@craftrpgs/cli 0.2.0 → 0.2.1

package/dist/bin.js

@@ -17851,6 +17851,9 @@ function contentTypeForContentExtension(extension) {
 // ../shared/src/constants/gm-engine.ts
 var GM_ENGINES = ["v1", "v2"];
 
+// ../shared/src/game-time.ts
+var TIME_TRACKER_KEY = "time";
+
 // ../shared/src/platform-instructions.ts
 var PLATFORM_INSTRUCTIONS = [
   {
@@ -17875,20 +17878,22 @@ var PLATFORM_INSTRUCTIONS = [
   },
   {
     id: "places-not-squares",
-    revision: 2,
+    revision: 3,
     instruction: {
       name: "Places, not squares",
-      when: "always",
+      when: "situational",
+      trigger: "When someone moves within the scene, or a fight is on",
       section: "Narration",
       body: `Never write grid squares or coordinates in the story ("moves to G5", "the goblin at I14"): they are for the current state and your tool calls, and the map shows where everyone stands. Say where someone goes by what is there and how far: "walks over to the well", "ducks behind the overturned cart", "closes to within a sword's reach of the bandit".`
     }
   },
   {
     id: "travel-times",
-    revision: 1,
+    revision: 2,
     instruction: {
       name: "Journeys, not timetables",
-      when: "always",
+      when: "situational",
+      trigger: "When the party travels somewhere, or the player asks how far or how long a way is",
       section: "Narration",
       body: `research() gives exact distances and travel times ("about 2.8 km north, ~35 min on foot"). They keep the world consistent and belong in your tool calls (how much time passes), not recited in the story: "You walk 35 minutes to the butcher's shop" reads like a timetable. Tell the way as the character lives it: "a short walk across the market square", "the sun is well up by the time you reach the butcher's", "half a day's ride along the coast road". Give a figure only when it matters to the moment (a deadline, a chase, a choice between routes) or the player asks, and then say it the way a person would: "a good half hour", "a couple of miles".`
     }
@@ -17932,12 +17937,12 @@ var PLATFORM_INSTRUCTIONS = [
   },
   {
     id: "objectives-tracker",
-    revision: 3,
+    revision: 4,
     instruction: {
       name: "Objectives",
       when: "always",
       section: "Rules",
-      body: `The party's objectives are one list for the whole game: what they are working toward beyond this scene. Add one when the story gives the party one (an order, a job or request taken on, a goal of their own that outlasts the scene), worded as the party knows it then, short, one goal to an objective: "Objectives": "Add: Find who opened the lid". Mark it done or failed when the story settles it: "Objectives": "Find who opened the lid: done". Never write a quest's later steps ahead of the story: they come as objectives of their own. One that runs over time (keep watch, log every contact) is done only when its end comes.`,
+      body: `The party's objectives are one list for the whole game: what they are working toward beyond this scene. Add one when the story gives the party one (an order, a job or request taken on, a goal of their own that outlasts the scene), worded as the party knows it then, short, one step to an objective: "Objectives": "Add: Find who opened the lid". A job with several steps they already know (go somewhere, learn something, report back) is one objective per step, in order, never one line joined with "and" or "then", so each is marked done when it happens: "Objectives": "Add: Get into the harbourmaster's office tonight", "Objectives": "Add: Find who signed the berth order", "Objectives": "Add: Tell Captain Vey whose name is on it". Mark one done or failed when the story settles it: "Objectives": "Find who opened the lid: done". Steps they do not know yet are never written ahead of the story: they come as objectives of their own when the story gives them. One that runs over time (keep watch, log every contact) is done only when its end comes.`,
       tracker: {
         key: "objectives",
         start: {
@@ -17951,7 +17956,7 @@ var PLATFORM_INSTRUCTIONS = [
           question: "In `earlier`, `player_turn` or `narration`, has the party been given an objective, something they are now working toward beyond this scene, that {tracker} does not hold under any wording?",
           yes: 'Yes: an order or an assignment handed to them (they act on it or do not refuse it), a request or a job they take on, or a goal they set themselves that will outlast this scene ("Find what woke the Sleeper", "Get the ledger to the Abbot", "Learn who signed the panel"), and nothing in {tracker} says it.',
           no: "No: {tracker} already holds it, however worded; or it is only floated, refused or still being weighed; or it is only what this scene is for, the next move (go to the archives, ask the clerk, cross the yard), or something done in the same moment.",
-          remind: `the story gave the party an objective the current state's Objectives list does not hold (add it as the party knows it now, short, one goal to an objective: "Objectives": "Add: <the objective>")`
+          remind: `the story gave the party an objective the current state's Objectives list does not hold (add it as the party knows it now, short, one step to an objective: "Objectives": "Add: <the objective>")`
         }
       }
     }
@@ -18071,6 +18076,97 @@ var PLATFORM_INSTRUCTIONS = [
       section: "World",
       body: "When research() finds nothing concrete, decide it yourself: how people speak and react from who their files say they are; a small detail a game master decides (a price, a name, what a shop sells) you decide and say, with an update() when it is a value a file keeps (a shop's prices, an innkeeper's name). Only lore, rules and history stay vague. When a place or person the player names has no file, take the nearest real one and play there. When research() says no file is called a name, nobody by that name is in this world: no character speaks of them as someone they know. Take the near match it offers when the player plainly means it, else let the story show nobody knows the name."
     }
+  },
+  {
+    id: "travel-procedure",
+    revision: 1,
+    instruction: {
+      name: "Travel",
+      when: "procedure",
+      trigger: "When the party goes to another place, sets out on a journey, or boards or leaves a ride (a ship, a caravan)",
+      pruning: "after-use",
+      section: "World",
+      body: `Going to another place is a "scene" change naming everyone who goes and where, in words that find the place without your narration. Anyone not named stays behind.
+- The place exactly as the current state or research() names it: "Move Character A and Character B to Place A", never "to the inn" or "back home".
+- A part of a place by the part and the place ("… to the north gate of Place A", "… to the cellar of Place A"), and the way in when the story gives one ("… into Place A through the kitchen door").
+- When the story stops at one of the places inside a region or a city, name that place. Somewhere the world has no place for (a camp, a clearing, a stretch of road) is said by what is there and where it lies from a place the current state or research() names ("… to a sheltered hollow a mile north of Place A", "… to the alley behind Place A"), never only the region or the city, and the current state makes it.
+
+A place's own map is ground for a scene whatever its size, a district's or a city's too: the party stands and moves on it, and stepping out of a place inside it (out of a tavern into its district) is a move onto that map beside the place they left, never a new place. Only a place with no map of its own, shown on a city's or a region's map, is not ground for a scene: when the story stops somewhere in one (a camp, a clearing, a stretch of road, a gate, a shop), that spot is a place of its own, and the current state makes it and draws its map when you move the party there.
+
+A journey the story plays out before they get there starts as "Character A and Character B set out for Place A by the river road; it takes about an hour" and ends as "Move Character A and Character B to Place A", and nothing in between. Setting out, the update() result tells the same.
+
+A place the current state says the party rides (its "ride": a ship, a caravan, an airship) carries them with the current state aboard it: "Ship A sails for Place A with Character A and Character B aboard; it takes about two days" sets out, "Ship A reaches Place A" gets there, and leaving it is a move off it: "Move Character A and Character B off Ship A onto the docks of Place A". Going below deck or to the bow is a move within it, never a voyage.
+
+Before you narrate the way somewhere or the arrival, or what lies further on, ask research() what the maps say ("What is Place A, and how far is it from here?", "What lies 15 minutes east of here?", "What is further along the path?"): it gives the way and how long it takes, the places inside and around, and where the party comes in. A travel time the files give wins over the map's. What the maps say is what the party knows of the land, never something they read: no one in the story looks at a map unless they hold one. Tell the way as the character lives it ("a short walk across the market square", "half a day's ride along the coast road"), not as research()'s figures.
+
+Someone who goes off without the party is their own change, "Leaves the scene"; where they went belongs in whatHappened, never in the instruction ("Leaves for the next village").`
+    }
+  },
+  {
+    id: "fight-procedure",
+    revision: 1,
+    instruction: {
+      name: "Running a fight",
+      when: "procedure",
+      trigger: "When a fight starts, and on its turns while it runs",
+      pruning: "on-compaction",
+      section: "Rules",
+      body: `A fight runs on its turn order, a tracker in the current state. Start it as the fight starts, as the turn order's line under "Trackers this game keeps" says ("scene": "Start a turn order, Combat at Place A: Character A 18, Lookout 1 15, Character B 12"). An initiative roll (one whose reason says initiative) puts whoever rolled it in the turn order at its total, so the order needs no change for it. As each turn ends, record whose it is now ("Combat": "Lookout 1's turn") and each new round ("Combat": "New round") in the update() with what the turn did.
+
+Sides. When the fight starts, give each NPC in it a side if theirs is not set: the current state marks everyone as the player's character or an NPC with a side. A side is always the one they are now, ally, neutral or enemy ("Character C": "Is now an enemy", "Character D": "Is now an ally"), never only what they stopped being ("Is no longer an enemy"). Hostile arrivals say so ("Add three hostile extras, Bandit 1 to Bandit 3 …").
+
+Turns. Every NPC's turn is yours to play, an ally's too (a companion travelling with the party): their move, their roll, what it did, then on to the next. Stop for the player only on the player's character's turn. Tell each turn a moment at a time: its words, its roll, then the update() of what it did, before the next turn's words.
+
+Reach. On a battle map with a grid, when the turn order moves to someone, or someone in it moves, the update() result gives how far everyone is from them and who is within reach ("From Lookout 1 (J9, speed 30 ft): Character A 15 ft south … Within reach (5 ft): nobody"). A melee attack needs its target within reach, so close the distance first, as a move.
+
+Stats on the map. Tokens move, hits and heals float over them and the downed are marked, in the order your update() changes give them. You choose which stats show under every token, for this scene: a bar (hit points, stress), a number (armour class), pips (spell slots, uses) or tags (conditions). Turn one on with a "scene" change when it matters, usually as the fight starts ("Show hit points on the map as a bar, hidden for enemies"); change it ("Show HP from hp and maxHp", "Show enemies' HP too"); turn it off when it no longer matters ("Stop showing HP on the map"). The current state's "shown_on_tokens" says what is shown. An extra shows the stat from its detail by that label ("HP": "6/10"), so give extras in the fight that detail. Anyone without the stat shows nothing.
+
+Going down, in one word, once it has happened: "Falls unconscious", "Is dead", "Surrenders", "Gets back up"; never "falls unconscious if …": work it out from the numbers first. The downed stay in the current state; only someone who is gone (fled, carried off) leaves it.
+
+Table talk. Talk at the table as a game master running a fight would, as much as the moment needs: hand the turn over ("Character B's up.", "Character A, it's your turn. What do you do?"), say how a roll went and what it did ("Seventeen: that hits, for seven damage."), give the logistics a choice turns on (who is in reach, how far, who is flanked, what a move would provoke), and say how hurt someone looks ("he's barely standing") rather than their hit points left. That is table talk; your own bookkeeping stays unsaid. Never write grid squares in the story ("the goblin at I14"): say where someone is by what is there and how far ("behind the overturned cart").`
+    }
+  },
+  {
+    id: "trackers-procedure",
+    revision: 1,
+    instruction: {
+      name: "Trackers",
+      when: "procedure",
+      trigger: "When you start, set up or end a tracker (a turn order, a clock, a plan's steps), or need one's value as it stands now",
+      pruning: "after-use",
+      section: "Rules",
+      body: `A tracker keeps what the scene is counting that is no value in a file: a fight's turn order, a clock that fills toward trouble, the steps of a plan, a record for each suspect or companion, and the like. What belongs to someone for good (hit points, gold, an item, a lasting stat) stays in their file, never in a tracker. Where and how a tracker shows on screen is decided for you.
+
+Starting one. Start one when the story begins counting something the player should follow (a fight starts: its turn order; a threat that grows with each noise or minute: a clock), with a "scene" change that names it and says what it counts in plain words, and the current state builds it: "Start a turn order, Fight at the mill: Character A 18, Lookout 1 15, Character B 12", "Start a hidden 6-step clock, The watch arrives. At 6: crossbowmen at the gate", "Start a tracker, The heist plan: case the vault, bribe the night guard, crack the safe" (a plan the party made, every step known), "Start a tracker for the whole game, Suspects: a record for each of Character B and Lookout 1, suspicion 0 of 5 and their alibi". A tracker the game keeps needs no start: a change with its name as the subject starts it the first time, as its line under "Trackers this game keeps" says.
+
+How long it lasts. A turn order, a clock or a count ends when the party leaves the place unless you say "for the whole game"; a list of steps (a plan, a ritual) lasts the game unless you say it ends here.
+
+Stats. A tracker can show any stat from the sheets of the people it names (HP, Mana, Stamina) and where each stands, read live and never copied in: "Start a turn order, Fight at the mill: Character A 18, Lookout 1 15, showing HP, Mana and where each stands", "Fight at the mill": "Show HP, Mana and Stamina", "Suspects": "Show each suspect's HP too". That is the tracker's own; the stats under the tokens are the map's.
+
+Hidden. One marked hidden is yours alone, for pressure the party cannot see yet; reveal it when they would know.
+
+Changing it. Keep it in step with the story in the same update() as the rest of what happened, with its name as the subject: "Fight at the mill": "Lookout 1's turn" (whose turn it is now), "Fight at the mill": "New round", "The watch arrives": "+1", "The watch arrives": "Fill it" (its trouble came before it filled), "The heist plan": "Bribe the night guard: done", "Suspects": "Character B: Suspicion +1", "The watch arrives": "At 4: the gate bell rings" (what reaching a value brings). A step the story completes is done; the hours or days that pass move a countdown of them, once: recording that time again later in the reply moves nothing; a clock whose trouble the story brings is filled, never left short of it.
+
+As it stands now. The <current-state> block that opens your context is the current state as it stood then, and a tracker's changes since are in the update() results: when you need one as it stands now (before you narrate from its value or change it by an amount that depends on it, or once the story has moved it several times), ask research() for it by its name, "Tracker: The watch arrives", in the same research() as the turn's other questions.
+
+Ending it. End it when it stops mattering (the fight is over, the clock filled and its trouble came): "Fight at the mill": "End".`
+    }
+  },
+  {
+    id: "hidden-things-procedure",
+    revision: 1,
+    instruction: {
+      name: "Hidden things",
+      when: "procedure",
+      trigger: "When someone or something is hidden from the party (an ambush, a stalker, a disguise), or is revealed",
+      pruning: "after-use",
+      section: "Rules",
+      body: `What the party has not seen yet is still in the current state. When it matters (the party hears, smells or spots a sign of it, or it lies in wait), add it as what it is, marked hidden, where it is (on a grid, its square), with what the party perceives of it: "Add a hostile Black Bear at J9, hidden; the party hears only slow, heavy breathing", "Add Character B at the gate, disguised as a hooded pilgrim". A sound, a smell or tracks are never a token.
+
+When the party sees it for what it is, say so ("Black Bear 1": "Is revealed"); an extra that turns out to be one of a kind becomes one ("scene": "The slow, heavy breathing is revealed as a Black Bear"). A note only you keep: ("Black Bear 1": "GM note: asleep; wakes at any loud noise").
+
+The current state shows you who everyone really is and the player's screen only what the party knows: narrate only what the party perceives ("a rustle beneath the thicket"), never the name or kind of what is hidden, until it is revealed.`
+    }
   }
 ];
 var RESPONSE_LENGTH = "Response length";
@@ -18236,9 +18332,6 @@ function sameJson(a, b) {
   return JSON.stringify(sortedKeys(a)) === JSON.stringify(sortedKeys(b));
 }
 
-// ../shared/src/game-time.ts
-var TIME_TRACKER_KEY = "time";
-
 // ../shared/src/trackers.ts
 var TRACKER_TONES = ["good", "bad"];
 var TRACKER_ITEM_STATES = ["open", "done", "failed"];
@@ -18564,6 +18657,8 @@ function trackerDefinitionProblem(definition) {
 var GAME_OPTION_INSTRUCTION_NAME_MAX_LENGTH = 120;
 var GAME_OPTION_INSTRUCTION_BODY_MAX_LENGTH = 2000;
 var GAME_OPTION_SITUATIONAL_BODY_MAX_LENGTH = 1000;
+var GAME_OPTION_PROCEDURE_BODY_MAX_LENGTH = 1e4;
+var GAME_OPTION_STORED_BODY_MAX_LENGTH = 12000;
 var GAME_OPTION_LABEL_MAX_LENGTH = 60;
 var GAME_OPTION_DESCRIPTION_MAX_LENGTH = 200;
 var GAME_OPTION_KEY_MAX_LENGTH = 60;
@@ -18573,16 +18668,26 @@ var GAME_OPTION_MAX_CHOICES = 8;
 var GAME_OPTIONS_MAX_INSTRUCTIONS = 200;
 var GAME_OPTIONS_MAX_ALWAYS_LENGTH = 1e4;
 var GAME_OPTIONS_MAX_SITUATIONAL = 100;
-var GAME_OPTION_INSTRUCTION_WHEN = ["always", "situational"];
+var GAME_OPTIONS_MAX_PROCEDURES = 25;
+var GAME_OPTION_INSTRUCTION_WHEN = [
+  "always",
+  "situational",
+  "procedure"
+];
+var GAME_OPTION_PROCEDURE_PRUNING = [
+  "after-use",
+  "on-compaction"
+];
 var GAME_OPTION_KINDS = ["one", "several", "toggle"];
 var keySchema = string2().trim().min(1).max(GAME_OPTION_KEY_MAX_LENGTH).regex(/^[a-z0-9][a-z0-9-]*$/, "Keys are lowercase letters, digits and -");
 var GAME_OPTION_SECTION_MAX_LENGTH = 40;
 var GAME_OPTIONS_MAX_SECTIONS = 30;
 var gameOptionInstructionSchema = object({
   name: string2().trim().max(GAME_OPTION_INSTRUCTION_NAME_MAX_LENGTH).optional(),
-  body: string2().trim().min(1).max(GAME_OPTION_INSTRUCTION_BODY_MAX_LENGTH),
+  body: string2().trim().min(1).max(GAME_OPTION_STORED_BODY_MAX_LENGTH),
   when: _enum(GAME_OPTION_INSTRUCTION_WHEN),
   trigger: string2().trim().max(GAME_OPTION_INSTRUCTION_NAME_MAX_LENGTH).optional(),
+  pruning: _enum(GAME_OPTION_PROCEDURE_PRUNING).optional(),
   section: string2().trim().max(GAME_OPTION_SECTION_MAX_LENGTH).optional(),
   tracker: trackerDefinitionSchema.optional(),
   platform: string2().max(GAME_OPTION_KEY_MAX_LENGTH).optional()
@@ -18655,7 +18760,28 @@ function sectionsOf(options) {
   ].map((name) => name.trim()).filter(Boolean);
   return [...new Set(names)];
 }
-function instructionProblem(instruction, base) {
+function instructionBodyMax(instruction) {
+  if (instruction.when === "procedure") {
+    return GAME_OPTION_PROCEDURE_BODY_MAX_LENGTH;
+  }
+  return instruction.when === "situational" && !instruction.tracker ? GAME_OPTION_SITUATIONAL_BODY_MAX_LENGTH : GAME_OPTION_INSTRUCTION_BODY_MAX_LENGTH;
+}
+function bodyLengthProblem(instruction) {
+  const max = instructionBodyMax(instruction);
+  const has = instruction.body.length;
+  if (has <= max) {
+    return null;
+  }
+  if (instruction.when === "procedure") {
+    return `it is a procedure, so its text is at most ${max} characters (it has ${has}). Trim it, or split it into procedures for its parts.`;
+  }
+  if (instruction.when === "situational" && !instruction.tracker) {
+    return `it is situational, so its text is at most ${max} characters (it has ${has}). Trim it, or make it a procedure: a procedure holds up to ${GAME_OPTION_PROCEDURE_BODY_MAX_LENGTH} characters, read whole when its moment comes.`;
+  }
+  const kind = instruction.tracker ? "a tracker's rules" : "always on";
+  return `it is ${kind}, so its text is at most ${max} characters (it has ${has}). Trim it, or make the part for one moment situational or a procedure.`;
+}
+function instructionProblem(instruction, base, bodyLengths) {
   if (instruction.tracker) {
     const problem = trackerDefinitionProblem(instruction.tracker);
     if (problem) {
@@ -18668,25 +18794,45 @@ function instructionProblem(instruction, base) {
   if (base && instruction.when === "always" && !instruction.name?.trim()) {
     return "an always instruction needs a title.";
   }
-  if (instruction.when === "situational" && instruction.body.length > GAME_OPTION_SITUATIONAL_BODY_MAX_LENGTH) {
-    return `"${instruction.name?.trim() || instructionTrigger(instruction)}" is situational, so its text is at most ${GAME_OPTION_SITUATIONAL_BODY_MAX_LENGTH} characters (it has ${instruction.body.length}). Split it or trim it.`;
+  if (instruction.when === "procedure") {
+    if (instruction.tracker) {
+      return `"${instruction.name?.trim() || instructionTrigger(instruction)}" is a procedure, which can't define a tracker: make the tracker its own instruction.`;
+    }
+    if (!instruction.trigger?.trim()) {
+      return "a procedure needs to say when to use it.";
+    }
+    if (base && !instruction.name?.trim()) {
+      return "a procedure needs a title.";
+    }
+  }
+  const long = bodyLengthProblem(instruction);
+  if (bodyLengths && long) {
+    return `"${instruction.name?.trim() || instructionTrigger(instruction)}": ${long}`;
   }
   return null;
 }
-function gameOptionsProblem(options) {
-  const baseProblem = options.instructions.map((instruction) => instructionProblem(instruction, true)).find(Boolean);
+function gameOptionsProblem(options, { bodyLengths = true } = {}) {
+  const baseProblem = options.instructions.map((instruction) => instructionProblem(instruction, true, bodyLengths)).find(Boolean);
   if (baseProblem) {
     return `In the base instructions, ${baseProblem}`;
   }
   for (const option of options.options) {
     for (const choice of option.choices) {
-      const problem = choice.instructions.map((instruction) => instructionProblem(instruction, false)).find(Boolean);
+      const problem = choice.instructions.map((instruction) => instructionProblem(instruction, false, bodyLengths)).find(Boolean);
       if (problem) {
         return `In "${option.label} · ${choice.label}", ${problem}`;
       }
     }
   }
-  return trackerKeysProblem(options) ?? gameOptionsStructureProblem(options) ?? gameOptionsLimitProblem(options);
+  return craftTimeProblem(options) ?? trackerKeysProblem(options) ?? gameOptionsStructureProblem(options) ?? gameOptionsLimitProblem(options);
+}
+var TIME_TRACKER_ID = "time-tracker";
+function craftTimeProblem(options) {
+  const time = options.instructions.find((instruction) => instruction.platform === TIME_TRACKER_ID);
+  if (!time || time.tracker?.key === TIME_TRACKER_KEY) {
+    return null;
+  }
+  return `Craft's Time tracker ("${time.name}") must keep its tracker with the key "${TIME_TRACKER_KEY}": code moves the clock by that key. Reword its name, rules and trigger, or turn it off.`;
 }
 function trackerKeysProblem(options) {
   const lists = [
@@ -18754,14 +18900,67 @@ function gameOptionsLimitProblem(options) {
   if (situational > GAME_OPTIONS_MAX_SITUATIONAL) {
     return `One game can have up to ${situational} situational instructions; the limit is ${GAME_OPTIONS_MAX_SITUATIONAL}.`;
   }
+  const procedures = worstCaseProcedureCount(options);
+  if (procedures > GAME_OPTIONS_MAX_PROCEDURES) {
+    return `One game can have up to ${procedures} procedures; the limit is ${GAME_OPTIONS_MAX_PROCEDURES}, Craft's included. Merge some, or make the short ones situational.`;
+  }
   return null;
 }
 var gameOptionsSchema = storedGameOptionsShape.superRefine((options, ctx) => {
-  const problem = gameOptionsProblem(withPlatform(options));
+  for (const { path, instruction } of storedInstructions(options)) {
+    const long = bodyLengthProblem(instruction);
+    if (long) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "body"],
+        message: long
+      });
+    }
+  }
+  const problem = gameOptionsProblem(withPlatform(options), {
+    bodyLengths: false
+  });
   if (problem) {
     ctx.addIssue({ code: "custom", message: problem });
   }
 });
+function storedInstructions(options) {
+  const found = [];
+  const choicesOf = (path, choices) => {
+    choices.forEach((choice, c) => {
+      choice.instructions.forEach((instruction, i) => {
+        found.push({
+          path: [...path, "choices", c, "instructions", i],
+          instruction
+        });
+      });
+    });
+  };
+  options.instructions.forEach((instruction, i) => {
+    if ("body" in instruction) {
+      found.push({ path: ["instructions", i], instruction });
+    }
+  });
+  options.options.forEach((option, o) => {
+    if ("choices" in option) {
+      choicesOf(["options", o], option.choices);
+    }
+  });
+  for (const [id, override] of Object.entries(options.platform?.instructions ?? {})) {
+    if ("body" in override) {
+      found.push({
+        path: ["platform", "instructions", id],
+        instruction: override
+      });
+    }
+  }
+  for (const [key, override] of Object.entries(options.platform?.options ?? {})) {
+    if ("choices" in override) {
+      choicesOf(["platform", "options", key], override.choices);
+    }
+  }
+  return found;
+}
 var storedGameOptionsSchema = storedGameOptionsShape.superRefine((options, ctx) => {
   const problem = gameOptionsStructureProblem(withPlatform(options));
   if (problem) {
@@ -19058,6 +19257,12 @@ function worstCaseAlwaysLength(options) {
 function worstCaseSituationalCount(options) {
   return worstCase(options, situationalCount);
 }
+function procedureCount(instructions, _place) {
+  return instructions.filter((instruction) => instruction.when === "procedure").length;
+}
+function worstCaseProcedureCount(options) {
+  return worstCase(options, procedureCount);
+}
 
 // ../shared/src/gm-tool-settings.ts
 var gmToolSettingsInputSchema = object({
@@ -37411,7 +37616,7 @@ async function refreshWorkspaceScriptTypes({
 // package.json
 var package_default = {
   name: "@craftrpgs/cli",
-  version: "0.2.0",
+  version: "0.2.1",
   description: "Sync Craft projects with a local folder — clone, edit with any coding agent, push back.",
   license: "UNLICENSED",
   homepage: "https://craftrpgs.com",
@@ -46122,10 +46327,53 @@ var sceneHeadingProps = object({
 });
 
 // ../shared/src/gm-narration/clean-narration-text.ts
-var POSTPROCESSING_MARKER_RE = /(?:\n?---[ \t]*\n)?\s*\**-*\s*STARTING POSTPROCESSING[^\n]*/g;
+var POSTPROCESSING_MARKER = "STARTING POSTPROCESSING";
+var WHITESPACE_CHAR_RE = /\s/;
+var DIVIDER_LINE_END_RE = /[ \t]*\n/y;
 var TRANSLATED_POSTPROCESSING_MARKER_RE = /(?:\n?---[ \t]*\r?\n)?^[ \t]*(?:`{3,}[ \t]*)?\\?(?:-{3,}|\*{2})[ \t]*(?:正在)?(?:开始后处理|開始後處理)[ \t]*(?:-{3,}|\*{2})?[ \t]*\r?$/gm;
+function isWhitespaceAt(text, index) {
+  const char = text[index];
+  return char !== undefined && WHITESPACE_CHAR_RE.test(char);
+}
+function markerPrefixStart(text, floor, markerAt) {
+  let start = markerAt;
+  while (start > floor && isWhitespaceAt(text, start - 1)) {
+    start--;
+  }
+  while (start > floor && text[start - 1] === "-") {
+    start--;
+  }
+  while (start > floor && text[start - 1] === "*") {
+    start--;
+  }
+  while (start > floor && isWhitespaceAt(text, start - 1)) {
+    start--;
+  }
+  if (start - 3 >= floor && text.startsWith("---", start - 3)) {
+    DIVIDER_LINE_END_RE.lastIndex = start;
+    if (DIVIDER_LINE_END_RE.test(text)) {
+      start -= 3;
+      if (start > floor && text[start - 1] === `
+`) {
+        start--;
+      }
+    }
+  }
+  return start;
+}
 function stripGmPostprocessingMarkers(text) {
-  return text.replace(POSTPROCESSING_MARKER_RE, "").replace(TRANSLATED_POSTPROCESSING_MARKER_RE, "");
+  let stripped = "";
+  let keepFrom = 0;
+  let markerAt = text.indexOf(POSTPROCESSING_MARKER);
+  while (markerAt >= 0) {
+    stripped += text.slice(keepFrom, markerPrefixStart(text, keepFrom, markerAt));
+    const lineEnd = text.indexOf(`
+`, markerAt + POSTPROCESSING_MARKER.length);
+    keepFrom = lineEnd < 0 ? text.length : lineEnd;
+    markerAt = text.indexOf(POSTPROCESSING_MARKER, keepFrom);
+  }
+  stripped += text.slice(keepFrom);
+  return stripped.replace(TRANSLATED_POSTPROCESSING_MARKER_RE, "");
 }
 
 // ../shared/src/tts/text.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftrpgs/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Sync Craft projects with a local folder — clone, edit with any coding agent, push back.",
   "license": "UNLICENSED",
   "homepage": "https://craftrpgs.com",