agentic-documents 0.1.0 → 0.3.0

package/dist/cli.js

@@ -2,18 +2,24 @@
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-BSXUNQDR.js";
+} from "./chunk-TFCRPEEM.js";
+import {
+  LiveService,
+  whoAmI
+} from "./chunk-R5XUTBC3.js";
 import {
   DocsService
-} from "./chunk-LRPLNXOF.js";
+} from "./chunk-FZA5LQV3.js";
 import {
   VERSION
 } from "./chunk-5Y66UCTE.js";
+import {
+  commands
+} from "./chunk-GYQFTF2E.js";
 import {
   DocError,
-  commands,
   parseAuthor
-} from "./chunk-4YVWD5PH.js";
+} from "./chunk-YBBQNCMC.js";
 
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -26,6 +32,7 @@ var options = {
   as: { type: "string" },
   scopes: { type: "string" },
   dir: { type: "string" },
+  live: { type: "string" },
   file: { type: "string" },
   out: { type: "string" },
   help: { type: "boolean", short: "h" },
@@ -47,6 +54,8 @@ function help() {
     "                    agent_of_agent, agent, user_token.",
     "  --scopes <a,b>    Rights for the author, such as docs:accept. Or set AGENTIC_DOCS_SCOPES. An agent",
     "                    needs docs:accept to accept a suggestion.",
+    "  --live <url>      Join live rooms on this server, as the author of AGENTIC_DOCS_TOKEN. Or set",
+    "                    AGENTIC_DOCS_LIVE_URL. The server sets your author kind, so --as, --scopes, and --dir are refused.",
     "  --dir <path>      Where documents live. Or set AGENTIC_DOCS_DIR. Default: .agentic-documents",
     "  --file <path>     Read content (or markdown for new) from a file.",
     "  --out <path>      Write the export to a file.",
@@ -76,13 +85,40 @@ async function main(argv, env = process.env) {
     console.log(values.version ? VERSION : help());
     return 0;
   }
-  const dir = values.dir ?? env.AGENTIC_DOCS_DIR ?? ".agentic-documents";
-  const service = new DocsService({ blobs: createFileBlobs(join(dir, "blobs")), store: createFileStore(join(dir, "store")) });
-  const scopes = (values.scopes ?? env.AGENTIC_DOCS_SCOPES)?.split(",").map((s) => s.trim()).filter(Boolean);
-  const named = parseAuthor(values.as ?? env.AGENTIC_DOCS_AS);
-  const author = named && scopes?.length ? { ...named, scopes } : named;
+  const liveUrl = values.live ?? (env.AGENTIC_DOCS_LIVE_URL || void 0);
+  let service;
+  let author;
+  if (liveUrl !== void 0) {
+    if (!/^https?:\/\/[^/\s]+/.test(liveUrl)) {
+      console.error(`--live needs an http:// or https:// address, not "${liveUrl}"`);
+      return 2;
+    }
+    if (values.as !== void 0 || values.scopes !== void 0 || values.dir !== void 0) {
+      console.error("--as, --scopes, and --dir do not apply with --live: the server sets the author kind and the scopes from the token, and keeps the documents.");
+      return 2;
+    }
+    const token = env.AGENTIC_DOCS_TOKEN;
+    if (!token) {
+      console.error("set AGENTIC_DOCS_TOKEN to a bearer token to join a live room");
+      return 2;
+    }
+    try {
+      author = (await whoAmI(liveUrl, token)).author;
+    } catch (error) {
+      if (!(error instanceof DocError)) throw error;
+      console.error(`${error.code}: ${error.message}`);
+      return 1;
+    }
+    service = new LiveService({ server: liveUrl, token });
+  } else {
+    const dir = values.dir ?? env.AGENTIC_DOCS_DIR ?? ".agentic-documents";
+    service = new DocsService({ blobs: createFileBlobs(join(dir, "blobs")), store: createFileStore(join(dir, "store")) });
+    const scopes = (values.scopes ?? env.AGENTIC_DOCS_SCOPES)?.split(",").map((s) => s.trim()).filter(Boolean);
+    const named = parseAuthor(values.as ?? env.AGENTIC_DOCS_AS);
+    author = named && scopes?.length ? { ...named, scopes } : named;
+  }
   if (name === "mcp") {
-    const { startMcp } = await import("./mcp-2VZIGHIX.js");
+    const { startMcp } = await import("./mcp-P2C75IIG.js");
     await startMcp(service, author);
     return 0;
   }
@@ -91,7 +127,7 @@ async function main(argv, env = process.env) {
     console.error(`unknown command "${name}". Run "${NAME} --help".`);
     return 2;
   }
-  const { as: _as, scopes: _scopes, dir: _dir, file, out, help: _help, version: _version, ...fields } = values;
+  const { as: _as, scopes: _scopes, dir: _dir, live: _live, file, out, help: _help, version: _version, ...fields } = values;
   const input = { ...command.shape.id ? { id } : {}, ...fields };
   try {
     if (file !== void 0) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { P as Principal, A as Anchor, a as AgenticDoc, T as TextTarget, b as AnchorTarget, D as DocsService, c as PmNode } from './service-eYISo6-b.js';
-export { d as DocInfo, e as DocOptions, f as DocsPorts, E as EditEntry, g as PRINCIPAL_KINDS, h as PrincipalKind, S as Section, i as SectionTarget, j as Target, k as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './service-eYISo6-b.js';
+import { P as Principal, A as Anchor, a as AgenticDoc, T as TextTarget, b as AnchorTarget, D as DocAccess, c as PmNode } from './service-BKkxEnaJ.js';
+export { d as DocInfo, e as DocOptions, f as DocsPorts, g as DocsService, E as EditEntry, h as PRINCIPAL_KINDS, i as PrincipalKind, S as Section, j as SectionTarget, k as Target, l as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './service-BKkxEnaJ.js';
 import { Schema } from 'prosemirror-model';
 import { z } from 'zod';
 import { AdapterOptions, Blobs, Store } from 'agentic-identity';
@@ -95,7 +95,7 @@ interface Command {
     description: string;
     shape: z.ZodRawShape;
     readOnly: boolean;
-    run(service: DocsService, input: Record<string, unknown>, author: Principal | undefined): Promise<unknown>;
+    run(service: DocAccess, input: Record<string, unknown>, author: Principal | undefined): Promise<unknown>;
 }
 declare const commands: Command[];
 
@@ -142,4 +142,4 @@ declare const ODT_MIME = "application/vnd.oasis.opendocument.text";
 /** Write blocks as an OpenDocument text file (.odt): content, styles, and images as embedded files. */
 declare function exportOdt(blocks: PmNode[]): Uint8Array;
 
-export { AgenticDoc, Anchor, AnchorTarget, type Command, DocError, type DocErrorCode, DocsService, EXPORT_FORMATS, type ExportFormat, type ExportOptions, type ExportResult, type FileBlobsOptions, type Message, ODT_MIME, PmNode, Principal, type Suggestion, Suggestions, TextTarget, type Thread, Threads, commands, createFileBlobs, createFileStore, exportDoc, exportOdt, schema };
+export { AgenticDoc, Anchor, AnchorTarget, type Command, DocError, type DocErrorCode, EXPORT_FORMATS, type ExportFormat, type ExportOptions, type ExportResult, type FileBlobsOptions, type Message, ODT_MIME, PmNode, Principal, type Suggestion, Suggestions, TextTarget, type Thread, Threads, commands, createFileBlobs, createFileStore, exportDoc, exportOdt, schema };

package/dist/index.js

@@ -1,26 +1,28 @@
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-BSXUNQDR.js";
+} from "./chunk-TFCRPEEM.js";
 import {
   DocsService
-} from "./chunk-LRPLNXOF.js";
+} from "./chunk-FZA5LQV3.js";
 import {
-  AgenticDoc,
-  DocError,
   EXPORT_FORMATS,
   ODT_MIME,
+  commands,
+  exportDoc,
+  exportOdt
+} from "./chunk-GYQFTF2E.js";
+import {
+  AgenticDoc,
+  DocError,
   PRINCIPAL_KINDS,
   Suggestions,
   Threads,
   blocksToMarkdown,
-  commands,
-  exportDoc,
-  exportOdt,
   markdownToBlocks,
   parseAuthor,
   schema
-} from "./chunk-4YVWD5PH.js";
+} from "./chunk-YBBQNCMC.js";
 export {
   AgenticDoc,
   DocError,

package/dist/live-worker.d.ts

@@ -0,0 +1,20 @@
+import { createDurableObjectRealtime } from 'agentic-realtime/worker';
+export { SyncRoom } from 'agentic-realtime/worker';
+import { WorkerEnv } from './worker.js';
+import 'hono';
+import 'agentic-identity';
+import 'agentic-identity/cloudflare';
+import 'agentic-realtime';
+import './service-BKkxEnaJ.js';
+import 'yjs';
+
+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,27 @@
+import {
+  createApp,
+  regionOf,
+  serviceFor
+} from "./chunk-IU3YIQ4Y.js";
+import "./chunk-FZA5LQV3.js";
+import "./chunk-GYQFTF2E.js";
+import {
+  DocError
+} from "./chunk-YBBQNCMC.js";
+
+// src/live-worker.ts
+import { createDurableObjectRealtime } from "agentic-realtime/worker";
+import { SyncRoom } from "agentic-realtime/worker";
+var app = createApp(serviceFor, {
+  live: (env) => {
+    const region = regionOf(env);
+    const rooms = env.SYNC_ROOM;
+    if (!rooms) throw new DocError("MISCONFIGURED", "bind a Durable Object namespace as SYNC_ROOM");
+    return createDurableObjectRealtime(rooms, region === "eu" ? "eu" : void 0);
+  }
+});
+var live_worker_default = { fetch: (request, env, ctx) => app.fetch(request, env, ctx) };
+export {
+  SyncRoom,
+  live_worker_default as default
+};

package/dist/live.d.ts

@@ -0,0 +1,73 @@
+import { Peer } from 'agentic-realtime/client';
+import { a as AgenticDoc, P as Principal, e as DocOptions, D as DocAccess } from './service-BKkxEnaJ.js';
+import 'yjs';
+import 'agentic-identity';
+
+interface LiveOptions {
+    /** The Worker address, such as `https://docs.example.com`. */
+    server: string;
+    /** Document id. */
+    id: string;
+    /** A bearer token. The server maps it to the author kind and the role. */
+    token: string;
+    /** The name other people see in presence. Defaults to the author name. */
+    name?: string;
+    /** Reconnect after a drop. Edits made offline merge when the socket returns. */
+    reconnect?: {
+        initialMs?: number;
+        maxMs?: number;
+    };
+    doc?: DocOptions;
+    /** Start an empty room from the stored document. Default true. A merge is safe when the room already holds it. */
+    seed?: boolean;
+}
+/** Who the server says the token is. */
+interface Me {
+    author: Principal;
+    role: "editor" | "viewer";
+}
+declare function whoAmI(server: string, token: string): Promise<Me>;
+/**
+ * One document, open in a live room. The author of every edit is the one the server reads from the
+ * token, so an agent token always writes agent edits. The room keeps the edits, the stored author
+ * label of each update, and the state for the next join.
+ */
+declare class LiveDoc {
+    readonly doc: AgenticDoc;
+    readonly me: Me;
+    private readonly client;
+    private readonly api;
+    private readonly refusedAtStart;
+    private constructor();
+    static join(options: LiveOptions): Promise<LiveDoc>;
+    /** Saves the room's state to the stored document, through the Blobs port. A viewer cannot save. */
+    save(): Promise<void>;
+    /** The other people and agents in the room. `machine` is true for an agent. */
+    get peers(): Peer[];
+    /** Why the room dropped an update, in order. */
+    get denied(): string[];
+    /**
+     * Runs one change as the token's author and waits until the room has it. A viewer fails before the change.
+     * After a refusal from the room the local copy still holds the change. Leave and join again.
+     */
+    edit<T>(run: (doc: AgenticDoc, author: Principal) => T): Promise<T>;
+    /** Waits until the room has every change made so far. */
+    flush(): Promise<void>;
+    leave(): Promise<void>;
+}
+/**
+ * The commands of the CLI and the MCP server, run in a live room. Each call joins the room, runs one
+ * change as the token's author, saves to the stored document, and leaves. A read joins and leaves.
+ */
+declare class LiveService implements DocAccess {
+    private readonly options;
+    constructor(options: Pick<LiveOptions, "server" | "token" | "name" | "doc">);
+    private join;
+    /** The room is only a copy, so a new document is made in the store. A room seeds from it on the next join. */
+    create(id: string, markdown: string): Promise<void>;
+    read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+    write<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+    private exists;
+}
+
+export { LiveDoc, type LiveOptions, LiveService, type Me, whoAmI };

package/dist/live.js

@@ -0,0 +1,12 @@
+import {
+  LiveDoc,
+  LiveService,
+  whoAmI
+} from "./chunk-R5XUTBC3.js";
+import "./chunk-FZA5LQV3.js";
+import "./chunk-YBBQNCMC.js";
+export {
+  LiveDoc,
+  LiveService,
+  whoAmI
+};

package/dist/{mcp-2VZIGHIX.js → mcp-P2C75IIG.js}

@@ -2,9 +2,11 @@ import {
   VERSION
 } from "./chunk-5Y66UCTE.js";
 import {
-  DocError,
   commands
-} from "./chunk-4YVWD5PH.js";
+} from "./chunk-GYQFTF2E.js";
+import {
+  DocError
+} from "./chunk-YBBQNCMC.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/{service-eYISo6-b.d.ts → service-BKkxEnaJ.d.ts}

@@ -138,14 +138,36 @@ interface DocsPorts {
     /** Holds the catalog: who created each document, and when. */
     store: Store;
 }
+/** What every command needs: make a document, read it, and change it. A live room can stand behind it as well as the ports. */
+interface DocAccess {
+    create(id: string, markdown: string, author: Principal): Promise<void>;
+    read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+    write<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+}
 /** Loads and saves documents as Yjs updates in a Blobs port. The CLI, MCP server, and API share it. */
-declare class DocsService {
+declare class DocsService implements DocAccess {
     private readonly options;
     private readonly blobs;
     private readonly store;
     constructor(ports: DocsPorts, options?: DocOptions);
     private key;
     create(id: string, markdown: string, author: Principal): Promise<void>;
+    /** The stored document as a Yjs update. A live client seeds its room from it. */
+    state(id: string): Promise<Uint8Array>;
+    /**
+     * Merge a Yjs update from a live room into the stored document, and create the document when it
+     * has none. A merge is safe to repeat and to run in any order. The save is conditional, so two
+     * checkpoints at once both land.
+     */
+    checkpoint(id: string, update: Uint8Array, author: Principal): Promise<void>;
+    /**
+     * The encoded document, once it reads back and every stored entry has the shape the commands rely on. Yjs does not
+     * check types, so an update can put text where the editor expects blocks, or a thread with no messages, and then a
+     * command fails on every later call.
+     */
+    private checked;
+    private fits;
+    private catalog;
     /** Who created the document and when, or null when it has no catalog entry (made before the catalog, or a failed catalog write). */
     info(id: string): Promise<DocInfo | null>;
     read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
@@ -156,4 +178,4 @@ declare class DocsService {
     write<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
 }
 
-export { type Anchor as A, DocsService as D, type EditEntry as E, type Principal as P, type Section as S, type TextTarget as T, AgenticDoc as a, type AnchorTarget as b, type PmNode as c, type DocInfo as d, type DocOptions as e, type DocsPorts as f, PRINCIPAL_KINDS as g, type PrincipalKind as h, type SectionTarget as i, type Target as j, blocksToMarkdown as k, markdownToBlocks as m, parseAuthor as p };
+export { type Anchor as A, type DocAccess as D, type EditEntry as E, type Principal as P, type Section as S, type TextTarget as T, AgenticDoc as a, type AnchorTarget as b, type PmNode as c, type DocInfo as d, type DocOptions as e, type DocsPorts as f, DocsService as g, PRINCIPAL_KINDS as h, type PrincipalKind as i, type SectionTarget as j, type Target as k, blocksToMarkdown as l, markdownToBlocks as m, parseAuthor as p };

package/dist/worker.d.ts

@@ -1,8 +1,9 @@
 import { Hono } from 'hono';
+import { Region } from 'agentic-identity';
 import { D1Like, R2Like } from 'agentic-identity/cloudflare';
-import { D as DocsService, P as Principal } from './service-eYISo6-b.js';
+import { Realtime, Role } from 'agentic-realtime';
+import { g as DocsService, P as Principal } from './service-BKkxEnaJ.js';
 import 'yjs';
-import 'agentic-identity';
 
 interface WorkerEnv {
     /**
@@ -17,21 +18,33 @@ interface WorkerEnv {
     /** R2 bucket: each document as a Yjs update. Create it with `--jurisdiction eu`. */
     DOCS?: R2Like;
     /**
-     * JSON object: bearer token (32 bytes or more) to `kind:name`, or to `{ "as": "kind:name", "scopes": ["docs:accept"] }`.
+     * JSON object: bearer token (32 bytes or more) to `kind:name`, or to `{ "as": "kind:name", "scopes": ["docs:accept"], "role": "viewer" }`.
+     * A role is `editor` (the default) or `viewer`. A viewer reads and cannot write, over HTTP or in a live room.
      * Set it as a secret. A short token or a bad entry refuses the whole config.
      */
     AGENTIC_DOCS_TOKENS?: string;
 }
+type DocRole = Extract<Role, "editor" | "viewer">;
 /** A service, or a function that makes one from the Worker bindings. */
 type ServiceSource = DocsService | ((env: WorkerEnv) => Promise<DocsService>);
-declare function createApp(source: ServiceSource): Hono<{
+type AppEnv = {
     Bindings: WorkerEnv;
     Variables: {
         author: Principal;
+        role: DocRole;
     };
-}>;
+};
+interface AppOptions {
+    /** Makes the live-room server from the Worker bindings. Without it, the ws route answers 404. */
+    live?: (env: WorkerEnv) => Realtime;
+}
+declare function createApp(source: ServiceSource, options?: AppOptions): Hono<AppEnv>;
+/** The region claim, or a MISCONFIGURED error. The HTTP API and the live rooms both use it, so neither runs without it. */
+declare function regionOf(env: WorkerEnv): Region;
+/** The service over D1 and R2. One region claim covers D1 and R2. The bucket is declared with the "eu" jurisdiction in wrangler.jsonc: keep the two in step. */
+declare function serviceFor(env: WorkerEnv): Promise<DocsService>;
 declare const _default: {
     fetch: (request: Request, env: WorkerEnv, ctx: unknown) => Response | Promise<Response>;
 };
 
-export { type ServiceSource, type WorkerEnv, createApp, _default as default };
+export { type AppOptions, type DocRole, type ServiceSource, type WorkerEnv, createApp, _default as default, regionOf, serviceFor };

package/dist/worker.js

@@ -1,162 +1,15 @@
 import {
-  DocsService
-} from "./chunk-LRPLNXOF.js";
-import {
-  DocError,
-  PRINCIPAL_KINDS,
-  commands,
-  parseAuthor
-} from "./chunk-4YVWD5PH.js";
-
-// src/worker.ts
-import { Hono } from "hono";
-import { assertRegion, parseRegion } from "agentic-identity";
-import { D1_SCHEMA, createD1Store, createR2Blobs } from "agentic-identity/cloudflare";
-var STATUS = {
-  NO_MATCH: 404,
-  NO_SECTION: 404,
-  NO_THREAD: 404,
-  NO_SUGGESTION: 404,
-  NO_DOCUMENT: 404,
-  AMBIGUOUS_MATCH: 409,
-  STALE_ANCHOR: 409,
-  ALREADY_DECIDED: 409,
-  DOCUMENT_EXISTS: 409,
-  CONFLICT: 409,
-  FORBIDDEN: 403,
-  LOCKED: 503,
-  MISCONFIGURED: 500
-};
-function same(a, b) {
-  let diff = a.length ^ b.length;
-  for (let i = 0; i < Math.max(a.length, b.length); i++) diff |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
-  return diff === 0;
-}
-var MIN_TOKEN_BYTES = 32;
-var warned = /* @__PURE__ */ new Set();
-function refuse(reason) {
-  if (!warned.has(reason)) {
-    warned.add(reason);
-    console.error(`AGENTIC_DOCS_TOKENS is refused: ${reason}`);
-  }
-  return void 0;
-}
-function principalOf(entry) {
-  const object = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? entry : void 0;
-  const who = typeof entry === "string" ? entry : object?.as;
-  const author = typeof who === "string" ? parseAuthor(who) : void 0;
-  if (!author || !PRINCIPAL_KINDS.includes(author.kind) || !author.name) return void 0;
-  if (object?.scopes === void 0) return author;
-  const scopes = object.scopes;
-  return Array.isArray(scopes) && scopes.every((s) => typeof s === "string" && s !== "") ? { ...author, scopes } : void 0;
-}
-function readTokens(raw) {
-  let table;
-  try {
-    table = JSON.parse(raw ?? "{}");
-  } catch {
-    return refuse("not valid JSON");
-  }
-  if (typeof table !== "object" || table === null || Array.isArray(table)) return refuse("not a JSON object");
-  const found = /* @__PURE__ */ new Map();
-  for (const [token, entry] of Object.entries(table)) {
-    if (new TextEncoder().encode(token).length < MIN_TOKEN_BYTES) return refuse(`a token is shorter than ${MIN_TOKEN_BYTES} bytes`);
-    const principal = principalOf(entry);
-    if (!principal) return refuse("an entry is not a valid kind:name or { as, scopes }");
-    found.set(token, principal);
-  }
-  return found;
-}
-function principalFor(tokens, bearer) {
-  let found;
-  for (const [token, principal] of readTokens(tokens) ?? []) if (same(token, bearer)) found = principal;
-  return found;
-}
-var fail = (code, message, status, matches = []) => Response.json({ error: { code, message, matches } }, { status });
-function createApp(source) {
-  const app2 = new Hono();
-  app2.use("*", async (c, next) => {
-    await next();
-    c.header("x-content-type-options", "nosniff");
-  });
-  app2.get("/health", (c) => c.json({ ok: true, pack: "agentic-documents" }));
-  app2.use("/api/v1/*", async (c, next) => {
-    const bearer = /^Bearer (.+)$/.exec(c.req.header("authorization") ?? "")?.[1];
-    const author = bearer === void 0 ? void 0 : principalFor(c.env?.AGENTIC_DOCS_TOKENS, bearer);
-    if (!author) return fail("UNAUTHENTICATED", "send a valid bearer token", 401);
-    c.set("author", author);
-    await next();
-  });
-  async function run(c, command, input) {
-    try {
-      const result = await command.run(await (typeof source === "function" ? source(c.env ?? {}) : source), input, c.get("author"));
-      if (command.name === "export") {
-        const { data, contentType, encoding, format } = result;
-        const images = input.remoteImages === true || input.remoteImages === "true" ? "data: https:" : "data:";
-        const disposition = format === "odt" ? { "content-disposition": `attachment; filename="${input.id}.odt"` } : {};
-        const headers = { ...disposition, "content-type": contentType, "content-security-policy": `default-src 'none'; style-src 'unsafe-inline'; img-src ${images}; sandbox` };
-        return encoding === "base64" ? c.body(Uint8Array.from(atob(data), (ch) => ch.charCodeAt(0)), 200, headers) : c.body(data, 200, headers);
-      }
-      if (typeof result === "string") return c.body(result, 200, { "content-type": "text/markdown; charset=utf-8" });
-      return c.json(result);
-    } catch (error) {
-      if (!(error instanceof DocError)) throw error;
-      return fail(error.code, error.message, STATUS[error.code] ?? 400, error.matches);
-    }
-  }
-  async function body(c) {
-    const parsed = await c.req.json().catch(() => void 0);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new DocError("INVALID_INPUT", "the body must be a JSON object");
-    }
-    return parsed;
-  }
-  const create = commands.find((c) => c.name === "new");
-  app2.post("/api/v1/docs", async (c) => run(c, create, await body(c)));
-  for (const command of commands.filter((c) => c !== create)) {
-    const path = `/api/v1/docs/:id/${command.name}`;
-    if (command.readOnly) app2.get(path, (c) => run(c, command, { ...c.req.query(), id: c.req.param("id") }));
-    else app2.post(path, async (c) => run(c, command, { ...await body(c), id: c.req.param("id") }));
-  }
-  app2.notFound(() => fail("NOT_FOUND", "no such route", 404));
-  app2.onError((error) => {
-    if (error instanceof DocError) return fail(error.code, error.message, STATUS[error.code] ?? 400, error.matches);
-    console.error(error instanceof Error ? error.name : "error");
-    return fail("INTERNAL", "the server could not finish the request", 500);
-  });
-  return app2;
-}
-var schemas = /* @__PURE__ */ new WeakMap();
-var urlSecret;
-async function serviceFor(env) {
-  if (!env.DB || !env.DOCS) throw new DocError("MISCONFIGURED", "bind a D1 database as DB and an R2 bucket as DOCS");
-  let region;
-  try {
-    region = parseRegion(env.AGENTIC_DOCS_REGION);
-  } catch {
-    throw new DocError("MISCONFIGURED", 'set AGENTIC_DOCS_REGION to "eu" or "us" ("unknown" only for local development)');
-  }
-  if (region === "unknown" && env.AGENTIC_DOCS_UNSAFE_REGION !== "1") {
-    throw new DocError("MISCONFIGURED", 'the region "unknown" turns the residency check off; set AGENTIC_DOCS_UNSAFE_REGION=1 to accept that for local development');
-  }
-  const db = env.DB;
-  let ready = schemas.get(db);
-  if (!ready) {
-    ready = db.prepare(D1_SCHEMA).run().catch((error) => {
-      schemas.delete(db);
-      throw error;
-    });
-    schemas.set(db, ready);
-  }
-  await ready;
-  const store = createD1Store(db, { region });
-  const blobs = createR2Blobs(env.DOCS, { region, urlBase: "https://invalid.example/unused", urlSecret: urlSecret ??= `${crypto.randomUUID()}${crypto.randomUUID()}` });
-  assertRegion(region, store, blobs);
-  return new DocsService({ store, blobs });
-}
-var app = createApp(serviceFor);
-var worker_default = { fetch: (request, env, ctx) => app.fetch(request, env, ctx) };
+  createApp,
+  regionOf,
+  serviceFor,
+  worker_default
+} from "./chunk-IU3YIQ4Y.js";
+import "./chunk-FZA5LQV3.js";
+import "./chunk-GYQFTF2E.js";
+import "./chunk-YBBQNCMC.js";
 export {
   createApp,
-  worker_default as default
+  worker_default as default,
+  regionOf,
+  serviceFor
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-documents",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Write documents with people and agents in real time.",
   "keywords": [
     "documents",
@@ -32,6 +32,7 @@
     "dist",
     "SECURITY.md",
     "SKILL.md",
+    "CHANGELOG.md",
     "llms.txt"
   ],
   "publishConfig": {
@@ -48,10 +49,19 @@
     "./worker": {
       "types": "./dist/worker.d.ts",
       "import": "./dist/worker.js"
+    },
+    "./live": {
+      "types": "./dist/live.d.ts",
+      "import": "./dist/live.js"
+    },
+    "./live-worker": {
+      "types": "./dist/live-worker.d.ts",
+      "import": "./dist/live-worker.js"
     }
   },
   "scripts": {
     "build": "tsup",
+    "prepack": "npm run build",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "clean": "rm -rf dist",
@@ -59,7 +69,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "agentic-identity": "^0.2.0",
+    "agentic-identity": "^0.4.0",
+    "agentic-realtime": "^0.1.0",
     "fflate": "^0.8.3",
     "hono": "^4.13.14",
     "lib0": "^0.2.119",