@agent-native/core 0.109.2 → 0.109.4

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

@@ -1,224 +0,0 @@
-import Collaboration from "@tiptap/extension-collaboration";
-import CollaborationCaret from "@tiptap/extension-collaboration-caret";
-import Link from "@tiptap/extension-link";
-import Placeholder from "@tiptap/extension-placeholder";
-import { Table } from "@tiptap/extension-table";
-import { TableCell } from "@tiptap/extension-table-cell";
-import { TableHeader } from "@tiptap/extension-table-header";
-import { TableRow } from "@tiptap/extension-table-row";
-import TaskItem from "@tiptap/extension-task-item";
-import TaskList from "@tiptap/extension-task-list";
-import StarterKit from "@tiptap/starter-kit";
-import bash from "highlight.js/lib/languages/bash";
-import css from "highlight.js/lib/languages/css";
-import javascript from "highlight.js/lib/languages/javascript";
-import json from "highlight.js/lib/languages/json";
-import markdown from "highlight.js/lib/languages/markdown";
-import python from "highlight.js/lib/languages/python";
-import sql from "highlight.js/lib/languages/sql";
-import typescript from "highlight.js/lib/languages/typescript";
-import xml from "highlight.js/lib/languages/xml";
-import yaml from "highlight.js/lib/languages/yaml";
-import { createLowlight } from "lowlight";
-import { Markdown } from "tiptap-markdown";
-/**
- * Shared lowlight instance for the editor's syntax-highlighted code blocks. A
- * curated grammar set (aliases like ts/tsx, js/jsx, html, sh, py, yml, md come
- * for free from each grammar) keeps the editor bundle lean while matching the
- * languages the read-side Shiki surfaces (`code-tabs`) support. highlight.js is
- * synchronous, which is what a live ProseMirror editor needs — Shiki is async
- * and only used for read-only render paths.
- */
-const codeLowlight = createLowlight({
-    bash,
-    css,
-    javascript,
-    json,
-    markdown,
-    python,
-    sql,
-    typescript,
-    xml,
-    yaml,
-});
-import { createCodeBlockNode } from "./CodeBlockNode.js";
-import { createImageExtension } from "./ImageExtension.js";
-/**
- * tiptap-markdown configuration, keyed by dialect. This is the single source of
- * truth for how each dialect parses/serializes markdown so the editor component
- * and the round-trip fidelity test can never drift apart.
- *
- * tiptap-markdown re-serializes the whole document on every edit, so the goal
- * for GFM is `serialize(parse(markdown)) === markdown` for the markdown plans
- * actually contain. We deliberately keep tiptap-markdown's own defaults
- * (`bulletListMarker: "-"`, `tightLists: true`, `linkify: false`,
- * `breaks: false`) because those produce the most byte-stable GFM. See
- * RichMarkdownEditor.roundtrip.spec.ts for the pinned corpus.
- *
- * NFM (Content) opts into inline HTML passthrough (`html: true`) so
- * Notion-specific blocks survive a markdown round-trip; the rest mirrors the
- * Content editor's existing `Markdown.configure` call.
- */
-export const MARKDOWN_DIALECT_CONFIG = {
-    gfm: {
-        // GFM plans are the common case and must never gain raw HTML as a second
-        // representation.
-        html: false,
-        // Keep tiptap-markdown's defaults that minimise first-edit normalisation
-        // churn (see roundtrip spec). Listed explicitly so the contract is
-        // self-documenting rather than relying on the package defaults.
-        bulletListMarker: "-",
-        tightLists: true,
-        linkify: false,
-        breaks: false,
-        transformPastedText: true,
-        transformCopiedText: true,
-    },
-    nfm: {
-        // NFM is a superset that allows inline HTML so Notion blocks round-trip.
-        html: true,
-        transformPastedText: true,
-        transformCopiedText: true,
-    },
-};
-const DEFAULT_FEATURES = {
-    tables: true,
-    tasks: true,
-    link: true,
-    codeBlock: true,
-    placeholder: true,
-    markdown: true,
-    // Off by default: only Plans opt in today. Content injects its own richer
-    // image node via `extraExtensions` and must not get a second `image` node.
-    image: false,
-};
-/**
- * The ONE editor extension factory shared by every embedder (Plans today,
- * Content next). It assembles the base Tiptap schema (StarterKit + Placeholder
- * + Link + tasks + tables + code block), the dialect-keyed {@link Markdown}
- * serializer, the optional Collaboration stack, and finally any app-specific
- * `extraExtensions`.
- *
- * Ordering matters:
- *   1. Base schema (StarterKit first so its nodes/marks register; `starterKit`
- *      overrides let an app disable replaced nodes / swap the dropcursor).
- *   2. dialect-keyed Markdown serializer (suppressible via `features.markdown`
- *      for apps that own the whole serialize/parse pipeline, e.g. Content's NFM).
- *   3. `extraExtensions` (Notion/media/etc.) — appended before Collaboration so
- *      apps can extend the schema and Collaboration still binds over the full
- *      schema.
- *   4. Collaboration (+ CollaborationCaret) LAST so they bind over everything.
- *
- * Content (the NFM editor) drives this factory with `features.placeholder` and
- * `features.markdown` off, `features.tasks/tables/link` off where it ships its
- * own, a `starterKit` override disabling paragraph/blockquote/codeBlock, and all
- * Notion/media/fidelity nodes + its own Markdown(NFM)/Placeholder via
- * `extraExtensions` — so it shares the StarterKit base + the collab wiring while
- * owning its byte-identical NFM serializer.
- */
-export function createSharedEditorExtensions({ dialect = "gfm", 
-// `preset` is accepted and forwarded for future preset-specific schema
-// branches; it is currently schema-neutral.
-preset: _preset = "plan", placeholder = "Type '/' for commands...", features, starterKit, markdown, extraExtensions = [], collab = null, onImageUpload = null, disableHistory = false, } = {}) {
-    const feat = { ...DEFAULT_FEATURES, ...(features ?? {}) };
-    const ydoc = collab?.ydoc ?? null;
-    const awareness = collab?.awareness ?? null;
-    const user = collab?.user ?? null;
-    const exts = [
-        StarterKit.configure({
-            heading: { levels: [1, 2, 3, 4] },
-            link: false,
-            // StarterKit's plain code block is always disabled; when enabled we add the
-            // syntax-highlighting `CodeBlockLowlight` (same `codeBlock` node) below.
-            codeBlock: false,
-            dropcursor: { color: "hsl(var(--ring))", width: 2 },
-            // Yjs owns undo/redo when Collaboration is active; the StarterKit history
-            // plugin and the CRDT cannot both track undo without corrupting state.
-            // `disableHistory` is the non-collab equivalent: a controlled editor whose
-            // host (e.g. the plan editor) owns a single app-level undo authority.
-            ...(ydoc || disableHistory ? { undoRedo: false } : {}),
-            // App overrides last so embedders can disable replaced nodes (paragraph,
-            // blockquote, code block) or swap the dropcursor while keeping the shared
-            // base + the collab undo/redo gating above.
-            ...(starterKit ?? {}),
-        }),
-    ];
-    // Notion-style syntax-highlighted code block (replaces StarterKit's plain one)
-    // only when the embedder opts in via `features.codeBlock`. The shared node adds
-    // a language picker header (Auto-detects by default) over `CodeBlockLowlight`,
-    // so fenced markdown still round-trips byte-identically. Content disables this
-    // and ships its own code node, so this affects Plans (and future opt-in apps)
-    // alone.
-    if (feat.codeBlock) {
-        exts.push(createCodeBlockNode({ lowlight: codeLowlight }));
-    }
-    if (feat.placeholder) {
-        exts.push(Placeholder.configure({
-            placeholder: ({ node }) => {
-                if (node.type.name === "heading") {
-                    const level = node.attrs.level;
-                    if (level === 1)
-                        return "Heading 1";
-                    if (level === 2)
-                        return "Heading 2";
-                    if (level === 3)
-                        return "Heading 3";
-                    return "Heading 4";
-                }
-                return placeholder;
-            },
-            showOnlyWhenEditable: true,
-            showOnlyCurrent: true,
-        }));
-    }
-    if (feat.link) {
-        exts.push(Link.configure({
-            openOnClick: false,
-            HTMLAttributes: { class: "an-rich-md-link" },
-        }));
-    }
-    if (feat.tasks) {
-        exts.push(TaskList.configure({
-            HTMLAttributes: { class: "an-rich-md-task-list" },
-        }), TaskItem.configure({ nested: true }));
-    }
-    if (feat.tables) {
-        exts.push(Table.configure({
-            resizable: false,
-            HTMLAttributes: { class: "an-rich-md-table" },
-        }), TableRow, TableHeader, TableCell);
-    }
-    if (feat.markdown) {
-        exts.push(Markdown.configure(markdown ?? MARKDOWN_DIALECT_CONFIG[dialect]));
-    }
-    // Shared block-level image node. The node is named `image`, so when
-    // `features.markdown` is on, tiptap-markdown serializes it through its
-    // built-in `defaultMarkdownSerializer.nodes.image` fallback → `![alt](src)`
-    // (no width-as-HTML override here, so GFM stays byte-stable and
-    // source-syncable). With an `onImageUpload` it accepts paste/drop uploads.
-    if (feat.image) {
-        exts.push(createImageExtension({ onImageUpload }));
-    }
-    // App-specific extensions (Notion/media/drag handles/comments). Appended
-    // before Collaboration so they can extend the schema and Collaboration binds
-    // over the full set.
-    if (extraExtensions.length > 0) {
-        exts.push(...extraExtensions);
-    }
-    // Collaborative editing via the shared Y.Doc. Markdown stays the canonical
-    // saved representation (onChange serializes it); the Y.Doc is transient live
-    // state only. Appended last so it binds over the configured schema above.
-    if (ydoc) {
-        exts.push(Collaboration.configure({ document: ydoc }));
-        // Live multi-user cursors. Only mounted alongside a Y.Doc so the standalone
-        // controlled editor (today's plan/content behavior) is untouched.
-        if (awareness) {
-            exts.push(CollaborationCaret.configure({
-                provider: { awareness },
-                user: user ?? { name: "Anonymous", color: "#999" },
-            }));
-        }
-    }
-    return exts;
-}
-//# sourceMappingURL=extensions.js.map

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

@@ -1 +0,0 @@
-{"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 Collaboration from \"@tiptap/extension-collaboration\";\nimport CollaborationCaret from \"@tiptap/extension-collaboration-caret\";\nimport Link from \"@tiptap/extension-link\";\nimport Placeholder from \"@tiptap/extension-placeholder\";\nimport { Table } from \"@tiptap/extension-table\";\nimport { TableCell } from \"@tiptap/extension-table-cell\";\nimport { TableHeader } from \"@tiptap/extension-table-header\";\nimport { TableRow } from \"@tiptap/extension-table-row\";\nimport TaskItem from \"@tiptap/extension-task-item\";\nimport TaskList from \"@tiptap/extension-task-list\";\nimport StarterKit from \"@tiptap/starter-kit\";\nimport type { StarterKitOptions } from \"@tiptap/starter-kit\";\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 { createLowlight } from \"lowlight\";\nimport { Markdown } from \"tiptap-markdown\";\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 { Awareness } from \"y-protocols/awareness\";\nimport type { Doc as YDoc } from \"yjs\";\n\nimport { createCodeBlockNode } from \"./CodeBlockNode.js\";\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   * Disable StarterKit's built-in undo/redo (prosemirror-history) for a\n   * controlled (non-collab) editor whose host owns its own undo authority.\n   * Default `false`. When a `collab.ydoc` is present, undo/redo is ALWAYS\n   * disabled regardless of this flag (Yjs owns history); this flag is the\n   * non-collab equivalent. The plan editor sets it so a single app-level undo\n   * stack (over the authoritative `blocks[]` tree, which includes block data\n   * the ProseMirror doc never stores) is the sole cmd+z authority — otherwise\n   * PM history and the app stack would both fire, and PM history can't see\n   * block-option edits at all.\n   */\n  disableHistory?: boolean;\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  disableHistory = false,\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      // `disableHistory` is the non-collab equivalent: a controlled editor whose\n      // host (e.g. the plan editor) owns a single app-level undo authority.\n      ...(ydoc || disableHistory ? { 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  // Notion-style syntax-highlighted code block (replaces StarterKit's plain one)\n  // only when the embedder opts in via `features.codeBlock`. The shared node adds\n  // a language picker header (Auto-detects by default) over `CodeBlockLowlight`,\n  // so fenced markdown still round-trips byte-identically. Content disables this\n  // and ships its own code node, so this affects Plans (and future opt-in apps)\n  // alone.\n  if (feat.codeBlock) {\n    exts.push(createCodeBlockNode({ lowlight: codeLowlight }));\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/gfmDoc.d.ts

@@ -1,24 +0,0 @@
-import { type JSONContent } from "@tiptap/core";
-/**
- * Parse a GFM markdown string into an array of top-level ProseMirror node JSON
- * (paragraph / heading / list / table / code block / etc.), matching the live
- * plan editor schema (`createSharedEditorExtensions({ dialect: "gfm",
- * features: { image: true } })`) plus the {@link RunId} attribute.
- *
- * `tiptap-markdown` registers the markdown parser, so handing the raw markdown
- * string to `setContent` deserializes it (the same path the live editor uses
- * when it seeds `content: markdown`). Returns the doc's child nodes; an empty
- * string yields a single empty paragraph.
- */
-export declare function gfmToProseJSON(markdown: string): JSONContent[];
-/**
- * Serialize an array of top-level ProseMirror node JSON into GFM markdown. The
- * `runId` attribute is omitted by GFM (the {@link RunId} extension registers no
- * markdown serializer), so it never leaks into the saved markdown.
- *
- * The nodes are wrapped in a `doc` and set on the shared editor, then the GFM
- * markdown is read from the tiptap-markdown storage — the exact serializer the
- * live editor persists with, so output is byte-stable with the live save path.
- */
-export declare function proseJSONToGfm(nodes: JSONContent[]): string;
-//# sourceMappingURL=gfmDoc.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gfmDoc.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/gfmDoc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AA0DxD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE,CAM9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAK3D"}

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

@@ -1,83 +0,0 @@
-import { Editor } from "@tiptap/core";
-import { createSharedEditorExtensions } from "./extensions.js";
-import { RunId } from "./RunId.js";
-/**
- * The GFM ↔ ProseMirror primitive for the plan single-doc editor.
- *
- * Plans keep `PlanContent.blocks[]` as the source of truth, but the editor is
- * ONE ProseMirror/Tiptap document. The `doc ↔ blocks[]` serializer
- * (`templates/plan/shared/plan-doc.ts`) needs to turn a `rich-text` block's GFM
- * markdown into prose nodes and back. This module is that primitive.
- *
- * Both directions go through a SINGLE headless Tiptap {@link Editor} built from
- * the exact same `createSharedEditorExtensions` config the live plan editor
- * uses (`dialect: "gfm"`, `features.image: true`) plus the {@link RunId}
- * extension, so the schema and the GFM serializer can never drift from the live
- * editor. The instance is created lazily on first use and reused across calls.
- *
- * The headless editor needs a DOM (ProseMirror's `EditorView`). It works under
- * `happy-dom` in vitest (see `gfmDoc.spec.ts`) and under the real browser DOM
- * in production. `createElement` is used rather than mounting into the page so
- * nothing is ever attached to the document.
- */
-let sharedEditor = null;
-/**
- * Lazily build (and memoize) the single headless editor. Throws if no DOM is
- * available — this primitive is for the client / jsdom-style test envs only.
- */
-function getSharedEditor() {
-    if (sharedEditor)
-        return sharedEditor;
-    if (typeof document === "undefined") {
-        throw new Error("gfmDoc requires a DOM (document). It runs in the browser and in jsdom/happy-dom tests, not in a bare Node server context.");
-    }
-    sharedEditor = new Editor({
-        element: document.createElement("div"),
-        extensions: createSharedEditorExtensions({
-            dialect: "gfm",
-            features: { image: true },
-            extraExtensions: [RunId],
-        }),
-        content: "",
-    });
-    return sharedEditor;
-}
-/** Reads the GFM markdown out of the tiptap-markdown storage. */
-function getMarkdown(editor) {
-    const storage = editor.storage;
-    return storage.markdown?.getMarkdown?.() ?? "";
-}
-/**
- * Parse a GFM markdown string into an array of top-level ProseMirror node JSON
- * (paragraph / heading / list / table / code block / etc.), matching the live
- * plan editor schema (`createSharedEditorExtensions({ dialect: "gfm",
- * features: { image: true } })`) plus the {@link RunId} attribute.
- *
- * `tiptap-markdown` registers the markdown parser, so handing the raw markdown
- * string to `setContent` deserializes it (the same path the live editor uses
- * when it seeds `content: markdown`). Returns the doc's child nodes; an empty
- * string yields a single empty paragraph.
- */
-export function gfmToProseJSON(markdown) {
-    const editor = getSharedEditor();
-    // `emitUpdate: false` keeps this a pure transform with no side effects on any
-    // (non-existent) consumers of the headless editor's update stream.
-    editor.commands.setContent(markdown, { emitUpdate: false });
-    return editor.getJSON().content ?? [];
-}
-/**
- * Serialize an array of top-level ProseMirror node JSON into GFM markdown. The
- * `runId` attribute is omitted by GFM (the {@link RunId} extension registers no
- * markdown serializer), so it never leaks into the saved markdown.
- *
- * The nodes are wrapped in a `doc` and set on the shared editor, then the GFM
- * markdown is read from the tiptap-markdown storage — the exact serializer the
- * live editor persists with, so output is byte-stable with the live save path.
- */
-export function proseJSONToGfm(nodes) {
-    const editor = getSharedEditor();
-    const content = nodes.length > 0 ? nodes : [{ type: "paragraph" }];
-    editor.commands.setContent({ type: "doc", content }, { emitUpdate: false });
-    return getMarkdown(editor);
-}
-//# sourceMappingURL=gfmDoc.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gfmDoc.js","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/gfmDoc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoB,MAAM,cAAc,CAAC;AAExD,OAAO,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,IAAI,YAAY,GAAkB,IAAI,CAAC;AAEvC;;;GAGG;AACH,SAAS,eAAe;IACtB,IAAI,YAAY;QAAE,OAAO,YAAY,CAAC;IACtC,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,2HAA2H,CAC5H,CAAC;IACJ,CAAC;IACD,YAAY,GAAG,IAAI,MAAM,CAAC;QACxB,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC;QACtC,UAAU,EAAE,4BAA4B,CAAC;YACvC,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;YACzB,eAAe,EAAE,CAAC,KAAK,CAAC;SACzB,CAAC;QACF,OAAO,EAAE,EAAE;KACZ,CAAC,CAAC;IACH,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,iEAAiE;AACjE,SAAS,WAAW,CAAC,MAAc;IACjC,MAAM,OAAO,GAAG,MAAM,CAAC,OAEtB,CAAC;IACF,OAAO,OAAO,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,CAAC;AACjD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,MAAM,MAAM,GAAG,eAAe,EAAE,CAAC;IACjC,8EAA8E;IAC9E,mEAAmE;IACnE,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5D,OAAO,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,KAAoB;IACjD,MAAM,MAAM,GAAG,eAAe,EAAE,CAAC;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IACnE,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5E,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;AAC7B,CAAC","sourcesContent":["import { Editor, type JSONContent } from \"@tiptap/core\";\n\nimport { createSharedEditorExtensions } from \"./extensions.js\";\nimport { RunId } from \"./RunId.js\";\n\n/**\n * The GFM ↔ ProseMirror primitive for the plan single-doc editor.\n *\n * Plans keep `PlanContent.blocks[]` as the source of truth, but the editor is\n * ONE ProseMirror/Tiptap document. The `doc ↔ blocks[]` serializer\n * (`templates/plan/shared/plan-doc.ts`) needs to turn a `rich-text` block's GFM\n * markdown into prose nodes and back. This module is that primitive.\n *\n * Both directions go through a SINGLE headless Tiptap {@link Editor} built from\n * the exact same `createSharedEditorExtensions` config the live plan editor\n * uses (`dialect: \"gfm\"`, `features.image: true`) plus the {@link RunId}\n * extension, so the schema and the GFM serializer can never drift from the live\n * editor. The instance is created lazily on first use and reused across calls.\n *\n * The headless editor needs a DOM (ProseMirror's `EditorView`). It works under\n * `happy-dom` in vitest (see `gfmDoc.spec.ts`) and under the real browser DOM\n * in production. `createElement` is used rather than mounting into the page so\n * nothing is ever attached to the document.\n */\n\nlet sharedEditor: Editor | null = null;\n\n/**\n * Lazily build (and memoize) the single headless editor. Throws if no DOM is\n * available — this primitive is for the client / jsdom-style test envs only.\n */\nfunction getSharedEditor(): Editor {\n  if (sharedEditor) return sharedEditor;\n  if (typeof document === \"undefined\") {\n    throw new Error(\n      \"gfmDoc requires a DOM (document). It runs in the browser and in jsdom/happy-dom tests, not in a bare Node server context.\",\n    );\n  }\n  sharedEditor = new Editor({\n    element: document.createElement(\"div\"),\n    extensions: createSharedEditorExtensions({\n      dialect: \"gfm\",\n      features: { image: true },\n      extraExtensions: [RunId],\n    }),\n    content: \"\",\n  });\n  return sharedEditor;\n}\n\n/** Reads the GFM markdown out of the tiptap-markdown storage. */\nfunction getMarkdown(editor: Editor): string {\n  const storage = editor.storage as unknown as {\n    markdown?: { getMarkdown?: () => string };\n  };\n  return storage.markdown?.getMarkdown?.() ?? \"\";\n}\n\n/**\n * Parse a GFM markdown string into an array of top-level ProseMirror node JSON\n * (paragraph / heading / list / table / code block / etc.), matching the live\n * plan editor schema (`createSharedEditorExtensions({ dialect: \"gfm\",\n * features: { image: true } })`) plus the {@link RunId} attribute.\n *\n * `tiptap-markdown` registers the markdown parser, so handing the raw markdown\n * string to `setContent` deserializes it (the same path the live editor uses\n * when it seeds `content: markdown`). Returns the doc's child nodes; an empty\n * string yields a single empty paragraph.\n */\nexport function gfmToProseJSON(markdown: string): JSONContent[] {\n  const editor = getSharedEditor();\n  // `emitUpdate: false` keeps this a pure transform with no side effects on any\n  // (non-existent) consumers of the headless editor's update stream.\n  editor.commands.setContent(markdown, { emitUpdate: false });\n  return editor.getJSON().content ?? [];\n}\n\n/**\n * Serialize an array of top-level ProseMirror node JSON into GFM markdown. The\n * `runId` attribute is omitted by GFM (the {@link RunId} extension registers no\n * markdown serializer), so it never leaks into the saved markdown.\n *\n * The nodes are wrapped in a `doc` and set on the shared editor, then the GFM\n * markdown is read from the tiptap-markdown storage — the exact serializer the\n * live editor persists with, so output is byte-stable with the live save path.\n */\nexport function proseJSONToGfm(nodes: JSONContent[]): string {\n  const editor = getSharedEditor();\n  const content = nodes.length > 0 ? nodes : [{ type: \"paragraph\" }];\n  editor.commands.setContent({ type: \"doc\", content }, { emitUpdate: false });\n  return getMarkdown(editor);\n}\n"]}

package/dist/client/rich-markdown-editor/surgical-apply.d.ts

@@ -1,66 +0,0 @@
-/**
- * Surgical reconcile — apply an authoritative external document into the live
- * editor by replacing only the changed top-level node run, instead of a
- * whole-document `setContent`.
- *
- * Why: under the Collaboration extension, `setContent` routes through
- * y-prosemirror and rewrites the ENTIRE `Y.XmlFragment`. Every block-level
- * NodeView is torn down and recreated (each `ReactRenderer` constructor calls
- * `flushSync`, firing inside a React lifecycle), remote carets jump, and the
- * CRDT sees a delete-all + insert-all instead of a small edit. Diffing the
- * top-level children and dispatching one `tr.replaceWith(from, to, changed)`
- * leaves unchanged NodeViews untouched and produces minimal Yjs ops.
- *
- * This is the core mechanism behind re-enabling single-doc collab in the plan
- * editor (see templates/plan/shared/plan-doc.collab-stability.spec.ts, "Option
- * B") and removing agent-edit NodeView churn in content.
- */
-import type { Node as ProseMirrorNode } from "@tiptap/pm/model";
-import type { Editor } from "@tiptap/react";
-/**
- * Transaction meta marking programmatic (non-user) rich-markdown transactions.
- * Declared here (not in useCollabReconcile) so the module dependency stays
- * one-directional; useCollabReconcile re-exports it for consumers.
- */
-export declare const RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION = "an-rich-md-programmatic-transaction";
-export interface TopLevelDiff {
-    /** Index of the first differing top-level child. */
-    fromIndex: number;
-    /** Exclusive end index of the differing run in the OLD doc. */
-    oldToIndex: number;
-    /** Exclusive end index of the differing run in the NEW doc. */
-    newToIndex: number;
-    /** Document position where the differing run starts. */
-    fromPos: number;
-    /** Document position where the differing run ends in the OLD doc. */
-    toPos: number;
-}
-/**
- * Diff two documents at top-level-node granularity: trim the common prefix and
- * suffix (node equality via ProseMirror's `Node.eq`, which is deep) and return
- * the remaining changed run. Returns null when the documents are equal.
- */
-export declare function diffTopLevel(oldDoc: ProseMirrorNode, newDoc: ProseMirrorNode): TopLevelDiff | null;
-/**
- * Replace only the changed top-level run of the live document with the
- * corresponding run from `newDoc`, in one programmatic, history-free
- * transaction. Returns:
- *  - "applied"   — a targeted replacement was dispatched
- *  - "noop"      — the documents were already equal (nothing dispatched)
- *  - "failed"    — the diff/transaction could not be applied (schema mismatch,
- *                  invalid content, …); caller should fall back to setContent.
- */
-export declare function applyDocSurgically(editor: Editor, newDoc: ProseMirrorNode): "applied" | "noop" | "failed";
-/**
- * Best-effort default parser for the surgical path: use the tiptap-markdown
- * storage parser (present when the shared editor's `features.markdown` is on)
- * to turn the authoritative markdown into a ProseMirror document. Returns null
- * when unavailable or when parsing fails — the caller falls back to the full
- * `setContent` path.
- *
- * Apps with their own serializers (Content's NFM, Plan's blocks[] doc) should
- * pass an explicit `parseValue` producing the exact doc their `setContent`
- * would have written.
- */
-export declare function defaultParseValue(editor: Editor, value: string): ProseMirrorNode | null;
-//# sourceMappingURL=surgical-apply.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"surgical-apply.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/surgical-apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAY,IAAI,IAAI,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,sCAAsC,wCACZ,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,YAAY,GAAG,IAAI,CAkCrB;AA0CD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,eAAe,GACtB,SAAS,GAAG,MAAM,GAAG,QAAQ,CAuB/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,eAAe,GAAG,IAAI,CAaxB"}

package/dist/client/rich-markdown-editor/surgical-apply.js

@@ -1,147 +0,0 @@
-/**
- * Surgical reconcile — apply an authoritative external document into the live
- * editor by replacing only the changed top-level node run, instead of a
- * whole-document `setContent`.
- *
- * Why: under the Collaboration extension, `setContent` routes through
- * y-prosemirror and rewrites the ENTIRE `Y.XmlFragment`. Every block-level
- * NodeView is torn down and recreated (each `ReactRenderer` constructor calls
- * `flushSync`, firing inside a React lifecycle), remote carets jump, and the
- * CRDT sees a delete-all + insert-all instead of a small edit. Diffing the
- * top-level children and dispatching one `tr.replaceWith(from, to, changed)`
- * leaves unchanged NodeViews untouched and produces minimal Yjs ops.
- *
- * This is the core mechanism behind re-enabling single-doc collab in the plan
- * editor (see templates/plan/shared/plan-doc.collab-stability.spec.ts, "Option
- * B") and removing agent-edit NodeView churn in content.
- */
-import { createNodeFromContent } from "@tiptap/core";
-/**
- * Transaction meta marking programmatic (non-user) rich-markdown transactions.
- * Declared here (not in useCollabReconcile) so the module dependency stays
- * one-directional; useCollabReconcile re-exports it for consumers.
- */
-export const RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION = "an-rich-md-programmatic-transaction";
-/**
- * Diff two documents at top-level-node granularity: trim the common prefix and
- * suffix (node equality via ProseMirror's `Node.eq`, which is deep) and return
- * the remaining changed run. Returns null when the documents are equal.
- */
-export function diffTopLevel(oldDoc, newDoc) {
-    const oldCount = oldDoc.childCount;
-    const newCount = newDoc.childCount;
-    let prefix = 0;
-    const maxPrefix = Math.min(oldCount, newCount);
-    while (prefix < maxPrefix && oldDoc.child(prefix).eq(newDoc.child(prefix))) {
-        prefix++;
-    }
-    if (prefix === oldCount && prefix === newCount)
-        return null; // identical
-    let suffix = 0;
-    const maxSuffix = Math.min(oldCount, newCount) - prefix;
-    while (suffix < maxSuffix &&
-        oldDoc.child(oldCount - 1 - suffix).eq(newDoc.child(newCount - 1 - suffix))) {
-        suffix++;
-    }
-    const fromIndex = prefix;
-    const oldToIndex = oldCount - suffix;
-    const newToIndex = newCount - suffix;
-    // Positions: sum nodeSize of the preserved prefix, then of the changed run.
-    let fromPos = 0;
-    for (let i = 0; i < fromIndex; i++)
-        fromPos += oldDoc.child(i).nodeSize;
-    let toPos = fromPos;
-    for (let i = fromIndex; i < oldToIndex; i++) {
-        toPos += oldDoc.child(i).nodeSize;
-    }
-    return { fromIndex, oldToIndex, newToIndex, fromPos, toPos };
-}
-function changedFragment(newDoc, diff) {
-    return newDoc.content.cut(positionOfChild(newDoc, diff.fromIndex), positionOfChild(newDoc, diff.newToIndex));
-}
-function positionOfChild(doc, index) {
-    let pos = 0;
-    for (let i = 0; i < index; i++)
-        pos += doc.child(i).nodeSize;
-    return pos;
-}
-function isEmptyParagraph(node) {
-    return !!node && node.type.name === "paragraph" && node.content.size === 0;
-}
-/**
- * Markdown can't represent a trailing empty paragraph (the cursor line users
- * keep below a list/code block), so a parsed authoritative value never has
- * one — but the live doc often does, and the legacy `setContent` path
- * preserves it. Without this, every surgical reconcile whose old doc ends
- * with an empty paragraph would DELETE the user's trailing cursor line.
- */
-function withPreservedTrailingParagraph(oldDoc, newDoc) {
-    const oldLast = oldDoc.childCount > 0 ? oldDoc.child(oldDoc.childCount - 1) : null;
-    if (!isEmptyParagraph(oldLast))
-        return newDoc;
-    const newLast = newDoc.childCount > 0 ? newDoc.child(newDoc.childCount - 1) : null;
-    if (isEmptyParagraph(newLast))
-        return newDoc;
-    return newDoc.copy(newDoc.content.addToEnd(oldLast.type.create()));
-}
-/**
- * Replace only the changed top-level run of the live document with the
- * corresponding run from `newDoc`, in one programmatic, history-free
- * transaction. Returns:
- *  - "applied"   — a targeted replacement was dispatched
- *  - "noop"      — the documents were already equal (nothing dispatched)
- *  - "failed"    — the diff/transaction could not be applied (schema mismatch,
- *                  invalid content, …); caller should fall back to setContent.
- */
-export function applyDocSurgically(editor, newDoc) {
-    try {
-        const oldDoc = editor.state.doc;
-        // The parsed doc MUST come from this editor's schema — NodeType identity
-        // is per-Schema-instance, so a foreign-schema doc can never diff or apply.
-        if (newDoc.type.schema !== editor.schema || newDoc.type !== oldDoc.type) {
-            return "failed";
-        }
-        const target = withPreservedTrailingParagraph(oldDoc, newDoc);
-        const diff = diffTopLevel(oldDoc, target);
-        if (!diff)
-            return "noop";
-        const fragment = changedFragment(target, diff);
-        const tr = editor.state.tr;
-        tr.replaceWith(diff.fromPos, diff.toPos, fragment);
-        tr.setMeta("addToHistory", false);
-        tr.setMeta(RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION, true);
-        editor.view.dispatch(tr);
-        return "applied";
-    }
-    catch {
-        return "failed";
-    }
-}
-/**
- * Best-effort default parser for the surgical path: use the tiptap-markdown
- * storage parser (present when the shared editor's `features.markdown` is on)
- * to turn the authoritative markdown into a ProseMirror document. Returns null
- * when unavailable or when parsing fails — the caller falls back to the full
- * `setContent` path.
- *
- * Apps with their own serializers (Content's NFM, Plan's blocks[] doc) should
- * pass an explicit `parseValue` producing the exact doc their `setContent`
- * would have written.
- */
-export function defaultParseValue(editor, value) {
-    try {
-        const storage = editor.storage.markdown;
-        const parsed = storage?.parser?.parse?.(value, { inline: false });
-        if (typeof parsed !== "string" || !parsed)
-            return null;
-        const node = createNodeFromContent(parsed, editor.schema, {
-            slice: false,
-        });
-        // createNodeFromContent with slice:false returns a Node (the doc).
-        return node ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=surgical-apply.js.map