agentic-canvas 0.0.0-stage → 0.2.0

package/dist/chunk-W7NRP3EX.js

@@ -0,0 +1,164 @@
+import {
+  Board,
+  CanvasError,
+  drawFlow,
+  principalSchema,
+  readBoard,
+  toSvg
+} from "./chunk-GGQPE65T.js";
+import {
+  FileStoreError
+} from "./chunk-NWQED42L.js";
+
+// src/service.ts
+import * as Y from "yjs";
+import { assertId, StoreConflictError } from "agentic-identity";
+var COLLECTION = "boards";
+var MAX_LIVE_BYTES = 1572864;
+var BOARD_ID = /^[A-Za-z0-9_-]{1,64}$/;
+function toBase64(bytes) {
+  let text = "";
+  for (let i = 0; i < bytes.length; i += 8192) text += String.fromCharCode(...bytes.subarray(i, i + 8192));
+  return btoa(text);
+}
+var fromBase64 = (text) => Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+function boardKey(id) {
+  try {
+    if (!BOARD_ID.test(id)) throw new Error();
+    assertId(id);
+  } catch {
+    throw new CanvasError("INVALID", "board id must be 1 to 64 of A-Z, a-z, 0-9, _ and -, and not like __x__");
+  }
+  return id;
+}
+function storeFailure(error) {
+  if (error instanceof StoreConflictError) throw new CanvasError("UNAVAILABLE", "the board changed at the same time. Try again");
+  if (error instanceof FileStoreError) throw new CanvasError(error.code === "LOCKED" ? "UNAVAILABLE" : "INVALID", error.message);
+  throw error;
+}
+var CanvasService = class {
+  store;
+  constructor(store) {
+    this.store = { ...store, transaction: (fn) => store.transaction(fn).catch(storeFailure) };
+  }
+  async create(actor, options = {}) {
+    const id = boardKey(options.id ?? crypto.randomUUID());
+    const board = new Board();
+    if (options.title !== void 0) board.setTitle(options.title, actor);
+    return this.store.transaction(async (tx) => {
+      if (await tx.get(COLLECTION, id)) throw new CanvasError("DUPLICATE_ID", `board "${id}" already exists`);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return { id, title: board.title };
+    });
+  }
+  /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
+  async assertExists(id) {
+    boardKey(id);
+    if (!await this.store.transaction((tx) => tx.get(COLLECTION, id))) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+  }
+  async read(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => ({ id, ...readBoard(await this.load(tx.get(COLLECTION, id), id)) }));
+  }
+  /** Run `change` on the board and save it, all inside one transaction. */
+  async change(id, change) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => {
+      const board = await this.load(tx.get(COLLECTION, id), id);
+      const result = change(board);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return result;
+    });
+  }
+  add(id, shape, actor) {
+    return this.change(id, (b) => b.addShape(shape, actor));
+  }
+  connect(id, connector, actor) {
+    return this.change(id, (b) => b.addConnector(connector, actor));
+  }
+  move(id, elementId, dx, dy, actor) {
+    return this.change(id, (b) => ({ moved: b.move(elementId, dx, dy, actor) }));
+  }
+  remove(id, elementId) {
+    return this.change(id, (b) => ({ removed: b.remove(elementId) }));
+  }
+  flow(id, text, actor, options) {
+    return this.change(id, (b) => drawFlow(b, text, actor, options));
+  }
+  async exportSvg(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => toSvg(await this.load(tx.get(COLLECTION, id), id)));
+  }
+  /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
+  async state(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => (await this.load(tx.get(COLLECTION, id), id)).encode());
+  }
+  /**
+   * Merge a live room's state into the stored board. `authors` are the principals the room saw send updates.
+   * An element stamped by anyone else is deleted, and a changed author is put back (see `Board.restamp`),
+   * so a client that writes raw Yjs cannot put another author on its work. Broken entries are repaired and
+   * a board past the element cap is refused. Returns the ids the checks fixed.
+   *
+   * Limits: the save corrects the stored board only. The room keeps what its clients wrote, so a client that sees
+   * a non-empty `fixed` must join again, or its later edits are lost at the next save. The room remembers its
+   * authors for good, so a client may stamp an element with the name of anyone who once sent an update in that room.
+   * A client that adds a root type of its own makes every later save of that room fail, because the room keeps it.
+   */
+  async checkpoint(id, update, actor, authors = []) {
+    boardKey(id);
+    const by = principalSchema.safeParse(actor);
+    if (!by.success) throw new CanvasError("INVALID", "the actor must be a valid principal");
+    const trusted = (who) => [by.data, ...authors].some((a) => a.kind === who.kind && a.id === who.id);
+    return this.store.transaction(async (tx) => {
+      const prior = await this.load(tx.get(COLLECTION, id), id);
+      const next = prior.clone();
+      try {
+        Y.applyUpdate(next.doc, update);
+      } catch {
+        throw new CanvasError("INVALID", "the update is not a Yjs update");
+      }
+      if (next.doc.store.pendingStructs || next.doc.store.pendingDs) throw new CanvasError("INVALID", "the update is not complete: it needs changes that the board does not have");
+      const strange = [...next.doc.share.keys()].filter((key) => key !== "elements" && key !== "meta");
+      if (strange.length > 0) throw new CanvasError("INVALID", "the update holds data that is not part of a board");
+      const fixed = /* @__PURE__ */ new Set([...next.restamp(prior, trusted), ...next.repair()]);
+      const saved = next.encode();
+      if (saved.length > MAX_LIVE_BYTES) throw new CanvasError("LIMIT", `the board would hold over ${MAX_LIVE_BYTES} bytes`);
+      await tx.put(COLLECTION, id, { update: toBase64(saved) });
+      return { elements: next.list().length, fixed: [...fixed].sort() };
+    });
+  }
+  /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
+  async repair(id, actor, drop = []) {
+    const by = principalSchema.safeParse(actor);
+    if (!by.success) throw new CanvasError("INVALID", "the actor must be a valid principal");
+    if (by.data.kind !== "human") throw new CanvasError("FORBIDDEN", "only a human owner can repair a board");
+    boardKey(id);
+    return this.store.transaction(async (tx) => {
+      const doc = await tx.get(COLLECTION, id);
+      if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+      const board = decodeStored(doc, id, Board.open);
+      const fixed = board.repair(drop);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return { id, fixed, elements: board.list().length };
+    });
+  }
+  async load(read, id) {
+    const doc = await read;
+    if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+    return decodeStored(doc, id, Board.decode);
+  }
+};
+function decodeStored(doc, id, decode) {
+  try {
+    return decode(fromBase64(String(doc.update)));
+  } catch (error) {
+    if (error instanceof CanvasError) throw error;
+    throw new CanvasError("INVALID", `stored board "${id}" is damaged`);
+  }
+}
+
+export {
+  MAX_LIVE_BYTES,
+  CanvasService
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import {
+  ActorConfigError,
+  BRAND,
+  operatorActor,
+  runMcp,
+  svgToPng
+} from "./chunk-KEMOXKBY.js";
+import {
+  openLocalStore
+} from "./chunk-UKST5A57.js";
+import {
+  CanvasService
+} from "./chunk-W7NRP3EX.js";
+import {
+  CanvasError
+} from "./chunk-GGQPE65T.js";
+import "./chunk-NWQED42L.js";
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+import { parseArgs } from "util";
+var UsageError = class extends Error {
+};
+var HELP = `${BRAND.command} ${BRAND.version}
+${BRAND.description}
+
+Usage: ${BRAND.command} [--dir <path>] <command> [flags]
+
+Commands:
+  new [--id <id>] [--title <t>]            Make a board.
+  read <board>                             Print the board as JSON.
+  add <board> --type <t> --x <n> --y <n>   Add a shape. Also: --w --h --text --fill --stroke --src --id.
+  connect <board> <from> <to> [--text <t>] Join two shapes with an arrow.
+  move <board> <element> --dx <n> --dy <n> Move an element or a group.
+  rm <board> <element>                     Delete an element.
+  flow <board> --text <t> | --file <p>     Draw a flowchart from text ("A -> B: label"). Use --file - for stdin.
+  export <board> [--format svg|png] [--out <path>]  Print SVG, or write PNG to --out.
+  repair <board> [--drop <element>]...     Owner only: fix a broken or over-cap board. Needs CANVAS_ACTOR=human:<id>.
+  mcp                                      Serve these as MCP tools on stdio. Needs CANVAS_ACTOR.
+
+Live mode: set CANVAS_SERVER=<worker url> and CANVAS_TOKEN=<bearer token>. Every command then runs in the live room of
+the board on that server, so a person and an agent can edit one board at once. The token sets the actor, the kind,
+and the role, so CANVAS_ACTOR is not needed. If it is set, it must match the token. --dir, CANVAS_DIR, and repair are local only.
+
+Write commands need an actor in CANVAS_ACTOR as <kind>:<id>, such as "agent:helper".
+The operator sets it. A caller cannot pick its own kind: there is no --actor flag.
+Kinds: human, agent_of_human, agent_of_agent, agent, user_token.
+The store folder is --dir, or CANVAS_DIR, or ./.agentic-canvas.`;
+var flags = {
+  dir: { type: "string" },
+  id: { type: "string" },
+  title: { type: "string" },
+  type: { type: "string" },
+  x: { type: "string" },
+  y: { type: "string" },
+  w: { type: "string" },
+  h: { type: "string" },
+  text: { type: "string" },
+  fill: { type: "string" },
+  stroke: { type: "string" },
+  src: { type: "string" },
+  dx: { type: "string" },
+  dy: { type: "string" },
+  file: { type: "string" },
+  prefix: { type: "string" },
+  format: { type: "string" },
+  out: { type: "string" },
+  drop: { type: "string", multiple: true },
+  help: { type: "boolean" },
+  version: { type: "boolean" }
+};
+var num = (v) => v === void 0 ? void 0 : v.trim() === "" ? Number.NaN : Number(v);
+function joinNegatives(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const next = argv[i + 1] ?? "";
+    if (argv[i].startsWith("--") && !argv[i].includes("=") && /^-\d/.test(next)) out.push(`${argv[i]}=${argv[++i]}`);
+    else out.push(argv[i]);
+  }
+  return out;
+}
+async function run(argv) {
+  const { values: v, positionals } = parseArgs({ args: joinNegatives(argv), options: flags, allowPositionals: true });
+  if (v.version) return void console.log(BRAND.version);
+  const [command, board, ...rest] = positionals;
+  if (v.help || command === void 0) return void console.log(HELP);
+  const need = (count, shape) => {
+    if (positionals.length !== count + 1) throw new UsageError(`usage: ${BRAND.command} ${command} ${shape}`);
+  };
+  const server = process.env.CANVAS_SERVER;
+  let live;
+  let service;
+  if (server) {
+    if (v.dir !== void 0 || process.env.CANVAS_DIR) throw new UsageError("--dir and CANVAS_DIR are local only: CANVAS_SERVER is set, so the board lives on the server");
+    const token = process.env.CANVAS_TOKEN;
+    if (!token) throw new UsageError("CANVAS_SERVER needs CANVAS_TOKEN");
+    if (command === "repair") throw new UsageError("repair runs on the local store only. Unset CANVAS_SERVER.");
+    const { LiveService, whoAmI } = await import("./live.js");
+    service = new LiveService({ server, token });
+    const claimed = process.env.CANVAS_ACTOR;
+    if (claimed || command !== "read" && command !== "export") live = (await whoAmI(server, token)).actor;
+    if (live && claimed && claimed !== `${live.kind}:${live.id}`) throw new UsageError(`CANVAS_ACTOR "${claimed}" does not match the token (${live.kind}:${live.id}). Unset CANVAS_ACTOR.`);
+  } else {
+    service = new CanvasService(openLocalStore(v.dir ?? process.env.CANVAS_DIR ?? ".agentic-canvas"));
+  }
+  const actor = () => {
+    if (live) return live;
+    try {
+      return operatorActor();
+    } catch (error) {
+      if (error instanceof ActorConfigError) throw new UsageError(`"${command}" needs an actor: ${error.message}`);
+      throw error;
+    }
+  };
+  const print = (value) => console.log(JSON.stringify(value));
+  switch (command) {
+    case "new":
+      need(0, "[--id <id>] [--title <t>]");
+      return print(await service.create(actor(), { id: v.id, title: v.title }));
+    case "read":
+      need(1, "<board>");
+      return print(await service.read(board));
+    case "add":
+      need(1, "<board> --type <t> --x <n> --y <n>");
+      return print(await service.add(board, { id: v.id, type: v.type, x: num(v.x), y: num(v.y), w: num(v.w), h: num(v.h), text: v.text, fill: v.fill, stroke: v.stroke, src: v.src }, actor()));
+    case "connect":
+      need(3, "<board> <from> <to> [--text <t>]");
+      return print(await service.connect(board, { id: v.id, from: { id: rest[0] }, to: { id: rest[1] }, text: v.text }, actor()));
+    case "move":
+      need(2, "<board> <element> --dx <n> --dy <n>");
+      return print(await service.move(board, rest[0], num(v.dx) ?? Number.NaN, num(v.dy) ?? Number.NaN, actor()));
+    case "rm":
+      need(2, "<board> <element>");
+      return print(await service.remove(board, rest[0]));
+    case "flow": {
+      need(1, "<board> --text <t> | --file <path>");
+      if (v.text === void 0 === (v.file === void 0)) throw new UsageError("flow needs exactly one of --text and --file");
+      const text = v.text ?? readFileSync(v.file === "-" ? 0 : v.file, "utf8");
+      return print(await service.flow(board, text, actor(), { idPrefix: v.prefix }));
+    }
+    case "export": {
+      need(1, "<board> [--format svg|png] [--out <path>]");
+      const format = v.format ?? "svg";
+      if (format !== "svg" && format !== "png") throw new UsageError(`format must be svg or png, got "${format}"`);
+      if (format === "png" && !v.out) throw new UsageError("png is binary: pass --out <path>");
+      const data = format === "svg" ? await service.exportSvg(board) : await svgToPng(await service.exportSvg(board));
+      if (!v.out) return void process.stdout.write(`${data}
+`);
+      writeFileSync(v.out, data);
+      return print({ out: v.out, format, bytes: data.length });
+    }
+    case "repair":
+      need(1, "<board> [--drop <element>]...");
+      return print(await service.repair(board, actor(), v.drop ?? []));
+    case "mcp":
+      need(0, "");
+      return runMcp(service, actor());
+    default:
+      throw new UsageError(`unknown command "${command}"`);
+  }
+}
+run(process.argv.slice(2)).catch((error) => {
+  const code = error.code ?? "";
+  if (error instanceof UsageError || code.startsWith("ERR_PARSE_ARGS")) {
+    console.error(`${error.message}
+Run "${BRAND.command} --help" for usage.`);
+    process.exitCode = 2;
+  } else if (error instanceof CanvasError) {
+    console.error(`${error.code}: ${error.message}`);
+    process.exitCode = 1;
+  } else {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { B as Board, P as Principal, a as BoardAccess } from './service-CJTe-uBI.js';
+export { b as BoardData, d as CanvasElement, e as CanvasError, c as CanvasService, C as Connector, D as DrawOptions, E as EdgeData, f as Endpoint, g as ErrorCode, F as FlowEdge, h as FlowGraph, i as FlowNode, G as Group, M as MAX_ELEMENTS, j as MAX_FLOW_EDGES, k as MAX_FLOW_NODES, l as MAX_TEXT, N as NodeData, m as Placement, n as SHAPE_TYPES, S as Shape, o as ShapeType, p as drawFlow, q as layoutFlow, r as parseFlow, s as principalSchema, t as readBoard } from './service-CJTe-uBI.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
+export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';
+import 'yjs';
+import 'zod';
+
+declare const VERSION: string;
+
+declare const BRAND: {
+    readonly command: "agentic-canvas";
+    readonly description: "A shared whiteboard for diagrams, drawn by people and agents.";
+    readonly version: string;
+};
+
+/** Draw the board, back to front, on a white background. */
+declare function toSvg(board: Board): string;
+
+/**
+ * Draw an SVG to PNG in a headless Chromium, through the optional
+ * `playwright-core` package. The page runs with JavaScript off and service
+ * workers blocked, and every network request is aborted, so a script planted in
+ * the SVG cannot run and nothing leaves the machine. When the package or the
+ * browser is missing, this throws.
+ */
+declare function svgToPng(svg: string): Promise<Uint8Array>;
+
+/** The operator set CANVAS_ACTOR wrong or not at all. */
+declare class ActorConfigError extends Error {
+}
+/**
+ * The actor for every write, from the operator's CANVAS_ACTOR as <kind>:<id>.
+ * A caller never picks its own actor or kind. Unset, empty, or bad is an error.
+ */
+declare function operatorActor(env?: Record<string, string | undefined>): Principal;
+
+/**
+ * The tools mirror the CLI. The actor is fixed here by the operator. No tool takes an actor,
+ * author, or kind, so a caller cannot choose who it writes as.
+ */
+declare function createMcpServer(service: BoardAccess, actor: Principal): McpServer;
+/** Serve the tools on stdin and stdout. Stdout carries protocol frames only. */
+declare function runMcp(service: BoardAccess, actor: Principal): Promise<void>;
+
+export { ActorConfigError, BRAND, Board, Principal, VERSION, createMcpServer, operatorActor, runMcp, svgToPng, toSvg };

package/dist/index.js

@@ -0,0 +1,61 @@
+import {
+  ActorConfigError,
+  BRAND,
+  VERSION,
+  createMcpServer,
+  operatorActor,
+  runMcp,
+  svgToPng
+} from "./chunk-KEMOXKBY.js";
+import {
+  createFileStore,
+  openLocalStore
+} from "./chunk-UKST5A57.js";
+import {
+  CanvasService
+} from "./chunk-W7NRP3EX.js";
+import {
+  Board,
+  CanvasError,
+  MAX_ELEMENTS,
+  MAX_FLOW_EDGES,
+  MAX_FLOW_NODES,
+  MAX_TEXT,
+  PRINCIPAL_KINDS,
+  SHAPE_TYPES,
+  drawFlow,
+  isMachineMade,
+  layoutFlow,
+  parseFlow,
+  principalSchema,
+  readBoard,
+  toSvg
+} from "./chunk-GGQPE65T.js";
+import "./chunk-NWQED42L.js";
+export {
+  ActorConfigError,
+  BRAND,
+  Board,
+  CanvasError,
+  CanvasService,
+  MAX_ELEMENTS,
+  MAX_FLOW_EDGES,
+  MAX_FLOW_NODES,
+  MAX_TEXT,
+  PRINCIPAL_KINDS,
+  SHAPE_TYPES,
+  VERSION,
+  createFileStore,
+  createMcpServer,
+  drawFlow,
+  isMachineMade,
+  layoutFlow,
+  openLocalStore,
+  operatorActor,
+  parseFlow,
+  principalSchema,
+  readBoard,
+  runMcp,
+  svgToPng,
+  toSvg
+};

package/dist/live-worker.d.ts

@@ -0,0 +1,21 @@
+import { createDurableObjectRealtime } from 'agentic-realtime/worker';
+export { SyncRoom } from 'agentic-realtime/worker';
+import { WorkerEnv } from './worker.js';
+import 'agentic-identity';
+import 'agentic-realtime';
+import 'agentic-identity/cloudflare';
+import 'hono';
+import './service-CJTe-uBI.js';
+import 'yjs';
+import 'zod';
+
+type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
+interface LiveEnv extends WorkerEnv {
+    /** Durable Object namespace of the live rooms. Bind `SyncRoom` to it. */
+    SYNC_ROOM?: Namespace;
+}
+declare const _default: {
+    fetch: (request: Request, env: LiveEnv, ctx: unknown) => Response | Promise<Response>;
+};
+
+export { type LiveEnv, _default as default };

package/dist/live-worker.js

@@ -0,0 +1,25 @@
+import {
+  createApp
+} from "./chunk-V477KSZQ.js";
+import "./chunk-W7NRP3EX.js";
+import {
+  CanvasError
+} from "./chunk-GGQPE65T.js";
+import "./chunk-NWQED42L.js";
+
+// src/live-worker.ts
+import { parseRegion } from "agentic-identity";
+import { createDurableObjectRealtime } from "agentic-realtime/worker";
+import { SyncRoom } from "agentic-realtime/worker";
+var app = createApp({
+  live: (env) => {
+    const rooms = env.SYNC_ROOM;
+    if (!rooms) throw new CanvasError("UNAVAILABLE", "bind a Durable Object namespace as SYNC_ROOM");
+    return createDurableObjectRealtime(rooms, parseRegion(env.CANVAS_REGION ?? "") === "eu" ? "eu" : void 0);
+  }
+});
+var live_worker_default = { fetch: (request, env, ctx) => app.fetch(request, env, ctx) };
+export {
+  SyncRoom,
+  live_worker_default as default
+};

package/dist/live.d.ts

@@ -0,0 +1,101 @@
+import { B as Board, P as Principal, a as BoardAccess, b as BoardData, S as Shape, C as Connector, D as DrawOptions } from './service-CJTe-uBI.js';
+import { Peer } from 'agentic-realtime/client';
+import 'yjs';
+import 'zod';
+import 'agentic-identity';
+
+interface LiveOptions {
+    /** The Worker address, such as `https://canvas.example.com`. */
+    server: string;
+    /** Board id. */
+    board: string;
+    /** A bearer token. The server maps it to the actor, the kind, and the role. */
+    token: string;
+    /** The name other people see in presence. Defaults to the actor id. */
+    name?: string;
+    /** Reconnect after a drop. Edits made offline merge when the socket returns. */
+    reconnect?: {
+        initialMs?: number;
+        maxMs?: number;
+    };
+}
+/** Who the server says the token is. */
+interface Me {
+    actor: Principal;
+    role: "editor" | "viewer";
+}
+declare function whoAmI(server: string, token: string): Promise<Me>;
+/**
+ * One board, open in a live room. The actor of every edit is the one the server reads from the token, so an agent
+ * token always writes agent edits. `save` writes the room to the stored board. The server checks the stamps then.
+ */
+declare class LiveBoard {
+    readonly board: Board;
+    readonly me: Me;
+    private readonly client;
+    private readonly id;
+    private readonly options;
+    private readonly refusedAtStart;
+    private constructor();
+    private changed;
+    /** The ids of the elements that the last `edit` added, changed, or removed. */
+    get touched(): ReadonlySet<string>;
+    static join(options: LiveOptions): Promise<LiveBoard>;
+    /** The other people and agents in the room. `machine` is true for an agent. */
+    get peers(): Peer[];
+    /** Why the room dropped an update, in order. */
+    get denied(): string[];
+    /**
+     * Run one change as the token's actor and wait until the room has it. A viewer fails before the change.
+     * After a refusal the local copy still holds the change: leave and join again.
+     */
+    edit<T>(run: (board: Board, actor: Principal) => T): Promise<T>;
+    /** Wait until the room has every change made so far. */
+    flush(): Promise<void>;
+    /**
+     * Save the room to the stored board. `fixed` lists the elements the server's checks changed. After that the
+     * room still holds the client's version, so leave and join again.
+     */
+    save(): Promise<{
+        elements: number;
+        fixed: string[];
+    }>;
+    leave(): Promise<void>;
+}
+/**
+ * The commands of the CLI and the MCP server, run in a live room. Each call joins the room, runs one change as the
+ * token's actor, saves to the stored board, and leaves. The `actor` argument is ignored: the server decides who writes.
+ * A read shows the room, which the server checks only when it saves: a forged stamp can show until then.
+ */
+declare class LiveService implements BoardAccess {
+    private readonly options;
+    constructor(options: Omit<LiveOptions, "board">);
+    private join;
+    create(_actor: Principal, options?: {
+        id?: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+    }>;
+    read(id: string): Promise<BoardData & {
+        id: string;
+    }>;
+    exportSvg(id: string): Promise<string>;
+    add(id: string, shape: unknown, _actor?: Principal): Promise<Shape>;
+    connect(id: string, connector: unknown, _actor?: Principal): Promise<Connector>;
+    move(id: string, element: string, dx: number, dy: number, _actor?: Principal): Promise<{
+        moved: string[];
+    }>;
+    remove(id: string, element: string): Promise<{
+        removed: string[];
+    }>;
+    flow(id: string, text: string, _actor?: Principal, options?: DrawOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    private use;
+    private write;
+}
+
+export { LiveBoard, type LiveOptions, LiveService, type Me, whoAmI };