agentic-canvas 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,9 +1,12 @@
-import * as Y from 'yjs';
-import { z } from 'zod';
+import { c as Board, P as Principal } from './read-BY6f-mmy.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-BY6f-mmy.js';
+import { B as BoardAccess } from './service-Cpl6wKeY.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-Cpl6wKeY.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { Store } from 'agentic-identity';
-export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';
 export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
+export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';
+import 'yjs';
+import 'zod';
 
 declare const VERSION: string;
 
@@ -13,207 +16,6 @@ declare const BRAND: {
     readonly version: string;
 };
 
-declare const principalSchema: z.ZodObject<{
-    kind: z.ZodEnum<["human", "agent_of_human", "agent_of_agent", "agent", "user_token"]>;
-    id: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    id: string;
-    kind: "human" | "agent_of_human" | "agent_of_agent" | "agent" | "user_token";
-}, {
-    id: string;
-    kind: "human" | "agent_of_human" | "agent_of_agent" | "agent" | "user_token";
-}>;
-type Principal = z.infer<typeof principalSchema>;
-
-type ErrorCode = "INVALID" | "DUPLICATE_ID" | "NOT_FOUND" | "BAD_REFERENCE" | "LIMIT" | "UNAVAILABLE" | "FORBIDDEN";
-declare class CanvasError extends Error {
-    readonly code: ErrorCode;
-    constructor(code: ErrorCode, message: string);
-}
-declare const SHAPE_TYPES: readonly ["rect", "ellipse", "diamond", "text", "sticky", "frame", "image"];
-type ShapeType = (typeof SHAPE_TYPES)[number];
-declare const MAX_ELEMENTS = 10000;
-declare const MAX_TEXT = 10000;
-type Endpoint = {
-    id: string;
-} | {
-    x: number;
-    y: number;
-};
-interface Stamp {
-    id: string;
-    z: number;
-    groupId?: string;
-    /** Who made the element. Never changes. */
-    author: Principal;
-    /** Who made the last edit. */
-    editedBy: Principal;
-}
-interface Shape extends Stamp {
-    type: ShapeType;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    text: string;
-    fill?: string;
-    stroke?: string;
-    src?: string;
-}
-interface Connector extends Stamp {
-    type: "connector";
-    from: Endpoint;
-    to: Endpoint;
-    text: string;
-    startArrow: boolean;
-    endArrow: boolean;
-    stroke?: string;
-}
-interface Group extends Stamp {
-    type: "group";
-}
-type CanvasElement = Shape | Connector | Group;
-/**
- * A whiteboard on a Yjs doc. Headless: no UI code. Every write names its actor.
- *
- * A synced Yjs update is untrusted input. Every read checks each stored element against the same
- * rules the write methods enforce, and returns only the checked fields. An entry that fails is
- * hidden at once. `repair()` deletes it, and `Board.decode` runs `repair()`. This holds even
- * when a caller writes to `doc` directly.
- */
-declare class Board {
-    readonly doc: Y.Doc;
-    private readonly elements;
-    private readonly meta;
-    private maxElements;
-    constructor(doc?: Y.Doc, options?: {
-        maxElements?: number;
-    });
-    /** Load a saved board with no element checks. Only the owner repair path uses it. */
-    static open(update: Uint8Array): Board;
-    /**
-     * 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: Uint8Array): Board;
-    encode(): Uint8Array;
-    /** An independent copy. Edits to it leave this board alone. */
-    clone(): Board;
-    get title(): string;
-    get titleBy(): Principal | undefined;
-    setTitle(title: string, actor: Principal): void;
-    /** One element. An invalid entry, or a connector with a missing bound end, is hidden. */
-    get(elementId: string): CanvasElement | undefined;
-    /** All visible elements from back to front. */
-    list(): CanvasElement[];
-    /**
-     * 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?: string[]): string[];
-    addShape(input: unknown, actor: Principal): Shape;
-    addConnector(input: unknown, actor: Principal): Connector;
-    update(elementId: string, patch: unknown, actor: Principal): CanvasElement;
-    /** Shift an element, or a whole group. Returns the ids that moved. Bound connector ends follow their shapes. */
-    move(elementId: string, dx: number, dy: number, actor: Principal): string[];
-    /** Delete an element. A shape takes its connectors and a group takes its members. Returns the ids removed. */
-    remove(elementId: string): string[];
-    group(ids: string[], actor: Principal, groupId?: string): Group;
-    /** Remove a group and hand its members to the parent group. */
-    ungroup(groupId: string, actor: Principal): void;
-    /** Put an element, or a group with its inner order kept, in front of or behind every other element. */
-    reorder(elementId: string, to: "front" | "back", actor: Principal): void;
-    /** One stored element that passes the checks and whose id matches its key, or undefined. */
-    private stored;
-    /** Every stored element that passes the checks, from back to front. Refuses a doc past the cap. */
-    private storedList;
-    /** Like storedList, with no cap check. Repair needs every entry, even on a board past the cap. */
-    private allStored;
-    /** A connector is detached when a bound end does not name a stored shape. */
-    private isDetached;
-    private require;
-    private checkEnd;
-    /** The z value just past the top or the bottom. Not clamped: the caller checks the range. */
-    private edgeZ;
-    /** The element and, for a group, everything below it. Cycle-safe. */
-    private subtree;
-    private subtreeIn;
-    private create;
-    /** Apply field changes and stamp the editor, all in one transaction. An undefined value clears the field. */
-    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;
-    /** The last edit came from an agent or one acting for one. */
-    lastEditMachineMade: boolean;
-}
-type NodeData = Shape & Labels;
-type EdgeData = Connector & Labels;
-interface BoardData {
-    title: string;
-    nodes: NodeData[];
-    edges: EdgeData[];
-    groups: {
-        id: string;
-        members: string[];
-    }[];
-    /** Every non-empty text, back to front. */
-    texts: string[];
-}
-/** The board as plain data for an agent. Reads only. Embedded image bytes are left out. */
-declare function readBoard(board: Board): BoardData;
-
 /** Draw the board, back to front, on a white background. */
 declare function toSvg(board: Board): string;
 
@@ -235,51 +37,12 @@ declare class ActorConfigError extends Error {
  */
 declare function operatorActor(env?: Record<string, string | undefined>): Principal;
 
-/** 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;
-    }>;
-    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>;
-    exportPng(id: string): Promise<Uint8Array>;
-    /** 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;
-}
-
 /**
  * The tools mirror the CLI. The actor is fixed here by the operator. No tool takes an actor,
  * author, or kind, so a caller cannot choose who it writes as.
  */
-declare function createMcpServer(service: CanvasService, actor: Principal): McpServer;
+declare function createMcpServer(service: BoardAccess, actor: Principal): McpServer;
 /** Serve the tools on stdin and stdout. Stdout carries protocol frames only. */
-declare function runMcp(service: CanvasService, actor: Principal): Promise<void>;
+declare function runMcp(service: BoardAccess, actor: Principal): Promise<void>;
 
-export { ActorConfigError, BRAND, Board, type BoardData, type CanvasElement, CanvasError, CanvasService, type Connector, type DrawOptions, type EdgeData, type Endpoint, type ErrorCode, type FlowEdge, type FlowGraph, type FlowNode, type Group, MAX_ELEMENTS, MAX_FLOW_EDGES, MAX_FLOW_NODES, MAX_TEXT, type NodeData, type Placement, type Principal, SHAPE_TYPES, type Shape, type ShapeType, VERSION, createMcpServer, drawFlow, layoutFlow, operatorActor, parseFlow, principalSchema, readBoard, runMcp, svgToPng, toSvg };
+export { ActorConfigError, BRAND, Board, Principal, VERSION, createMcpServer, operatorActor, runMcp, svgToPng, toSvg };

package/dist/index.js

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

package/dist/live-worker.d.ts

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

package/dist/live-worker.js

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

package/dist/live.d.ts

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

package/dist/live.js

@@ -0,0 +1,192 @@
+import {
+  Board,
+  CanvasError,
+  drawFlow,
+  principalSchema,
+  readBoard,
+  toSvg
+} from "./chunk-GGQPE65T.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) {
+  const { error } = await response.json().catch(() => ({}));
+  const code = CODES.find((known) => known === error?.code) ?? (response.status === 401 || response.status === 403 ? "FORBIDDEN" : response.status >= 500 ? "UNAVAILABLE" : "INVALID");
+  return new CanvasError(code, typeof error?.message === "string" ? error.message : `${fallback} (${response.status})`);
+}
+async function json(response) {
+  const body = await response.json().catch(() => void 0);
+  if (typeof body !== "object" || body === null || Array.isArray(body)) throw new CanvasError("INVALID", "the server sent a body this client does not know");
+  return body;
+}
+var unreachable = (error) => error instanceof CanvasError ? error : new CanvasError("UNAVAILABLE", `could not reach the live server: ${error instanceof Error ? error.message : String(error)}`);
+async function call(server, token, path, init = {}) {
+  return fetch(`${base(server)}${path}`, { ...init, headers: { ...init.headers, authorization: `Bearer ${token}` } }).catch((error) => {
+    throw unreachable(error);
+  });
+}
+async function whoAmI(server, token) {
+  const response = await call(server, token, "/me");
+  if (!response.ok) throw await refusal(response, "the server refused the token");
+  const { actor, kind, role } = await json(response);
+  const principal = principalSchema.safeParse({ kind, id: actor });
+  if (!principal.success || role !== "editor" && role !== "viewer") throw new CanvasError("INVALID", "the server sent an identity this client does not know");
+  return { actor: principal.data, role };
+}
+var LiveBoard = class _LiveBoard {
+  constructor(board, me, client, id, options, refusedAtStart) {
+    this.board = board;
+    this.me = me;
+    this.client = client;
+    this.id = id;
+    this.options = options;
+    this.refusedAtStart = refusedAtStart;
+  }
+  board;
+  me;
+  client;
+  id;
+  options;
+  refusedAtStart;
+  changed = /* @__PURE__ */ new Set();
+  /** The ids of the elements that the last `edit` added, changed, or removed. */
+  get touched() {
+    return this.changed;
+  }
+  static async join(options) {
+    const me = await whoAmI(options.server, options.token);
+    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());
+    const url = new URL(`${base(options.server)}/boards/${id}/ws`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    let client;
+    try {
+      client = await SyncClient.connect({ url: url.toString(), headers: { authorization: `Bearer ${options.token}` }, presence: { name: options.name ?? me.actor.id }, reconnect: options.reconnect });
+    } 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. */
+  get peers() {
+    return this.client.peers;
+  }
+  /** Why the room dropped an update, in order. */
+  get denied() {
+    return this.client.denied.slice(this.refusedAtStart);
+  }
+  /**
+   * Run one change as the token's actor and wait until the room has it. A viewer fails before the change.
+   * After a refusal the local copy still holds the change: leave and join again.
+   */
+  async edit(run) {
+    if (this.me.role === "viewer") throw new CanvasError("FORBIDDEN", "this token is a viewer; it cannot change a board");
+    const seen = this.denied.length;
+    const snapshot = () => new Map(this.board.list().map((e) => [e.id, JSON.stringify(e)]));
+    const before = snapshot();
+    const result = run(this.board, this.me.actor);
+    const after = snapshot();
+    this.changed = new Set([...before.keys(), ...after.keys()].filter((id) => before.get(id) !== after.get(id)));
+    await this.flush();
+    if (this.denied.length > seen) throw new CanvasError("FORBIDDEN", `the room refused the edit: ${this.denied[seen]}`);
+    return result;
+  }
+  /** Wait until the room has every change made so far. */
+  flush() {
+    return this.client.flush().catch((error) => {
+      throw unreachable(error);
+    });
+  }
+  /**
+   * Save the room to the stored board. `fixed` lists the elements the server's checks changed. After that the
+   * room still holds the client's version, so leave and join again.
+   */
+  async save() {
+    if (this.me.role === "viewer") throw new CanvasError("FORBIDDEN", "this token is a viewer; it cannot change a board");
+    await this.flush();
+    const saved = await call(this.options.server, this.options.token, `/boards/${encodeURIComponent(this.id)}/checkpoint`, { method: "POST", headers: { "content-type": "application/octet-stream" }, body: this.board.encode() });
+    if (!saved.ok) throw await refusal(saved, "the server did not save the board");
+    const { elements, fixed } = await json(saved);
+    if (typeof elements !== "number" || !Array.isArray(fixed) || !fixed.every((id) => typeof id === "string")) throw new CanvasError("INVALID", "the server sent a save result this client does not know");
+    return { elements, fixed };
+  }
+  async leave() {
+    await this.client.disconnect();
+  }
+};
+var LiveService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  join(board) {
+    return LiveBoard.join({ ...this.options, board });
+  }
+  async create(_actor, options = {}) {
+    const response = await call(this.options.server, this.options.token, "/boards", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(options) });
+    if (!response.ok) throw await refusal(response, "the server refused the request");
+    const { id, title } = await json(response);
+    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 read(id) {
+    return this.use(id, async (live) => ({ id, ...readBoard(live.board) }));
+  }
+  async exportSvg(id) {
+    return this.use(id, async (live) => toSvg(live.board));
+  }
+  add(id, shape, _actor) {
+    return this.write(id, (board, actor) => board.addShape(shape, actor));
+  }
+  connect(id, connector, _actor) {
+    return this.write(id, (board, actor) => board.addConnector(connector, actor));
+  }
+  move(id, element, dx, dy, _actor) {
+    return this.write(id, (board, actor) => ({ moved: board.move(element, dx, dy, actor) }));
+  }
+  remove(id, element) {
+    return this.write(id, (board) => ({ removed: board.remove(element) }));
+  }
+  flow(id, text, _actor, options) {
+    return this.write(id, (board, actor) => drawFlow(board, text, actor, options));
+  }
+  async use(id, run) {
+    const live = await this.join(id);
+    try {
+      return await run(live);
+    } finally {
+      await live.leave();
+    }
+  }
+  write(id, change) {
+    return this.use(id, async (live) => {
+      const result = await live.edit(change).catch((error) => {
+        if (live.touched.size === 0 || !(error instanceof CanvasError && error.code === "UNAVAILABLE")) throw error;
+        throw new CanvasError("UNAVAILABLE", `${error.message}. The room may have the change: read the board before you repeat it.`);
+      });
+      const saved = await live.save().catch((error) => {
+        throw new CanvasError(error instanceof CanvasError ? error.code : "UNAVAILABLE", `the room has the change, but it is not saved: ${error instanceof Error ? error.message : String(error)}. Do not repeat the change.`);
+      });
+      if (saved.fixed.some((id2) => live.touched.has(id2))) throw new CanvasError("FORBIDDEN", "the server undid the change: its checks changed an element this change touched. Do not repeat the change.");
+      return result;
+    });
+  }
+};
+export {
+  LiveBoard,
+  LiveService,
+  whoAmI
+};