@agent-native/core 0.109.2 → 0.109.4

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

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

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

@@ -1,110 +0,0 @@
-import type { Node as ProseMirrorNode } from "@tiptap/pm/model";
-import type { Transaction } from "@tiptap/pm/state";
-import type { Editor } from "@tiptap/react";
-import { type MutableRefObject } from "react";
-import type { Awareness } from "y-protocols/awareness";
-import type { Doc as YDoc } from "yjs";
-import { RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION } from "./surgical-apply.js";
-export { RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION };
-/** 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;
-    /** True after the collab provider has loaded the persisted initial Y.Doc state. */
-    collabSynced?: boolean;
-    /** 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;
-    /**
-     * Parses the authoritative `value` into a full ProseMirror document for the
-     * SURGICAL reconcile path: instead of a whole-document `setContent` (which
-     * under Collaboration rewrites the entire Y.XmlFragment and tears down every
-     * block NodeView), the reconcile diffs the parsed doc against the live doc
-     * and replaces only the changed top-level run. Return null to skip the
-     * surgical path for a given value (falls back to `setContent`).
-     *
-     * Defaults to a best-effort tiptap-markdown parse; apps with their own
-     * serializers (Content's NFM, Plan's blocks[] doc) should supply the exact
-     * doc their `setContent` would write. Pass `false` to disable surgical
-     * application entirely.
-     */
-    parseValue?: ((editor: Editor, value: string) => ProseMirrorNode | null) | false;
-    /**
-     * 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, collabSynced, awareness, value, contentUpdatedAt, editable, getMarkdown, setContent, parseValue, normalizeValue, shouldSeed, initialAppliedUpdatedAt, }: UseCollabReconcileOptions): UseCollabReconcileResult;
-//# sourceMappingURL=useCollabReconcile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useCollabReconcile.d.ts","sourceRoot":"","sources":["../../../src/client/rich-markdown-editor/useCollabReconcile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,IAAI,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,GAAG,IAAI,IAAI,EAAE,MAAM,KAAK,CAAC;AAIvC,OAAO,EACL,sCAAsC,EAGvC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,sCAAsC,EAAE,CAAC;AAElD,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKxD;AAqBD,MAAM,WAAW,yBAAyB;IACxC,gDAAgD;IAChD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uEAAuE;IACvE,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACnB,mFAAmF;IACnF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,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;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EACP,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,eAAe,GAAG,IAAI,CAAC,GAC3D,KAAK,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,YAAmB,EACnB,SAAgB,EAChB,KAAK,EACL,gBAAgB,EAChB,QAAQ,EACR,WAA+B,EAC/B,UAA8B,EAC9B,UAAU,EACV,cAAyB,EACzB,UAA8B,EAC9B,uBAAuB,GACxB,EAAE,yBAAyB,GAAG,wBAAwB,CAyWtD"}

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

@@ -1,441 +0,0 @@
-import { isChangeOrigin } from "@tiptap/extension-collaboration";
-import { useEffect, useRef, useState } from "react";
-import { AGENT_CLIENT_ID } from "../../collab/agent-identity.js";
-import { isReconcileLeadClient } from "../../collab/client.js";
-import { RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION, applyDocSurgically, defaultParseValue, } from "./surgical-apply.js";
-export { RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION };
-/** Reads the current markdown out of the tiptap-markdown storage. */
-export function getEditorMarkdown(editor) {
-    const markdownStorage = editor.storage;
-    return markdownStorage.markdown?.getMarkdown?.() ?? "";
-}
-/**
- * Push a value onto the bounded ring of recently-emitted markdown (most recent
- * last, deduped, capped). The reconcile uses this to recognize a stale-but-recent
- * echo of OUR OWN edits: a debounced autosave can persist a PARTIAL burst, and
- * the next poll re-supplies that partial value with a newer timestamp — applying
- * it would clobber the freshly-typed tail. An external change (agent/peer) never
- * byte-matches one of our own recent emissions, and if it somehow did the content
- * is identical, so skipping it is safe by construction.
- */
-const EMITTED_RING_MAX = 16;
-function pushEmittedRing(ring, value) {
-    if (!value)
-        return;
-    if (ring[ring.length - 1] === value)
-        return;
-    const dupe = ring.indexOf(value);
-    if (dupe !== -1)
-        ring.splice(dupe, 1);
-    ring.push(value);
-    if (ring.length > EMITTED_RING_MAX)
-        ring.shift();
-}
-/**
- * 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, collabSynced = true, awareness = null, value, contentUpdatedAt, editable, getMarkdown = getEditorMarkdown, setContent = defaultSetContent, parseValue, normalizeValue = (v) => v, shouldSeed = defaultShouldSeed, initialAppliedUpdatedAt, }) {
-    const collab = !!ydoc;
-    const isSettingContentRef = useRef(false);
-    const lastEmittedRef = useRef("");
-    // Ring of recent local emissions (see pushEmittedRing). Lets the reconcile
-    // recognize a stale-but-recent echo of our OWN (possibly partial, debounced)
-    // save so a lagging poll never clobbers freshly-typed text.
-    const recentEmittedRef = 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 (!collabSynced)
-            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 })) {
-            seededRef.current = true;
-            return;
-        }
-        let cancelled = false;
-        // Defer via a timer task (NOT a microtask — microtasks can still run
-        // inside React's commit and trigger flushSync-from-lifecycle warnings).
-        const seedTimer = setTimeout(() => {
-            if (cancelled || editor.isDestroyed)
-                return;
-            isSettingContentRef.current = true;
-            try {
-                setContent(editor, value, {});
-            }
-            finally {
-                isSettingContentRef.current = false;
-            }
-            const serialized = getMarkdown(editor);
-            lastEmittedRef.current = serialized;
-            pushEmittedRing(recentEmittedRef.current, serialized);
-            lastAppliedValueRef.current = value;
-            lastAppliedSerializedRef.current = serialized;
-            if (contentUpdatedAt)
-                lastAppliedUpdatedAtRef.current = contentUpdatedAt;
-            seededRef.current = true;
-        }, 0);
-        return () => {
-            cancelled = true;
-            clearTimeout(seedTimer);
-        };
-    }, [
-        collab,
-        collabSynced,
-        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 && (!collabSynced || !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;
-            const typingRecently = editor.isFocused && Date.now() - lastTypedAtRef.current < 1500;
-            // 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 ||
-                (typingRecently &&
-                    // A stale echo of our own (possibly partial) save while the user is
-                    // actively typing would clobber the fresh tail. Outside active
-                    // typing, the same bytes can be a deliberate newer external revert
-                    // (history restore / provider conflict choice) and must be allowed
-                    // through even if mount-time normalization emitted them.
-                    (value === lastEmittedRef.current ||
-                        recentEmittedRef.current.includes(value) ||
-                        recentEmittedRef.current.includes(normalizedValue))) ||
-                (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.
-            if (typingRecently) {
-                if (externalNewer) {
-                    retry = setTimeout(() => apply(deferred), 700);
-                }
-                return;
-            }
-            // Older-or-equal content is a stale poll / lagging echo. Drop it while
-            // focused (a peer/agent edit would be NEWER and retries above). In
-            // NON-COLLAB mode there is no peer, so older-or-equal external content is
-            // ALWAYS stale — dropping it regardless of focus stops a lagging
-            // `get-visual-plan` poll from reverting a just-applied local structural
-            // change (drag-to-columns) while the editor is blurred (the drag grips the
-            // handle, not the prose, so `isFocused` is false at drop time). Gated on
-            // `lastAppliedSerializedRef` so the very first seed (nothing applied yet,
-            // also not-newer) still lands.
-            const seeded = lastAppliedSerializedRef.current !== null;
-            if (!externalNewer && (editor.isFocused || (!collab && seeded)))
-                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;
-            }
-            const applyTimer = setTimeout(() => {
-                if (cancelled || editor.isDestroyed)
-                    return;
-                // Re-check doc-equivalence at apply time. Between the decision above and
-                // this task 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;
-                // Surgical path first: replace only the changed top-level run so
-                // unchanged block NodeViews are never torn down and (under
-                // Collaboration) Yjs sees a minimal edit instead of a full-fragment
-                // rewrite. Falls back to the classic whole-document setContent when no
-                // parser is available or the targeted transaction cannot be applied.
-                let appliedSurgically = false;
-                if (parseValue !== false) {
-                    const parse = parseValue ?? defaultParseValue;
-                    const parsedDoc = parse(editor, value);
-                    if (parsedDoc) {
-                        const result = applyDocSurgically(editor, parsedDoc);
-                        appliedSurgically = result === "applied" || result === "noop";
-                    }
-                }
-                if (!appliedSurgically) {
-                    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;
-                pushEmittedRing(recentEmittedRef.current, serialized);
-                lastAppliedValueRef.current = value;
-                lastAppliedSerializedRef.current = serialized;
-                if (contentUpdatedAt) {
-                    lastAppliedUpdatedAtRef.current = contentUpdatedAt;
-                }
-            }, 0);
-            retry = applyTimer;
-        };
-        apply();
-        return () => {
-            cancelled = true;
-            if (retry)
-                clearTimeout(retry);
-        };
-    }, [
-        contentUpdatedAt,
-        editor,
-        value,
-        collab,
-        collabSynced,
-        isLeadClient,
-        getMarkdown,
-        setContent,
-        parseValue,
-        normalizeValue,
-    ]);
-    const shouldIgnoreUpdate = (transaction) => {
-        if (!editable || isSettingContentRef.current)
-            return true;
-        // Collaboration can emit schema/default-paragraph transactions while the
-        // persisted Y.Doc is still loading and before the authoritative value has
-        // seeded/reconciled. Never let those transient pre-seed updates reach an
-        // app's local mirror or autosave path (Content serializes an empty paragraph
-        // as `<empty-block/>`, which is non-empty text and bypasses the generic
-        // registerEmitted empty-string guard).
-        if (collab && !seededRef.current)
-            return true;
-        if (transaction.getMeta(RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION)) {
-            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;
-        pushEmittedRing(recentEmittedRef.current, markdown);
-        return true;
-    };
-    return {
-        collab,
-        isSettingContentRef,
-        shouldIgnoreUpdate,
-        registerEmitted,
-    };
-}
-//# sourceMappingURL=useCollabReconcile.js.map