agentic-canvas 0.7.0 → 0.8.0

package/README.md

@@ -7,7 +7,7 @@
 
 A shared whiteboard for diagrams, drawn by people and agents.
 
-> Status: 0.7.0. The board model, the agent operations, the exports, the CLI, the
+> Status: 0.8.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. A remote client calls the Worker API. A small web UI, served by the Worker, is new in 0.4.0.
 > The package exports `agentic-canvas/ui`, a board view you can mount in your own app, new in 0.5.0.
@@ -157,6 +157,35 @@ revoked without a new deploy. It ignores revocation in the Store: a static grant
 `ada` after the identity credential of `ada` is revoked. Use it for local work and throwaway demos only. If `CANVAS_API_TOKENS` is set
 and the switch is not, every API request gets 503 `NOT_CONFIGURED`, so a deploy never trusts the list by accident.
 
+## Sharing
+
+A board is an `agentic-identity` resource of type `canvas`. The person or agent that makes a board owns it.
+Roles, from least to most: `viewer`, `commenter`, `editor`, `owner`.
+
+| Role | May do |
+|---|---|
+| viewer, commenter | Read the board, its SVG, and join its live room to read. A board has no comments yet, so a commenter reads as a viewer. |
+| editor | Also draw: add, update, move, and remove elements. |
+| owner | Also delete the board, grant and revoke roles, list access, invite, and make or revoke share links. |
+
+A role never exceeds the scopes of the credential. An agent of an owner holds the owner's role only inside its own
+scopes: it needs `canvas:admin` to share, and `canvas:write` to draw. A caller with no role on a board gets 404, so a read or a write tells a stranger nothing. (A create with an id that is taken answers 409.) A caller with a role that is too low gets 403. `GET /boards` lists the boards you hold a role on.
+
+HTTP routes, under `/api/v1/canvas`. Each needs a bearer token, except the link read:
+
+| Route | Does |
+|---|---|
+| `GET /boards/:id/access` | Owner. The grants and the invites. An invite shows no email. |
+| `POST /boards/:id/grants` | Owner. Body `{ subjectKind: "human" or "agent", subjectId, role }`. |
+| `DELETE /boards/:id/grants?subjectKind=&subjectId=` | Owner. Revoke. The last owner cannot be removed. |
+| `POST /boards/:id/invites` | Owner. Body `{ role, email }` or `{ role, handle }`, and optional `expiresInMs`. The role is not `owner`. Returns `{ id }`. |
+| `POST /invites/accept` | Body `{ id }`. The caller must be the person (verified email) or the agent (handle) the invite names. |
+| `POST /boards/:id/links` | Owner. Body `{ role, signedInOnly?, expiresInMs? }`. Returns `{ id, token }`. The token shows once. |
+| `DELETE /boards/:id/links/:link` | Owner. Revoke a link of this board. |
+| `GET /shared/:id` and `GET /shared/:id/svg` | No bearer token needed. Send the link token in `x-link-token`. Read only. |
+
+The static dev fallback holds no board roles. Its tokens reach every board and cannot share.
+
 ## UI
 
 The Worker serves a small web UI at its root. It uses the published `agentic-design` package for
@@ -330,9 +359,9 @@ old author stays on its elements. Only new writes follow the strict rule.
 
 | Name | What it is |
 |---|---|
-| `createFileStore(path, options?)`, `openLocalStore(dir)` | A store on one JSON file, or on `canvas.json` in a directory. |
-| `FileStoreError` | The error that the store throws. Its `code` is `LOCKED` or `DAMAGED`. |
-| `FileStoreOptions` (type) | `lockTimeoutMs` (default 10000) and `staleAfterMs` (default 30000), plus the adapter options. |
+| `createFileStore(path, options?)`, `openLocalStore(dir)` | A store on one JSON file, or on `canvas.json` in a directory. It is the file store of agentic-identity. |
+| `FileStoreError` | The error for a file that is not a store file, or a lock that stays held. Its `code` is `DAMAGED` or `LOCKED`. |
+| `FileStoreOptions` (type) | The adapter options. The lock options `lockTimeoutMs` and `staleAfterMs` are gone. |
 | `STORE_FILE` | The file name that `openLocalStore` uses, `canvas.json`. |
 
 ### `agentic-canvas/live`
@@ -377,8 +406,12 @@ The stylesheet is a separate export, `agentic-canvas/ui.css`. Load `agentic-desi
 ## Limits
 
 - Canvas takes principal kinds, regions, and the Store and Blobs ports from `agentic-identity` 0.6.
-  It does not use the sharing API yet: every principal with `canvas:write` reaches every board. When it adopts sharing, grants are keyed
-  on kind and id, and a delete calls `deleteResource`.
+- A board made before sharing has no owner. Identity credentials get 404 on it. Only the dev fallback reaches it. Make it again, or add its
+  `canvas` resource and an owner grant with `agentic-identity`.
+- An image is stored under the hash of its bytes, not under a board. Any credential with `canvas:read` can fetch an image if it knows the hash.
+- A link visitor reads the stored board, which a live room saves at its next save. It cannot load `blob:` images.
+- A revoke, or a grant of viewer or commenter, closes the live sockets of the person or agent whose role changed. An agent that acts for that person keeps its socket until it joins again.
+- A link visitor reads. A link never writes. Links are not listed: the token shows once, at creation.
 - A board holds at most 10,000 elements. A flow holds at most 500 nodes and 2,000
   edges.
 - Flow text has no chains (`A -> B -> C`). Write one edge per line.
@@ -399,13 +432,15 @@ The stylesheet is a separate export, `agentic-canvas/ui.css`. Load `agentic-desi
 - `move` writes absolute positions. Two peers that move one shape at the same time do not add up:
   the last writer wins.
 - Frames are plain shapes. They do not own the shapes inside them yet.
-- The store is one file, `canvas.json`, in the store folder. A write takes `canvas.json.lock`.
-  A lock whose owner is gone, or that is older than 30 seconds, is taken over. A lock that
-  cannot be read counts as held: the call then waits 10 seconds and fails with `UNAVAILABLE`.
-  Remove the lock by hand if no process runs.
+- The store is one file, `canvas.json`, in the store folder. It is the file store of
+  agentic-identity: a write takes `canvas.json.lock`, and a lock older than 3 seconds is taken
+  over, so a writer that is paused for longer can lose its lock and the write then fails with
+  `UNAVAILABLE`. A write that clashes with another process is run again, for up to 10 seconds.
+  Remove the lock by hand if no process runs. A file written by an older agentic-canvas is
+  upgraded in place the first time a store opens it, and an older agentic-canvas cannot read
+  the upgraded file. Stop older agentic-canvas processes before you upgrade.
 - Node 22 or newer is needed. `agentic-canvas/file-store` exports `createFileStore(path)` and
-  `openLocalStore(dir)`. A writer that is paused for more than 30 seconds can lose its lock
-  and then still write.
+  `openLocalStore(dir)`.
 - A room remembers its authors for good, so a client can stamp an element with the name of anyone who
   once sent an update in that room. A save corrects the stored board and not the room: after a save that
   reports `fixed`, join again. A client that adds a root Yjs type of its own blocks later saves of that room.

package/dist/{chunk-3QW4UF2R.js → chunk-7IOW6LML.js}

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

package/dist/{chunk-EH7WCMK6.js → chunk-JQCUVXXD.js}

@@ -1,13 +1,15 @@
 import {
   CanvasService,
-  MAX_LIVE_BYTES
-} from "./chunk-GPSOLW2Y.js";
+  MAX_LIVE_BYTES,
+  isBoardId,
+  isStoreId
+} from "./chunk-M74ENUWR.js";
 import {
   CanvasError
 } from "./chunk-ZSPZMGHG.js";
 
 // src/worker.ts
-import { createStoreAuth, hasScope, parsePrincipal, parseRegion } from "agentic-identity";
+import { createStoreAuth, hasScope as hasScope2, parsePrincipal, parseRegion } from "agentic-identity";
 import { createD1Store, createR2Blobs, D1_SCHEMA } from "agentic-identity/cloudflare";
 import { acceptWebSocketProtocol, principalFromWebSocketRequest } from "agentic-identity/http";
 
@@ -1788,6 +1790,150 @@ var Hono3 = class extends Hono {
   }
 };
 
+// src/access.ts
+import { createSharing, EraseRefusedError, hasScope, ROLES, SUBJECT_KINDS } from "agentic-identity";
+var RESOURCE_TYPE = "canvas";
+var SHARE_ROLES = ROLES.filter((r) => r !== "owner");
+var BAD_INPUT = /^(give an email or a handle|invalid handle|invalid email|invalid subject( kind "[^"]*")?|the last owner cannot be removed|expiresInMs must be .*|expiresAt must be .*|invalid role .*)$/;
+function refuse(error) {
+  if (error instanceof EraseRefusedError) throw new CanvasError("INVALID", error.message);
+  if (error instanceof Error && error.message === "forbidden") throw new CanvasError("FORBIDDEN", "you may not do this on this board");
+  if (error instanceof Error && BAD_INPUT.test(error.message)) throw new CanvasError("INVALID", error.message);
+  throw error;
+}
+var oneOf = (value, list, name) => {
+  if (typeof value !== "string" || !list.includes(value)) throw new CanvasError("INVALID", `${name} must be one of: ${list.join(", ")}`);
+  return value;
+};
+var storeId = (value, name) => {
+  if (typeof value !== "string" || !isStoreId(value)) throw new CanvasError("INVALID", `${name} must be 1 to 128 of A-Z, a-z, 0-9, _ and -, and not like __x__`);
+  return value;
+};
+var word = (value, name) => {
+  if (typeof value !== "string" || value === "") throw new CanvasError("INVALID", `${name} must be a non-empty string`);
+  return value;
+};
+var lifetime = (value, name) => {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new CanvasError("INVALID", `${name} must be a whole number of milliseconds above 0`);
+  return value;
+};
+var CanvasAccess = class {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.sharing = createSharing(store, options);
+    this.now = options.now ?? Date.now;
+  }
+  store;
+  sharing;
+  now;
+  /** A board id that the Store refuses names no board. The gate checks this for a role holder: a token of the dev list skips the gate. */
+  known(id) {
+    if (!isBoardId(id)) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+  }
+  /** Make the actor the owner of a new board. */
+  async register(ctx, id) {
+    await this.sharing.createResource(ctx, { id, type: RESOURCE_TYPE }).catch((error) => {
+      if (error instanceof Error && error.message === "resource exists") throw new CanvasError("DUPLICATE_ID", `board "${id}" already exists`);
+      if (error instanceof Error && error.message === "resource id has old audit entries") throw new CanvasError("UNAVAILABLE", "this board id was used a moment ago. Try again, or use another id");
+      return refuse(error);
+    });
+  }
+  /** Remove the sharing records of a board. Needs an owner. */
+  async unregister(ctx, id) {
+    await this.sharing.deleteResource(ctx, id).catch(refuse);
+  }
+  /** True if the board has sharing records: it was made by an identity credential. */
+  async registered(id) {
+    if (!isBoardId(id)) return false;
+    return (await this.store.get("resources", id))?.type === RESOURCE_TYPE;
+  }
+  /**
+   * True if the caller may do `action` on the board. A link token adds the role of its link. It writes an audit entry.
+   * An id that belongs to a resource of another type, in a Store shared with another app, is no board: it is denied.
+   */
+  async allowed(ctx, action, id, linkToken) {
+    if (!await this.registered(id)) return false;
+    return (await this.sharing.can(ctx, action, id, linkToken === void 0 ? {} : { linkToken })).allowed;
+  }
+  /** Throw NOT_FOUND for a caller who cannot read the board, and FORBIDDEN for one who can read it but not do `action`. */
+  async require(ctx, action, id, linkToken) {
+    if (await this.allowed(ctx, action, id, linkToken)) return;
+    if (action === "read" || !await this.allowed(ctx, "read", id, linkToken)) throw new CanvasError("NOT_FOUND", `no board "${id}"`);
+    throw new CanvasError("FORBIDDEN", `this needs the ${action === "admin" ? "owner" : "editor"} role on the board`);
+  }
+  /** The ids of the boards a person or agent holds a role on, the first 100. A credential without `canvas:read` gets none. */
+  async readable(ctx) {
+    const root = ctx.chain[0];
+    if (!root || !SUBJECT_KINDS.includes(root.kind) || !hasScope(ctx.scopes, `${RESOURCE_TYPE}:read`)) return [];
+    const ids = [];
+    let cursor;
+    for (let pages = 0; pages < 10 && ids.length < 100; pages++) {
+      const page = await this.store.query("grants", { where: { subjectKind: root.kind, subjectId: root.id }, limit: 100, ...cursor === void 0 ? {} : { cursor } });
+      for (const { data } of page.items) {
+        if (ids.length >= 100 || typeof data.resourceId !== "string" || !ROLES.includes(data.role)) continue;
+        if (await this.registered(data.resourceId)) ids.push(data.resourceId);
+      }
+      if ((cursor = page.nextCursor) === void 0) break;
+    }
+    return ids;
+  }
+  async grant(ctx, id, input) {
+    this.known(id);
+    const subject = { kind: oneOf(input.subjectKind, SUBJECT_KINDS, "subjectKind"), id: storeId(input.subjectId, "subjectId") };
+    await this.sharing.grant(ctx, id, subject, oneOf(input.role, ROLES, "role")).catch(refuse);
+    return { ok: true };
+  }
+  async revoke(ctx, id, input) {
+    this.known(id);
+    const subject = { kind: oneOf(input.subjectKind, SUBJECT_KINDS, "subjectKind"), id: storeId(input.subjectId, "subjectId") };
+    await this.sharing.revokeGrant(ctx, id, subject).catch(refuse);
+    return { ok: true };
+  }
+  /** The grants and the invites on a board. An invite never shows its email. Links are not listed: a token shows once. */
+  async list(ctx, id) {
+    this.known(id);
+    const [grants, invites] = await Promise.all([this.sharing.listGrants(ctx, id, { limit: 200 }), this.sharing.listInvites(ctx, id, { limit: 200 })]).catch(refuse);
+    return { grants: grants.grants, invites: invites.invites };
+  }
+  async invite(ctx, id, input) {
+    this.known(id);
+    const role = oneOf(input.role, SHARE_ROLES, "role");
+    const expiresInMs = lifetime(input.expiresInMs, "expiresInMs");
+    const who = input.email !== void 0 ? { email: word(input.email, "email") } : input.handle !== void 0 ? { handle: word(input.handle, "handle") } : {};
+    if (input.email !== void 0 && input.handle !== void 0) throw new CanvasError("INVALID", "give an email or a handle, not both");
+    return this.sharing.createInvite(ctx, id, { role, ...who, ...expiresInMs === void 0 ? {} : { expiresInMs } }).catch(refuse);
+  }
+  /** The email comes from a verified sign-in and the handle from the agent's own record, never from the request. */
+  async accept(ctx, inviteId) {
+    if (!isStoreId(inviteId)) throw new CanvasError("FORBIDDEN", "you may not do this on this board");
+    const user = await this.store.get("users", ctx.principalId);
+    const agent = await this.store.get("principals", ctx.principalId);
+    const identity = {
+      ...user?.emailVerified === true && typeof user.email === "string" ? { email: user.email } : {},
+      ...typeof agent?.handle === "string" ? { handle: agent.handle } : {}
+    };
+    await this.sharing.acceptInvite(ctx, word(inviteId, "id"), identity).catch(refuse);
+    return { ok: true };
+  }
+  /** The token shows once. Only its hash is stored. */
+  async createLink(ctx, id, input) {
+    this.known(id);
+    const role = oneOf(input.role, SHARE_ROLES, "role");
+    const expiresInMs = lifetime(input.expiresInMs, "expiresInMs");
+    if (input.signedInOnly !== void 0 && typeof input.signedInOnly !== "boolean") throw new CanvasError("INVALID", "signedInOnly must be true or false");
+    return this.sharing.createLink(ctx, id, { role, signedInOnly: input.signedInOnly === true, ...expiresInMs === void 0 ? {} : { expiresAt: this.now() + expiresInMs } }).catch(refuse);
+  }
+  /** Revoke a link of this board. A link of another board is NOT_FOUND here, even for an owner of both. */
+  async revokeLink(ctx, id, linkId) {
+    this.known(id);
+    const link = isStoreId(linkId) ? await this.store.get("links", linkId) : null;
+    if (!link || link.resourceId !== id) throw new CanvasError("NOT_FOUND", "no such link on this board");
+    await this.sharing.revokeLink(ctx, linkId).catch(refuse);
+    return { ok: true };
+  }
+};
+
 // src/room-sync.ts
 import * as Y from "yjs";
 var SEEDER = { kind: "agent", id: "canvas-room" };
@@ -1986,7 +2132,9 @@ var staticTokensOn = (env) => env.CANVAS_UNSAFE_STATIC_TOKENS === "1";
 function workerAuth(env, store) {
   const auths = [];
   if (store) auths.push(createStoreAuth(store));
-  if (staticTokensOn(env)) auths.push(tokenAuth(env));
+  const devAuth = staticTokensOn(env) ? tokenAuth(env) : void 0;
+  if (devAuth) auths.push(devAuth);
+  let dev = false;
   let failure;
   const auth = {
     async authenticate(request) {
@@ -1999,6 +2147,7 @@ function workerAuth(env, store) {
           return null;
         }
         if (!found) continue;
+        dev = auth2 === devAuth;
         let step;
         try {
           step = parsePrincipal({ kind: found.kind, id: found.principalId });
@@ -2011,15 +2160,20 @@ function workerAuth(env, store) {
       return null;
     }
   };
-  return { auth, failure: () => failure };
+  return { auth, failure: () => failure, dev: () => dev };
 }
 async function authenticate(request, env, store) {
-  const { auth, failure } = workerAuth(env, store);
+  const found = await identify(request, env, store);
+  return found && { actor: found.actor, role: found.role };
+}
+async function identify(request, env, store) {
+  const { auth, failure, dev } = workerAuth(env, store);
   const found = await principalFromWebSocketRequest(request, auth, { protocol: WS_PROTOCOL, scope: "canvas:read" });
   if (failure() !== void 0) throw failure();
   if (found instanceof Response) return null;
-  return { actor: { kind: found.kind, id: found.principalId }, role: hasScope(found.scopes, "canvas:write") ? "editor" : "viewer" };
+  return { actor: { kind: found.kind, id: found.principalId }, role: hasScope2(found.scopes, "canvas:write") ? "editor" : "viewer", principal: found, dev: dev() };
 }
+var svgResponse = (svg) => new Response(svg, { headers: { "content-type": "image/svg+xml", "x-content-type-options": "nosniff", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; img-src data:" } });
 function sniffImage(bytes) {
   const at = (offset, ...sig) => sig.every((b, i) => bytes[offset + i] === b);
   if (at(0, 137, 80, 78, 71, 13, 10, 26, 10)) return "image/png";
@@ -2088,8 +2242,7 @@ var loggable = (error) => error instanceof Error ? LOGGABLE.exec(error.message)?
 function createApp(options = {}) {
   const app2 = new Hono3();
   app2.get("/health", (c) => c.json({ ok: true }));
-  const api = new Hono3();
-  api.use("*", async (c, next) => {
+  const open = async (c) => {
     let region;
     try {
       region = parseRegion(c.env.CANVAS_REGION ?? "");
@@ -2099,14 +2252,34 @@ function createApp(options = {}) {
     if (!c.env.DB || !c.env.IMAGES) return fail("NOT_CONFIGURED", "bind DB (D1) and IMAGES (R2)", 503);
     if (c.env.CANVAS_API_TOKENS && !staticTokensOn(c.env)) return fail("NOT_CONFIGURED", "CANVAS_API_TOKENS is a dev fallback. Set CANVAS_UNSAFE_STATIC_TOKENS=1 to use it, or remove it and issue agentic-identity credentials", 503);
     await ready(c.env.DB);
-    const store = createD1Store(c.env.DB, { region });
-    const who = await authenticate(c.req.raw, c.env, store);
+    return createD1Store(c.env.DB, { region });
+  };
+  const shared = new Hono3();
+  const visit = async (c, route) => {
+    const store = await open(c);
+    if (store instanceof Response) return store;
+    const who = await identify(c.req.raw, c.env, store);
+    if (!who && c.req.header("authorization")) return fail("UNAUTHORIZED", "send a valid bearer token", 401);
+    const id = c.req.param("id");
+    await new CanvasAccess(store).require(who?.principal ?? null, "read", id, c.req.header("x-link-token") ?? "");
+    return route(new CanvasService(store));
+  };
+  shared.get("/:id", (c) => visit(c, async (service) => c.json(await service.read(c.req.param("id")))));
+  shared.get("/:id/svg", (c) => visit(c, async (service) => svgResponse(await service.exportSvg(c.req.param("id")))));
+  app2.route("/api/v1/canvas/shared", shared);
+  const api = new Hono3();
+  api.use("*", async (c, next) => {
+    const store = await open(c);
+    if (store instanceof Response) return store;
+    const who = await identify(c.req.raw, c.env, store);
     if (!who) return fail("UNAUTHORIZED", "send a valid bearer token", 401);
-    if (who.role === "viewer" && c.req.method !== "GET") return fail("FORBIDDEN", "this token is a viewer; it cannot change a board", 403);
+    if (who.role === "viewer" && c.req.method !== "GET" && !(c.req.method === "POST" && c.req.path === "/api/v1/canvas/invites/accept")) return fail("FORBIDDEN", "this token is a viewer; it cannot change a board", 403);
     c.set("actor", who.actor);
     c.set("role", who.role);
+    c.set("caller", who);
     c.set("service", new CanvasService(store));
-    c.set("blobs", createR2Blobs(c.env.IMAGES, { region, urlBase: new URL(c.req.url).origin, urlSecret: `${crypto.randomUUID()}${crypto.randomUUID()}` }));
+    c.set("access", new CanvasAccess(store));
+    c.set("blobs", createR2Blobs(c.env.IMAGES, { region: parseRegion(c.env.CANVAS_REGION ?? ""), urlBase: new URL(c.req.url).origin, urlSecret: `${crypto.randomUUID()}${crypto.randomUUID()}` }));
     await next();
   });
   api.get("/me", (c) => c.json({ actor: c.var.actor.id, kind: c.var.actor.kind, role: c.var.role }));
@@ -2124,16 +2297,39 @@ function createApp(options = {}) {
     }
   };
   const sync = async (c, next) => {
-    if (!/\/(ws|checkpoint)$/.test(new URL(c.req.url).pathname)) await saveRoom(c, false);
+    if (!/\/(ws|checkpoint)$/.test(new URL(c.req.url).pathname)) {
+      await saveRoom(c, false).catch((error) => {
+        if (!(c.req.method === "DELETE" && error instanceof CanvasError && error.code === "NOT_FOUND")) throw error;
+      });
+    }
     await next();
   };
+  const ADMIN = /* @__PURE__ */ new Set(["access", "grants", "invites", "links"]);
+  const WRITE = /* @__PURE__ */ new Set(["shapes", "connectors", "flow", "move", "elements", "checkpoint"]);
+  const needs = (method, path) => {
+    let decoded;
+    try {
+      decoded = decodeURI(path);
+    } catch {
+      return "admin";
+    }
+    const part = decoded.split("/boards/")[1].split("/");
+    if (part.length === 1) return method === "DELETE" ? "admin" : method === "GET" ? "read" : "write";
+    if (ADMIN.has(part[1])) return "admin";
+    return WRITE.has(part[1]) || method !== "GET" ? "write" : "read";
+  };
+  api.use("/boards/:id/*", async (c, next) => {
+    if (!c.var.caller.dev) await c.var.access.require(c.var.caller.principal, needs(c.req.method, new URL(c.req.url).pathname), c.req.param("id"));
+    await next();
+  });
   api.use("/boards/:id/*", sync);
   api.get("/boards/:id/ws", async (c) => {
     if (!options.live) return fail("NOT_FOUND", "this server hosts no live rooms", 404);
     if (c.req.header("upgrade") !== "websocket") return fail("UPGRADE_REQUIRED", "open this route as a WebSocket", 426);
     const id = c.req.param("id");
     await saveRoom(c, true);
-    const { actor, role } = c.var;
+    const { actor, caller } = c.var;
+    const role = caller.dev ? c.var.role : await c.var.access.allowed(caller.principal, "write", id) ? "editor" : "viewer";
     const opened = await options.live(c.env).connect(id, c.req.raw, { principal: { id: actor.id, kind: actor.kind }, role, name: actor.id });
     return acceptWebSocketProtocol(c.req.raw, opened, WS_PROTOCOL);
   });
@@ -2146,20 +2342,34 @@ function createApp(options = {}) {
     if (!update) throw new CanvasError("INVALID", `the update must be at most ${MAX_LIVE_BYTES} bytes`);
     return c.json(await handSave(options.live(c.env), c.var.service, id, update, c.var.actor));
   });
-  api.get("/boards", async (c) => c.json({ boards: await c.var.service.list() }));
+  api.get("/boards", async (c) => c.json({ boards: c.var.caller.dev ? await c.var.service.list() : await c.var.service.summaries(await c.var.access.readable(c.var.caller.principal)) }));
   api.post("/boards", async (c) => {
     const b = await jsonBody(c);
     const id = b.id === void 0 ? void 0 : text(b.id, "id");
     const title = b.title === void 0 ? void 0 : text(b.title, "title");
-    return c.json(await c.var.service.create(c.var.actor, { id, title }), 201);
+    if (c.var.caller.dev && id !== void 0 && await c.var.access.registered(id)) throw new CanvasError("DUPLICATE_ID", `board "${id}" already exists`);
+    const created = await c.var.service.create(c.var.actor, { id, title });
+    if (!c.var.caller.dev) {
+      await c.var.access.register(c.var.caller.principal, created.id).catch(async (error) => {
+        await c.var.service.delete(created.id).catch((failed) => console.error(JSON.stringify({ level: "error", op: "undo-create", message: loggable(failed) })));
+        throw error;
+      });
+    }
+    return c.json(created, 201);
   });
   api.get("/boards/:id", async (c) => c.json(await c.var.service.read(c.req.param("id"))));
   api.delete("/boards/:id", async (c) => {
     const id = c.req.param("id");
-    await c.var.service.assertExists(id);
+    const { dev, principal } = c.var.caller;
+    if (dev && await c.var.access.registered(id)) throw new CanvasError("FORBIDDEN", "this board has owners: only an owner deletes it");
+    const present = await c.var.service.assertExists(id).then(() => true, (error) => {
+      if (error instanceof CanvasError && error.code === "NOT_FOUND" && !dev) return false;
+      throw error;
+    });
     const live = options.live?.(c.env);
     if (live) await live.erase(id);
-    const deleted = await c.var.service.delete(id);
+    const deleted = present ? await c.var.service.delete(id) : { deleted: id };
+    if (!dev) await c.var.access.unregister(principal, id);
     if (live) {
       await live.erase(id);
       forget(id);
@@ -2167,7 +2377,29 @@ function createApp(options = {}) {
     console.log(JSON.stringify({ level: "info", op: "delete-board", actorKind: c.var.actor.kind }));
     return c.json(deleted);
   });
-  api.get("/boards/:id/svg", async (c) => new Response(await c.var.service.exportSvg(c.req.param("id")), { headers: { "content-type": "image/svg+xml", "x-content-type-options": "nosniff", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; img-src data:" } }));
+  api.get("/boards/:id/svg", async (c) => svgResponse(await c.var.service.exportSvg(c.req.param("id"))));
+  api.get("/boards/:id/access", async (c) => c.json(await c.var.access.list(c.var.caller.principal, c.req.param("id"))));
+  api.post("/boards/:id/grants", async (c) => {
+    const id = c.req.param("id");
+    const input = await jsonBody(c);
+    const done = await c.var.access.grant(c.var.caller.principal, id, input);
+    if (options.live && (input.role === "viewer" || input.role === "commenter") && typeof input.subjectId === "string") {
+      await options.live(c.env).revoke(id, input.subjectId).catch((error) => console.error(JSON.stringify({ level: "error", op: "revoke-room", message: loggable(error) })));
+    }
+    return c.json(done);
+  });
+  api.delete("/boards/:id/grants", async (c) => {
+    const id = c.req.param("id");
+    const subjectKind = c.req.query("subjectKind");
+    const subjectId = c.req.query("subjectId");
+    const done = await c.var.access.revoke(c.var.caller.principal, id, { subjectKind, subjectId });
+    if (options.live && subjectId) await options.live(c.env).revoke(id, subjectId).catch((error) => console.error(JSON.stringify({ level: "error", op: "revoke-room", message: loggable(error) })));
+    return c.json(done);
+  });
+  api.post("/boards/:id/invites", async (c) => c.json(await c.var.access.invite(c.var.caller.principal, c.req.param("id"), await jsonBody(c)), 201));
+  api.post("/boards/:id/links", async (c) => c.json(await c.var.access.createLink(c.var.caller.principal, c.req.param("id"), await jsonBody(c)), 201));
+  api.delete("/boards/:id/links/:link", async (c) => c.json(await c.var.access.revokeLink(c.var.caller.principal, c.req.param("id"), c.req.param("link"))));
+  api.post("/invites/accept", async (c) => c.json(await c.var.access.accept(c.var.caller.principal, text((await jsonBody(c)).id, "id"))));
   api.post("/boards/:id/shapes", async (c) => c.json(await c.var.service.add(c.req.param("id"), await jsonBody(c), c.var.actor), 201));
   api.post("/boards/:id/connectors", async (c) => c.json(await c.var.service.connect(c.req.param("id"), await jsonBody(c), c.var.actor), 201));
   api.post("/boards/:id/flow", async (c) => c.json(await c.var.service.flow(c.req.param("id"), text((await jsonBody(c)).text, "text"), c.var.actor)));
@@ -2227,6 +2459,7 @@ var worker_default = { fetch: (request, env, ctx) => app.fetch(request, env, ctx
 export {
   WS_PROTOCOL,
   authenticate,
+  identify,
   sniffImage,
   createApp,
   worker_default

package/dist/{chunk-GPSOLW2Y.js → chunk-M74ENUWR.js}

@@ -34,6 +34,22 @@ function boardKey(id) {
   }
   return id;
 }
+function isStoreId(id) {
+  try {
+    assertId(id);
+    return /^[A-Za-z0-9_-]{1,128}$/.test(id);
+  } catch {
+    return false;
+  }
+}
+function isBoardId(id) {
+  try {
+    boardKey(id);
+    return true;
+  } catch {
+    return false;
+  }
+}
 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);
@@ -57,13 +73,12 @@ var CanvasService = class {
   /** The first 100 boards (the store sorts by id), with titles. A board whose stored bytes are damaged shows an empty title: it stays in the list so a person can find and repair it. */
   async list() {
     const page = await this.store.query(COLLECTION, { limit: 100 }).catch(storeFailure);
-    return page.items.map(({ id, data }) => {
-      try {
-        return { id, title: decodeStored(data, id, Board.decode).title };
-      } catch {
-        return { id, title: "" };
-      }
-    });
+    return page.items.map(({ id, data }) => summary(id, data));
+  }
+  /** The listed boards that exist, with titles, in the order given. */
+  async summaries(ids) {
+    const found = await Promise.all(ids.map(async (id) => ({ id, data: await this.store.get(COLLECTION, id).catch(storeFailure) })));
+    return found.flatMap(({ id, data }) => data ? [summary(id, data)] : []);
   }
   /** Delete a board and everything on it. Throws NOT_FOUND unless the board exists. The Worker erases the live room too. */
   async delete(id) {
@@ -191,6 +206,13 @@ var CanvasService = class {
     return decodeStored(doc, id, Board.decode);
   }
 };
+function summary(id, data) {
+  try {
+    return { id, title: decodeStored(data, id, Board.decode).title };
+  } catch {
+    return { id, title: "" };
+  }
+}
 function decodeStored(doc, id, decode) {
   try {
     return decode(fromBase64(String(doc.update)));
@@ -202,5 +224,7 @@ function decodeStored(doc, id, decode) {
 
 export {
   MAX_LIVE_BYTES,
+  isStoreId,
+  isBoardId,
   CanvasService
 };

package/dist/chunk-NRLF6MGR.js

@@ -0,0 +1,130 @@
+import {
+  FileStoreError
+} from "./chunk-NWQED42L.js";
+
+// src/store-file.ts
+import { randomUUID } from "crypto";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "fs";
+import { join } from "path";
+import { createFileStore as createIdentityFileStore } from "agentic-identity/file";
+import { StoreConflictError } from "agentic-identity";
+var RETRY_FOR_MS = 1e4;
+var LOCK_STALE_MS = 3e3;
+var LOCK_WAIT_MS = 5e3;
+var HELD = /locked by another process/;
+var NOT_A_STORE_FILE = /is not an agentic-identity store file/;
+async function retried(run) {
+  const deadline = Date.now() + RETRY_FOR_MS;
+  for (; ; ) {
+    try {
+      return await run();
+    } catch (error) {
+      const clash = error instanceof StoreConflictError && !HELD.test(error.message);
+      if (!clash || Date.now() > deadline) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 5 + Math.random() * 20));
+    }
+  }
+}
+var isDoc = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sleep = (ms) => void Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function legacyCollections(path) {
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    const current = isDoc(data) && data.format === 1 && isDoc(data.collections);
+    const old = isDoc(data) && !current && Object.values(data).every((docs) => isDoc(docs) && Object.values(docs).every(isDoc));
+    return old ? data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function withLock(path, fn) {
+  const lock = `${path}.lock`;
+  const mine = `${process.pid}:${randomUUID()}`;
+  for (const start = Date.now(); ; ) {
+    try {
+      writeFileSync(lock, mine, { flag: "wx", mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") return false;
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) unlinkSync(lock);
+      } catch {
+      }
+      if (Date.now() - start > LOCK_WAIT_MS) return false;
+      sleep(10);
+    }
+  }
+  const owned = () => {
+    try {
+      return readFileSync(lock, "utf8") === mine;
+    } catch {
+      return false;
+    }
+  };
+  try {
+    fn(owned);
+  } finally {
+    if (owned()) rmSync(lock, { force: true });
+  }
+  return true;
+}
+function upgradeLegacyFile(path) {
+  if (legacyCollections(path) === void 0) return true;
+  try {
+    withLock(path, (owned) => {
+      const data = legacyCollections(path);
+      if (data === void 0) return;
+      const temp = `${path}.${process.pid}.upgrade`;
+      try {
+        const fd = openSync(temp, "w", 384);
+        try {
+          writeSync(fd, JSON.stringify({ format: 1, collections: data }));
+          fsyncSync(fd);
+        } finally {
+          closeSync(fd);
+        }
+        if (owned()) renameSync(temp, path);
+      } finally {
+        rmSync(temp, { force: true });
+      }
+    });
+  } catch {
+  }
+  return legacyCollections(path) === void 0;
+}
+function createFileStore(path, options = {}) {
+  upgradeLegacyFile(path);
+  const inner = createIdentityFileStore({ ...options, path });
+  const guard = async (run) => {
+    for (let upgraded = false; ; upgraded = true) {
+      try {
+        return await retried(run);
+      } catch (error) {
+        if (!(error instanceof Error)) throw error;
+        if (HELD.test(error.message)) throw new FileStoreError("LOCKED", "the database file is locked. If no agentic-canvas process runs, remove the .lock file next to it");
+        if (!NOT_A_STORE_FILE.test(error.message)) throw error;
+        if (legacyCollections(path) === void 0) throw new FileStoreError("DAMAGED", "the database file is not valid JSON. Repair or remove it");
+        if (upgraded || !upgradeLegacyFile(path)) throw new FileStoreError("DAMAGED", "the database file is in the older layout and could not be upgraded. Try again, and check that its folder is writable");
+      }
+    }
+  };
+  return {
+    region: inner.region,
+    get: (collection, id) => guard(() => inner.get(collection, id)),
+    query: (collection, query) => guard(() => inner.query(collection, query)),
+    put: (collection, id, doc) => guard(() => inner.put(collection, id, doc)),
+    delete: (collection, id) => guard(() => inner.delete(collection, id)),
+    transaction: (fn) => guard(() => inner.transaction(fn))
+  };
+}
+function openLocalStore(dir) {
+  mkdirSync(dir, { recursive: true });
+  return createFileStore(join(dir, STORE_FILE));
+}
+var STORE_FILE = "canvas.json";
+
+export {
+  createFileStore,
+  openLocalStore,
+  STORE_FILE
+};

package/dist/cli.js

@@ -5,13 +5,13 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-3QW4UF2R.js";
+} from "./chunk-7IOW6LML.js";
 import {
   openLocalStore
-} from "./chunk-UKST5A57.js";
+} from "./chunk-NRLF6MGR.js";
 import {
   CanvasService
-} from "./chunk-GPSOLW2Y.js";
+} from "./chunk-M74ENUWR.js";
 import "./chunk-NWQED42L.js";
 import {
   CanvasError

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { E as ErrorCode, a as BoardData, c as ShapeType, S as Shape, d as Endpoint, C as Connector } from './read-CeWoSAAy.js';
+import { E as ErrorCode, a as BoardData, c as ShapeType, S as Shape, d as Endpoint, C as Connector } from './read--Jd3kE13.js';
 import { PrincipalKind } from 'agentic-identity';
 import 'yjs';
 import 'zod';

package/dist/embed.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { CanvasClient } from './client.js';
 import { PrincipalKind } from 'agentic-identity';
-import './read-CeWoSAAy.js';
+import './read--Jd3kE13.js';
 import 'yjs';
 import 'zod';
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { B as Board, P as Principal } from './read-CeWoSAAy.js';
-export { a as BoardData, b as CanvasElement, e as CanvasError, C as Connector, f as EdgeData, d as Endpoint, E as ErrorCode, G as Group, M as MAX_ELEMENTS, g as MAX_TEXT, N as NodeData, h as SHAPE_TYPES, S as Shape, c as ShapeType, p as principalSchema, r as readBoard } from './read-CeWoSAAy.js';
-import { B as BoardAccess } from './service-D9WzMLH1.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-D9WzMLH1.js';
+import { B as Board, P as Principal } from './read--Jd3kE13.js';
+export { a as BoardData, b as CanvasElement, e as CanvasError, C as Connector, f as EdgeData, d as Endpoint, E as ErrorCode, G as Group, M as MAX_ELEMENTS, g as MAX_TEXT, N as NodeData, h as SHAPE_TYPES, S as Shape, c as ShapeType, p as principalSchema, r as readBoard } from './read--Jd3kE13.js';
+import { B as BoardAccess } from './service-OiTtNadu.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-OiTtNadu.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,14 +6,14 @@ import {
   operatorActor,
   runMcp,
   svgToPng
-} from "./chunk-3QW4UF2R.js";
+} from "./chunk-7IOW6LML.js";
 import {
   createFileStore,
   openLocalStore
-} from "./chunk-UKST5A57.js";
+} from "./chunk-NRLF6MGR.js";
 import {
   CanvasService
-} from "./chunk-GPSOLW2Y.js";
+} from "./chunk-M74ENUWR.js";
 import "./chunk-NWQED42L.js";
 import {
   Board,

package/dist/live-worker.d.ts

@@ -5,10 +5,10 @@ import 'agentic-identity';
 import 'agentic-realtime';
 import 'agentic-identity/cloudflare';
 import 'hono';
-import './read-CeWoSAAy.js';
+import './read--Jd3kE13.js';
 import 'yjs';
 import 'zod';
-import './service-D9WzMLH1.js';
+import './service-OiTtNadu.js';
 
 type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
 interface LiveEnv extends WorkerEnv {

package/dist/live-worker.js

@@ -1,7 +1,7 @@
 import {
   createApp
-} from "./chunk-EH7WCMK6.js";
-import "./chunk-GPSOLW2Y.js";
+} from "./chunk-JQCUVXXD.js";
+import "./chunk-M74ENUWR.js";
 import "./chunk-NWQED42L.js";
 import {
   CanvasError

package/dist/live.d.ts

@@ -1,6 +1,6 @@
-import { B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read-CeWoSAAy.js';
+import { B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read--Jd3kE13.js';
 import { Peer } from 'agentic-realtime/client';
-import { B as BoardAccess, D as DrawOptions } from './service-D9WzMLH1.js';
+import { B as BoardAccess, D as DrawOptions } from './service-OiTtNadu.js';
 import 'yjs';
 import 'agentic-identity';
 import 'zod';

package/dist/{read-CeWoSAAy.d.ts → read--Jd3kE13.d.ts}

@@ -6,22 +6,16 @@ import { z } from 'zod';
  * The actor of a new write. The rule is the identity kernel's `parsePrincipal`: a known kind, and an id of 1 to 128
  * characters from A-Z, a-z, 0-9, ".", "_" and "-". The Worker, the CLI and the SDK all use it.
  */
-declare const principalSchema: z.ZodEffects<z.ZodObject<{
+declare const principalSchema: z.ZodPipe<z.ZodObject<{
     kind: z.ZodString;
     id: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    kind: string;
-    id: string;
-}, {
-    kind: string;
-    id: string;
-}>, {
+}, z.core.$strict>, z.ZodTransform<{
     kind: PrincipalKind;
     id: string;
 }, {
     kind: string;
     id: string;
-}>;
+}>>;
 type Principal = {
     kind: PrincipalKind;
     id: string;

package/dist/{service-D9WzMLH1.d.ts → service-OiTtNadu.d.ts}

@@ -1,4 +1,4 @@
-import { c as ShapeType, B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read-CeWoSAAy.js';
+import { c as ShapeType, B as Board, P as Principal, a as BoardData, S as Shape, C as Connector, b as CanvasElement } from './read--Jd3kE13.js';
 import { Store } from 'agentic-identity';
 
 declare const MAX_FLOW_NODES = 500;
@@ -68,6 +68,11 @@ declare class CanvasService {
         id: string;
         title: string;
     }[]>;
+    /** The listed boards that exist, with titles, in the order given. */
+    summaries(ids: string[]): Promise<{
+        id: string;
+        title: string;
+    }[]>;
     /** Delete a board and everything on it. Throws NOT_FOUND unless the board exists. The Worker erases the live room too. */
     delete(id: string): Promise<{
         deleted: string;

package/dist/store-file.d.ts

@@ -7,19 +7,8 @@ declare class FileStoreError extends Error {
 }
 
 interface FileStoreOptions extends AdapterOptions {
-    /** How long a write waits for the lock before it fails. Defaults to 10000. */
-    lockTimeoutMs?: number;
-    /** A lock older than this is stale, if its owner is alive. Defaults to 30000. */
-    staleAfterMs?: number;
 }
-/**
- * A Store kept in one JSON file. Node only. It is an adapter of the shared Store port and passes `runStoreContract`. Many processes may share the file, for example the CLI
- * and the MCP server. Each write takes a lock file, reads the file again, applies the change, and
- * replaces the file by an atomic rename. A read sees the last renamed file, so it takes no lock.
- * Each call reads the whole file and loads the docs it needs into the shared memory adapter, which runs the
- * queries and the transaction rules. Cost grows with the file. Use it for local work, not for scale.
- * The lock needs one machine: the process check and the clock do not work across hosts.
- */
+/** A Store kept in one JSON file. Node only. It is the file adapter of agentic-identity, with a retry on a write clash. */
 declare function createFileStore(path: string, options?: FileStoreOptions): Store;
 /** The store the CLI and the MCP server share: one file in `dir`, which is made if it is missing. */
 declare function openLocalStore(dir: string): Store;

package/dist/store-file.js

@@ -2,7 +2,7 @@ import {
   STORE_FILE,
   createFileStore,
   openLocalStore
-} from "./chunk-UKST5A57.js";
+} from "./chunk-NRLF6MGR.js";
 import {
   FileStoreError
 } from "./chunk-NWQED42L.js";

package/dist/worker.d.ts

@@ -1,12 +1,87 @@
-import { Store, Blobs } from 'agentic-identity';
+import { Store, PrincipalContext, Action, Grant, InviteSummary, Blobs } from 'agentic-identity';
 import { Realtime } from 'agentic-realtime';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
 import { Hono } from 'hono';
-import { P as Principal } from './read-CeWoSAAy.js';
-import { C as CanvasService } from './service-D9WzMLH1.js';
+import { P as Principal } from './read--Jd3kE13.js';
+import { C as CanvasService } from './service-OiTtNadu.js';
 import 'yjs';
 import 'zod';
 
+/**
+ * Who may do what on a board. A board is an identity resource of type `canvas`. The roles, the grants, the invites,
+ * and the links are those of agentic-identity: this class checks input and maps its failures to `CanvasError`.
+ * A caller who cannot read a board gets NOT_FOUND, so a board id tells a stranger nothing. A caller who can read
+ * it and lacks the role for the action gets FORBIDDEN.
+ */
+declare class CanvasAccess {
+    private readonly store;
+    private readonly sharing;
+    private readonly now;
+    constructor(store: Store, options?: {
+        now?: () => number;
+    });
+    /** A board id that the Store refuses names no board. The gate checks this for a role holder: a token of the dev list skips the gate. */
+    private known;
+    /** Make the actor the owner of a new board. */
+    register(ctx: PrincipalContext, id: string): Promise<void>;
+    /** Remove the sharing records of a board. Needs an owner. */
+    unregister(ctx: PrincipalContext, id: string): Promise<void>;
+    /** True if the board has sharing records: it was made by an identity credential. */
+    registered(id: string): Promise<boolean>;
+    /**
+     * True if the caller may do `action` on the board. A link token adds the role of its link. It writes an audit entry.
+     * An id that belongs to a resource of another type, in a Store shared with another app, is no board: it is denied.
+     */
+    allowed(ctx: PrincipalContext | null, action: Action, id: string, linkToken?: string): Promise<boolean>;
+    /** Throw NOT_FOUND for a caller who cannot read the board, and FORBIDDEN for one who can read it but not do `action`. */
+    require(ctx: PrincipalContext | null, action: Action, id: string, linkToken?: string): Promise<void>;
+    /** The ids of the boards a person or agent holds a role on, the first 100. A credential without `canvas:read` gets none. */
+    readable(ctx: PrincipalContext): Promise<string[]>;
+    grant(ctx: PrincipalContext, id: string, input: {
+        subjectKind?: unknown;
+        subjectId?: unknown;
+        role?: unknown;
+    }): Promise<{
+        ok: true;
+    }>;
+    revoke(ctx: PrincipalContext, id: string, input: {
+        subjectKind?: unknown;
+        subjectId?: unknown;
+    }): Promise<{
+        ok: true;
+    }>;
+    /** The grants and the invites on a board. An invite never shows its email. Links are not listed: a token shows once. */
+    list(ctx: PrincipalContext, id: string): Promise<{
+        grants: Grant[];
+        invites: InviteSummary[];
+    }>;
+    invite(ctx: PrincipalContext, id: string, input: {
+        role?: unknown;
+        email?: unknown;
+        handle?: unknown;
+        expiresInMs?: unknown;
+    }): Promise<{
+        id: string;
+    }>;
+    /** The email comes from a verified sign-in and the handle from the agent's own record, never from the request. */
+    accept(ctx: PrincipalContext, inviteId: string): Promise<{
+        ok: true;
+    }>;
+    /** The token shows once. Only its hash is stored. */
+    createLink(ctx: PrincipalContext, id: string, input: {
+        role?: unknown;
+        signedInOnly?: unknown;
+        expiresInMs?: unknown;
+    }): Promise<{
+        id: string;
+        token: string;
+    }>;
+    /** Revoke a link of this board. A link of another board is NOT_FOUND here, even for an owner of both. */
+    revokeLink(ctx: PrincipalContext, id: string, linkId: string): Promise<{
+        ok: true;
+    }>;
+}
+
 interface WorkerEnv {
     DB: D1Like;
     IMAGES: R2Like;
@@ -33,13 +108,22 @@ interface WorkerEnv {
     CANVAS_MAX_IMAGE_BYTES?: string;
 }
 type Role = "editor" | "viewer";
+/** The caller. `dev` is true for a token of the static list: it holds no board roles and reaches every board. */
+interface Caller {
+    actor: Principal;
+    role: Role;
+    principal: PrincipalContext;
+    dev: boolean;
+}
 type App = {
     Bindings: WorkerEnv;
     Variables: {
         service: CanvasService;
+        access: CanvasAccess;
         blobs: Blobs;
         actor: Principal;
         role: Role;
+        caller: Caller;
     };
 };
 interface AppOptions {
@@ -58,6 +142,8 @@ declare function authenticate(request: Request, env: WorkerEnv, store?: Store):
     actor: Principal;
     role: Role;
 } | null>;
+/** Like `authenticate`, with the whole principal context that board roles are checked against. */
+declare function identify(request: Request, env: WorkerEnv, store?: Store): Promise<Caller | null>;
 /** The image types we accept, found by their first bytes. The client's claim of a type is not trusted. */
 declare function sniffImage(bytes: Uint8Array): string | null;
 declare function createApp(options?: AppOptions): Hono<App>;
@@ -65,4 +151,4 @@ declare const _default: {
     fetch: (request: Request, env: WorkerEnv, ctx: unknown) => Response | Promise<Response>;
 };
 
-export { type AppOptions, type Role, WS_PROTOCOL, type WorkerEnv, authenticate, createApp, _default as default, sniffImage };
+export { type AppOptions, type Caller, type Role, WS_PROTOCOL, type WorkerEnv, authenticate, createApp, _default as default, identify, sniffImage };

package/dist/worker.js

@@ -2,10 +2,11 @@ import {
   WS_PROTOCOL,
   authenticate,
   createApp,
+  identify,
   sniffImage,
   worker_default
-} from "./chunk-EH7WCMK6.js";
-import "./chunk-GPSOLW2Y.js";
+} from "./chunk-JQCUVXXD.js";
+import "./chunk-M74ENUWR.js";
 import "./chunk-NWQED42L.js";
 import "./chunk-ZSPZMGHG.js";
 import "./chunk-JOBTIAFJ.js";
@@ -14,5 +15,6 @@ export {
   authenticate,
   createApp,
   worker_default as default,
+  identify,
   sniffImage
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-canvas",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A shared whiteboard for diagrams, drawn by people and agents.",
   "keywords": [
     "whiteboard",
@@ -25,6 +25,7 @@
   },
   "files": [
     "dist",
+    "LICENSE",
     "llms.txt",
     "SKILL.md"
   ],
@@ -80,11 +81,11 @@
   "dependencies": {
     "@dagrejs/dagre": "^3.1.3",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "agentic-design": "^0.2.0",
-    "agentic-identity": "^0.6.0",
+    "agentic-design": "^0.3.2",
+    "agentic-identity": "^0.7.0",
     "agentic-realtime": "^0.4.2",
     "yjs": "^13.6.0",
-    "zod": "^3.25.0"
+    "zod": "^4.6.7"
   },
   "peerDependencies": {
     "playwright-core": ">=1.40.0",
@@ -121,5 +122,8 @@
     "vite": "^7.3.7",
     "vitest": "^3.0.0",
     "wrangler": "^4.155.0"
+  },
+  "overrides": {
+    "zod": "$zod"
   }
 }

package/dist/chunk-UKST5A57.js

@@ -1,228 +0,0 @@
-import {
-  FileStoreError
-} from "./chunk-NWQED42L.js";
-
-// src/store-file.ts
-import { randomUUID } from "crypto";
-import { mkdirSync } from "fs";
-import { link, open, readFile, rename, unlink } from "fs/promises";
-import { join } from "path";
-import { assertCollection, assertId, createMemoryStore, parseRegion, StoreConflictError } from "agentic-identity";
-var MAX_TRANSACTION_RUNS = 50;
-var clone = (value) => JSON.parse(JSON.stringify(value));
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var codeOf = (error) => error?.code;
-function processIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return codeOf(error) === "EPERM";
-  }
-}
-function lockIsStale(text, staleAfterMs) {
-  let held;
-  try {
-    held = JSON.parse(text);
-  } catch {
-    return false;
-  }
-  if (typeof held !== "object" || held === null) return false;
-  const { pid, at } = held;
-  if (typeof pid !== "number" || !Number.isInteger(pid) || pid < 1 || typeof at !== "number" || !Number.isFinite(at)) return false;
-  return !processIsAlive(pid) || Date.now() - at > staleAfterMs;
-}
-function createFileStore(path, options = {}) {
-  const region = parseRegion(options.region ?? "unknown");
-  const lockPath = `${path}.lock`;
-  const timeoutMs = options.lockTimeoutMs ?? 1e4;
-  const staleAfterMs = options.staleAfterMs ?? 3e4;
-  for (const ms of [timeoutMs, staleAfterMs]) if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) throw new TypeError("lockTimeoutMs and staleAfterMs must be finite numbers of 0 or more");
-  let queue = Promise.resolve();
-  async function load() {
-    let text;
-    try {
-      text = await readFile(path, "utf8");
-    } catch (error) {
-      if (codeOf(error) === "ENOENT") return /* @__PURE__ */ new Map();
-      throw error;
-    }
-    try {
-      const data = JSON.parse(text);
-      if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error();
-      return new Map(
-        Object.entries(data).map(([name, docs]) => {
-          if (typeof docs !== "object" || docs === null || Array.isArray(docs)) throw new Error();
-          for (const doc of Object.values(docs)) if (typeof doc !== "object" || doc === null || Array.isArray(doc)) throw new Error();
-          return [name, new Map(Object.entries(docs))];
-        })
-      );
-    } catch {
-      throw new FileStoreError("DAMAGED", `the database file is not valid JSON. Repair or remove it`);
-    }
-  }
-  async function save(snapshot) {
-    const text = JSON.stringify(Object.fromEntries([...snapshot].map(([name, docs]) => [name, Object.fromEntries(docs)])));
-    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-      const handle = await open(temp, "w");
-      try {
-        await handle.writeFile(text);
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await rename(temp, path);
-    } catch (error) {
-      await unlink(temp).catch(() => void 0);
-      throw error;
-    }
-  }
-  async function takeOverIfStale() {
-    let seen;
-    try {
-      seen = await readFile(lockPath, "utf8");
-    } catch {
-      return;
-    }
-    if (!lockIsStale(seen, staleAfterMs)) return;
-    const aside = `${lockPath}.stale.${randomUUID()}`;
-    try {
-      await rename(lockPath, aside);
-    } catch {
-      return;
-    }
-    if (await readFile(aside, "utf8").catch(() => "") !== seen) await link(aside, lockPath).catch(() => void 0);
-    await unlink(aside).catch(() => void 0);
-  }
-  async function acquire() {
-    const token = randomUUID();
-    const deadline = Date.now() + timeoutMs;
-    for (; ; ) {
-      try {
-        const handle = await open(lockPath, "wx");
-        try {
-          await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), token }));
-        } finally {
-          await handle.close();
-        }
-        return token;
-      } catch (error) {
-        if (codeOf(error) !== "EEXIST") throw error;
-      }
-      await takeOverIfStale();
-      if (Date.now() > deadline) throw new FileStoreError("LOCKED", `the database file is locked. If no agentic-canvas process runs, remove the .lock file next to it`);
-      await sleep(5 + Math.random() * 15);
-    }
-  }
-  async function release(token) {
-    const text = await readFile(lockPath, "utf8").catch(() => "");
-    if (text.includes(`"token":"${token}"`)) await unlink(lockPath).catch(() => void 0);
-  }
-  async function memoryOf(snapshot, only) {
-    const memory = createMemoryStore({ region });
-    for (const [name, docs] of snapshot) if (only === void 0 || only === name) for (const [id, doc] of docs) await memory.put(name, id, doc);
-    return memory;
-  }
-  const recording = (inner, log) => ({
-    get: (collection, id) => inner.get(collection, id),
-    query: (collection, query) => inner.query(collection, query),
-    put: async (collection, id, doc) => {
-      await inner.put(collection, id, doc);
-      log.push([collection, id, clone(doc)]);
-    },
-    delete: async (collection, id) => {
-      await inner.delete(collection, id);
-      log.push([collection, id, null]);
-    }
-  });
-  const locked = (body) => {
-    const run = queue.then(async () => {
-      const token = await acquire();
-      try {
-        return await body();
-      } finally {
-        await release(token);
-      }
-    });
-    queue = run.catch(() => void 0);
-    return run;
-  };
-  async function commit(snapshot, log) {
-    for (const [name, id, doc] of log) {
-      if (doc === null) snapshot.get(name)?.delete(id);
-      else snapshot.set(name, (snapshot.get(name) ?? /* @__PURE__ */ new Map()).set(id, doc));
-    }
-    if (log.length > 0) await save(snapshot);
-  }
-  const writeOne = (write) => locked(async () => {
-    const log = [];
-    await write(recording(createMemoryStore({ region }), log));
-    await commit(await load(), log);
-  });
-  const watching = (inner, seen) => ({
-    ...inner,
-    async get(collection, id) {
-      const doc = await inner.get(collection, id);
-      if (!seen.has(`${collection}/${id}`)) seen.set(`${collection}/${id}`, JSON.stringify(doc));
-      return doc;
-    },
-    async query(collection, query) {
-      const page = await inner.query(collection, query);
-      for (const item of page.items) if (!seen.has(`${collection}/${item.id}`)) seen.set(`${collection}/${item.id}`, JSON.stringify(item.data));
-      return page;
-    }
-  });
-  const unchanged = (snapshot, seen) => [...seen].every(([key, text]) => {
-    const slash = key.indexOf("/");
-    return JSON.stringify(snapshot.get(key.slice(0, slash))?.get(key.slice(slash + 1)) ?? null) === text;
-  });
-  return {
-    region,
-    async get(collection, id) {
-      assertCollection(collection);
-      assertId(id);
-      const doc = (await load()).get(collection)?.get(id);
-      return doc ? clone(doc) : null;
-    },
-    async query(collection, query) {
-      assertCollection(collection);
-      return (await memoryOf(await load(), collection)).query(collection, query);
-    },
-    put: (collection, id, doc) => writeOne((ops) => ops.put(collection, id, doc)),
-    delete: (collection, id) => writeOne((ops) => ops.delete(collection, id)),
-    // Optimistic, as the port requires: run on a copy of the file with no lock, then take the lock and commit
-    // only if every doc the run read is unchanged. Else run again. The memory adapter keeps the rule that
-    // every read comes before the first write.
-    async transaction(fn) {
-      for (let run = 0; run < MAX_TRANSACTION_RUNS; run++) {
-        const log = [];
-        const seen = /* @__PURE__ */ new Map();
-        const result = await (await memoryOf(await load())).transaction(async (tx) => {
-          log.length = 0;
-          seen.clear();
-          return fn(watching(recording(tx, log), seen));
-        });
-        const done = log.length === 0 ? unchanged(await load(), seen) : await locked(async () => {
-          const current = await load();
-          if (!unchanged(current, seen)) return false;
-          await commit(current, log);
-          return true;
-        });
-        if (done) return result;
-      }
-      throw new StoreConflictError();
-    }
-  };
-}
-function openLocalStore(dir) {
-  mkdirSync(dir, { recursive: true });
-  return createFileStore(join(dir, STORE_FILE));
-}
-var STORE_FILE = "canvas.json";
-
-export {
-  createFileStore,
-  openLocalStore,
-  STORE_FILE
-};