agentic-canvas 0.2.0 → 0.3.0

package/README.md

@@ -7,9 +7,9 @@
 
 A shared whiteboard for diagrams, drawn by people and agents.
 
-> Status: 0.2.0. The board model, the agent operations, the exports, the CLI, the
+> Status: 0.3.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.
+> and the SDK can join a live room. A remote client calls the Worker API. The web UI is not built yet.
 
 ## Install
 
@@ -84,6 +84,33 @@ The flow text takes one statement per line: `A -> B: label`. Use `[text]` for a
 box, `(text)` for an ellipse, and `{text}` for a diamond. `direction LR` sets
 the direction. Lines that start with `#` or `//` are comments.
 
+### Remote client
+
+Call a running Worker from a browser, a Worker, or Node 22. The client uses only `fetch`.
+
+```ts
+import { createClient, CanvasApiError } from "agentic-canvas/client";
+
+const canvas = createClient({ baseUrl: "https://canvas.example.com/api/v1/canvas", token });
+await canvas.createBoard({ id: "plan", title: "Plan" });
+await canvas.addShape("plan", { type: "rect", x: 0, y: 0, text: "Start" });
+await canvas.drawFlow("plan", "A -> B: go");
+const board = await canvas.readBoard("plan");
+
+try {
+  await canvas.readBoard("missing");
+} catch (error) {
+  if (error instanceof CanvasApiError) console.log(error.code, error.status); // NOT_FOUND 404
+}
+```
+
+There is one method per route: `me`, `createBoard`, `readBoard`, `exportSvg`, `addShape`, `addConnector`,
+`drawFlow`, `move`, `remove`, `uploadImage`, `getImage`, `state`, and `checkpoint`. Each takes
+`{ signal }` last, so an `AbortSignal` can stop a call. The token sets the actor. A failed call throws
+`CanvasApiError` with the API `code` and the HTTP `status`. A call that gets no reply has code `NETWORK`
+and status 0. The client never retries. A 503 means "try again", and the caller decides, because a
+repeated write can change a board twice. Pass `fetch` to use your own.
+
 ## Features
 
 - Shapes: rectangle, ellipse, diamond, text, sticky note, frame, image.

package/dist/{chunk-KEMOXKBY.js → chunk-AGODNBN7.js}

@@ -7,7 +7,7 @@ import {
 
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.2.0" : readPackageVersion();
+var VERSION = true ? "0.3.0" : readPackageVersion();
 
 // src/brand.ts
 var BRAND = {

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-KEMOXKBY.js";
+} from "./chunk-AGODNBN7.js";
 import {
   openLocalStore
 } from "./chunk-UKST5A57.js";

package/dist/client.d.ts

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

package/dist/client.js

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

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { B as Board, P as Principal, a as BoardAccess } from './service-CJTe-uBI.js';
-export { b as BoardData, d as CanvasElement, e as CanvasError, c as CanvasService, C as Connector, D as DrawOptions, E as EdgeData, f as Endpoint, g as ErrorCode, F as FlowEdge, h as FlowGraph, i as FlowNode, G as Group, M as MAX_ELEMENTS, j as MAX_FLOW_EDGES, k as MAX_FLOW_NODES, l as MAX_TEXT, N as NodeData, m as Placement, n as SHAPE_TYPES, S as Shape, o as ShapeType, p as drawFlow, q as layoutFlow, r as parseFlow, s as principalSchema, t as readBoard } from './service-CJTe-uBI.js';
+import { c as Board, P as Principal } from './read-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';
 export { FileStoreOptions, createFileStore, openLocalStore } from './store-file.js';
 export { PRINCIPAL_KINDS, PrincipalKind, isMachineMade } from 'agentic-identity';

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-KEMOXKBY.js";
+} from "./chunk-AGODNBN7.js";
 import {
   createFileStore,
   openLocalStore

package/dist/live-worker.d.ts

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

package/dist/live.d.ts

@@ -1,5 +1,6 @@
-import { B as Board, P as Principal, a as BoardAccess, b as BoardData, S as Shape, C as Connector, D as DrawOptions } from './service-CJTe-uBI.js';
+import { c as Board, P as Principal, B as BoardData, a as Shape, C as Connector } 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';

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

@@ -1,6 +1,5 @@
 import * as Y from 'yjs';
 import { z } from 'zod';
-import { Store } from 'agentic-identity';
 
 declare const principalSchema: z.ZodObject<{
     kind: z.ZodEnum<["human", "agent_of_human", "agent_of_agent", "agent", "user_token"]>;
@@ -143,52 +142,6 @@ declare class Board {
     private write;
 }
 
-declare const MAX_FLOW_NODES = 500;
-declare const MAX_FLOW_EDGES = 2000;
-interface FlowNode {
-    id: string;
-    text: string;
-    shape: Extract<ShapeType, "rect" | "ellipse" | "diamond">;
-}
-interface FlowEdge {
-    from: string;
-    to: string;
-    text: string;
-}
-interface FlowGraph {
-    direction: "TB" | "LR";
-    nodes: FlowNode[];
-    edges: FlowEdge[];
-}
-declare function parseFlow(source: string): FlowGraph;
-interface Placement {
-    id: string;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-/** Layered layout. The top-left of the result is (0, 0). The layout breaks cycles and handles self-loops. */
-declare function layoutFlow(graph: FlowGraph): Placement[];
-interface DrawOptions {
-    /**
-     * Put in front of every id. Default: a new random prefix for each call, so two agents that draw at
-     * the same time never write the same id. A prefix you pass is used as given, and it makes ids
-     * repeatable. Up to 16 of A-Z, a-z, 0-9, _ and -.
-     */
-    idPrefix?: string;
-    /** Top-left of the drawing. Default: below the shapes already on the board. */
-    origin?: {
-        x: number;
-        y: number;
-    };
-}
-/** Draw a flow on the board. All or nothing: on any error the board stays as it was. */
-declare function drawFlow(board: Board, source: string, actor: Principal, options?: DrawOptions): {
-    nodes: string[];
-    edges: string[];
-};
-
 interface Labels {
     /** The author is an agent or acts for one. */
     machineMade: boolean;
@@ -211,63 +164,4 @@ interface BoardData {
 /** The board as plain data for an agent. Reads only. Embedded image bytes are left out. */
 declare function readBoard(board: Board): BoardData;
 
-/** One place for every board operation. The CLI, the MCP server, and the Worker call it. */
-declare class CanvasService {
-    private readonly store;
-    constructor(store: Store);
-    create(actor: Principal, options?: {
-        id?: string;
-        title?: string;
-    }): Promise<{
-        id: string;
-        title: string;
-    }>;
-    /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
-    assertExists(id: string): Promise<void>;
-    read(id: string): Promise<BoardData & {
-        id: string;
-    }>;
-    /** Run `change` on the board and save it, all inside one transaction. */
-    change<R>(id: string, change: (board: Board) => R): Promise<R>;
-    add(id: string, shape: unknown, actor: Principal): Promise<Shape>;
-    connect(id: string, connector: unknown, actor: Principal): Promise<Connector>;
-    move(id: string, elementId: string, dx: number, dy: number, actor: Principal): Promise<{
-        moved: string[];
-    }>;
-    remove(id: string, elementId: string): Promise<{
-        removed: string[];
-    }>;
-    flow(id: string, text: string, actor: Principal, options?: DrawOptions): Promise<{
-        nodes: string[];
-        edges: string[];
-    }>;
-    exportSvg(id: string): Promise<string>;
-    /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
-    state(id: string): Promise<Uint8Array>;
-    /**
-     * Merge a live room's state into the stored board. `authors` are the principals the room saw send updates.
-     * An element stamped by anyone else is deleted, and a changed author is put back (see `Board.restamp`),
-     * so a client that writes raw Yjs cannot put another author on its work. Broken entries are repaired and
-     * a board past the element cap is refused. Returns the ids the checks fixed.
-     *
-     * Limits: the save corrects the stored board only. The room keeps what its clients wrote, so a client that sees
-     * a non-empty `fixed` must join again, or its later edits are lost at the next save. The room remembers its
-     * authors for good, so a client may stamp an element with the name of anyone who once sent an update in that room.
-     * A client that adds a root type of its own makes every later save of that room fail, because the room keeps it.
-     */
-    checkpoint(id: string, update: Uint8Array, actor: Principal, authors?: Principal[]): Promise<{
-        elements: number;
-        fixed: string[];
-    }>;
-    /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
-    repair(id: string, actor: Principal, drop?: string[]): Promise<{
-        id: string;
-        fixed: string[];
-        elements: number;
-    }>;
-    private load;
-}
-/** What the CLI and the MCP server need. `CanvasService` runs it on a store, and `LiveService` runs it in a live room. */
-type BoardAccess = Pick<CanvasService, "create" | "read" | "add" | "connect" | "move" | "remove" | "flow" | "exportSvg">;
-
-export { Board as B, type Connector as C, type DrawOptions as D, type EdgeData as E, type FlowEdge as F, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type Shape as S, type BoardAccess as a, type BoardData as b, CanvasService as c, type CanvasElement as d, CanvasError as e, type Endpoint as f, type ErrorCode as g, type FlowGraph as h, type FlowNode as i, MAX_FLOW_EDGES as j, MAX_FLOW_NODES as k, MAX_TEXT as l, type Placement as m, SHAPE_TYPES as n, type ShapeType as o, drawFlow as p, layoutFlow as q, parseFlow as r, principalSchema as s, readBoard as t };
+export { type BoardData as B, type Connector as C, type ErrorCode as E, type Group as G, MAX_ELEMENTS as M, type NodeData as N, type Principal as P, type ShapeType as S, type Shape as a, type Endpoint as b, Board as c, type CanvasElement as d, CanvasError as e, type EdgeData as f, MAX_TEXT as g, SHAPE_TYPES as h, principalSchema as p, readBoard as r };

package/dist/service-Cpl6wKeY.d.ts

@@ -0,0 +1,109 @@
+import { S as ShapeType, c as Board, P as Principal, B as BoardData, a as Shape, C as Connector } from './read-BY6f-mmy.js';
+import { Store } from 'agentic-identity';
+
+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[];
+};
+
+/** One place for every board operation. The CLI, the MCP server, and the Worker call it. */
+declare class CanvasService {
+    private readonly store;
+    constructor(store: Store);
+    create(actor: Principal, options?: {
+        id?: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+    }>;
+    /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
+    assertExists(id: string): Promise<void>;
+    read(id: string): Promise<BoardData & {
+        id: string;
+    }>;
+    /** Run `change` on the board and save it, all inside one transaction. */
+    change<R>(id: string, change: (board: Board) => R): Promise<R>;
+    add(id: string, shape: unknown, actor: Principal): Promise<Shape>;
+    connect(id: string, connector: unknown, actor: Principal): Promise<Connector>;
+    move(id: string, elementId: string, dx: number, dy: number, actor: Principal): Promise<{
+        moved: string[];
+    }>;
+    remove(id: string, elementId: string): Promise<{
+        removed: string[];
+    }>;
+    flow(id: string, text: string, actor: Principal, options?: DrawOptions): Promise<{
+        nodes: string[];
+        edges: string[];
+    }>;
+    exportSvg(id: string): Promise<string>;
+    /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
+    state(id: string): Promise<Uint8Array>;
+    /**
+     * Merge a live room's state into the stored board. `authors` are the principals the room saw send updates.
+     * An element stamped by anyone else is deleted, and a changed author is put back (see `Board.restamp`),
+     * so a client that writes raw Yjs cannot put another author on its work. Broken entries are repaired and
+     * a board past the element cap is refused. Returns the ids the checks fixed.
+     *
+     * Limits: the save corrects the stored board only. The room keeps what its clients wrote, so a client that sees
+     * a non-empty `fixed` must join again, or its later edits are lost at the next save. The room remembers its
+     * authors for good, so a client may stamp an element with the name of anyone who once sent an update in that room.
+     * A client that adds a root type of its own makes every later save of that room fail, because the room keeps it.
+     */
+    checkpoint(id: string, update: Uint8Array, actor: Principal, authors?: Principal[]): Promise<{
+        elements: number;
+        fixed: string[];
+    }>;
+    /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
+    repair(id: string, actor: Principal, drop?: string[]): Promise<{
+        id: string;
+        fixed: string[];
+        elements: number;
+    }>;
+    private load;
+}
+/** What the CLI and the MCP server need. `CanvasService` runs it on a store, and `LiveService` runs it in a live room. */
+type BoardAccess = Pick<CanvasService, "create" | "read" | "add" | "connect" | "move" | "remove" | "flow" | "exportSvg">;
+
+export { type BoardAccess as B, CanvasService as C, type DrawOptions as D, type FlowEdge as F, MAX_FLOW_EDGES as M, type Placement as P, type FlowGraph as a, type FlowNode as b, MAX_FLOW_NODES as c, drawFlow as d, layoutFlow as l, parseFlow as p };

package/dist/worker.d.ts

@@ -2,7 +2,8 @@ import { Blobs } from 'agentic-identity';
 import { Realtime } from 'agentic-realtime';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
 import { Hono } from 'hono';
-import { P as Principal, c as CanvasService } from './service-CJTe-uBI.js';
+import { P as Principal } from './read-BY6f-mmy.js';
+import { C as CanvasService } from './service-Cpl6wKeY.js';
 import 'yjs';
 import 'zod';
 

package/llms.txt

@@ -8,6 +8,7 @@ Keywords: whiteboard,canvas,diagrams,drawing,collaboration,agents,mcp,cli.
 - CLI: agentic-canvas new|read|add|connect|move|rm|flow|export.
 - Live: set CANVAS_SERVER and CANVAS_TOKEN, and the CLI and `agentic-canvas mcp` edit the board in its live room.
 - SDK: import { LiveBoard, LiveService } from "agentic-canvas/live".
+- SDK: import { createClient, CanvasApiError } from "agentic-canvas/client". It calls the Worker API with fetch. Methods: me, createBoard, readBoard, exportSvg, addShape, addConnector, drawFlow, move, remove, uploadImage, getImage, state, checkpoint. A failure throws CanvasApiError with `code` and `status`. No retries.
 
 ## Docs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-canvas",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A shared whiteboard for diagrams, drawn by people and agents.",
   "keywords": [
     "whiteboard",
@@ -51,6 +51,10 @@
       "types": "./dist/live-worker.d.ts",
       "import": "./dist/live-worker.js"
     },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
     "./file-store": {
       "types": "./dist/store-file.d.ts",
       "import": "./dist/store-file.js"