@craftrpgs/cli 0.2.0-alpha.1 → 0.2.0-alpha.2

package/dist/bin.js

@@ -26811,6 +26811,345 @@ function contentTypeForContentExtension(extension) {
 // ../shared/src/constants/gm-engine.ts
 var GM_ENGINES = ["v1", "v2"];
 
+// ../shared/src/board-time.ts
+var TIME_TRACKER_KEY = "time";
+
+// ../shared/src/same-json.ts
+function sortedKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortedKeys);
+  }
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return Object.fromEntries(Object.keys(record2).filter((key) => record2[key] !== undefined).sort().map((key) => [key, sortedKeys(record2[key])]));
+  }
+  return value;
+}
+function sameJson(a, b) {
+  return JSON.stringify(sortedKeys(a)) === JSON.stringify(sortedKeys(b));
+}
+
+// ../shared/src/board-trackers.ts
+var TRACKER_TONES = ["good", "bad"];
+var TRACKER_ITEM_STATES = ["open", "done", "failed"];
+var TRACKER_LASTS = ["here", "game", "always"];
+var COUNT_DISPLAYS = ["number", "bar", "pips"];
+var RECORDS_DISPLAYS = ["table", "roster"];
+var TRACKER_LIMITS = {
+  board: 10,
+  name: 60,
+  label: 40,
+  text: 160,
+  fields: 8,
+  items: 16,
+  entries: 20,
+  records: 12,
+  links: 12,
+  recordFields: 4,
+  show: 6,
+  types: 6,
+  sourceName: 80,
+  marks: 10,
+  pipsMax: 20,
+  clockMin: 2,
+  clockMax: 12,
+  scaleSteps: 21
+};
+var labelSchema = exports_external.string().trim().max(TRACKER_LIMITS.label).nullish();
+var hiddenSchema = exports_external.boolean().nullish();
+var refSchema = exports_external.object({
+  name: exports_external.string().trim().min(1).max(TRACKER_LIMITS.name),
+  file: exports_external.string().nullish()
+});
+var showSchema = exports_external.array(exports_external.string().trim().min(1).max(TRACKER_LIMITS.label)).max(TRACKER_LIMITS.show).nullish();
+var showSourceSchema = exports_external.object({
+  value: exports_external.string().trim().min(1).max(TRACKER_LIMITS.sourceName),
+  max: exports_external.string().trim().min(1).max(TRACKER_LIMITS.sourceName).nullish()
+});
+var showSourcesSchema = exports_external.record(exports_external.string().trim().min(1).max(TRACKER_LIMITS.label), exports_external.record(exports_external.string().trim().min(1).max(TRACKER_LIMITS.sourceName), showSourceSchema)).nullish();
+var entryTypesSchema = exports_external.array(exports_external.string().trim().min(1).max(TRACKER_LIMITS.sourceName)).max(TRACKER_LIMITS.types).nullish();
+var numberShape = {
+  label: labelSchema,
+  hidden: hiddenSchema,
+  value: exports_external.number(),
+  min: exports_external.number().nullish(),
+  max: exports_external.number().nullish(),
+  tone: exports_external.enum(TRACKER_TONES).nullish(),
+  at: exports_external.record(exports_external.string(), exports_external.string()).nullish(),
+  start: exports_external.number().nullish()
+};
+var countFieldSchema = exports_external.object({
+  kind: exports_external.literal("count"),
+  ...numberShape,
+  display: exports_external.enum(COUNT_DISPLAYS).nullish()
+});
+var clockFieldSchema = exports_external.object({ kind: exports_external.literal("clock"), ...numberShape });
+var scaleFieldSchema = exports_external.object({
+  kind: exports_external.literal("scale"),
+  ...numberShape,
+  ends: exports_external.tuple([exports_external.string(), exports_external.string()]).nullish()
+});
+var listItemSchema = exports_external.object({
+  text: exports_external.string().trim().min(1).max(TRACKER_LIMITS.text),
+  state: exports_external.enum(TRACKER_ITEM_STATES),
+  note: exports_external.string().trim().max(TRACKER_LIMITS.text).nullish(),
+  ref: refSchema.nullish(),
+  hidden: hiddenSchema
+});
+var listFieldSchema = exports_external.object({
+  kind: exports_external.literal("list"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  items: exports_external.array(listItemSchema).max(TRACKER_LIMITS.items)
+});
+var orderEntrySchema = exports_external.object({
+  name: exports_external.string().trim().min(1),
+  score: exports_external.number().nullish()
+});
+var orderFieldSchema = exports_external.object({
+  kind: exports_external.literal("order"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  entries: exports_external.array(orderEntrySchema).max(TRACKER_LIMITS.entries),
+  current: exports_external.string().nullish(),
+  round: exports_external.number().int().nullish(),
+  show: showSchema,
+  types: entryTypesSchema,
+  sources: showSourcesSchema
+});
+var textFieldSchema = exports_external.object({
+  kind: exports_external.literal("text"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  text: exports_external.string().trim().max(TRACKER_LIMITS.text)
+});
+var refFieldSchema = exports_external.object({
+  kind: exports_external.literal("ref"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  ref: refSchema,
+  show: showSchema
+});
+var trackerRecordFieldSchema = exports_external.discriminatedUnion("kind", [
+  countFieldSchema,
+  clockFieldSchema,
+  scaleFieldSchema,
+  listFieldSchema,
+  textFieldSchema
+]);
+var recordSchema = exports_external.object({
+  ref: refSchema,
+  hidden: hiddenSchema,
+  fields: exports_external.array(trackerRecordFieldSchema).max(TRACKER_LIMITS.recordFields)
+});
+var recordsFieldSchema = exports_external.object({
+  kind: exports_external.literal("records"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  entries: exports_external.array(recordSchema).max(TRACKER_LIMITS.records),
+  show: showSchema,
+  types: entryTypesSchema,
+  sources: showSourcesSchema,
+  display: exports_external.enum(RECORDS_DISPLAYS).nullish(),
+  each: exports_external.array(trackerRecordFieldSchema).max(TRACKER_LIMITS.recordFields).nullish()
+});
+var linkSchema = exports_external.object({
+  between: exports_external.tuple([refSchema, refSchema]),
+  hidden: hiddenSchema,
+  fields: exports_external.array(trackerRecordFieldSchema).max(TRACKER_LIMITS.recordFields)
+});
+var linksFieldSchema = exports_external.object({
+  kind: exports_external.literal("links"),
+  label: labelSchema,
+  hidden: hiddenSchema,
+  entries: exports_external.array(linkSchema).max(TRACKER_LIMITS.links),
+  types: entryTypesSchema,
+  each: exports_external.array(trackerRecordFieldSchema).max(TRACKER_LIMITS.recordFields).nullish()
+});
+var trackerFieldSchema = exports_external.discriminatedUnion("kind", [
+  countFieldSchema,
+  clockFieldSchema,
+  scaleFieldSchema,
+  listFieldSchema,
+  orderFieldSchema,
+  textFieldSchema,
+  refFieldSchema,
+  recordsFieldSchema,
+  linksFieldSchema
+]);
+var trackerShapeSchema = exports_external.object({
+  name: exports_external.string().trim().min(1).max(TRACKER_LIMITS.name),
+  fields: exports_external.array(trackerFieldSchema).min(1).max(TRACKER_LIMITS.fields),
+  for: exports_external.string().trim().min(1).nullish(),
+  hidden: exports_external.boolean().nullish(),
+  lasts: exports_external.enum(TRACKER_LASTS).nullish(),
+  from: exports_external.string().nullish(),
+  since: exports_external.string().nullish(),
+  changed: exports_external.string().nullish()
+});
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function upgradedRow(row) {
+  if (!isObject2(row)) {
+    return row;
+  }
+  if (row.kind === "count") {
+    const { style, ...rest } = row;
+    if (style === "clock" || style === "scale") {
+      return { ...rest, kind: style };
+    }
+    return rest;
+  }
+  if (row.kind === "order" && Array.isArray(row.order)) {
+    const { order, ...rest } = row;
+    return { ...rest, entries: order };
+  }
+  return row;
+}
+function upgradedTracker(value) {
+  if (!isObject2(value) || "fields" in value || !Array.isArray(value.rows)) {
+    return value;
+  }
+  const { rows, ...rest } = value;
+  return { ...rest, fields: rows.map(upgradedRow) };
+}
+var trackerSchema = exports_external.preprocess(upgradedTracker, trackerShapeSchema);
+var TRACKER_STARTS = [
+  "game-start",
+  "first-change",
+  "when-started"
+];
+var TRACKER_UPDATES = ["on-trigger", "every-turn"];
+var TRACKER_DEFINITION_LIMITS = {
+  key: 60,
+  when: 300,
+  trigger: 200,
+  question: 400,
+  answer: 600
+};
+var trackerDefinitionSchema = exports_external.object({
+  key: exports_external.string().trim().min(1).max(TRACKER_DEFINITION_LIMITS.key).regex(/^[a-z0-9][a-z0-9-]*$/, "Keys are lowercase letters, digits and -"),
+  start: trackerShapeSchema.omit({ since: true, changed: true, from: true }),
+  starts: exports_external.enum(TRACKER_STARTS),
+  when: exports_external.string().trim().max(TRACKER_DEFINITION_LIMITS.when).nullish(),
+  updates: exports_external.enum(TRACKER_UPDATES).nullish(),
+  trigger: exports_external.string().trim().max(TRACKER_DEFINITION_LIMITS.trigger).nullish(),
+  watch: exports_external.object({
+    question: exports_external.string().trim().min(1).max(TRACKER_DEFINITION_LIMITS.question),
+    yes: exports_external.string().trim().max(TRACKER_DEFINITION_LIMITS.answer).nullish(),
+    no: exports_external.string().trim().max(TRACKER_DEFINITION_LIMITS.answer).nullish(),
+    remind: exports_external.string().trim().max(TRACKER_DEFINITION_LIMITS.answer).nullish()
+  }).nullish(),
+  perPerson: exports_external.boolean().nullish(),
+  personTypes: entryTypesSchema
+});
+var NUMBER_KINDS = new Set(["count", "clock", "scale"]);
+function isNumberField(field) {
+  return NUMBER_KINDS.has(field.kind);
+}
+var ARTICLE_RE = /^(?:the|a|an)\s+/;
+var POSSESSIVE_RE = /['’]s\b/g;
+var NON_WORD_RE = /[^\p{L}\p{N}]+/gu;
+function trackerKey(name) {
+  return name.toLowerCase().replace(POSSESSIVE_RE, "").replace(NON_WORD_RE, " ").trim().replace(ARTICLE_RE, "").trim();
+}
+function numberProblem(field, label) {
+  if (field.kind === "clock") {
+    const size = field.max ?? 0;
+    if (size < TRACKER_LIMITS.clockMin || size > TRACKER_LIMITS.clockMax) {
+      return `${label} is a clock of ${TRACKER_LIMITS.clockMin} to ${TRACKER_LIMITS.clockMax} segments`;
+    }
+  }
+  if (field.kind === "scale") {
+    if (field.min == null || field.max == null || field.min >= field.max) {
+      return `${label} is a tug of war: give it a low end below its high end`;
+    }
+    if (field.max - field.min + 1 > TRACKER_LIMITS.scaleSteps) {
+      return `${label} spans at most ${TRACKER_LIMITS.scaleSteps} steps`;
+    }
+  }
+  if (field.min != null && field.max != null && field.min > field.max) {
+    return `${label} has a lowest value above its highest`;
+  }
+  if (field.min != null && field.value < field.min || field.max != null && field.value > field.max) {
+    return `${label} starts outside its range`;
+  }
+  return null;
+}
+function fieldsProblem(fields, where) {
+  const labels = fields.map((field) => field.label?.trim() ?? "");
+  if (fields.length > 1 && labels.some((label) => !label)) {
+    return `${where} has more than one field, so each needs a label`;
+  }
+  const keys = labels.filter(Boolean).map(trackerKey);
+  if (new Set(keys).size !== keys.length) {
+    return `${where} has two fields with the same label`;
+  }
+  for (const [index, field] of fields.entries()) {
+    const label = labels[index] ? `"${labels[index]}"` : where;
+    const problem = isNumberField(field) ? numberProblem(field, label) : null;
+    if (problem) {
+      return problem;
+    }
+    if ((field.kind === "records" || field.kind === "links") && field.each?.length) {
+      const inner = fieldsProblem(field.each, `What each ${field.kind === "links" ? "link" : "record"} of ${label} starts with`);
+      if (inner) {
+        return inner;
+      }
+    }
+  }
+  return null;
+}
+var QUOTE_RE = /"/;
+function needsStartTrigger(definition) {
+  return definition.starts === "when-started" && !definition.trigger?.trim() && !QUOTE_RE.test(definition.when ?? "");
+}
+function blankStartingName(definition) {
+  for (const field of definition.start.fields) {
+    if (field.kind === "links" && field.entries.some((link) => link.between.some((end) => !end.name.trim()))) {
+      return "a name on each side of every pair it starts with";
+    }
+    const names = field.kind === "records" && field.entries.map((entry) => entry.ref.name) || field.kind === "order" && field.entries.map((entry) => entry.name) || field.kind === "list" && field.items.map((item) => item.text) || [];
+    if (names.some((each) => !each.trim())) {
+      return "a name for everyone and everything it starts with";
+    }
+  }
+  return null;
+}
+function updatesEveryTurn(definition) {
+  return definition.updates === "every-turn";
+}
+function trackerDefinitionProblem(definition) {
+  const name = definition.start.name.trim();
+  const tracker = name ? `The tracker "${name}"` : "A tracker";
+  if (!name) {
+    return "A tracker needs a name.";
+  }
+  if (definition.start.lasts === "always" && definition.starts !== "game-start") {
+    return `${tracker} never goes away, so it is on the board from the game's start: its "starts" is "game-start".`;
+  }
+  if (needsStartTrigger(definition)) {
+    return `${tracker} starts on a trigger, so it needs to say what starts it.`;
+  }
+  if (updatesEveryTurn(definition)) {
+    if (definition.when?.trim() || definition.watch) {
+      return `${tracker} updates every turn, so it has no update trigger: leave out "when" and "watch".`;
+    }
+  } else if (!definition.when?.trim()) {
+    return `${tracker} needs to say what updates it.`;
+  }
+  if (definition.watch && !definition.watch.question.trim()) {
+    return `${tracker} updates on a trigger, so it needs the trigger to check for.`;
+  }
+  const problem = fieldsProblem(definition.start.fields, tracker);
+  if (problem) {
+    return `${problem}.`;
+  }
+  const blank = blankStartingName(definition);
+  return blank ? `${tracker} needs ${blank}.` : null;
+}
+
 // ../shared/src/platform-instructions.ts
 var PLATFORM_INSTRUCTIONS = [
   {
@@ -26867,12 +27206,150 @@ End each reply on something concrete in front of the player's character that the
   },
   {
     id: "combat-tracker",
-    revision: 1,
+    revision: 6,
     instruction: {
       name: "Combat tracker",
       when: "always",
       section: "Rules",
-      body: `When a fight begins, start a turn order on the board with everyone taking part, in the same update() as the fight's first changes: "Start a turn order, Fight at the mill: Kael 18, Lookout 1 15". When the fight is over (every foe down, fled or surrendered, or the fighting stops), end it: "Fight at the mill": "End".`
+      body: `When the fight is over (every foe down, fled or surrendered, or the fighting stops), end it: "<its name>": "End".`,
+      tracker: {
+        key: "fight",
+        start: {
+          name: "Combat",
+          fields: [
+            {
+              kind: "order",
+              entries: [],
+              round: 1,
+              show: ["HP", "Conditions"]
+            }
+          ]
+        },
+        starts: "when-started",
+        trigger: "a fight begins",
+        when: "a fighter's turn ends, or someone joins or leaves the fight"
+      }
+    }
+  },
+  {
+    id: "objectives-tracker",
+    revision: 2,
+    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.`,
+      tracker: {
+        key: "objectives",
+        start: {
+          name: "Objectives",
+          lasts: "game",
+          fields: [{ kind: "list", items: [] }]
+        },
+        starts: "first-change",
+        when: "the story gives the party an objective (an order, a job or request they take on, a goal of their own that outlasts the scene)",
+        watch: {
+          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 board's Objectives list does not hold (add it as the party knows it now, short, one goal to an objective: "Objectives": "Add: <the objective>")`
+        }
+      }
+    }
+  },
+  {
+    id: "party-tracker",
+    revision: 2,
+    instruction: {
+      name: "Party",
+      when: "always",
+      section: "Rules",
+      body: `The Party is everyone who travels and acts with the player's character as one of them: the player's character, who is always in it, and the companions who have joined. Add someone when they join ("Party": "Add Mira"), and take them off when they leave, part ways for good or die ("Party": "Remove Mira"). Someone who only helps for a while (a guide for the afternoon, a guard who fights beside them once) is not in it unless the story has them join.`,
+      tracker: {
+        key: "party",
+        start: {
+          name: "Party",
+          lasts: "game",
+          fields: [
+            {
+              kind: "records",
+              entries: [],
+              show: ["HP", "Conditions"],
+              display: "roster"
+            }
+          ]
+        },
+        starts: "game-start",
+        when: "someone joins the party or leaves it",
+        watch: {
+          question: "In `earlier`, `player_turn` or `narration`, has someone joined the party (now travelling and acting with the player's character as one of them) or left it, that {tracker} does not show?",
+          yes: `Yes: someone agrees to come along, is taken on, or sets out with them as one of the group ("I'll come with you", hired for the journey, rescued and staying with them); or someone {tracker} lists leaves, parts ways for good, is left behind or dies.`,
+          no: "No: {tracker} already shows who is in the party; or someone only helps for a moment, offers to come but has not joined, or is only met, fought beside or travelled near.",
+          remind: `someone joined or left the party and the board's Party does not show it (add or take them off: "Party": "Add <name>", "Party": "Remove <name>")`
+        }
+      }
+    }
+  },
+  {
+    id: "death-saves-tracker",
+    revision: 3,
+    instruction: {
+      name: "Death saves",
+      when: "always",
+      section: "Rules",
+      body: `Only for a world whose rules have the dying roll to stay alive. Each save is a roll on their turn: the player's for their character, yours for anyone else. Record each one as it lands ("Death saves for Sara": "Successes +1", "Death saves for Sara": "Failures +1"). When they stabilize, are healed or die, end it ("Death saves for Sara": "End").`,
+      tracker: {
+        key: "death-saves",
+        start: {
+          name: "Death saves",
+          fields: [
+            {
+              kind: "count",
+              label: "Successes",
+              value: 0,
+              min: 0,
+              max: 3,
+              tone: "good",
+              display: "pips",
+              at: { "3": "Stable" }
+            },
+            {
+              kind: "count",
+              label: "Failures",
+              value: 0,
+              min: 0,
+              max: 3,
+              tone: "bad",
+              display: "pips",
+              at: { "3": "Dies" }
+            }
+          ]
+        },
+        starts: "when-started",
+        trigger: "someone falls dying, and the world's rules have them roll to stay alive",
+        perPerson: true,
+        when: "they make a death save"
+      }
+    }
+  },
+  {
+    id: "time-tracker",
+    revision: 3,
+    instruction: {
+      name: "Time",
+      when: "always",
+      section: "Rules",
+      body: `The Time tracker is the in-game time, and only you move it: nothing moves it after the turn. It is always a time someone could tell by a clock or the sky, in the world's own terms: a clock hour ("10:40 pm"), a part of the day ("dawn", "late afternoon") or how long until something ("about 2 hours until sunset"); never only how long passed ("30 minutes later": later than what?). Whenever the story takes time worth counting (a journey, a rest, a wait, a long job or talk), set it to the time it is now in the update() for that stretch of story, beside its other changes: "Time": "It is now dusk". When it shows a clock hour, a span is enough ("Time": "40 minutes pass") and the clock adds it. With nothing else to record, the time is still an update() of its own. A line or two of talk needs no record. Tell it once, as the time it is now: "It is now 12:10 am", "It is now dawn", "It is now about an hour until sunset"; never "a while later" or "30 minutes later". A rest recorded with its length ("scene": "The party rests for 1 hour") already moves the clock, so no "Time": "1 hour passes" after it. Narrate the hour, the light and what is open from the board's time, never from a guess.`,
+      tracker: {
+        key: "time",
+        start: {
+          name: "Time",
+          lasts: "game",
+          fields: [{ kind: "text", text: "" }]
+        },
+        starts: "game-start",
+        when: "the story takes time worth counting (a journey, a rest, a wait, a long job or talk)"
+      }
     }
   },
   {
@@ -26898,7 +27375,6 @@ End each reply on something concrete in front of the player's character that the
   }
 ];
 var RESPONSE_LENGTH = "Response length";
-var ROLL_NUMBERS = "Roll numbers in narration";
 var LONG_TRAVEL = "Long-distance travel";
 var PLATFORM_OPTIONS = [
   {
@@ -26952,40 +27428,6 @@ var PLATFORM_OPTIONS = [
       ]
     }
   },
-  {
-    revision: 2,
-    option: {
-      key: "platform-roll-numbers",
-      label: ROLL_NUMBERS,
-      description: "Whether the story repeats the dice. Rolls always show as dice cards in the chat.",
-      kind: "one",
-      default: ["left-out"],
-      choices: [
-        {
-          key: "left-out",
-          label: "Exclude",
-          description: "The story tells what happens, not the numbers.",
-          instructions: [
-            {
-              when: "always",
-              body: "Never write dice, totals or difficulties in the story: the dice cards show them. Tell what the roll's outcome looks and feels like."
-            }
-          ]
-        },
-        {
-          key: "shown",
-          label: "Include",
-          description: "Each total in a short bracket where it lands.",
-          instructions: [
-            {
-              when: "always",
-              body: "Show each roll's total once, in a short bracket where it lands in the story: (Climb: 11 + 3 = 14 vs DC 12), or for an attack and its damage (15 vs AC 14, 4 piercing damage)."
-            }
-          ]
-        }
-      ]
-    }
-  },
   {
     revision: 1,
     option: {
@@ -27036,7 +27478,7 @@ var GAME_OPTION_LABEL_MAX_LENGTH = 60;
 var GAME_OPTION_DESCRIPTION_MAX_LENGTH = 200;
 var GAME_OPTION_KEY_MAX_LENGTH = 60;
 var GAME_OPTIONS_MAX_OPTIONS = 8;
-var GAME_OPTIONS_READ_MAX_OPTIONS = 12 + PLATFORM_OPTIONS.length;
+var GAME_OPTIONS_READ_MAX_OPTIONS = 15;
 var GAME_OPTION_MAX_CHOICES = 8;
 var GAME_OPTIONS_MAX_INSTRUCTIONS = 200;
 var GAME_OPTIONS_MAX_ALWAYS_LENGTH = 1e4;
@@ -27052,6 +27494,7 @@ var gameOptionInstructionSchema = exports_external.object({
   when: exports_external.enum(GAME_OPTION_INSTRUCTION_WHEN),
   trigger: exports_external.string().trim().max(GAME_OPTION_INSTRUCTION_NAME_MAX_LENGTH).optional(),
   section: exports_external.string().trim().max(GAME_OPTION_SECTION_MAX_LENGTH).optional(),
+  tracker: trackerDefinitionSchema.optional(),
   platform: exports_external.string().max(GAME_OPTION_KEY_MAX_LENGTH).optional()
 });
 var gameOptionChoiceSchema = exports_external.object({
@@ -27123,6 +27566,12 @@ function sectionsOf(options) {
   return [...new Set(names)];
 }
 function instructionProblem(instruction, base) {
+  if (instruction.tracker) {
+    const problem = trackerDefinitionProblem(instruction.tracker);
+    if (problem) {
+      return problem.charAt(0).toLowerCase() + problem.slice(1);
+    }
+  }
   if (instruction.when === "situational" && !instruction.trigger?.trim()) {
     return "a situational instruction needs the moment it's for.";
   }
@@ -27147,7 +27596,28 @@ function gameOptionsProblem(options) {
       }
     }
   }
-  return gameOptionsStructureProblem(options) ?? gameOptionsLimitProblem(options);
+  return trackerKeysProblem(options) ?? gameOptionsStructureProblem(options) ?? gameOptionsLimitProblem(options);
+}
+function trackerKeysProblem(options) {
+  const lists = [
+    options.instructions.filter((instruction) => !instruction.platform),
+    ...options.options.flatMap((option) => option.choices.map((choice) => choice.instructions))
+  ];
+  for (const list of lists) {
+    const seen = new Map;
+    for (const instruction of list) {
+      const definition = instruction.tracker;
+      if (!definition) {
+        continue;
+      }
+      const other = seen.get(definition.key);
+      if (other !== undefined) {
+        return `The trackers "${other}" and "${definition.start.name}" share the key "${definition.key}": rename one.`;
+      }
+      seen.set(definition.key, definition.start.name);
+    }
+  }
+  return null;
 }
 function gameOptionsStructureProblem(options) {
   const optionKeys = new Set;
@@ -27208,6 +27678,54 @@ var storedGameOptionsSchema = storedGameOptionsShape.superRefine((options, ctx)
     ctx.addIssue({ code: "custom", message: problem });
   }
 });
+function droppedKeys({
+  raw,
+  parsed,
+  path = ""
+}) {
+  if (Array.isArray(raw) && Array.isArray(parsed)) {
+    return raw.flatMap((item, index) => droppedKeys({
+      raw: item,
+      parsed: parsed[index],
+      path: `${path}[${index}]`
+    }));
+  }
+  if (typeof raw !== "object" || raw === null || typeof parsed !== "object" || parsed === null) {
+    return [];
+  }
+  return Object.entries(raw).flatMap(([key, value]) => (key in parsed) ? droppedKeys({
+    raw: value,
+    parsed: parsed[key],
+    path: `${path}.${key}`
+  }) : [`${path}.${key}`]);
+}
+var INDEX_RE = /\[\d+\]/g;
+var LEADING_DOT_RE = /^\./;
+function unknownGameOptionsKeys({
+  raw,
+  before
+}) {
+  const parsed = storedGameOptionsShape.safeParse(raw);
+  if (!parsed.success) {
+    return [];
+  }
+  const stored = before === undefined || before === null ? null : storedGameOptionsShape.safeParse(before);
+  const old = new Set(stored?.success ? droppedKeys({ raw: before, parsed: stored.data }).map((path) => path.replace(INDEX_RE, "[]")) : []);
+  return droppedKeys({ raw, parsed: parsed.data }).filter((path) => !old.has(path.replace(INDEX_RE, "[]"))).map((path) => path.replace(LEADING_DOT_RE, ""));
+}
+function unknownGameOptionsKeysProblem({
+  raw,
+  before,
+  where
+}) {
+  const unknown2 = unknownGameOptionsKeys({ raw, before });
+  if (unknown2.length === 0) {
+    return null;
+  }
+  const listed = unknown2.slice(0, 5).map((path) => `${where}.${path}`).join(", ");
+  const more = unknown2.length > 5 ? ` and ${unknown2.length - 5} more` : "";
+  return `${listed}${more}: the format has no ${unknown2.length === 1 ? "such key" : "such keys"} there, and it would be dropped without effect. Check the field names and where each sits (a tracker's "lasts", "name", "fields" and "hidden" go inside its "start").`;
+}
 var resolvedGameOptionsSchema = gameOptionsShape.superRefine((options, ctx) => {
   const problem = gameOptionsProblem(options);
   if (problem) {
@@ -27280,7 +27798,13 @@ function withPlatform(stored) {
     const content = override ? overrideInstruction(override) : entry.instruction;
     const { section: ownSection, ...rest } = content;
     const section = placedIn?.trim() || ownSection?.trim() || entry.instruction.section;
-    return { ...rest, ...section ? { section } : {}, platform: entry.id };
+    const tracker = rest.tracker ?? entry.instruction.tracker;
+    return {
+      ...rest,
+      ...tracker ? { tracker } : {},
+      ...section ? { section } : {},
+      platform: entry.id
+    };
   }
   const instructions = [];
   const placed = new Set;
@@ -27356,6 +27880,12 @@ function instructionSignature(instruction) {
     instruction.trigger?.trim() ?? ""
   ]);
 }
+function sameTracker(a, b) {
+  return sameJson(a ?? null, b ?? null);
+}
+function craftTracker(instruction, entry) {
+  return sameTracker(instruction.tracker ?? entry.instruction.tracker, entry.instruction.tracker);
+}
 function optionSignature(option) {
   return JSON.stringify([
     option.label.trim(),
@@ -27381,7 +27911,7 @@ function platformInstructionStatus(instruction, stored) {
   if (!entry) {
     return null;
   }
-  if (instructionSignature(withoutPlatformTag(instruction)) === instructionSignature(entry.instruction)) {
+  if (instructionSignature(withoutPlatformTag(instruction)) === instructionSignature(entry.instruction) && craftTracker(instruction, entry)) {
     return "platform";
   }
   const before = parseGameOptions(stored);
@@ -27416,10 +27946,11 @@ function alwaysTextLength(instructions) {
   return always.reduce((total, instruction) => total + instruction.body.length, 0) + [...titles].reduce((total, title) => total + title.length, 0);
 }
 function alwaysLength(instructions, place) {
-  return alwaysTextLength(instructions.map((instruction) => ({
+  const trackerLines = instructions.reduce((total, instruction) => instruction.tracker ? total + instruction.tracker.start.name.length + (instruction.tracker.when?.length ?? 0) + 4 : total, 0);
+  return alwaysTextLength(instructions.filter((instruction) => !instruction.tracker).map((instruction) => ({
     ...instruction,
     title: instructionTitle(instruction, place)
-  })));
+  }))) + trackerLines;
 }
 function situationalCount(instructions, _place) {
   return instructions.filter((instruction) => instruction.when === "situational").length;
@@ -36485,8 +37016,52 @@ function validateFileContentAgainstSchemaVariants(contents, schema) {
   return sharedErrors.length > 0 ? { status: "invalid", errors: sharedErrors } : { status: "valid" };
 }
 
+// ../shared/src/vfs/path.ts
+var LEADING_SLASHES = /^\/+/;
+var TRAILING_SLASHES = /\/+$/;
+function parseVfsPath(path) {
+  const trimmed = path.replace(LEADING_SLASHES, "").replace(TRAILING_SLASHES, "");
+  const isDir = path.endsWith("/") || path === "/";
+  if (!trimmed) {
+    return { kind: "folder", segments: [] };
+  }
+  const parts = trimmed.split("/").map((part) => part.trim());
+  if (parts.some((part) => part.length === 0)) {
+    throw new Error(`Invalid path "${path}": empty path segment`);
+  }
+  if (parts.some((part) => part === "." || part === "..")) {
+    throw new Error(`Invalid path "${path}": "." and ".." path segments are not allowed`);
+  }
+  const lastPart = parts.at(-1);
+  if (isDir || !lastPart || !lastPart.includes(".")) {
+    return { kind: "folder", segments: parts };
+  }
+  const dotIdx = lastPart.lastIndexOf(".");
+  const finalSuffix = lastPart.slice(dotIdx + 1);
+  const stem = lastPart.slice(0, dotIdx);
+  const stemDotIdx = stem.lastIndexOf(".");
+  const hasContentExtension = isContentExtension(finalSuffix) && stemDotIdx > 0;
+  return {
+    kind: "file",
+    segments: parts.slice(0, -1),
+    baseName: hasContentExtension ? stem.slice(0, stemDotIdx) : stem,
+    extension: hasContentExtension ? stem.slice(stemDotIdx + 1) : finalSuffix,
+    ...hasContentExtension && { contentExtension: finalSuffix }
+  };
+}
+var UNSAFE_DISK_SEGMENT_CHARS = /[\\/:*?"<>|\u0000-\u001f\u007f]/g;
+function sanitizeVfsSegmentForDisk(segment) {
+  if (segment === "." || segment === ".." || segment.trim().length === 0) {
+    return "_";
+  }
+  const cleaned = segment.replace(UNSAFE_DISK_SEGMENT_CHARS, "_").trim();
+  return cleaned.length > 0 ? cleaned : "_";
+}
+function sanitizeVfsPathForDisk(path) {
+  return path.split("/").map((segment) => segment === "" ? "" : sanitizeVfsSegmentForDisk(segment)).join("/");
+}
+
 // ../shared/src/files/file-reference-content.ts
-var FILE_REFERENCE_EXTENSION_RE = /\.[^.]+$/;
 var STATE_PATH_LEADING_SLASH_RE = /^\/+/;
 var STATE_PATH_ARRAY_INDEX_RE = /\[(?:\d+|\*)\]/g;
 function isRecord5(value) {
@@ -36637,23 +37212,36 @@ function referenceHintsFromLayout(layout) {
   collectLayoutReferenceHints(layout, hints);
   return hints;
 }
-function referenceCandidate(value) {
+function referenceNameParts(value) {
   const trimmed = value.trim();
   const lastSegment = trimmed.split("/").filter(Boolean).at(-1) ?? trimmed;
-  return lastSegment.replace(FILE_REFERENCE_EXTENSION_RE, "");
+  try {
+    const parsed = parseVfsPath(lastSegment);
+    if (parsed.kind === "file") {
+      return { name: parsed.baseName, type: parsed.extension };
+    }
+  } catch {}
+  return { name: lastSegment, type: null };
+}
+function referenceCandidate(value) {
+  return referenceNameParts(value).name;
 }
 function normalizeFileReferenceLookupValue(value) {
   const candidate = referenceCandidate(value);
   return generateSlug(candidate) || candidate.toLowerCase();
 }
 function qualifiedLookupTypeSlug(value, fileTypeSlugs) {
+  const normalizedTargets = new Set(fileTypeSlugs.map((slug) => normalizeReferenceTargetSlug(slug)).filter(Boolean));
   const segments = value.trim().split("/").filter(Boolean);
-  if (segments.length < 2) {
-    return null;
+  if (segments.length >= 2) {
+    const prefix = normalizeReferenceTargetSlug(segments[0]);
+    if (normalizedTargets.has(prefix)) {
+      return prefix;
+    }
   }
-  const prefix = normalizeReferenceTargetSlug(segments[0]);
-  const normalizedTargets = new Set(fileTypeSlugs.map((slug) => normalizeReferenceTargetSlug(slug)).filter(Boolean));
-  return normalizedTargets.has(prefix) ? prefix : null;
+  const ending = referenceNameParts(value).type;
+  const type = ending ? normalizeReferenceTargetSlug(ending) : "";
+  return type && normalizedTargets.has(type) ? type : null;
 }
 function parseFileReferenceLookupValue(value, fileTypeSlugs = []) {
   const fileTypeSlug = qualifiedLookupTypeSlug(value, fileTypeSlugs);
@@ -40209,85 +40797,6 @@ function validateSectionsBlock(sections, errors3, options) {
     }
   }
 }
-// ../shared/src/board-trackers.ts
-var TRACKER_COUNT_STYLES = [
-  "number",
-  "bar",
-  "pips",
-  "boxes",
-  "clock",
-  "scale"
-];
-var TRACKER_TONES = ["good", "bad"];
-var TRACKER_ITEM_STATES = ["open", "done", "failed"];
-var TRACKER_LASTS = ["here", "game"];
-var TRACKER_LIMITS = {
-  name: 60,
-  label: 40,
-  text: 160,
-  rows: 6,
-  items: 16,
-  order: 20,
-  marks: 20,
-  clockMin: 2,
-  clockMax: 12,
-  scaleSteps: 21
-};
-var labelSchema = exports_external.string().trim().max(TRACKER_LIMITS.label).nullish();
-var countRowSchema = exports_external.object({
-  kind: exports_external.literal("count"),
-  label: labelSchema,
-  value: exports_external.number(),
-  min: exports_external.number().nullish(),
-  max: exports_external.number().nullish(),
-  style: exports_external.enum(TRACKER_COUNT_STYLES).nullish(),
-  tone: exports_external.enum(TRACKER_TONES).nullish(),
-  ends: exports_external.tuple([exports_external.string(), exports_external.string()]).nullish(),
-  at: exports_external.record(exports_external.string(), exports_external.string()).nullish(),
-  start: exports_external.number().nullish()
-});
-var listItemSchema = exports_external.object({
-  text: exports_external.string().trim().min(1).max(TRACKER_LIMITS.text),
-  state: exports_external.enum(TRACKER_ITEM_STATES),
-  note: exports_external.string().trim().max(TRACKER_LIMITS.text).nullish()
-});
-var listRowSchema = exports_external.object({
-  kind: exports_external.literal("list"),
-  label: labelSchema,
-  items: exports_external.array(listItemSchema).max(TRACKER_LIMITS.items)
-});
-var orderEntrySchema = exports_external.object({
-  name: exports_external.string().trim().min(1),
-  score: exports_external.number().nullish()
-});
-var orderRowSchema = exports_external.object({
-  kind: exports_external.literal("order"),
-  label: labelSchema,
-  order: exports_external.array(orderEntrySchema).max(TRACKER_LIMITS.order),
-  current: exports_external.string().nullish(),
-  round: exports_external.number().int().nullish()
-});
-var textRowSchema = exports_external.object({
-  kind: exports_external.literal("text"),
-  label: labelSchema,
-  text: exports_external.string().trim().max(TRACKER_LIMITS.text)
-});
-var trackerRowSchema = exports_external.discriminatedUnion("kind", [
-  countRowSchema,
-  listRowSchema,
-  orderRowSchema,
-  textRowSchema
-]);
-var trackerSchema = exports_external.object({
-  name: exports_external.string().trim().min(1).max(TRACKER_LIMITS.name),
-  rows: exports_external.array(trackerRowSchema).min(1).max(TRACKER_LIMITS.rows),
-  for: exports_external.string().trim().min(1).nullish(),
-  hidden: exports_external.boolean().nullish(),
-  lasts: exports_external.enum(TRACKER_LASTS).nullish(),
-  since: exports_external.string().nullish(),
-  changed: exports_external.string().nullish()
-});
-
 // ../shared/src/scripts/board.ts
 var UPDATE_KEYS = new Set([
   "arrive",
@@ -41061,13 +41570,14 @@ var GAME_START_MAX_CHARACTER_OPENINGS = 100;
 var GAME_START_GM_NOTES_MAX_LENGTH = 40000;
 var GAME_START_BOARD_LIMITS = {
   people: 30,
-  time: 80,
   purpose: 300,
   area: 60,
   hiddenAs: 160,
   note: 160,
   objectives: 16,
-  objective: 160
+  objective: 160,
+  trackers: 30,
+  trackerKey: 60
 };
 var GM_INSTRUCTION_TRIGGER_PHASES = [
   "post_player_message",
@@ -41449,12 +41959,43 @@ var GameStartBoardPersonSchema = exports_external.object({
   }).nullish(),
   note: exports_external.string().trim().max(GAME_START_BOARD_LIMITS.note).nullish()
 });
-var GameStartBoardSchema = exports_external.object({
+var GameStartTrackerSchema = exports_external.object({
+  key: exports_external.string().trim().min(1).max(GAME_START_BOARD_LIMITS.trackerKey),
+  on: exports_external.boolean(),
+  fields: exports_external.array(trackerFieldSchema).max(TRACKER_LIMITS.fields).nullish()
+});
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function boardWithTimeAsTracker(value) {
+  if (!(isPlainObject2(value) && ("time" in value))) {
+    return value;
+  }
+  const { time: time3, ...rest } = value;
+  const words = typeof time3 === "string" ? time3.trim() : "";
+  const trackers = Array.isArray(rest.trackers) ? rest.trackers : [];
+  const set2 = trackers.some((entry) => isPlainObject2(entry) && entry.key === TIME_TRACKER_KEY);
+  if (!words || set2) {
+    return rest;
+  }
+  return {
+    ...rest,
+    trackers: [
+      ...trackers,
+      {
+        key: TIME_TRACKER_KEY,
+        on: true,
+        fields: [{ kind: "text", text: words }]
+      }
+    ]
+  };
+}
+var GameStartBoardSchema = exports_external.preprocess(boardWithTimeAsTracker, exports_external.object({
   people: exports_external.array(GameStartBoardPersonSchema).max(GAME_START_BOARD_LIMITS.people).default([]),
-  time: exports_external.string().trim().max(GAME_START_BOARD_LIMITS.time).default(""),
   purpose: exports_external.string().trim().max(GAME_START_BOARD_LIMITS.purpose).default(""),
-  objectives: exports_external.array(exports_external.string().trim().min(1).max(GAME_START_BOARD_LIMITS.objective)).max(GAME_START_BOARD_LIMITS.objectives).default([])
-});
+  objectives: exports_external.array(exports_external.string().trim().min(1).max(GAME_START_BOARD_LIMITS.objective)).max(GAME_START_BOARD_LIMITS.objectives).default([]),
+  trackers: exports_external.array(GameStartTrackerSchema).max(GAME_START_BOARD_LIMITS.trackers).default([])
+}));
 function combinedOpeningLength(opening) {
   if (opening.kind !== "static" || !opening.beats) {
     return 0;
@@ -41473,9 +42014,9 @@ var GameStartMetadataObjectSchema = exports_external.object({
   openingInstructions: exports_external.string().max(GAME_START_OPENING_MAX_LENGTH).default(""),
   board: GameStartBoardSchema.default({
     people: [],
-    time: "",
     purpose: "",
-    objectives: []
+    objectives: [],
+    trackers: []
   }),
   gmNotes: exports_external.string().max(GAME_START_GM_NOTES_MAX_LENGTH).default("")
 });
@@ -41518,6 +42059,17 @@ var GameStartMetadataSchema = GameStartMetadataObjectSchema.superRefine((metadat
     }
     seenBoardReferenceIds.add(referenceId);
   });
+  const seenTrackerKeys = new Set;
+  metadata.board.trackers.forEach((tracker, index) => {
+    if (seenTrackerKeys.has(tracker.key)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["board", "trackers", index, "key"],
+        message: "Each tracker can only be set once."
+      });
+    }
+    seenTrackerKeys.add(tracker.key);
+  });
 });
 var FileDesignationMetadataV1Schema = exports_external.object({
   schemaVersionId: exports_external.literal(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V1).default(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V1),
@@ -42022,39 +42574,95 @@ interface BoardPerson {
   readonly details: { readonly [detail: string]: string | number | boolean };
 }
 
-/** One row of a tracker: a count, a list, a turn order or a short text. */
-type BoardTrackerRow =
+/** A file or person a tracker points at, by name; its file is filled in by the game. */
+type BoardTrackerRef = { name: string; file?: string | null };
+
+/** A number: a count, a clock (pressure filling toward trouble) or a scale (a tug of war between two ends). */
+type BoardTrackerNumber = {
+  kind: "count" | "clock" | "scale";
+  label?: string | null;
+  /** The GM's alone: players never see this field. */
+  hidden?: boolean | null;
+  value: number;
+  min?: number | null;
+  max?: number | null;
+  tone?: "good" | "bad" | null;
+  /** A scale's two ends, low first. */
+  ends?: [string, string] | null;
+  /** What happens when the number reaches a value: { "6": "The guards arrive" }. */
+  at?: { [value: string]: string } | null;
+};
+
+type BoardTrackerList = {
+  kind: "list";
+  label?: string | null;
+  hidden?: boolean | null;
+  items: {
+    text: string;
+    state: "open" | "done" | "failed";
+    note?: string | null;
+    /** Who or what the item is about. */
+    ref?: BoardTrackerRef | null;
+    hidden?: boolean | null;
+  }[];
+};
+
+type BoardTrackerText = { kind: "text"; label?: string | null; hidden?: boolean | null; text: string };
+
+/**
+ * One field of a tracker: a number, a list, a turn order, a short text, a
+ * file or person it points at, records (one per person or file, each with
+ * fields of its own) or links (one per pair of them, with fields between
+ * the two). show names live values drawn beside each person a field names:
+ * a stat the board shows ("HP") or "where".
+ */
+type BoardTrackerField =
+  | BoardTrackerNumber
+  | BoardTrackerList
   | {
-      kind: "count";
+      kind: "order";
       label?: string | null;
-      value: number;
-      min?: number | null;
-      max?: number | null;
-      style?: "number" | "bar" | "pips" | "boxes" | "clock" | "scale" | null;
-      tone?: "good" | "bad" | null;
-      /** A scale's two ends, low first. */
-      ends?: [string, string] | null;
-      /** What happens when the count reaches a value: { "6": "The guards arrive" }. */
-      at?: { [value: string]: string } | null;
+      hidden?: boolean | null;
+      entries: { name: string; score?: number | null }[];
+      current?: string | null;
+      round?: number | null;
+      show?: string[] | null;
     }
+  | BoardTrackerText
   | {
-      kind: "list";
+      kind: "ref";
       label?: string | null;
-      items: { text: string; state: "open" | "done" | "failed"; note?: string | null }[];
+      hidden?: boolean | null;
+      ref: BoardTrackerRef;
+      show?: string[] | null;
     }
   | {
-      kind: "order";
+      kind: "records";
       label?: string | null;
-      order: { name: string; score?: number | null }[];
-      current?: string | null;
-      round?: number | null;
+      hidden?: boolean | null;
+      entries: {
+        ref: BoardTrackerRef;
+        hidden?: boolean | null;
+        fields: (BoardTrackerNumber | BoardTrackerList | BoardTrackerText)[];
+      }[];
+      show?: string[] | null;
     }
-  | { kind: "text"; label?: string | null; text: string };
+  | {
+      kind: "links";
+      label?: string | null;
+      hidden?: boolean | null;
+      entries: {
+        /** The two it links ("Kael" and "Mira"); a pair is the same either way round. */
+        between: [BoardTrackerRef, BoardTrackerRef];
+        hidden?: boolean | null;
+        fields: (BoardTrackerNumber | BoardTrackerList | BoardTrackerText)[];
+      }[];
+    };
 
-/** A tracker on the board: a turn order, a clock, a quest's steps, a count. */
+/** A tracker on the board: a turn order, a clock, the objectives, suspects, a count. */
 interface BoardTracker {
   name: string;
-  rows: BoardTrackerRow[];
+  fields: BoardTrackerField[];
   /** Someone on the board it is about. */
   for?: string | null;
   /** The GM's alone: players never see it. */
@@ -43008,7 +43616,7 @@ function parseMarkdown(source) {
   } catch {
     return { content: source };
   }
-  if (!isPlainObject2(parsed)) {
+  if (!isPlainObject3(parsed)) {
     return { content: body };
   }
   const file2 = { content: body };
@@ -43056,7 +43664,7 @@ function parseFrontmatterObject(source) {
   } catch {
     return null;
   }
-  return isPlainObject2(parsed) ? parsed : null;
+  return isPlainObject3(parsed) ? parsed : null;
 }
 function stripLeadingNewline(s) {
   if (s.startsWith(`\r
@@ -43069,7 +43677,7 @@ function stripLeadingNewline(s) {
   }
   return s;
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function coerceString(value) {
@@ -43085,19 +43693,6 @@ function coerceString(value) {
 // src/engine/vfs-name.ts
 import { isAbsolute, relative, resolve } from "node:path";
 
-// ../shared/src/vfs/path.ts
-var UNSAFE_DISK_SEGMENT_CHARS = /[\\/:*?"<>|\u0000-\u001f\u007f]/g;
-function sanitizeVfsSegmentForDisk(segment) {
-  if (segment === "." || segment === ".." || segment.trim().length === 0) {
-    return "_";
-  }
-  const cleaned = segment.replace(UNSAFE_DISK_SEGMENT_CHARS, "_").trim();
-  return cleaned.length > 0 ? cleaned : "_";
-}
-function sanitizeVfsPathForDisk(path) {
-  return path.split("/").map((segment) => segment === "" ? "" : sanitizeVfsSegmentForDisk(segment)).join("/");
-}
-
 // ../shared/src/cli/vfs-name.ts
 function parseVfsFileName(fileName) {
   if (fileName.includes("/")) {
@@ -43192,10 +43787,10 @@ function deletedSidecarPath(workingPath) {
 }
 
 // src/engine/vfs-name.ts
-var LEADING_SLASHES = /^\/+/;
+var LEADING_SLASHES2 = /^\/+/;
 function joinUnderWorkspaceRoot(root, vfsPath) {
   const rootResolved = resolve(root);
-  const relativePath = vfsPath.replace(LEADING_SLASHES, "");
+  const relativePath = vfsPath.replace(LEADING_SLASHES2, "");
   if (relativePath.length === 0 || relativePath.split("/").some((segment) => segment === "." || segment === "..")) {
     throw new Error(`path escapes workspace root: ${vfsPath}`);
   }
@@ -43890,9 +44485,9 @@ async function loadBaseRecordsForMissing({
   return records;
 }
 var LEADING_DOT_SLASH = /^\.\//;
-var TRAILING_SLASHES = /\/+$/;
+var TRAILING_SLASHES2 = /\/+$/;
 function normalizeVfsPath(input) {
-  const cleaned = input.replace(LEADING_DOT_SLASH, "").replace(TRAILING_SLASHES, "");
+  const cleaned = input.replace(LEADING_DOT_SLASH, "").replace(TRAILING_SLASHES2, "");
   return cleaned.startsWith("/") ? cleaned : `/${cleaned}`;
 }
 function toIsoTimestamp(value) {
@@ -44361,6 +44956,17 @@ function checkGameOptions(workspace) {
         detail: "shape errors are reported under project-settings"
       };
     }
+    const unknown2 = unknownGameOptionsKeysProblem({
+      raw: value,
+      where: "settings.gameOptions"
+    });
+    if (unknown2) {
+      return {
+        ...base,
+        status: "warn",
+        detail: `${unknown2} Push drops them, so they do nothing (format: .craft/instructions/upgrading-to-gm-harness-2.md)`
+      };
+    }
     const parsed = gameOptionsSchema.safeParse(value);
     if (!parsed.success) {
       const issue3 = parsed.error.issues[0];
@@ -45139,7 +45745,7 @@ var credentialsFileSchema = exports_external.object({
   version: exports_external.literal(1),
   remotes: exports_external.record(exports_external.string(), storedCredentialsSchema)
 }).strict();
-var TRAILING_SLASHES2 = /\/+$/;
+var TRAILING_SLASHES3 = /\/+$/;
 function credentialsPath() {
   const dir = process.env.CRAFT_CONFIG_DIR ?? join4(homedir(), ".config", "craft");
   return join4(dir, "credentials.json");
@@ -45148,7 +45754,7 @@ function normalizeRemoteKey(remote) {
   try {
     return new URL(remote).origin;
   } catch {
-    return remote.replace(TRAILING_SLASHES2, "");
+    return remote.replace(TRAILING_SLASHES3, "");
   }
 }
 async function readCredentialsFile() {
@@ -45203,7 +45809,7 @@ async function deleteStoredCredentials(remote) {
 
 // src/auth/oauth.ts
 import { createHash as createHash2, randomBytes as randomBytes3 } from "node:crypto";
-var TRAILING_SLASHES3 = /\/+$/;
+var TRAILING_SLASHES4 = /\/+$/;
 async function fetchJson(fetchImpl, url2, init) {
   let response;
   try {
@@ -45221,7 +45827,7 @@ function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function authServerMetadataUrls(issuer) {
-  const base = issuer.replace(TRAILING_SLASHES3, "");
+  const base = issuer.replace(TRAILING_SLASHES4, "");
   const url2 = new URL(base);
   const suffixForm = `${base}/.well-known/oauth-authorization-server`;
   const insertionForm = `${url2.origin}/.well-known/oauth-authorization-server${url2.pathname === "/" ? "" : url2.pathname}`;
@@ -45231,7 +45837,7 @@ async function discoverAuthorization({
   remote,
   fetchImpl = fetch
 }) {
-  const origin = remote.replace(TRAILING_SLASHES3, "");
+  const origin = remote.replace(TRAILING_SLASHES4, "");
   const prmUrl = `${origin}/.well-known/oauth-protected-resource/mcp`;
   const prm = await fetchJson(fetchImpl, prmUrl);
   if (!(prm.ok && isRecord15(prm.json))) {
@@ -45589,7 +46195,7 @@ async function refreshWorkspaceScriptTypes({
 // package.json
 var package_default = {
   name: "@craftrpgs/cli",
-  version: "0.2.0-alpha.1",
+  version: "0.2.0-alpha.2",
   description: "Sync Craft projects with a local folder — clone, edit with any coding agent, push back.",
   license: "UNLICENSED",
   homepage: "https://craftrpgs.com",
@@ -45610,14 +46216,14 @@ var package_default = {
   scripts: {
     build: "bun run scripts/build.ts",
     prepack: "bun run build",
-    typecheck: "tsc --noEmit"
+    typecheck: "bun check"
   },
   devDependencies: {
     "@craft/flow": "workspace:*",
     "@craft/shared": "workspace:*",
     fflate: "^0.8.3",
     typescript: "7.0.2",
-    uuid: "11.1.0",
+    uuid: "11.1.1",
     zod: "4.3.6"
   }
 };
@@ -45626,7 +46232,7 @@ var package_default = {
 var CLI_VERSION = package_default.version;
 
 // src/http.ts
-var TRAILING_SLASHES4 = /\/+$/;
+var TRAILING_SLASHES5 = /\/+$/;
 var MAX_CONTRACT_ISSUES_SHOWN = 3;
 function formatContractIssues(issues) {
   if (!issues || issues.length === 0) {
@@ -45762,8 +46368,8 @@ function createCliClient({
   auth,
   fetchImpl = fetch
 }) {
-  const base = remote.replace(TRAILING_SLASHES4, "");
-  const appBase = (appRemote ?? remote).replace(TRAILING_SLASHES4, "");
+  const base = remote.replace(TRAILING_SLASHES5, "");
+  const appBase = (appRemote ?? remote).replace(TRAILING_SLASHES5, "");
   async function requestWithToken(url2, token, init) {
     try {
       return await fetchImpl(url2, {
@@ -57037,10 +57643,13 @@ set-game-start JSON: { "startingLocation": "<path|slug.location|null>",
   "openingInstructions": "...", "displayOrder": 0,
   "board": { "people": [{ "character": "<path|slug.character>", "side": "ally|enemy|neutral",
       "area": "...", "hidden": {"how":"unseen|sensed|disguised","as":"..."}, "note": "..." }],
-    "time": "...", "purpose": "...", "objectives": ["..."] },
+    "purpose": "...", "objectives": ["..."],
+    "trackers": [{ "key": "time", "on": true, "fields": [{ "kind": "text", "text": "Dusk" }] },
+      { "key": "<tracker key>", "on": true, "fields": [{ "kind": "count", "value": 2 }] }] },
   "gmNotes": "..." }
   (board and gmNotes are read by GM Harness V2: the opening board and the facts it
-  reads on its first turn instead of looking them up)
+  reads on its first turn instead of looking them up; the time it opens at is the
+  Time tracker's, key "time")
 
 set-gm-trigger JSON (triggered GM rules; name \u2264120 / body \u2264500 chars):
   {"triggerKind":"narrative","triggerPhases":["post_player_message"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftrpgs/cli",
-  "version": "0.2.0-alpha.1",
+  "version": "0.2.0-alpha.2",
   "description": "Sync Craft projects with a local folder — clone, edit with any coding agent, push back.",
   "license": "UNLICENSED",
   "homepage": "https://craftrpgs.com",
@@ -21,14 +21,14 @@
   "scripts": {
     "build": "bun run scripts/build.ts",
     "prepack": "bun run build",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "bun check"
   },
   "devDependencies": {
     "@craft/flow": "workspace:*",
     "@craft/shared": "workspace:*",
     "fflate": "^0.8.3",
     "typescript": "7.0.2",
-    "uuid": "11.1.0",
+    "uuid": "11.1.1",
     "zod": "4.3.6"
   }
 }