plotcoder-board 0.1.13 → 0.1.15

package/src/board/compareStructure.d.ts

@@ -0,0 +1,32 @@
+// Type surface for compareStructure.js — a structure beside the wall (R52).
+
+import type { BoardState } from "./reducer";
+
+export declare const MATCH_PAGES: number;
+export declare const NEAR_PAGES: number;
+
+export type ComparedBeat = {
+  name: string;
+  at: number;
+  /** The page the structure's beat falls near on this board's target. */
+  page: number;
+  /** The wall's beat that answers it, or null. */
+  match: { id: string; headline: string; page: number } | null;
+  /** Pages the wall's beat is off by: negative is early. Null with no match. */
+  drift: number | null;
+  /** No match, and the page is past the story so far. */
+  beyond: boolean;
+};
+
+export type StructureComparison = {
+  rows: ComparedBeat[];
+  /** The wall's beats no beat of the structure took. */
+  unmatched: Array<{ id: string; headline: string; page: number }>;
+  /** Pages on the wall so far. */
+  soFar: number;
+  targetEighths: number;
+};
+
+export declare function compareStructure(state: BoardState, beats: ReadonlyArray<{ name: string; at: number }>): StructureComparison;
+export declare function driftWord(drift: number | null | undefined): string | null;
+export declare function describeComparison(comparison: StructureComparison): string[];

package/src/board/compareStructure.js

@@ -0,0 +1,85 @@
+// A structure beside the wall (R52).
+//
+// A structure's beats each carry the share of the story they tend to fall
+// near. Laying one out makes cards; this is the other thing the sheet's
+// words promise — a comparison. Each of the structure's beats gets the page
+// it falls near on this board's target, and the nearest of the wall's own
+// beats within reach, one to one and in order, with how far off it is. A
+// reading, like read_wall: it moves nothing and makes nothing.
+//
+// Pure and DOM-free, like the kernel: the sheet, the strip and the MCP
+// server all read the same rows.
+
+import { readingOrder } from "./readWall.js";
+import { EIGHTHS_PER_PAGE, noteEighths } from "./reducer.js";
+import { beatPage } from "./templates.js";
+
+/** Within this many pages a beat of the wall answers a beat of the structure. */
+export const MATCH_PAGES = 6;
+/** Within this many pages the match is "near" rather than early or late. */
+export const NEAR_PAGES = 2;
+
+/**
+ * Set a structure's beats beside this wall's. `beats` are a template's or a
+ * saved structure's: `{ name, at }`. The wall's beats are taken in reading
+ * order; each of the structure's takes the nearest wall beat not yet taken
+ * and not before the last one taken, within MATCH_PAGES, so the matching
+ * never crosses.
+ */
+export function compareStructure(state, beats) {
+  const order = readingOrder(state.notes);
+  const wallBeats = [];
+  let at = 0;
+  for (const note of order) {
+    if (note.rank === "beat") {
+      wallBeats.push({ id: note.id, headline: note.headline, page: Math.floor(at / EIGHTHS_PER_PAGE) + 1 });
+    }
+    at += noteEighths(note);
+  }
+  const soFar = Math.ceil(at / EIGHTHS_PER_PAGE);
+  let from = 0;
+  const taken = new Set();
+  const rows = beats.map((beat) => {
+    const page = beatPage(beat.at, state.targetEighths);
+    let best = -1;
+    for (let i = from; i < wallBeats.length; i += 1) {
+      const gap = Math.abs(wallBeats[i].page - page);
+      if (gap > MATCH_PAGES) continue;
+      if (best < 0 || gap < Math.abs(wallBeats[best].page - page)) best = i;
+    }
+    if (best >= 0) {
+      taken.add(best);
+      from = best + 1;
+    }
+    const match = best >= 0 ? wallBeats[best] : null;
+    return {
+      name: beat.name,
+      at: beat.at,
+      page,
+      match,
+      drift: match ? match.page - page : null,
+      // No match and the page is past the story so far: nothing is there yet.
+      beyond: !match && page > soFar,
+    };
+  });
+  const unmatched = wallBeats.filter((_, index) => !taken.has(index));
+  return { rows, unmatched, soFar, targetEighths: state.targetEighths };
+}
+
+/** The drift as a word or two: here, near, 3 pp early, 12 pp late. */
+export function driftWord(drift) {
+  if (drift === null || drift === undefined) return null;
+  if (drift === 0) return "here";
+  if (Math.abs(drift) <= NEAR_PAGES) return "near";
+  return drift < 0 ? `${-drift} pp early` : `${drift} pp late`;
+}
+
+/** One line per row, for a reply or a sheet: the structure's beat, its page, and the wall's answer. */
+export function describeComparison(comparison) {
+  return comparison.rows.map((row) => {
+    const head = `${row.name} (p. ${row.page})`;
+    if (row.match) return `${head} — yours: "${row.match.headline}" p. ${row.match.page} · ${driftWord(row.drift)}`;
+    if (row.beyond) return `${head} — nothing yet: past p. ${comparison.soFar}, the story so far`;
+    return `${head} — none of yours within ${MATCH_PAGES} pages`;
+  });
+}

package/src/board/markdown.d.ts

@@ -0,0 +1,15 @@
+import type { Line } from "./paginate";
+import type { BoardState } from "./reducer";
+
+/** What a document carries above the script: the board's name, the project's when it has several boards, the premise. */
+export type TakeOptions = { title?: string; project?: string; premise?: string };
+
+/** The wall as Markdown (R54): title, premise, logline, beats as headings, a heading per scene, the text or the change line. */
+export declare function toMarkdown(state: BoardState, options?: TakeOptions): string;
+
+/** The script as plain text, set as it prints: Courier's columns kept with spaces, scene numbers in the margins. */
+export declare function toPlainText(state: BoardState, options?: TakeOptions): string;
+
+export declare const GUTTER: number;
+export declare const COLUMN: Record<"character" | "more" | "parenthetical" | "dialogue", number>;
+export declare function setLine(line: Line): string;

package/src/board/markdown.js

@@ -0,0 +1,177 @@
+// Take the pages with you (R54): the wall as Markdown, and the script as
+// plain text — for a collaborator who lives in Google Docs rather than in a
+// screenwriting app. Both are pure and shared by every door: the Pages
+// panel's sheet, the console, and the MCP server's export_markdown and
+// export_text.
+//
+// Markdown is the wall read out, in wall order: the board as the title, the
+// premise and the logline under it, beats as second-level headings, one
+// third-level heading per scene from its place (with its scene number, locked
+// or by wall order), the headline as a synopsis line, then the scene's text —
+// set by what each element is, from the same rules the paginator reads by —
+// or, unwritten, its change line. Nothing invisible: Markdown has no notes
+// that print as nothing, so the cast and the fold stay on the wall.
+//
+// Plain text is the script as it prints: the paginator's lines, Courier's
+// columns kept with spaces, scene numbers in both margins, no page numbers.
+// It pastes into anything and reads as a script wherever the font is
+// monospaced.
+
+import { readingOrder } from "./readWall.js";
+import { sceneHeading } from "./fountain.js";
+import { paginate, parseScene, WIDTH } from "./paginate.js";
+import { sceneNumbers } from "./numbering.js";
+
+function upper(text) {
+  return text.trim().replace(/\s+/g, " ").toUpperCase();
+}
+
+function documentTitle(options) {
+  const title = options.title || "Untitled";
+  return options.project && options.project !== title ? `${options.project} · ${title}` : title;
+}
+
+/** A scene's text as Markdown paragraphs: action as it is, a speech as its cue in bold with the lines hard-broken under it. */
+function sceneMarkdown(text) {
+  const out = [];
+  for (const element of parseScene(text)) {
+    switch (element.kind) {
+      case "break":
+        out.push("---", "");
+        break;
+      case "speech": {
+        const lines = [`**${element.name}**`];
+        for (const part of element.parts) lines.push(part.kind === "parenthetical" ? `*${part.text}*` : part.text);
+        // Two trailing spaces: Markdown's line break, so the cue and its lines stay on their own lines.
+        out.push(lines.join("  \n"), "");
+        break;
+      }
+      case "centered":
+      case "transition":
+      case "action":
+      default:
+        out.push(element.text, "");
+    }
+  }
+  return out;
+}
+
+/**
+ * The whole wall as Markdown.
+ *
+ * @param state the board
+ * @param options.title the board's name; options.project the project's name
+ *   when the project has several boards; options.premise
+ */
+export function toMarkdown(state, options = {}) {
+  const order = readingOrder(state.notes);
+  const numbers = sceneNumbers(order, state.lock);
+  const out = [`# ${documentTitle(options)}`, ""];
+  if (options.premise) out.push(`*${options.premise}*`, "");
+  if (state.logline) out.push(`**${state.logline}**`, "");
+  let beat = 0;
+  for (const note of order) {
+    if (note.rank === "beat") {
+      beat += 1;
+      out.push(`## ${beat}. ${note.headline || "Untitled beat"}`, "");
+    }
+    const heading = sceneHeading(note).slice(1);
+    out.push(`### ${numbers.get(note.id) ?? ""} · ${heading}`.replace(/^###  · /, "### "), "");
+    if (note.headline && upper(note.headline) !== heading) out.push(`*${note.headline.trim()}*`, "");
+    if (note.text && note.text.trim()) out.push(...sceneMarkdown(note.text));
+    else if (note.change && note.change.trim()) out.push(note.change.trim(), "");
+  }
+  return `${out.join("\n").trimEnd()}\n`;
+}
+
+/** The column the script's body starts at: room for a scene number on the left. */
+export const GUTTER = 5;
+
+/** Where each kind of line starts, in characters from the body's left edge — the print stylesheet's columns. */
+export const COLUMN = { character: 22, more: 22, parenthetical: 16, dialogue: 10 };
+
+const DUAL_RIGHT = 32;
+const DUAL_CUE = 8;
+
+function pad(n) {
+  return " ".repeat(Math.max(0, n));
+}
+
+function centred(text, width = WIDTH.action) {
+  return pad(GUTTER + Math.floor((width - text.length) / 2)) + text;
+}
+
+/** One line of a dual-dialogue column, from the column's own left edge. */
+function columnLine(line) {
+  if (!line || line.kind === "blank") return "";
+  const text = line.text ?? "";
+  if (line.kind === "character") return pad(DUAL_CUE) + text;
+  if (line.kind === "parenthetical") return pad(4) + text;
+  return text;
+}
+
+/** A printed line set with spaces. Exported for the test; the file is `toPlainText`. */
+export function setLine(line) {
+  const text = line.text ?? "";
+  switch (line.kind) {
+    case "blank":
+      return "";
+    case "heading": {
+      const number = line.sceneNumber === null || line.sceneNumber === undefined ? "" : String(line.sceneNumber);
+      if (!number) return pad(GUTTER) + text;
+      return `${number.padEnd(GUTTER)}${text.padEnd(WIDTH.action)} ${number}`.trimEnd();
+    }
+    case "character":
+    case "more":
+    case "parenthetical":
+    case "dialogue":
+      return pad(GUTTER + COLUMN[line.kind]) + text;
+    case "transition":
+      return pad(GUTTER + WIDTH.action - text.length) + text;
+    case "centered":
+      return centred(text);
+    case "dual": {
+      const left = pad(GUTTER) + columnLine(line.left);
+      const right = columnLine(line.right);
+      return right ? `${left.padEnd(GUTTER + DUAL_RIGHT)}${right}` : left.trimEnd();
+    }
+    case "action":
+    default:
+      return pad(GUTTER) + text;
+  }
+}
+
+/**
+ * The script as plain text, set as it prints.
+ *
+ * @param state the board
+ * @param options.title the board's name; options.project the project's name
+ *   when the project has several boards
+ */
+export function toPlainText(state, options = {}) {
+  const order = readingOrder(state.notes);
+  const numbers = sceneNumbers(order, state.lock);
+  const result = paginate(
+    order.map((note) => ({
+      id: note.id,
+      heading: sceneHeading(note).slice(1),
+      text: note.text,
+      change: note.change,
+      written: Boolean(note.text && note.text.trim()),
+      number: numbers.get(note.id) ?? undefined,
+    })),
+  );
+  const title = options.title || "Untitled";
+  const out = [];
+  if (options.project && options.project !== title) {
+    out.push(centred(upper(options.project)), "", centred(title));
+  } else {
+    out.push(centred(upper(title)));
+  }
+  out.push("", "");
+  for (const page of result.pages) {
+    if (page.number > 1) out.push("");
+    for (const line of page.lines) out.push(setLine(line));
+  }
+  return `${out.join("\n").replace(/\n{4,}/g, "\n\n\n").trimEnd()}\n`;
+}

package/src/board/project.d.ts

@@ -1,6 +1,6 @@
 // Type surface for project.js — the project record (R35).
 
-import type { BoardNote } from "./reducer";
+import type { BoardCharacter, BoardNote, BoardState } from "./reducer";
 
 export declare const PROJECT_VERSION: number;
 export declare const DEFAULT_PROJECT_NAME: string;
@@ -22,6 +22,8 @@ export type ProjectRecord = {
   activeBoardId: string;
   /** A writer's own structures, saved from a wall's beats (Roadmap 2, item 7). */
   structures?: OwnStructure[];
+  /** The project's cast (R51): one roster every board draws from. Absent until liftCast has run. */
+  characters?: BoardCharacter[];
   createdAt: string;
   updatedAt: string;
 };
@@ -70,3 +72,19 @@ export declare function reidentifyProject(
   project: ProjectRecord,
   now?: string,
 ): ProjectRecord & { renamed: Record<string, string> };
+
+/** A board's state composed with the project's cast (R51). */
+export declare function withRoster(state: BoardState, project: ProjectRecord): BoardState;
+export declare function sameRoster(a: BoardCharacter[] | undefined, b: BoardCharacter[] | undefined): boolean;
+export declare function liftCast(
+  project: ProjectRecord,
+  boards: Record<string, BoardState>,
+  now?: string,
+): { project: ProjectRecord; boards: Record<string, BoardState>; changed: boolean };
+export type CastElsewhere = Record<string, Array<{ board: string; boardId: string; cards: number }>>;
+export declare function castElsewhere(project: ProjectRecord, boards: Record<string, BoardState>, activeBoardId: string): CastElsewhere;
+export declare function mergeRoster(
+  project: ProjectRecord,
+  state: BoardState,
+  now?: string,
+): { project: ProjectRecord; state: BoardState };

package/src/board/project.js

@@ -9,7 +9,7 @@
 // Plain ESM with a sibling .d.ts, like the kernel, so the browser store and the
 // MCP server share one idea of what a project is. Keep it free of `window`.
 
-import { newId, noteEighths, nowIso } from "./reducer.js";
+import { CHARACTER_FIELDS, fillCharacter, isCharacter, newId, normalizeState, noteEighths, nowIso, sameName } from "./reducer.js";
 
 export const PROJECT_VERSION = 2;
 export const DEFAULT_PROJECT_NAME = "Untitled project";
@@ -75,7 +75,7 @@ export function normalizeProject(value, now = nowIso()) {
     : [];
   // `renamed` is reidentifyProject's map for the store, never part of the record.
   const { renamed: _renamed, ...rest } = value;
-  return {
+  const record = {
     ...rest,
     version: PROJECT_VERSION,
     name: trimmed(value.name, DEFAULT_PROJECT_NAME),
@@ -86,6 +86,138 @@ export function normalizeProject(value, now = nowIso()) {
     createdAt: typeof value.createdAt === "string" ? value.createdAt : now,
     updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : now,
   };
+  // The project's cast (R51). A record with none has not been lifted yet —
+  // its boards still carry their own rosters — and liftCast does that at the
+  // next load boundary; so absent stays absent, and never becomes [].
+  if (Array.isArray(value.characters)) record.characters = value.characters.filter(isCharacter).map(fillCharacter);
+  else delete record.characters;
+  return record;
+}
+
+// --- The project's cast (R51) -----------------------------------------
+//
+// One roster for the project, on the record, that every board draws from.
+// A board's state still carries `characters`, but as a copy of the
+// project's: every load boundary composes it with withRoster, and every
+// store lifts a roster a kernel command changed back onto the record. So
+// the kernel, the readings and the wall go on reading state.characters,
+// and there is one Nessa across the pilot and episode two.
+
+/** A board's state with the project's cast in it; unknown cast ids on cards drop. */
+export function withRoster(state, project) {
+  if (!Array.isArray(project.characters) || sameRoster(project.characters, state.characters)) return state;
+  const next = normalizeState({ ...state, characters: project.characters });
+  return next.characters === project.characters ? next : { ...next, characters: project.characters };
+}
+
+/** True when two rosters are the same people with the same pages. */
+export function sameRoster(a, b) {
+  if (a === b) return true;
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+  return a.every((character, index) => {
+    const other = b[index];
+    return other && character.id === other.id && character.name === other.name && CHARACTER_FIELDS.every((field) => (character[field] ?? "") === (other[field] ?? ""));
+  });
+}
+
+/**
+ * Lift the cast onto the project. A record that already has one composes
+ * every board with it. A record with none — written before R51 — takes the
+ * boards' rosters in board order and merges them by name: the first record
+ * of a name keeps its id, later ones fold into it (a page line fills from the
+ * first board that had it), and every card that cast a folded id casts the
+ * kept one. Returns the record, every board composed, and whether anything
+ * changed.
+ */
+export function liftCast(project, boards, now = nowIso()) {
+  if (Array.isArray(project.characters)) {
+    let changed = false;
+    const out = {};
+    for (const [id, state] of Object.entries(boards)) {
+      const next = withRoster(state, project);
+      if (next !== state) changed = true;
+      out[id] = next;
+    }
+    return { project, boards: out, changed };
+  }
+  const roster = [];
+  const folded = {};
+  const order = [
+    ...project.boards.map((meta) => meta.id).filter((id) => boards[id]),
+    ...Object.keys(boards).filter((id) => !project.boards.some((meta) => meta.id === id)),
+  ];
+  for (const boardId of order) {
+    const map = {};
+    for (const character of boards[boardId].characters ?? []) {
+      if (!isCharacter(character)) continue;
+      const kept = roster.find((item) => sameName(item.name, character.name));
+      if (!kept) {
+        roster.push(fillCharacter({ ...character }));
+        continue;
+      }
+      map[character.id] = kept.id;
+      for (const field of CHARACTER_FIELDS) {
+        if (!kept[field].trim() && typeof character[field] === "string" && character[field].trim()) kept[field] = character[field];
+      }
+    }
+    folded[boardId] = map;
+  }
+  const lifted = { ...project, characters: roster, updatedAt: now };
+  const out = {};
+  for (const [boardId, state] of Object.entries(boards)) {
+    const map = folded[boardId] ?? {};
+    const notes = state.notes.map((note) => {
+      const ids = [...new Set(note.characterIds.map((id) => map[id] ?? id))];
+      return ids.length === note.characterIds.length && ids.every((id, index) => id === note.characterIds[index]) ? note : { ...note, characterIds: ids };
+    });
+    out[boardId] = normalizeState({ ...state, notes, characters: roster });
+  }
+  return { project: lifted, boards: out, changed: true };
+}
+
+/**
+ * A board with a roster of its own — an imported file, a board opened from
+ * elsewhere — joins the project's cast without shrinking it: a name the
+ * project already has keeps the project's record (its cards recast to that
+ * id), a new name is appended with the record it came with. Returns the
+ * record and the board composed with it.
+ */
+export function mergeRoster(project, state, now = nowIso()) {
+  if (!Array.isArray(project.characters)) return { project, state };
+  const roster = [...project.characters];
+  const map = {};
+  let grew = false;
+  for (const character of state.characters ?? []) {
+    if (!isCharacter(character)) continue;
+    const kept = roster.find((item) => sameName(item.name, character.name));
+    if (kept) {
+      if (kept.id !== character.id) map[character.id] = kept.id;
+      continue;
+    }
+    roster.push(fillCharacter({ ...character }));
+    grew = true;
+  }
+  const next = grew ? { ...project, characters: roster, updatedAt: now } : project;
+  const notes = state.notes.map((note) => {
+    const ids = [...new Set(note.characterIds.map((id) => map[id] ?? id))];
+    return ids.length === note.characterIds.length && ids.every((id, index) => id === note.characterIds[index]) ? note : { ...note, characterIds: ids };
+  });
+  const recast = notes.some((note, index) => note !== state.notes[index]) ? { ...state, notes } : state;
+  return { project: next, state: withRoster(recast, next) };
+}
+
+/** Which other boards of the project have each person on a card: id -> [{ board, cards }]. */
+export function castElsewhere(project, boards, activeBoardId) {
+  const map = {};
+  for (const meta of project.boards) {
+    if (meta.id === activeBoardId) continue;
+    const state = boards[meta.id];
+    if (!state) continue;
+    const counts = {};
+    for (const note of state.notes) for (const id of note.characterIds ?? []) counts[id] = (counts[id] ?? 0) + 1;
+    for (const [id, cards] of Object.entries(counts)) (map[id] ??= []).push({ board: meta.name, boardId: meta.id, cards });
+  }
+  return map;
 }
 
 function touch(project, patch, now) {

package/src/board/readWall.d.ts

@@ -63,11 +63,20 @@ export type WallReading = {
   payoffs: Record<string, string[]>;
   /** Folded cards that pay off on another board of the project (R50): the card and the board. */
   later: { id: string; boardId: string }[];
+  /** The questions the wall asks now. A left one (R53) is not here while its words hold. */
   findings: Finding[];
+  /** Questions the writer has left, for now: the same question, with when it was left. */
+  left: Array<Finding & { since: string }>;
 };
 
 /** Rows top to bottom, cards left to right within a row. */
 export declare function readingOrder(notes: BoardNote[]): BoardNote[];
-export declare function readWall(state: BoardState): WallReading;
+export declare function readWall(
+  state: BoardState,
+  options?: {
+    /** Cast ids on a card of another board of the project (R51): not asked about as uncast here. */
+    elsewhere?: string[];
+  },
+): WallReading;
 export declare function describeRuns(reading: WallReading, state: BoardState): string[];
 export declare function describeSetups(reading: WallReading, state: BoardState): string[];

package/src/board/readWall.js

@@ -110,7 +110,10 @@ function list(notes) {
  * Read the board. Returns the reading and the findings; see readWall.d.ts for
  * the shape. Never mutates the state.
  */
-export function readWall(state) {
+export function readWall(state, options = {}) {
+  // People on a card of another board of the project (R51) are cast, and
+  // are not asked about here.
+  const elsewhere = new Set(Array.isArray(options.elsewhere) ? options.elsewhere : []);
   const order = readingOrder(state.notes);
   const beats = order.filter((note) => note.rank === "beat");
 
@@ -334,6 +337,7 @@ export function readWall(state) {
   for (const character of state.characters ?? []) {
     const scenes = order.filter((note) => note.characterIds?.includes(character.id));
     if (scenes.length === 0) {
+      if (elsewhere.has(character.id)) continue;
       findings.push({
         kind: "uncast",
         ids: [character.id],
@@ -372,6 +376,21 @@ export function readWall(state) {
     }
   }
 
+  // A question the writer has left (R53) is held back while it is still the
+  // same question — same kind, same cards, same words. The moment it would
+  // read differently (a page moved, a headline changed, the median shifted)
+  // it is a new question and is asked. The kernel never decides this; the
+  // reading does, on every read.
+  const left = [];
+  const asked = findings.filter((finding) => {
+    const entry = (state.left ?? []).find(
+      (item) => item.kind === finding.kind && sameList(item.ids, finding.ids) && item.text === finding.text,
+    );
+    if (!entry) return true;
+    left.push({ ...finding, since: entry.since });
+    return false;
+  });
+
   return {
     order: order.map((note) => note.id),
     beats: beats.map((note) => ({ id: note.id, headline: note.headline })),
@@ -379,10 +398,15 @@ export function readWall(state) {
     setups,
     payoffs,
     later,
-    findings,
+    findings: asked,
+    left,
   };
 }
 
+function sameList(a, b) {
+  return a.length === b.length && a.every((id, index) => id === b[index]);
+}
+
 /** The setups as prose lines: what plants what, and how far apart. */
 export function describeSetups(reading, state) {
   const byId = new Map(state.notes.map((note) => [note.id, note]));

package/src/board/reducer.d.ts

@@ -117,10 +117,25 @@ export type BoardState = {
   lock: import("./numbering").Lock | null;
   /** The revision in progress — a name, a colour, a snapshot — or null. */
   revision: import("./numbering").Revision | null;
+  /** Questions the writer has left, for now (R53): kept until the question would read differently. */
+  left: LeftQuestion[];
+};
+
+/** A question the wall asked and the writer left (R53). */
+export type LeftQuestion = {
+  kind: string;
+  ids: string[];
+  /** The question's words when it was left; it comes back when they would differ. */
+  text: string;
+  since: string;
 };
 
 export type Pose = { id: string; x: number; y: number; rotate: number };
 
+export declare function isCharacter(value: unknown): value is { id: string; name: string };
+export declare function fillCharacter(character: { id: string; name: string } & Partial<BoardCharacter>): BoardCharacter;
+export declare function sameName(a: string, b: string): boolean;
+
 export type Command =
   | { type: "set_logline"; logline: string }
   | { type: "set_rank"; ids: string[]; rank: NoteRank }
@@ -170,7 +185,9 @@ export type Command =
   | { type: "lock_numbers"; order?: string[] }
   | { type: "unlock_numbers" }
   | { type: "start_revision"; name: string; color?: string }
-  | { type: "end_revision" };
+  | { type: "end_revision" }
+  | { type: "leave_question"; kind: string; ids: string[]; text: string }
+  | { type: "ask_again"; kind: string; ids?: string[] };
 
 export type CommandResult = {
   state: BoardState;