agentic-documents 0.4.0 → 0.6.0

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
+};

package/dist/formats.d.ts

@@ -0,0 +1,52 @@
+import { Limits, TextDoc } from 'agentic-formats';
+import { D as DocOptions, A as AgenticDoc, d as PmNode, P as Principal } from './doc-BXG9qG5X.js';
+import { a as ExportOptions } from './render-463xHb-x.js';
+import 'yjs';
+
+declare const IMPORT_FORMATS: readonly ["md", "odt", "docx"];
+type ImportFormat = (typeof IMPORT_FORMATS)[number];
+declare const FILE_FORMATS: readonly ["md", "html", "odt", "docx"];
+type FileFormat = (typeof FILE_FORMATS)[number];
+declare const DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+interface ImportOptions {
+    /** Caps for the file. A file that goes past one is refused, never trimmed. The defaults are those of agentic-formats. */
+    limits?: Partial<Limits>;
+    doc?: DocOptions;
+}
+interface ImportResult {
+    doc: AgenticDoc;
+    /** The title the file holds, if any. */
+    title?: string;
+    /** One line for each part of the file that the document cannot hold. Empty when nothing was lost. */
+    warnings: string[];
+}
+interface FileResult {
+    format: FileFormat;
+    contentType: string;
+    /** Text for `md` and `html`. File bytes for `odt` and `docx`. */
+    data: string | Uint8Array;
+    /** One line for each part of the document that the format cannot hold. Empty when nothing was lost. */
+    warnings: string[];
+}
+/** Map document blocks to the neutral text model. A part the model cannot hold keeps its text and adds a warning. */
+declare function toTextDoc(blocks: PmNode[], title?: string): {
+    model: TextDoc;
+    warnings: string[];
+};
+/** Map the neutral text model to document blocks. A part the editor cannot hold keeps its text and adds a warning. */
+declare function fromTextDoc(model: TextDoc): {
+    blocks: PmNode[];
+    title?: string;
+    warnings: string[];
+};
+/** Read a file into a new document. The author makes the one `create` edit, so text from an agent stays labeled. */
+declare function importFile(input: string | Uint8Array, format: ImportFormat, author: Principal, options?: ImportOptions): ImportResult;
+declare const ODT_MIME: string;
+/** Write blocks as an OpenDocument text file (.odt). It drops the warnings; use `exportFile` or `exportDoc` to read what the file cannot hold. */
+declare function exportOdt(blocks: PmNode[]): Uint8Array;
+/** Write a document as a file. `title` goes into the ODT and DOCX metadata. */
+declare function exportFile(doc: AgenticDoc, format: FileFormat, options?: ExportOptions & {
+    title?: string;
+}): FileResult;
+
+export { DOCX_MIME, FILE_FORMATS, type FileFormat, type FileResult, IMPORT_FORMATS, type ImportFormat, type ImportOptions, type ImportResult, ODT_MIME, exportFile, exportOdt, fromTextDoc, importFile, toTextDoc };

package/dist/formats.js

@@ -0,0 +1,24 @@
+import {
+  DOCX_MIME,
+  FILE_FORMATS,
+  IMPORT_FORMATS,
+  ODT_MIME,
+  exportFile,
+  exportOdt,
+  fromTextDoc,
+  importFile,
+  toTextDoc
+} from "./chunk-KC5KFB5R.js";
+import "./chunk-GQ5E6T7Z.js";
+import "./chunk-DWVJIKVT.js";
+export {
+  DOCX_MIME,
+  FILE_FORMATS,
+  IMPORT_FORMATS,
+  ODT_MIME,
+  exportFile,
+  exportOdt,
+  fromTextDoc,
+  importFile,
+  toTextDoc
+};

package/dist/index.d.ts

@@ -1,12 +1,18 @@
-import { a as Principal, b as PmNode } from './doc-C_8kCsl7.js';
-export { c as AgenticDoc, A as Anchor, d as AnchorTarget, D as DocOptions, E as EditEntry, e as PRINCIPAL_KINDS, P as PrincipalKind, S as Section, f as SectionTarget, T as Target, g as TextTarget, h as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './doc-C_8kCsl7.js';
+import { A as AgenticDoc, P as Principal } from './doc-BXG9qG5X.js';
+export { a as Anchor, b as AnchorTarget, D as DocOptions, E as EditEntry, c as PRINCIPAL_KINDS, d as PmNode, e as PrincipalKind, S as Section, f as SectionTarget, T as Target, g as TextTarget, h as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './doc-BXG9qG5X.js';
 import { Schema } from 'prosemirror-model';
-export { a as DocError, D as DocErrorCode, b as EXPORT_FORMATS, E as ExportFormat, c as ExportOptions, d as ExportResult, M as Message, S as Suggestion, e as Suggestions, T as Thread, f as Threads, g as exportDoc } from './review-BQW2Ci2h.js';
+export { D as DocError, a as DocErrorCode, M as Message, S as Suggestion, b as Suggestions, T as Thread, c as Threads } from './review-Ds-i5Vnc.js';
 import { z } from 'zod';
-import { D as DocAccess } from './service-Do2Jwb5U.js';
-export { a as DocInfo, b as DocsPorts, c as DocsService } from './service-Do2Jwb5U.js';
+import { D as DocAccess } from './service-Ck6oX-Kq.js';
+export { a as DocInfo, b as DocsPorts, c as DocsService } from './service-Ck6oX-Kq.js';
+import { E as ExportFormat, a as ExportOptions, b as ExportResult } from './render-463xHb-x.js';
+export { c as EXPORT_FORMATS } from './render-463xHb-x.js';
 import { AdapterOptions, Blobs, Store } from 'agentic-identity';
+export { ODT_MIME, exportOdt } from './formats.js';
 import 'yjs';
+import 'agentic-formats';
+
+declare function exportDoc(doc: AgenticDoc, format: ExportFormat, options?: ExportOptions): ExportResult;
 
 declare const schema: Schema<string, string>;
 
@@ -45,8 +51,4 @@ declare function createFileStore(dir: string, options?: AdapterOptions & Pick<Fi
     shared?: string;
 }): Store;
 
-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 { type Command, type FileBlobsOptions, ODT_MIME, PmNode, Principal, commands, createFileBlobs, createFileStore, exportOdt, schema };
+export { AgenticDoc, type Command, ExportFormat, ExportOptions, ExportResult, type FileBlobsOptions, Principal, commands, createFileBlobs, createFileStore, exportDoc, schema };