plotcoder-board 0.1.0

package/scripts/plotcoder-mcp.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// The PlotCoder MCP server's front door, and the package's `plotcoder-board`
+// command: no argument is the server on stdio; `call <tool> '{json}'` is one
+// call from a shell; `serve` is the hosted door on a port. The server itself
+// is plotcoder-mcp-server.mjs; this file only checks that it can start.
+//
+// When the repo's dependencies are not installed — a fresh clone, or a git
+// worktree that never had `npm ci` — the server dies on its first import,
+// and an MCP client says only "Connection closed" (rounds four and five).
+// So this file, which needs nothing but Node, answers the client itself in
+// that case: one tool, `plotcoder_not_installed`, whose description says the
+// folder and the command. The agent reads the reason instead of a closed
+// connection, and the fix is one line.
+
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+let installed = true;
+try {
+  createRequire(import.meta.url).resolve("@modelcontextprotocol/sdk/package.json");
+} catch {
+  installed = false;
+}
+
+if (installed && process.env.PLOTCODER_PRETEND_NOT_INSTALLED !== "1") {
+  if (process.argv[2] === "call") {
+    // `plotcoder-board call <tool> '{json}'` — one call from a shell, the
+    // package's own shell door (npx plotcoder-board call list_words).
+    process.argv.splice(2, 1);
+    await import("./plotcoder-call.mjs");
+  } else if (process.argv[2] === "serve") {
+    // `plotcoder-board serve` — the hosted door on a port (R48).
+    process.env.PLOTCODER_SERVE = "1";
+    await import("./plotcoder-http.mjs");
+  } else {
+    const { serveStdio } = await import("./plotcoder-mcp-server.mjs");
+    serveStdio(process.env).catch((error) => {
+      process.stderr.write(`[plotcoder-mcp] fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+      process.exit(1);
+    });
+  }
+} else {
+  const reason = `PlotCoder's MCP server cannot start: its dependencies are not installed in ${root}. Run \`npm ci\` in that folder once, then start the session again (or reconnect the server). Nothing else is wrong.`;
+  const tool = {
+    name: "plotcoder_not_installed",
+    description: reason,
+    inputSchema: { type: "object", properties: {} },
+  };
+  process.stderr.write(`[plotcoder-mcp] ${reason}\n`);
+  let buffer = "";
+  const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    let cut;
+    while ((cut = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, cut).trim();
+      buffer = buffer.slice(cut + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (message.id === undefined) continue; // a notification
+      const reply = (result) => send({ jsonrpc: "2.0", id: message.id, result });
+      switch (message.method) {
+        case "initialize":
+          reply({
+            protocolVersion: message.params?.protocolVersion ?? "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "plotcoder-board", version: "0.1.0" },
+          });
+          break;
+        case "tools/list":
+          reply({ tools: [tool] });
+          break;
+        case "tools/call":
+          reply({ content: [{ type: "text", text: reason }], isError: false });
+          break;
+        case "ping":
+          reply({});
+          break;
+        default:
+          send({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: `${message.method}: ${reason}` } });
+      }
+    }
+  });
+  process.stdin.on("end", () => process.exit(0));
+}

package/src/board/agents.d.ts

@@ -0,0 +1,14 @@
+// Type surface for agents.js — the agent on-ramp (R43).
+
+export type AgentDoor = { id: string; name: string; text: string; code?: string };
+export declare const AGENTS: {
+  lead: string;
+  doors: AgentDoor[];
+  firstNote: string;
+  first: Array<{ tool: string; why: string }>;
+  rules: string[];
+  person: string;
+  guide: string;
+  url: string;
+};
+export declare function agentsAsText(): string;

package/src/board/agents.js

@@ -0,0 +1,78 @@
+// Are you an agent? Start here (R43).
+//
+// The on-ramp, written once: what PlotCoder is in three sentences, the doors
+// in, what to call first, the rules in one breath, and a part for the person
+// about trust. The Agents sheet reads it, the file at /llms.txt is generated
+// from it, and the README's agent section says the same. DOM-free.
+
+export const AGENTS = {
+  lead:
+    "A storyline wall. Cards are scenes, beats are the big turns, arrows say what follows or pays off what. An agent driven by a person has every tool a person here has; the person directs, the agent operates. Call the tools; never fake a mouse.",
+  doors: [
+    {
+      id: "mcp",
+      name: "MCP, for the next session",
+      text: "For Cursor or Claude Code, once, from any folder — nothing to clone: claude mcp add plotcoder-board -s user -- npx -y plotcoder-board@latest — then start the session again. A server wired from inside a session connects on the next one, never the one you are in; an agent already inside a session takes the shell door below. The block is the same wiring for a config file; npx fetches the current server each time. A server that comes up with one tool, plotcoder_not_installed, is a checkout of the repo whose npm ci was never run: that only happens with the repo as the session's folder.",
+      code: '{\n  "mcpServers": {\n    "plotcoder-board": {\n      "command": "npx",\n      "args": ["-y", "plotcoder-board@latest"]\n    }\n  }\n}',
+    },
+    {
+      id: "shell",
+      name: "The shell, for this session",
+      text: "npx -y plotcoder-board@latest call <tool> '{json}' makes one call, with no MCP and no restart. One server per call, so undo and the project you opened do not carry between calls; npx -y plotcoder-board@latest call --batch < calls.jsonl runs a file of calls — one per line, {\"tool\": \"…\", \"arguments\": {…}} — on one server, so they do. With the account door the sign-in is kept in the folder's .plotcoder between calls (PLOTCODER_SESSION=0 to sign in every time). PLOTCODER_PROJECT names the project for each call. The JSON tail is off on this door; PLOTCODER_JSON=1 keeps it. PLOTCODER_ROOT points the server at the folder whose wall you mean; without it, the folder you run it from.",
+    },
+    {
+      id: "hosted",
+      name: "The hosted door, with nothing installed",
+      text: "Where someone runs PlotCoder's server for you — npx -y plotcoder-board@latest serve puts it on a port, and the repo has a Dockerfile — an MCP client connects over HTTP with the writer's sign-in on the request: claude mcp add plotcoder --transport http https://<that host>/mcp --header \"Authorization: Basic <base64 of email:password>\", then start the session again. The same server, the same tools, the account as the wall, no disk. PlotCoder does not run a public one yet; the address is the writer's to give.",
+    },
+    {
+      id: "account",
+      name: "The account",
+      text: "With the writer's own sign-in in the server's environment, the same server works their project from anywhere, live on every open wall. The two variables go where the server is started: in the MCP config's env, as -e flags on claude mcp add, or exported in the shell before a call. With the sign-in set, the account is the wall, even when a dev app is open on the machine. Without PLOTCODER_PROJECT it works the project touched most recently. Every read of the wall or the project names the project it read; the app's own lists — list_words, list_workflows — belong to no project. A wrong password is refused by every tool, never worked around. No account yet? claim_account makes one with the writer's email and a password they chose, and starts it empty.",
+      code: '{\n  "mcpServers": {\n    "plotcoder-board": {\n      "command": "npx",\n      "args": ["-y", "plotcoder-board@latest"],\n      "env": {\n        "PLOTCODER_EMAIL": "you@example.com",\n        "PLOTCODER_PASSWORD": "…",\n        "PLOTCODER_PROJECT": "The Letter"\n      }\n    }\n  }\n}\n\nclaude mcp add plotcoder-board -s user \\\n  -e PLOTCODER_EMAIL=you@example.com \\\n  -e PLOTCODER_PASSWORD=… \\\n  -- npx -y plotcoder-board@latest',
+    },
+    {
+      id: "page",
+      name: "The page",
+      text: "window.plotcoder on an open wall, for a browser session.",
+    },
+    {
+      id: "where",
+      name: "Where the wall lives, without an account",
+      text: "Skip this when the account is the wall. Without an account, a wall is a folder: any folder, empty is fine — choose one that will outlive your session, never a scratch one. The app run from that folder shows the wall, and the server writes it there (PLOTCODER_ROOT, or the folder it is run from). A fresh folder holds the sample; new_board for the writer's wall, then rename_project. No app running? export_fountain is the wall in order, as text.",
+    },
+  ],
+  firstNote: "On the wall you will work, so after open_project or open_board, read_wall again. No server in front of you, and no shell to take the shell door? Nothing gets you in from inside the session: say so, and ask the person to wire the server and start a new session.",
+  first: [
+    { tool: "list_words", why: "the room's words, the app's meaning." },
+    { tool: "read_wall", why: "what is here, and what it asks. A fresh folder holds a sample wall (Maya, Tom, the letter) and says so; it is not the writer's." },
+    { tool: "list_workflows", why: "what a writer can ask you for." },
+    { tool: "list_reminders", why: "the house principles the app starts with, and the writer's own; read them before you change anything." },
+  ],
+  rules: [
+    "Questions, not fixes, until the writer says.",
+    "No opinions about how many beats there should be.",
+    "Page counts are estimates.",
+    "Ask before delete_board, delete_project, empty_account, delete_account, unlock_numbers, remove_file, an import_project that replaces, or claim_account — the writer gives the email and the password; never invent one. export_project first, when something might be wanted back.",
+    "Do not invent people or a logline. What the treatment states — an age, a job, a bad knee — is not invented: it goes in the person's notes. An unnamed person is named by their role — Dana's mother, the dispatcher — which is a name until the writer gives one. A scene is one place and one stretch of time; a new place or time is a new card. A beat is a whole card; a setup arrow lands on the scene's card, so a payoff never needs a card of its own. Acts are groups titled Act one, Act two, when the treatment has them; the wall never asks whether an act is a sequence. Paper colour means nothing to the app. Under target is a fact to report plainly, like over; neither is a verdict.",
+  ],
+  person:
+    "Give your agent the account door only on a machine you trust; it signs in as you and shows under People as “an agent, as you” while it runs. Wire the server before you start the agent's session, with the two sign-in lines beside it, and the agent has every tool from its first message; wired from inside a session, the server connects only on the next one. Your agent can also make your account: give it your email and a password of your choosing.",
+  guide: "https://plotcoder.com/guide.md",
+  url: "https://plotcoder.com/llms.txt",
+};
+
+/** The on-ramp as one text: the file at /llms.txt, and what an agent reads. */
+export function agentsAsText() {
+  const lines = ["# PlotCoder — for agents", "", AGENTS.lead, "", `The guide, read once before anything: ${AGENTS.guide}.`, "", "## Doors"];
+  for (const door of AGENTS.doors) {
+    lines.push(`- ${door.name}: ${door.text}`);
+    if (door.code) lines.push("", "```", door.code, "```", "");
+  }
+  lines.push("## Call these first", AGENTS.firstNote);
+  AGENTS.first.forEach((item, index) => lines.push(`${index + 1}. ${item.tool} — ${item.why}`));
+  lines.push("", "## Rules");
+  for (const rule of AGENTS.rules) lines.push(`- ${rule}`);
+  lines.push("", "## For the person", AGENTS.person, "", "## The guide", AGENTS.guide, "");
+  return lines.join("\n");
+}

package/src/board/fdx.d.ts

@@ -0,0 +1,26 @@
+// Type surface for fdx.js — Final Draft in and out (R23, slices c3 and c4).
+
+import type { BoardState } from "./reducer";
+import type { FountainScene } from "./fountain";
+
+export declare function toFdx(
+  state: BoardState,
+  options?: { title?: string; project?: string; author?: string; draftDate?: string },
+): string;
+
+export type SetAside = {
+  scriptNotes: number;
+  revisedParagraphs: number;
+  lockedNumbers: number;
+  pageBreaks: number;
+  other: Record<string, number>;
+};
+
+export declare function fromFdx(xml: string): {
+  titles: Record<string, string>;
+  scenes: Array<FountainScene & { number: string | null }>;
+  setAside: SetAside;
+};
+
+/** The receipt as one line; "" when nothing was set aside. */
+export declare function describeSetAside(setAside: SetAside | undefined): string;

package/src/board/fdx.js

@@ -0,0 +1,206 @@
+// Final Draft in and out (R23, slices c3 and c4).
+//
+// An .fdx is XML: a Content of Paragraphs, each with a Type — Scene Heading,
+// Action, Character, Parenthetical, Dialogue, Transition, General — and Text;
+// dual dialogue is a Paragraph holding a DualDialogue of the two speakers'
+// paragraphs; a scene's number rides on SceneProperties; the title page is a
+// TitlePage of its own paragraphs. Out: the wall's scenes through the same
+// parser the paginator uses, scene numbers by wall order. In: the paragraphs
+// back into Fountain per scene, then the same merge as Fountain in — by
+// heading and order, never deleting. No DOM: a small reader of exactly the
+// tags used, so the MCP server reads the same file the browser does.
+
+import { parseScene, TRANSITION } from "./paginate.js";
+import { readingOrder } from "./readWall.js";
+import { sceneHeading } from "./fountain.js";
+import { sceneNumbers } from "./numbering.js";
+
+function escapeXml(text) {
+  return String(text)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function unescapeXml(text) {
+  return String(text)
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (_m, code) => String.fromCodePoint(Number(code)))
+    .replace(/&amp;/g, "&");
+}
+
+function paragraph(type, text, extra = "") {
+  return `    <Paragraph Type="${type}"${extra}>\n      <Text>${escapeXml(text)}</Text>\n    </Paragraph>\n`;
+}
+
+function speechParagraphs(speech) {
+  let out = paragraph("Character", speech.name.toUpperCase());
+  for (const part of speech.parts) {
+    out += paragraph(part.kind === "parenthetical" ? "Parenthetical" : "Dialogue", part.text);
+  }
+  return out;
+}
+
+/**
+ * The whole wall as an .fdx document, in reading order: a heading per card
+ * with its scene number, the scene's text through the paginator's parser
+ * when written and the change line as action when not, and a title page.
+ */
+export function toFdx(state, options = {}) {
+  const order = readingOrder(state.notes);
+  const numbers = sceneNumbers(order, state.lock);
+  let content = "";
+  order.forEach((note, index) => {
+    const number = numbers.get(note.id) ?? index + 1;
+    content += paragraph("Scene Heading", sceneHeading(note).slice(1), ` Number="${number}"`).replace(
+      "<Text>",
+      `<SceneProperties Length="" Page="" Title="${escapeXml(note.headline)}" />\n      <Text>`,
+    );
+    const elements = parseScene(note.text && note.text.trim() ? note.text : note.change || "");
+    for (let i = 0; i < elements.length; i += 1) {
+      const element = elements[i];
+      if (element.kind === "action") content += paragraph("Action", element.text);
+      else if (element.kind === "transition") content += paragraph("Transition", element.text);
+      else if (element.kind === "centered") content += paragraph("General", element.text, ' Alignment="Center"');
+      else if (element.kind === "speech") {
+        const next = elements[i + 1];
+        if (next && next.kind === "speech" && next.dual) {
+          content += `    <Paragraph>\n      <DualDialogue>\n${speechParagraphs(element)}${speechParagraphs(next)}      </DualDialogue>\n    </Paragraph>\n`;
+          i += 1;
+        } else {
+          content += speechParagraphs(element);
+        }
+      }
+    }
+  });
+
+  const title = [];
+  if (options.title) title.push(paragraph("General", options.title, ' Alignment="Center"'));
+  if (options.project && options.project !== options.title) title.push(paragraph("General", `An episode of ${options.project}`, ' Alignment="Center"'));
+  if (options.author) title.push(paragraph("General", `Written by ${options.author}`, ' Alignment="Center"'));
+  if (options.draftDate) title.push(paragraph("General", options.draftDate.slice(0, 10)));
+  title.push(paragraph("General", state.lock ? `Scene numbers locked ${String(state.lock.at).slice(0, 10)}.` : "Scene numbers follow the wall's order and are not locked."));
+
+  return (
+    `<?xml version="1.0" encoding="UTF-8" standalone="no" ?>\n` +
+    `<FinalDraft DocumentType="Script" Template="No" Version="5">\n` +
+    `  <Content>\n${content}  </Content>\n` +
+    `  <TitlePage>\n    <Content>\n${title.join("")}    </Content>\n  </TitlePage>\n` +
+    `</FinalDraft>\n`
+  );
+}
+
+/** Every Paragraph in a Content, in order, with Type and Text; nested DualDialogue flattened with a dual mark. */
+function readParagraphs(xml) {
+  const paragraphs = [];
+  // A script note holds its own Paragraphs; take it out first so the outer
+  // paragraph closes where it should. The receipt counts them from the body.
+  xml = xml.replace(/<ScriptNote\b[\s\S]*?<\/ScriptNote>/g, "");
+  const re = /<Paragraph\b([^>]*)>([\s\S]*?)<\/Paragraph>/g;
+  // DualDialogue holds inner Paragraphs; the lazy match above stops at the
+  // first inner close, so read dual blocks first and blank them out.
+  const dualRe = /<Paragraph\b[^>]*>\s*<DualDialogue>([\s\S]*?)<\/DualDialogue>\s*<\/Paragraph>/g;
+  const duals = [];
+  const stripped = xml.replace(dualRe, (_m, inner) => {
+    duals.push(inner);
+    return `<Paragraph Type="__dual${duals.length - 1}"></Paragraph>`;
+  });
+  let match;
+  while ((match = re.exec(stripped)) !== null) {
+    const attrs = match[1];
+    const type = /Type="([^"]*)"/.exec(attrs)?.[1] ?? "Action";
+    if (type.startsWith("__dual")) {
+      const inner = duals[Number(type.slice(6))];
+      const innerParagraphs = readParagraphs(inner);
+      innerParagraphs.forEach((p, index) => {
+        // The second speaker's cue gets the dual mark.
+        if (p.type === "Character" && innerParagraphs.slice(0, index).some((q) => q.type === "Character")) p.dual = true;
+      });
+      paragraphs.push(...innerParagraphs);
+      continue;
+    }
+    const texts = [...match[2].matchAll(/<Text\b[^>]*>([\s\S]*?)<\/Text>/g)].map((m) => unescapeXml(m[1]));
+    const number = /Number="([^"]*)"/.exec(attrs)?.[1] ?? null;
+    // Marks a production draft carries that the wall does not hold (yet).
+    const revised = /RevisionID="[^"]+"|Revision="[^"]+"/.test(match[2]) || /RevisionID="[^"]+"/.test(attrs);
+    const locked = /Locked="Yes"/.test(attrs) || /SceneNumberLocked="Yes"/.test(match[2]);
+    paragraphs.push({ type, text: texts.join("").replace(/\s+$/, ""), number, revised, locked });
+  }
+  return paragraphs;
+}
+
+/**
+ * An .fdx document as the same scenes Fountain in produces: heading, body in
+ * Fountain, and the title page's lines. Cues become capitals, parentheticals
+ * stay in brackets, a second dual speaker gets ^, transitions end lines,
+ * centred text is set in > <.
+ */
+export function fromFdx(xml) {
+  const contentMatch = /<Content>([\s\S]*?)<\/Content>\s*(?:<TitlePage>|<\/FinalDraft>)/.exec(xml);
+  const body = contentMatch ? contentMatch[1] : xml;
+  const titleMatch = /<TitlePage>([\s\S]*?)<\/TitlePage>/.exec(xml);
+  const titles = {};
+  if (titleMatch) {
+    const lines = readParagraphs(titleMatch[1]).map((p) => p.text).filter(Boolean);
+    if (lines[0]) titles.title = lines[0];
+    if (lines.length > 1) titles.notes = lines.slice(1).join("\n");
+  }
+  const scenes = [];
+  // The receipt (Roadmap 2, item 3): what was read and set aside, by count,
+  // so a writer bringing a production draft in knows what the wall does not hold.
+  const setAside = { scriptNotes: 0, revisedParagraphs: 0, lockedNumbers: 0, pageBreaks: 0, other: {} };
+  let current = null;
+  let lastKind = null;
+  setAside.scriptNotes = (body.match(/<ScriptNote\b/g) ?? []).length;
+  for (const p of readParagraphs(body)) {
+    if (p.revised) setAside.revisedParagraphs += 1;
+    if (p.locked) setAside.lockedNumbers += 1;
+    if (p.type === "Scene Heading") {
+      current = { heading: p.text.trim().replace(/\s+/g, " "), forced: true, synopsis: "", section: null, notes: [], lines: [], number: p.number };
+      scenes.push(current);
+      lastKind = null;
+      continue;
+    }
+    if (!current) continue;
+    const text = p.text.trim();
+    if (!text) continue;
+    if (p.type === "Character") {
+      current.lines.push("", `${text.toUpperCase()}${p.dual ? " ^" : ""}`);
+    } else if (p.type === "Dialogue") {
+      if (lastKind !== "Character" && lastKind !== "Parenthetical" && lastKind !== "Dialogue") current.lines.push("", "SPEAKER");
+      current.lines.push(text);
+    } else if (p.type === "Parenthetical") {
+      current.lines.push(/^\(.*\)$/.test(text) ? text : `(${text})`);
+    } else if (p.type === "Transition") {
+      // A standard transition reads as one on its own; anything else is forced with >.
+      current.lines.push("", TRANSITION.test(text) ? text : `> ${text}`);
+    } else {
+      if (p.type !== "Action" && p.type !== "General") setAside.other[p.type] = (setAside.other[p.type] ?? 0) + 1;
+      // Action, General and anything else: a paragraph of action.
+      current.lines.push("", /^[A-Z0-9 .,'!?-]+$/.test(text) && /[A-Z]/.test(text) ? `!${text}` : text);
+    }
+    lastKind = p.type;
+  }
+  setAside.pageBreaks = (body.match(/StartsNewPage="Yes"/g) ?? []).length;
+  for (const scene of scenes) {
+    scene.text = scene.lines.join("\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n").trim();
+    delete scene.lines;
+  }
+  return { titles, scenes, setAside };
+}
+
+/** The receipt as one line for a sheet or a tool: "" when nothing was set aside. */
+export function describeSetAside(setAside) {
+  if (!setAside) return "";
+  const parts = [];
+  if (setAside.scriptNotes) parts.push(`${setAside.scriptNotes} script note${setAside.scriptNotes === 1 ? "" : "s"}`);
+  if (setAside.revisedParagraphs) parts.push(`revision marks on ${setAside.revisedParagraphs} paragraph${setAside.revisedParagraphs === 1 ? "" : "s"}`);
+  if (setAside.lockedNumbers) parts.push(`${setAside.lockedNumbers} locked scene number${setAside.lockedNumbers === 1 ? "" : "s"}`);
+  if (setAside.pageBreaks) parts.push(`${setAside.pageBreaks} forced page break${setAside.pageBreaks === 1 ? "" : "s"}`);
+  for (const [type, count] of Object.entries(setAside.other)) parts.push(`${count} ${type} paragraph${count === 1 ? "" : "s"} read as action`);
+  return parts.length ? `Kept out of the wall: ${parts.join(" · ")}. Nothing was deleted.` : "";
+}

package/src/board/fountain.d.ts

@@ -0,0 +1,48 @@
+// Type surface for fountain.js — Fountain out (R23, slice a).
+
+import type { BoardNote, BoardState } from "./reducer";
+
+export declare function sceneHeading(note: BoardNote): string;
+
+export declare function titlePage(titles: {
+  title?: string;
+  credit?: string;
+  author?: string;
+  draftDate?: string;
+  notes?: string[];
+}): string;
+
+export type FountainOptions = {
+  /** The board's name. */
+  title?: string;
+  /** The project's name, when the board is one of several. */
+  project?: string;
+  premise?: string;
+  author?: string;
+  /** ISO date string; only the date is printed. */
+  draftDate?: string;
+};
+
+export declare function toFountain(state: BoardState, options?: FountainOptions): string;
+
+export type FountainScene = {
+  /** The heading as written, without the forcing dot. */
+  heading: string;
+  forced: boolean;
+  synopsis: string;
+  section: string | null;
+  notes: string[];
+  /** The body under the heading: action, cues, dialogue. */
+  text: string;
+};
+
+export declare function fromFountain(text: string): {
+  titles: Record<string, string>;
+  scenes: FountainScene[];
+};
+
+import type { Command } from "./reducer";
+export declare function mergeFountain(
+  state: BoardState,
+  parsed: { scenes: FountainScene[] },
+): { commands: Command[]; matched: Array<{ id: string; heading: string; created: boolean }> };