agentic-canvas 0.2.0 → 0.4.0

package/dist/cli.js

@@ -5,16 +5,16 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-KEMOXKBY.js";
+} from "./chunk-TSWXD4YG.js";
 import {
   openLocalStore
 } from "./chunk-UKST5A57.js";
 import {
   CanvasService
-} from "./chunk-W7NRP3EX.js";
+} from "./chunk-J52RPFRP.js";
 import {
   CanvasError
-} from "./chunk-GGQPE65T.js";
+} from "./chunk-JZA525X5.js";
 import "./chunk-NWQED42L.js";
 
 // src/cli.ts
@@ -29,9 +29,11 @@ Usage: ${BRAND.command} [--dir <path>] <command> [flags]
 
 Commands:
   new [--id <id>] [--title <t>]            Make a board.
+  list                                     List the boards with their titles.
   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.
+  update <board> <element> [--x --y --w --h --text --fill --stroke]  Change fields of an element. Resize with --w and --h.
   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.
@@ -118,6 +120,9 @@ async function run(argv) {
     case "new":
       need(0, "[--id <id>] [--title <t>]");
       return print(await service.create(actor(), { id: v.id, title: v.title }));
+    case "list":
+      need(0, "");
+      return print({ boards: await service.list() });
     case "read":
       need(1, "<board>");
       return print(await service.read(board));
@@ -127,6 +132,11 @@ async function run(argv) {
     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 "update": {
+      need(2, "<board> <element> [--x <n>] [--y <n>] [--w <n>] [--h <n>] [--text <t>] [--fill <c>] [--stroke <c>]");
+      const patch = Object.fromEntries(Object.entries({ 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 }).filter(([, value]) => value !== void 0));
+      return print(await service.update(board, rest[0], patch, 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()));

package/dist/client.d.ts

@@ -0,0 +1,119 @@
+import { E as ErrorCode, B as BoardData, S as ShapeType, a as Shape, b as Endpoint, C as Connector } from './read-Bdg1uiFC.js';
+import { PrincipalKind } from 'agentic-identity';
+import 'yjs';
+import 'zod';
+
+interface ClientOptions {
+    /** The API root, for example `https://canvas.example.com/api/v1/canvas`. */
+    baseUrl: string;
+    /** A bearer token. The token sets the actor, the kind, and the role. */
+    token: string;
+    /** A custom `fetch`. Defaults to the global one. */
+    fetch?: typeof fetch;
+}
+/** Options for every call. */
+interface CallOptions {
+    signal?: AbortSignal;
+}
+interface ShapeInput {
+    id?: string;
+    type: ShapeType;
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    text?: string;
+    fill?: string;
+    stroke?: string;
+    /** A `data:` URL or a `blob:` ref, for an image. */
+    src?: string;
+}
+interface ConnectorInput {
+    id?: string;
+    from: Endpoint;
+    to: Endpoint;
+    text?: string;
+    startArrow?: boolean;
+    endArrow?: boolean;
+    stroke?: string;
+}
+type ShapePatch = Partial<Pick<ShapeInput, "x" | "y" | "w" | "h" | "text" | "fill" | "stroke" | "src">>;
+type ConnectorPatch = Partial<Pick<ConnectorInput, "from" | "to" | "text" | "startArrow" | "endArrow" | "stroke">>;
+interface ImageInfo {
+    id: string;
+    ref: string;
+    type: string;
+    size: number;
+    /** False when the same bytes were stored before. */
+    created: boolean;
+}
+/**
+ * A failed call. `code` is the API error code, such as `NOT_FOUND`, `UNAUTHORIZED`, or `INVALID`. `status` is the HTTP status.
+ * A reply that is not the API's error shape has code `HTTP_ERROR`. A call that never got a reply has code `NETWORK` and status 0.
+ */
+type ApiErrorCode = ErrorCode | "UNAUTHORIZED" | "NOT_CONFIGURED" | "TOO_LARGE" | "UNSUPPORTED_TYPE" | "UPGRADE_REQUIRED" | "INTERNAL" | "NETWORK" | "HTTP_ERROR" | (string & {});
+declare class CanvasApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status: number;
+    constructor(code: ApiErrorCode, message: string, status: number);
+}
+interface CanvasClient {
+    /** Who the token stands for. */
+    me(options?: CallOptions): Promise<{
+        actor: string;
+        kind: PrincipalKind;
+        role: "editor" | "viewer";
+    }>;
+    /** The first 100 boards, with titles. */
+    listBoards(options?: CallOptions): Promise<{
+        boards: {
+            id: string;
+            title: string;
+        }[];
+    }>;
+    createBoard(input?: {
+        id?: string;
+        title?: string;
+    }, options?: CallOptions): Promise<{
+        id: string;
+        title: string;
+    }>;
+    readBoard(id: string, options?: CallOptions): Promise<BoardData & {
+        id: string;
+    }>;
+    /** The board as an SVG document. */
+    exportSvg(id: string, options?: CallOptions): Promise<string>;
+    addShape(id: string, shape: ShapeInput, options?: CallOptions): Promise<Shape>;
+    addConnector(id: string, connector: ConnectorInput, options?: CallOptions): Promise<Connector>;
+    /** Draw a flowchart from text such as `A -> B: label`. Returns the new ids. */
+    drawFlow(id: string, text: string, options?: CallOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    /** Change fields of one shape or connector, such as its size or text. The patch holds at least one field. */
+    update(id: string, element: string, patch: ShapePatch | ConnectorPatch, options?: CallOptions): Promise<Shape | Connector>;
+    /** Move an element. Returns the ids that moved: a shape takes its connectors with it. */
+    move(id: string, element: string, dx: number, dy: number, options?: CallOptions): Promise<{
+        moved: string[];
+    }>;
+    /** Remove an element. Returns the ids removed. */
+    remove(id: string, element: string, options?: CallOptions): Promise<{
+        removed: string[];
+    }>;
+    uploadImage(bytes: Uint8Array | ArrayBuffer | Blob, options?: CallOptions): Promise<ImageInfo>;
+    /** The bytes of a stored image, and its content type. */
+    getImage(id: string, options?: CallOptions): Promise<{
+        bytes: Uint8Array;
+        type: string;
+    }>;
+    /** The stored board as a Yjs update. Only a server with live rooms serves it. */
+    state(id: string, options?: CallOptions): Promise<Uint8Array>;
+    /** Merge a live room's Yjs update into the stored board. Only a server with live rooms serves it. */
+    checkpoint(id: string, update: Uint8Array, options?: CallOptions): Promise<{
+        elements: number;
+        fixed: string[];
+    }>;
+}
+declare function createClient(options: ClientOptions): CanvasClient;
+
+export { type ApiErrorCode, type CallOptions, CanvasApiError, type CanvasClient, type ClientOptions, type ConnectorInput, type ConnectorPatch, type ImageInfo, type ShapeInput, type ShapePatch, createClient };

package/dist/client.js

@@ -0,0 +1,80 @@
+// src/client.ts
+var CanvasApiError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "CanvasApiError";
+  }
+  code;
+  status;
+};
+function createClient(options) {
+  const { token } = options;
+  const base = options.baseUrl.replace(/\/+$/, "");
+  if (!token) throw new TypeError("token is required");
+  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const seg = encodeURIComponent;
+  async function send(method, path, init, call) {
+    const headers = { authorization: `Bearer ${token}` };
+    if (init.json !== void 0) headers["content-type"] = "application/json";
+    if (init.contentType) headers["content-type"] = init.contentType;
+    let response;
+    try {
+      response = await doFetch(`${base}${path}`, {
+        method,
+        headers,
+        body: init.json === void 0 ? init.body : JSON.stringify(init.json),
+        signal: call?.signal
+      });
+    } catch (error) {
+      if (call?.signal?.aborted) throw error;
+      throw new CanvasApiError("NETWORK", error instanceof Error ? error.message : "the request failed", 0);
+    }
+    if (response.ok) return response;
+    let code = "HTTP_ERROR";
+    let message = `the server answered ${response.status}`;
+    try {
+      const { error } = await response.json();
+      if (typeof error?.code === "string") code = error.code;
+      if (typeof error?.message === "string") message = error.message;
+    } catch {
+      if (call?.signal?.aborted) throw call.signal.reason;
+    }
+    throw new CanvasApiError(code, message, response.status);
+  }
+  const parse = async (response, call) => {
+    try {
+      return await response.json();
+    } catch (error) {
+      if (call?.signal?.aborted) throw error;
+      throw new CanvasApiError("HTTP_ERROR", "the server did not answer with JSON", response.status);
+    }
+  };
+  const json = async (method, path, body, call) => parse(await send(method, path, { json: body }, call), call);
+  const bytes = async (response) => new Uint8Array(await response.arrayBuffer());
+  return {
+    me: (o) => json("GET", "/me", void 0, o),
+    listBoards: (o) => json("GET", "/boards", void 0, o),
+    createBoard: (input = {}, o) => json("POST", "/boards", input, o),
+    readBoard: (id, o) => json("GET", `/boards/${seg(id)}`, void 0, o),
+    exportSvg: async (id, o) => (await send("GET", `/boards/${seg(id)}/svg`, {}, o)).text(),
+    addShape: (id, shape, o) => json("POST", `/boards/${seg(id)}/shapes`, shape, o),
+    addConnector: (id, connector, o) => json("POST", `/boards/${seg(id)}/connectors`, connector, o),
+    drawFlow: (id, text, o) => json("POST", `/boards/${seg(id)}/flow`, { text }, o),
+    update: (id, element, patch, o) => json("PATCH", `/boards/${seg(id)}/elements/${seg(element)}`, patch, o),
+    move: (id, element, dx, dy, o) => json("POST", `/boards/${seg(id)}/move`, { element, dx, dy }, o),
+    remove: (id, element, o) => json("DELETE", `/boards/${seg(id)}/elements/${seg(element)}`, void 0, o),
+    uploadImage: async (data, o) => parse(await send("POST", "/images", { body: data, contentType: "application/octet-stream" }, o), o),
+    getImage: async (id, o) => {
+      const response = await send("GET", `/images/${seg(id)}`, {}, o);
+      return { bytes: await bytes(response), type: response.headers.get("content-type") ?? "application/octet-stream" };
+    },
+    state: async (id, o) => bytes(await send("GET", `/boards/${seg(id)}/state`, {}, o)),
+    checkpoint: async (id, update, o) => parse(await send("POST", `/boards/${seg(id)}/checkpoint`, { body: update, contentType: "application/octet-stream" }, o), o)
+  };
+}
+export {
+  CanvasApiError,
+  createClient
+};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-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 { c as Board, P as Principal } from './read-Bdg1uiFC.js';
+export { B as BoardData, d as CanvasElement, e as CanvasError, C as Connector, f as EdgeData, b as Endpoint, E as ErrorCode, G as Group, M as MAX_ELEMENTS, g as MAX_TEXT, N as NodeData, h as SHAPE_TYPES, a as Shape, S as ShapeType, p as principalSchema, r as readBoard } from './read-Bdg1uiFC.js';
+import { B as BoardAccess } from './service-Cim7TWnJ.js';
+export { C as CanvasService, D as DrawOptions, F as FlowEdge, a as FlowGraph, b as FlowNode, M as MAX_FLOW_EDGES, c as MAX_FLOW_NODES, P as Placement, d as drawFlow, l as layoutFlow, p as parseFlow } from './service-Cim7TWnJ.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';

package/dist/index.js

@@ -6,14 +6,14 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-KEMOXKBY.js";
+} from "./chunk-TSWXD4YG.js";
 import {
   createFileStore,
   openLocalStore
 } from "./chunk-UKST5A57.js";
 import {
   CanvasService
-} from "./chunk-W7NRP3EX.js";
+} from "./chunk-J52RPFRP.js";
 import {
   Board,
   CanvasError,
@@ -30,7 +30,7 @@ import {
   principalSchema,
   readBoard,
   toSvg
-} from "./chunk-GGQPE65T.js";
+} from "./chunk-JZA525X5.js";
 import "./chunk-NWQED42L.js";
 export {
   ActorConfigError,

package/dist/live-worker.d.ts

@@ -5,9 +5,10 @@ import 'agentic-identity';
 import 'agentic-realtime';
 import 'agentic-identity/cloudflare';
 import 'hono';
-import './service-CJTe-uBI.js';
+import './read-Bdg1uiFC.js';
 import 'yjs';
 import 'zod';
+import './service-Cim7TWnJ.js';
 
 type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
 interface LiveEnv extends WorkerEnv {

package/dist/live-worker.js

@@ -1,10 +1,10 @@
 import {
   createApp
-} from "./chunk-V477KSZQ.js";
-import "./chunk-W7NRP3EX.js";
+} from "./chunk-HPUYT5TC.js";
+import "./chunk-J52RPFRP.js";
 import {
   CanvasError
-} from "./chunk-GGQPE65T.js";
+} from "./chunk-JZA525X5.js";
 import "./chunk-NWQED42L.js";
 
 // src/live-worker.ts

package/dist/live.d.ts

@@ -1,5 +1,6 @@
-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 { c as Board, P as Principal, B as BoardData, a as Shape, C as Connector, d as CanvasElement } from './read-Bdg1uiFC.js';
 import { Peer } from 'agentic-realtime/client';
+import { B as BoardAccess, D as DrawOptions } from './service-Cim7TWnJ.js';
 import 'yjs';
 import 'zod';
 import 'agentic-identity';
@@ -78,12 +79,17 @@ declare class LiveService implements BoardAccess {
         id: string;
         title: string;
     }>;
+    list(): 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>;
+    update(id: string, element: string, patch: unknown, _actor?: Principal): Promise<CanvasElement>;
     move(id: string, element: string, dx: number, dy: number, _actor?: Principal): Promise<{
         moved: string[];
     }>;

package/dist/live.js

@@ -5,11 +5,10 @@ import {
   principalSchema,
   readBoard,
   toSvg
-} from "./chunk-GGQPE65T.js";
+} from "./chunk-JZA525X5.js";
 
 // src/live.ts
 import { SyncClient } from "agentic-realtime/client";
-import * as Y from "yjs";
 var CODES = ["INVALID", "DUPLICATE_ID", "NOT_FOUND", "BAD_REFERENCE", "LIMIT", "UNAVAILABLE", "FORBIDDEN"];
 var base = (server) => server.replace(/\/$/, "") + "/api/v1/canvas";
 async function refusal(response, fallback) {
@@ -61,7 +60,7 @@ var LiveBoard = class _LiveBoard {
     const id = encodeURIComponent(options.board);
     const stored = await call(options.server, options.token, `/boards/${id}/state`);
     if (!stored.ok) throw await refusal(stored, "could not read the stored board");
-    const state = new Uint8Array(await stored.arrayBuffer());
+    await stored.body?.cancel();
     const url = new URL(`${base(options.server)}/boards/${id}/ws`);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     let client;
@@ -70,14 +69,6 @@ var LiveBoard = class _LiveBoard {
     } catch (error) {
       throw unreachable(error);
     }
-    try {
-      Y.applyUpdate(client.doc, state);
-      await client.flush();
-      if (me.role === "editor" && client.denied.length > 0) throw new CanvasError("FORBIDDEN", `the room refused the stored board: ${client.denied[0]}`);
-    } catch (error) {
-      await client.disconnect();
-      throw unreachable(error);
-    }
     return new _LiveBoard(new Board(client.doc), me, client, options.board, options, client.denied.length);
   }
   /** The other people and agents in the room. `machine` is true for an agent. */
@@ -142,6 +133,13 @@ var LiveService = class {
     if (typeof id !== "string" || typeof title !== "string") throw new CanvasError("INVALID", "the server sent a board this client does not know");
     return { id, title };
   }
+  async list() {
+    const response = await call(this.options.server, this.options.token, "/boards");
+    if (!response.ok) throw await refusal(response, "the server refused the request");
+    const { boards } = await json(response);
+    if (!Array.isArray(boards) || !boards.every((b) => typeof b?.id === "string" && typeof b?.title === "string")) throw new CanvasError("INVALID", "the server sent a board list this client does not know");
+    return boards;
+  }
   async read(id) {
     return this.use(id, async (live) => ({ id, ...readBoard(live.board) }));
   }
@@ -154,6 +152,9 @@ var LiveService = class {
   connect(id, connector, _actor) {
     return this.write(id, (board, actor) => board.addConnector(connector, actor));
   }
+  update(id, element, patch, _actor) {
+    return this.write(id, (board, actor) => board.update(element, patch, actor));
+  }
   move(id, element, dx, dy, _actor) {
     return this.write(id, (board, actor) => ({ moved: board.move(element, dx, dy, actor) }));
   }

package/dist/{service-CJTe-uBI.d.ts → read-Bdg1uiFC.d.ts}

@@ -1,6 +1,5 @@
 import * as Y from 'yjs';
 import { z } from 'zod';
-import { Store } from 'agentic-identity';
 
 declare const principalSchema: z.ZodObject<{
     kind: z.ZodEnum<["human", "agent_of_human", "agent_of_agent", "agent", "user_token"]>;
@@ -109,8 +108,17 @@ declare class Board {
      * author, and a changed one needs a trusted editor or it goes back to its prior state. An editor stamp changed alone
      * to an untrusted principal is put back. Unknown keys, nested Yjs types, and bad or foreign title values are deleted
      * or undone. Returns the ids it deleted or restored.
+     *
+     * `writer` says who sent the update that holds a Yjs item, or undefined when it does not know. Where it knows, it
+     * decides: a new element gets its creator as author and editor, and an old one gets the sender of its changes as editor.
+     * A client cannot claim another principal, and an agent cannot pass as a person. A new item that the log lacks has no
+     * sender: it is deleted or undone. Only an old item falls back to `trusted`. A hand save names its poster as the sender
+     * of every item that the room does not hold, in `writer`.
      */
-    restamp(prior: Board, trusted: (who: Principal) => boolean): string[];
+    restamp(prior: Board, trusted: (who: Principal) => boolean, writer?: (item: {
+        client: number;
+        clock: number;
+    }) => Principal | undefined): string[];
     addShape(input: unknown, actor: Principal): Shape;
     addConnector(input: unknown, actor: Principal): Connector;
     update(elementId: string, patch: unknown, actor: Principal): CanvasElement;
@@ -143,52 +151,6 @@ declare class Board {
     private write;
 }
 
-declare const MAX_FLOW_NODES = 500;
-declare const MAX_FLOW_EDGES = 2000;
-interface FlowNode {
-    id: string;
-    text: string;
-    shape: Extract<ShapeType, "rect" | "ellipse" | "diamond">;
-}
-interface FlowEdge {
-    from: string;
-    to: string;
-    text: string;
-}
-interface FlowGraph {
-    direction: "TB" | "LR";
-    nodes: FlowNode[];
-    edges: FlowEdge[];
-}
-declare function parseFlow(source: string): FlowGraph;
-interface Placement {
-    id: string;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-/** Layered layout. The top-left of the result is (0, 0). The layout breaks cycles and handles self-loops. */
-declare function layoutFlow(graph: FlowGraph): Placement[];
-interface DrawOptions {
-    /**
-     * Put in front of every id. Default: a new random prefix for each call, so two agents that draw at
-     * the same time never write the same id. A prefix you pass is used as given, and it makes ids
-     * repeatable. Up to 16 of A-Z, a-z, 0-9, _ and -.
-     */
-    idPrefix?: string;
-    /** Top-left of the drawing. Default: below the shapes already on the board. */
-    origin?: {
-        x: number;
-        y: number;
-    };
-}
-/** Draw a flow on the board. All or nothing: on any error the board stays as it was. */
-declare function drawFlow(board: Board, source: string, actor: Principal, options?: DrawOptions): {
-    nodes: string[];
-    edges: string[];
-};
-
 interface Labels {
     /** The author is an agent or acts for one. */
     machineMade: boolean;
@@ -211,63 +173,4 @@ interface BoardData {
 /** The board as plain data for an agent. Reads only. Embedded image bytes are left out. */
 declare function readBoard(board: Board): BoardData;
 
-/** One place for every board operation. The CLI, the MCP server, and the Worker call it. */
-declare class CanvasService {
-    private readonly store;
-    constructor(store: Store);
-    create(actor: Principal, options?: {
-        id?: string;
-        title?: string;
-    }): Promise<{
-        id: string;
-        title: string;
-    }>;
-    /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
-    assertExists(id: string): Promise<void>;
-    read(id: string): Promise<BoardData & {
-        id: string;
-    }>;
-    /** Run `change` on the board and save it, all inside one transaction. */
-    change<R>(id: string, change: (board: Board) => R): Promise<R>;
-    add(id: string, shape: unknown, actor: Principal): Promise<Shape>;
-    connect(id: string, connector: unknown, actor: Principal): Promise<Connector>;
-    move(id: string, elementId: string, dx: number, dy: number, actor: Principal): Promise<{
-        moved: string[];
-    }>;
-    remove(id: string, elementId: string): Promise<{
-        removed: string[];
-    }>;
-    flow(id: string, text: string, actor: Principal, options?: DrawOptions): Promise<{
-        nodes: string[];
-        edges: string[];
-    }>;
-    exportSvg(id: string): Promise<string>;
-    /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
-    state(id: string): Promise<Uint8Array>;
-    /**
-     * 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.
-     */
-    checkpoint(id: string, update: Uint8Array, actor: Principal, authors?: Principal[]): Promise<{
-        elements: number;
-        fixed: string[];
-    }>;
-    /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
-    repair(id: string, actor: Principal, drop?: string[]): Promise<{
-        id: string;
-        fixed: string[];
-        elements: number;
-    }>;
-    private load;
-}
-/** What the CLI and the MCP server need. `CanvasService` runs it on a store, and `LiveService` runs it in a live room. */
-type BoardAccess = Pick<CanvasService, "create" | "read" | "add" | "connect" | "move" | "remove" | "flow" | "exportSvg">;
-
-export { Board as B, type Connector as C, type DrawOptions as D, type EdgeData as E, type FlowEdge as F, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type Shape as S, type BoardAccess as a, type BoardData as b, CanvasService as c, type CanvasElement as d, CanvasError as e, type Endpoint as f, type ErrorCode as g, type FlowGraph as h, type FlowNode as i, MAX_FLOW_EDGES as j, MAX_FLOW_NODES as k, MAX_TEXT as l, type Placement as m, SHAPE_TYPES as n, type ShapeType as o, drawFlow as p, layoutFlow as q, parseFlow as r, principalSchema as s, readBoard as t };
+export { type BoardData as B, type Connector as C, type ErrorCode as E, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type ShapeType as S, type Shape as a, type Endpoint as b, Board as c, type CanvasElement as d, CanvasError as e, type EdgeData as f, MAX_TEXT as g, SHAPE_TYPES as h, principalSchema as p, readBoard as r };