@agent-native/core 0.37.3 → 0.38.0

package/dist/client/rich-markdown-editor/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/extensions.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Extension, Node, Mark } from \"@tiptap/core\";\nimport StarterKit from \"@tiptap/starter-kit\";\nimport type { StarterKitOptions } from \"@tiptap/starter-kit\";\nimport Placeholder from \"@tiptap/extension-placeholder\";\nimport Link from \"@tiptap/extension-link\";\nimport TaskList from \"@tiptap/extension-task-list\";\nimport TaskItem from \"@tiptap/extension-task-item\";\nimport { Table } from \"@tiptap/extension-table\";\nimport { TableRow } from \"@tiptap/extension-table-row\";\nimport { TableCell } from \"@tiptap/extension-table-cell\";\nimport { TableHeader } from \"@tiptap/extension-table-header\";\nimport { Markdown } from \"tiptap-markdown\";\nimport { CodeBlockLowlight } from \"@tiptap/extension-code-block-lowlight\";\nimport { createLowlight } from \"lowlight\";\nimport bash from \"highlight.js/lib/languages/bash\";\nimport css from \"highlight.js/lib/languages/css\";\nimport javascript from \"highlight.js/lib/languages/javascript\";\nimport json from \"highlight.js/lib/languages/json\";\nimport markdown from \"highlight.js/lib/languages/markdown\";\nimport python from \"highlight.js/lib/languages/python\";\nimport sql from \"highlight.js/lib/languages/sql\";\nimport typescript from \"highlight.js/lib/languages/typescript\";\nimport xml from \"highlight.js/lib/languages/xml\";\nimport yaml from \"highlight.js/lib/languages/yaml\";\nimport Collaboration from \"@tiptap/extension-collaboration\";\nimport CollaborationCaret from \"@tiptap/extension-collaboration-caret\";\n\n/**\n * Shared lowlight instance for the editor's syntax-highlighted code blocks. A\n * curated grammar set (aliases like ts/tsx, js/jsx, html, sh, py, yml, md come\n * for free from each grammar) keeps the editor bundle lean while matching the\n * languages the read-side Shiki surfaces (`code-tabs`) support. highlight.js is\n * synchronous, which is what a live ProseMirror editor needs — Shiki is async\n * and only used for read-only render paths.\n */\nconst codeLowlight = createLowlight({\n  bash,\n  css,\n  javascript,\n  json,\n  markdown,\n  python,\n  sql,\n  typescript,\n  xml,\n  yaml,\n});\nimport type { Doc as YDoc } from \"yjs\";\nimport type { Awareness } from \"y-protocols/awareness\";\nimport { createImageExtension, type ImageUploadFn } from \"./ImageExtension.js\";\n\n/**\n * Markdown dialect the editor parses/serializes.\n *\n * - `gfm` — GitHub-Flavored Markdown. No raw HTML passthrough. The byte-stable\n *   serialization used by Plans (see RichMarkdownEditor.roundtrip.spec.ts).\n * - `nfm` — the Notion-Flavored Markdown superset used by the Content editor,\n *   which opts into inline HTML so Notion-specific blocks round-trip.\n */\nexport type RichMarkdownDialect = \"gfm\" | \"nfm\";\n\n/**\n * Editor preset. Schema-neutral today (both presets share the base schema),\n * but threaded through so an app can branch schema/behavior per preset without\n * a new factory. The collab/markdown wiring is preset-independent.\n */\nexport type RichMarkdownEditorPreset = \"plan\" | \"content\";\n\n/** User info used to label this client's collaborative cursor. */\nexport interface RichMarkdownCollabUser {\n  name: string;\n  color: string;\n  email?: string;\n}\n\n/** Optional collaborative-editing inputs for the shared editor. */\nexport interface SharedEditorCollab {\n  /**\n   * Yjs document for collaborative editing. When present the editor binds the\n   * shared {@link Collaboration} (+ {@link CollaborationCaret} when awareness\n   * is set) extensions and StarterKit's built-in undo/redo is disabled (Yjs\n   * owns history). When absent the editor is a controlled `value`/`onChange`\n   * editor.\n   */\n  ydoc?: YDoc | null;\n  /** Shared awareness instance for live multi-user cursors. */\n  awareness?: Awareness | null;\n  /** Current user info for the collaborative cursor label. */\n  user?: RichMarkdownCollabUser | null;\n}\n\n/** Toggle the optional base extensions on/off per app. All default to `true`. */\nexport interface SharedEditorFeatures {\n  /** GFM pipe tables (Table + TableRow + TableHeader + TableCell). */\n  tables?: boolean;\n  /** Task / checklist lists (TaskList + TaskItem). */\n  tasks?: boolean;\n  /** Inline links (the `Link` mark). When off, links fall back to plain text. */\n  link?: boolean;\n  /** Fenced code blocks. Disabling lets an app inject its own code-block node. */\n  codeBlock?: boolean;\n  /**\n   * The built-in {@link Placeholder} extension. Default `true`. Apps that need a\n   * bespoke placeholder resolver (per-node-type labels, ancestor-aware text)\n   * disable this and supply their own Placeholder via `extraExtensions`.\n   */\n  placeholder?: boolean;\n  /**\n   * The built-in dialect-keyed {@link Markdown} serializer. Default `true`.\n   * Apps with a custom serializer (e.g. Content's NFM converter, which does NOT\n   * round-trip through tiptap-markdown's storage) disable this and own the\n   * serialize/parse pipeline themselves. The Markdown extension is still added\n   * so paste/clipboard transforms work — disable it only when supplying your own\n   * Markdown configuration via the {@link CreateSharedEditorExtensionsOptions.markdown}\n   * option instead.\n   */\n  markdown?: boolean;\n  /**\n   * The shared block-level image node (`@tiptap/extension-image`). Default\n   * `false` so existing embedders are unchanged. When `true`, images\n   * serialize to GFM `![alt](src)` (source-syncable) and — when an\n   * {@link CreateSharedEditorExtensionsOptions.onImageUpload} function is\n   * supplied — paste / drop of local image files uploads through it. Content\n   * leaves this off and injects its own richer image node via\n   * `extraExtensions`, so the two never collide.\n   */\n  image?: boolean;\n}\n\nexport interface CreateSharedEditorExtensionsOptions {\n  /** Markdown dialect; selects the keyed {@link Markdown} config. */\n  dialect?: RichMarkdownDialect;\n  /** Preset hook (schema-neutral today). */\n  preset?: RichMarkdownEditorPreset;\n  /** Empty-block placeholder text (headings get their own labels). */\n  placeholder?: string;\n  /** Toggle individual base extensions. */\n  features?: SharedEditorFeatures;\n  /**\n   * Extra StarterKit options merged over the shared defaults. Lets an app turn\n   * off StarterKit nodes it replaces (Content swaps in its own paragraph /\n   * blockquote / code block) or pass a custom dropcursor, while still sharing\n   * the rest of the StarterKit base + the collab undo/redo gating. The shared\n   * defaults (`heading` levels 1-4, `link: false`, the default dropcursor, and\n   * `undoRedo: false` in collab mode) are applied first and can be overridden\n   * key-by-key here.\n   */\n  starterKit?: Partial<StarterKitOptions>;\n  /**\n   * Custom {@link Markdown} configuration. Replaces the dialect-keyed config from\n   * {@link MARKDOWN_DIALECT_CONFIG} when provided. Only used when\n   * `features.markdown !== false`; apps that own the whole markdown pipeline (no\n   * tiptap-markdown serialization at all) should set `features.markdown: false`\n   * and add their own configured Markdown extension via `extraExtensions`.\n   */\n  markdown?: Parameters<typeof Markdown.configure>[0];\n  /**\n   * App-specific extensions (Notion nodes, media, drag handles, comment\n   * anchors, etc.) appended LAST so they bind over the shared base schema and\n   * the optional Collaboration extensions still mount after them.\n   */\n  extraExtensions?: Array<Extension | Node | Mark>;\n  /** Optional collaborative-editing wiring. */\n  collab?: SharedEditorCollab | null;\n  /**\n   * Injectable image uploader for the shared image block. Only used when\n   * `features.image` is on. Turns a picked / pasted / dropped image File into a\n   * hosted `{ src, alt? }`. Plans pass `uploadEditorImage` (the framework\n   * `upload-image` action). When omitted, the image block still renders and\n   * round-trips `![alt](src)` markdown but cannot ingest local files.\n   */\n  onImageUpload?: ImageUploadFn | null;\n}\n\n/**\n * tiptap-markdown configuration, keyed by dialect. This is the single source of\n * truth for how each dialect parses/serializes markdown so the editor component\n * and the round-trip fidelity test can never drift apart.\n *\n * tiptap-markdown re-serializes the whole document on every edit, so the goal\n * for GFM is `serialize(parse(markdown)) === markdown` for the markdown plans\n * actually contain. We deliberately keep tiptap-markdown's own defaults\n * (`bulletListMarker: \"-\"`, `tightLists: true`, `linkify: false`,\n * `breaks: false`) because those produce the most byte-stable GFM. See\n * RichMarkdownEditor.roundtrip.spec.ts for the pinned corpus.\n *\n * NFM (Content) opts into inline HTML passthrough (`html: true`) so\n * Notion-specific blocks survive a markdown round-trip; the rest mirrors the\n * Content editor's existing `Markdown.configure` call.\n */\nexport const MARKDOWN_DIALECT_CONFIG: Record<\n  RichMarkdownDialect,\n  Parameters<typeof Markdown.configure>[0]\n> = {\n  gfm: {\n    // GFM plans are the common case and must never gain raw HTML as a second\n    // representation.\n    html: false,\n    // Keep tiptap-markdown's defaults that minimise first-edit normalisation\n    // churn (see roundtrip spec). Listed explicitly so the contract is\n    // self-documenting rather than relying on the package defaults.\n    bulletListMarker: \"-\",\n    tightLists: true,\n    linkify: false,\n    breaks: false,\n    transformPastedText: true,\n    transformCopiedText: true,\n  },\n  nfm: {\n    // NFM is a superset that allows inline HTML so Notion blocks round-trip.\n    html: true,\n    transformPastedText: true,\n    transformCopiedText: true,\n  },\n};\n\nconst DEFAULT_FEATURES: Required<SharedEditorFeatures> = {\n  tables: true,\n  tasks: true,\n  link: true,\n  codeBlock: true,\n  placeholder: true,\n  markdown: true,\n  // Off by default: only Plans opt in today. Content injects its own richer\n  // image node via `extraExtensions` and must not get a second `image` node.\n  image: false,\n};\n\n/**\n * The ONE editor extension factory shared by every embedder (Plans today,\n * Content next). It assembles the base Tiptap schema (StarterKit + Placeholder\n * + Link + tasks + tables + code block), the dialect-keyed {@link Markdown}\n * serializer, the optional Collaboration stack, and finally any app-specific\n * `extraExtensions`.\n *\n * Ordering matters:\n *   1. Base schema (StarterKit first so its nodes/marks register; `starterKit`\n *      overrides let an app disable replaced nodes / swap the dropcursor).\n *   2. dialect-keyed Markdown serializer (suppressible via `features.markdown`\n *      for apps that own the whole serialize/parse pipeline, e.g. Content's NFM).\n *   3. `extraExtensions` (Notion/media/etc.) — appended before Collaboration so\n *      apps can extend the schema and Collaboration still binds over the full\n *      schema.\n *   4. Collaboration (+ CollaborationCaret) LAST so they bind over everything.\n *\n * Content (the NFM editor) drives this factory with `features.placeholder` and\n * `features.markdown` off, `features.tasks/tables/link` off where it ships its\n * own, a `starterKit` override disabling paragraph/blockquote/codeBlock, and all\n * Notion/media/fidelity nodes + its own Markdown(NFM)/Placeholder via\n * `extraExtensions` — so it shares the StarterKit base + the collab wiring while\n * owning its byte-identical NFM serializer.\n */\nexport function createSharedEditorExtensions({\n  dialect = \"gfm\",\n  // `preset` is accepted and forwarded for future preset-specific schema\n  // branches; it is currently schema-neutral.\n  preset: _preset = \"plan\",\n  placeholder = \"Type '/' for commands...\",\n  features,\n  starterKit,\n  markdown,\n  extraExtensions = [],\n  collab = null,\n  onImageUpload = null,\n}: CreateSharedEditorExtensionsOptions = {}): Array<Extension | Node | Mark> {\n  const feat = { ...DEFAULT_FEATURES, ...(features ?? {}) };\n  const ydoc = collab?.ydoc ?? null;\n  const awareness = collab?.awareness ?? null;\n  const user = collab?.user ?? null;\n\n  const exts: Array<Extension | Node | Mark> = [\n    StarterKit.configure({\n      heading: { levels: [1, 2, 3, 4] },\n      link: false,\n      // StarterKit's plain code block is always disabled; when enabled we add the\n      // syntax-highlighting `CodeBlockLowlight` (same `codeBlock` node) below.\n      codeBlock: false,\n      dropcursor: { color: \"hsl(var(--ring))\", width: 2 },\n      // Yjs owns undo/redo when Collaboration is active; the StarterKit history\n      // plugin and the CRDT cannot both track undo without corrupting state.\n      ...(ydoc ? { undoRedo: false } : {}),\n      // App overrides last so embedders can disable replaced nodes (paragraph,\n      // blockquote, code block) or swap the dropcursor while keeping the shared\n      // base + the collab undo/redo gating above.\n      ...(starterKit ?? {}),\n    }),\n  ];\n\n  // Syntax-highlighted code block (replaces StarterKit's plain one) only when the\n  // embedder opts in via `features.codeBlock`. Content disables it and ships its\n  // own code node, so this affects Plans (and future opt-in apps) alone.\n  if (feat.codeBlock) {\n    exts.push(\n      CodeBlockLowlight.configure({\n        lowlight: codeLowlight,\n        defaultLanguage: null,\n      }),\n    );\n  }\n\n  if (feat.placeholder) {\n    exts.push(\n      Placeholder.configure({\n        placeholder: ({ node }) => {\n          if (node.type.name === \"heading\") {\n            const level = node.attrs.level;\n            if (level === 1) return \"Heading 1\";\n            if (level === 2) return \"Heading 2\";\n            if (level === 3) return \"Heading 3\";\n            return \"Heading 4\";\n          }\n          return placeholder;\n        },\n        showOnlyWhenEditable: true,\n        showOnlyCurrent: true,\n      }),\n    );\n  }\n\n  if (feat.link) {\n    exts.push(\n      Link.configure({\n        openOnClick: false,\n        HTMLAttributes: { class: \"an-rich-md-link\" },\n      }),\n    );\n  }\n\n  if (feat.tasks) {\n    exts.push(\n      TaskList.configure({\n        HTMLAttributes: { class: \"an-rich-md-task-list\" },\n      }),\n      TaskItem.configure({ nested: true }),\n    );\n  }\n\n  if (feat.tables) {\n    exts.push(\n      Table.configure({\n        resizable: false,\n        HTMLAttributes: { class: \"an-rich-md-table\" },\n      }),\n      TableRow,\n      TableHeader,\n      TableCell,\n    );\n  }\n\n  if (feat.markdown) {\n    exts.push(Markdown.configure(markdown ?? MARKDOWN_DIALECT_CONFIG[dialect]));\n  }\n\n  // Shared block-level image node. The node is named `image`, so when\n  // `features.markdown` is on, tiptap-markdown serializes it through its\n  // built-in `defaultMarkdownSerializer.nodes.image` fallback → `![alt](src)`\n  // (no width-as-HTML override here, so GFM stays byte-stable and\n  // source-syncable). With an `onImageUpload` it accepts paste/drop uploads.\n  if (feat.image) {\n    exts.push(createImageExtension({ onImageUpload }));\n  }\n\n  // App-specific extensions (Notion/media/drag handles/comments). Appended\n  // before Collaboration so they can extend the schema and Collaboration binds\n  // over the full set.\n  if (extraExtensions.length > 0) {\n    exts.push(...extraExtensions);\n  }\n\n  // Collaborative editing via the shared Y.Doc. Markdown stays the canonical\n  // saved representation (onChange serializes it); the Y.Doc is transient live\n  // state only. Appended last so it binds over the configured schema above.\n  if (ydoc) {\n    exts.push(Collaboration.configure({ document: ydoc }));\n    // Live multi-user cursors. Only mounted alongside a Y.Doc so the standalone\n    // controlled editor (today's plan/content behavior) is untouched.\n    if (awareness) {\n      exts.push(\n        CollaborationCaret.configure({\n          provider: { awareness },\n          user: user ?? { name: \"Anonymous\", color: \"#999\" },\n        }),\n      );\n    }\n  }\n\n  return exts;\n}\n"]}

package/dist/client/rich-markdown-editor/index.d.ts

@@ -0,0 +1,9 @@
+export { createSharedEditorExtensions, MARKDOWN_DIALECT_CONFIG, type RichMarkdownDialect, type RichMarkdownEditorPreset, type RichMarkdownCollabUser, type SharedEditorCollab, type SharedEditorFeatures, type CreateSharedEditorExtensionsOptions, } from "./extensions.js";
+export { useCollabReconcile, getEditorMarkdown, type UseCollabReconcileOptions, type UseCollabReconcileResult, } from "./useCollabReconcile.js";
+export { SlashCommandMenu, DEFAULT_SLASH_COMMANDS, createImageSlashCommand, type SlashCommandItem, type SlashCommandMenuProps, } from "./SlashCommandMenu.js";
+export { SharedImage, createImageExtension, pickAndInsertImage, type ImageUploadFn, type SharedImageOptions, } from "./ImageExtension.js";
+export { uploadEditorImage } from "./uploadEditorImage.js";
+export { BubbleToolbar, buildDefaultBubbleItems, type BubbleToolbarItem, type BubbleToolbarProps, } from "./BubbleToolbar.js";
+export { SharedRichEditor, type SharedRichEditorProps, } from "./SharedRichEditor.js";
+export { RichMarkdownEditor, createRichMarkdownExtensions, type RichMarkdownEditorProps, type CreateRichMarkdownExtensionsOptions, } from "./RichMarkdownEditor.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/rich-markdown-editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,mCAAmC,GACzC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,mCAAmC,GACzC,MAAM,yBAAyB,CAAC"}

package/dist/client/rich-markdown-editor/index.js

@@ -0,0 +1,9 @@
+export { createSharedEditorExtensions, MARKDOWN_DIALECT_CONFIG, } from "./extensions.js";
+export { useCollabReconcile, getEditorMarkdown, } from "./useCollabReconcile.js";
+export { SlashCommandMenu, DEFAULT_SLASH_COMMANDS, createImageSlashCommand, } from "./SlashCommandMenu.js";
+export { SharedImage, createImageExtension, pickAndInsertImage, } from "./ImageExtension.js";
+export { uploadEditorImage } from "./uploadEditorImage.js";
+export { BubbleToolbar, buildDefaultBubbleItems, } from "./BubbleToolbar.js";
+export { SharedRichEditor, } from "./SharedRichEditor.js";
+export { RichMarkdownEditor, createRichMarkdownExtensions, } from "./RichMarkdownEditor.js";
+//# sourceMappingURL=index.js.map

package/dist/client/rich-markdown-editor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,GAOxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,GAGlB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,GAGxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,kBAAkB,GAGnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,aAAa,EACb,uBAAuB,GAGxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,GAEjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAClB,4BAA4B,GAG7B,MAAM,yBAAyB,CAAC","sourcesContent":["export {\n  createSharedEditorExtensions,\n  MARKDOWN_DIALECT_CONFIG,\n  type RichMarkdownDialect,\n  type RichMarkdownEditorPreset,\n  type RichMarkdownCollabUser,\n  type SharedEditorCollab,\n  type SharedEditorFeatures,\n  type CreateSharedEditorExtensionsOptions,\n} from \"./extensions.js\";\nexport {\n  useCollabReconcile,\n  getEditorMarkdown,\n  type UseCollabReconcileOptions,\n  type UseCollabReconcileResult,\n} from \"./useCollabReconcile.js\";\nexport {\n  SlashCommandMenu,\n  DEFAULT_SLASH_COMMANDS,\n  createImageSlashCommand,\n  type SlashCommandItem,\n  type SlashCommandMenuProps,\n} from \"./SlashCommandMenu.js\";\nexport {\n  SharedImage,\n  createImageExtension,\n  pickAndInsertImage,\n  type ImageUploadFn,\n  type SharedImageOptions,\n} from \"./ImageExtension.js\";\nexport { uploadEditorImage } from \"./uploadEditorImage.js\";\nexport {\n  BubbleToolbar,\n  buildDefaultBubbleItems,\n  type BubbleToolbarItem,\n  type BubbleToolbarProps,\n} from \"./BubbleToolbar.js\";\nexport {\n  SharedRichEditor,\n  type SharedRichEditorProps,\n} from \"./SharedRichEditor.js\";\nexport {\n  RichMarkdownEditor,\n  createRichMarkdownExtensions,\n  type RichMarkdownEditorProps,\n  type CreateRichMarkdownExtensionsOptions,\n} from \"./RichMarkdownEditor.js\";\n"]}

package/dist/client/rich-markdown-editor/uploadEditorImage.d.ts

@@ -0,0 +1,18 @@
+import type { ImageUploadFn } from "./ImageExtension.js";
+/**
+ * The shared editor's default image uploader: upload a picked / pasted /
+ * dropped image File through the framework `upload-image` action and return the
+ * hosted CDN URL.
+ *
+ * This is the {@link ImageUploadFn} embedders pass to the shared image block so
+ * any app gets a real uploading image block with zero per-app upload code. The
+ * action re-hosts the bytes on the configured provider (Builder.io by default),
+ * is session-scoped, and returns a stable `![alt](url)` source — so a plan's
+ * inserted image autosaves as plain markdown through the existing
+ * `update-rich-text` path with no new persistence channel.
+ *
+ * @throws when the file cannot be read, the action returns no URL, or upload is
+ *   not configured (with the action's "connect Builder.io" guidance).
+ */
+export declare const uploadEditorImage: ImageUploadFn;
+//# sourceMappingURL=uploadEditorImage.d.ts.map

package/dist/client/rich-markdown-editor/uploadEditorImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadEditorImage.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/uploadEditorImage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgCzD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAsB/B,CAAC"}

package/dist/client/rich-markdown-editor/uploadEditorImage.js

@@ -0,0 +1,57 @@
+import { callAction } from "../use-action.js";
+/**
+ * Read a {@link File} as a base64 data URL (`data:image/...;base64,...`).
+ *
+ * The framework `upload-image` action accepts a data URL (`data`) or a remote
+ * URL (`url`) — not raw multipart — so a browser file-picker must convert the
+ * File to a data URL first.
+ */
+function fileToDataUrl(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = reader.result;
+            if (typeof result === "string") {
+                resolve(result);
+            }
+            else {
+                reject(new Error("Failed to read image file."));
+            }
+        };
+        reader.onerror = () => reject(reader.error ?? new Error("Failed to read image file."));
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * The shared editor's default image uploader: upload a picked / pasted /
+ * dropped image File through the framework `upload-image` action and return the
+ * hosted CDN URL.
+ *
+ * This is the {@link ImageUploadFn} embedders pass to the shared image block so
+ * any app gets a real uploading image block with zero per-app upload code. The
+ * action re-hosts the bytes on the configured provider (Builder.io by default),
+ * is session-scoped, and returns a stable `![alt](url)` source — so a plan's
+ * inserted image autosaves as plain markdown through the existing
+ * `update-rich-text` path with no new persistence channel.
+ *
+ * @throws when the file cannot be read, the action returns no URL, or upload is
+ *   not configured (with the action's "connect Builder.io" guidance).
+ */
+export const uploadEditorImage = async (file) => {
+    if (!file.type.startsWith("image/")) {
+        throw new Error("Only image files can be uploaded.");
+    }
+    const dataUrl = await fileToDataUrl(file);
+    const result = await callAction("upload-image", {
+        data: dataUrl,
+        filename: file.name || undefined,
+    });
+    if (!result || typeof result.url !== "string" || !result.url) {
+        throw new Error(result?.error ||
+            "Image upload failed. Connect Builder.io in Settings → File uploads, then try again.");
+    }
+    // Use the filename (sans extension) as a reasonable default alt text.
+    const alt = file.name ? file.name.replace(/\.[^./\\]+$/, "") : "";
+    return { src: result.url, alt };
+};
+//# sourceMappingURL=uploadEditorImage.js.map

package/dist/client/rich-markdown-editor/uploadEditorImage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadEditorImage.js","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/uploadEditorImage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;;;;GAMG;AACH,SAAS,aAAa,CAAC,IAAU;IAC/B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAChC,MAAM,CAAC,MAAM,GAAG,GAAG,EAAE;YACnB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YAC7B,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC/B,OAAO,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC;YAClD,CAAC;QACH,CAAC,CAAC;QACF,MAAM,CAAC,OAAO,GAAG,GAAG,EAAE,CACpB,MAAM,CAAC,MAAM,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC;QAClE,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;AACL,CAAC;AAQD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkB,KAAK,EAAE,IAAU,EAAE,EAAE;IACnE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,CAAC;IAE1C,MAAM,MAAM,GAAG,MAAM,UAAU,CAA0B,cAAc,EAAE;QACvE,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS;KACjC,CAAC,CAAC;IAEH,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CACb,MAAM,EAAE,KAAK;YACX,qFAAqF,CACxF,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;AAClC,CAAC,CAAC","sourcesContent":["import { callAction } from \"../use-action.js\";\nimport type { ImageUploadFn } from \"./ImageExtension.js\";\n\n/**\n * Read a {@link File} as a base64 data URL (`data:image/...;base64,...`).\n *\n * The framework `upload-image` action accepts a data URL (`data`) or a remote\n * URL (`url`) — not raw multipart — so a browser file-picker must convert the\n * File to a data URL first.\n */\nfunction fileToDataUrl(file: File): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => {\n      const result = reader.result;\n      if (typeof result === \"string\") {\n        resolve(result);\n      } else {\n        reject(new Error(\"Failed to read image file.\"));\n      }\n    };\n    reader.onerror = () =>\n      reject(reader.error ?? new Error(\"Failed to read image file.\"));\n    reader.readAsDataURL(file);\n  });\n}\n\ninterface UploadImageActionResult {\n  url?: string;\n  error?: string;\n  configured?: boolean;\n}\n\n/**\n * The shared editor's default image uploader: upload a picked / pasted /\n * dropped image File through the framework `upload-image` action and return the\n * hosted CDN URL.\n *\n * This is the {@link ImageUploadFn} embedders pass to the shared image block so\n * any app gets a real uploading image block with zero per-app upload code. The\n * action re-hosts the bytes on the configured provider (Builder.io by default),\n * is session-scoped, and returns a stable `![alt](url)` source — so a plan's\n * inserted image autosaves as plain markdown through the existing\n * `update-rich-text` path with no new persistence channel.\n *\n * @throws when the file cannot be read, the action returns no URL, or upload is\n *   not configured (with the action's \"connect Builder.io\" guidance).\n */\nexport const uploadEditorImage: ImageUploadFn = async (file: File) => {\n  if (!file.type.startsWith(\"image/\")) {\n    throw new Error(\"Only image files can be uploaded.\");\n  }\n\n  const dataUrl = await fileToDataUrl(file);\n\n  const result = await callAction<UploadImageActionResult>(\"upload-image\", {\n    data: dataUrl,\n    filename: file.name || undefined,\n  });\n\n  if (!result || typeof result.url !== \"string\" || !result.url) {\n    throw new Error(\n      result?.error ||\n        \"Image upload failed. Connect Builder.io in Settings → File uploads, then try again.\",\n    );\n  }\n\n  // Use the filename (sans extension) as a reasonable default alt text.\n  const alt = file.name ? file.name.replace(/\\.[^./\\\\]+$/, \"\") : \"\";\n  return { src: result.url, alt };\n};\n"]}

package/dist/client/rich-markdown-editor/useCollabReconcile.d.ts

@@ -0,0 +1,91 @@
+import { type MutableRefObject } from "react";
+import type { Editor } from "@tiptap/react";
+import type { Transaction } from "@tiptap/pm/state";
+import type { Doc as YDoc } from "yjs";
+import type { Awareness } from "y-protocols/awareness";
+/** Reads the current markdown out of the tiptap-markdown storage. */
+export declare function getEditorMarkdown(editor: Editor): string;
+export interface UseCollabReconcileOptions {
+    /** The live editor, or null until it mounts. */
+    editor: Editor | null;
+    /** Shared Y.Doc when collaborating; null disables all collab paths. */
+    ydoc?: YDoc | null;
+    /** Shared awareness; null keeps the sole-client lead path. */
+    awareness?: Awareness | null;
+    /** Authoritative markdown value (SQL source of truth). */
+    value: string;
+    /** Timestamp of the authoritative value; gates newer-than reconcile. */
+    contentUpdatedAt?: string | null;
+    /** Whether the editor accepts edits. Reconcile/seed only run for the live editor. */
+    editable: boolean;
+    /**
+     * Reads the current markdown from the editor. Injected so a dialect could
+     * swap serializers; defaults to the tiptap-markdown storage reader. For an app
+     * with a custom serializer (e.g. Content's `docToNfm(editor.getJSON())`), pass
+     * it here so the seed/reconcile equality checks compare like-for-like.
+     */
+    getMarkdown?: (editor: Editor) => string;
+    /**
+     * Applies the authoritative `value` into the editor. Defaults to passing the
+     * raw markdown string to `editor.commands.setContent`. Apps whose serializer
+     * is NOT tiptap-markdown (Content parses `nfmToDoc(value)` into a PM doc)
+     * override this so seed + reconcile write the correct content shape. The
+     * supplied `options` carry the history/whitespace flags the default path uses;
+     * a custom implementation should forward them when relevant.
+     */
+    setContent?: (editor: Editor, value: string, options: {
+        emitUpdate?: boolean;
+        addToHistory?: boolean;
+    }) => void;
+    /**
+     * Normalizes the authoritative `value` to the canonical markdown the editor
+     * would emit, so the "already in sync / our own echo" equality checks match a
+     * serializer that re-canonicalizes (Content's `canonicalizeNfm`). Defaults to
+     * identity (GFM already round-trips byte-stably).
+     */
+    normalizeValue?: (value: string) => string;
+    /**
+     * Decides whether the empty-doc seed should run for the current shared
+     * fragment. Defaults to "fragment has no nodes, or the editor holds no
+     * semantic markdown". Apps with sentinel-empty content (Content's
+     * `<empty-block/>` filler) override this. Receives the live fragment length
+     * and the editor's current markdown.
+     */
+    shouldSeed?: (info: {
+        value: string;
+        currentMarkdown: string;
+        fragmentLength: number;
+    }) => boolean;
+    /**
+     * The initial "applied" watermark. Default mirrors `contentUpdatedAt`, so a
+     * fresh mount whose Y.Doc already matches SQL doesn't re-apply. Pass `null`
+     * to force the first reconcile pass to adopt authoritative SQL even at the
+     * same timestamp — Content does this so a stale persisted Y.Doc (an agent that
+     * edited the CLOSED doc) is corrected on open. The editor is keyed per
+     * document upstream, so this only affects the first mount of each doc.
+     */
+    initialAppliedUpdatedAt?: string | null;
+}
+export interface UseCollabReconcileResult {
+    /** True when a Y.Doc is bound (collaborative editing active). */
+    collab: boolean;
+    /**
+     * Set true around any programmatic `setContent` so the editor's `onUpdate`
+     * can ignore the resulting transaction (it isn't a user edit).
+     */
+    isSettingContentRef: MutableRefObject<boolean>;
+    /**
+     * Call from `onUpdate` BEFORE serializing. Returns true when the update must
+     * be ignored: editor not editable, mid-programmatic-setContent, or (in collab
+     * mode) a remote-origin transaction. Also records the local typing time.
+     */
+    shouldIgnoreUpdate: (transaction: Transaction) => boolean;
+    /**
+     * Call from `onUpdate` AFTER computing the markdown to emit. Returns false
+     * when the value must NOT be persisted yet (an empty collab doc before the
+     * seed has run); records it as the last-emitted value otherwise.
+     */
+    registerEmitted: (markdown: string) => boolean;
+}
+export declare function useCollabReconcile({ editor, ydoc, awareness, value, contentUpdatedAt, editable, getMarkdown, setContent, normalizeValue, shouldSeed, initialAppliedUpdatedAt, }: UseCollabReconcileOptions): UseCollabReconcileResult;
+//# sourceMappingURL=useCollabReconcile.d.ts.map

package/dist/client/rich-markdown-editor/useCollabReconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCollabReconcile.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/useCollabReconcile.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,GAAG,IAAI,IAAI,EAAE,MAAM,KAAK,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAIvD,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,MAAM,WAAW,yBAAyB;IACxC,gDAAgD;IAChD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uEAAuE;IACvE,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACnB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,qFAAqF;IACrF,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,KACtD,IAAI,CAAC;IACV;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;KACxB,KAAK,OAAO,CAAC;IACd;;;;;;;OAOG;IACH,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,wBAAwB;IACvC,iEAAiE;IACjE,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,mBAAmB,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC/C;;;;OAIG;IACH,kBAAkB,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC;IAC1D;;;;OAIG;IACH,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CAChD;AAoED,wBAAgB,kBAAkB,CAAC,EACjC,MAAM,EACN,IAAW,EACX,SAAgB,EAChB,KAAK,EACL,gBAAgB,EAChB,QAAQ,EACR,WAA+B,EAC/B,UAA8B,EAC9B,cAAyB,EACzB,UAA8B,EAC9B,uBAAuB,GACxB,EAAE,yBAAyB,GAAG,wBAAwB,CAiStD"}

package/dist/client/rich-markdown-editor/useCollabReconcile.js

@@ -0,0 +1,342 @@
+import { useEffect, useRef, useState } from "react";
+import { isChangeOrigin } from "@tiptap/extension-collaboration";
+import { isReconcileLeadClient } from "../../collab/client.js";
+import { AGENT_CLIENT_ID } from "../../collab/agent-identity.js";
+/** Reads the current markdown out of the tiptap-markdown storage. */
+export function getEditorMarkdown(editor) {
+    const markdownStorage = editor.storage;
+    return markdownStorage.markdown?.getMarkdown?.() ?? "";
+}
+/**
+ * The subtle seed / reconcile / lead-client logic for the shared markdown
+ * editor, extracted once so it can never be duplicated across embedders.
+ *
+ * Responsibilities (reproducing the Plan editor's behavior exactly):
+ *  - Track whether THIS client is the reconcile lead (sole client always leads;
+ *    otherwise elected via {@link isReconcileLeadClient}) and how many other
+ *    visible human peers are present.
+ *  - Seed an empty shared Y.Doc once from `value` — lead client only — so two
+ *    clients opening a brand-new block don't both insert the content.
+ *  - Reconcile authoritative external markdown (agent edit, source patch, peer
+ *    edit mirrored to SQL) into the editor: in collab mode only the lead client
+ *    applies it through `setContent` and Yjs propagates; in non-collab mode this
+ *    is the original controlled-value reconcile.
+ *  - Provide the `onUpdate` guards (`shouldIgnoreUpdate`, `registerEmitted`) so
+ *    the component never persists remote-origin or pre-seed empty content.
+ */
+/** Default seed predicate: seed only when the shared doc is genuinely empty. */
+function defaultShouldSeed({ currentMarkdown, fragmentLength, }) {
+    return fragmentLength === 0 || !currentMarkdown.trim();
+}
+/**
+ * Default content writer: hand the raw markdown string to `setContent`, which
+ * tiptap-markdown overrides to parse the markdown into a ProseMirror doc.
+ *
+ * IMPORTANT: do NOT pass `parseOptions: { preserveWhitespace: "full" }` here.
+ * In tiptap v3 the core `setContent` command routes `preserveWhitespace: "full"`
+ * through `insertContentAt`, which tiptap-markdown ALSO overrides to re-run its
+ * markdown parser. That double-parse stringifies the already-parsed PM doc and
+ * re-parses it as HTML, so a clean heading/list/code block comes back as the
+ * escaped, non-idempotent `<h1>…` — which then escalates every reconcile
+ * cycle (`<p>` → `&lt;p&gt;` → `&amp;lt;p&amp;gt;` …). Letting the markdown
+ * override parse the string directly (no `parseOptions`) round-trips byte-stably
+ * for the GFM corpus, including code-block and empty-line whitespace. Content's
+ * NFM path supplies its own `setContent` (it passes a pre-parsed PM doc) and is
+ * unaffected by this default.
+ */
+function defaultSetContent(editor, value, options) {
+    if (options.addToHistory === false) {
+        editor
+            .chain()
+            .command(({ tr }) => {
+            // addToHistory:false so cmd+z (or Yjs undo) doesn't erase
+            // externally-loaded content.
+            tr.setMeta("addToHistory", false);
+            return true;
+        })
+            .setContent(value, { emitUpdate: options.emitUpdate })
+            .run();
+        return;
+    }
+    editor.commands.setContent(value);
+}
+export function useCollabReconcile({ editor, ydoc = null, awareness = null, value, contentUpdatedAt, editable, getMarkdown = getEditorMarkdown, setContent = defaultSetContent, normalizeValue = (v) => v, shouldSeed = defaultShouldSeed, initialAppliedUpdatedAt, }) {
+    const collab = !!ydoc;
+    const isSettingContentRef = useRef(false);
+    const lastEmittedRef = useRef("");
+    const lastTypedAtRef = useRef(0);
+    // The raw authoritative `value` string the reconcile last applied. When the
+    // SAME raw string is re-fetched (a lagging poll, or a source-sync that keeps
+    // re-supplying the same stored markdown), applying it again would only
+    // reproduce the doc we already hold — and if `value` is NON-idempotent
+    // (serialize(parse(value)) !== value) re-applying compounds the divergence
+    // every cycle (`<p>` → `&lt;p&gt;` → `&amp;lt;p&amp;gt;` …). Tracked so the
+    // identical re-fetch is recognized and skipped.
+    const lastAppliedValueRef = useRef(null);
+    // The editor's SERIALIZED output captured right AFTER the last reconcile/seed
+    // apply (`getMarkdown(editor)` once the content settled). For non-idempotent
+    // input this is what autosave actually persists, so the NEXT poll hands it
+    // back as the new `value`. Comparing the incoming value against this lets the
+    // reconcile recognize its own echo even when the raw string changed once, so
+    // it never re-parses content the editor already represents. This is the
+    // doc-equivalence guard that breaks the escalation loop.
+    const lastAppliedSerializedRef = useRef(null);
+    const lastAppliedUpdatedAtRef = useRef(initialAppliedUpdatedAt !== undefined
+        ? initialAppliedUpdatedAt
+        : (contentUpdatedAt ?? null));
+    // Whether THIS client is the one that seeds the empty shared doc / applies an
+    // authoritative external snapshot into it. Exactly one client does, so the
+    // content isn't inserted once per open editor. A sole client always leads.
+    const [isLeadClient, setIsLeadClient] = useState(true);
+    // Count of OTHER visible human collaborators. When >0, a peer's edit also
+    // arrives via Yjs, so external markdown reconcile must defer (avoid applying
+    // the same change through both Yjs and setContent).
+    const peerCountRef = useRef(0);
+    useEffect(() => {
+        if (!collab || !awareness || !ydoc) {
+            setIsLeadClient(true);
+            peerCountRef.current = 0;
+            return;
+        }
+        const update = () => {
+            setIsLeadClient(isReconcileLeadClient(awareness, ydoc.clientID));
+            let peers = 0;
+            awareness.getStates().forEach((state, clientId) => {
+                if (clientId === ydoc.clientID)
+                    return; // self
+                if (clientId === AGENT_CLIENT_ID)
+                    return; // agent isn't a Yjs editor
+                const s = state;
+                if (s && s.user && s.visible !== false)
+                    peers += 1;
+            });
+            peerCountRef.current = peers;
+        };
+        update();
+        awareness.on("change", update);
+        document.addEventListener("visibilitychange", update);
+        return () => {
+            awareness.off("change", update);
+            document.removeEventListener("visibilitychange", update);
+        };
+    }, [collab, awareness, ydoc]);
+    // Collab seed: populate an empty shared Y.Doc from the markdown `value` once.
+    // The Collaboration extension does NOT auto-seed; only the lead client does,
+    // so two clients opening a brand-new block at once don't both seed (which
+    // would duplicate the content via concurrent inserts at the same position).
+    const seededRef = useRef(false);
+    useEffect(() => {
+        if (!collab || !editor || editor.isDestroyed || !ydoc)
+            return;
+        if (seededRef.current)
+            return;
+        if (!isLeadClient)
+            return;
+        if (!value.trim())
+            return;
+        const fragment = ydoc.getXmlFragment("default");
+        const currentMarkdown = getMarkdown(editor);
+        // Seed only when the shared doc is genuinely empty — either the fragment has
+        // no nodes yet, or it holds no semantic markdown (an empty paragraph, or an
+        // app's sentinel-empty filler via a custom `shouldSeed`).
+        if (shouldSeed({ value, currentMarkdown, fragmentLength: fragment.length })) {
+            isSettingContentRef.current = true;
+            setContent(editor, value, {});
+            isSettingContentRef.current = false;
+            const serialized = getMarkdown(editor);
+            lastEmittedRef.current = serialized;
+            lastAppliedValueRef.current = value;
+            lastAppliedSerializedRef.current = serialized;
+            if (contentUpdatedAt)
+                lastAppliedUpdatedAtRef.current = contentUpdatedAt;
+        }
+        seededRef.current = true;
+    }, [
+        collab,
+        editor,
+        ydoc,
+        value,
+        isLeadClient,
+        contentUpdatedAt,
+        getMarkdown,
+        setContent,
+        shouldSeed,
+    ]);
+    // Reconcile authoritative external markdown (agent edit, source patch, or a
+    // peer edit mirrored to SQL) into the live editor. In collab mode only the
+    // lead client applies it through setContent; Yjs propagates the result to
+    // every other client. In non-collab mode this is the original controlled-value
+    // reconcile, unchanged.
+    useEffect(() => {
+        if (!editor || editor.isDestroyed)
+            return;
+        let cancelled = false;
+        let retry = null;
+        // With peers present, a peer's edit also arrives via Yjs. Defer one poll
+        // cycle (+margin) and re-check before applying via setContent so the same
+        // change isn't inserted twice (Yjs + setContent → duplicated region).
+        const PEER_SETTLE_MS = 2500;
+        const apply = (deferred = false) => {
+            if (cancelled || editor.isDestroyed)
+                return;
+            // In collab mode, defer all reconcile until the shared doc is seeded so we
+            // never setContent over an unseeded fragment.
+            if (collab && !seededRef.current) {
+                retry = setTimeout(() => apply(deferred), 300);
+                return;
+            }
+            const currentMarkdown = getMarkdown(editor);
+            // Compare against the canonical form the editor would emit so a serializer
+            // that re-normalizes (Content's NFM) still recognizes "already in sync".
+            const normalizedValue = normalizeValue(value);
+            // Whether the editor still holds exactly what THIS hook last applied (the
+            // user hasn't edited since). Only then are the round-trip echo guards
+            // below safe: if the user has since edited away from the applied content,
+            // an external snapshot equal to a previously-applied value is a real
+            // revert and must NOT be swallowed as an echo.
+            const editorUnchangedSinceApply = lastAppliedSerializedRef.current !== null &&
+                currentMarkdown === lastAppliedSerializedRef.current;
+            // Doc-equivalence skip. Never re-apply content the editor already
+            // represents — comparing by DOC EQUIVALENCE, not raw strings/timestamps:
+            //   1. `currentMarkdown === normalizedValue` — the editor's CURRENT
+            //      serialized doc already equals the (normalized) incoming value.
+            //   2. `value === lastEmittedRef.current` — the incoming value is our own
+            //      just-emitted markdown echoing back.
+            //   3. `value === lastAppliedValueRef.current` — the SAME raw value we
+            //      already applied is being re-supplied (a lagging poll or a
+            //      source-sync re-handing the same stored markdown). Applying it again
+            //      would only reproduce the doc we hold; for NON-idempotent input it
+            //      would compound divergence. Guarded by `editorUnchangedSinceApply`
+            //      so a deliberate revert-to-previous after a local edit still lands.
+            //   4. `normalizedValue === lastAppliedSerializedRef.current` — the
+            //      incoming value round-trips to the serialized output we last
+            //      produced (our own autosaved echo coming back from SQL). For
+            //      non-idempotent input the raw string differs from what we were
+            //      handed, but it is doc-equivalent to what the editor already shows,
+            //      so re-parsing it must be skipped. This is the guard that stops the
+            //      `<p>` → `&lt;p&gt;` → `&amp;lt;p&amp;gt;` escalation.
+            if (currentMarkdown === normalizedValue ||
+                value === lastEmittedRef.current ||
+                (editorUnchangedSinceApply &&
+                    (value === lastAppliedValueRef.current ||
+                        normalizedValue === lastAppliedSerializedRef.current))) {
+                if (contentUpdatedAt) {
+                    lastAppliedUpdatedAtRef.current = contentUpdatedAt;
+                }
+                return;
+            }
+            const externalNewer = !lastAppliedUpdatedAtRef.current ||
+                !contentUpdatedAt ||
+                contentUpdatedAt > lastAppliedUpdatedAtRef.current;
+            // Only the lead client applies an authoritative snapshot into the shared
+            // Y.Doc; peers receive it through Yjs sync.
+            if (collab && !isLeadClient) {
+                if (contentUpdatedAt && !externalNewer) {
+                    lastAppliedUpdatedAtRef.current = contentUpdatedAt;
+                }
+                return;
+            }
+            // Never clobber an in-progress edit. While the user is actively typing
+            // (focused and a keystroke landed within the window) defer and re-check —
+            // applying external content now would yank text out from under them and,
+            // for non-idempotent input, fight every keystroke. Newer external content
+            // retries so it still lands once they pause; older-or-equal content is a
+            // stale poll and is dropped outright while focused.
+            const typingRecently = editor.isFocused && Date.now() - lastTypedAtRef.current < 1500;
+            if (typingRecently) {
+                if (externalNewer) {
+                    retry = setTimeout(() => apply(deferred), 700);
+                }
+                return;
+            }
+            if (!externalNewer && editor.isFocused)
+                return;
+            // Race guard: with peers present, let Yjs deliver a peer's edit first.
+            // Defer once and re-check — a peer edit makes the equality check above
+            // no-op next pass; an agent/source edit still differs and applies.
+            if (collab && externalNewer && !deferred && peerCountRef.current > 0) {
+                retry = setTimeout(() => apply(true), PEER_SETTLE_MS);
+                return;
+            }
+            queueMicrotask(() => {
+                if (cancelled || editor.isDestroyed)
+                    return;
+                // Re-check doc-equivalence at apply time. Between the decision above and
+                // this microtask a peer/Yjs edit (or our own prior apply) may have made
+                // the editor already represent this value — re-applying would be a
+                // wasted setContent that, for non-idempotent input, re-triggers the
+                // loop. Skip when the editor's current serialization already matches the
+                // normalized value, or the value round-trips to what we last produced.
+                const beforeMarkdown = getMarkdown(editor);
+                const normalized = normalizeValue(value);
+                const unchangedSinceApply = lastAppliedSerializedRef.current !== null &&
+                    beforeMarkdown === lastAppliedSerializedRef.current;
+                if (beforeMarkdown === normalized ||
+                    (unchangedSinceApply &&
+                        normalized === lastAppliedSerializedRef.current)) {
+                    lastAppliedValueRef.current = value;
+                    if (contentUpdatedAt) {
+                        lastAppliedUpdatedAtRef.current = contentUpdatedAt;
+                    }
+                    return;
+                }
+                isSettingContentRef.current = true;
+                setContent(editor, value, { emitUpdate: false, addToHistory: false });
+                isSettingContentRef.current = false;
+                // Capture the SERIALIZED result, not the raw value. For non-idempotent
+                // input these differ; recording the serialized output is what lets the
+                // next poll (which returns this serialized form) be recognized as our
+                // own echo and skipped — stabilizing the doc after exactly one apply.
+                const serialized = getMarkdown(editor);
+                lastEmittedRef.current = serialized;
+                lastAppliedValueRef.current = value;
+                lastAppliedSerializedRef.current = serialized;
+                if (contentUpdatedAt) {
+                    lastAppliedUpdatedAtRef.current = contentUpdatedAt;
+                }
+            });
+        };
+        apply();
+        return () => {
+            cancelled = true;
+            if (retry)
+                clearTimeout(retry);
+        };
+    }, [
+        contentUpdatedAt,
+        editor,
+        value,
+        collab,
+        isLeadClient,
+        getMarkdown,
+        setContent,
+        normalizeValue,
+    ]);
+    const shouldIgnoreUpdate = (transaction) => {
+        if (!editable || isSettingContentRef.current)
+            return true;
+        // In collab mode, never persist remote-originated changes (the initial Yjs
+        // state load or a peer's edit arriving via sync). Each client saves only its
+        // OWN local edits; a peer's edit is saved by that peer. Without this, a
+        // lagging Y.Doc load would write stale markdown over newer SQL.
+        if (collab && transaction && isChangeOrigin(transaction))
+            return true;
+        lastTypedAtRef.current = Date.now();
+        return false;
+    };
+    const registerEmitted = (markdown) => {
+        // Don't persist an empty doc before Collaboration has seeded — that would
+        // clobber the saved block content with an empty string.
+        if (collab && !markdown.trim())
+            return false;
+        lastEmittedRef.current = markdown;
+        return true;
+    };
+    return {
+        collab,
+        isSettingContentRef,
+        shouldIgnoreUpdate,
+        registerEmitted,
+    };
+}
+//# sourceMappingURL=useCollabReconcile.js.map