agentic-documents 0.5.0 → 0.6.0

package/dist/cli.js

@@ -1,27 +1,28 @@
 #!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-5Y66UCTE.js";
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-7R7ZPPRF.js";
+} from "./chunk-34C47PDC.js";
 import {
   LiveService,
   whoAmI
-} from "./chunk-E7B6T5WN.js";
-import {
-  DocsService
-} from "./chunk-YNHZCIGO.js";
-import {
-  VERSION
-} from "./chunk-5Y66UCTE.js";
+} from "./chunk-CN6UAW7B.js";
 import {
   commands
-} from "./chunk-S6MQDWFK.js";
-import "./chunk-L6W2AQUF.js";
-import "./chunk-UPEGODUV.js";
+} from "./chunk-6UYJV2EJ.js";
+import {
+  DocsService
+} from "./chunk-JBAQEIOH.js";
+import "./chunk-5IQX2W52.js";
+import "./chunk-KC5KFB5R.js";
 import {
   DocError,
   parseAuthor
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-GQ5E6T7Z.js";
+import "./chunk-DWVJIKVT.js";
 
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -120,7 +121,7 @@ async function main(argv, env = process.env) {
     author = named && scopes?.length ? { ...named, scopes } : named;
   }
   if (name === "mcp") {
-    const { startMcp } = await import("./mcp-ESSEG46C.js");
+    const { startMcp } = await import("./mcp-ZTUTC4CS.js");
     await startMcp(service, author);
     return 0;
   }
@@ -140,7 +141,8 @@ async function main(argv, env = process.env) {
     }
     const result = await command.run(service, input, author);
     if (name === "export") {
-      const { data, encoding } = result;
+      const { data, encoding, warnings } = result;
+      for (const line of warnings) console.error(`warning: ${line}`);
       const bytes = encoding === "base64" ? Buffer.from(data, "base64") : data;
       if (out === void 0) process.stdout.write(bytes);
       else writeFileSync(out, bytes);

package/dist/client.d.ts

@@ -1,8 +1,8 @@
-import { P as PrincipalKind, S as Section, E as EditEntry } from './doc-mJPajXEQ.js';
-export { A as Anchor } from './doc-mJPajXEQ.js';
-import { E as ExportFormat } from './export-Cwx276UP.js';
-import { D as DocErrorCode, S as Suggestion, T as Thread } from './review-Hgq8OgvD.js';
-import { D as DocSummary } from './service-CqKE9DKz.js';
+import { e as PrincipalKind, S as Section, E as EditEntry } from './doc-BXG9qG5X.js';
+export { a as Anchor } from './doc-BXG9qG5X.js';
+import { E as ExportFormat } from './render-463xHb-x.js';
+import { a as DocErrorCode, S as Suggestion, T as Thread } from './review-Ds-i5Vnc.js';
+import { d as DocSummary } from './service-Ck6oX-Kq.js';
 import 'yjs';
 import 'agentic-identity';
 

package/dist/{doc-mJPajXEQ.d.ts → doc-BXG9qG5X.d.ts}

@@ -18,6 +18,7 @@ declare function blocksToMarkdown(nodes: PmNode[]): string;
 
 declare const PRINCIPAL_KINDS: readonly ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
 type PrincipalKind = (typeof PRINCIPAL_KINDS)[number];
+
 /** Who made a change. Every mutation needs one, so machine-made work stays labeled. */
 interface Principal {
     kind: PrincipalKind;
@@ -51,7 +52,8 @@ interface Section {
     title: string;
 }
 interface EditEntry {
-    op: "create" | "append" | "insert" | "replace" | "delete";
+    /** `live` ties the editor client of an agent to that agent, so the text the client types is marked as its work. Its counts stay 0. */
+    op: "create" | "append" | "insert" | "replace" | "delete" | "live";
     at: string;
     author: Principal;
     /** Counts of characters (text targets) or blocks (section targets). Never content. */
@@ -127,4 +129,4 @@ declare class AgenticDoc {
     append(markdown: string, author: Principal): void;
 }
 
-export { type Anchor as A, type DocOptions as D, type EditEntry as E, type PrincipalKind as P, type Section as S, type Target as T, AgenticDoc as a, type PmNode as b, type Principal as c, type AnchorTarget as d, PRINCIPAL_KINDS as e, type SectionTarget as f, type TextTarget as g, blocksToMarkdown as h, markdownToBlocks as m, parseAuthor as p };
+export { AgenticDoc as A, type DocOptions as D, type EditEntry as E, type Principal as P, type Section as S, type Target as T, type Anchor as a, type AnchorTarget as b, PRINCIPAL_KINDS as c, type PmNode as d, type PrincipalKind as e, type SectionTarget as f, type TextTarget as g, blocksToMarkdown as h, markdownToBlocks as m, parseAuthor as p };

package/dist/editor.css

@@ -0,0 +1,37 @@
+/* The editor that `agentic-documents/ui` renders. Every rule sits under `.adoc`, so it does not touch the page around it.
+   Color, type, and space come from the agentic-design tokens: load `agentic-design/styles.css` first. */
+.adoc.muted, .adoc .muted { color: var(--ad-color-text-muted); font-size: var(--ad-font-size-sm); margin: 0; }
+.adoc.notice, .adoc .notice { max-width: var(--ad-size-content); }
+.adoc.form { display: grid; gap: var(--ad-space-4); }
+.adoc.form .form-actions { display: flex; gap: var(--ad-space-2); align-items: center; justify-content: flex-end; flex-wrap: wrap; }
+.adoc .editor-bar { display: flex; align-items: center; justify-content: space-between; gap: var(--ad-space-4); flex-wrap: wrap; max-width: var(--ad-size-content); margin-block-end: var(--ad-space-3); }
+.adoc .editor-meta { display: flex; align-items: center; gap: var(--ad-space-4); flex-wrap: wrap; }
+.adoc .glyph { font-weight: var(--ad-font-weight-semibold); min-width: 1.25rem; text-align: center; }
+.adoc .glyph--b { font-weight: 800; }
+.adoc .glyph--i { font-style: italic; font-family: serif; }
+.adoc .editor-host { max-width: var(--ad-size-content); background: var(--ad-color-surface); border: 1px solid var(--ad-color-border); border-radius: var(--ad-radius-md); }
+.adoc .editor-host:focus-within { outline: 2px solid var(--ad-color-focus); outline-offset: 2px; }
+.adoc .prose { min-height: 20rem; padding: var(--ad-space-6); outline: none; line-height: var(--ad-line-height-normal); overflow-wrap: anywhere; }
+.adoc .prose > :first-child { margin-top: 0; }
+.adoc .prose h1 { font-size: var(--ad-font-size-2xl); line-height: var(--ad-line-height-tight); }
+.adoc .prose h2 { font-size: var(--ad-font-size-xl); line-height: var(--ad-line-height-tight); }
+.adoc .prose h3 { font-size: var(--ad-font-size-lg); }
+.adoc .prose a { color: var(--ad-color-accent-text); text-decoration: underline; }
+.adoc .prose blockquote { margin-inline: 0; padding-inline-start: var(--ad-space-4); border-inline-start: 3px solid var(--ad-color-border-strong); }
+.adoc .prose code { font-family: var(--ad-font-family-mono); background: var(--ad-color-surface-sunken); padding: 0 0.25em; border-radius: var(--ad-radius-sm); }
+.adoc .prose pre { background: var(--ad-color-surface-sunken); padding: var(--ad-space-3); border-radius: var(--ad-radius-md); overflow-x: auto; }
+.adoc .prose table { border-collapse: collapse; }
+.adoc .prose th, .adoc .prose td { border: 1px solid var(--ad-color-border-strong); padding: var(--ad-space-1) var(--ad-space-2); }
+.adoc .prose img { max-width: 100%; }
+.adoc .prose ul[data-type="taskList"] { list-style: none; padding-inline-start: var(--ad-space-2); }
+.adoc .prose ul[data-type="taskList"] li { display: flex; gap: var(--ad-space-2); }
+
+/* Text an agent wrote: a dotted underline in the agent color and a tint. The legend and the title say it in words. */
+.adoc .agent-text { text-decoration: underline dotted 2px var(--ad-color-agent); text-underline-offset: 3px; background: var(--ad-color-agent-subtle); border-radius: 2px; }
+.adoc .legend { margin-block-start: var(--ad-space-3); }
+
+/* The caret of another person or agent. */
+.adoc .caret { position: relative; border-inline-start: 2px solid var(--ad-color-accent); margin-inline: -1px; pointer-events: none; word-break: normal; }
+.adoc .caret--agent { border-inline-start: 2px dashed var(--ad-color-agent); }
+.adoc .caret__tag { position: absolute; top: -1.45em; inset-inline-start: -2px; white-space: nowrap; font-size: var(--ad-font-size-xs); line-height: 1.3; padding: 0 var(--ad-space-1); border-radius: var(--ad-radius-sm) var(--ad-radius-sm) var(--ad-radius-sm) 0; background: var(--ad-color-accent); color: var(--ad-color-text-on-accent); user-select: none; }
+.adoc .caret--agent .caret__tag { background: var(--ad-color-surface); color: var(--ad-color-agent-text); border: 1px solid var(--ad-color-agent); border-radius: 0; }

package/dist/embed.d.ts

@@ -0,0 +1,86 @@
+import * as react from 'react';
+import { e as PrincipalKind } from './doc-BXG9qG5X.js';
+import { SyncClient, Status } from 'agentic-realtime/client';
+import * as Y from 'yjs';
+import { DocsClient } from './client.js';
+import './render-463xHb-x.js';
+import './review-Ds-i5Vnc.js';
+import './service-Ck6oX-Kq.js';
+import 'agentic-identity';
+
+/** The calls the editor makes. A `DocsClient` from `agentic-documents/client` has them. */
+type EditorClient = Pick<DocsClient, "state" | "checkpoint">;
+/** A live room of agentic-realtime for one document. */
+interface EditorRoom {
+    /** The WebSocket address of the room, such as `wss://docs.example.com/api/v1/docs/plan/ws`. */
+    url: string;
+    /** A bearer token for the room. In a browser it goes in a WebSocket subprotocol. */
+    token?: string;
+    /** Your own WebSocket class, for a room that takes its token another way. */
+    WebSocket?: new (url: string, options?: {
+        headers?: Record<string, string>;
+    }) => WebSocket;
+}
+interface LiveSession {
+    /** The room, or undefined when the document is open without one. */
+    sync?: SyncClient;
+    doc: Y.Doc;
+    /** The socket state now, and a way to hear when it changes. */
+    status: () => Status;
+    onStatus: (listener: (status: Status) => void) => () => void;
+    /** True when this tab changed the text since the last save that worked. */
+    readonly dirty: boolean;
+    /** Call it when this tab changes the text. */
+    touch(): void;
+    /** Merge the room into the stored document. It never makes a document: a removed one fails with NO_DOCUMENT. */
+    save(): Promise<void>;
+    close(): Promise<void>;
+}
+
+/** Who uses the editor. The server still checks every write against its own token. */
+interface EmbedPrincipal {
+    kind: PrincipalKind;
+    name: string;
+    /** Only `editor` can change the text. Any other value, or no value, opens it read only. */
+    role?: "editor" | "viewer";
+}
+interface DocumentEditorOptions {
+    /** The document id. */
+    id: string;
+    /** Loads and saves the document. A client from `createClient` in `agentic-documents/client` works. */
+    client: EditorClient;
+    principal: EmbedPrincipal;
+    /** The live room. With one, people and agents edit together and see each other. Without one, the editor saves alone. */
+    room?: EditorRoom;
+    /** Called when the document cannot open, with the error. */
+    onError?: (error: unknown) => void;
+    /** Called when the editor closes a document, with a promise that settles when the last save and the leave are done. It rejects when that save fails. */
+    onLeave?: (done: Promise<void>) => void;
+}
+type SessionState = {
+    state: "loading";
+} | {
+    state: "error";
+    error: unknown;
+} | {
+    state: "ready";
+    live: LiveSession;
+};
+/**
+ * Open a document for an editor, and close it when the component goes. On leave it saves first, but only when this tab
+ * changed something and may write. A save never makes a document, so a removed document stays removed. `onLeave` gets a
+ * promise that settles when the leave is done. It rejects when the save fails. With no `onLeave`, a failure is dropped.
+ */
+declare function useEditorSession(client: EditorClient, id: string, name: string, editable: boolean, room: EditorRoom | undefined, attempt: number, onLeave?: (done: Promise<void>) => void): SessionState;
+/** The editor for one document, with its toolbar, presence, and save state. */
+declare function DocumentEditor({ id, client, principal, room, onError, onLeave }: DocumentEditorOptions): react.JSX.Element;
+interface MountedEditor {
+    /** Show another document, principal, or room in the same place. A bad principal throws and keeps the editor as it is. */
+    update(options: DocumentEditorOptions): void;
+    /** Remove the editor. It saves this tab's changes, then leaves the room. The promise rejects when that save fails. */
+    unmount(): Promise<void>;
+}
+/** Render the editor into an element, for an app that does not use React itself. */
+declare function mountEditor(element: HTMLElement, options: DocumentEditorOptions): MountedEditor;
+
+export { DocumentEditor, type DocumentEditorOptions, type EditorClient, type EditorRoom, type EmbedPrincipal, type LiveSession, type MountedEditor, type SessionState, mountEditor, useEditorSession };

package/dist/embed.js

@@ -0,0 +1,431 @@
+import {
+  PRINCIPAL_KINDS,
+  isMachine
+} from "./chunk-DWVJIKVT.js";
+
+// ui/embed.tsx
+import { Button as Button2, EmptyState as EmptyState2 } from "agentic-design/react";
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { createRoot } from "react-dom/client";
+
+// ui/live.ts
+import { SyncClient } from "agentic-realtime/client";
+import * as Y from "yjs";
+var base64url = (text) => btoa(String.fromCharCode(...new TextEncoder().encode(text))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var TokenSocket = class extends WebSocket {
+  constructor(url, options) {
+    const token = /^Bearer (.+)$/.exec(options?.headers?.authorization ?? "")?.[1];
+    super(url, token ? ["agentic-docs", `agentic-docs.bearer.${base64url(token)}`] : void 0);
+  }
+};
+async function openSession(client, id, name, room) {
+  let status = room ? "connecting" : "connected";
+  const listeners = /* @__PURE__ */ new Set();
+  const doc = new Y.Doc();
+  Y.applyUpdate(doc, await client.state(id));
+  const sync = room ? await SyncClient.connect({
+    url: room.url,
+    headers: room.token ? { authorization: `Bearer ${room.token}` } : void 0,
+    WebSocket: room.WebSocket ?? TokenSocket,
+    doc,
+    presence: { name },
+    reconnect: {},
+    onStatus: (next) => {
+      status = next;
+      for (const listener of listeners) listener(next);
+    }
+  }) : void 0;
+  await sync?.whenSynced().catch(() => void 0);
+  let changes = 0;
+  let saved = 0;
+  const session = {
+    sync,
+    doc,
+    status: () => status,
+    onStatus: (listener) => (listeners.add(listener), () => void listeners.delete(listener)),
+    get dirty() {
+      return changes !== saved;
+    },
+    touch: () => void changes++,
+    async save() {
+      const mark = changes;
+      await sync?.flush();
+      await client.checkpoint(id, Y.encodeStateAsUpdate(doc), { create: false });
+      saved = mark;
+    },
+    close: async () => await sync?.disconnect()
+  };
+  return session;
+}
+
+// ui/editor.tsx
+import { Editor, Extension as Extension2 } from "@tiptap/core";
+import Collaboration from "@tiptap/extension-collaboration";
+import Image from "@tiptap/extension-image";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
+import StarterKit from "@tiptap/starter-kit";
+import { ySyncPluginKey as ySyncPluginKey2, yCursorPlugin } from "@tiptap/y-tiptap";
+import { Component, useEffect, useReducer, useRef, useState } from "react";
+import { Button, Dialog, DialogClose, EmptyState, Input, PresenceStack, Toolbar, ToolbarButton, ToolbarSeparator, usableName } from "agentic-design/react";
+
+// ui/marks.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { relativePositionToAbsolutePosition, ySyncPluginKey } from "@tiptap/y-tiptap";
+import * as Y2 from "yjs";
+function agentRuns(doc) {
+  const agents = /* @__PURE__ */ new Set();
+  for (const entry of doc.getArray("edits").toArray()) {
+    if (typeof entry !== "object" || entry === null) continue;
+    if (typeof entry.client === "number" && entry.author?.kind !== void 0 && entry.author.kind !== "human") agents.add(entry.client);
+  }
+  const runs = [];
+  if (agents.size === 0) return runs;
+  const walk = (node) => {
+    for (const child of node.toArray()) {
+      if (child instanceof Y2.XmlElement) walk(child);
+      else if (child instanceof Y2.XmlText) {
+        let index = 0;
+        for (let item = child._start; item; item = item.right) {
+          if (item.deleted || !item.countable) continue;
+          if (agents.has(item.id.client)) runs.push({ text: child, from: index, to: index + item.length });
+          index += item.length;
+        }
+      }
+    }
+  };
+  walk(doc.getXmlFragment("default"));
+  return runs;
+}
+var key = new PluginKey("agentText");
+var AgentText = Extension.create({
+  name: "agentText",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key,
+        state: {
+          init: () => DecorationSet.empty,
+          apply: (tr, old) => tr.getMeta(key) ?? old.map(tr.mapping, tr.doc)
+        },
+        props: { decorations: (state) => key.getState(state) },
+        view(view) {
+          const sync = ySyncPluginKey.getState(view.state);
+          if (!sync) return {};
+          let timer;
+          let drawn = "";
+          const refresh = () => {
+            timer = void 0;
+            try {
+              const mapping = ySyncPluginKey.getState(view.state).binding?.mapping;
+              if (!mapping) return;
+              const size = view.state.doc.content.size;
+              const marks = [];
+              for (const { text, from, to } of agentRuns(sync.doc)) {
+                const a = relativePositionToAbsolutePosition(sync.doc, sync.type, Y2.createRelativePositionFromTypeIndex(text, from), mapping);
+                const b = relativePositionToAbsolutePosition(sync.doc, sync.type, Y2.createRelativePositionFromTypeIndex(text, to), mapping);
+                if (a !== null && b !== null && a < b && b <= size) marks.push(Decoration.inline(a, b, { class: "agent-text", title: "Written by an agent" }));
+              }
+              const signature = marks.map((m) => `${m.from}-${m.to}`).join(",");
+              if (signature === drawn) return;
+              drawn = signature;
+              view.dispatch(view.state.tr.setMeta(key, DecorationSet.create(view.state.doc, marks)).setMeta("addToHistory", false));
+            } catch {
+            }
+          };
+          const schedule = () => {
+            timer ??= setTimeout(refresh, 60);
+          };
+          sync.doc.on("update", schedule);
+          schedule();
+          return {
+            destroy() {
+              sync.doc.off("update", schedule);
+              if (timer) clearTimeout(timer);
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+
+// ui/editor.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SAVE_AFTER_MS = 1500;
+var entryOf = (peer) => ({ id: String(peer.clientId), name: usableName(peer.name) ?? "Unnamed", kind: peer.machine ? "agent" : "person" });
+var isRemoved = (error) => typeof error === "object" && error !== null && error.code === "NO_DOCUMENT";
+function carets(sync) {
+  return Extension2.create({
+    name: "remoteCarets",
+    addProseMirrorPlugins: () => [
+      yCursorPlugin(sync.awareness, {
+        cursorBuilder: (_user, clientId) => {
+          const caret = document.createElement("span");
+          const peer = sync.peers.find((p) => p.clientId === clientId);
+          if (!peer) return caret;
+          caret.className = `caret${peer.machine ? " caret--agent" : ""}`;
+          const tag = document.createElement("span");
+          tag.className = "caret__tag";
+          tag.textContent = `${usableName(peer.name) ?? "Unnamed"}${peer.machine ? " \xB7 Agent" : ""}`;
+          caret.append(tag);
+          return caret;
+        },
+        selectionBuilder: () => ({})
+      })
+    ]
+  });
+}
+var Boundary = class extends Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  render() {
+    return this.state.failed ? /* @__PURE__ */ jsx("div", { role: "alert", className: "adoc notice", children: /* @__PURE__ */ jsx(EmptyState, { title: "The editor stopped", description: "The document has content this page cannot show. Reload to try again." }) }) : this.props.children;
+  }
+};
+function Surface({ live, editable, principal: me }) {
+  const host = useRef(null);
+  const [editor, setEditor] = useState();
+  const [, refresh] = useReducer((n) => n + 1, 0);
+  const [peers, setPeers] = useState([]);
+  const [saved, setSaved] = useState("saved");
+  const [connection, setConnection] = useState("connecting");
+  const [agentText, setAgentText] = useState(false);
+  const [linking, setLinking] = useState(false);
+  const [href, setHref] = useState("");
+  const [linkError, setLinkError] = useState();
+  const refocus = useRef(false);
+  useEffect(() => {
+    const editor2 = new Editor({
+      element: host.current,
+      editable,
+      extensions: [
+        StarterKit.configure({ undoRedo: false, underline: false, link: { openOnClick: false, autolink: true, defaultProtocol: "https", isAllowedUri: (url) => /^(https?:\/\/|mailto:)\S+$/i.test(url) } }),
+        Image,
+        TaskList,
+        TaskItem,
+        Table,
+        TableRow,
+        TableCell,
+        TableHeader,
+        Collaboration.configure({ document: live.doc, field: "default" }),
+        ...live.sync ? [carets(live.sync)] : [],
+        AgentText
+      ],
+      editorProps: { attributes: { role: "textbox", "aria-multiline": "true", "aria-label": "Document text", class: "prose" } }
+    });
+    setEditor(editor2);
+    editor2.on("transaction", () => (setAgentText(host.current?.querySelector(".agent-text") != null), refresh()));
+    const offPeers = live.sync?.onPeers(setPeers);
+    setPeers(live.sync?.peers ?? []);
+    let timer;
+    let stopped = false;
+    let gone = false;
+    const save = () => {
+      timer = void 0;
+      setSaved("saving");
+      live.save().then(
+        () => !stopped && setSaved("saved"),
+        (error) => {
+          if (stopped) return;
+          if (isRemoved(error)) {
+            gone = true;
+            editor2.setEditable(false);
+            return setSaved("removed");
+          }
+          setSaved("failed");
+          timer = setTimeout(save, 5e3);
+        }
+      );
+    };
+    let labeled = false;
+    const changed = (_update, origin) => {
+      if (editable && !gone && origin === ySyncPluginKey2) {
+        if (!labeled && isMachine(me.kind)) {
+          labeled = true;
+          live.doc.getArray("edits").push([{ op: "live", at: (/* @__PURE__ */ new Date()).toISOString(), author: { kind: me.kind, name: me.name }, client: live.doc.clientID, inserted: 0, deleted: 0 }]);
+        }
+        live.touch();
+        setSaved("saving");
+        clearTimeout(timer);
+        timer = setTimeout(save, SAVE_AFTER_MS);
+      }
+    };
+    live.doc.on("update", changed);
+    setConnection(live.status());
+    const offStatus = live.onStatus(setConnection);
+    return () => {
+      stopped = true;
+      live.doc.off("update", changed);
+      offStatus();
+      if (timer) clearTimeout(timer);
+      offPeers?.();
+      editor2.destroy();
+    };
+  }, [live, editable, me.name, me.kind]);
+  const entries = [{ id: "me", name: me.name, kind: isMachine(me.kind) ? "agent" : "person" }, ...peers.map(entryOf)];
+  const pressed = (name, attrs) => editor?.isActive(name, attrs) ?? false;
+  const chain = () => (editor.view.focus(), editor.chain().focus());
+  const glyph = (text, style) => /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: `glyph glyph--${style ?? "plain"}`, children: text });
+  const listIcon = (numbered) => /* @__PURE__ */ jsxs("svg", { "aria-hidden": "true", focusable: "false", viewBox: "0 0 20 20", width: "1.25em", height: "1.25em", fill: "none", stroke: "currentColor", strokeWidth: "1.6", strokeLinecap: "round", children: [
+    /* @__PURE__ */ jsx("path", { d: "M8 5h9M8 10h9M8 15h9" }),
+    numbered ? /* @__PURE__ */ jsx("path", { d: "M3 4.5l1-.5v4M3 11.5h2l-2 2.5h2.2", strokeLinejoin: "round" }) : /* @__PURE__ */ jsx("path", { d: "M3.5 5h.01M3.5 10h.01M3.5 15h.01", strokeWidth: "2.6" })
+  ] });
+  const tool = (label, icon, active, run) => /* @__PURE__ */ jsx(ToolbarButton, { label, icon, pressed: active, onClick: run, disabled: !editable });
+  function openLink() {
+    setHref(editor?.getAttributes("link").href ?? "");
+    setLinkError(void 0);
+    setLinking(true);
+  }
+  function applyLink() {
+    const value = href.trim();
+    if (value === "") chain().extendMarkRange("link").unsetLink().run();
+    else if (!/^(https?:\/\/|mailto:)\S+$/i.test(value)) return setLinkError("Use a web address that starts with https:// or http://, or a mailto: address.");
+    else chain().extendMarkRange("link").setLink({ href: value }).run();
+    if (editor && !editor.state.selection.empty) editor.chain().setTextSelection(editor.state.selection.to).unsetMark("link").run();
+    refocus.current = true;
+    setLinking(false);
+  }
+  useEffect(() => {
+    if (linking || !refocus.current) return;
+    refocus.current = false;
+    let tries = 0;
+    const timer = setInterval(() => {
+      if (editor?.isFocused || ++tries > 10) return clearInterval(timer);
+      editor?.view.focus();
+    }, 40);
+    return () => clearInterval(timer);
+  }, [linking, editor]);
+  return /* @__PURE__ */ jsxs("section", { "aria-label": "Editor", className: "adoc", children: [
+    /* @__PURE__ */ jsxs("div", { className: "editor-bar", children: [
+      /* @__PURE__ */ jsxs(Toolbar, { label: "Formatting", children: [
+        tool("Bold", glyph("B", "b"), pressed("bold"), () => chain().toggleBold().run()),
+        tool("Italic", glyph("I", "i"), pressed("italic"), () => chain().toggleItalic().run()),
+        /* @__PURE__ */ jsx(ToolbarSeparator, {}),
+        tool("H1 heading", glyph("H1"), pressed("heading", { level: 1 }), () => chain().toggleHeading({ level: 1 }).run()),
+        tool("H2 heading", glyph("H2"), pressed("heading", { level: 2 }), () => chain().toggleHeading({ level: 2 }).run()),
+        /* @__PURE__ */ jsx(ToolbarSeparator, {}),
+        tool("Bulleted list", listIcon(false), pressed("bulletList"), () => chain().toggleBulletList().run()),
+        tool("Numbered list", listIcon(true), pressed("orderedList"), () => chain().toggleOrderedList().run()),
+        /* @__PURE__ */ jsx(ToolbarSeparator, {}),
+        tool("Link", glyph("\u2197"), pressed("link"), openLink)
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "editor-meta", children: [
+        /* @__PURE__ */ jsx(PresenceStack, { entries, label: "People and agents here" }),
+        /* @__PURE__ */ jsxs("span", { role: "status", className: "muted", children: [
+          !editable ? "Read only. " : "",
+          connection === "disconnected" ? "Offline: changes are kept and sync when you are back. " : "",
+          saved === "saving" ? "Saving\u2026" : saved === "failed" ? "Not saved. Will try again." : saved === "removed" ? "This document was removed. Your changes are not saved." : "Saved"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { ref: host, className: "editor-host" }),
+    /* @__PURE__ */ jsx("p", { className: "muted legend", children: agentText ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { className: "agent-text", children: "Dotted text" }),
+      " was written by an agent."
+    ] }) : "Text that an agent writes shows with a dotted underline." }),
+    /* @__PURE__ */ jsx(Dialog, { open: linking, onOpenChange: setLinking, title: "Link", description: "Leave it empty to remove the link.", children: /* @__PURE__ */ jsxs("form", { className: "adoc form", onSubmit: (e) => (e.preventDefault(), applyLink()), children: [
+      /* @__PURE__ */ jsx(Input, { label: "Address", value: href, onChange: (e) => setHref(e.target.value), error: linkError, placeholder: "https://", autoComplete: "off" }),
+      /* @__PURE__ */ jsxs("div", { className: "form-actions", children: [
+        /* @__PURE__ */ jsx(DialogClose, { asChild: true, children: /* @__PURE__ */ jsx(Button, { type: "button", variant: "secondary", children: "Cancel" }) }),
+        /* @__PURE__ */ jsx(Button, { type: "submit", children: "Apply" })
+      ] })
+    ] }) })
+  ] });
+}
+
+// ui/embed.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function checkPrincipal(principal) {
+  if (!principal || !PRINCIPAL_KINDS.includes(principal.kind) || typeof principal.name !== "string" || principal.name.trim() === "") {
+    throw new TypeError(`the editor needs a principal with a kind (${PRINCIPAL_KINDS.join(", ")}) and a name`);
+  }
+}
+function useEditorSession(client, id, name, editable, room, attempt, onLeave) {
+  const [load, setLoad] = useState2({ state: "loading" });
+  const roomKey = room ? JSON.stringify([room.url, room.token ?? ""]) : "";
+  const roomRef = useRef2(room);
+  roomRef.current = room;
+  const leaveRef = useRef2(onLeave);
+  leaveRef.current = onLeave;
+  useEffect2(() => {
+    let cancelled = false;
+    let live;
+    setLoad({ state: "loading" });
+    openSession(client, id, name, roomRef.current).then(
+      (found) => {
+        live = found;
+        if (cancelled) return void found.close();
+        setLoad({ state: "ready", live: found });
+      },
+      (error) => !cancelled && setLoad({ state: "error", error })
+    );
+    return () => {
+      cancelled = true;
+      const open = live;
+      if (!open) return;
+      const done = (async () => {
+        try {
+          if (editable && open.dirty) await open.save();
+        } finally {
+          await open.close();
+        }
+      })();
+      if (leaveRef.current) leaveRef.current(done);
+      else done.catch(() => void 0);
+    };
+  }, [client, id, name, editable, roomKey, room?.WebSocket, attempt]);
+  return load;
+}
+var describe = (error) => {
+  if (isRemoved(error)) return "This document does not exist. It may have been removed.";
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  if (code === "UNAUTHENTICATED") return "The server did not accept the token.";
+  if (code === "FORBIDDEN") return "You may not open this document.";
+  return error instanceof Error ? error.message : "Something went wrong.";
+};
+function DocumentEditor({ id, client, principal, room, onError, onLeave }) {
+  checkPrincipal(principal);
+  const editable = principal.role === "editor";
+  const [attempt, setAttempt] = useState2(0);
+  const load = useEditorSession(client, id, principal.name, editable, room, attempt, onLeave);
+  const reported = useRef2(void 0);
+  useEffect2(() => {
+    if (load.state === "error" && reported.current !== load.error) {
+      reported.current = load.error;
+      onError?.(load.error);
+    }
+  }, [load, onError]);
+  if (load.state === "loading") return /* @__PURE__ */ jsx2("p", { role: "status", className: "adoc muted", children: "Opening document\u2026" });
+  if (load.state === "error") {
+    return /* @__PURE__ */ jsx2("div", { role: "alert", className: "adoc notice", children: /* @__PURE__ */ jsx2(EmptyState2, { title: "Could not open this document", description: describe(load.error), action: /* @__PURE__ */ jsx2(Button2, { onClick: () => setAttempt(attempt + 1), children: "Try again" }) }) });
+  }
+  return /* @__PURE__ */ jsx2(Boundary, { children: /* @__PURE__ */ jsx2(Surface, { live: load.live, editable, principal }) });
+}
+function mountEditor(element, options) {
+  checkPrincipal(options.principal);
+  const root = createRoot(element);
+  const leaving = /* @__PURE__ */ new Set();
+  const track = (done) => {
+    leaving.add(done);
+    void done.catch(() => void 0).finally(() => leaving.delete(done));
+  };
+  const render = (next) => root.render(/* @__PURE__ */ jsx2(DocumentEditor, { ...next, onLeave: (done) => (track(done), next.onLeave?.(done)) }, next.id));
+  render(options);
+  return {
+    update: (next) => (checkPrincipal(next.principal), render(next)),
+    unmount: async () => {
+      root.unmount();
+      await Promise.all(leaving);
+    }
+  };
+}
+export {
+  DocumentEditor,
+  mountEditor,
+  useEditorSession
+};