agentic-canvas 0.1.0 → 0.2.0

package/dist/chunk-W7NRP3EX.js

@@ -0,0 +1,164 @@
+import {
+  Board,
+  CanvasError,
+  drawFlow,
+  principalSchema,
+  readBoard,
+  toSvg
+} from "./chunk-GGQPE65T.js";
+import {
+  FileStoreError
+} from "./chunk-NWQED42L.js";
+
+// src/service.ts
+import * as Y from "yjs";
+import { assertId, StoreConflictError } from "agentic-identity";
+var COLLECTION = "boards";
+var MAX_LIVE_BYTES = 1572864;
+var BOARD_ID = /^[A-Za-z0-9_-]{1,64}$/;
+function toBase64(bytes) {
+  let text = "";
+  for (let i = 0; i < bytes.length; i += 8192) text += String.fromCharCode(...bytes.subarray(i, i + 8192));
+  return btoa(text);
+}
+var fromBase64 = (text) => Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+function boardKey(id) {
+  try {
+    if (!BOARD_ID.test(id)) throw new Error();
+    assertId(id);
+  } 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 id;
+}
+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 id = boardKey(options.id ?? crypto.randomUUID());
+    const board = new Board();
+    if (options.title !== void 0) board.setTitle(options.title, actor);
+    return this.store.transaction(async (tx) => {
+      if (await tx.get(COLLECTION, id)) throw new CanvasError("DUPLICATE_ID", `board "${id}" already exists`);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return { id, title: board.title };
+    });
+  }
+  /** Throws NOT_FOUND unless the board exists. A live room opens only for a board that exists. */
+  async assertExists(id) {
+    boardKey(id);
+    if (!await this.store.transaction((tx) => tx.get(COLLECTION, id))) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+  }
+  async read(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => ({ id, ...readBoard(await this.load(tx.get(COLLECTION, id), id)) }));
+  }
+  /** Run `change` on the board and save it, all inside one transaction. */
+  async change(id, change) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => {
+      const board = await this.load(tx.get(COLLECTION, id), id);
+      const result = change(board);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return result;
+    });
+  }
+  add(id, shape, actor) {
+    return this.change(id, (b) => b.addShape(shape, actor));
+  }
+  connect(id, connector, actor) {
+    return this.change(id, (b) => b.addConnector(connector, actor));
+  }
+  move(id, elementId, dx, dy, actor) {
+    return this.change(id, (b) => ({ moved: b.move(elementId, dx, dy, actor) }));
+  }
+  remove(id, elementId) {
+    return this.change(id, (b) => ({ removed: b.remove(elementId) }));
+  }
+  flow(id, text, actor, options) {
+    return this.change(id, (b) => drawFlow(b, text, actor, options));
+  }
+  async exportSvg(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => toSvg(await this.load(tx.get(COLLECTION, id), id)));
+  }
+  /** The stored board as a Yjs update. A client applies it to a room to seed it: the room does not read it. */
+  async state(id) {
+    boardKey(id);
+    return this.store.transaction(async (tx) => (await this.load(tx.get(COLLECTION, id), id)).encode());
+  }
+  /**
+   * 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.
+   */
+  async checkpoint(id, update, actor, authors = []) {
+    boardKey(id);
+    const by = principalSchema.safeParse(actor);
+    if (!by.success) throw new CanvasError("INVALID", "the actor must be a valid principal");
+    const trusted = (who) => [by.data, ...authors].some((a) => a.kind === who.kind && a.id === who.id);
+    return this.store.transaction(async (tx) => {
+      const prior = await this.load(tx.get(COLLECTION, id), id);
+      const next = prior.clone();
+      try {
+        Y.applyUpdate(next.doc, update);
+      } catch {
+        throw new CanvasError("INVALID", "the update is not a Yjs update");
+      }
+      if (next.doc.store.pendingStructs || next.doc.store.pendingDs) throw new CanvasError("INVALID", "the update is not complete: it needs changes that the board does not have");
+      const strange = [...next.doc.share.keys()].filter((key) => key !== "elements" && key !== "meta");
+      if (strange.length > 0) throw new CanvasError("INVALID", "the update holds data that is not part of a board");
+      const fixed = /* @__PURE__ */ new Set([...next.restamp(prior, trusted), ...next.repair()]);
+      const saved = next.encode();
+      if (saved.length > MAX_LIVE_BYTES) throw new CanvasError("LIMIT", `the board would hold over ${MAX_LIVE_BYTES} bytes`);
+      await tx.put(COLLECTION, id, { update: toBase64(saved) });
+      return { elements: next.list().length, fixed: [...fixed].sort() };
+    });
+  }
+  /** Owner only. Repair a board and delete the named elements. Only a human actor may call it. */
+  async repair(id, 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(id);
+    return this.store.transaction(async (tx) => {
+      const doc = await tx.get(COLLECTION, id);
+      if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+      const board = decodeStored(doc, id, Board.open);
+      const fixed = board.repair(drop);
+      await tx.put(COLLECTION, id, { update: toBase64(board.encode()) });
+      return { id, fixed, elements: board.list().length };
+    });
+  }
+  async load(read, id) {
+    const doc = await read;
+    if (!doc) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+    return decodeStored(doc, id, Board.decode);
+  }
+};
+function decodeStored(doc, id, decode) {
+  try {
+    return decode(fromBase64(String(doc.update)));
+  } catch (error) {
+    if (error instanceof CanvasError) throw error;
+    throw new CanvasError("INVALID", `stored board "${id}" is damaged`);
+  }
+}
+
+export {
+  MAX_LIVE_BYTES,
+  CanvasService
+};

package/dist/cli.js

@@ -2,14 +2,20 @@
 import {
   ActorConfigError,
   BRAND,
-  CanvasError,
-  CanvasService,
   operatorActor,
-  runMcp
-} from "./chunk-NSZ2AC5O.js";
+  runMcp,
+  svgToPng
+} from "./chunk-KEMOXKBY.js";
 import {
   openLocalStore
-} from "./chunk-I3EJ5JB7.js";
+} from "./chunk-UKST5A57.js";
+import {
+  CanvasService
+} from "./chunk-W7NRP3EX.js";
+import {
+  CanvasError
+} from "./chunk-GGQPE65T.js";
+import "./chunk-NWQED42L.js";
 
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -33,6 +39,10 @@ Commands:
   repair <board> [--drop <element>]...     Owner only: fix a broken or over-cap board. Needs CANVAS_ACTOR=human:<id>.
   mcp                                      Serve these as MCP tools on stdio. Needs CANVAS_ACTOR.
 
+Live mode: set CANVAS_SERVER=<worker url> and CANVAS_TOKEN=<bearer token>. Every command then runs in the live room of
+the board on that server, so a person and an agent can edit one board at once. The token sets the actor, the kind,
+and the role, so CANVAS_ACTOR is not needed. If it is set, it must match the token. --dir, CANVAS_DIR, and repair are local only.
+
 Write commands need an actor in CANVAS_ACTOR as <kind>:<id>, such as "agent:helper".
 The operator sets it. A caller cannot pick its own kind: there is no --actor flag.
 Kinds: human, agent_of_human, agent_of_agent, agent, user_token.
@@ -78,7 +88,24 @@ async function run(argv) {
   const need = (count, shape) => {
     if (positionals.length !== count + 1) throw new UsageError(`usage: ${BRAND.command} ${command} ${shape}`);
   };
+  const server = process.env.CANVAS_SERVER;
+  let live;
+  let service;
+  if (server) {
+    if (v.dir !== void 0 || process.env.CANVAS_DIR) throw new UsageError("--dir and CANVAS_DIR are local only: CANVAS_SERVER is set, so the board lives on the server");
+    const token = process.env.CANVAS_TOKEN;
+    if (!token) throw new UsageError("CANVAS_SERVER needs CANVAS_TOKEN");
+    if (command === "repair") throw new UsageError("repair runs on the local store only. Unset CANVAS_SERVER.");
+    const { LiveService, whoAmI } = await import("./live.js");
+    service = new LiveService({ server, token });
+    const claimed = process.env.CANVAS_ACTOR;
+    if (claimed || command !== "read" && command !== "export") live = (await whoAmI(server, token)).actor;
+    if (live && claimed && claimed !== `${live.kind}:${live.id}`) throw new UsageError(`CANVAS_ACTOR "${claimed}" does not match the token (${live.kind}:${live.id}). Unset CANVAS_ACTOR.`);
+  } else {
+    service = new CanvasService(openLocalStore(v.dir ?? process.env.CANVAS_DIR ?? ".agentic-canvas"));
+  }
   const actor = () => {
+    if (live) return live;
     try {
       return operatorActor();
     } catch (error) {
@@ -86,7 +113,6 @@ async function run(argv) {
       throw error;
     }
   };
-  const service = new CanvasService(openLocalStore(v.dir ?? process.env.CANVAS_DIR ?? ".agentic-canvas"));
   const print = (value) => console.log(JSON.stringify(value));
   switch (command) {
     case "new":
@@ -118,7 +144,7 @@ async function run(argv) {
       const format = v.format ?? "svg";
       if (format !== "svg" && format !== "png") throw new UsageError(`format must be svg or png, got "${format}"`);
       if (format === "png" && !v.out) throw new UsageError("png is binary: pass --out <path>");
-      const data = format === "svg" ? await service.exportSvg(board) : await service.exportPng(board);
+      const data = format === "svg" ? await service.exportSvg(board) : await svgToPng(await service.exportSvg(board));
       if (!v.out) return void process.stdout.write(`${data}
 `);
       writeFileSync(v.out, data);

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import * as Y from 'yjs';
-import { z } from 'zod';
+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 { 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 +14,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 +35,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-KEMOXKBY.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,21 @@
+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 './service-CJTe-uBI.js';
+import 'yjs';
+import 'zod';
+
+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
+};