agentic-canvas 0.0.0-stage → 0.1.0

package/dist/chunk-NSZ2AC5O.js

@@ -0,0 +1,932 @@
+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";
+var principalSchema = z.object({ kind: z.enum(PRINCIPAL_KINDS), id: z.string().min(1).max(200) }).strict();
+
+// src/core/board.ts
+import { randomUUID } from "crypto";
+import * as Y from "yjs";
+import { z as z2 } from "zod";
+var CanvasError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CanvasError";
+  }
+  code;
+};
+var SHAPE_TYPES = ["rect", "ellipse", "diamond", "text", "sticky", "frame", "image"];
+var MAX_ELEMENTS = 1e4;
+var MAX_TEXT = 1e4;
+var id = z2.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
+var coord = z2.number().finite().min(-1e7).max(1e7);
+var size = z2.number().finite().gt(0).max(1e7);
+var text = z2.string().max(MAX_TEXT);
+var COLOR_PATTERN = /^(#[0-9a-fA-F]{3,8}|[a-z]{3,20})$/;
+var IMAGE_PATTERN = /^(data:image\/(png|jpeg|gif|webp);base64,[A-Za-z0-9+/]+=*|blob:[A-Za-z0-9._-]{1,200})$/;
+var color = z2.string().regex(COLOR_PATTERN);
+var imageSrc = z2.string().max(2e6).regex(IMAGE_PATTERN);
+var endpoint = z2.union([z2.object({ id }).strict(), z2.object({ x: coord, y: coord }).strict()]);
+var shapeInput = z2.object({
+  id: id.optional(),
+  type: z2.enum(SHAPE_TYPES),
+  x: coord,
+  y: coord,
+  w: size.default(120),
+  h: size.default(60),
+  text: text.default(""),
+  fill: color.optional(),
+  stroke: color.optional(),
+  src: imageSrc.optional()
+}).strict().refine((s) => s.type === "image" === (s.src !== void 0), {
+  message: "src is required for image shapes and allowed on no other type"
+});
+var connectorInput = z2.object({
+  id: id.optional(),
+  from: endpoint,
+  to: endpoint,
+  text: text.default(""),
+  startArrow: z2.boolean().default(false),
+  endArrow: z2.boolean().default(true),
+  stroke: color.optional()
+}).strict();
+var shapePatch = z2.object({ x: coord, y: coord, w: size, h: size, text, fill: color, stroke: color, src: imageSrc }).partial().strict();
+var connectorPatch = z2.object({ from: endpoint, to: endpoint, text, startArrow: z2.boolean(), endArrow: z2.boolean(), stroke: color }).partial().strict();
+var delta = z2.number().finite().min(-2e7).max(2e7);
+var MAX_Z = 1e9;
+var stampFields = {
+  id,
+  z: z2.number().finite().min(-MAX_Z).max(MAX_Z),
+  groupId: id.optional(),
+  author: principalSchema,
+  editedBy: principalSchema
+};
+var storedShape = z2.object({ ...stampFields, type: z2.enum(SHAPE_TYPES), x: coord, y: coord, w: size, h: size, text, fill: color.optional(), stroke: color.optional(), src: imageSrc.optional() }).refine((s) => s.type === "image" === (s.src !== void 0), { message: "src is required for image shapes and allowed on no other type" });
+var storedConnector = z2.object({
+  ...stampFields,
+  type: z2.literal("connector"),
+  from: endpoint,
+  to: endpoint,
+  text,
+  startArrow: z2.boolean(),
+  endArrow: z2.boolean(),
+  stroke: color.optional()
+});
+var storedGroup = z2.object({ ...stampFields, type: z2.literal("group") });
+var storedElement = z2.union([storedShape, storedConnector, storedGroup]);
+var titleSchema = z2.string().max(200);
+function parse(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "input"}: ${i.message}`);
+    throw new CanvasError("INVALID", issues.join("; "));
+  }
+  return result.data;
+}
+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 hasId = (e) => typeof e === "object" && e !== null && typeof e.id === "string";
+var Board = class _Board {
+  doc;
+  elements;
+  meta;
+  maxElements;
+  constructor(doc = new Y.Doc(), options = {}) {
+    this.maxElements = Math.min(options.maxElements ?? MAX_ELEMENTS, MAX_ELEMENTS);
+    this.doc = doc;
+    this.elements = doc.getMap("elements");
+    this.meta = doc.getMap("meta");
+  }
+  /** Load a saved board with no element checks. Only the owner repair path uses it. */
+  static open(update) {
+    const doc = new Y.Doc();
+    Y.applyUpdate(doc, update);
+    return new _Board(doc);
+  }
+  /**
+   * Load a saved board. Refuses a doc past the element cap. Then it deletes every entry that fails
+   * 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;
+  }
+  encode() {
+    return Y.encodeStateAsUpdate(this.doc);
+  }
+  /** An independent copy. Edits to it leave this board alone. */
+  clone() {
+    const copy = _Board.decode(this.encode());
+    copy.maxElements = this.maxElements;
+    return copy;
+  }
+  get title() {
+    const value = titleSchema.safeParse(this.meta.get("title"));
+    return value.success ? value.data : "";
+  }
+  get titleBy() {
+    const value = principalSchema.safeParse(this.meta.get("titleBy"));
+    return value.success ? value.data : void 0;
+  }
+  setTitle(title, actor) {
+    const t = parse(z2.string().max(200), title);
+    const by = parse(principalSchema, actor);
+    this.doc.transact(() => {
+      this.meta.set("title", t);
+      this.meta.set("titleBy", by);
+    });
+  }
+  /** One element. An invalid entry, or a connector with a missing bound end, is hidden. */
+  get(elementId) {
+    const el = this.stored(elementId);
+    return el && !this.isDetached(el, (endId) => this.stored(endId)) ? el : void 0;
+  }
+  /** All visible elements from back to front. */
+  list() {
+    const all = this.storedList();
+    const byId = new Map(all.map((e) => [e.id, e]));
+    return all.filter((e) => !this.isDetached(e, (endId) => byId.get(endId)));
+  }
+  /**
+   * Delete what peers can leave broken: entries that fail the element checks, connectors whose
+   * bound end is gone, and members that name a deleted group. Idempotent, so every peer may run it.
+   * `drop` names elements the owner removes too, with what they hold: a shape takes its connectors,
+   * a group takes its members. Refuses a result still past the cap, and then changes nothing.
+   * Returns the ids fixed.
+   */
+  repair(drop = []) {
+    const all = this.allStored();
+    const byId = new Map(all.map((e) => [e.id, e]));
+    const doomed = new Set([...this.elements.keys()].filter((key) => !byId.has(key)));
+    for (const name of drop) {
+      if (byId.has(name)) this.subtreeIn(all, name).forEach((d) => doomed.add(d));
+      else if (!this.elements.has(name)) throw new CanvasError("NOT_FOUND", `no element "${name}"`);
+    }
+    const alive = all.filter((e) => !doomed.has(e.id));
+    const aliveById = new Map(alive.map((e) => [e.id, e]));
+    const detached = new Set(alive.filter((e) => this.isDetached(e, (endId) => aliveById.get(endId))).map((e) => e.id));
+    const kept = alive.filter((e) => !detached.has(e.id));
+    if (kept.length > this.maxElements) throw new CanvasError("LIMIT", `a board holds at most ${this.maxElements} elements`);
+    const loose = kept.filter((e) => e.groupId !== void 0 && aliveById.get(e.groupId)?.type !== "group").map((e) => e.id);
+    this.doc.transact(() => {
+      [...doomed, ...detached].forEach((d) => this.elements.delete(d));
+      loose.forEach((l) => this.elements.get(l)?.delete("groupId"));
+    });
+    return [.../* @__PURE__ */ new Set([...doomed, ...detached, ...loose])].sort();
+  }
+  addShape(input, actor) {
+    const { id: given, ...fields } = parse(shapeInput, input);
+    return this.create({ ...fields, id: given }, actor);
+  }
+  addConnector(input, actor) {
+    const { id: given, ...fields } = parse(connectorInput, input);
+    this.checkEnd(fields.from);
+    this.checkEnd(fields.to);
+    return this.create({ ...fields, type: "connector", id: given }, actor);
+  }
+  update(elementId, patch, actor) {
+    const by = parse(principalSchema, actor);
+    const el = this.require(elementId);
+    if (el.type === "group") throw new CanvasError("INVALID", "a group has no fields to update");
+    const fields = parse(el.type === "connector" ? connectorPatch : shapePatch, patch);
+    if (Object.keys(fields).length === 0) throw new CanvasError("INVALID", "patch is empty");
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === void 0 && key !== "fill" && key !== "stroke") throw new CanvasError("INVALID", `${key} cannot be cleared`);
+    }
+    if ("src" in fields && el.type !== "image") throw new CanvasError("INVALID", "only an image has a src");
+    if (el.type === "connector") {
+      this.checkEnd(fields.from);
+      this.checkEnd(fields.to);
+    }
+    this.write([[elementId, fields]], by);
+    return this.get(elementId);
+  }
+  /** Shift an element, or a whole group. Returns the ids that moved. Bound connector ends follow their shapes. */
+  move(elementId, dx, dy, actor) {
+    const by = parse(principalSchema, actor);
+    const [mx, my] = parse(z2.tuple([delta, delta]), [dx, dy]);
+    this.require(elementId);
+    const free = (e) => hasId(e) ? e : { x: e.x + mx, y: e.y + my };
+    const plan = [];
+    for (const memberId of this.subtree(elementId)) {
+      const el = this.get(memberId);
+      if (!el) continue;
+      if (el.type === "connector") {
+        const patch = parse(connectorPatch, { from: free(el.from), to: free(el.to) });
+        if (!hasId(el.from) || !hasId(el.to)) plan.push([memberId, patch]);
+      } else if (el.type !== "group") {
+        plan.push([memberId, parse(shapePatch, { x: el.x + mx, y: el.y + my })]);
+      }
+    }
+    this.write(plan, by);
+    return plan.map(([memberId]) => memberId);
+  }
+  /** Delete an element. A shape takes its connectors and a group takes its members. Returns the ids removed. */
+  remove(elementId) {
+    this.require(elementId);
+    const doomed = new Set(this.subtree(elementId));
+    for (const el of this.storedList()) {
+      if (el.type === "connector" && [el.from, el.to].some((e) => hasId(e) && doomed.has(e.id))) doomed.add(el.id);
+    }
+    this.doc.transact(() => doomed.forEach((d) => this.elements.delete(d)));
+    return [...doomed].sort();
+  }
+  group(ids, actor, groupId) {
+    const by = parse(principalSchema, actor);
+    const members = parse(z2.array(id).min(2).max(MAX_ELEMENTS), ids);
+    const gid = parse(id.optional(), groupId);
+    if (new Set(members).size !== members.length) throw new CanvasError("INVALID", "member ids repeat");
+    const parents = new Set(members.map((m) => this.require(m).groupId));
+    if (parents.size > 1) throw new CanvasError("BAD_REFERENCE", "members must share one parent group");
+    const [parent] = parents;
+    const group = this.create({ type: "group", id: gid, groupId: parent }, by);
+    this.write(members.map((m) => [m, { groupId: group.id }]), by);
+    return group;
+  }
+  /** Remove a group and hand its members to the parent group. */
+  ungroup(groupId, actor) {
+    const by = parse(principalSchema, actor);
+    const group = this.require(groupId);
+    if (group.type !== "group") throw new CanvasError("INVALID", `"${groupId}" is not a group`);
+    const members = this.list().filter((e) => e.groupId === groupId);
+    this.doc.transact(() => {
+      this.write(members.map((m) => [m.id, { groupId: group.groupId }]), by);
+      this.elements.delete(groupId);
+    });
+  }
+  /** Put an element, or a group with its inner order kept, in front of or behind every other element. */
+  reorder(elementId, to, actor) {
+    const by = parse(principalSchema, actor);
+    this.require(elementId);
+    const inner = new Set(this.subtree(elementId));
+    const members = this.list().filter((e) => inner.has(e.id) && e.type !== "group");
+    const start = to === "front" ? this.edgeZ(1) : this.edgeZ(-1) - (members.length - 1);
+    if (start < -MAX_Z || start + members.length - 1 > MAX_Z) throw new CanvasError("LIMIT", `z order is full: values must stay within ${MAX_Z}`);
+    this.write(members.map((m, i) => [m.id, { z: start + i }]), by);
+  }
+  /** One stored element that passes the checks and whose id matches its key, or undefined. */
+  stored(key) {
+    const entry = this.elements.get(key);
+    if (!(entry instanceof Y.Map)) return void 0;
+    const parsed = storedElement.safeParse(entry.toJSON());
+    return parsed.success && parsed.data.id === key ? parsed.data : void 0;
+  }
+  /** Every stored element that passes the checks, from back to front. Refuses a doc past the cap. */
+  storedList() {
+    if (this.elements.size > MAX_ELEMENTS) throw new CanvasError("LIMIT", `a board holds at most ${MAX_ELEMENTS} elements`);
+    return this.allStored();
+  }
+  /** Like storedList, with no cap check. Repair needs every entry, even on a board past the cap. */
+  allStored() {
+    const all = [];
+    for (const key of this.elements.keys()) {
+      const el = this.stored(key);
+      if (el) all.push(el);
+    }
+    return all.sort((a, b) => a.z - b.z || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  }
+  /** A connector is detached when a bound end does not name a stored shape. */
+  isDetached(el, lookup) {
+    if (el.type !== "connector") return false;
+    return [el.from, el.to].some((e) => hasId(e) && !isBindable(lookup(e.id)?.type));
+  }
+  require(elementId) {
+    const el = this.get(elementId);
+    if (!el) throw new CanvasError("NOT_FOUND", `no element "${elementId}"`);
+    return el;
+  }
+  checkEnd(end) {
+    if (!end || !hasId(end)) return;
+    if (!isBindable(this.stored(end.id)?.type)) {
+      throw new CanvasError("BAD_REFERENCE", `"${end.id}" is not a shape a connector can bind to`);
+    }
+  }
+  /** The z value just past the top or the bottom. Not clamped: the caller checks the range. */
+  edgeZ(direction) {
+    let z4 = 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);
+    }
+    return z4 + direction;
+  }
+  /** The element and, for a group, everything below it. Cycle-safe. */
+  subtree(elementId) {
+    return this.subtreeIn(this.storedList(), elementId);
+  }
+  subtreeIn(all, elementId) {
+    const children = /* @__PURE__ */ new Map();
+    for (const { id: childId, groupId: parent } of all) {
+      if (parent !== void 0) children.set(parent, [...children.get(parent) ?? [], childId]);
+    }
+    const seen = /* @__PURE__ */ new Set([elementId]);
+    for (const next of seen) for (const child of children.get(next) ?? []) seen.add(child);
+    return [...seen];
+  }
+  create(fields, actor) {
+    const by = parse(principalSchema, actor);
+    const elementId = fields.id ?? randomUUID();
+    if (this.elements.has(elementId)) throw new CanvasError("DUPLICATE_ID", `element "${elementId}" already exists`);
+    if (this.elements.size >= this.maxElements) throw new CanvasError("LIMIT", `a board holds at most ${this.maxElements} elements`);
+    const record = { ...fields, id: elementId, z: clampZ(this.edgeZ(1)), author: by, editedBy: by };
+    const entries = Object.entries(record).filter(([, v]) => v !== void 0);
+    this.doc.transact(() => this.elements.set(elementId, new Y.Map(entries)));
+    return this.get(elementId);
+  }
+  /** Apply field changes and stamp the editor, all in one transaction. An undefined value clears the field. */
+  write(plan, actor) {
+    this.doc.transact(() => {
+      for (const [elementId, fields] of plan) {
+        const m = this.elements.get(elementId);
+        for (const [key, value] of Object.entries(fields)) {
+          if (value === void 0) m.delete(key);
+          else m.set(key, value);
+        }
+        m.set("editedBy", actor);
+      }
+    });
+  }
+};
+
+// 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";
+import * as Y2 from "yjs";
+var MAX_FLOW_NODES = 500;
+var MAX_FLOW_EDGES = 2e3;
+var MAX_FLOW_CHARS = 2e5;
+var NODE = String.raw`([A-Za-z0-9_-]{1,48})(?:\[([^\]]*)\]|\(([^)]*)\)|\{([^}]*)\})?`;
+var EDGE = new RegExp(String.raw`^${NODE}\s*->\s*${NODE}\s*(?::(.*))?$`);
+var ALONE = new RegExp(String.raw`^${NODE}$`);
+var SHAPES = ["rect", "ellipse", "diamond"];
+function parseFlow(source) {
+  if (source.length > MAX_FLOW_CHARS) throw new CanvasError("LIMIT", `flow text is over ${MAX_FLOW_CHARS} characters`);
+  const graph = { direction: "TB", nodes: [], edges: [] };
+  const byId = /* @__PURE__ */ new Map();
+  const fail = (line, message) => {
+    throw new CanvasError("INVALID", `line ${line}: ${message}`);
+  };
+  const node = (line, m, at) => {
+    const id2 = m[at];
+    if (/^edge_\d+$/.test(id2)) fail(line, `"${id2}" is reserved for connectors. Pick another node id.`);
+    const brackets = m.slice(at + 1, at + 4);
+    const open = brackets.findIndex((b) => b !== void 0);
+    const shape = SHAPES[Math.max(open, 0)];
+    const text2 = (open < 0 ? "" : brackets[open].trim()) || id2;
+    const known = byId.get(id2);
+    if (!known) {
+      const created = { id: id2, text: text2, shape, explicit: open >= 0 };
+      byId.set(id2, created);
+      graph.nodes.push(created);
+    } else if (open >= 0) {
+      if (known.explicit && (known.text !== text2 || known.shape !== shape)) fail(line, `"${id2}" is defined twice with different text`);
+      Object.assign(known, { text: text2, shape, explicit: true });
+    }
+    return id2;
+  };
+  source.replace(/^/, "").split(/\r?\n/).forEach((raw, index) => {
+    const line = index + 1;
+    const text2 = raw.trim();
+    if (text2 === "" || text2.startsWith("#") || text2.startsWith("//")) return;
+    if (/[\u0000-\u0008\u000a-\u001f\u007f]/.test(text2)) fail(line, "control characters are not allowed");
+    const direction = /^direction\s+(\S+)$/.exec(text2);
+    if (direction) {
+      if (direction[1] !== "TB" && direction[1] !== "LR") fail(line, `direction must be TB or LR, got "${direction[1]}"`);
+      graph.direction = direction[1];
+      return;
+    }
+    const edge = EDGE.exec(text2);
+    if (edge) {
+      const from = node(line, edge, 1);
+      const to = node(line, edge, 5);
+      graph.edges.push({ from, to, text: (edge[9] ?? "").trim() });
+    } else {
+      const alone = ALONE.exec(text2);
+      if (!alone) fail(line, `cannot read "${text2.slice(0, 40)}". Use "A -> B: label".`);
+      else node(line, alone, 1);
+    }
+    if (graph.nodes.length > MAX_FLOW_NODES) throw new CanvasError("LIMIT", `a flow holds at most ${MAX_FLOW_NODES} nodes`);
+    if (graph.edges.length > MAX_FLOW_EDGES) throw new CanvasError("LIMIT", `a flow holds at most ${MAX_FLOW_EDGES} edges`);
+  });
+  if (graph.nodes.length === 0) throw new CanvasError("INVALID", "the flow has no nodes");
+  return { ...graph, nodes: graph.nodes.map(({ id: id2, text: text2, shape }) => ({ id: id2, text: text2, shape })) };
+}
+function sizeOf(n) {
+  const w = Math.min(360, Math.max(120, 24 + 8 * n.text.length));
+  return n.shape === "diamond" ? { w: Math.min(360, Math.round(w * 1.5)), h: 90 } : { w, h: 60 };
+}
+function layoutFlow(graph) {
+  const g = new dagre.graphlib.Graph({ multigraph: true });
+  g.setGraph({ rankdir: graph.direction, nodesep: 40, ranksep: 70, marginx: 0, marginy: 0 });
+  g.setDefaultEdgeLabel(() => ({}));
+  const index = new Map(graph.nodes.map((n, i) => [n.id, `n${i}`]));
+  const sizes = graph.nodes.map(sizeOf);
+  sizes.forEach(({ w, h }, i) => g.setNode(`n${i}`, { width: w, height: h }));
+  graph.edges.forEach((e, i) => g.setEdge(index.get(e.from), index.get(e.to), {}, String(i)));
+  dagre.layout(g);
+  const boxes = graph.nodes.map((n, i) => {
+    const { w, h } = sizes[i];
+    const c = g.node(`n${i}`);
+    return { id: n.id, x: Math.round(c.x - w / 2), y: Math.round(c.y - h / 2), w, h };
+  });
+  const minX = Math.min(...boxes.map((b) => b.x));
+  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 = {}) {
+  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 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 text2 = new Map(graph.nodes.map((n) => [n.id, n]));
+  for (const p of placed) {
+    const n = text2.get(p.id);
+    work.addShape({ id: prefix + p.id, type: n.shape, text: n.text, x: p.x + origin.x, y: p.y + origin.y, w: p.w, h: p.h }, actor);
+  }
+  const edges = graph.edges.map((e, i) => {
+    const id2 = `${prefix}edge_${i + 1}`;
+    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)));
+  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();
+  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) });
+      continue;
+    }
+    const labels = { machineMade: isMachineMade(el.author.kind), lastEditMachineMade: isMachineMade(el.editedBy.kind) };
+    if (el.text !== "") data.texts.push(el.text);
+    if (el.type === "connector") data.edges.push({ ...el, ...labels });
+    else {
+      const src = el.src?.startsWith("data:") ? `${el.src.slice(0, el.src.indexOf(","))},(${el.src.length} characters left out)` : el.src;
+      data.nodes.push({ ...el, ...src === void 0 ? {} : { src }, ...labels });
+    }
+  }
+  return data;
+}
+
+// src/core/svg.ts
+var LINE = 17;
+var num2 = (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 : "";
+var within = (n, low, high) => typeof n === "number" && Number.isFinite(n) && n >= low && n <= high;
+var LIMIT_COORD = 1e7;
+var TYPES = /* @__PURE__ */ new Set([...SHAPE_TYPES, "connector", "group"]);
+var sane = (s) => within(s.x, -LIMIT_COORD, LIMIT_COORD) && within(s.y, -LIMIT_COORD, LIMIT_COORD) && within(s.w, 1e-6, LIMIT_COORD) && within(s.h, 1e-6, LIMIT_COORD);
+var isShape = (v) => "w" in v;
+var center = (s) => ({ x: s.x + s.w / 2, y: s.y + s.h / 2 });
+function edgePoint(s, toward) {
+  const c = center(s);
+  const dx = toward.x - c.x;
+  const dy = toward.y - c.y;
+  if (dx === 0 && dy === 0) return c;
+  const a = s.w / 2;
+  const b = s.h / 2;
+  const k = s.type === "ellipse" ? 1 / Math.hypot(dx / a, dy / b) : s.type === "diamond" ? 1 / (Math.abs(dx) / a + Math.abs(dy) / b) : Math.min(a / Math.abs(dx), b / Math.abs(dy));
+  return { x: c.x + dx * k, y: c.y + dy * k };
+}
+function wrap(text2, width) {
+  const max = Math.max(4, Math.floor((width - 16) / 7.5));
+  const out = [];
+  for (const paragraph of text2.split(/\r?\n/)) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      const chars = [...word];
+      while (chars.length > max) {
+        if (line) out.push(line);
+        line = "";
+        out.push(chars.splice(0, max).join(""));
+      }
+      const rest = chars.join("");
+      if (line && [...line].length + 1 + chars.length > max) {
+        out.push(line);
+        line = rest;
+      } else line = line ? `${line} ${rest}` : rest;
+    }
+    out.push(line);
+  }
+  return out.slice(0, 40);
+}
+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>`);
+  return `<text text-anchor="middle" dominant-baseline="central"${extra}>${spans.join("")}</text>`;
+}
+function shapeBody(s) {
+  const { x, y, w, h } = s;
+  const stroke = paint(s.stroke, "#1f2937");
+  const look = (fill, more = "") => `fill="${paint(s.fill, fill)}" stroke="${stroke}" stroke-width="2"${more}`;
+  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}`;
+    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}`;
+    }
+    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)}`;
+    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 `<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)}`;
+    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}`;
+  }
+}
+var endKey = (e) => "id" in e ? e.id : `${e.x},${e.y}`;
+var wellFormed = (e) => typeof e === "object" && e !== null && (typeof e.id === "string" || within(e.x, -LIMIT_COORD, LIMIT_COORD) && within(e.y, -LIMIT_COORD, LIMIT_COORD));
+function connectorBody(c, shapes, lane) {
+  const resolve = (e) => "id" in e ? shapes.get(e.id) : e;
+  const a = resolve(c.from);
+  const b = resolve(c.to);
+  if (!a || !b) return "";
+  let d;
+  let at;
+  if (isShape(a) && a === b) {
+    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)}`;
+    at = { x: a.x + a.w / 2, y: a.y - lift * 0.75 - 6 };
+  } else {
+    const ca = isShape(a) ? center(a) : a;
+    const cb = isShape(b) ? center(b) : b;
+    const flip = endKey(c.from) > endKey(c.to);
+    const dx = (flip ? ca.x - cb.x : cb.x - ca.x) || 0;
+    const dy = (flip ? ca.y - cb.y : cb.y - ca.y) || 0;
+    const len = Math.hypot(dx, dy) || 1;
+    const offset = (lane.index - (lane.count - 1) / 2) * 44;
+    const mid = { x: (ca.x + cb.x) / 2, y: (ca.y + cb.y) / 2 };
+    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)}`;
+    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)"' : ""}`;
+  const halo = ' stroke="#ffffff" stroke-width="4" paint-order="stroke"';
+  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();
+  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();
+  const box = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+  const grow = (x, y) => {
+    box.minX = Math.min(box.minX, x);
+    box.minY = Math.min(box.minY, y);
+    box.maxX = Math.max(box.maxX, x);
+    box.maxY = Math.max(box.maxY, y);
+  };
+  for (const el of all) {
+    if (el.type === "connector") {
+      for (const e of [el.from, el.to]) if (!("id" in e)) grow(e.x, e.y);
+    } else if (el.type !== "group") {
+      shapes.set(el.id, el);
+      grow(el.x, el.y);
+      grow(el.x + el.w, el.y + el.h);
+    }
+  }
+  const pad = 80;
+  const any = box.minX !== Infinity;
+  const minX = any ? box.minX - pad : 0;
+  const minY = any ? box.minY - pad : 0;
+  const width = any ? Math.ceil(box.maxX + pad - minX) : 240;
+  const height = any ? Math.ceil(box.maxY + pad - minY) : 120;
+  const lanes = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const el of all) {
+    if (el.type !== "connector") continue;
+    const key = [endKey(el.from), endKey(el.to)].sort().join("|");
+    groups.set(key, [...groups.get(key) ?? [], el.id]);
+  }
+  for (const ids of groups.values()) ids.forEach((id2, index) => lanes.set(id2, { index, count: ids.length }));
+  const body = all.map((el) => {
+    if (el.type === "group") return "";
+    const inner = el.type === "connector" ? connectorBody(el, shapes, lanes.get(el.id)) : shapeBody(el);
+    if (inner === "") return "";
+    const kind = el.author.kind;
+    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";
+  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}">`,
+    `<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"/>`,
+    ...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,
+  CanvasError,
+  SHAPE_TYPES,
+  MAX_ELEMENTS,
+  MAX_TEXT,
+  Board,
+  ActorConfigError,
+  operatorActor,
+  createMcpServer,
+  runMcp,
+  MAX_FLOW_NODES,
+  MAX_FLOW_EDGES,
+  parseFlow,
+  layoutFlow,
+  drawFlow,
+  readBoard,
+  toSvg,
+  svgToPng,
+  CanvasService
+};