@craftrpgs/cli 0.2.0-alpha.0 → 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,7 @@ 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 = [
   {
     revision: 3,
@@ -26952,33 +27429,39 @@ var PLATFORM_OPTIONS = [
     }
   },
   {
-    revision: 2,
+    revision: 1,
     option: {
-      key: "platform-roll-numbers",
-      label: ROLL_NUMBERS,
-      description: "Whether the story repeats the dice. Rolls always show as dice cards in the chat.",
+      key: "platform-long-distance-travel",
+      label: LONG_TRAVEL,
+      description: "What happens when the party travels somewhere far away.",
       kind: "one",
-      default: ["left-out"],
+      default: ["up-to-gm"],
       choices: [
         {
-          key: "left-out",
-          label: "Exclude",
-          description: "The story tells what happens, not the numbers.",
+          key: "up-to-gm",
+          label: "Up to the GM",
+          description: "The Game Master decides when the road is worth playing.",
+          instructions: []
+        },
+        {
+          key: "fast-travel",
+          label: "Fast travel",
+          description: "Skip ahead to the destination, with the trip summed up.",
           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."
+              body: `When the party travels somewhere far (a trip of hours or more), take them straight there in the same reply: record it as arriving ("Move Kael and Mira to Harrowmere"), never "set out for", sum up the trip in a sentence or two (how long it took, how the way went), and go on from the arrival. When the player set out from the map, tell the arrival the same way.`
             }
           ]
         },
         {
-          key: "shown",
-          label: "Include",
-          description: "Each total in a short bracket where it lands.",
+          key: "journey",
+          label: "Journey",
+          description: "Travel there step by step, with the road played out.",
           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)."
+              body: `When the party travels somewhere far (a trip of hours or more), play it as a journey to where the player said they are going. Set out first ("Kael and Mira set out for Harrowmere by the coast road; it takes about three days"), then tell the way in stages over several replies, for as long as the distance really takes: the road and the weather, rests and camps, people and trouble met on the way, with time passing as it would ("It is now dusk"). The party stays on the way the whole time: a camp or a rest is told with the time it takes, never a move to a camp or a stretch of road. Someone met stops the journey where they meet; when the party goes on from there, record it as "Kael and Mira set out again for Harrowmere", never as a move farther along the road. Keep heading for the place the player named unless they change course, and record the arrival ("Move Kael and Mira to Harrowmere") only once the way has been travelled. When the player set out from the map, they are already on the way: go on with the journey.`
             }
           ]
         }
@@ -26995,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;
@@ -27011,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({
@@ -27082,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.";
   }
@@ -27106,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;
@@ -27167,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) {
@@ -27239,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;
@@ -27315,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(),
@@ -27340,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);
@@ -27375,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;
@@ -36444,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) {
@@ -36596,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);
@@ -40168,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",
@@ -41012,19 +41562,22 @@ var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V6 = "file-designation-metadata:v6"
 var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V7 = "file-designation-metadata:v7";
 var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V8 = "file-designation-metadata:v8";
 var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9 = "file-designation-metadata:v9";
+var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V10 = "file-designation-metadata:v10";
+var FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V11 = "file-designation-metadata:v11";
 var GAME_START_OPENING_MAX_LENGTH = 1e4;
 var GAME_START_MAX_OPENING_BEATS = 50;
 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",
@@ -41212,6 +41765,142 @@ var MapDataV6Schema = MapDataV5Schema.extend({
 var MapDataV8Schema = MapDataV6Schema.extend({
   grid: MapGridSchema.nullable().default(null)
 });
+var MAP_EXIT_KINDS = [
+  "door",
+  "gate",
+  "stairs",
+  "ladder",
+  "hatch",
+  "path",
+  "road",
+  "dock",
+  "portal",
+  "other"
+];
+var MAP_EXIT_DIRECTIONS = [
+  "up",
+  "down",
+  "in",
+  "out",
+  "through"
+];
+var MapExitSchema = exports_external.object({
+  kind: exports_external.enum(MAP_EXIT_KINDS).default("door"),
+  to: exports_external.string().uuid().nullable().default(null),
+  direction: exports_external.enum(MAP_EXIT_DIRECTIONS).optional(),
+  arriveAt: exports_external.string().uuid().nullable().optional(),
+  main: exports_external.boolean().optional(),
+  locked: exports_external.boolean().optional(),
+  hidden: exports_external.boolean().optional()
+});
+var MapAreaV10Schema = MapAreaSchema.extend({
+  exit: MapExitSchema.optional()
+});
+var MapPointV10Schema = MapPointSchema.extend({
+  exit: MapExitSchema.optional()
+});
+var MapDataV10Schema = MapDataV8Schema.extend({
+  areas: exports_external.array(MapAreaV10Schema),
+  points: exports_external.array(MapPointV10Schema)
+});
+var COMPASS_DIRECTIONS = [
+  "north",
+  "northeast",
+  "east",
+  "southeast",
+  "south",
+  "southwest",
+  "west",
+  "northwest"
+];
+var PLACE_WAY_KINDS = [
+  ...MAP_EXIT_KINDS,
+  "bridge",
+  "ferry",
+  "tunnel",
+  "ritual"
+];
+var PLACE_WAY_DIRECTIONS = [
+  ...MAP_EXIT_DIRECTIONS,
+  ...COMPASS_DIRECTIONS
+];
+var relationWords = (max) => exports_external.string().trim().min(1).max(max);
+var PlaceWaySchema = MapExitSchema.extend({
+  kind: exports_external.enum(PLACE_WAY_KINDS).default("door"),
+  direction: exports_external.enum(PLACE_WAY_DIRECTIONS).optional(),
+  oneWay: exports_external.boolean().optional(),
+  when: relationWords(200).optional(),
+  requires: relationWords(200).optional(),
+  by: exports_external.string().uuid().optional(),
+  label: relationWords(120).optional(),
+  distance: relationWords(60).optional(),
+  time: relationWords(60).optional()
+});
+var MapAreaV11Schema = MapAreaSchema.extend({
+  exit: PlaceWaySchema.optional()
+});
+var MapPointV11Schema = MapPointSchema.extend({
+  exit: PlaceWaySchema.optional()
+});
+var MapDataV11Schema = MapDataV8Schema.extend({
+  areas: exports_external.array(MapAreaV11Schema),
+  points: exports_external.array(MapPointV11Schema)
+});
+var RelationIdSchema = exports_external.string().uuid();
+var RelationTargetSchema = exports_external.string().uuid();
+var InsideRelationSchema = exports_external.object({
+  id: RelationIdSchema,
+  type: exports_external.literal("inside"),
+  to: RelationTargetSchema,
+  level: exports_external.number().int().min(-100).max(500).optional()
+});
+var ConnectsRelationSchema = PlaceWaySchema.extend({
+  id: RelationIdSchema,
+  type: exports_external.literal("connects")
+});
+var OtherRelationSchema = exports_external.object({
+  id: RelationIdSchema,
+  type: exports_external.literal("other"),
+  to: RelationTargetSchema,
+  label: relationWords(120)
+});
+var PlaceRelationSchema = exports_external.discriminatedUnion("type", [
+  InsideRelationSchema,
+  ConnectsRelationSchema,
+  OtherRelationSchema
+]);
+var MAX_PLACE_RELATIONS = 100;
+var TRANSPORT_KINDS = [
+  "ship",
+  "boat",
+  "airship",
+  "wagon",
+  "caravan",
+  "carriage",
+  "train",
+  "car",
+  "bus",
+  "plane",
+  "mount",
+  "other"
+];
+var TRANSPORT_MEDIUMS = [
+  "water",
+  "land",
+  "air",
+  "rail",
+  "underground",
+  "space"
+];
+var TransportMetadataSchema = exports_external.object({
+  kind: exports_external.enum(TRANSPORT_KINDS),
+  travels: exports_external.enum(TRANSPORT_MEDIUMS).optional(),
+  speed: exports_external.object({
+    value: exports_external.number().positive(),
+    unit: exports_external.enum(["mph", "km/h", "knots"])
+  }).optional(),
+  capacity: exports_external.number().int().positive().optional()
+});
 var GmInstructionTriggerPhaseSchema = exports_external.enum(GM_INSTRUCTION_TRIGGER_PHASES);
 var GmInstructionToolEventSchema = exports_external.enum(GM_INSTRUCTION_TOOL_EVENTS);
 var GmInstructionNarrativeMetadataSchema = exports_external.object({
@@ -41270,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;
@@ -41294,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("")
 });
@@ -41339,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),
@@ -41403,24 +42134,36 @@ var FileDesignationMetadataV9Schema = FileDesignationMetadataV8Schema.extend({
   schemaVersionId: exports_external.literal(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9).default(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9),
   script: ScriptMetadataSchema.optional()
 });
-var MapSchema = FileDesignationMetadataV9Schema.shape.map.unwrap();
-var LocationDesignationMetadataSchema = FileDesignationMetadataV9Schema.pick({
+var FileDesignationMetadataV10Schema = FileDesignationMetadataV9Schema.extend({
+  schemaVersionId: exports_external.literal(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V10).default(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V10),
+  map: MapDataV10Schema.optional(),
+  transport: TransportMetadataSchema.optional()
+});
+var FileDesignationMetadataV11Schema = FileDesignationMetadataV10Schema.extend({
+  schemaVersionId: exports_external.literal(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V11).default(FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V11),
+  map: MapDataV11Schema.optional(),
+  relations: exports_external.array(PlaceRelationSchema).max(MAX_PLACE_RELATIONS).optional()
+});
+var MapSchema = FileDesignationMetadataV11Schema.shape.map.unwrap();
+var LocationDesignationMetadataSchema = FileDesignationMetadataV11Schema.pick({
   schemaVersionId: true,
-  map: true
+  map: true,
+  transport: true,
+  relations: true
 });
-var CharacterDesignationMetadataSchema = FileDesignationMetadataV9Schema.pick({
+var CharacterDesignationMetadataSchema = FileDesignationMetadataV11Schema.pick({
   schemaVersionId: true,
   playable: true
 });
-var GmInstructionDesignationMetadataSchema = FileDesignationMetadataV9Schema.pick({
+var GmInstructionDesignationMetadataSchema = FileDesignationMetadataV11Schema.pick({
   schemaVersionId: true,
   gmInstruction: true
 });
-var GameStartDesignationMetadataSchema = FileDesignationMetadataV9Schema.pick({
+var GameStartDesignationMetadataSchema = FileDesignationMetadataV11Schema.pick({
   schemaVersionId: true,
   gameStart: true
 });
-var ScriptDesignationMetadataSchema = FileDesignationMetadataV9Schema.pick({
+var ScriptDesignationMetadataSchema = FileDesignationMetadataV11Schema.pick({
   schemaVersionId: true,
   script: true
 });
@@ -41428,10 +42171,17 @@ function upgradeFileDesignationMetadata(input) {
   if (input === null || input === undefined) {
     return null;
   }
-  if (readSchemaVersionId(input) === FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9) {
-    return FileDesignationMetadataV9Schema.parse(input);
+  const schemaVersionId = readSchemaVersionId(input);
+  if (schemaVersionId === FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V11) {
+    return FileDesignationMetadataV11Schema.parse(input);
+  }
+  if (schemaVersionId === FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V10) {
+    return upgradeV10MetadataToV11(FileDesignationMetadataV10Schema.parse(input));
+  }
+  if (schemaVersionId === FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9) {
+    return upgradeV10MetadataToV11(upgradeV9MetadataToV10(FileDesignationMetadataV9Schema.parse(input)));
   }
-  return upgradeV8MetadataToV9(upgradeMetadataToV8(input));
+  return upgradeV10MetadataToV11(upgradeV9MetadataToV10(upgradeV8MetadataToV9(upgradeMetadataToV8(input))));
 }
 function upgradeMetadataToV8(input) {
   const schemaVersionId = readSchemaVersionId(input);
@@ -41518,6 +42268,18 @@ function upgradeV8MetadataToV9(metadata) {
     schemaVersionId: FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V9
   });
 }
+function upgradeV9MetadataToV10(metadata) {
+  return FileDesignationMetadataV10Schema.parse({
+    ...metadata,
+    schemaVersionId: FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V10
+  });
+}
+function upgradeV10MetadataToV11(metadata) {
+  return FileDesignationMetadataV11Schema.parse({
+    ...metadata,
+    schemaVersionId: FILE_DESIGNATION_METADATA_SCHEMA_VERSION_V11
+  });
+}
 function normalizeLegacyDefaultGrid(map2) {
   if (map2.grid?.mode !== "default") {
     return map2;
@@ -41812,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. */
@@ -42798,7 +43616,7 @@ function parseMarkdown(source) {
   } catch {
     return { content: source };
   }
-  if (!isPlainObject2(parsed)) {
+  if (!isPlainObject3(parsed)) {
     return { content: body };
   }
   const file2 = { content: body };
@@ -42846,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
@@ -42859,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) {
@@ -42875,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("/")) {
@@ -42982,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}`);
   }
@@ -43680,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) {
@@ -44151,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];
@@ -44929,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");
@@ -44938,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() {
@@ -44993,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 {
@@ -45011,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}`;
@@ -45021,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))) {
@@ -45379,7 +46195,7 @@ async function refreshWorkspaceScriptTypes({
 // package.json
 var package_default = {
   name: "@craftrpgs/cli",
-  version: "0.2.0-alpha.0",
+  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",
@@ -45400,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"
   }
 };
@@ -45416,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) {
@@ -45439,6 +46255,17 @@ var cliMetaWriteResponseSchema = exports_external.object({
   version: exports_external.object({ id: exports_external.string().min(1) }),
   linkStateChanged: exports_external.boolean().optional()
 });
+var cliPlacePairWriteResponseSchema = exports_external.object({
+  changedFileIds: exports_external.array(exports_external.string().min(1))
+});
+var cliLinkedLocationsResponseSchema = exports_external.object({
+  parent: exports_external.object({ referenceId: exports_external.string() }).nullable(),
+  places: exports_external.array(exports_external.object({
+    referenceId: exports_external.string(),
+    name: exports_external.string(),
+    pair: exports_external.record(exports_external.string(), exports_external.unknown())
+  }))
+});
 var cliFileMetaResponseSchema = exports_external.object({
   currentVersion: exports_external.object({
     id: exports_external.string().min(1),
@@ -45541,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, {
@@ -45829,6 +46656,40 @@ function createCliClient({
     async putGmInstruction({ fileId, gmInstruction }) {
       return await putMetadata(`/api/files/${fileId}/gm-instruction`, { gmInstruction }, "GM instruction trigger save");
     },
+    async fetchLinkedLocations({ fileId }) {
+      const response = await request(`/api/files/${fileId}/relations`);
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        const { code, message, details } = await readErrorBody(response);
+        throw new CliApiError({
+          message,
+          code,
+          status: response.status,
+          exitCode: 1,
+          details
+        });
+      }
+      return await parseJson(response, cliLinkedLocationsResponseSchema, "linked locations");
+    },
+    async putFileTransport({ fileId, transport }) {
+      return await putMetadata(`/api/files/${fileId}/transport`, { transport }, "transport save");
+    },
+    async putPlacePair({ fileId, otherFileId, pair }) {
+      const response = await request(`/api/files/${fileId}/relations/${otherFileId}`, pair === null ? { method: "DELETE" } : { method: "PUT", body: JSON.stringify(pair) });
+      if (!response.ok) {
+        const { code, message, details } = await readErrorBody(response);
+        throw new CliApiError({
+          message,
+          code,
+          status: response.status,
+          exitCode: response.status === 400 || response.status === 422 ? 2 : 1,
+          details
+        });
+      }
+      return await parseJson(response, cliPlacePairWriteResponseSchema, "linked location save");
+    },
     async putDesignationFlag({ fileId, flag, value }) {
       return await putMetadata(`/api/files/${fileId}/designation`, { flag, value }, "designation flag save");
     },
@@ -48549,11 +49410,66 @@ async function runLogout(argv) {
 
 // src/commands/map.ts
 import { readFile as readFile11 } from "node:fs/promises";
+
+// src/commands/place-metadata.ts
+function pathOrId(ledger, referenceId) {
+  return referenceIdToPath({ ledger, referenceId }) ?? referenceId;
+}
+function exitForOutput(ledger, exit) {
+  return {
+    ...exit,
+    ...typeof exit.to === "string" ? { to: pathOrId(ledger, exit.to) } : {},
+    ...typeof exit.by === "string" ? { by: pathOrId(ledger, exit.by) } : {}
+  };
+}
+function relationsForOutput(ledger, relations) {
+  return relations.map((relation) => exitForOutput(ledger, relation));
+}
+function listMapExitsForOutput(ledger, map2) {
+  return [...map2.areas, ...map2.points].flatMap((element) => element.exit ? [
+    {
+      element: element.label ?? element.id,
+      ...exitForOutput(ledger, element.exit)
+    }
+  ] : []);
+}
+function resolveExitInput({
+  ledger,
+  exit,
+  where,
+  failures
+}) {
+  if (typeof exit !== "object" || exit === null || Array.isArray(exit)) {
+    return exit;
+  }
+  const record2 = { ...exit };
+  for (const key of ["to", "by"]) {
+    const value = record2[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const resolution = resolveLink({ ledger, link: value });
+    if (resolution.status === "resolved") {
+      record2[key] = resolution.referenceId;
+    } else {
+      failures.push({
+        where: `${where}.${key}`,
+        link: value,
+        reason: resolution.status
+      });
+    }
+  }
+  return record2;
+}
+
+// src/commands/map.ts
 var MAP_USAGE = `Usage: craft map get <location-path> [--json]
 ` + `       craft map set <location-path> --file <map.json>
 ` + `
-` + "The map JSON is the stored MapData shape; in `set` input, areas/points may\n" + 'use `"link": "<workspace path | slug.type | referenceId>"` instead of\n' + `fileReferenceId, and element ids are minted when omitted. Read
-` + ".craft/instructions/authoring-maps.md for the format and quality bar.";
+` + "The map JSON is the stored MapData shape; in `set` input, areas/points may\n" + 'use `"link": "<workspace path | slug.type | referenceId>"` instead of\n' + `fileReferenceId, and element ids are minted when omitted. An element's
+` + '`exit` (a door, stairs, a road to another location) takes `"to"` as a\n' + "workspace path too; no `to` is the way out to the parent map. `get` prints\n" + `links and exit targets as workspace paths. Read
+` + `.craft/instructions/authoring-maps.md for the format and
+` + ".craft/instructions/linking-locations.md for exits.";
 async function runMap(argv) {
   const [subcommand, ...rest] = argv;
   if (subcommand === "get") {
@@ -48575,16 +49491,22 @@ function hydrateMapForOutput(workspace, map2) {
     if (typeof element !== "object" || element === null) {
       return element;
     }
-    const record2 = element;
+    let record2 = element;
+    if (typeof record2.exit === "object" && record2.exit !== null) {
+      record2 = {
+        ...record2,
+        exit: exitForOutput(workspace.ledger, record2.exit)
+      };
+    }
     if (typeof record2.fileReferenceId !== "string") {
-      return element;
+      return record2;
     }
     const path = referenceIdToPath({
       ledger: workspace.ledger,
       referenceId: record2.fileReferenceId
     });
     if (!path) {
-      return element;
+      return record2;
     }
     const { fileReferenceId: _dropped, ...rest } = record2;
     return { ...rest, link: path };
@@ -48677,6 +49599,14 @@ function normalizeMapInput(workspace, raw) {
     if (record2.fileReferenceId === undefined) {
       record2.fileReferenceId = null;
     }
+    if (record2.exit !== undefined) {
+      record2.exit = resolveExitInput({
+        ledger: workspace.ledger,
+        exit: record2.exit,
+        where: `${kindLabel2}[${index}].exit`,
+        failures
+      });
+    }
     for (const [key, value] of Object.entries(defaults)) {
       if (record2[key] === undefined) {
         record2[key] = value;
@@ -48945,13 +49875,75 @@ function translateGameStartAuthoringInput({
   return input;
 }
 
+// ../shared/src/place-pairs.ts
+var PLACE_PAIR_KINDS = [
+  "same_place",
+  "contains",
+  "part_of",
+  "separate",
+  "other"
+];
+var PairWaySchema = PlaceWaySchema.omit({
+  to: true,
+  arriveAt: true,
+  main: true,
+  oneWay: true
+}).extend({
+  oneWay: exports_external.enum(["there", "back"]).optional()
+});
+var PairWordsSchema = exports_external.object({
+  text: exports_external.string().trim().min(1).max(120),
+  first: exports_external.enum(["a", "b"])
+});
+var PlacePairSchema = exports_external.object({
+  kind: exports_external.enum(PLACE_PAIR_KINDS),
+  parentRef: exports_external.string().uuid().optional(),
+  way: PairWaySchema.nullable(),
+  words: PairWordsSchema.nullable()
+});
+function placePairProblem({
+  pair,
+  aRef,
+  bRef
+}) {
+  if (aRef === bRef) {
+    return "A location can't be linked to itself.";
+  }
+  if (pair.kind === "same_place") {
+    if (!pair.parentRef) {
+      return "Pick the location they're both in.";
+    }
+    if (pair.parentRef === aRef || pair.parentRef === bRef) {
+      return "A location can't be inside itself.";
+    }
+  } else if (pair.parentRef) {
+    return "Only locations in one location name the location they're in.";
+  }
+  if (pair.kind === "separate" && !pair.way) {
+    return "Separate locations need a way between them.";
+  }
+  if (pair.kind === "other" && !pair.words) {
+    return "Say how they relate.";
+  }
+  if (pair.kind !== "other" && pair.words) {
+    return "Only something else has words of its own.";
+  }
+  return null;
+}
+
 // src/commands/meta.ts
+var PAIR_KIND_FIELD_RE = /^kind/;
 var META_USAGE = `Usage: craft meta get <path> [--json]
 ` + `       craft meta set-game-start <game-start-path> --file <json>
 ` + `       craft meta set-gm-trigger <gm-instruction-path> (--file <json> | --clear)
 ` + `       craft meta set-playable <character-path> <true|false>
+` + `       craft meta set-transport <location-path> (--file <json> | --clear)
+` + `       craft meta link <location-path> <other-location-path> --file <json>
+` + `       craft meta unlink <location-path> <other-location-path>
 ` + `
-` + "See .craft/instructions/making-it-playable.md for the JSON shapes.";
+` + `See .craft/instructions/making-it-playable.md for game starts, triggers and
+` + `playable, and .craft/instructions/linking-locations.md for transports and
+` + "linked locations. `get` on a location shows its transport, its linked\n" + "locations (read from both ends) and its map's exits, with workspace paths.";
 async function runMeta(argv) {
   const [subcommand, ...rest] = argv;
   if (subcommand === "get") {
@@ -48966,6 +49958,15 @@ async function runMeta(argv) {
   if (subcommand === "set-playable") {
     return await runSetPlayable(rest);
   }
+  if (subcommand === "set-transport") {
+    return await runSetTransport(rest);
+  }
+  if (subcommand === "link") {
+    return await runLink(rest, "link");
+  }
+  if (subcommand === "unlink") {
+    return await runLink(rest, "unlink");
+  }
   throw new CliError(META_USAGE, 2);
 }
 async function readJsonFile2(inputPath) {
@@ -49028,6 +50029,8 @@ async function runMetaGet(argv) {
   if (gameStart) {
     gameStart.startingLocationFileReferenceId = undefined;
   }
+  const isLocation = meta3.fileType?.designation === "location" || Boolean(parsed?.map || parsed?.transport || parsed?.relations);
+  const linkedLocations = isLocation ? await linkedLocationsForOutput(workspace, client, entry.fileId) : undefined;
   printJson({
     path,
     fileType: entry.fileType,
@@ -49039,11 +50042,38 @@ async function runMetaGet(argv) {
       areas: parsed.map.areas.length,
       points: parsed.map.points.length,
       useParentMap: parsed.map.useParentMap ?? false,
+      exits: listMapExitsForOutput(workspace.ledger, parsed.map),
       hint: "Full map via `craft map get`."
-    } : null
+    } : null,
+    ...isLocation ? {
+      transport: parsed?.transport ?? null,
+      relations: relationsForOutput(workspace.ledger, parsed?.relations ?? []),
+      ...linkedLocations === undefined ? {} : { linkedLocations }
+    } : {}
   });
   return 0;
 }
+async function linkedLocationsForOutput(workspace, client, fileId) {
+  const linked = await client.fetchLinkedLocations({ fileId });
+  if (!linked) {
+    return;
+  }
+  return linked.places.map((place) => {
+    const pair = place.pair;
+    return {
+      location: pathForReference(workspace, place.referenceId) ?? place.name,
+      relation: pair.kind,
+      ...pair.parentRef ? { in: pathForReference(workspace, pair.parentRef) } : {},
+      ...pair.way ? {
+        way: exitForOutput(workspace.ledger, pair.way)
+      } : {},
+      ...pair.words ? {
+        words: pair.words.text,
+        wordsFirst: pair.words.first === "a" ? "location" : "other"
+      } : {}
+    };
+  });
+}
 function projectOpeningForOutput(workspace, opening) {
   if (opening.kind !== "static" || !opening.beats?.length) {
     return opening;
@@ -49220,6 +50250,159 @@ async function runSetPlayable(argv) {
   printLines([`Set playable: ${value} on ${path}.`]);
   return 0;
 }
+async function runSetTransport(argv) {
+  const args = parseCommandArgs({
+    argv,
+    flags: {
+      file: { type: "string" },
+      clear: { type: "boolean" },
+      json: { type: "boolean" }
+    },
+    maxPositionals: 1
+  });
+  const path = args.positionals[0];
+  const inputPath = stringFlag(args, "file");
+  const clear = args.booleans.has("clear");
+  const exactlyOneMode = clear ? !inputPath : Boolean(inputPath);
+  if (!(path && exactlyOneMode)) {
+    throw new CliError(META_USAGE, 2);
+  }
+  let transport = null;
+  if (inputPath) {
+    const parsed = LocationDesignationMetadataSchema.shape.transport.unwrap().safeParse(await readJsonFile2(inputPath));
+    if (!parsed.success) {
+      throw new CliError(`The transport JSON failed validation:
+` + parsed.error.issues.map((issue3) => `  ${issue3.path.join(".") || "(root)"}: ${issue3.message}`).join(`
+`), 2);
+    }
+    transport = parsed.data;
+  }
+  const workspace = await loadWorkspaceContext();
+  const entry = resolveTrackedEntry({ ledger: workspace.ledger, input: path });
+  const client = await workspaceClient(workspace);
+  const result = await client.putFileTransport({
+    fileId: entry.fileId,
+    transport
+  });
+  await freshenLedgerAfterMetaWrite({
+    root: workspace.root,
+    ledger: workspace.ledger,
+    fileId: entry.fileId,
+    versionId: result.version.id
+  });
+  if (args.booleans.has("json")) {
+    printJson({ path, saved: true, transport });
+    return 0;
+  }
+  printLines([
+    transport ? `Saved transport on ${path}: ${transport.kind}${transport.travels ? ` (${transport.travels})` : ""}.` : `Cleared transport on ${path}.`
+  ]);
+  return 0;
+}
+function translatePlacePairInput({
+  workspace,
+  raw,
+  aRef,
+  bRef
+}) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new CliError("The link JSON must be a single object.", 2);
+  }
+  const input = raw;
+  const failures = [];
+  let parentRef;
+  if (typeof input.in === "string") {
+    const resolution = resolveLink({
+      ledger: workspace.ledger,
+      link: input.in
+    });
+    if (resolution.status === "resolved") {
+      parentRef = resolution.referenceId;
+    } else {
+      failures.push({ where: "in", link: input.in, reason: resolution.status });
+    }
+  }
+  const way = input.way === undefined || input.way === null ? null : resolveExitInput({
+    ledger: workspace.ledger,
+    exit: input.way,
+    where: "way",
+    failures
+  });
+  if (failures.length > 0) {
+    throw new CliError(`Nothing was saved — some links do not resolve to pushed files:
+` + failures.map((failure2) => `  ${failure2.where}: "${failure2.link}"` + `${failure2.reason === "unpushed" ? " (tracked but not pushed yet)" : " (no tracked file matches)"}`).join(`
+`), 2);
+  }
+  const parsedWay = way === null ? null : PairWaySchema.safeParse(way);
+  const parsed = PlacePairSchema.safeParse({
+    kind: input.relation,
+    ...parentRef ? { parentRef } : {},
+    way: parsedWay?.success ? parsedWay.data : way,
+    words: typeof input.words === "string" ? { text: input.words, first: input.wordsFirst === "other" ? "b" : "a" } : null
+  });
+  if (!parsed.success) {
+    throw new CliError(`The link JSON failed validation:
+` + parsed.error.issues.map((issue3) => {
+      const field = issue3.path.join(".").replace(PAIR_KIND_FIELD_RE, "relation");
+      return `  ${field || "(root)"}: ${issue3.message}`;
+    }).join(`
+`), 2);
+  }
+  const problem = placePairProblem({ pair: parsed.data, aRef, bRef });
+  if (problem) {
+    throw new CliError(problem, 2);
+  }
+  return parsed.data;
+}
+async function runLink(argv, mode) {
+  const args = parseCommandArgs({
+    argv,
+    flags: { file: { type: "string" }, json: { type: "boolean" } },
+    maxPositionals: 2
+  });
+  const [path, otherPath] = args.positionals;
+  const inputPath = stringFlag(args, "file");
+  if (!(path && otherPath) || mode === "link" !== Boolean(inputPath)) {
+    throw new CliError(META_USAGE, 2);
+  }
+  const workspace = await loadWorkspaceContext();
+  const entry = resolveTrackedEntry({ ledger: workspace.ledger, input: path });
+  const other = resolveTrackedEntry({
+    ledger: workspace.ledger,
+    input: otherPath
+  });
+  const pair = inputPath ? translatePlacePairInput({
+    workspace,
+    raw: await readJsonFile2(inputPath),
+    aRef: entry.referenceId,
+    bRef: other.referenceId
+  }) : null;
+  const client = await workspaceClient(workspace);
+  const { changedFileIds } = await client.putPlacePair({
+    fileId: entry.fileId,
+    otherFileId: other.fileId,
+    pair
+  });
+  for (const fileId of changedFileIds) {
+    const meta3 = await client.fetchFileMeta({ fileId });
+    await freshenLedgerAfterMetaWrite({
+      root: workspace.root,
+      ledger: workspace.ledger,
+      fileId,
+      versionId: meta3.currentVersion.id
+    });
+  }
+  if (args.booleans.has("json")) {
+    printJson({ path, other: otherPath, saved: true, pair, changedFileIds });
+    return 0;
+  }
+  const changed = changedFileIds.length === 0 ? "nothing changed" : `${changedFileIds.length} location${changedFileIds.length === 1 ? "" : "s"} changed`;
+  printLines([
+    mode === "link" ? `Linked ${path} and ${otherPath} (${pair?.kind}): ${changed}.` : `Unlinked ${path} and ${otherPath}: ${changed}.`,
+    "See where each location now sits with `craft meta get`."
+  ]);
+  return 0;
+}
 
 // src/commands/mv.ts
 import { existsSync as existsSync8 } from "node:fs";
@@ -56055,9 +57238,12 @@ var HELP_COMMAND_LINES = `  clone <projectIdOrUrl> [dir]   Download a project as
   map get|set <location-path>    Read/author the interactive map stored on a
                                  location file (see "craft help map")
   meta get <path>                Show a file's designation metadata (game start
-                                 config, GM triggers, playable flag, map summary)
+                                 config, GM triggers, playable flag, map summary,
+                                 a location's transport and linked locations)
   meta set-game-start|set-gm-trigger|set-playable
                                  Configure playability metadata (see "craft help meta")
+  meta set-transport|link|unlink Make a location a ship/caravan, or link two
+                                 locations (see "craft help meta")
   vn list|create|pull|check|push|publish|assets
                                  Write visual novels: pull a story to a JSON
                                  file, edit it, push it back, publish it
@@ -56389,6 +57575,10 @@ Authoring format = the stored MapData shape with conveniences:
 - element "id"s are minted when omitted; point style defaults are applied.
 - required: "aspectRatio" matching the background image (4:3 for a default
   landscape-4-3 generation). background/scale/grid default to null.
+- an area/point may carry "exit": a way to another location, e.g.
+  {"kind":"stairs","to":"Places/The Inn Upstairs.location.json","direction":"up"}.
+  "to" takes a workspace path (or slug.type / referenceId); leave it out for
+  the way out to the parent map. \`get\` prints links and exit "to"s as paths.
 
 The background image URL must be Craft-hosted \u2014 generate one with
 \`craft image generate\` (or upload with \`craft image upload\`) and paste
@@ -56440,6 +57630,9 @@ chapters, where cutouts stand (desktop and phone), and pictures on pages.
        craft meta set-game-start <game-start-path> --file <json>
        craft meta set-gm-trigger <gm-instruction-path> (--file <json> | --clear)
        craft meta set-playable <character-path> <true|false>
+       craft meta set-transport <location-path> (--file <json> | --clear)
+       craft meta link <location-path> <other-location-path> --file <json>
+       craft meta unlink <location-path> <other-location-path>
 
 Designation metadata is app-managed and lives outside the working tree;
 these commands write the server directly (the target file must be pushed).
@@ -56450,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"]}
@@ -56461,6 +57657,23 @@ set-gm-trigger JSON (triggered GM rules; name \u2264120 / body \u2264500 chars):
 
 Read .craft/instructions/making-it-playable.md for how these fit together.
 
+set-transport JSON (a location that carries people; its deck plan is its map):
+  {"kind":"ship","travels":"water","speed":{"value":6,"unit":"knots"},"capacity":40}
+  kind: ship|boat|airship|wagon|caravan|carriage|train|car|bus|plane|mount|other
+
+link JSON \u2014 how <location> relates to <other>, the shape \`meta get\` prints
+under linkedLocations (it replaces whatever lay between the two):
+  {"relation":"part_of","way":{"kind":"stairs","direction":"up"}}
+  relation: same_place (both parts of "in": "<path>") | contains (other is part
+  of location) | part_of (location is part of other) | separate (needs "way") |
+  other (needs "words": "is the Shadowfell reflection of", "wordsFirst":
+  "location"|"other"). way: {kind, direction from location, oneWay:
+  "there"|"back", locked, hidden, when, requires, label, distance, time}.
+  A location is inside at most one place and never inside itself; linking can
+  move a place in or out of another. unlink removes everything between them.
+Read .craft/instructions/linking-locations.md for exits, transports and
+linked locations.
+
 upload: send a local image file (max 10MB; 50 per 24h, 1,000 per 24h for
 subscribers) to the project's media
 storage; the server re-encodes it to webp and returns the same pasteable