@scrthq/runlog 0.0.39 → 0.0.41

package/README.md

@@ -7,6 +7,7 @@ release, and issue sealed copies to buyers.
 ```bash
 npx @scrthq/runlog validate my-game.yaml --strict
 npx @scrthq/runlog test my-game.yaml
+npx @scrthq/runlog docs my-game.yaml -o dist/docs   # rulebook, quick start, reference card, run log sheet, summary
 npx @scrthq/runlog keygen -o my-key.json
 npx @scrthq/runlog sign my-game.yaml --key my-key.json --as "Your Name"
 npx @scrthq/runlog issue my-game.yaml --to "Buyer" --ref order-1 --key my-key.json --seal

package/dist/runlog.js

@@ -7369,8 +7369,8 @@ var require_dist = __commonJS({
 
 // packages/cli/src/bin.ts
 var import_yaml4 = __toESM(require_dist(), 1);
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
-import { basename, dirname, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "node:fs";
+import { basename as basename2, dirname, resolve as resolve4 } from "node:path";
 import { createHash } from "node:crypto";
 
 // node_modules/zod/v4/classic/external.js
@@ -17794,8 +17794,8 @@ var error43 = () => {
       case "not_multiple_of":
         return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
       case "unrecognized_keys": {
-        const plural = issue2.keys.length > 1 ? "s" : "";
-        return `Chave${plural} inv\xE1lida${plural}: ${joinValues(issue2.keys, ", ")}`;
+        const plural2 = issue2.keys.length > 1 ? "s" : "";
+        return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
       }
       case "invalid_key":
         return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
@@ -17937,8 +17937,8 @@ var error44 = () => {
       case "not_multiple_of":
         return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
       case "unrecognized_keys": {
-        const plural = issue2.keys.length > 1 ? "s" : "";
-        return `Chave${plural} inv\xE1lida${plural}: ${joinValues(issue2.keys, ", ")}`;
+        const plural2 = issue2.keys.length > 1 ? "s" : "";
+        return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
       }
       case "invalid_key":
         return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
@@ -20135,9 +20135,9 @@ function codePointLengthVar(doc, ctx, accessor, inDoubt) {
   doc.write(`const ${v} = typeof ${accessor} === "string" && ${inDoubt} ? ${cpLen}(${accessor}) : ${accessor}.length;`);
   return v;
 }
-function numericOperand(value, label) {
+function numericOperand(value, label2) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new ZodCompileUnsupportedError(`${label} bound of type ${typeof value}`);
+    throw new ZodCompileUnsupportedError(`${label2} bound of type ${typeof value}`);
   }
   return `${value}`;
 }
@@ -26617,7 +26617,7 @@ var Deck = external_exports.discriminatedUnion("kind", [
     ),
     resolveBy: external_exports.enum(["rank", "suit"]).default("rank").describe("Whether the draw's rank or its suit selects the table entry.")
   }).strict().describe(
-    "A standard 52-card deck. Included because a whole family of solo journalling games is built on drawing from one."
+    "A standard 52-card deck. Included because a whole family of solo journaling games is built on drawing from one."
   )
 ]).describe("A deck the game draws from.");
 
@@ -26794,7 +26794,7 @@ var JournalDef = external_exports.object({
   prompt: external_exports.string().optional().describe("The question shown above the note field."),
   required: external_exports.boolean().default(false).describe("Require a note before a unit can be closed.")
 }).strict().describe(
-  "Free-text notes attached to units. Essential for journalling games, and useful anywhere, since a log of rolls alone does not tell you what you actually made."
+  "Free-text notes attached to units. Essential for journaling games, and useful anywhere, since a log of rolls alone does not tell you what you actually made."
 );
 var EndingDef = external_exports.object({
   id: Id.describe("Unique among endings."),
@@ -27524,13 +27524,13 @@ function lintPack(pack) {
     }
   }
   const claimed = new Set(pack.capabilities);
-  const requireCap = (cap, used, why) => {
-    if (used && !claimed.has(cap)) {
+  const requireCap = (cap2, used, why) => {
+    if (used && !claimed.has(cap2)) {
       d.push(
         warn(
           "capability/undeclared",
           "capabilities",
-          `pack ${why} but does not declare the "${cap}" capability`
+          `pack ${why} but does not declare the "${cap2}" capability`
         )
       );
     }
@@ -27638,12 +27638,12 @@ function parsePack(input2) {
   const unsupported = pack.capabilities.filter(
     (c) => !IMPLEMENTED_CAPABILITIES.includes(c)
   );
-  for (const cap of unsupported) {
+  for (const cap2 of unsupported) {
     diagnostics.push({
       level: "error",
       code: "pack/unsupported-capability",
       path: "capabilities",
-      message: `pack requires the "${cap}" capability, which this build does not implement`
+      message: `pack requires the "${cap2}" capability, which this build does not implement`
     });
   }
   if (hasErrors(diagnostics)) return { ok: false, pack: null, diagnostics };
@@ -27885,6 +27885,830 @@ async function verifyPack(document) {
   }
 }
 
+// packages/rules-schema/src/describe.ts
+function entryKeys(table) {
+  switch (table.resolution) {
+    case "lookup":
+      return table.entries.map((e) => e.range[0] === e.range[1] ? `${e.range[0]}` : `${e.range[0]}\u2013${e.range[1]}`);
+    case "bands":
+      return table.entries.map(
+        (e) => [e.gte !== void 0 ? `\u2265${e.gte}` : "", e.lte !== void 0 ? `\u2264${e.lte}` : ""].filter(Boolean).join(" ")
+      );
+    case "opposed":
+      return table.entries.map((e) => `beats ${e.beats}`);
+    case "keyed":
+      return table.entries.map((e) => e.key);
+  }
+}
+function howConsulted(table) {
+  switch (table.resolution) {
+    case "lookup":
+      return `Roll ${table.roll}.`;
+    case "bands":
+      return `Roll ${table.roll} and find the band it lands in.`;
+    case "opposed":
+      return `Roll ${table.action}${table.addResource ? ` and add ${table.addResource}` : ""} against ${table.challenge.count} \xD7 ${table.challenge.dice}; count how many of the challenge dice your total beats.`;
+    case "keyed":
+      return "Find the row whose key matches what was drawn.";
+  }
+}
+function nouns(pack) {
+  const v = pack.vocabulary;
+  return {
+    run: v.run.one,
+    runs: v.run.many,
+    unit: v.unit.one,
+    units: v.unit.many,
+    subject: v.subject.one,
+    subjects: v.subject.many,
+    finalize: v.finalize
+  };
+}
+var label = (pack, kind, id) => {
+  const entry = pack[kind]?.[id];
+  return entry?.label ?? entry?.title ?? id;
+};
+function targetInWords(pack, to) {
+  const n = nouns(pack);
+  if (to === void 0) return `this ${n.subject}`;
+  if (typeof to === "object") return `the ${n.subject} chosen as \u201C${to.var}\u201D`;
+  switch (to) {
+    case "thisSubject":
+      return `this ${n.subject}`;
+    case "targetSubject":
+      return `the target`;
+    case "allSubjects":
+      return `every ${n.subject}`;
+    case "allPriorSubjects":
+      return `every earlier ${n.subject}`;
+    case "run":
+      return `the ${n.run}`;
+  }
+}
+function boundInWords(pack, b) {
+  const parts = [];
+  if (b.eq !== void 0) parts.push(`exactly ${b.eq}`);
+  if (b.gte !== void 0 && b.lte !== void 0) parts.push(`between ${b.gte} and ${b.lte}`);
+  else {
+    if (b.gte !== void 0) parts.push(`${b.gte} or more`);
+    if (b.lte !== void 0) parts.push(`${b.lte} or fewer`);
+  }
+  if (b.gteCounter !== void 0) parts.push(`at least the ${label(pack, "counters", b.gteCounter)} tally`);
+  if (b.lteCounter !== void 0) parts.push(`no more than the ${label(pack, "counters", b.lteCounter)} tally`);
+  return parts.join(" and ");
+}
+function predicateInWords(pack, p) {
+  const n = nouns(pack);
+  if ("ask" in p) return `you answer yes to \u201C${p.ask}\u201D`;
+  if ("unitIndex" in p) return p.unitIndex.eq !== void 0 ? `this is ${n.unit} ${p.unitIndex.eq}` : `the ${n.unit} number is ${boundInWords(pack, p.unitIndex)}`;
+  if ("subjectCount" in p) return `there are ${boundInWords(pack, p.subjectCount)} ${n.subjects}`;
+  if ("eligibleTargets" in p) return `there are ${boundInWords(pack, p.eligibleTargets)} ${n.subjects} that can be targeted`;
+  if ("counter" in p) return `${label(pack, "counters", p.counter)} is ${boundInWords(pack, p.is)}`;
+  if ("resource" in p) return `${label(pack, "resources", p.resource)} is ${boundInWords(pack, p.is)}`;
+  if ("flag" in p) return `${p.flag} is ${p.is === false ? "not " : ""}set`;
+  if ("subjectHasState" in p) return `${targetInWords(pack, p.of)} is ${label(pack, "states", p.subjectHasState)}`;
+  if ("priorSubjectTagged" in p) return `an earlier ${n.subject} was tagged \u201C${p.priorSubjectTagged}\u201D`;
+  if ("modeIs" in p) return `playing ${p.modeIs.map((m) => label(pack, "modes", m)).join(" or ")}`;
+  if ("not" in p) return `not (${predicateInWords(pack, p.not)})`;
+  if ("allOf" in p) return p.allOf.map((q) => predicateInWords(pack, q)).join(" and ");
+  if ("anyOf" in p) return p.anyOf.map((q) => predicateInWords(pack, q)).join(" or ");
+  return "";
+}
+function conditionsInWords(pack, preds, joiner = "all") {
+  if (!preds || preds.length === 0) return "";
+  return preds.map((p) => predicateInWords(pack, p)).join(joiner === "all" ? " and " : ", or ");
+}
+var signed = (by, set2) => set2 !== void 0 ? `set to ${set2}` : by === void 0 ? "+1" : by >= 0 ? `+${by}` : `\u2212${Math.abs(by)}`;
+function actionInWords(pack, a) {
+  const n = nouns(pack);
+  switch (a.do) {
+    case "roll":
+      return a.label ? `${a.label} (${a.dice})` : `roll ${a.dice}`;
+    case "rollOn": {
+      const t = label(pack, "tables", a.table);
+      if (a.times && a.times > 1) return `roll ${a.times} times on ${t}${a.choose === "one" ? " and keep one" : ""}`;
+      return `roll on ${t}`;
+    }
+    case "branch": {
+      const cases = a.cases.map((c) => {
+        const cond = c.in ? `on ${c.in.join(", ")}` : c.is ? boundInWords(pack, c.is) : "otherwise";
+        return `${cond} \u2192 ${actionsInWords(pack, c.then)}`;
+      });
+      if (a.else) cases.push(`otherwise \u2192 ${actionsInWords(pack, a.else)}`);
+      return `then, by the result: ${cases.join("; ")}`;
+    }
+    case "prompt":
+      return a.label;
+    case "resolveTarget":
+      return `pick the target${a.from === "choice" ? " yourself" : a.from === "event" ? " by the pack's targeting rule" : " from the roll"}`;
+    case "applyState":
+      return `mark ${targetInWords(pack, a.to)} ${label(pack, "states", a.state)}`;
+    case "removeState":
+      return `clear ${label(pack, "states", a.state)} from ${targetInWords(pack, a.to)}`;
+    case "removeSubject":
+      return `remove ${targetInWords(pack, a.to)} from play`;
+    case "ban":
+      return a.label ?? (a.subjectType ? `no more ${a.subjectType} ${n.subjects} this ${n.run}` : `no more ${n.subjects} of ${targetInWords(pack, a.from)}'s kind this ${n.run}`);
+    case "forceUnit": {
+      const c = a.count ?? 1;
+      return `add ${c} more ${c === 1 ? n.unit : n.units} before the ${n.run} may end`;
+    }
+    case "modCounter":
+      return `${label(pack, "counters", a.counter)} ${signed(a.by, a.set)}`;
+    case "modResource":
+      return `${label(pack, "resources", a.resource)} ${signed(a.by, a.set)}`;
+    case "grantCard": {
+      const c = a.count ?? 1;
+      return `draw ${c} from ${label(pack, "decks", a.deck)}`;
+    }
+    case "discardCard": {
+      const c = a.count ?? 1;
+      return `discard ${c} from ${label(pack, "decks", a.deck)}`;
+    }
+    case "startTimer":
+      return a.label ? `${a.label} (${a.minutes} min)` : `start a ${a.minutes}-minute timer`;
+    case "note":
+      return a.text;
+    case "setFlag":
+      return a.value === false ? `unset ${a.flag}` : `set ${a.flag}`;
+    case "endRunAttempt":
+      return `try to end the ${n.run}`;
+    case "when": {
+      const then = `if ${conditionsInWords(pack, a.all)}: ${actionsInWords(pack, a.then)}`;
+      return a.else ? `${then}; otherwise ${actionsInWords(pack, a.else)}` : then;
+    }
+  }
+}
+function actionsInWords(pack, actions) {
+  return actions.map((a) => unstop(actionInWords(pack, a))).join("; ");
+}
+function unstop(s) {
+  return s.replace(/\.\s*$/, "");
+}
+function sentence(s) {
+  const t = s.trim();
+  return /[.!?…]$/.test(t) ? t : `${t}.`;
+}
+function triggerPointInWords(pack, on) {
+  const n = nouns(pack);
+  switch (on) {
+    case "immediately":
+      return "Then";
+    case "onEnterUnit":
+      return `When a ${n.unit} begins`;
+    case "onDeclareSubject":
+      return `When the ${n.subject} is declared`;
+    case "afterWork":
+      return "After the work";
+    case "onFinalize":
+      return `When you ${n.finalize}`;
+    case "onDeclareRunOver":
+      return `When you declare the ${n.run} over`;
+    case "onRunEnd":
+      return `When the ${n.run} ends`;
+  }
+}
+function triggerInWords(pack, t) {
+  const when = conditionsInWords(pack, t.when);
+  const head = t.label ? `${t.label} \u2014 ${triggerPointInWords(pack, t.on).toLowerCase()}` : triggerPointInWords(pack, t.on);
+  return `${head}${when ? ` (if ${when})` : ""}: ${actionsInWords(pack, t.do)}`;
+}
+function modeLength(pack, mode) {
+  const n = nouns(pack);
+  const u = mode.units;
+  if (u?.fixed !== void 0) return `${u.fixed} ${u.fixed === 1 ? n.unit : n.units}`;
+  if (u?.roll) return `roll ${u.roll} for the number of ${n.units}`;
+  if (u?.min !== void 0 && u?.max !== void 0) return `${u.min}\u2013${u.max} ${n.units}`;
+  if (u?.max !== void 0) return `up to ${u.max} ${n.units}`;
+  if (u?.min !== void 0) return `at least ${u.min} ${n.units}`;
+  const max = pack.unit.max;
+  return `as many ${n.units} as you like${max ? `, up to ${max}` : ""}`;
+}
+function modePlayers(mode) {
+  const p = mode.players;
+  if (!p || p.min <= 1 && p.max <= 1) return "solo";
+  return p.min === p.max ? `${p.min} players` : `${p.min}\u2013${p.max} players`;
+}
+var diceOf = (expr) => {
+  const m = /^(\d*)d(\d+)/.exec(expr);
+  return m ? `d${m[2]}` : expr;
+};
+function diceNeeded(pack) {
+  const found = /* @__PURE__ */ new Set();
+  const seeActions = (actions) => {
+    for (const a of actions ?? []) {
+      if (a.do === "roll") found.add(diceOf(a.dice));
+      if (a.do === "branch") {
+        for (const c of a.cases) seeActions(c.then);
+        seeActions(a.else);
+      }
+      if (a.do === "when") {
+        seeActions(a.then);
+        seeActions(a.else);
+      }
+    }
+  };
+  const seeTriggers = (triggers) => {
+    for (const t of triggers ?? []) seeActions(t.do);
+  };
+  for (const table of Object.values(pack.tables)) {
+    if (table.resolution === "lookup" || table.resolution === "bands") found.add(diceOf(table.roll));
+    if (table.resolution === "opposed") {
+      found.add(diceOf(table.action));
+      found.add(diceOf(table.challenge.dice));
+    }
+    for (const e of table.entries) seeTriggers(e.triggers);
+  }
+  for (const deck of Object.values(pack.decks ?? {})) if (deck.kind === "cards") for (const c of deck.cards) seeTriggers(c.triggers);
+  for (const c of Object.values(pack.counters ?? {})) for (const t of c.triggers ?? []) seeActions(t.do);
+  for (const m of Object.values(pack.moves ?? {})) seeActions(m.do);
+  for (const m of Object.values(pack.modes)) {
+    if (m.units?.roll) found.add(diceOf(m.units.roll));
+    for (const p of m.perUnit ?? []) seeActions(p.extra);
+  }
+  for (const p of pack.phases) for (const s of p.steps) if (s.kind === "actions") seeActions(s.do);
+  seeTriggers(pack.triggers);
+  if (pack.targeting?.strategy === "anchoredOffset" && pack.targeting.eventFallback) found.add(diceOf(pack.targeting.eventFallback.roll));
+  return [...found].sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
+}
+function diceInWords(dice) {
+  const names = dice.map((d) => d === "d100" ? "percentile dice (d100)" : `a ${d}`);
+  if (names.length === 0) return "";
+  if (names.length === 1) return names[0];
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+
+// packages/rules-schema/src/docs.ts
+var DOC_KINDS = [
+  { kind: "summary", label: "Summary", what: "What a catalog shows: the shape of the game without its rules.", full: false },
+  { kind: "rulebook", label: "Rulebook", what: "Everything, in reading order: setup, flow, every table, every rule.", full: true },
+  { kind: "quickstart", label: "Quick start", what: "Enough to play the first time; the rest is on the reference card.", full: true },
+  { kind: "reference", label: "Reference card", what: "Every table and the things people forget, compact enough to keep beside you.", full: true },
+  { kind: "runlog", label: "Run log sheet", what: "A printable sheet to write a run on by hand.", full: true }
+];
+var Builder = class {
+  blocks = [];
+  h(level, text) {
+    this.blocks.push({ kind: "heading", level, text });
+    return this;
+  }
+  p(text, tone) {
+    if (text && text.trim()) this.blocks.push(tone ? { kind: "paragraph", text: text.trim(), tone } : { kind: "paragraph", text: text.trim() });
+    return this;
+  }
+  list(items, ordered = false) {
+    if (items.length > 0) this.blocks.push(ordered ? { kind: "list", items, ordered } : { kind: "list", items });
+    return this;
+  }
+  table(columns, rows, compact = false) {
+    if (rows.length > 0) this.blocks.push(compact ? { kind: "table", columns, rows, compact } : { kind: "table", columns, rows });
+    return this;
+  }
+  terms(items) {
+    if (items.length > 0) this.blocks.push({ kind: "terms", items });
+    return this;
+  }
+  form(fields) {
+    this.blocks.push({ kind: "form", fields });
+    return this;
+  }
+  rule() {
+    this.blocks.push({ kind: "rule" });
+    return this;
+  }
+  page() {
+    this.blocks.push({ kind: "pagebreak" });
+    return this;
+  }
+};
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+var cap = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
+function stepInWords(pack, step) {
+  const n = nouns(pack);
+  switch (step.kind) {
+    case "rollTable":
+      return `${step.label ?? `Roll on ${pack.tables[step.table]?.title ?? step.table}`}${step.optional ? " (optional)" : ""}`;
+    case "declareSubject":
+      return step.label ?? `Declare the ${n.subject}${step.constrainedBy ? `, within what ${pack.tables[step.constrainedBy]?.title ?? step.constrainedBy} allowed` : ""}`;
+    case "manual":
+      return step.label;
+    case "actions":
+      return sentence(cap(actionsInWords(pack, step.do)));
+    case "finalizeUnit":
+      return step.label ?? `${n.finalize} the ${n.unit}`;
+  }
+}
+var checklistText = (item) => typeof item === "string" ? item : item.text;
+function stepDetail(pack, step) {
+  const out = [];
+  if (step.kind === "manual") {
+    if (step.description) out.push(step.description);
+    for (const c of step.checklist ?? []) out.push(`\u2610 ${checklistText(c)}`);
+  }
+  if (step.kind === "finalizeUnit") for (const c of step.confirm ?? []) out.push(`\u2610 ${checklistText(c)}`);
+  if ("skipWhen" in step && step.skipWhen?.length) out.push(`Skipped when ${conditionsInWords(pack, step.skipWhen, "any")}.`);
+  return out;
+}
+function whatYouNeed(pack) {
+  const n = nouns(pack);
+  const items = [];
+  const dice = diceInWords(diceNeeded(pack));
+  if (dice) items.push(cap(dice) + ".");
+  for (const deck of Object.values(pack.decks ?? {})) {
+    if (deck.kind === "standard52") items.push(`A standard deck of playing cards${deck.includeJokers ? " with the jokers in" : ""}.`);
+    else items.push(`${plural(deck.cards.length, "card", "cards")} for ${deck.title} \u2014 write them out, or use the app.`);
+  }
+  if (pack.capabilities.includes("timers")) items.push("A timer.");
+  items.push(pack.journal?.enabled === false ? `Somewhere to keep the ${n.run} log.` : `Somewhere to keep the ${n.run} log \u2014 the run log sheet, or the app.`);
+  return items;
+}
+function flowSteps(pack, opts) {
+  const items = [];
+  for (const phase of pack.phases) {
+    const head = phase.steps.length === 1 ? `${phase.label}: ${stepInWords(pack, phase.steps[0])}` : phase.label;
+    const notes = [];
+    if (opts.detail && phase.description) notes.push(phase.description);
+    if (opts.detail && phase.skipWhen?.length) notes.push(`Skipped when ${conditionsInWords(pack, phase.skipWhen, "any")}.`);
+    if (phase.steps.length > 1) for (const s of phase.steps) notes.push(`${stepInWords(pack, s)}${opts.detail ? stepDetail(pack, s).map((d) => ` \u2014 ${d}`).join("") : ""}`);
+    else if (opts.detail) notes.push(...stepDetail(pack, phase.steps[0]));
+    items.push([head, ...notes.map((t) => `  ${t}`)].join("\n"));
+  }
+  return items;
+}
+function modeRows(pack, opts) {
+  return Object.entries(pack.modes).map(([id, m]) => [
+    `${m.label}${id === pack.defaultMode ? " (default)" : ""}`,
+    modeLength(pack, m),
+    modePlayers(m) + (m.seeded ? ", seeded" : ""),
+    [m.description ?? "", ...opts.notes ? modeExtras(pack, m) : []].filter(Boolean).join(" ")
+  ]);
+}
+function modeExtras(pack, m) {
+  const n = nouns(pack);
+  const out = [];
+  for (const note of m.notes ?? []) out.push(note);
+  const off = [
+    ...(m.disable?.tables ?? []).map((t) => pack.tables[t]?.title ?? t),
+    ...(m.disable?.decks ?? []).map((d) => pack.decks?.[d]?.title ?? d),
+    ...(m.disable?.counters ?? []).map((c) => pack.counters?.[c]?.label ?? c),
+    ...(m.disable?.phases ?? []).map((p) => pack.phases.find((x) => x.id === p)?.label ?? p)
+  ];
+  if (off.length) out.push(`Without ${off.join(", ")}.`);
+  for (const p of m.perUnit ?? []) {
+    const which = p.unit === "all" ? `Every ${n.unit}` : `${cap(n.unit)} ${p.unit}`;
+    const skip = (p.skipPhases ?? []).map((id) => pack.phases.find((x) => x.id === id)?.label ?? id);
+    const parts = [skip.length ? `skips ${skip.join(", ")}` : "", p.extra?.length ? actionsInWords(pack, p.extra) : ""].filter(Boolean);
+    if (parts.length) out.push(sentence(`${which}: ${parts.join("; ")}`));
+  }
+  for (const r of m.players?.roles ?? []) out.push(`${r.label}: ${r.description ?? ""}`.trim());
+  return out;
+}
+function tableRows(pack, table, opts) {
+  const keys = entryKeys(table);
+  return table.entries.map((e, i) => {
+    const extras = [];
+    if (opts.full) {
+      for (const g of e.grants ?? []) extras.push(`\u2192 ${pack.states?.[g]?.label ?? g}`);
+      for (const t of e.triggers ?? []) extras.push(sentence(triggerInWords(pack, t)));
+      if (e.requires?.length) extras.push(`Only if ${conditionsInWords(pack, e.requires)}; otherwise roll again.`);
+    }
+    const text = [e.title ? `${e.title}. ` : "", sentence(e.text), ...extras.map((x) => ` ${x}`)].join("");
+    return [keys[i] ?? "", text];
+  });
+}
+function license(pack) {
+  const l = pack.license;
+  const who = l.holder ? ` \xA9 ${l.holder}` : "";
+  return `${l.id}${who}${l.redistributable ? "" : " \u2014 private; not for redistribution"}${l.notice ? `. ${l.notice}` : ""}${l.url ? ` (${l.url})` : ""}`;
+}
+function byline(pack) {
+  return [pack.author ? `by ${pack.author}` : "", `version ${pack.version}`].filter(Boolean).join(" \xB7 ");
+}
+function summaryDoc(pack) {
+  const n = nouns(pack);
+  const b = new Builder();
+  b.p(pack.description);
+  b.p(license(pack), "muted");
+  b.h(2, "How it plays");
+  const unitRange = `${pack.unit.min === pack.unit.max ? pack.unit.min : `${pack.unit.min}\u2013${pack.unit.max}`}`;
+  b.p(
+    `A ${n.run} is a series of ${n.units}${pack.unit.createsSubject ? `, each producing a ${n.subject}` : ""}; ${unitRange} of them, depending on the mode. Each ${n.unit} moves through ${plural(pack.phases.length, "phase", "phases")}: ${pack.phases.map((p) => p.label).join(", ")}.`
+  );
+  b.table(["Mode", "Length", "Players", "About"], modeRows(pack, { notes: false }));
+  b.h(2, "What is inside");
+  const tables = Object.values(pack.tables);
+  const decks = Object.values(pack.decks ?? {});
+  const parts = [];
+  if (tables.length) parts.push(`${plural(tables.length, "table", "tables")}: ${tables.map((t) => `${t.title} (${howConsulted(t).replace(/\.$/, "").toLowerCase()}, ${plural(t.entries.length, "entry", "entries")})`).join("; ")}.`);
+  if (decks.length) parts.push(`${plural(decks.length, "deck", "decks")}: ${decks.map((d) => d.kind === "cards" ? `${d.title} (${plural(d.cards.length, "card", "cards")})` : `${d.title} (a standard deck)`).join("; ")}.`);
+  const states = Object.values(pack.states ?? {});
+  if (states.length) parts.push(`${plural(states.length, "state", "states")} a ${n.subject} or ${n.run} can carry: ${states.map((s) => s.label).join(", ")}.`);
+  const counters = Object.values(pack.counters ?? {}).filter((c) => !c.hidden);
+  if (counters.length) parts.push(`${plural(counters.length, "tally", "tallies")}: ${counters.map((c) => c.label).join(", ")}.`);
+  const resources = Object.values(pack.resources ?? {});
+  if (resources.length) parts.push(`${plural(resources.length, "track", "tracks")}: ${resources.map((r) => r.label).join(", ")}.`);
+  const moves = Object.values(pack.moves ?? {});
+  if (moves.length) parts.push(`${plural(moves.length, "move", "moves")} you may make: ${moves.map((m) => m.label).join(", ")}.`);
+  if (pack.endings?.length) parts.push(`${plural(pack.endings.length, "ending", "endings")}: ${pack.endings.map((e) => e.label).join(", ")}.`);
+  if (pack.targeting && pack.targeting.strategy !== "none") parts.push(`Consequences can reach back to earlier ${n.subjects}.`);
+  if (pack.journal?.enabled !== false) parts.push(`A journal line per ${n.unit}${pack.journal?.required ? ", required" : ""}.`);
+  b.list(parts);
+  b.h(2, "What you need");
+  b.list(whatYouNeed(pack));
+  if (pack.homepage) b.p(`More at ${pack.homepage}`, "muted");
+  return { kind: "summary", layout: "book", title: pack.title, subtitle: byline(pack), blocks: b.blocks };
+}
+function rulebookDoc(pack) {
+  const n = nouns(pack);
+  const b = new Builder();
+  b.p(pack.description);
+  b.p(license(pack), "muted");
+  b.h(2, "What you need");
+  b.list(whatYouNeed(pack));
+  b.h(2, "Terms");
+  b.terms([
+    { term: cap(n.run), text: `One session of play. A ${n.run} is a series of ${n.units}, and ends when you say so or when the game does.` },
+    { term: cap(n.unit), text: `One round. Every ${n.unit} passes through the same phases${pack.unit.createsSubject ? ` and produces one ${n.subject}` : ""}.` },
+    ...pack.unit.createsSubject ? [{ term: cap(n.subject), text: `The thing a ${n.unit} makes. States attach to it, and consequences can land on it later.` }] : [],
+    { term: cap(n.finalize), text: `Closing a ${n.unit}. Once ${n.finalize.toLowerCase()}d, what it made is fixed unless a rule says otherwise.` },
+    ...Object.entries(pack.vocabulary.terms ?? {}).map(([term, text]) => ({ term, text }))
+  ]);
+  if (pack.hierarchy?.length) b.p(`When rules contradict each other, the more specific wins, in this order: ${pack.hierarchy.join(" > ")}.`, "note");
+  b.h(2, `A ${n.unit}, step by step`);
+  b.list(flowSteps(pack, { detail: true }), true);
+  if (pack.journal?.enabled !== false) b.p(`${pack.journal?.prompt ? `After each ${n.unit}: \u201C${pack.journal.prompt}\u201D` : `Keep a line of notes per ${n.unit}.`}${pack.journal?.required ? " A note is required before moving on." : ""}`);
+  b.h(2, "Modes");
+  b.table(["Mode", "Length", "Players", "About"], modeRows(pack, { notes: true }));
+  b.h(2, "Tables");
+  for (const [id, table] of Object.entries(pack.tables)) {
+    b.h(3, table.title);
+    b.p([howConsulted(table), table.description ?? ""].filter(Boolean).join(" "));
+    b.table([table.resolution === "keyed" ? "Key" : "Roll", "Result"], tableRows(pack, table, { full: true }));
+    void id;
+  }
+  const decks = Object.entries(pack.decks ?? {});
+  if (decks.length) {
+    b.h(2, "Cards");
+    for (const [, deck] of decks) {
+      b.h(3, deck.title);
+      if (deck.kind === "standard52") {
+        b.p([deck.description, `A standard deck${deck.includeJokers ? " with jokers" : ""}; ${deck.drawAtStart ? `draw ${deck.drawAtStart} at the start. ` : ""}Each draw is read by ${deck.resolveBy}${deck.resolveOn ? ` on ${pack.tables[deck.resolveOn]?.title ?? deck.resolveOn}` : ""}.`].filter(Boolean).join(" "));
+      } else {
+        b.p([deck.description, deck.drawAtStart ? `Draw ${deck.drawAtStart} at the start.` : "", deck.unique ? "" : "Cards may repeat.", deck.carriesOver ? `Unused cards carry over to the next ${n.run}.` : ""].filter(Boolean).join(" "));
+        b.table(
+          ["Card", "Effect"],
+          deck.cards.map((c) => [c.title, [c.text, ...(c.triggers ?? []).map((t) => triggerInWords(pack, t)), c.requires?.length ? `Only if ${conditionsInWords(pack, c.requires)}.` : ""].filter(Boolean).join(" ")])
+        );
+      }
+    }
+  }
+  const states = Object.entries(pack.states ?? {});
+  if (states.length) {
+    b.h(2, "States");
+    b.table(
+      ["State", "On", "Means"],
+      states.map(([, s]) => [
+        s.short ? `${s.label} (${s.short})` : s.label,
+        s.scope === "run" ? `the ${n.run}` : `a ${n.subject}`,
+        [s.description ?? "", ...(s.semantics ?? []).map(semanticInWords)].filter(Boolean).join(" ")
+      ])
+    );
+  }
+  const counters = Object.entries(pack.counters ?? {}).filter(([, c]) => !c.hidden);
+  const resources = Object.entries(pack.resources ?? {});
+  if (counters.length || resources.length) {
+    b.h(2, "Tallies and tracks");
+    b.table(
+      ["Name", "Starts at", "Rule"],
+      [
+        ...counters.map(([, c]) => [
+          c.label,
+          String(c.initial ?? 0),
+          [
+            c.min !== void 0 && c.max !== void 0 ? `Stays within ${c.min}\u2013${c.max}.` : c.max !== void 0 ? `Never above ${c.max}.` : c.min !== void 0 && c.min !== 0 ? `Never below ${c.min}.` : "",
+            ...(c.triggers ?? []).map((t) => sentence(`${t.label ? `${t.label} \u2014 ` : ""}at ${boundText(t.when)}${t.oncePerRun ? `, once per ${n.run}` : ""}: ${actionsInWords(pack, t.do)}`))
+          ].filter(Boolean).join(" ")
+        ]),
+        ...resources.map(([, r]) => [r.label, String(r.initial ?? 0), [r.description ?? "", `From ${r.min ?? 0}${r.max !== void 0 ? ` to ${r.max}` : ""}, in steps of ${r.step ?? 1}.`].filter(Boolean).join(" ")])
+      ]
+    );
+  }
+  const moves = Object.entries(pack.moves ?? {});
+  if (moves.length) {
+    b.h(2, "Moves");
+    b.table(
+      ["Move", "When", "What happens"],
+      moves.map(([, m]) => [
+        m.label,
+        [whenInWords(m.when, n), m.oncePerRun ? `once per ${n.run}` : "", m.available?.length ? `if ${conditionsInWords(pack, m.available)}` : ""].filter(Boolean).join("; "),
+        [m.description ?? "", sentence(cap(actionsInWords(pack, m.do)))].filter(Boolean).join(" ")
+      ])
+    );
+  }
+  if (pack.targeting && pack.targeting.strategy !== "none") {
+    b.h(2, "Reaching back");
+    b.p(targetingInWords(pack));
+  }
+  if (pack.triggers?.length) {
+    b.h(2, "Always in effect");
+    b.list(pack.triggers.map((t) => sentence(cap(triggerInWords(pack, t)))));
+  }
+  if (pack.endings?.length) {
+    b.h(2, `Ending a ${n.run}`);
+    b.terms(pack.endings.map((e) => ({ term: e.label, text: [e.text ?? "", e.requires?.length ? `Available when ${conditionsInWords(pack, e.requires)}.` : ""].filter(Boolean).join(" ") })));
+  }
+  return { kind: "rulebook", layout: "book", title: pack.title, subtitle: byline(pack), blocks: b.blocks };
+}
+function quickstartDoc(pack) {
+  const n = nouns(pack);
+  const b = new Builder();
+  b.p(pack.description);
+  b.h(2, "What you need");
+  b.list(whatYouNeed(pack));
+  b.h(2, "The words");
+  b.p(`A ${n.run} is one session. It is made of ${n.units}${pack.unit.createsSubject ? `, and each ${n.unit} makes one ${n.subject}` : ""}. Closing a ${n.unit} is called \u201C${n.finalize}\u201D.`);
+  b.h(2, `Each ${n.unit}`);
+  b.list(flowSteps(pack, { detail: false }), true);
+  const d = pack.modes[pack.defaultMode];
+  if (d) {
+    b.h(2, `Start with ${d.label}`);
+    b.p([d.description ?? "", `${cap(modeLength(pack, d))}, ${modePlayers(d)}.`, ...modeExtras(pack, d)].filter(Boolean).join(" "));
+    const others = Object.entries(pack.modes).filter(([id]) => id !== pack.defaultMode);
+    if (others.length) b.p(`Other ways to play: ${others.map(([, m]) => m.label).join(", ")}. They are in the rulebook.`, "muted");
+  }
+  if (pack.endings?.length) {
+    b.h(2, "When you stop");
+    b.terms(pack.endings.map((e) => ({ term: e.label, text: e.text ?? "" })));
+  }
+  b.p("Every table is on the reference card. Everything else is in the rulebook.", "muted");
+  return { kind: "quickstart", layout: "book", title: pack.title, subtitle: "Quick start", blocks: b.blocks };
+}
+function referenceDoc(pack) {
+  const n = nouns(pack);
+  const b = new Builder();
+  b.h(2, `Each ${n.unit}`);
+  b.list(flowSteps(pack, { detail: false }), true);
+  for (const [, table] of Object.entries(pack.tables)) {
+    b.h(2, `${table.title} \u2014 ${howConsulted(table).replace(/\.$/, "")}`);
+    b.table([table.resolution === "keyed" ? "Key" : "Roll", ""], tableRows(pack, table, { full: true }), true);
+  }
+  const states = Object.values(pack.states ?? {});
+  if (states.length) {
+    b.h(2, "States");
+    b.table(["", "State"], states.map((s) => [s.short ?? "", `${s.label}${s.description ? ` \u2014 ${s.description}` : ""}`]), true);
+  }
+  const moves = Object.values(pack.moves ?? {});
+  if (moves.length) {
+    b.h(2, "Moves");
+    b.list(moves.map((m) => sentence(`${m.label} (${whenInWords(m.when, n)}${m.oncePerRun ? `, once per ${n.run}` : ""}): ${actionsInWords(pack, m.do)}`)));
+  }
+  const remember = [];
+  for (const t of pack.triggers ?? []) remember.push(sentence(cap(triggerInWords(pack, t))));
+  for (const c of Object.values(pack.counters ?? {})) for (const t of c.triggers ?? []) remember.push(sentence(`${c.label} at ${boundText(t.when)}: ${actionsInWords(pack, t.do)}`));
+  for (const m of Object.values(pack.modes)) for (const note of m.notes ?? []) remember.push(`${m.label}: ${note}`);
+  if (pack.hierarchy?.length) remember.push(`Precedence: ${pack.hierarchy.join(" > ")}.`);
+  if (remember.length) {
+    b.h(2, "Frequently forgotten");
+    b.list(remember);
+  }
+  if (pack.endings?.length) {
+    b.h(2, "Endings");
+    b.list(pack.endings.map((e) => `${e.label}${e.text ? `: ${e.text}` : ""}`));
+  }
+  return { kind: "reference", layout: "card", title: pack.title, subtitle: `Reference \xB7 v${pack.version}`, blocks: b.blocks };
+}
+function runlogDoc(pack) {
+  const n = nouns(pack);
+  const b = new Builder();
+  const head = [{ label: "Date", width: "short" }, { label: "Mode", width: "short" }];
+  if (Object.values(pack.modes).some((m) => m.seeded)) head.push({ label: "Seed", width: "short" });
+  if (Object.values(pack.modes).some((m) => (m.players?.max ?? 1) > 1)) head.push({ label: "Players", width: "long" });
+  for (const deck of Object.values(pack.decks ?? {})) if (deck.kind === "cards" && deck.drawAtStart) head.push({ label: deck.title, width: "short" });
+  for (const c of Object.values(pack.counters ?? {}).filter((c2) => !c2.hidden)) head.push({ label: c.label, width: "short", box: true });
+  for (const r of Object.values(pack.resources ?? {})) head.push({ label: r.label, width: "short", box: true });
+  head.push({ label: "Page", width: "short" });
+  b.form(head);
+  b.rule();
+  const unitFields = [];
+  unitFields.push({ label: `${cap(n.unit)} \u2116`, width: "short" });
+  if (pack.unit.createsSubject) unitFields.push({ label: `${cap(n.subject)} / states`, width: "long" });
+  for (const phase of pack.phases) {
+    for (const step of phase.steps) {
+      if (step.kind === "rollTable") unitFields.push({ label: pack.tables[step.table]?.title ?? step.table, width: "full", lines: 2 });
+    }
+  }
+  if (pack.journal?.enabled !== false) unitFields.push({ label: "Notes", width: "full", lines: 2 });
+  for (let i = 0; i < 6; i++) b.form(unitFields);
+  b.rule();
+  b.form([{ label: `${cap(n.run)} states`, width: "full", lines: 2 }, { label: "Ending", width: "long" }]);
+  return { kind: "runlog", layout: "sheet", title: pack.title, subtitle: `${cap(n.run)} log`, blocks: b.blocks };
+}
+function semanticInWords(s) {
+  switch (s) {
+    case "blocksEdit":
+      return "Nothing about it may be changed.";
+    case "makesUntargetable":
+      return "Consequences cannot land on it.";
+    case "excludesFromResult":
+      return "It does not count toward the result.";
+    case "locksValue":
+      return "Its value is fixed.";
+    case "removesFromPlay":
+      return "It is out of play.";
+    default:
+      return s;
+  }
+}
+function whenInWords(when, n) {
+  switch (when) {
+    case "betweenUnits":
+      return `between ${n.units}`;
+    case "beforeEnding":
+      return `before ending the ${n.run}`;
+    default:
+      return "any time";
+  }
+}
+function boundText(b) {
+  if (b.eq !== void 0) return String(b.eq);
+  if (b.gte !== void 0 && b.lte !== void 0) return `${b.gte}\u2013${b.lte}`;
+  if (b.gte !== void 0) return `${b.gte}+`;
+  if (b.lte !== void 0) return `\u2264${b.lte}`;
+  return "";
+}
+function targetingInWords(pack) {
+  const n = nouns(pack);
+  const t = pack.targeting;
+  if (!t) return "";
+  switch (t.strategy) {
+    case "none":
+      return "";
+    case "playerChoice":
+      return `When a consequence reaches back, you choose which earlier ${n.subject} it lands on.`;
+    case "random":
+      return `When a consequence reaches back, pick an earlier ${n.subject} at random.`;
+    case "oldest":
+      return `When a consequence reaches back, it lands on the oldest ${n.subject} still in play.`;
+    case "newest":
+      return `When a consequence reaches back, it lands on the newest ${n.subject} still in play.`;
+    case "anchoredOffset": {
+      const bands = t.bands.map((b) => {
+        const anchor2 = b.anchor === "playerChoice" ? "you choose" : `count ${b.direction ?? "before"} from the ${b.anchor}`;
+        return `${b.range[0]}\u2013${b.range[1]}: ${anchor2}`;
+      });
+      return `When a roll reaches back, its ones digit says how far: ${bands.join("; ")}. Counting ${t.wraparound === false ? "stops at the end" : "wraps around"}${t.skipIneligible === false ? "" : ` and skips any ${n.subject} that cannot be targeted`}. A 0 lands on the anchor itself.${t.eventFallback ? ` When something other than a roll reaches back, roll ${t.eventFallback.roll} and read it the same way${t.eventFallback.missOn ? `; a ${t.eventFallback.missOn} misses` : ""}.` : ""}`;
+    }
+  }
+}
+function generateDoc(pack, kind) {
+  switch (kind) {
+    case "summary":
+      return summaryDoc(pack);
+    case "rulebook":
+      return rulebookDoc(pack);
+    case "quickstart":
+      return quickstartDoc(pack);
+    case "reference":
+      return referenceDoc(pack);
+    case "runlog":
+      return runlogDoc(pack);
+  }
+}
+var mdEscape = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+function toMarkdown(doc) {
+  const out = [`# ${doc.title}`];
+  if (doc.subtitle) out.push(`*${doc.subtitle}*`);
+  for (const block of doc.blocks) {
+    switch (block.kind) {
+      case "heading":
+        out.push(`${"#".repeat(block.level)} ${block.text}`);
+        break;
+      case "paragraph":
+        out.push(block.tone === "note" ? `> ${block.text}` : block.text);
+        break;
+      case "list":
+        out.push(block.items.map((item, i) => `${block.ordered ? `${i + 1}.` : "-"} ${item.replace(/\n\s*/g, "  \n   ")}`).join("\n"));
+        break;
+      case "table":
+        out.push([`| ${block.columns.map(mdEscape).join(" | ")} |`, `| ${block.columns.map(() => "---").join(" | ")} |`, ...block.rows.map((r) => `| ${r.map(mdEscape).join(" | ")} |`)].join("\n"));
+        break;
+      case "terms":
+        out.push(block.items.map((t) => `**${t.term}** \u2014 ${t.text}`).join("\n\n"));
+        break;
+      case "form":
+        out.push(block.fields.map((f) => `${f.label}: ${f.box ? "[    ]" : "_".repeat(f.width === "full" ? 40 : f.width === "long" ? 24 : 12)}`).join("  \n"));
+        break;
+      case "rule":
+        out.push("---");
+        break;
+      case "pagebreak":
+        out.push("");
+        break;
+    }
+  }
+  return `${out.join("\n\n")}
+`;
+}
+var esc2 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var multiline = (s) => esc2(s).replace(/\n/g, "<br>");
+var CSS = `
+:root { color-scheme: light; }
+body { margin: 0; background: #fff; color: #161513; font: 11pt/1.45 Georgia, "Times New Roman", serif; }
+main { max-width: 42em; margin: 0 auto; padding: 2.5rem 1.5rem; }
+h1 { font-size: 2rem; margin: 0 0 .25rem; line-height: 1.1; }
+.subtitle { margin: 0 0 2rem; color: #5b5751; font-style: italic; }
+h2 { font-size: 1.25rem; margin: 2rem 0 .5rem; border-bottom: 1px solid #d9d4cb; padding-bottom: .2rem; }
+h3 { font-size: 1.05rem; margin: 1.4rem 0 .35rem; }
+p { margin: 0 0 .75rem; }
+p.muted { color: #5b5751; font-size: .92em; }
+p.note { border-left: 3px solid #b9b2a5; padding-left: .75rem; color: #3f3b36; }
+ol, ul { margin: 0 0 .9rem; padding-left: 1.4rem; }
+li { margin: .2rem 0; white-space: pre-line; }
+table { border-collapse: collapse; width: 100%; margin: 0 0 1rem; font-size: .95em; }
+th, td { text-align: left; vertical-align: top; padding: .3rem .5rem; border-bottom: 1px solid #e4dfd6; }
+th { font-family: system-ui, sans-serif; font-size: .75em; letter-spacing: .04em; text-transform: uppercase; color: #5b5751; }
+td:first-child { white-space: nowrap; font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace; font-size: .9em; }
+table.compact td { padding: .12rem .35rem; font-size: .85em; }
+dl { margin: 0 0 1rem; }
+dt { font-weight: 700; margin-top: .5rem; }
+dd { margin: 0; }
+hr { border: 0; border-top: 1px solid #d9d4cb; margin: 1.5rem 0; }
+.page { break-after: page; }
+.form { display: flex; flex-wrap: wrap; gap: .5rem 1.25rem; margin: .6rem 0 .9rem; font-family: system-ui, sans-serif; font-size: .85em; }
+.field { display: flex; align-items: flex-end; gap: .4rem; }
+.field .line { display: inline-block; border-bottom: 1px solid #161513; height: 1.3em; }
+.field.short .line { width: 7em; } .field.long .line { width: 16em; } .field.full { flex: 1 1 100%; }
+.field.full .line { flex: 1; }
+.field .lines { flex: 1; display: grid; gap: .55em; }
+.field .lines .line { width: 100%; }
+.field .box { display: inline-block; width: 2.6em; height: 1.6em; border: 1px solid #161513; }
+.layout-card main { max-width: none; column-width: 17em; column-gap: 2rem; padding: 1.25rem; font-size: 9pt; }
+.layout-card h1 { column-span: all; font-size: 1.4rem; }
+.layout-card .subtitle { column-span: all; margin-bottom: 1rem; }
+.layout-card h2 { margin-top: 1rem; font-size: .95rem; break-after: avoid; }
+.layout-card table { break-inside: auto; }
+.layout-card tr { break-inside: avoid; }
+.layout-sheet main { max-width: none; padding: 1.25rem; }
+.layout-sheet .form + .form { border-top: 1px dashed #d9d4cb; padding-top: .6rem; }
+@media print { main { padding: 0; } @page { margin: 1.6cm; } .layout-card @page { margin: 1cm; } }
+`;
+function toHtml(doc) {
+  const body = [];
+  for (const block of doc.blocks) {
+    switch (block.kind) {
+      case "heading":
+        body.push(`<h${block.level}>${esc2(block.text)}</h${block.level}>`);
+        break;
+      case "paragraph":
+        body.push(`<p${block.tone ? ` class="${block.tone}"` : ""}>${multiline(block.text)}</p>`);
+        break;
+      case "list":
+        body.push(`<${block.ordered ? "ol" : "ul"}>${block.items.map((i) => `<li>${esc2(i)}</li>`).join("")}</${block.ordered ? "ol" : "ul"}>`);
+        break;
+      case "table":
+        body.push(
+          `<table${block.compact ? ' class="compact"' : ""}><thead><tr>${block.columns.map((c) => `<th>${esc2(c)}</th>`).join("")}</tr></thead><tbody>${block.rows.map((r) => `<tr>${r.map((c) => `<td>${multiline(c)}</td>`).join("")}</tr>`).join("")}</tbody></table>`
+        );
+        break;
+      case "terms":
+        body.push(`<dl>${block.items.map((t) => `<dt>${esc2(t.term)}</dt><dd>${multiline(t.text)}</dd>`).join("")}</dl>`);
+        break;
+      case "form":
+        body.push(
+          `<div class="form">${block.fields.map((f) => {
+            const width = f.width ?? "short";
+            const line = f.box ? `<span class="box"></span>` : f.lines && f.lines > 1 ? `<span class="lines">${'<span class="line"></span>'.repeat(f.lines)}</span>` : `<span class="line"></span>`;
+            return `<span class="field ${width}"><span class="label">${esc2(f.label)}</span>${line}</span>`;
+          }).join("")}</div>`
+        );
+        break;
+      case "rule":
+        body.push("<hr>");
+        break;
+      case "pagebreak":
+        body.push('<div class="page"></div>');
+        break;
+    }
+  }
+  return `<!doctype html>
+<html lang="en" class="layout-${doc.layout}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc2(doc.title)}${doc.subtitle ? ` \u2014 ${esc2(doc.subtitle)}` : ""}</title>
+<style>${CSS}</style>
+</head>
+<body>
+<main>
+<h1>${esc2(doc.title)}</h1>
+${doc.subtitle ? `<p class="subtitle">${esc2(doc.subtitle)}</p>` : ""}
+${body.join("\n")}
+</main>
+</body>
+</html>
+`;
+}
+
 // packages/engine/src/log.ts
 function voidedIds(events) {
   const out = /* @__PURE__ */ new Set();
@@ -28622,11 +29446,11 @@ async function cmdSign(args) {
   const format = detectFormat(path);
   const document = import_yaml3.default.parse(text);
   const signature = await signPack(document, key.privateKey, flag2(args, "--as"));
-  const signed = { ...document, signature };
+  const signed2 = { ...document, signature };
   writeFileSync2(
     path,
-    format === "json" ? `${JSON.stringify(signed, null, 2)}
-` : import_yaml3.default.stringify(signed, { lineWidth: 90 }),
+    format === "json" ? `${JSON.stringify(signed2, null, 2)}
+` : import_yaml3.default.stringify(signed2, { lineWidth: 90 }),
     "utf8"
   );
   console.log(`${paint(GREEN, "signed")} ${input2}`);
@@ -28767,6 +29591,62 @@ async function reportSignature(document) {
   );
 }
 
+// packages/cli/src/docs.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, join as join2, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+function cmdDocs(args) {
+  const files = args.filter((a) => !a.startsWith("-"));
+  const input2 = files[0];
+  if (!input2) {
+    console.error("usage: runlog docs <pack.yaml> [-o dir] [--only summary,rulebook,quickstart,reference,runlog] [--md | --html]");
+    return 2;
+  }
+  const outIndex = args.findIndex((a) => a === "-o" || a === "--out");
+  const onlyIndex = args.findIndex((a) => a === "--only");
+  const wanted = new Set(
+    onlyIndex >= 0 && args[onlyIndex + 1] ? args[onlyIndex + 1].split(",").map((k) => k.trim()) : DOC_KINDS.map((k) => k.kind)
+  );
+  for (const k of wanted) {
+    if (!DOC_KINDS.some((d) => d.kind === k)) {
+      console.error(`no such document: ${k}. Choose from ${DOC_KINDS.map((d) => d.kind).join(", ")}.`);
+      return 2;
+    }
+  }
+  const formats = args.includes("--md") && !args.includes("--html") ? ["md"] : args.includes("--html") && !args.includes("--md") ? ["html"] : ["html", "md"];
+  const path = resolve3(input2);
+  let text;
+  try {
+    text = readFileSync3(path, "utf8");
+  } catch {
+    console.error(`cannot read ${input2}`);
+    return 1;
+  }
+  const loaded = loadPackText(text, detectFormat(path));
+  if (!loaded.ok) {
+    console.error(`${basename(input2)} does not load; run \`runlog validate\` to see why`);
+    return 1;
+  }
+  const { pack } = loaded;
+  const dir = outIndex >= 0 && args[outIndex + 1] ? resolve3(args[outIndex + 1]) : resolve3(`${pack.id}-docs`);
+  mkdirSync2(dir, { recursive: true });
+  for (const kind of DOC_KINDS) {
+    if (!wanted.has(kind.kind)) continue;
+    const doc = generateDoc(pack, kind.kind);
+    for (const format of formats) {
+      const file2 = join2(dir, `${kind.kind}.${format}`);
+      writeFileSync3(file2, format === "md" ? toMarkdown(doc) : toHtml(doc), "utf8");
+      console.log(`${kind.label.padEnd(14)} ${file2}`);
+    }
+  }
+  if (!pack.license.redistributable) {
+    console.log("note: this pack is marked non-redistributable. The summary is safe to show anyone; keep the rest as private as the pack.");
+  } else {
+    console.log("open an .html in a browser and print it for a PDF; the reference card lays out in columns and the run log as a sheet.");
+  }
+  return 0;
+}
+
 // packages/cli/src/bin.ts
 var RESET2 = "\x1B[0m";
 var RED2 = "\x1B[31m";
@@ -28794,17 +29674,17 @@ function printDiagnostics(diagnostics, file2) {
   console.error(`  ${parts.join(", ")} in ${file2}`);
 }
 function read(path) {
-  const abs = resolve3(path);
+  const abs = resolve4(path);
   if (!existsSync3(abs)) {
     console.error(paint2(RED2, `no such file: ${path}`));
     process.exit(2);
   }
-  const text = readFileSync3(abs, "utf8");
+  const text = readFileSync4(abs, "utf8");
   const result = loadPackText(text, detectFormat(abs));
   return { text, pack: result.pack, diagnostics: result.diagnostics };
 }
 function report(path, diagnostics, strict) {
-  printDiagnostics(diagnostics, basename(path));
+  printDiagnostics(diagnostics, basename2(path));
   if (hasErrors(diagnostics)) return 1;
   if (strict && diagnostics.length > 0) {
     console.error(paint2(YELLOW2, "  --strict: treating warnings as failures"));
@@ -28830,7 +29710,7 @@ async function cmdValidate(args) {
       console.log(
         `${paint2(GREEN2, "ok")} ${paint2(BOLD, pack.title)} ${paint2(DIM2, `v${pack.version}`)} \u2014 ${tables} table${tables === 1 ? "" : "s"}, ${entries} entries, ${Object.keys(pack.modes).length} mode(s)` + (diagnostics.length ? paint2(YELLOW2, `, ${diagnostics.length} warning(s)`) : "")
       );
-      await reportSignature(import_yaml4.default.parse(readFileSync3(resolve3(file2), "utf8")));
+      await reportSignature(import_yaml4.default.parse(readFileSync4(resolve4(file2), "utf8")));
     }
   }
   return worst;
@@ -28850,14 +29730,14 @@ function cmdBundle(args) {
   }
   printDiagnostics(
     diagnostics.filter((d) => d.level === "warning"),
-    basename(input2)
+    basename2(input2)
   );
   const body = JSON.stringify(pack, null, 2);
   const hash2 = createHash("sha256").update(body).digest("hex").slice(0, 16);
   const bundled = { ...pack, bundledAt: (/* @__PURE__ */ new Date()).toISOString(), contentHash: hash2 };
-  const out = outIndex >= 0 && args[outIndex + 1] ? resolve3(args[outIndex + 1]) : resolve3(`${pack.id}-${pack.version}.pack.json`);
-  mkdirSync2(dirname(out), { recursive: true });
-  writeFileSync3(out, `${JSON.stringify(bundled, null, 2)}
+  const out = outIndex >= 0 && args[outIndex + 1] ? resolve4(args[outIndex + 1]) : resolve4(`${pack.id}-${pack.version}.pack.json`);
+  mkdirSync3(dirname(out), { recursive: true });
+  writeFileSync4(out, `${JSON.stringify(bundled, null, 2)}
 `, "utf8");
   console.log(`${paint2(GREEN2, "bundled")} ${out} ${paint2(DIM2, `sha256:${hash2}`)}`);
   if (!pack.license.redistributable) {
@@ -28910,12 +29790,12 @@ function cmdTest(args) {
 }
 function cmdInit(args) {
   const name = args.filter((a) => !a.startsWith("-"))[0] ?? "my-pack";
-  const out = resolve3(`${name}.yaml`);
+  const out = resolve4(`${name}.yaml`);
   if (existsSync3(out)) {
     console.error(paint2(RED2, `refusing to overwrite ${out}`));
     return 1;
   }
-  writeFileSync3(out, SKELETON.replaceAll("__NAME__", name), "utf8");
+  writeFileSync4(out, SKELETON.replaceAll("__NAME__", name), "utf8");
   console.log(`${paint2(GREEN2, "created")} ${out}`);
   console.log(paint2(DIM2, `  next: runlog validate ${name}.yaml`));
   return 0;
@@ -28977,6 +29857,8 @@ usage:
   runlog bundle   <pack> [-o out.json]   normalize to a distributable JSON
   runlog test     <pack>                 replay the pack's own fixtures
   runlog init     [name]                 scaffold a new pack
+  runlog docs     <pack> [-o dir]        write its rulebook, quick start, reference card,
+                    [--only kinds]         run log sheet and catalog summary (HTML and Markdown)
   runlog keygen   [-o key.json]          make a signing key for your packs
   runlog sign     <pack> --key key.json  sign a pack, proving you wrote it
   runlog issue    <pack> --to "Name"     stamp a copy with a buyer's name and sign it
@@ -29006,6 +29888,8 @@ async function main(argv) {
       return cmdValidate(args);
     case "bundle":
       return cmdBundle(args);
+    case "docs":
+      return cmdDocs(args);
     case "test":
       return cmdTest(args);
     case "keygen":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrthq/runlog",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "Validate, lint, bundle and test Runlog rule packs.",
   "type": "module",
   "license": "MIT",