agentic-canvas 0.1.0 → 0.2.0

package/README.md

@@ -7,9 +7,9 @@
 
 A shared whiteboard for diagrams, drawn by people and agents.
 
-> Status: 0.1.0, the first release. The board model, the agent operations, the
-> exports, the CLI, and the MCP server work. The HTTP API and the web UI are not
-> built yet.
+> Status: 0.2.0. The board model, the agent operations, the exports, the CLI, the
+> MCP server, a small Worker API, and live co-editing work. The CLI, the MCP server,
+> and the SDK can join a live room. The web UI is not built yet.
 
 ## Install
 
@@ -101,11 +101,30 @@ the direction. Lines that start with `#` or `//` are comments.
   and every network request blocked. A board over 16 million pixels exports as SVG only.
 - A CLI over a local file store. Several processes can write at once.
 - An MCP server (stdio) over the same service as the CLI.
+- A Worker (`agentic-canvas/worker`) under `/api/v1/canvas`. Boards live in D1 and images in R2
+  (EU jurisdiction), through the shared `Store` and `Blobs` ports. Set `CANVAS_API_TOKENS`
+  (a JSON map of token to `{ actor, kind }`, tokens of 32 characters or more) and `CANVAS_REGION`.
+  Routes: `POST /boards`, `GET /boards/:id`, `GET /boards/:id/svg`, `POST /boards/:id/shapes`,
+  `/connectors`, `/flow`, `/move`, `DELETE /boards/:id/elements/:element`, `POST /images`,
+  `GET /images/:id`. An image is stored under the SHA-256 of its bytes, and the reply gives
+  the `blob:` ref for a shape. A busy database or bucket answers 503: try again.
+- Live rooms (`agentic-canvas/live-worker`, on `agentic-realtime`). One Durable Object holds one
+  board. A token may carry `"role": "viewer"`: a viewer reads and cannot write. `GET /boards/:id/ws`
+  opens a room, `GET /me` says who a token is, `GET /boards/:id/state` and
+  `POST /boards/:id/checkpoint` seed a room from the stored board and save it back, as a merge. A save
+  checks author stamps: a client cannot put another author on its work.
+- The SDK joins a room: `import { LiveBoard, LiveService } from "agentic-canvas/live"`. The CLI and the MCP
+  server join when `CANVAS_SERVER` and `CANVAS_TOKEN` are set. The token sets the actor, so
+  `CANVAS_ACTOR` is not needed. `--dir`, `CANVAS_DIR`, and `repair` stay local.
 - Yjs underneath: two copies of a board merge without conflicts.
 - No UI code. The model is plain TypeScript on Yjs, with no outbound calls.
 
 ## Limits
 
+- Canvas takes principal kinds, regions, and the Store and Blobs ports from `agentic-identity` 0.4.
+  It does not use the sharing API yet. Its editor and viewer tokens are a separate table in
+  `CANVAS_API_TOKENS`. It has no board delete or erase. When it adopts sharing, grants are keyed
+  on kind and id, and a delete calls `deleteResource`.
 - A board holds at most 10,000 elements. A flow holds at most 500 nodes and 2,000
   edges.
 - Flow text has no chains (`A -> B -> C`). Write one edge per line.
@@ -133,7 +152,14 @@ the direction. Lines that start with `#` or `//` are comments.
 - Node 22 or newer is needed. `agentic-canvas/file-store` exports `createFileStore(path)` and
   `openLocalStore(dir)`. A writer that is paused for more than 30 seconds can lose its lock
   and then still write.
-- Delete leaves no audit record yet. The caller logs it.
+- A room remembers its authors for good, so a client can stamp an element with the name of anyone who
+  once sent an update in that room. A save corrects the stored board and not the room: after a save that
+  reports `fixed`, join again. A client that adds a root Yjs type of its own blocks later saves of that room.
+- Every Worker token reaches every board. A token has an editor or viewer role, and nothing finer yet. Local
+  `wrangler dev` cannot confirm a region, so run it with `CANVAS_REGION=unknown`. The region claim covers D1 only: R2 reports no region, so the bucket is in
+  the EU jurisdiction only if you create it so. A real D1
+  confirms `eu` or `us` on each query. The Worker has no PNG export.
+- Delete leaves no audit record yet. The Worker logs the actor kind of each delete, and no ids.
 - PNG needs the optional `playwright-core` and a Chromium. Without them it fails with
   `UNAVAILABLE`. SVG always works.
 

package/SKILL.md

@@ -36,6 +36,9 @@ agentic-canvas read demo
 agentic-canvas export demo --out demo.svg
 ```
 
+To edit a board that a person has open, use live mode. Set `CANVAS_SERVER` and `CANVAS_TOKEN`
+and run the same commands. The token names the actor, so leave `CANVAS_ACTOR` unset.
+
 ## Rules
 
 - Name the actor on every write.

package/dist/{chunk-NSZ2AC5O.js → chunk-GGQPE65T.js}

@@ -1,18 +1,3 @@
-import {
-  FileStoreError
-} from "./chunk-I3EJ5JB7.js";
-
-// src/version.ts
-import { createRequire } from "module";
-var VERSION = true ? "0.1.0" : readPackageVersion();
-
-// src/brand.ts
-var BRAND = {
-  command: "agentic-canvas",
-  description: "A shared whiteboard for diagrams, drawn by people and agents.",
-  version: VERSION
-};
-
 // src/core/principal.ts
 import { PRINCIPAL_KINDS, isMachineMade } from "agentic-identity";
 import { z } from "zod";
@@ -101,6 +86,7 @@ function parse(schema, value) {
 var isBindable = (type) => typeof type === "string" && type !== "connector" && type !== "group";
 var isValidZ = (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= MAX_Z;
 var clampZ = (value) => Math.min(MAX_Z, Math.max(-MAX_Z, value));
+var samePrincipal = (a, b) => a.kind === b.kind && a.id === b.id;
 var hasId = (e) => typeof e === "object" && e !== null && typeof e.id === "string";
 var Board = class _Board {
   doc;
@@ -124,10 +110,10 @@ var Board = class _Board {
    * the element checks, and repairs what concurrent writers left broken.
    */
   static decode(update) {
-    const board2 = _Board.open(update);
-    if (board2.elements.size > MAX_ELEMENTS) throw new CanvasError("LIMIT", `a board holds at most ${MAX_ELEMENTS} elements`);
-    board2.repair();
-    return board2;
+    const board = _Board.open(update);
+    if (board.elements.size > MAX_ELEMENTS) throw new CanvasError("LIMIT", `a board holds at most ${MAX_ELEMENTS} elements`);
+    board.repair();
+    return board;
   }
   encode() {
     return Y.encodeStateAsUpdate(this.doc);
@@ -192,6 +178,63 @@ var Board = class _Board {
     });
     return [.../* @__PURE__ */ new Set([...doomed, ...detached, ...loose])].sort();
   }
+  /**
+   * Make the author stamps of a merged board honest. `prior` is the board before the merge, and `trusted` says whether
+   * a principal really wrote in this session. A new element stamped by anyone else is deleted. An old element keeps its
+   * 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.
+   */
+  restamp(prior, trusted) {
+    const before = new Map(prior.allStored().map((e) => [e.id, e]));
+    const body = ({ author: _a, editedBy: _e, ...rest }) => JSON.stringify(rest);
+    const fixed = [];
+    this.doc.transact(() => {
+      for (const el of this.allStored()) {
+        const old = before.get(el.id);
+        if (!old) {
+          if (trusted(el.author) && trusted(el.editedBy)) continue;
+          this.elements.delete(el.id);
+        } else {
+          const entry = this.elements.get(el.id);
+          const authorKept = samePrincipal(el.author, old.author);
+          const editorOk = trusted(el.editedBy) || samePrincipal(el.editedBy, old.editedBy);
+          const changed = body(el) !== body(old);
+          if (authorKept && editorOk && !(changed && !trusted(el.editedBy))) continue;
+          if (changed && !trusted(el.editedBy)) this.elements.set(el.id, new Y.Map(Object.entries(old).filter(([, v]) => v !== void 0)));
+          else {
+            if (!authorKept) entry.set("author", old.author);
+            if (!editorOk) entry.set("editedBy", old.editedBy);
+          }
+        }
+        fixed.push(el.id);
+      }
+      for (const el of this.allStored()) {
+        const entry = this.elements.get(el.id);
+        const extra = [...entry.keys()].filter((key) => !(key in el) || entry.get(key) instanceof Y.AbstractType);
+        extra.forEach((key) => entry.delete(key));
+        if (extra.length > 0 && !fixed.includes(el.id)) fixed.push(el.id);
+      }
+      const same = (key) => !(this.meta.get(key) instanceof Y.AbstractType) && JSON.stringify(this.meta.get(key)) === JSON.stringify(prior.meta.get(key));
+      const by = this.titleBy;
+      const title = this.meta.get("title");
+      const honest = by !== void 0 && trusted(by) && (title === void 0 || titleSchema.safeParse(title).success);
+      if (!honest && !(same("title") && same("titleBy"))) {
+        for (const key of ["title", "titleBy"]) {
+          const old = prior.meta.get(key);
+          if (old === void 0) this.meta.delete(key);
+          else this.meta.set(key, old);
+        }
+        fixed.push("title");
+      }
+      for (const key of [...this.meta.keys()]) {
+        if (key === "title" || key === "titleBy") continue;
+        this.meta.delete(key);
+        fixed.push(`meta:${key}`);
+      }
+    });
+    return fixed;
+  }
   addShape(input, actor) {
     const { id: given, ...fields } = parse(shapeInput, input);
     return this.create({ ...fields, id: given }, actor);
@@ -321,12 +364,12 @@ var Board = class _Board {
   }
   /** The z value just past the top or the bottom. Not clamped: the caller checks the range. */
   edgeZ(direction) {
-    let z4 = 0;
+    let z3 = 0;
     for (const m of this.elements.values()) {
       const value = m instanceof Y.Map ? m.get("z") : void 0;
-      if (isValidZ(value)) z4 = direction === 1 ? Math.max(z4, value) : Math.min(z4, value);
+      if (isValidZ(value)) z3 = direction === 1 ? Math.max(z3, value) : Math.min(z3, value);
     }
-    return z4 + direction;
+    return z3 + direction;
   }
   /** The element and, for a group, everything below it. Cycle-safe. */
   subtree(elementId) {
@@ -366,113 +409,6 @@ var Board = class _Board {
   }
 };
 
-// src/actor.ts
-var ActorConfigError = class extends Error {
-};
-function operatorActor(env = process.env) {
-  const raw = env.CANVAS_ACTOR;
-  if (!raw) throw new ActorConfigError("the operator must set CANVAS_ACTOR=<kind>:<id>");
-  const at = raw.indexOf(":");
-  const parsed = principalSchema.safeParse({ kind: raw.slice(0, at), id: raw.slice(at + 1) });
-  if (at < 0 || !parsed.success) {
-    throw new ActorConfigError(`bad CANVAS_ACTOR "${raw}": use <kind>:<id>, kind is one of ${PRINCIPAL_KINDS.join(", ")}`);
-  }
-  return parsed.data;
-}
-
-// src/mcp.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z3 } from "zod";
-var json = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }] });
-function failure(error) {
-  if (!(error instanceof CanvasError)) console.error(error instanceof Error ? error.message : String(error));
-  const body = error instanceof CanvasError ? { code: error.code, message: error.message } : { code: "INTERNAL", message: "the board operation failed" };
-  return { isError: true, content: [{ type: "text", text: JSON.stringify(body) }] };
-}
-function tool(run) {
-  return async (args) => {
-    try {
-      return await run(args);
-    } catch (error) {
-      return failure(error);
-    }
-  };
-}
-var board = z3.string().describe("Board id.");
-var num = z3.number();
-function createMcpServer(service, actor) {
-  const server = new McpServer({ name: BRAND.command, version: BRAND.version });
-  const read = { readOnlyHint: true };
-  server.registerTool(
-    "create_board",
-    { description: "Make a board.", inputSchema: { id: z3.string().optional(), title: z3.string().optional() } },
-    tool(async (a) => json(await service.create(actor, a)))
-  );
-  server.registerTool(
-    "read_board",
-    { description: "Read a board as data: nodes, edges, groups, text, and who made what.", inputSchema: { board }, annotations: read },
-    tool(async (a) => json(await service.read(a.board)))
-  );
-  server.registerTool(
-    "add_shape",
-    {
-      description: "Add a shape. Image shapes need src.",
-      inputSchema: {
-        board,
-        id: z3.string().optional(),
-        type: z3.enum(SHAPE_TYPES),
-        x: num,
-        y: num,
-        w: num.optional(),
-        h: num.optional(),
-        text: z3.string().optional(),
-        fill: z3.string().optional(),
-        stroke: z3.string().optional(),
-        src: z3.string().optional()
-      }
-    },
-    tool(async ({ board: b, ...shape }) => json(await service.add(b, shape, actor)))
-  );
-  server.registerTool(
-    "connect",
-    { description: "Join two shapes with an arrow.", inputSchema: { board, from: z3.string(), to: z3.string(), id: z3.string().optional(), text: z3.string().optional() } },
-    tool(async (a) => json(await service.connect(a.board, { id: a.id, from: { id: a.from }, to: { id: a.to }, text: a.text }, actor)))
-  );
-  server.registerTool(
-    "move",
-    { description: "Move an element, or a whole group.", inputSchema: { board, element: z3.string(), dx: num, dy: num } },
-    tool(async (a) => json(await service.move(a.board, a.element, a.dx, a.dy, actor)))
-  );
-  server.registerTool(
-    "remove",
-    { description: "Delete an element. A shape takes its connectors, a group its members.", inputSchema: { board, element: z3.string() }, annotations: { destructiveHint: true } },
-    tool(async (a) => json(await service.remove(a.board, a.element)))
-  );
-  server.registerTool(
-    "draw_flow",
-    {
-      description: 'Draw a flowchart from text, one statement per line: "A[Box] -> B{Choice}: label". [] box, () ellipse, {} diamond.',
-      inputSchema: { board, text: z3.string(), idPrefix: z3.string().optional() }
-    },
-    tool(async (a) => json(await service.flow(a.board, a.text, actor, { idPrefix: a.idPrefix })))
-  );
-  server.registerTool(
-    "export_svg",
-    { description: "Export the board as SVG text.", inputSchema: { board }, annotations: read },
-    tool(async (a) => ({ content: [{ type: "text", text: await service.exportSvg(a.board) }] }))
-  );
-  server.registerTool(
-    "export_png",
-    { description: "Export the board as a PNG image. Needs the optional playwright-core and a Chromium.", inputSchema: { board }, annotations: read },
-    tool(async (a) => ({ content: [{ type: "image", data: Buffer.from(await service.exportPng(a.board)).toString("base64"), mimeType: "image/png" }] }))
-  );
-  return server;
-}
-async function runMcp(service, actor) {
-  await createMcpServer(service, actor).connect(new StdioServerTransport());
-}
-
 // src/core/flow.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import dagre from "@dagrejs/dagre";
@@ -558,17 +494,17 @@ function layoutFlow(graph) {
   const minY = Math.min(...boxes.map((b) => b.y));
   return boxes.map((b) => ({ ...b, x: b.x - minX, y: b.y - minY }));
 }
-function drawFlow(board2, source, actor, options = {}) {
+function drawFlow(board, source, actor, options = {}) {
   const prefix = options.idPrefix ?? `${randomUUID2().slice(0, 8)}-`;
   if (!/^[A-Za-z0-9_-]{0,16}$/.test(prefix)) throw new CanvasError("INVALID", "idPrefix must be up to 16 of A-Z, a-z, 0-9, _ and -");
   const graph = parseFlow(source);
   const placed = layoutFlow(graph);
-  const shapes = board2.list().flatMap((e) => e.type === "connector" || e.type === "group" ? [] : [e]);
+  const shapes = board.list().flatMap((e) => e.type === "connector" || e.type === "group" ? [] : [e]);
   const origin = options.origin ?? {
     x: shapes.length ? Math.min(...shapes.map((s) => s.x)) : 0,
     y: shapes.length ? Math.max(...shapes.map((s) => s.y + s.h)) + 80 : 0
   };
-  const work = board2.clone();
+  const work = board.clone();
   const text2 = new Map(graph.nodes.map((n) => [n.id, n]));
   for (const p of placed) {
     const n = text2.get(p.id);
@@ -579,14 +515,14 @@ function drawFlow(board2, source, actor, options = {}) {
     work.addConnector({ id: id2, from: { id: prefix + e.from }, to: { id: prefix + e.to }, text: e.text }, actor);
     return id2;
   });
-  Y2.applyUpdate(board2.doc, Y2.encodeStateAsUpdate(work.doc, Y2.encodeStateVector(board2.doc)));
+  Y2.applyUpdate(board.doc, Y2.encodeStateAsUpdate(work.doc, Y2.encodeStateVector(board.doc)));
   return { nodes: placed.map((p) => prefix + p.id), edges };
 }
 
 // src/core/read.ts
-function readBoard(board2) {
-  const data = { title: board2.title, nodes: [], edges: [], groups: [], texts: [] };
-  const all = board2.list();
+function readBoard(board) {
+  const data = { title: board.title, nodes: [], edges: [], groups: [], texts: [] };
+  const all = board.list();
   for (const el of all) {
     if (el.type === "group") {
       data.groups.push({ id: el.id, members: all.filter((m) => m.groupId === el.id).map((m) => m.id) });
@@ -605,7 +541,7 @@ function readBoard(board2) {
 
 // src/core/svg.ts
 var LINE = 17;
-var num2 = (n) => String(Math.round(n * 100) / 100);
+var num = (n) => String(Math.round(n * 100) / 100);
 var esc = (value) => (typeof value === "string" ? value : "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f￾￿]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var paint = (value, fallback) => typeof value === "string" && COLOR_PATTERN.test(value) ? value : fallback;
 var str = (value) => typeof value === "string" ? value : "";
@@ -651,7 +587,7 @@ function label(text2, cx, cy, width, extra = "") {
   if (text2 === "") return "";
   const lines = wrap(text2, width);
   const top = cy - (lines.length - 1) * LINE / 2;
-  const spans = lines.map((l, i) => `<tspan x="${num2(cx)}" y="${num2(top + i * LINE)}">${esc(l)}</tspan>`);
+  const spans = lines.map((l, i) => `<tspan x="${num(cx)}" y="${num(top + i * LINE)}">${esc(l)}</tspan>`);
   return `<text text-anchor="middle" dominant-baseline="central"${extra}>${spans.join("")}</text>`;
 }
 function shapeBody(s) {
@@ -661,22 +597,22 @@ function shapeBody(s) {
   const text2 = label(str(s.text), x + w / 2, y + h / 2, w);
   switch (s.type) {
     case "ellipse":
-      return `<ellipse cx="${num2(x + w / 2)}" cy="${num2(y + h / 2)}" rx="${num2(w / 2)}" ry="${num2(h / 2)}" ${look("#ffffff")}/>${text2}`;
+      return `<ellipse cx="${num(x + w / 2)}" cy="${num(y + h / 2)}" rx="${num(w / 2)}" ry="${num(h / 2)}" ${look("#ffffff")}/>${text2}`;
     case "diamond": {
       const pts = [[x + w / 2, y], [x + w, y + h / 2], [x + w / 2, y + h], [x, y + h / 2]];
-      return `<polygon points="${pts.map(([px, py]) => `${num2(px)},${num2(py)}`).join(" ")}" ${look("#ffffff")}/>${text2}`;
+      return `<polygon points="${pts.map(([px, py]) => `${num(px)},${num(py)}`).join(" ")}" ${look("#ffffff")}/>${text2}`;
     }
     case "text":
       return text2;
     case "frame":
-      return `<rect x="${num2(x)}" y="${num2(y)}" width="${num2(w)}" height="${num2(h)}" ${look("none", ' stroke-dasharray="8 6"')}/>${label(str(s.text), x + w / 2, y - 12, w)}`;
+      return `<rect x="${num(x)}" y="${num(y)}" width="${num(w)}" height="${num(h)}" ${look("none", ' stroke-dasharray="8 6"')}/>${label(str(s.text), x + w / 2, y - 12, w)}`;
     case "image":
       if (typeof s.src === "string" && s.src.startsWith("data:") && IMAGE_PATTERN.test(s.src)) {
-        return `<image href="${s.src}" x="${num2(x)}" y="${num2(y)}" width="${num2(w)}" height="${num2(h)}" preserveAspectRatio="xMidYMid meet"/>`;
+        return `<image href="${s.src}" x="${num(x)}" y="${num(y)}" width="${num(w)}" height="${num(h)}" preserveAspectRatio="xMidYMid meet"/>`;
       }
-      return `<rect x="${num2(x)}" y="${num2(y)}" width="${num2(w)}" height="${num2(h)}" ${look("#f3f4f6", ' stroke-dasharray="4 4"')}/>${label("image", x + w / 2, y + h / 2, w)}`;
+      return `<rect x="${num(x)}" y="${num(y)}" width="${num(w)}" height="${num(h)}" ${look("#f3f4f6", ' stroke-dasharray="4 4"')}/>${label("image", x + w / 2, y + h / 2, w)}`;
     default:
-      return `<rect x="${num2(x)}" y="${num2(y)}" width="${num2(w)}" height="${num2(h)}" rx="${s.type === "sticky" ? 2 : 6}" ${look(s.type === "sticky" ? "#fde68a" : "#ffffff")}/>${text2}`;
+      return `<rect x="${num(x)}" y="${num(y)}" width="${num(w)}" height="${num(h)}" rx="${s.type === "sticky" ? 2 : 6}" ${look(s.type === "sticky" ? "#fde68a" : "#ffffff")}/>${text2}`;
   }
 }
 var endKey = (e) => "id" in e ? e.id : `${e.x},${e.y}`;
@@ -692,7 +628,7 @@ function connectorBody(c, shapes, lane) {
     const x0 = a.x + a.w * 0.35;
     const x1 = a.x + a.w * 0.65;
     const lift = 45 + 32 * lane.index;
-    d = `M${num2(x0)} ${num2(a.y)}C${num2(x0)} ${num2(a.y - lift)} ${num2(x1)} ${num2(a.y - lift)} ${num2(x1)} ${num2(a.y)}`;
+    d = `M${num(x0)} ${num(a.y)}C${num(x0)} ${num(a.y - lift)} ${num(x1)} ${num(a.y - lift)} ${num(x1)} ${num(a.y)}`;
     at = { x: a.x + a.w / 2, y: a.y - lift * 0.75 - 6 };
   } else {
     const ca = isShape(a) ? center(a) : a;
@@ -706,7 +642,7 @@ function connectorBody(c, shapes, lane) {
     const ctrl = { x: mid.x - dy / len * 2 * offset, y: mid.y + dx / len * 2 * offset };
     const p = isShape(a) ? edgePoint(a, ctrl) : a;
     const q = isShape(b) ? edgePoint(b, ctrl) : b;
-    d = offset === 0 ? `M${num2(p.x)} ${num2(p.y)}L${num2(q.x)} ${num2(q.y)}` : `M${num2(p.x)} ${num2(p.y)}Q${num2(ctrl.x)} ${num2(ctrl.y)} ${num2(q.x)} ${num2(q.y)}`;
+    d = offset === 0 ? `M${num(p.x)} ${num(p.y)}L${num(q.x)} ${num(q.y)}` : `M${num(p.x)} ${num(p.y)}Q${num(ctrl.x)} ${num(ctrl.y)} ${num(q.x)} ${num(q.y)}`;
     at = offset === 0 ? { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 } : { x: (p.x + q.x) / 4 + ctrl.x / 2, y: (p.y + q.y) / 4 + ctrl.y / 2 };
   }
   const marks = `${c.startArrow ? ' marker-start="url(#arrow)"' : ""}${c.endArrow ? ' marker-end="url(#arrow)"' : ""}`;
@@ -714,8 +650,8 @@ function connectorBody(c, shapes, lane) {
   return `<path d="${d}" fill="none" stroke="${paint(c.stroke, "#1f2937")}" stroke-width="2"${marks}/>${label(str(c.text), at.x, at.y, 160, halo)}`;
 }
 var drawable = (el) => TYPES.has(el.type) && (el.type === "connector" ? wellFormed(el.from) && wellFormed(el.to) : el.type === "group" || sane(el));
-function toSvg(board2) {
-  const listed = board2.list();
+function toSvg(board) {
+  const listed = board.list();
   if (listed.length > MAX_ELEMENTS) throw new CanvasError("LIMIT", `a board holds at most ${MAX_ELEMENTS} elements`);
   const all = listed.filter((el) => drawable(el));
   const shapes = /* @__PURE__ */ new Map();
@@ -757,157 +693,18 @@ function toSvg(board2) {
     const mark = `data-id="${esc(el.id)}" data-type="${el.type}" data-author-kind="${kind}" data-machine-made="${kind !== "human"}"`;
     return `<g ${mark}>${inner}</g>`;
   });
-  const title = esc(board2.title) || "Whiteboard";
+  const title = esc(board.title) || "Whiteboard";
   return [
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${num2(minX)} ${num2(minY)} ${width} ${height}" font-family="sans-serif" font-size="14" fill="#111827" role="img" aria-label="${title}">`,
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${num(minX)} ${num(minY)} ${width} ${height}" font-family="sans-serif" font-size="14" fill="#111827" role="img" aria-label="${title}">`,
     `<title>${title}</title>`,
     '<defs><marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto-start-reverse"><path d="M0 0L10 5L0 10z" fill="#1f2937"/></marker></defs>',
-    `<rect x="${num2(minX)}" y="${num2(minY)}" width="${width}" height="${height}" fill="#ffffff"/>`,
+    `<rect x="${num(minX)}" y="${num(minY)}" width="${width}" height="${height}" fill="#ffffff"/>`,
     ...body.filter(Boolean),
     "</svg>"
   ].join("\n");
 }
 
-// src/png.ts
-var MAX_SIDE = 16384;
-var MAX_PIXELS = 16e6;
-var TIMEOUT_MS = 2e4;
-async function svgToPng(svg) {
-  const size2 = /^<svg [^>]*?width="(\d+)" height="(\d+)"/.exec(svg);
-  const width = Number(size2?.[1]);
-  const height = Number(size2?.[2]);
-  if (!(width > 0 && height > 0) || width > MAX_SIDE || height > MAX_SIDE || width * height > MAX_PIXELS) {
-    throw new CanvasError("LIMIT", `the board is too large for PNG: up to ${MAX_SIDE} px a side and ${MAX_PIXELS / 1e6} million pixels`);
-  }
-  let chromium;
-  try {
-    ({ chromium } = await import("playwright-core"));
-  } catch {
-    throw new CanvasError("UNAVAILABLE", "PNG export needs the playwright-core package. Install it, or export SVG.");
-  }
-  const browser = await chromium.launch().catch(() => {
-    throw new CanvasError("UNAVAILABLE", "PNG export needs Chromium. Run: npx playwright-core install chromium");
-  });
-  try {
-    const context = await browser.newContext({ viewport: { width, height }, javaScriptEnabled: false, serviceWorkers: "block" });
-    context.setDefaultTimeout(TIMEOUT_MS);
-    await context.route("**/*", (route) => route.abort());
-    const page = await context.newPage();
-    await page.setContent(`<!doctype html><body style="margin:0">${svg}</body>`);
-    return await page.screenshot({ clip: { x: 0, y: 0, width, height } });
-  } finally {
-    await browser.close();
-  }
-}
-
-// src/service.ts
-import { assertId, StoreConflictError } from "agentic-identity";
-var COLLECTION = "boards";
-var BOARD_ID = /^[A-Za-z0-9_-]{1,64}$/;
-function toBase64(bytes) {
-  let text2 = "";
-  for (let i = 0; i < bytes.length; i += 8192) text2 += String.fromCharCode(...bytes.subarray(i, i + 8192));
-  return btoa(text2);
-}
-var fromBase64 = (text2) => Uint8Array.from(atob(text2), (c) => c.charCodeAt(0));
-function boardKey(id2) {
-  try {
-    if (!BOARD_ID.test(id2)) throw new Error();
-    assertId(id2);
-  } 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 id2;
-}
-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 id2 = boardKey(options.id ?? crypto.randomUUID());
-    const board2 = new Board();
-    if (options.title !== void 0) board2.setTitle(options.title, actor);
-    return this.store.transaction(async (tx) => {
-      if (await tx.get(COLLECTION, id2)) throw new CanvasError("DUPLICATE_ID", `board "${id2}" already exists`);
-      await tx.put(COLLECTION, id2, { update: toBase64(board2.encode()) });
-      return { id: id2, title: board2.title };
-    });
-  }
-  async read(id2) {
-    boardKey(id2);
-    return this.store.transaction(async (tx) => ({ id: id2, ...readBoard(await this.load(tx.get(COLLECTION, id2), id2)) }));
-  }
-  /** Run `change` on the board and save it, all inside one transaction. */
-  async change(id2, change) {
-    boardKey(id2);
-    return this.store.transaction(async (tx) => {
-      const board2 = await this.load(tx.get(COLLECTION, id2), id2);
-      const result = change(board2);
-      await tx.put(COLLECTION, id2, { update: toBase64(board2.encode()) });
-      return result;
-    });
-  }
-  add(id2, shape, actor) {
-    return this.change(id2, (b) => b.addShape(shape, actor));
-  }
-  connect(id2, connector, actor) {
-    return this.change(id2, (b) => b.addConnector(connector, actor));
-  }
-  move(id2, elementId, dx, dy, actor) {
-    return this.change(id2, (b) => ({ moved: b.move(elementId, dx, dy, actor) }));
-  }
-  remove(id2, elementId) {
-    return this.change(id2, (b) => ({ removed: b.remove(elementId) }));
-  }
-  flow(id2, text2, actor, options) {
-    return this.change(id2, (b) => drawFlow(b, text2, actor, options));
-  }
-  async exportSvg(id2) {
-    boardKey(id2);
-    return this.store.transaction(async (tx) => toSvg(await this.load(tx.get(COLLECTION, id2), id2)));
-  }
-  async exportPng(id2) {
-    return svgToPng(await this.exportSvg(id2));
-  }
-  /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
-  async repair(id2, 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(id2);
-    return this.store.transaction(async (tx) => {
-      const doc = await tx.get(COLLECTION, id2);
-      if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id2}"`);
-      const board2 = decodeStored(doc, id2, Board.open);
-      const fixed = board2.repair(drop);
-      await tx.put(COLLECTION, id2, { update: toBase64(board2.encode()) });
-      return { id: id2, fixed, elements: board2.list().length };
-    });
-  }
-  async load(read, id2) {
-    const doc = await read;
-    if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id2}"`);
-    return decodeStored(doc, id2, Board.decode);
-  }
-};
-function decodeStored(doc, id2, decode) {
-  try {
-    return decode(fromBase64(String(doc.update)));
-  } catch (error) {
-    if (error instanceof CanvasError) throw error;
-    throw new CanvasError("INVALID", `stored board "${id2}" is damaged`);
-  }
-}
-
 export {
-  VERSION,
-  BRAND,
   PRINCIPAL_KINDS,
   isMachineMade,
   principalSchema,
@@ -916,17 +713,11 @@ export {
   MAX_ELEMENTS,
   MAX_TEXT,
   Board,
-  ActorConfigError,
-  operatorActor,
-  createMcpServer,
-  runMcp,
   MAX_FLOW_NODES,
   MAX_FLOW_EDGES,
   parseFlow,
   layoutFlow,
   drawFlow,
   readBoard,
-  toSvg,
-  svgToPng,
-  CanvasService
+  toSvg
 };