Como criar um módulo de ferramentas de token

tokens-workshop/
  manifest.json
  main.mjs
  recipes.mjs
  styles.css
  LICENSE.txt

python -m json.tool manifest.json
python -m zipfile -c ../tokens-workshop-1.0.0.zip manifest.json main.mjs recipes.mjs styles.css LICENSE.txt
python -m zipfile -l ../tokens-workshop-1.0.0.zip

async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    return {actors:await api.actors.list({},read),tokens:await api.tokens.list({mapId:v.mapId},read)};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.actors.get(v.actorId,{},read);
    const created=await api.tokens.place({mapId:v.mapId,actorId:v.actorId,gridX:v.x,gridY:v.y},write());
    return {createdIds:created.createdIds,tokens:created.tokens};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!token.canControl||token.locked) throw new Error('Choose a controlled unlocked token');
    return await api.tokens.move({mapId:v.mapId,id:token.id,expectedVersion:token.version,gridX:v.x,gridY:v.y,path:[]},write());
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    const result=await api.tokens.duplicate({mapId:v.mapId,tokenIds:[v.id]},write());
    return {createdIds:result.createdIds,tokens:result.tokens};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.configure({mapId:v.mapId,tokenIds:[token.id],expectedVersion:token.version,values:{rotation:v.rotation,elevation:v.elevation,disposition:v.disposition,locked:v.locked}},write());
    return await api.tokens.get(token.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.setVision({mapId:v.mapId,tokenIds:[v.id],enabled:v.enabled,range:v.range},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.setHidden({mapId:v.mapId,tokenIds:[v.id],hidden:v.hidden},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!['everyone','gm'].includes(v.visibility)) throw new Error('Use everyone or gm');
    if(!Number.isInteger(v.rounds)||v.rounds<1) throw new Error('Use a positive integer duration');
    if(v.visibility==='gm'&&context.role!=='gm') throw new Error('GM required for hidden conditions');
    await api.tokens.addCondition({mapId:v.mapId,tokenIds:[v.id],label:v.label,description:'Original tutorial marker with no RPG rules.',kind:'positive',visibility:v.visibility,duration:{type:'rounds',value:v.rounds,expires:'end'}},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!token.conditions.some(item=>item.condition_id===v.conditionId)) throw new Error('Choose a visible condition from this token');
    await api.tokens.removeCondition({mapId:v.mapId,tokenIds:[v.id],conditionId:v.conditionId},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    if(!v.confirm) throw new Error('Confirm the disposable token');
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.remove({mapId:v.mapId,tokenIds:[v.id]},write());
    return await api.tokens.list({mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}

{
  "id": "tutorial.tokens-workshop",
  "name": "Token workshop",
  "version": "1.0.0",
  "sdk": {
    "requires": ">=1.0.0 <2.0.0",
    "tested": "1.0.0"
  },
  "entry": "main.mjs",
  "description": "Place, move, duplicate, configure and remove tokens; control native vision/visibility and timed conditions.",
  "author": "Gravewright documentation",
  "license": "MIT"
}

import {recipes} from './recipes.mjs';
export default {
  start({styles}) { styles.use('styles.css'); },
  register({register}) {
    register("table.interface", ({root,api,host,assets,storage,context,events,viewport,signal,onDispose}) => {
      const doc=root.ownerDocument;
      const button=doc.createElement('button');
      button.type='button';button.className='tutorial-launcher';
      button.textContent="Token workshop";
      root.append(button);
      for(const type of ['pointerdown','mousedown'])button.addEventListener(type,event=>event.stopPropagation(),{signal});
      let modal,pending=false;
      button.addEventListener('click',event=>{
        event.stopPropagation();
        if(modal?.isConnected) { modal.focus();return; }
        const panel=doc.createElement('section');
        panel.className="tutorial-workbench-tokens-workshop";
        panel.setAttribute('role','dialog');panel.setAttribute('aria-modal','true');
        panel.setAttribute('aria-label',button.textContent);panel.tabIndex=-1;
        const title=doc.createElement('h2');title.textContent=button.textContent;panel.append(title);
        const choose=doc.createElement('select');choose.setAttribute('aria-label','Action');
        for(const recipe of recipes) {
          const option=doc.createElement('option');option.value=recipe.id;option.textContent=recipe.label;choose.append(option);
        }
        const form=doc.createElement('form'),fields=doc.createElement('div');
        const description=doc.createElement('p');
        const run=doc.createElement('button');run.type='submit';run.textContent='Run action';
        const close=doc.createElement('button');close.type='button';close.textContent='Close';
        const output=doc.createElement('pre');output.setAttribute('role','status');output.setAttribute('aria-live','polite');
        form.append(description,fields,run,close,output);panel.append(choose,form);
        function renderFields(){
          const recipe=recipes.find(item=>item.id===choose.value);fields.replaceChildren();
          description.textContent=recipe.description;
          for(const field of recipe.fields||[]) {
            const label=doc.createElement('label');label.textContent=field.label;
            const input=doc.createElement('input');input.name=field.name;input.type=field.type||'text';
            if(field.type==='number')input.step=String(field.step??'any');
            if(field.type==='checkbox')input.checked=!!field.value;
            else if(field.type!=='file')input.value=String(field.value??'');
            input.required=!!field.required;
            if(field.accept)input.accept=field.accept;
            label.append(input);fields.append(label);
          }
          output.textContent='';
        }
        choose.addEventListener('change',renderFields,{signal});renderFields();
        form.addEventListener('submit',async event=>{
          event.preventDefault();if(pending)return;
          const recipe=recipes.find(item=>item.id===choose.value),values={};
          for(const input of fields.querySelectorAll('input')) {
            values[input.name]=input.type==='file'?input.files[0]:input.type==='checkbox'?input.checked:input.type==='number'?Number(input.value):input.value;
          }
          pending=true;choose.disabled=true;run.disabled=true;close.disabled=true;
          for(const input of fields.querySelectorAll('input'))input.disabled=true;
          output.textContent='Running…';
          try {
            const value=await recipe.run({api,host,assets,storage,context,events,viewport,signal,onDispose},values);
            if(!signal.aborted)output.textContent=typeof value==='string'?value:JSON.stringify(value??null,null,2);
          } catch(error) {
            if(!signal.aborted)output.textContent=String(error.code||error.message||'unavailable');
          } finally {
            pending=false;
            if(!signal.aborted){choose.disabled=false;run.disabled=false;close.disabled=false;for(const input of fields.querySelectorAll('input'))input.disabled=false;}
          }
        },{signal});
        close.addEventListener('click',()=>void modal.close(),{signal});
        modal=api.ui.openModal(panel,{canClose:()=>!pending||signal.aborted});
      },{signal});
      onDispose(()=>{button.remove();if(modal)void modal.close();});
    });
  },
  stop() {}
};

export const recipes=[
{
  id:"inspect",
  label:"Inspect available actors and scene tokens",
  description:"Paste the test Scene ID from the maps tutorial. Copy a readable actor ID for Place, then a token ID for later actions.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    return {actors:await api.actors.list({},read),tokens:await api.tokens.list({mapId:v.mapId},read)};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"place",
  label:"Place an actor token in the test scene",
  description:"Create an original disposable actor using the native/system sheet first. Coordinates use cell-space gridX/gridY for token placement, not scene pixels. The host validates bounds and token size.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "actorId",
    "label": "Actor ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "x",
    "label": "Grid x",
    "value": 2,
    "type": "number",
    "required": true
  },
  {
    "name": "y",
    "label": "Grid y",
    "value": 2,
    "type": "number",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.actors.get(v.actorId,{},read);
    const created=await api.tokens.place({mapId:v.mapId,actorId:v.actorId,gridX:v.x,gridY:v.y},write());
    return {createdIds:created.createdIds,tokens:created.tokens};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"move",
  label:"Move a controlled unlocked token",
  description:"Enter the token ID and a nearby destination. path:[] requests the direct segment; intermediate waypoints must use the same grid coordinates. Player movement still checks walls and ownership.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "x",
    "label": "Destination grid x",
    "value": 3,
    "type": "number",
    "required": true
  },
  {
    "name": "y",
    "label": "Destination grid y",
    "value": 2,
    "type": "number",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!token.canControl||token.locked) throw new Error('Choose a controlled unlocked token');
    return await api.tokens.move({mapId:v.mapId,id:token.id,expectedVersion:token.version,gridX:v.x,gridY:v.y,path:[]},write());
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"duplicate",
  label:"Duplicate one tutorial token",
  description:"Use the token placed above. The native service creates an independent snapshot and chooses its bounded offset.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    const result=await api.tokens.duplicate({mapId:v.mapId,tokenIds:[v.id]},write());
    return {createdIds:result.createdIds,tokens:result.tokens};
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"configure",
  label:"Configure rotation, elevation and disposition",
  description:"Configure a single disposable token. Keep locked false for the movement recipe. Elevation can affect region eligibility. A player may rotate a controlled token only with the rotation-only values variant; this multi-field recipe is GM-only.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "rotation",
    "label": "Rotation degrees",
    "value": 90,
    "type": "number",
    "required": true
  },
  {
    "name": "elevation",
    "label": "Elevation",
    "value": 0,
    "type": "number",
    "required": true
  },
  {
    "name": "disposition",
    "label": "friendly, neutral, hostile or unknown",
    "value": "friendly",
    "type": "text",
    "required": true
  },
  {
    "name": "locked",
    "label": "Lock token movement",
    "value": false,
    "type": "checkbox",
    "required": false
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.configure({mapId:v.mapId,tokenIds:[token.id],expectedVersion:token.version,values:{rotation:v.rotation,elevation:v.elevation,disposition:v.disposition,locked:v.locked}},write());
    return await api.tokens.get(token.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"vision",
  label:"Enable and configure token vision",
  description:"Use the placed token; range is a nonnegative cell distance. To observe line-of-sight, configure dynamic lighting in the native scene and use the token controlling player.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "enabled",
    "label": "Enable vision",
    "value": true,
    "type": "checkbox",
    "required": false
  },
  {
    "name": "range",
    "label": "Vision range in cells",
    "value": 6,
    "type": "number",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.setVision({mapId:v.mapId,tokenIds:[v.id],enabled:v.enabled,range:v.range},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"hidden",
  label:"Hide and show the tutorial token",
  description:"Run with Hidden selected, inspect the player account, then clear it and run again. This changes token visibility, not the actor permission map.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "hidden",
    "label": "Hide from players",
    "value": true,
    "type": "checkbox",
    "required": false
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.setHidden({mapId:v.mapId,tokenIds:[v.id],hidden:v.hidden},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"condition-add",
  label:"Add an original timed token condition",
  description:"Use an original label. This is a generic marker, not a bundled rule. Copy condition_id from the result for Remove condition. Duration advances through real forward combat events when the token participates.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "label",
    "label": "Condition label",
    "value": "Workshop focus",
    "type": "text",
    "required": true
  },
  {
    "name": "visibility",
    "label": "everyone or gm",
    "value": "everyone",
    "type": "text",
    "required": true
  },
  {
    "name": "rounds",
    "label": "Duration in rounds",
    "value": 2,
    "type": "number",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!['everyone','gm'].includes(v.visibility)) throw new Error('Use everyone or gm');
    if(!Number.isInteger(v.rounds)||v.rounds<1) throw new Error('Use a positive integer duration');
    if(v.visibility==='gm'&&context.role!=='gm') throw new Error('GM required for hidden conditions');
    await api.tokens.addCondition({mapId:v.mapId,tokenIds:[v.id],label:v.label,description:'Original tutorial marker with no RPG rules.',kind:'positive',visibility:v.visibility,duration:{type:'rounds',value:v.rounds,expires:'end'}},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"condition-remove",
  label:"Remove the chosen token condition",
  description:"Paste the exact condition_id, not its display label. Remove only the marker created in this tutorial.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "conditionId",
    "label": "condition_id from Inspect",
    "value": "",
    "type": "text",
    "required": true
  }
],
  run:async ({api,context,signal},v) => {

  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    const token=await api.tokens.get(v.id,{mapId:v.mapId},read);
    if(!token.conditions.some(item=>item.condition_id===v.conditionId)) throw new Error('Choose a visible condition from this token');
    await api.tokens.removeCondition({mapId:v.mapId,tokenIds:[v.id],conditionId:v.conditionId},write());
    return await api.tokens.get(v.id,{mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
},
{
  id:"remove",
  label:"Remove the disposable token",
  description:"Use only the tutorial token/duplicate. Run after combat cleanup. Removing a token does not delete its actor.",
  fields:[
  {
    "name": "mapId",
    "label": "Scene ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "id",
    "label": "Token ID",
    "value": "",
    "type": "text",
    "required": true
  },
  {
    "name": "confirm",
    "label": "I selected disposable tutorial data",
    "value": false,
    "type": "checkbox",
    "required": false
  }
],
  run:async ({api,context,signal},v) => {
  if(context.role!=='gm') throw new Error('GM required');
  const read={signal};
  const write=()=>{
    if(signal?.aborted) throw Object.assign(new Error('Mount closed'),{code:'cancelled'});
    return {signal,requestId:crypto.randomUUID()};
  };
  try {
    if(!v.confirm) throw new Error('Confirm the disposable token');
    await api.tokens.get(v.id,{mapId:v.mapId},read);
    await api.tokens.remove({mapId:v.mapId,tokenIds:[v.id]},write());
    return await api.tokens.list({mapId:v.mapId},read);
  } catch(problem) {
    if(problem.code==='conflict'&&!signal?.aborted) await api.tokens.state({mapId:v.mapId},read);
    throw problem;
  }
}
}
];

.gw-module-root[data-module-id="tutorial.tokens-workshop"] .tutorial-launcher { position: fixed; left: 16px; bottom: 112px; z-index: 10; padding: var(--space-3); border: 1px solid var(--border); border-radius: var(--radius-md); background: var(--surface); color: var(--text); font-size: 14px; pointer-events: auto; max-width: min(440px, calc(100vw - 32px)); white-space: normal; }
.tutorial-workbench-tokens-workshop { width: min(640px, calc(100vw - 48px)); padding: var(--space-5); font-size: 14px; }
.tutorial-workbench-tokens-workshop label { display: block; margin: var(--space-3) 0; }
.tutorial-workbench-tokens-workshop input, .tutorial-workbench-tokens-workshop select { display: block; width: 100%; margin-top: var(--space-2); }
.tutorial-workbench-tokens-workshop pre { max-height: 360px; max-width: 100%; overflow: auto; white-space: pre-wrap; overflow-wrap: anywhere; }
.tutorial-workbench-tokens-workshop button { margin-right: var(--space-3); }

MIT License

Copyright (c) 2026 Gravewright contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Estenda Token workshop no Gravewright0.3.0 para [tarefa]. Confira tokens/services.py e frontend.json. Separe células e pixels, use expectedVersion real para move/configure, preserve modos vinculado/snapshot e filtros de controle/trava/ocultação. Entregue código completo e testes concretos GM/jogador, parede, versão antiga e abort.