@june-ai/june-ui 0.2.1 → 0.2.3

package/dist/index.cjs

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,63 +20,261 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors/errors.ts
+function isJuneError(value) {
+  return value instanceof JuneError;
+}
+function toJuneError(error, fallbackCode, message) {
+  if (error instanceof JuneError) return error;
+  const text = message ?? (error instanceof Error ? error.message : String(error));
+  return new JuneError(fallbackCode, text, { cause: error });
+}
+var JuneError;
+var init_errors = __esm({
+  "src/errors/errors.ts"() {
+    "use strict";
+    JuneError = class _JuneError extends Error {
+      constructor(code2, message, options = {}) {
+        super(message);
+        Object.setPrototypeOf(this, _JuneError.prototype);
+        this.name = "JuneError";
+        this.code = code2;
+        this.details = options.details;
+        if (options.cause !== void 0) {
+          this.cause = options.cause;
+        }
+      }
+    };
+  }
+});
+
+// src/components/document-editor/document-extensions.ts
+function createDocumentExtensions() {
+  return [
+    import_starter_kit.default.configure({
+      heading: { levels: [1, 2, 3] },
+      // Tiptap v3 StarterKit already includes Link and Underline
+      link: { openOnClick: false, autolink: true, defaultProtocol: "https" }
+    }),
+    import_extension_text_align.default.configure({ types: ["heading", "paragraph"] }),
+    import_extension_table.TableKit,
+    import_markdown.Markdown
+  ];
+}
+var import_extension_table, import_extension_text_align, import_markdown, import_starter_kit;
+var init_document_extensions = __esm({
+  "src/components/document-editor/document-extensions.ts"() {
+    "use strict";
+    import_extension_table = require("@tiptap/extension-table");
+    import_extension_text_align = __toESM(require("@tiptap/extension-text-align"), 1);
+    import_markdown = require("@tiptap/markdown");
+    import_starter_kit = __toESM(require("@tiptap/starter-kit"), 1);
+  }
+});
+
+// src/components/document-editor/document-utils.ts
+function isDocJSON(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === "doc" && (v.content === void 0 || Array.isArray(v.content));
+}
+function looksLikeDocJSON(text) {
+  return /^\s*\{\s*"type"\s*:\s*"doc"/.test(text);
+}
+function tryParseDocJSON(text) {
+  try {
+    const value = JSON.parse(text);
+    return isDocJSON(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function docKey(doc) {
+  let key = keyCache.get(doc);
+  if (key === void 0) {
+    key = JSON.stringify(doc);
+    keyCache.set(doc, key);
+  }
+  return key;
+}
+function plainText(node) {
+  const n = node;
+  if (typeof n.text === "string") return n.text;
+  return (n.content ?? []).map(plainText).join(" ");
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  return trimmed ? trimmed.split(/\s+/).length : 0;
+}
+function wordCountOf(doc) {
+  let count = wordCache.get(doc);
+  if (count === void 0) {
+    count = countWords(plainText(doc));
+    wordCache.set(doc, count);
+  }
+  return count;
+}
+function slugify(value) {
+  return value.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function debounce(fn, wait) {
+  let timer = null;
+  const run = () => {
+    timer = null;
+    fn();
+  };
+  const debounced = (() => {
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(run, wait);
+  });
+  debounced.cancel = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  debounced.flush = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      run();
+    }
+  };
+  return debounced;
+}
+function sanitizeHref(input) {
+  const value = input.trim();
+  if (!value) return null;
+  if (/^(https?:|mailto:|tel:)/i.test(value)) return value;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (value.startsWith("/") || value.startsWith("#")) return value;
+  return `https://${value}`;
+}
+var emptyDoc, keyCache, wordCache;
+var init_document_utils = __esm({
+  "src/components/document-editor/document-utils.ts"() {
+    "use strict";
+    emptyDoc = () => ({ type: "doc", content: [{ type: "paragraph" }] });
+    keyCache = /* @__PURE__ */ new WeakMap();
+    wordCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/components/document-editor/document-engine.ts
+var document_engine_exports = {};
+__export(document_engine_exports, {
+  docToHtml: () => docToHtml,
+  docToMarkdown: () => docToMarkdown,
+  docToText: () => docToText,
+  parseDocumentContent: () => parseDocumentContent
+});
+function scratchEditor() {
+  if (!scratch || scratch.isDestroyed) {
+    scratch = new import_core.Editor({ extensions: createDocumentExtensions(), content: "" });
+  }
+  return scratch;
+}
+function parseDocumentContent(text) {
+  const editor = scratchEditor();
+  const trimmed = text.trim();
+  try {
+    if (looksLikeDocJSON(trimmed)) {
+      const json = tryParseDocJSON(trimmed);
+      if (!json) throw new Error("The document JSON could not be parsed");
+      editor.schema.nodeFromJSON(json).check();
+      editor.commands.setContent(json, { emitUpdate: false });
+    } else {
+      editor.commands.setContent(trimmed, { contentType: "markdown", emitUpdate: false });
+    }
+    return editor.getJSON();
+  } catch (error) {
+    throw toJuneError(error, "DOCUMENT_ERROR", "The document content is invalid");
+  }
+}
+function load(doc) {
+  const editor = scratchEditor();
+  editor.commands.setContent(doc, { emitUpdate: false });
+  return editor;
+}
+var import_core, scratch, docToHtml, docToMarkdown, docToText;
+var init_document_engine = __esm({
+  "src/components/document-editor/document-engine.ts"() {
+    "use strict";
+    import_core = require("@tiptap/core");
+    init_errors();
+    init_document_extensions();
+    init_document_utils();
+    scratch = null;
+    docToHtml = (doc) => load(doc).getHTML();
+    docToMarkdown = (doc) => load(doc).getMarkdown();
+    docToText = (doc) => load(doc).getText({ blockSeparator: "\n\n" });
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALL_EXPORT_FORMATS: () => ALL_EXPORT_FORMATS,
+  DocumentEditor: () => DocumentEditor,
+  JuneDocumentContext: () => JuneDocumentContext,
+  JuneDocumentEditorComponent: () => JuneDocumentEditorComponent,
   JuneError: () => JuneError,
   JuneErrorBoundary: () => JuneErrorBoundary,
   JuneRenderer: () => JuneRenderer,
+  JuneRuntimeContext: () => JuneRuntimeContext,
   JuneThemeProvider: () => JuneThemeProvider,
   JuneUI: () => JuneUI,
   consumeStream: () => consumeStream,
+  copyDocumentToClipboard: () => copyDocumentToClipboard,
   createActionHandler: () => createActionHandler,
+  createDocumentStore: () => createDocumentStore,
   createJuneLibrary: () => createJuneLibrary,
   darkTheme: () => darkTheme,
   defaultParseActionEvent: () => defaultParseActionEvent,
   defineJuneAction: () => defineJuneAction,
   defineJuneComponent: () => defineJuneComponent,
+  documentPromptOptions: () => documentPromptOptions,
+  downloadResult: () => downloadResult,
+  exportDocument: () => exportDocument,
   fetchStream: () => fetchStream,
+  getDefaultDocumentStore: () => getDefaultDocumentStore,
+  getDocumentEditorInstructions: () => getDocumentEditorInstructions,
+  getDocumentEditorRules: () => getDocumentEditorRules,
   isJuneError: () => isJuneError,
   jsonFieldExtractor: () => jsonFieldExtractor,
+  juneLibrary: () => juneLibrary,
   lightTheme: () => lightTheme,
+  listDocumentExporters: () => listDocumentExporters,
+  mergeDocuments: () => mergeDocuments,
+  registerDocumentExporter: () => registerDocumentExporter,
   runAction: () => runAction,
+  serializeDocumentsForAgent: () => serializeDocumentsForAgent,
   sseToText: () => sseToText,
   toJuneError: () => toJuneError,
+  useDocumentOptions: () => useDocumentOptions,
+  useJuneRuntime: () => useJuneRuntime,
   useJuneStream: () => useJuneStream,
   useJuneTheme: () => useJuneTheme,
-  useResolvedTheme: () => useResolvedTheme
+  useResolvedTheme: () => useResolvedTheme,
+  withDocumentEditor: () => withDocumentEditor
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/renderer/renderer.tsx
 var import_react_lang = require("@openuidev/react-lang");
-var import_react4 = require("react");
-
-// src/errors/errors.ts
-var JuneError = class _JuneError extends Error {
-  constructor(code, message, options = {}) {
-    super(message);
-    Object.setPrototypeOf(this, _JuneError.prototype);
-    this.name = "JuneError";
-    this.code = code;
-    this.details = options.details;
-    if (options.cause !== void 0) {
-      this.cause = options.cause;
-    }
-  }
-};
-function isJuneError(value) {
-  return value instanceof JuneError;
-}
-function toJuneError(error, fallbackCode, message) {
-  if (error instanceof JuneError) return error;
-  const text = message ?? (error instanceof Error ? error.message : String(error));
-  return new JuneError(fallbackCode, text, { cause: error });
-}
+var import_react5 = require("react");
 
 // src/actions/action-handler.ts
+init_errors();
 function firstString(...values) {
   for (const v of values) if (typeof v === "string" && v.length > 0) return v;
   return null;
@@ -133,28 +336,44 @@ function createActionHandler(options) {
   };
 }
 
-// src/themes/theme-provider.tsx
-var import_react2 = require("react");
+// src/components/document-editor/document-context.ts
+var import_react = require("react");
+var JuneDocumentContext = (0, import_react.createContext)({});
+function useDocumentOptions() {
+  return (0, import_react.useContext)(JuneDocumentContext);
+}
+function useDocumentValue(store, id, selector) {
+  const read = () => selector(store.get(id));
+  return (0, import_react.useSyncExternalStore)(store.subscribe, read, read);
+}
 
 // src/core/context.ts
-var import_react = require("react");
-var JuneContext = (0, import_react.createContext)({
+var import_react2 = require("react");
+var JuneContext = (0, import_react2.createContext)({
   mode: "light",
   theme: "light"
 });
 function useJuneTheme() {
-  return (0, import_react.useContext)(JuneContext);
+  return (0, import_react2.useContext)(JuneContext);
+}
+var JuneRuntimeContext = (0, import_react2.createContext)({ isStreaming: false });
+function useJuneRuntime() {
+  return (0, import_react2.useContext)(JuneRuntimeContext);
 }
 
+// src/renderer/renderer.tsx
+init_errors();
+
+// src/themes/theme-provider.tsx
+var import_react3 = require("react");
+
 // src/themes/dark.ts
 var darkTheme = {
   "--june-foreground": "#f3f4f6",
   "--june-muted": "#9ca3af",
   "--june-border": "#1f2937",
   "--june-accent": "#818cf8",
-  "--june-danger": "#f87171",
-  "--june-radius": "8px",
-  "--june-font-family": "system-ui, -apple-system, 'Segoe UI', sans-serif"
+  "--june-danger": "#f87171"
 };
 
 // src/themes/light.ts
@@ -163,9 +382,7 @@ var lightTheme = {
   "--june-muted": "#6b7280",
   "--june-border": "#e5e7eb",
   "--june-accent": "#4f46e5",
-  "--june-danger": "#b91c1c",
-  "--june-radius": "8px",
-  "--june-font-family": "system-ui, -apple-system, 'Segoe UI', sans-serif"
+  "--june-danger": "#b91c1c"
 };
 
 // src/themes/theme-provider.tsx
@@ -186,27 +403,37 @@ function getServerSnapshot() {
   return "light";
 }
 function useResolvedTheme(mode) {
-  const system = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot);
+  const system = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot);
   return mode === "system" ? system : mode;
 }
 function JuneThemeProvider({
-  mode = "light",
+  mode,
   vars,
   className,
   style,
   children
 }) {
-  const resolved = useResolvedTheme(mode);
-  const mergedStyle = (0, import_react2.useMemo)(() => {
-    const base = resolved === "dark" ? darkTheme : lightTheme;
-    return { ...base, ...vars, colorScheme: resolved, ...style };
-  }, [resolved, vars, style]);
-  const context = (0, import_react2.useMemo)(() => ({ mode, theme: resolved }), [mode, resolved]);
+  const explicit = mode !== void 0;
+  const resolved = useResolvedTheme(mode ?? "system");
+  const mergedStyle = (0, import_react3.useMemo)(() => {
+    if (!explicit && !vars && !style) return void 0;
+    const base = explicit ? resolved === "dark" ? darkTheme : lightTheme : void 0;
+    return {
+      ...base,
+      ...vars,
+      ...explicit ? { colorScheme: resolved } : {},
+      ...style
+    };
+  }, [explicit, resolved, vars, style]);
+  const context = (0, import_react3.useMemo)(
+    () => ({ mode: mode ?? "system", theme: resolved }),
+    [mode, resolved]
+  );
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(JuneContext.Provider, { value: context, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     "div",
     {
       className: className ? `june-ui-root ${className}` : "june-ui-root",
-      "data-june-theme": resolved,
+      "data-june-theme": explicit ? resolved : void 0,
       style: mergedStyle,
       children
     }
@@ -622,12 +849,12 @@ function splitResponse(source, options = {}) {
 }
 
 // src/renderer/error-boundary.tsx
-var import_react3 = require("react");
+var import_react4 = require("react");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 function keysChanged(a = [], b = []) {
   return a.length !== b.length || a.some((v, i) => !Object.is(v, b[i]));
 }
-var JuneErrorBoundary = class extends import_react3.Component {
+var JuneErrorBoundary = class extends import_react4.Component {
   constructor() {
     super(...arguments);
     this.state = { error: null };
@@ -665,7 +892,8 @@ function JuneRenderer(props) {
     isStreaming = false,
     mixedContent = true,
     renderText,
-    theme = "light",
+    repair = true,
+    theme,
     themeVars,
     className,
     style,
@@ -675,29 +903,16 @@ function JuneRenderer(props) {
     onAction,
     onError,
     onJuneError,
+    documents,
     loadingFallback = null,
     emptyFallback = null,
     errorFallback,
     resetKeys,
     ...rendererProps
   } = props;
-  const latest = (0, import_react4.useRef)({
-    actions,
-    confirmAction,
-    parseActionEvent,
-    onAction,
-    onError,
-    onJuneError
-  });
-  latest.current = {
-    actions,
-    confirmAction,
-    parseActionEvent,
-    onAction,
-    onError,
-    onJuneError
-  };
-  const handleAction = (0, import_react4.useCallback)((event) => {
+  const latest = (0, import_react5.useRef)({ actions, confirmAction, parseActionEvent, onAction, onError, onJuneError });
+  latest.current = { actions, confirmAction, parseActionEvent, onAction, onError, onJuneError };
+  const handleAction = (0, import_react5.useCallback)((event) => {
     const l = latest.current;
     l.onAction?.(event);
     if (l.actions) {
@@ -709,21 +924,21 @@ function JuneRenderer(props) {
       });
     }
   }, []);
-  const handleParserErrors = (0, import_react4.useCallback)((errors) => {
-    const list = Array.isArray(errors) ? errors : [];
+  const handleParserErrors = (0, import_react5.useCallback)((errors) => {
+    const list2 = Array.isArray(errors) ? errors : [];
     const l = latest.current;
-    l.onError?.(list);
-    const real = list.filter((e) => e?.severity !== "warning");
+    l.onError?.(list2);
+    const real = list2.filter((e) => e?.severity !== "warning");
     if (real.length > 0) {
       l.onJuneError?.(
         new JuneError("PARSE_ERROR", `OpenUI reported ${real.length} error(s)`, { details: real })
       );
     }
-    if (list.length > 0 && !l.onError && !l.onJuneError) {
-      console.warn("[june-ui] OpenUI reported errors:", list);
+    if (list2.length > 0 && !l.onError && !l.onJuneError) {
+      console.warn("[june-ui] OpenUI reported errors:", list2);
     }
   }, []);
-  const handleBoundaryError = (0, import_react4.useCallback)((error, info) => {
+  const handleBoundaryError = (0, import_react5.useCallback)((error, info) => {
     latest.current.onJuneError?.(
       new JuneError("RENDER_ERROR", error.message, {
         cause: error,
@@ -731,21 +946,32 @@ function JuneRenderer(props) {
       })
     );
   }, []);
-  const parts = (0, import_react4.useMemo)(
+  const runtime = (0, import_react5.useMemo)(() => ({ isStreaming }), [isStreaming]);
+  const documentOptions = (0, import_react5.useMemo)(
+    () => ({
+      ...documents,
+      onError: (error) => {
+        documents?.onError?.(error);
+        latest.current.onJuneError?.(error);
+      }
+    }),
+    [documents]
+  );
+  const parts = (0, import_react5.useMemo)(
     () => mixedContent && response ? splitResponse(response, { streaming: isStreaming }) : null,
     [mixedContent, response, isStreaming]
   );
-  const uiText = (0, import_react4.useMemo)(() => {
+  const uiText = (0, import_react5.useMemo)(() => {
     const raw = parts && !parts.pure ? parts.ui : response;
-    if (!mixedContent || isStreaming || typeof raw !== "string" || raw.length === 0) return raw;
+    if (!repair || !mixedContent || isStreaming || typeof raw !== "string" || raw.length === 0) return raw;
     return normalizeProgram(raw);
-  }, [parts, response, mixedContent, isStreaming]);
+  }, [parts, response, mixedContent, isStreaming, repair]);
   const hasUi = typeof uiText === "string" && uiText.trim().length > 0;
   const before = parts?.before ?? [];
   const after = parts?.after ?? [];
   const hasText = before.length + after.length > 0;
-  const text = (value, index, key) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react4.Fragment, { children: renderText ? renderText(value, index) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "june-text", children: value }) }, key);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(JuneThemeProvider, { mode: theme, vars: themeVars, className, style, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+  const text = (value, index, key) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react5.Fragment, { children: renderText ? renderText(value, index) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "june-text", children: value }) }, key);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(JuneThemeProvider, { mode: theme, vars: themeVars, className, style, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(JuneRuntimeContext.Provider, { value: runtime, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(JuneDocumentContext.Provider, { value: documentOptions, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
     JuneErrorBoundary,
     {
       fallback: errorFallback,
@@ -768,11 +994,12 @@ function JuneRenderer(props) {
         !hasUi && !hasText && (isStreaming ? loadingFallback : emptyFallback)
       ]
     }
-  ) });
+  ) }) }) });
 }
 
 // src/components/library.ts
 var import_react_lang2 = require("@openuidev/react-lang");
+init_errors();
 var defineJuneComponent = import_react_lang2.defineComponent;
 function createJuneLibrary(options) {
   const { allow, deny, ...rest } = options;
@@ -814,6 +1041,7 @@ function createJuneLibrary(options) {
 }
 
 // src/actions/define-action.ts
+init_errors();
 function defineJuneAction(definition) {
   if (typeof definition.handler !== "function") {
     throw new JuneError("ACTION_VALIDATION_ERROR", "defineJuneAction requires a handler function");
@@ -822,9 +1050,17 @@ function defineJuneAction(definition) {
 }
 
 // src/streaming/use-june-stream.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
+init_errors();
+
+// src/streaming/fetch-adapter.ts
+init_errors();
+
+// src/streaming/sse-adapter.ts
+init_errors();
 
 // src/streaming/stream-handler.ts
+init_errors();
 function isReadableStream(source) {
   return typeof source.getReader === "function";
 }
@@ -995,20 +1231,20 @@ var INITIAL = {
   error: null
 };
 function useJuneStream(options = {}) {
-  const [state, setState] = (0, import_react5.useState)(INITIAL);
-  const optionsRef = (0, import_react5.useRef)(options);
+  const [state, setState] = (0, import_react6.useState)(INITIAL);
+  const optionsRef = (0, import_react6.useRef)(options);
   optionsRef.current = options;
-  const controllerRef = (0, import_react5.useRef)(null);
-  const runIdRef = (0, import_react5.useRef)(0);
-  const textRef = (0, import_react5.useRef)("");
-  const timerRef = (0, import_react5.useRef)(null);
-  const clearTimer = (0, import_react5.useCallback)(() => {
+  const controllerRef = (0, import_react6.useRef)(null);
+  const runIdRef = (0, import_react6.useRef)(0);
+  const textRef = (0, import_react6.useRef)("");
+  const timerRef = (0, import_react6.useRef)(null);
+  const clearTimer = (0, import_react6.useCallback)(() => {
     if (timerRef.current !== null) {
       clearTimeout(timerRef.current);
       timerRef.current = null;
     }
   }, []);
-  const schedule = (0, import_react5.useCallback)(() => {
+  const schedule = (0, import_react6.useCallback)(() => {
     if (timerRef.current !== null) return;
     timerRef.current = setTimeout(() => {
       timerRef.current = null;
@@ -1018,7 +1254,7 @@ function useJuneStream(options = {}) {
       );
     }, FLUSH_MS);
   }, []);
-  const start = (0, import_react5.useCallback)(
+  const start = (0, import_react6.useCallback)(
     async (input) => {
       controllerRef.current?.abort();
       const controller = new AbortController();
@@ -1063,21 +1299,21 @@ function useJuneStream(options = {}) {
     },
     [clearTimer, schedule]
   );
-  const startFetch = (0, import_react5.useCallback)(
+  const startFetch = (0, import_react6.useCallback)(
     (input, fetchOptions) => start((signal) => fetchStream(input, { ...fetchOptions, signal })),
     [start]
   );
-  const abort = (0, import_react5.useCallback)(() => {
+  const abort = (0, import_react6.useCallback)(() => {
     controllerRef.current?.abort();
   }, []);
-  const reset = (0, import_react5.useCallback)(() => {
+  const reset = (0, import_react6.useCallback)(() => {
     controllerRef.current?.abort();
     runIdRef.current++;
     textRef.current = "";
     clearTimer();
     setState(INITIAL);
   }, [clearTimer]);
-  (0, import_react5.useEffect)(
+  (0, import_react6.useEffect)(
     () => () => {
       runIdRef.current++;
       controllerRef.current?.abort();
@@ -1085,40 +1321,1181 @@ function useJuneStream(options = {}) {
     },
     [clearTimer]
   );
-  return (0, import_react5.useMemo)(
+  return (0, import_react6.useMemo)(
     () => ({ ...state, start, startFetch, abort, reset }),
     [state, start, startFetch, abort, reset]
   );
 }
 
-// src/core/JuneUI.tsx
-var import_react_ui = require("@openuidev/react-ui");
+// src/entry-core.ts
+init_errors();
+
+// src/components/document-editor/document-component.tsx
+var import_react_lang3 = require("@openuidev/react-lang");
+var import_v4 = require("zod/v4");
+
+// src/components/document-editor/document-draft.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
-function JuneUI({ library = import_react_ui.openuiLibrary, ...props }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(JuneRenderer, { library, ...props });
+function DocumentDraft({ title, words, state }) {
+  if (state === "empty") {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "june-doc june-doc--draft", role: "alert", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "june-doc__draft-text", children: "No document content was received." }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "june-doc june-doc--draft", role: "status", "aria-live": "polite", children: [
+    title ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "june-doc__draft-title", children: title }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "june-doc__draft-text", children: state === "drafting" ? `Drafting document\u2026${words ? ` ${words} words so far` : ""}` : "Loading editor\u2026" }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "june-doc__pulse", "aria-hidden": "true", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", {}),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", {}),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", {})
+    ] })
+  ] });
+}
+
+// src/components/document-editor/document-editor.tsx
+var import_react10 = require("@tiptap/react");
+var import_react11 = require("react");
+init_errors();
+
+// src/components/document-editor/document-content.tsx
+var import_react7 = require("@tiptap/react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function DocumentContent({ editor }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "june-doc__content", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react7.EditorContent, { editor }) });
+}
+
+// src/components/document-editor/document-editor.tsx
+init_document_engine();
+
+// src/components/document-editor/document-export.ts
+init_errors();
+init_document_utils();
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var PRINT_CSS = 'body{font-family:system-ui,-apple-system,"Segoe UI",sans-serif;line-height:1.6;color:#111827;max-width:780px;margin:32px auto;padding:0 20px}h1,h2,h3{line-height:1.25}table{border-collapse:collapse;width:100%}th,td{border:1px solid #d1d5db;padding:6px 10px;text-align:left}blockquote{border-left:4px solid #d1d5db;margin:1em 0;padding-left:1em;color:#4b5563}pre,code{font-family:ui-monospace,Menlo,monospace;background:#f3f4f6}pre{padding:12px;overflow:auto}@media print{body{margin:0;max-width:none}}';
+function buildHtmlDocument(title, bodyHtml) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${escapeHtml(
+    title
+  )}</title><style>${PRINT_CSS}</style></head><body><h1>${escapeHtml(title)}</h1>${bodyHtml}</body></html>`;
+}
+var textResult = (text, filename, mimeType) => ({
+  filename,
+  mimeType,
+  text,
+  blob: new Blob([text], { type: `${mimeType};charset=utf-8` })
+});
+var exportHtml = async (ctx) => {
+  const { docToHtml: docToHtml2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  return textResult(
+    buildHtmlDocument(ctx.title, docToHtml2(ctx.json)),
+    `${ctx.basename}.html`,
+    "text/html"
+  );
+};
+var exportMarkdown = async (ctx) => {
+  const { docToMarkdown: docToMarkdown2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  return textResult(
+    `# ${ctx.title}
+
+${docToMarkdown2(ctx.json)}
+`,
+    `${ctx.basename}.md`,
+    "text/markdown"
+  );
+};
+var exportTxt = async (ctx) => {
+  const { docToText: docToText2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  return textResult(`${ctx.title}
+
+${docToText2(ctx.json)}
+`, `${ctx.basename}.txt`, "text/plain");
+};
+var ORDERED_REF = "june-ordered";
+var DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+function runs(d, node, fmt) {
+  const out = [];
+  for (const child of node.content ?? []) {
+    if (child.type === "hardBreak") {
+      out.push(new d.TextRun({ break: 1 }));
+      continue;
+    }
+    if (child.type !== "text" || !child.text) continue;
+    const marks = child.marks ?? [];
+    const has = (type) => marks.some((m) => m.type === type);
+    const link = marks.find((m) => m.type === "link");
+    const run = new d.TextRun({
+      text: child.text,
+      bold: fmt.bold || has("bold") || void 0,
+      italics: has("italic") || void 0,
+      underline: has("underline") || link ? {} : void 0,
+      strike: has("strike") || void 0,
+      font: has("code") ? "Courier New" : void 0,
+      color: link ? "0563C1" : void 0
+    });
+    const href = typeof link?.attrs?.href === "string" ? sanitizeHref(link.attrs.href) : null;
+    out.push(href ? new d.ExternalHyperlink({ link: href, children: [run] }) : run);
+  }
+  return out;
+}
+function paragraph(d, node, fmt, extra = {}) {
+  const align = node.attrs?.textAlign;
+  return new d.Paragraph({
+    children: runs(d, node, fmt),
+    alignment: align === "center" ? d.AlignmentType.CENTER : align === "right" ? d.AlignmentType.RIGHT : align === "justify" ? d.AlignmentType.JUSTIFIED : void 0,
+    indent: fmt.indent ? { left: fmt.indent } : void 0,
+    border: fmt.quote ? { left: { color: "9CA3AF", space: 8, style: d.BorderStyle.SINGLE, size: 12 } } : void 0,
+    spacing: { after: 120 },
+    ...extra
+  });
+}
+function list(d, node, fmt, level, state) {
+  const ordered = node.type === "orderedList";
+  const instance = ordered ? ++state.instance : 0;
+  const out = [];
+  for (const item of node.content ?? []) {
+    let first = true;
+    for (const child of item.content ?? []) {
+      if (child.type === "bulletList" || child.type === "orderedList") {
+        out.push(...list(d, child, fmt, level + 1, state));
+      } else if (child.type === "paragraph" && first) {
+        first = false;
+        const lvl = Math.min(level, 2);
+        out.push(
+          paragraph(
+            d,
+            child,
+            fmt,
+            ordered ? { numbering: { reference: ORDERED_REF, level: lvl, instance } } : { bullet: { level: lvl } }
+          )
+        );
+      } else {
+        out.push(...blocks(d, [child], { ...fmt, indent: (fmt.indent ?? 0) + 720 * (level + 1) }, state));
+      }
+    }
+  }
+  return out;
+}
+function code(d, node) {
+  const lines = (node.content ?? []).map((c) => c.text ?? "").join("").split("\n");
+  return new d.Paragraph({
+    children: lines.map((line, i) => new d.TextRun({ text: line, font: "Courier New", break: i ? 1 : void 0 })),
+    spacing: { after: 120 },
+    shading: { type: d.ShadingType.CLEAR, fill: "F3F4F6" }
+  });
+}
+function table(d, node, state) {
+  const rows = (node.content ?? []).map(
+    (row) => new d.TableRow({
+      children: (row.content ?? []).map((cell) => {
+        const header = cell.type === "tableHeader";
+        const children = blocks(d, cell.content, { bold: header }, state);
+        return new d.TableCell({
+          children: children.length ? children : [new d.Paragraph("")],
+          shading: header ? { type: d.ShadingType.CLEAR, fill: "F3F4F6" } : void 0
+        });
+      })
+    })
+  );
+  if (rows.length === 0) return new d.Paragraph("");
+  return new d.Table({ rows, width: { size: 100, type: d.WidthType.PERCENTAGE } });
+}
+function blocks(d, nodes, fmt, state) {
+  const headings = [d.HeadingLevel.HEADING_1, d.HeadingLevel.HEADING_2, d.HeadingLevel.HEADING_3];
+  const out = [];
+  for (const node of nodes ?? []) {
+    switch (node.type) {
+      case "paragraph":
+        out.push(paragraph(d, node, fmt));
+        break;
+      case "heading": {
+        const level = Math.min(Math.max(Number(node.attrs?.level) || 1, 1), 3);
+        out.push(paragraph(d, node, fmt, { heading: headings[level - 1] }));
+        break;
+      }
+      case "bulletList":
+      case "orderedList":
+        out.push(...list(d, node, fmt, 0, state));
+        break;
+      case "blockquote":
+        out.push(...blocks(d, node.content, { ...fmt, quote: true, indent: (fmt.indent ?? 0) + 360 }, state));
+        break;
+      case "codeBlock":
+        out.push(code(d, node));
+        break;
+      case "horizontalRule":
+        out.push(
+          new d.Paragraph({
+            border: { bottom: { color: "9CA3AF", space: 1, style: d.BorderStyle.SINGLE, size: 6 } },
+            spacing: { after: 120 }
+          })
+        );
+        break;
+      case "table":
+        out.push(table(d, node, state));
+        break;
+      default:
+        if (node.content) out.push(...blocks(d, node.content, fmt, state));
+    }
+  }
+  return out;
+}
+var exportDocx = async (ctx) => {
+  const d = await import("docx");
+  const state = { instance: 0 };
+  const children = [
+    new d.Paragraph({ text: ctx.title, heading: d.HeadingLevel.TITLE }),
+    ...blocks(d, ctx.json.content, {}, state)
+  ];
+  const doc = new d.Document({
+    title: ctx.title,
+    numbering: {
+      config: [
+        {
+          reference: ORDERED_REF,
+          levels: [0, 1, 2].map((level) => ({
+            level,
+            format: d.LevelFormat.DECIMAL,
+            text: `%${level + 1}.`,
+            alignment: d.AlignmentType.START,
+            style: { paragraph: { indent: { left: 720 * (level + 1), hanging: 360 } } }
+          }))
+        }
+      ]
+    },
+    sections: [{ children }]
+  });
+  const blob = await d.Packer.toBlob(doc);
+  return { filename: `${ctx.basename}.docx`, mimeType: DOCX_MIME, blob };
+};
+function printHtml(html) {
+  return new Promise((resolve, reject) => {
+    const frame = document.createElement("iframe");
+    frame.setAttribute("aria-hidden", "true");
+    frame.style.cssText = "position:fixed;right:0;bottom:0;width:0;height:0;border:0;";
+    const cleanup = () => setTimeout(() => frame.remove(), 500);
+    frame.onload = () => {
+      try {
+        const win = frame.contentWindow;
+        if (!win) throw new Error("The print frame is unavailable");
+        win.addEventListener("afterprint", cleanup);
+        win.focus();
+        win.print();
+        setTimeout(cleanup, 12e4);
+        resolve();
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    };
+    frame.srcdoc = html;
+    document.body.appendChild(frame);
+  });
+}
+var exportPdf = async (ctx) => {
+  const { docToHtml: docToHtml2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  await printHtml(buildHtmlDocument(ctx.title, docToHtml2(ctx.json)));
+  return { filename: `${ctx.basename}.pdf`, mimeType: "application/pdf", handled: true };
+};
+var registry = /* @__PURE__ */ new Map([
+  ["html", exportHtml],
+  ["markdown", exportMarkdown],
+  ["txt", exportTxt],
+  ["docx", exportDocx],
+  ["pdf", exportPdf]
+]);
+function registerDocumentExporter(format, exporter) {
+  registry.set(format, exporter);
+}
+function listDocumentExporters() {
+  return [...registry.keys()];
+}
+async function exportDocument(format, doc) {
+  const exporter = registry.get(format);
+  if (!exporter) throw new JuneError("EXPORT_ERROR", `No exporter is registered for "${format}"`);
+  try {
+    return await exporter({ ...doc, basename: slugify(doc.title) || "document" });
+  } catch (error) {
+    throw toJuneError(error, "EXPORT_ERROR", `Exporting ${format} failed`);
+  }
+}
+function downloadResult(result) {
+  if (!result.blob) return;
+  const url = URL.createObjectURL(result.blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = result.filename;
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 1e3);
+}
+async function copyDocumentToClipboard(doc) {
+  const { docToHtml: docToHtml2, docToText: docToText2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  const html = docToHtml2(doc.json);
+  const text = `${doc.title}
+
+${docToText2(doc.json)}`;
+  try {
+    if (typeof ClipboardItem !== "undefined" && navigator.clipboard?.write) {
+      await navigator.clipboard.write([
+        new ClipboardItem({
+          "text/html": new Blob([html], { type: "text/html" }),
+          "text/plain": new Blob([text], { type: "text/plain" })
+        })
+      ]);
+      return true;
+    }
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/components/document-editor/document-editor.tsx
+init_document_extensions();
+
+// src/components/document-editor/document-merge.ts
+init_document_utils();
+var MAX_CELLS = 4e6;
+function matchIndices(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (n * m > MAX_CELLS) return null;
+  const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const matches = /* @__PURE__ */ new Map();
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      matches.set(i, j);
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) i++;
+    else j++;
+  }
+  return matches;
+}
+var same = (x, y) => x.length === y.length && x.every((v, i) => v === y[i]);
+function mergeBlocks(base, local, incoming) {
+  if (same(local, base)) return { blocks: incoming, conflicts: 0 };
+  if (same(incoming, base) || same(local, incoming)) return { blocks: local, conflicts: 0 };
+  const ml = matchIndices(base, local);
+  const mn = matchIndices(base, incoming);
+  if (!ml || !mn) return { blocks: null, conflicts: 1 };
+  const anchors = [...ml.keys()].filter((i) => mn.has(i)).sort((x, y) => x - y);
+  const out = [];
+  let conflicts = 0;
+  let pb = -1;
+  let pl = -1;
+  let pn = -1;
+  const region = (bEnd, lEnd, nEnd) => {
+    const B = base.slice(pb + 1, bEnd);
+    const L = local.slice(pl + 1, lEnd);
+    const N = incoming.slice(pn + 1, nEnd);
+    if (B.length === L.length && L.length === N.length) {
+      for (let k = 0; k < B.length; k++) {
+        if (L[k] === B[k]) out.push(N[k]);
+        else if (N[k] === B[k] || N[k] === L[k]) out.push(L[k]);
+        else {
+          conflicts++;
+          out.push(L[k]);
+        }
+      }
+      return;
+    }
+    if (same(L, B)) out.push(...N);
+    else if (same(N, B) || same(L, N)) out.push(...L);
+    else {
+      conflicts++;
+      out.push(...L);
+    }
+  };
+  for (const a of anchors) {
+    const la = ml.get(a);
+    const na = mn.get(a);
+    region(a, la, na);
+    out.push(local[la]);
+    pb = a;
+    pl = la;
+    pn = na;
+  }
+  region(base.length, local.length, incoming.length);
+  return { blocks: out, conflicts };
+}
+function mergeDocuments(base, local, incoming) {
+  const toBlocks = (d) => (d.content ?? []).map((node) => JSON.stringify(node));
+  const { blocks: blocks2, conflicts } = mergeBlocks(toBlocks(base), toBlocks(local), toBlocks(incoming));
+  if (!blocks2) return { doc: local, conflicts: Math.max(1, conflicts) };
+  if (blocks2.length === 0) return { doc: emptyDoc(), conflicts };
+  return { doc: { type: "doc", content: blocks2.map((b) => JSON.parse(b)) }, conflicts };
+}
+
+// src/components/document-editor/document-store.ts
+init_document_utils();
+var incomingKey = (doc) => JSON.stringify([doc.title, docKey(doc.json)]);
+function createDocumentStore() {
+  const records = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((listener) => listener());
+  const put = (record) => {
+    records.set(record.id, record);
+    emit();
+  };
+  const fresh2 = (doc) => ({
+    id: doc.id,
+    title: doc.title,
+    documentType: doc.documentType,
+    status: doc.status,
+    json: doc.json,
+    baseJson: doc.json,
+    baseTitle: doc.title,
+    lastIncomingKey: incomingKey(doc),
+    revision: 0,
+    origin: "external",
+    pending: null,
+    updatedAt: Date.now()
+  });
+  return {
+    get: (id) => records.get(id),
+    list: () => [...records.values()],
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    receive(incoming) {
+      const current = records.get(incoming.id);
+      if (!current) {
+        put(fresh2(incoming));
+        return "created";
+      }
+      const key = incomingKey(incoming);
+      if (current.lastIncomingKey === key) return "unchanged";
+      const userEditedBody = docKey(current.json) !== docKey(current.baseJson);
+      const userEditedTitle = current.title !== current.baseTitle;
+      const title = userEditedTitle ? current.title : incoming.title;
+      const meta = {
+        documentType: incoming.documentType ?? current.documentType,
+        status: incoming.status ?? current.status
+      };
+      if (!userEditedBody) {
+        put({
+          ...current,
+          ...meta,
+          title,
+          baseTitle: incoming.title,
+          json: incoming.json,
+          baseJson: incoming.json,
+          lastIncomingKey: key,
+          revision: current.revision + 1,
+          origin: "external",
+          pending: null,
+          updatedAt: Date.now()
+        });
+        return "applied";
+      }
+      const { doc, conflicts } = mergeDocuments(current.baseJson, current.json, incoming.json);
+      if (conflicts === 0) {
+        put({
+          ...current,
+          ...meta,
+          title,
+          baseTitle: incoming.title,
+          json: doc,
+          baseJson: incoming.json,
+          lastIncomingKey: key,
+          revision: current.revision + 1,
+          origin: "external",
+          pending: null,
+          updatedAt: Date.now()
+        });
+        return "merged";
+      }
+      put({
+        ...current,
+        ...meta,
+        lastIncomingKey: key,
+        pending: { json: incoming.json, title: incoming.title, merged: doc, conflicts }
+      });
+      return "conflict";
+    },
+    hydrate(doc) {
+      put(fresh2(doc));
+    },
+    edit(id, json, origin) {
+      const current = records.get(id);
+      if (!current || docKey(current.json) === docKey(json)) return;
+      put({ ...current, json, origin, revision: current.revision + 1, updatedAt: Date.now() });
+    },
+    setTitle(id, title) {
+      const current = records.get(id);
+      if (!current || current.title === title) return;
+      put({ ...current, title, updatedAt: Date.now() });
+    },
+    resolve(id, choice) {
+      const current = records.get(id);
+      const pending = current?.pending;
+      if (!current || !pending) return;
+      if (choice === "keep") {
+        put({ ...current, baseJson: pending.json, baseTitle: pending.title, pending: null });
+        return;
+      }
+      const json = choice === "merge" ? pending.merged : pending.json;
+      const title = choice === "merge" ? current.title : pending.title;
+      put({
+        ...current,
+        title,
+        json,
+        baseJson: pending.json,
+        baseTitle: pending.title,
+        revision: current.revision + 1,
+        origin: "external",
+        pending: null,
+        updatedAt: Date.now()
+      });
+    },
+    remove(id) {
+      if (records.delete(id)) emit();
+    }
+  };
+}
+var defaultStore = null;
+function getDefaultDocumentStore() {
+  if (!defaultStore) defaultStore = createDocumentStore();
+  return defaultStore;
+}
+
+// src/components/document-editor/document-title.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function DocumentTitle({ value, disabled, onChange }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    "input",
+    {
+      className: "june-doc__title",
+      "aria-label": "Document title",
+      value,
+      disabled,
+      placeholder: "Untitled document",
+      onChange: (e) => onChange(e.target.value)
+    }
+  );
+}
+
+// src/components/document-editor/document-toolbar.tsx
+var import_react8 = require("@tiptap/react");
+var import_react9 = require("react");
+init_document_utils();
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var FORMAT_LABELS = {
+  html: "HTML",
+  markdown: "Markdown",
+  txt: "Plain text",
+  docx: "Word (.docx)",
+  pdf: "PDF (print)"
+};
+function Btn({ label, active, disabled, toggle, onClick, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    "button",
+    {
+      type: "button",
+      className: "june-doc__btn",
+      "aria-label": label,
+      title: label,
+      "aria-pressed": toggle ? !!active : void 0,
+      "data-active": active || void 0,
+      disabled,
+      onMouseDown: (e) => e.preventDefault(),
+      onClick,
+      children
+    }
+  );
+}
+function DocumentToolbar(props) {
+  const { editor, editable, exportFormats, canSave, saveState, onExport, onCopy, onSave } = props;
+  const [linkOpen, setLinkOpen] = (0, import_react9.useState)(false);
+  const [linkValue, setLinkValue] = (0, import_react9.useState)("");
+  const s = (0, import_react8.useEditorState)({
+    editor,
+    selector: ({ editor: ed }) => ed ? {
+      bold: ed.isActive("bold"),
+      italic: ed.isActive("italic"),
+      underline: ed.isActive("underline"),
+      strike: ed.isActive("strike"),
+      bullet: ed.isActive("bulletList"),
+      ordered: ed.isActive("orderedList"),
+      quote: ed.isActive("blockquote"),
+      link: ed.isActive("link"),
+      linkHref: ed.getAttributes("link").href ?? "",
+      h1: ed.isActive("heading", { level: 1 }),
+      h2: ed.isActive("heading", { level: 2 }),
+      h3: ed.isActive("heading", { level: 3 }),
+      left: ed.isActive({ textAlign: "left" }),
+      center: ed.isActive({ textAlign: "center" }),
+      right: ed.isActive({ textAlign: "right" }),
+      justify: ed.isActive({ textAlign: "justify" }),
+      inTable: ed.isActive("table"),
+      canUndo: ed.can().undo(),
+      canRedo: ed.can().redo()
+    } : null
+  });
+  const run = () => editor?.chain().focus();
+  const off = !editor || !editable;
+  const heading = s?.h1 ? "1" : s?.h2 ? "2" : s?.h3 ? "3" : "p";
+  const openLink = () => {
+    setLinkValue(s?.linkHref ?? "");
+    setLinkOpen(true);
+  };
+  const applyLink = () => {
+    const href = sanitizeHref(linkValue);
+    if (href) run()?.extendMarkRange("link").setLink({ href }).run();
+    setLinkOpen(false);
+  };
+  const removeLink = () => {
+    run()?.extendMarkRange("link").unsetLink().run();
+    setLinkOpen(false);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__toolbar", role: "toolbar", "aria-label": "Document formatting", children: [
+    editable ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Undo", disabled: off || !s?.canUndo, onClick: () => run()?.undo().run(), children: "\u21B6" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Redo", disabled: off || !s?.canRedo, onClick: () => run()?.redo().run(), children: "\u21B7" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: "june-doc__group", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+        "select",
+        {
+          className: "june-doc__select",
+          "aria-label": "Text style",
+          disabled: off,
+          value: heading,
+          onChange: (e) => {
+            const v = e.target.value;
+            if (v === "p") run()?.setParagraph().run();
+            else run()?.toggleHeading({ level: Number(v) }).run();
+          },
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "p", children: "Paragraph" }),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "1", children: "Heading 1" }),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "2", children: "Heading 2" }),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "3", children: "Heading 3" })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Bold", toggle: true, active: s?.bold, disabled: off, onClick: () => run()?.toggleBold().run(), children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("b", { children: "B" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Italic", toggle: true, active: s?.italic, disabled: off, onClick: () => run()?.toggleItalic().run(), children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("i", { children: "I" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Underline", toggle: true, active: s?.underline, disabled: off, onClick: () => run()?.toggleUnderline().run(), children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("u", { children: "U" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Strikethrough", toggle: true, active: s?.strike, disabled: off, onClick: () => run()?.toggleStrike().run(), children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("s", { children: "S" }) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Bullet list", toggle: true, active: s?.bullet, disabled: off, onClick: () => run()?.toggleBulletList().run(), children: "\u2022 List" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Numbered list", toggle: true, active: s?.ordered, disabled: off, onClick: () => run()?.toggleOrderedList().run(), children: "1. List" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Blockquote", toggle: true, active: s?.quote, disabled: off, onClick: () => run()?.toggleBlockquote().run(), children: "Quote" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Link", toggle: true, active: s?.link, disabled: off, onClick: openLink, children: "Link" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Align left", toggle: true, active: s?.left, disabled: off, onClick: () => run()?.setTextAlign("left").run(), children: "L" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Align center", toggle: true, active: s?.center, disabled: off, onClick: () => run()?.setTextAlign("center").run(), children: "C" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Align right", toggle: true, active: s?.right, disabled: off, onClick: () => run()?.setTextAlign("right").run(), children: "R" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Justify", toggle: true, active: s?.justify, disabled: off, onClick: () => run()?.setTextAlign("justify").run(), children: "J" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Insert table", disabled: off, onClick: () => run()?.insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run(), children: "Table" }),
+        s?.inTable ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Add row below", disabled: off, onClick: () => run()?.addRowAfter().run(), children: "+Row" }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Add column right", disabled: off, onClick: () => run()?.addColumnAfter().run(), children: "+Col" }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Delete row", disabled: off, onClick: () => run()?.deleteRow().run(), children: "\u2212Row" }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Delete column", disabled: off, onClick: () => run()?.deleteColumn().run(), children: "\u2212Col" }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Delete table", disabled: off, onClick: () => run()?.deleteTable().run(), children: "Del table" })
+        ] }) : null
+      ] })
+    ] }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__group june-doc__group--end", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Copy document", onClick: onCopy, children: "Copy" }),
+      exportFormats.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+        "select",
+        {
+          className: "june-doc__select",
+          "aria-label": "Export document",
+          value: "",
+          onChange: (e) => e.target.value && onExport(e.target.value),
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "", children: "Export\u2026" }),
+            exportFormats.map((f) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: f, children: FORMAT_LABELS[f] ?? f }, f))
+          ]
+        }
+      ) : null,
+      canSave ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Btn, { label: "Save", disabled: saveState === "saving" || saveState === "saved" || saveState === "idle", onClick: onSave, children: "Save" }) : null
+    ] }),
+    linkOpen ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "june-doc__linkbar", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        "input",
+        {
+          "aria-label": "Link address",
+          className: "june-doc__input",
+          placeholder: "https://example.com",
+          value: linkValue,
+          autoFocus: true,
+          onChange: (e) => setLinkValue(e.target.value),
+          onKeyDown: (e) => {
+            if (e.key === "Enter") applyLink();
+            if (e.key === "Escape") setLinkOpen(false);
+          }
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", className: "june-doc__btn", onClick: applyLink, children: "Apply" }),
+      s?.link ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", className: "june-doc__btn", onClick: removeLink, children: "Remove" }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("button", { type: "button", className: "june-doc__btn", onClick: () => setLinkOpen(false), children: "Cancel" })
+    ] }) : null
+  ] });
+}
+
+// src/components/document-editor/document-types.ts
+var ALL_EXPORT_FORMATS = [
+  "html",
+  "markdown",
+  "txt",
+  "docx",
+  "pdf"
+];
+
+// src/components/document-editor/document-editor.tsx
+init_document_utils();
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var snapshotOf = (r) => ({
+  documentId: r.id,
+  title: r.title,
+  documentType: r.documentType,
+  status: r.status,
+  json: r.json
+});
+var SAVE_LABEL = {
+  idle: "",
+  dirty: "Unsaved changes",
+  saving: "Saving\u2026",
+  saved: "Saved",
+  error: "Save failed"
+};
+function DocumentEditorImpl(props) {
+  const {
+    documentId,
+    title: titleProp = "Untitled document",
+    content,
+    documentType,
+    status = "draft",
+    editable = true,
+    exportFormats,
+    theme = "auto",
+    className
+  } = props;
+  const ctxOptions = useDocumentOptions();
+  const options = (0, import_react11.useMemo)(() => ({ ...ctxOptions, ...props.options }), [ctxOptions, props.options]);
+  const optionsRef = (0, import_react11.useRef)(options);
+  optionsRef.current = options;
+  const store = (0, import_react11.useMemo)(() => options.store ?? getDefaultDocumentStore(), [options.store]);
+  const instanceId = (0, import_react11.useId)();
+  const { theme: contextTheme } = useJuneTheme();
+  const resolvedTheme = theme === "auto" ? contextTheme : theme;
+  const contentKey = typeof content === "string" ? content : content ? JSON.stringify(content) : "";
+  const parsed = (0, import_react11.useMemo)(() => {
+    if (!contentKey) return { json: null, error: null };
+    try {
+      return { json: parseDocumentContent(contentKey), error: null };
+    } catch (e) {
+      return { json: null, error: toJuneError(e, "DOCUMENT_ERROR") };
+    }
+  }, [contentKey]);
+  (0, import_react11.useEffect)(() => {
+    if (parsed.error) optionsRef.current.onError?.(parsed.error);
+  }, [parsed.error]);
+  const title = useDocumentValue(store, documentId, (r) => r?.title ?? titleProp);
+  const pending = useDocumentValue(store, documentId, (r) => r?.pending ?? null);
+  const words = useDocumentValue(store, documentId, (r) => r ? wordCountOf(r.json) : 0);
+  const recordStatus = useDocumentValue(store, documentId, (r) => r?.status ?? status);
+  const [saveState, setSaveState] = (0, import_react11.useState)("idle");
+  const [notice, setNotice] = (0, import_react11.useState)(null);
+  const lastSavedKey = (0, import_react11.useRef)("");
+  const seenRevision = (0, import_react11.useRef)(store.get(documentId)?.revision ?? 0);
+  const readyRef = (0, import_react11.useRef)(false);
+  const flash = (0, import_react11.useCallback)((message) => {
+    setNotice(message);
+  }, []);
+  (0, import_react11.useEffect)(() => {
+    if (!notice) return;
+    const t = setTimeout(() => setNotice(null), 3e3);
+    return () => clearTimeout(t);
+  }, [notice]);
+  const emitChange = (0, import_react11.useCallback)(
+    (source) => {
+      const record = store.get(documentId);
+      if (record) optionsRef.current.onDocumentChange?.({ ...snapshotOf(record), source });
+    },
+    [store, documentId]
+  );
+  const saveRef = (0, import_react11.useRef)(async () => {
+  });
+  const autosave = (0, import_react11.useMemo)(() => {
+    const delay = options.autosaveDelay ?? 1500;
+    return delay > 0 ? debounce(() => void saveRef.current(), delay) : null;
+  }, [options.autosaveDelay]);
+  (0, import_react11.useEffect)(() => () => autosave?.flush(), [autosave]);
+  saveRef.current = async () => {
+    const record = store.get(documentId);
+    const onSave = optionsRef.current.onSave;
+    if (!record || !onSave) return;
+    const key = JSON.stringify([record.title, docKey(record.json)]);
+    if (key === lastSavedKey.current) {
+      setSaveState("saved");
+      return;
+    }
+    setSaveState("saving");
+    try {
+      await onSave({
+        ...snapshotOf(record),
+        html: docToHtml(record.json),
+        markdown: docToMarkdown(record.json)
+      });
+      lastSavedKey.current = key;
+      const latest = store.get(documentId);
+      const latestKey = latest ? JSON.stringify([latest.title, docKey(latest.json)]) : key;
+      setSaveState(latestKey === key ? "saved" : "dirty");
+    } catch (error) {
+      setSaveState("error");
+      optionsRef.current.onError?.(toJuneError(error, "DOCUMENT_ERROR", "Saving the document failed"));
+    }
+  };
+  const markDirty = (0, import_react11.useCallback)(() => {
+    if (!optionsRef.current.onSave) return;
+    setSaveState("dirty");
+    autosave?.();
+  }, [autosave]);
+  const [initialJson] = (0, import_react11.useState)(() => store.get(documentId)?.json ?? parsed.json ?? emptyDoc());
+  const extensions = (0, import_react11.useMemo)(() => createDocumentExtensions(), []);
+  const onUpdateRef = (0, import_react11.useRef)(() => {
+  });
+  onUpdateRef.current = (json) => {
+    store.edit(documentId, json, instanceId);
+    emitChange("user");
+    markDirty();
+  };
+  const editor = (0, import_react10.useEditor)({
+    extensions,
+    content: initialJson,
+    editable,
+    immediatelyRender: false,
+    editorProps: {
+      attributes: {
+        class: "june-doc__prose",
+        role: "textbox",
+        "aria-multiline": "true",
+        "aria-label": "Document content"
+      }
+    },
+    onUpdate: ({ editor: ed }) => onUpdateRef.current(ed.getJSON())
+  });
+  (0, import_react11.useEffect)(() => {
+    editor?.setEditable(editable);
+  }, [editor, editable]);
+  (0, import_react11.useEffect)(() => {
+    if (!parsed.json) return;
+    const outcome = store.receive({
+      id: documentId,
+      title: titleProp,
+      json: parsed.json,
+      documentType,
+      status
+    });
+    if (outcome === "applied" || outcome === "merged") {
+      emitChange(outcome === "applied" ? "ai" : "merge");
+      markDirty();
+    } else if (outcome === "conflict") {
+      const record = store.get(documentId);
+      optionsRef.current.onConflict?.({
+        documentId,
+        title: record?.title ?? titleProp,
+        conflicts: record?.pending?.conflicts ?? 1
+      });
+    }
+  }, [store, documentId, titleProp, parsed.json, documentType, status, emitChange, markDirty]);
+  (0, import_react11.useEffect)(() => {
+    if (!editor) return;
+    const apply = () => {
+      const record = store.get(documentId);
+      if (!record || record.revision === seenRevision.current) return;
+      seenRevision.current = record.revision;
+      if (record.origin === instanceId) return;
+      const { from, to } = editor.state.selection;
+      editor.commands.setContent(record.json, { emitUpdate: false });
+      if (editor.isFocused) {
+        const size = editor.state.doc.content.size;
+        editor.commands.setTextSelection({ from: Math.min(from, size), to: Math.min(to, size) });
+      }
+    };
+    apply();
+    return store.subscribe(apply);
+  }, [editor, store, documentId, instanceId]);
+  (0, import_react11.useEffect)(() => {
+    if (!editor || readyRef.current) return;
+    const record = store.get(documentId);
+    if (!record) return;
+    readyRef.current = true;
+    lastSavedKey.current = JSON.stringify([record.title, docKey(record.json)]);
+    optionsRef.current.onDocumentReady?.(snapshotOf(record));
+  }, [editor, store, documentId, title]);
+  const handleTitle = (value) => {
+    store.setTitle(documentId, value);
+    emitChange("user");
+    markDirty();
+  };
+  const resolve = (choice) => {
+    store.resolve(documentId, choice);
+    if (choice !== "keep") {
+      emitChange(choice === "merge" ? "merge" : "resolve");
+      markDirty();
+    }
+  };
+  const handleExport = async (format) => {
+    const record = store.get(documentId);
+    if (!record) return;
+    try {
+      const result = await exportDocument(format, {
+        documentId,
+        title: record.title,
+        json: record.json
+        // always the latest editor content
+      });
+      if (result.blob) downloadResult(result);
+      optionsRef.current.onExport?.({ documentId, format, ...result });
+    } catch (error) {
+      optionsRef.current.onError?.(toJuneError(error, "EXPORT_ERROR"));
+      flash("Export failed");
+    }
+  };
+  const handleCopy = async () => {
+    const record = store.get(documentId);
+    if (!record) return;
+    flash(await copyDocumentToClipboard({ title: record.title, json: record.json }) ? "Copied" : "Copy failed");
+  };
+  const formats = (exportFormats ?? [...ALL_EXPORT_FORMATS]).filter((f) => listDocumentExporters().includes(f));
+  if (parsed.error && !store.get(documentId)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "june-doc june-doc--error", "data-theme": resolvedTheme, role: "alert", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { className: "june-doc__draft-text", children: "This document could not be displayed." }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("details", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("summary", { children: "Show raw content" }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("pre", { className: "june-doc__raw", children: contentKey })
+      ] })
+    ] });
+  }
+  if (!editor) return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DocumentDraft, { title, state: "loading" });
+  const isDraft = recordStatus === "draft";
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+    "div",
+    {
+      className: className ? `june-doc ${className}` : "june-doc",
+      "data-theme": resolvedTheme,
+      "data-status": recordStatus,
+      onKeyDown: (e) => {
+        if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "s" && options.onSave) {
+          e.preventDefault();
+          void saveRef.current();
+        }
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "june-doc__header", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DocumentTitle, { value: title, disabled: !editable, onChange: handleTitle }),
+          isDraft ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "june-doc__badge", children: "AI draft" }) : null
+        ] }),
+        pending ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "june-doc__banner", role: "status", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { children: [
+            "The assistant suggested changes that overlap your edits (",
+            pending.conflicts,
+            " ",
+            pending.conflicts === 1 ? "section" : "sections",
+            ")."
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "june-doc__banner-actions", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", className: "june-doc__btn", onClick: () => resolve("merge"), children: "Merge, keep my edits" }),
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", className: "june-doc__btn", onClick: () => resolve("replace"), children: "Use AI version" }),
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("button", { type: "button", className: "june-doc__btn", onClick: () => resolve("keep"), children: "Keep mine" })
+          ] })
+        ] }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          DocumentToolbar,
+          {
+            editor,
+            editable,
+            exportFormats: formats,
+            canSave: !!options.onSave,
+            saveState,
+            onExport: (f) => void handleExport(f),
+            onCopy: () => void handleCopy(),
+            onSave: () => void saveRef.current()
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DocumentContent, { editor }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "june-doc__footer", "aria-live": "polite", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { children: [
+            words,
+            " words"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { children: notice ?? SAVE_LABEL[saveState] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/document-editor/document-component.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var DOCUMENT_COMPONENT_DESCRIPTION = 'An editable document. DocumentEditor(documentId, title, content, documentType?, status?, editable?, exportFormats?). "content" is the full document body as one Markdown string. Reuse documentId when revising the same document. Use it only when the user asks to create or revise a document.';
+var documentProps = import_v4.z.object({
+  documentId: import_v4.z.string().describe("Stable id. Reuse it when revising the same document."),
+  title: import_v4.z.string().describe("Document title. Do not repeat it as a heading in content."),
+  content: import_v4.z.string().describe("The whole document body as Markdown."),
+  documentType: import_v4.z.string().optional().describe("Kind of document, such as proposal, contract or invoice."),
+  status: import_v4.z.string().optional().describe('Use "draft" for generated documents.'),
+  editable: import_v4.z.boolean().optional().describe("Whether the user can edit. Defaults to true."),
+  exportFormats: import_v4.z.array(import_v4.z.string()).optional().describe("Export formats to offer, such as html, markdown, docx.")
+});
+function DocumentEditor(props) {
+  const { isStreaming } = useJuneRuntime();
+  if (props.generating || isStreaming) {
+    return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(DocumentDraft, { title: props.title, state: "drafting" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(DocumentEditorImpl, { ...props });
+}
+function OpenUIDocument({ props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    DocumentEditor,
+    {
+      documentId: props.documentId,
+      title: props.title,
+      content: props.content,
+      documentType: props.documentType,
+      status: props.status,
+      editable: props.editable,
+      exportFormats: props.exportFormats
+    }
+  );
+}
+var JuneDocumentEditorComponent = (0, import_react_lang3.defineComponent)({
+  name: "DocumentEditor",
+  description: DOCUMENT_COMPONENT_DESCRIPTION,
+  props: documentProps,
+  component: OpenUIDocument
+});
+function withDocumentEditor(library) {
+  return library.extend({ components: { add: [JuneDocumentEditorComponent] } });
+}
+
+// src/components/document-editor/document-instructions.ts
+var DEFAULT_TYPES = [
+  "proposal",
+  "report",
+  "email",
+  "letter",
+  "invoice",
+  "contract",
+  "NDA",
+  "memo",
+  "meeting notes"
+];
+function getDocumentEditorRules(options = {}) {
+  const name = options.componentName ?? "DocumentEditor";
+  const types = (options.documentTypes ?? DEFAULT_TYPES).join(", ");
+  return [
+    `WHEN TO USE ${name}: use it only when the user asks you to create, draft, write, prepare, generate or revise an editable document (${types}, or similar). Put the finished document inside ${name}.`,
+    `WHEN NOT TO USE ${name}: for explanations ("explain what an NDA is"), factual answers, comparisons, brainstorming and general questions, answer with normal text and the other components. Never open ${name} for those.`,
+    `${name}(documentId, title, content, documentType?, status?, editable?, exportFormats?): "content" is the whole document body as Markdown inside ONE double-quoted string. Write line breaks as \\n and escape double quotes as \\". Supported Markdown: headings (#, ##, ###), paragraphs, **bold**, *italic*, lists, > quotes, [links](https://...), and tables.`,
+    `Do not repeat the title as a heading inside "content"; the title is shown separately. Structure the document with headings, short paragraphs and tables where useful. Keep a professional tone.`,
+    `EDITING: when the user asks to change an existing document (add a section, rewrite a part, change the title), write ${name} again with the SAME documentId and the COMPLETE updated content, starting from the current document text you were given. Copy every unchanged section exactly as it was. Change only what was requested. The app merges your version with the user's own edits.`,
+    `If the user asks for a document but leaves out details, write the document anyway and use clear placeholders such as [CLIENT NAME], [DATE], [AMOUNT]. Do not stop to ask unless the request is impossible to interpret.`,
+    `Never invent legal, financial or business facts, prices, dates, names or figures. Use placeholders instead. Set status to "draft" for generated documents, and for legal or financial documents say in one short sentence outside the component that the document is a draft that should be reviewed by a professional.`,
+    `You may add one short sentence before or after the component. Do not repeat the document text outside the component.`,
+    ...options.extraRules ?? []
+  ];
+}
+function getDocumentEditorInstructions(options = {}) {
+  const rules = getDocumentEditorRules(options);
+  return ["Document drafting:", ...rules.map((rule, i) => `${i + 1}. ${rule}`)].join("\n");
+}
+var EXAMPLE_NEW = 'root = Stack([doc])\ndoc = DocumentEditor("business-proposal", "Business Proposal", "## Executive Summary\\n\\nThis proposal outlines [SERVICE] for [CLIENT NAME].\\n\\n## Scope of Work\\n\\n- Discovery\\n- Delivery\\n\\n## Pricing\\n\\n| Item | Cost |\\n| --- | --- |\\n| Discovery | [AMOUNT] |", "proposal", "draft")';
+var EXAMPLE_EDIT = 'root = Stack([doc])\ndoc = DocumentEditor("business-proposal", "Business Proposal", "## Executive Summary\\n\\nThis proposal outlines [SERVICE] for [CLIENT NAME].\\n\\n## Scope of Work\\n\\n- Discovery\\n- Delivery\\n\\n## Pricing\\n\\n| Item | Cost |\\n| --- | --- |\\n| Discovery | [AMOUNT] |\\n| Delivery | [AMOUNT] |", "proposal", "draft")';
+function documentPromptOptions(options = {}) {
+  return {
+    additionalRules: getDocumentEditorRules(options),
+    examples: [EXAMPLE_NEW, EXAMPLE_EDIT]
+  };
+}
+
+// src/components/document-editor/document-agent.ts
+var attr = (value) => value.replace(/"/g, "&quot;");
+async function serializeDocumentsForAgent(options = {}) {
+  const store = options.store ?? getDefaultDocumentStore();
+  const { docToMarkdown: docToMarkdown2 } = await Promise.resolve().then(() => (init_document_engine(), document_engine_exports));
+  return store.list().filter((r) => !options.ids || options.ids.includes(r.id)).map(
+    (r) => `<document id="${attr(r.id)}" title="${attr(r.title)}"${r.documentType ? ` type="${attr(r.documentType)}"` : ""}>
+${docToMarkdown2(r.json)}
+</document>`
+  ).join("\n\n");
+}
+
+// src/components/june-library.ts
+var import_react_ui = require("@openuidev/react-ui");
+var juneLibrary = withDocumentEditor(import_react_ui.openuiLibrary);
+
+// src/core/JuneUI.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function JuneUI({ library = juneLibrary, ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(JuneRenderer, { library, ...props });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALL_EXPORT_FORMATS,
+  DocumentEditor,
+  JuneDocumentContext,
+  JuneDocumentEditorComponent,
   JuneError,
   JuneErrorBoundary,
   JuneRenderer,
+  JuneRuntimeContext,
   JuneThemeProvider,
   JuneUI,
   consumeStream,
+  copyDocumentToClipboard,
   createActionHandler,
+  createDocumentStore,
   createJuneLibrary,
   darkTheme,
   defaultParseActionEvent,
   defineJuneAction,
   defineJuneComponent,
+  documentPromptOptions,
+  downloadResult,
+  exportDocument,
   fetchStream,
+  getDefaultDocumentStore,
+  getDocumentEditorInstructions,
+  getDocumentEditorRules,
   isJuneError,
   jsonFieldExtractor,
+  juneLibrary,
   lightTheme,
+  listDocumentExporters,
+  mergeDocuments,
+  registerDocumentExporter,
   runAction,
+  serializeDocumentsForAgent,
   sseToText,
   toJuneError,
+  useDocumentOptions,
+  useJuneRuntime,
   useJuneStream,
   useJuneTheme,
-  useResolvedTheme
+  useResolvedTheme,
+  withDocumentEditor
 });