greprag 5.79.0 → 5.82.0

package/dist/node-identity.bundle.js

@@ -0,0 +1,1166 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// <stdin>
+var stdin_exports = {};
+__export(stdin_exports, {
+  CONTAINER_TYPES: () => CONTAINER_TYPES,
+  GRAPH_VERSION: () => GRAPH_VERSION,
+  GRAVEYARD_CAP: () => GRAVEYARD_CAP,
+  ZERO_STRUCTURE: () => ZERO_STRUCTURE,
+  bootstrapPreviousNodes: () => bootstrapPreviousNodes,
+  fingerprint: () => fingerprint2,
+  fingerprintAll: () => fingerprintAll2,
+  hashBody: () => hashBody,
+  isExactMatch: () => isExactMatch2,
+  isSameContent: () => isSameContent,
+  makeMinter: () => makeMinter,
+  markdownToBlocks: () => markdownToBlocks,
+  matchNodes: () => matchNodes,
+  parseNodeGraph: () => parseNodeGraph,
+  rebuildPreviousFromResult: () => rebuildPreviousFromResult,
+  reconcile: () => reconcile,
+  sentenceArraysEqual: () => sentenceArraysEqual,
+  sentenceSignalOverlapScore: () => sentenceSignalOverlapScore,
+  sentenceTuplesEqual: () => sentenceTuplesEqual,
+  serializeNodeGraph: () => serializeNodeGraph,
+  shareAnySentenceTuple: () => shareAnySentenceTuple,
+  sidecarPathFor: () => sidecarPathFor,
+  simpleHash: () => simpleHash2,
+  splitSentences: () => splitSentences2,
+  tokenizeWords: () => tokenizeWords
+});
+module.exports = __toCommonJS(stdin_exports);
+
+// ../core/src/node-graph/markdown-walker.ts
+var MIN_CHUNK_WORDS = 30;
+var MAX_CHUNK_WORDS = 300;
+function markdownToBlocks(markdown, options = {}) {
+  if (!markdown || !markdown.trim())
+    return [];
+  const minWords = options.minWords ?? MIN_CHUNK_WORDS;
+  const maxWords = options.maxWords ?? MAX_CHUNK_WORDS;
+  const rawBlocks = parseRawBlocks(markdown);
+  const sized = applySizeRules(rawBlocks, minWords, maxWords);
+  return emitBlocks(sized);
+}
+function parseRawBlocks(markdown) {
+  const blocks = [];
+  const lines = markdown.split("\n");
+  let i = 0;
+  if (lines[0]?.trim() === "---") {
+    i = 1;
+    while (i < lines.length && lines[i].trim() !== "---")
+      i++;
+    i++;
+  }
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    const fenceMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const fence = fenceMatch[1];
+      const language = fenceMatch[2].trim() || void 0;
+      const codeLines = [];
+      i++;
+      while (i < lines.length) {
+        if (lines[i].trim().startsWith(fence[0].repeat(fence.length))) {
+          i++;
+          break;
+        }
+        codeLines.push(lines[i]);
+        i++;
+      }
+      blocks.push({ type: "code", text: codeLines.join("\n"), language });
+      continue;
+    }
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+      blocks.push({ type: "horizontalRule", text: "" });
+      i++;
+      continue;
+    }
+    const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      blocks.push({
+        type: "heading",
+        text: headingMatch[2].trim(),
+        level: headingMatch[1].length
+      });
+      i++;
+      continue;
+    }
+    if (trimmed.includes("|") && i + 1 < lines.length && /^\|?[\s\-:|]+\|/.test(lines[i + 1]?.trim() || "")) {
+      const tableLines = [line];
+      i++;
+      while (i < lines.length && lines[i].trim().includes("|")) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      blocks.push({ type: "table", text: tableLines.join("\n") });
+      continue;
+    }
+    if (trimmed.startsWith(">")) {
+      const quoteLines = [];
+      while (i < lines.length) {
+        const t = lines[i].trim();
+        if (t.startsWith(">")) {
+          quoteLines.push(t.replace(/^>\s?/, ""));
+          i++;
+        } else if (t === "") {
+          break;
+        } else {
+          break;
+        }
+      }
+      blocks.push({ type: "blockquote", text: quoteLines.join("\n") });
+      continue;
+    }
+    if (/^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) {
+      const items = [];
+      let current = [];
+      const flushItem = () => {
+        if (current.length > 0) {
+          items.push(current.join("\n").trim());
+          current = [];
+        }
+      };
+      while (i < lines.length) {
+        const t = lines[i].trim();
+        if (/^[-*+]\s/.test(t) || /^\d+\.\s/.test(t)) {
+          flushItem();
+          current.push(t.replace(/^([-*+]|\d+\.)\s+/, ""));
+          i++;
+        } else if (t === "") {
+          const next = lines[i + 1]?.trim() || "";
+          if (/^[-*+]\s/.test(next) || /^\d+\.\s/.test(next) || next.startsWith("  ") || next.startsWith("	")) {
+            i++;
+            continue;
+          }
+          break;
+        } else if (lines[i].startsWith("  ") || lines[i].startsWith("	")) {
+          current.push(t);
+          i++;
+        } else {
+          break;
+        }
+      }
+      flushItem();
+      if (items.length > 0) {
+        blocks.push({ type: "list", text: "", listItems: items });
+      }
+      continue;
+    }
+    const paraLines = [line];
+    i++;
+    while (i < lines.length) {
+      const t = lines[i].trim();
+      if (t === "" || /^#{1,6}\s/.test(t) || /^(`{3,}|~{3,})/.test(t) || t.startsWith(">") || /^[-*+]\s/.test(t) || /^\d+\.\s/.test(t) || t.startsWith("|") && t.endsWith("|")) {
+        break;
+      }
+      paraLines.push(lines[i]);
+      i++;
+    }
+    blocks.push({ type: "paragraph", text: paraLines.join(" ").trim() });
+  }
+  return blocks;
+}
+var SENTENCE_BOUNDARY = /(?<=[.!?])\s+(?=[A-Z])/;
+function countWords(text) {
+  return text.trim().split(/\s+/).filter((w) => w.length > 0).length;
+}
+function splitTable(block, maxWords) {
+  if (countWords(block.text) <= maxWords)
+    return [block];
+  const lines = block.text.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length < 3)
+    return [block];
+  const header = lines[0];
+  const sep = lines[1];
+  const headerWords = countWords(header) + countWords(sep);
+  const out = [];
+  let buf = [];
+  let bufWords = 0;
+  const flush = () => {
+    if (buf.length > 0) {
+      out.push({ type: "table", text: [header, sep, ...buf].join("\n") });
+      buf = [];
+      bufWords = 0;
+    }
+  };
+  for (const row of lines.slice(2)) {
+    const rw = countWords(row);
+    if (buf.length > 0 && headerWords + bufWords + rw > maxWords)
+      flush();
+    buf.push(row);
+    bufWords += rw;
+  }
+  flush();
+  return out.length > 0 ? out : [block];
+}
+function applySizeRules(raw, minWords, maxWords) {
+  const out = [];
+  for (const block of raw) {
+    if (block.type === "table") {
+      out.push(...splitTable(block, maxWords));
+      continue;
+    }
+    if (block.type !== "paragraph") {
+      out.push(block);
+      continue;
+    }
+    const words = countWords(block.text);
+    if (words <= maxWords) {
+      out.push(block);
+      continue;
+    }
+    const sentences = block.text.split(SENTENCE_BOUNDARY);
+    let buf = [];
+    let bufWords = 0;
+    for (const s of sentences) {
+      const sw = countWords(s);
+      if (bufWords + sw > maxWords && buf.length > 0) {
+        out.push({ type: "paragraph", text: buf.join(" ").trim() });
+        buf = [s];
+        bufWords = sw;
+      } else {
+        buf.push(s);
+        bufWords += sw;
+      }
+    }
+    if (buf.length > 0) {
+      out.push({ type: "paragraph", text: buf.join(" ").trim() });
+    }
+  }
+  return out;
+}
+function emitBlocks(raw) {
+  const out = [];
+  const headingStack = [];
+  const levelStack = [];
+  let topLevelOrdinal = 0;
+  const currentHeadingPath = () => [...headingStack];
+  for (const r of raw) {
+    if (r.type === "heading") {
+      const lvl = r.level || 1;
+      while (levelStack.length > 0 && levelStack[levelStack.length - 1] >= lvl) {
+        levelStack.pop();
+        headingStack.pop();
+      }
+      const pathForHeading = [...headingStack];
+      headingStack.push(r.text);
+      levelStack.push(lvl);
+      out.push({
+        position: out.length,
+        type: "heading",
+        text: r.text,
+        parentPosition: null,
+        ordinalInParent: topLevelOrdinal++,
+        level: lvl,
+        headingPath: pathForHeading
+      });
+      continue;
+    }
+    if (r.type === "list" && r.listItems) {
+      const listPos = out.length;
+      out.push({
+        position: listPos,
+        type: "list",
+        text: "",
+        parentPosition: null,
+        ordinalInParent: topLevelOrdinal++,
+        headingPath: currentHeadingPath()
+      });
+      let itemOrdinal = 0;
+      for (const itemText of r.listItems) {
+        out.push({
+          position: out.length,
+          type: "listItem",
+          text: itemText,
+          parentPosition: listPos,
+          ordinalInParent: itemOrdinal++,
+          headingPath: currentHeadingPath()
+        });
+      }
+      continue;
+    }
+    out.push({
+      position: out.length,
+      type: r.type,
+      text: r.text,
+      parentPosition: null,
+      ordinalInParent: topLevelOrdinal++,
+      language: r.language,
+      headingPath: currentHeadingPath()
+    });
+  }
+  return out;
+}
+
+// ../core/src/node-identity/types.ts
+var ZERO_STRUCTURE = { bold: 0, italic: 0, links: 0, code: 0 };
+var CONTAINER_TYPES = ["list"];
+
+// ../core/src/node-identity/fingerprint.ts
+var WORD_FALLBACK_WINDOW = 5;
+var PREFIX_LEN = 3;
+function fingerprint2(block, allBlocks) {
+  const text = block.text || "";
+  const sentences = splitSentences2(text);
+  const words = tokenizeWords(text);
+  const fp = {
+    type: block.type,
+    position: block.position,
+    parentPosition: block.parentPosition,
+    ordinalInParent: block.ordinalInParent,
+    charCount: text.length,
+    sentenceCount: sentences.length,
+    wordCount: words.length,
+    sentences: sentences.map(sentenceTuple),
+    structureSig: block.inlineMarks || ZERO_STRUCTURE,
+    prevType: allBlocks[block.position - 1]?.type ?? null,
+    nextType: allBlocks[block.position + 1]?.type ?? null,
+    parentType: block.parentPosition != null ? allBlocks[block.parentPosition]?.type ?? null : null,
+    firstWords: words.slice(0, WORD_FALLBACK_WINDOW),
+    lastWords: words.slice(-WORD_FALLBACK_WINDOW)
+  };
+  if (block.type === "heading")
+    fp.level = block.level;
+  if (block.type === "code") {
+    fp.language = block.language || "";
+    fp.contentHash = simpleHash2(text);
+  }
+  if (CONTAINER_TYPES.includes(block.type)) {
+    const children = allBlocks.filter((b) => b.parentPosition === block.position);
+    fp.childCount = children.length;
+    fp.childTypes = children.map((c) => c.type);
+  }
+  return fp;
+}
+function fingerprintAll2(blocks) {
+  return blocks.map((b) => fingerprint2(b, blocks));
+}
+function isExactMatch2(a, b) {
+  if (a.type !== b.type)
+    return false;
+  if (a.level !== b.level)
+    return false;
+  if (a.language !== b.language)
+    return false;
+  if (a.charCount !== b.charCount)
+    return false;
+  if (a.sentenceCount !== b.sentenceCount)
+    return false;
+  if (a.wordCount !== b.wordCount)
+    return false;
+  if (!sentenceArraysEqual(a.sentences, b.sentences))
+    return false;
+  if (!structureEqual(a.structureSig, b.structureSig))
+    return false;
+  if (a.childCount != null || b.childCount != null) {
+    if (a.childCount !== b.childCount)
+      return false;
+    if (!arraysEqual(a.childTypes, b.childTypes))
+      return false;
+  }
+  return true;
+}
+function isSameContent(a, b) {
+  const aIsContainer = a.childCount != null;
+  const bIsContainer = b.childCount != null;
+  if (aIsContainer !== bIsContainer)
+    return false;
+  if (aIsContainer) {
+    return a.childCount === b.childCount && arraysEqual(a.childTypes, b.childTypes);
+  }
+  if (a.sentences != null && b.sentences != null) {
+    if (!sentenceArraysEqual(a.sentences, b.sentences))
+      return false;
+    return structureEqual(a.structureSig, b.structureSig);
+  }
+  return false;
+}
+function sentenceTuplesEqual(a, b) {
+  return a.c === b.c && a.f === b.f && a.l === b.l && a.t === b.t && arraysEqual(a.wls, b.wls) && arraysEqual(a.w, b.w);
+}
+function sentenceArraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b))
+    return false;
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!sentenceTuplesEqual(a[i], b[i]))
+      return false;
+  }
+  return true;
+}
+function shareAnySentenceTuple(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b))
+    return false;
+  for (const sa of a) {
+    for (const sb of b) {
+      if (sentenceTuplesEqual(sa, sb))
+        return true;
+    }
+  }
+  return false;
+}
+function sentenceSignalOverlapScore(a, b) {
+  if (!a.sentences || !b.sentences)
+    return 0;
+  let score = 0;
+  for (const sa of a.sentences) {
+    for (const sb of b.sentences) {
+      if (sa.f === sb.f)
+        score++;
+      if (sa.l === sb.l)
+        score++;
+      if (sa.t === sb.t)
+        score++;
+      if (arraysEqual(sa.wls, sb.wls))
+        score += 2;
+      if (Array.isArray(sa.w) && Array.isArray(sb.w)) {
+        const aSet = new Set(sa.w);
+        let shared = 0;
+        for (const w of sb.w)
+          if (aSet.has(w))
+            shared++;
+        score += shared * 3;
+        if (arraysEqual(sa.w, sb.w))
+          score += 10;
+      }
+    }
+  }
+  return score;
+}
+function splitSentences2(text) {
+  if (!text)
+    return [];
+  const sentences = [];
+  const re = /([^.!?]+?)([.!?]+)(\s+|$)/g;
+  let lastIdx = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const term = m[2][0];
+    sentences.push({
+      text: m[1].trim(),
+      terminator: term === "." ? "D" : term === "!" ? "E" : term === "?" ? "Q" : "-"
+    });
+    lastIdx = re.lastIndex;
+  }
+  if (lastIdx < text.length) {
+    const remaining = text.slice(lastIdx).trim();
+    if (remaining)
+      sentences.push({ text: remaining, terminator: "-" });
+  }
+  return sentences;
+}
+function tokenizeWords(text) {
+  if (!text)
+    return [];
+  return text.split(/\s+/).map((w) => w.replace(/^[^\w]+|[^\w]+$/g, "")).filter((w) => w.length > 0);
+}
+function simpleHash2(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i);
+    h |= 0;
+  }
+  return h.toString(16);
+}
+function sentenceTuple(sentence) {
+  const t = sentence.text;
+  const words = tokenizeWords(t);
+  return {
+    c: t.length,
+    f: t.slice(0, PREFIX_LEN),
+    l: t.slice(-PREFIX_LEN),
+    t: sentence.terminator,
+    wls: words.map((w) => w.length),
+    w: words
+  };
+}
+function arraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b))
+    return false;
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+}
+function structureEqual(a, b) {
+  if (!a || !b)
+    return false;
+  return a.bold === b.bold && a.italic === b.italic && a.links === b.links && a.code === b.code;
+}
+
+// ../core/src/node-identity/matcher.ts
+function matchNodes(previousNodes, newBlocks, options = {}) {
+  const graveyard = options.graveyard || [];
+  const mintId = options.mintId || defaultMintId;
+  const newFingerprints = fingerprintAll2(newBlocks);
+  const pinned = [];
+  const claimedPrevIds = /* @__PURE__ */ new Set();
+  const claimedGraveIds = /* @__PURE__ */ new Set();
+  const unmatched = newBlocks.map((block, i) => ({
+    position: newFingerprints[i].position,
+    fingerprint: newFingerprints[i],
+    block
+  }));
+  pinExactMatches(unmatched, previousNodes, claimedPrevIds, pinned);
+  applySplitRule(unmatched, previousNodes, claimedPrevIds, pinned, mintId);
+  applyMergeRule(unmatched, previousNodes, claimedPrevIds, pinned);
+  applyTypeChangeRule(unmatched, previousNodes, claimedPrevIds, pinned);
+  applyEditRule(unmatched, previousNodes, claimedPrevIds, pinned);
+  applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned);
+  applyGraveyardRestoreRule(unmatched, graveyard, claimedGraveIds, pinned);
+  applyInsertRule(unmatched, pinned, mintId);
+  const orphaned = previousNodes.filter((prev) => !claimedPrevIds.has(prev.id)).map((prev) => ({ id: prev.id, fingerprint: prev.fingerprint }));
+  const remainingGraveyard = graveyard.filter((g) => !claimedGraveIds.has(g.id));
+  const preserved = pinned.filter((p) => p.mutation !== "inserted").length;
+  return {
+    pinned,
+    unmatched,
+    orphaned,
+    graveyardRestored: pinned.filter((p) => p.mutation === "graveyard-restore"),
+    nextGraveyard: [...orphaned, ...remainingGraveyard],
+    summary: {
+      totalBlocks: newBlocks.length,
+      pinnedCount: pinned.length,
+      unmatchedCount: unmatched.length,
+      orphanedCount: orphaned.length,
+      preserved,
+      fresh: pinned.length - preserved
+    }
+  };
+}
+function rebuildPreviousFromResult(result) {
+  return result.pinned.slice().sort((a, b) => a.position - b.position).map((p) => ({ id: p.id, fingerprint: p.fingerprint }));
+}
+function bootstrapPreviousNodes(blocks, mintId = defaultMintId) {
+  const fps = fingerprintAll2(blocks);
+  return blocks.map((_, i) => ({ id: mintId(), fingerprint: fps[i] }));
+}
+function pinExactMatches(unmatched, previousNodes, claimedPrevIds, pinned) {
+  let changedA = true;
+  while (changedA) {
+    changedA = false;
+    const prevToCands = /* @__PURE__ */ new Map();
+    const candToPrevs = /* @__PURE__ */ new Map();
+    for (const prev of previousNodes) {
+      if (claimedPrevIds.has(prev.id))
+        continue;
+      const cands = unmatched.filter((u) => isExactMatch2(prev.fingerprint, u.fingerprint));
+      prevToCands.set(prev.id, cands);
+      for (const c of cands) {
+        if (!candToPrevs.has(c.position))
+          candToPrevs.set(c.position, []);
+        candToPrevs.get(c.position).push(prev);
+      }
+    }
+    for (const [prevId, cands] of prevToCands) {
+      if (claimedPrevIds.has(prevId))
+        continue;
+      if (cands.length !== 1)
+        continue;
+      const cand = cands[0];
+      const prevs = candToPrevs.get(cand.position);
+      if (!prevs || prevs.length !== 1)
+        continue;
+      if (!unmatched.includes(cand))
+        continue;
+      const prev = previousNodes.find((p) => p.id === prevId);
+      const origPos = prev.fingerprint.position;
+      claimedPrevIds.add(prevId);
+      pinned.push({
+        id: prevId,
+        position: cand.position,
+        fingerprint: cand.fingerprint,
+        block: cand.block,
+        mutation: origPos !== cand.position ? "moved" : "unchanged"
+      });
+      unmatched.splice(unmatched.indexOf(cand), 1);
+      changedA = true;
+    }
+  }
+  let changedB = true;
+  while (changedB) {
+    changedB = false;
+    for (const prev of previousNodes) {
+      if (claimedPrevIds.has(prev.id))
+        continue;
+      const candidates = unmatched.filter((u) => isExactMatch2(prev.fingerprint, u.fingerprint));
+      if (candidates.length === 0)
+        continue;
+      const prevIdx = previousNodes.findIndex((p) => p.id === prev.id);
+      const lo = slotLowBound(previousNodes, claimedPrevIds, pinned, prevIdx);
+      const hi = slotHighBound(previousNodes, claimedPrevIds, pinned, prevIdx);
+      let inRange;
+      if (lo + 1 < hi) {
+        inRange = candidates.filter((c) => c.position > lo && c.position < hi);
+      } else if (lo > hi) {
+        inRange = candidates;
+      } else {
+        inRange = [];
+      }
+      if (inRange.length === 0)
+        continue;
+      const origPos = prev.fingerprint.position;
+      const best = nearestBy(inRange, (c) => c.position, origPos);
+      claimedPrevIds.add(prev.id);
+      pinned.push({
+        id: prev.id,
+        position: best.position,
+        fingerprint: best.fingerprint,
+        block: best.block,
+        mutation: origPos !== best.position ? "moved" : "unchanged"
+      });
+      unmatched.splice(unmatched.indexOf(best), 1);
+      changedB = true;
+    }
+  }
+}
+function applySplitRule(unmatched, previousNodes, claimedPrevIds, pinned, mintId) {
+  let progress = true;
+  while (progress) {
+    progress = false;
+    for (const orphan of previousNodes) {
+      if (claimedPrevIds.has(orphan.id))
+        continue;
+      const orphanSents = orphan.fingerprint.sentences;
+      if (!orphanSents || orphanSents.length < 2)
+        continue;
+      let claimed = false;
+      for (let startIdx = 0; startIdx < unmatched.length && !claimed; startIdx++) {
+        const start = unmatched[startIdx];
+        if (start.fingerprint.type !== orphan.fingerprint.type)
+          continue;
+        const group = [startIdx];
+        let concatLen = start.fingerprint.sentences.length;
+        for (let next = startIdx + 1; next < unmatched.length; next++) {
+          const prev = unmatched[next - 1];
+          const cur = unmatched[next];
+          if (cur.position !== prev.position + 1)
+            break;
+          if (cur.fingerprint.type !== orphan.fingerprint.type)
+            break;
+          group.push(next);
+          concatLen += cur.fingerprint.sentences.length;
+          if (concatLen > orphanSents.length)
+            break;
+          if (concatLen < orphanSents.length)
+            continue;
+          const concat = [];
+          for (const gi of group)
+            concat.push(...unmatched[gi].fingerprint.sentences);
+          if (!sentenceArraysEqual(concat, orphanSents))
+            break;
+          claimedPrevIds.add(orphan.id);
+          for (let i = 0; i < group.length; i++) {
+            const c = unmatched[group[i]];
+            pinned.push({
+              id: i === 0 ? orphan.id : mintId(),
+              position: c.position,
+              fingerprint: c.fingerprint,
+              block: c.block,
+              mutation: i === 0 ? "split-first" : `split-${i + 1}`
+            });
+          }
+          for (let i = group.length - 1; i >= 0; i--)
+            unmatched.splice(group[i], 1);
+          claimed = true;
+          progress = true;
+          break;
+        }
+      }
+    }
+  }
+}
+function applyMergeRule(unmatched, previousNodes, claimedPrevIds, pinned) {
+  let progress = true;
+  while (progress) {
+    progress = false;
+    for (let ui = 0; ui < unmatched.length; ui++) {
+      const candidate = unmatched[ui];
+      const candidateSents = candidate.fingerprint.sentences;
+      if (!candidateSents || candidateSents.length < 2)
+        continue;
+      let merged = false;
+      for (let s = 0; s < previousNodes.length && !merged; s++) {
+        const start = previousNodes[s];
+        if (claimedPrevIds.has(start.id))
+          continue;
+        if (start.fingerprint.type !== candidate.fingerprint.type)
+          continue;
+        const group = [s];
+        let concatLen = start.fingerprint.sentences.length;
+        for (let next = s + 1; next < previousNodes.length; next++) {
+          const prev = previousNodes[next - 1];
+          const cur = previousNodes[next];
+          if (claimedPrevIds.has(cur.id))
+            break;
+          if (cur.fingerprint.type !== candidate.fingerprint.type)
+            break;
+          if (cur.fingerprint.position !== prev.fingerprint.position + 1)
+            break;
+          group.push(next);
+          concatLen += cur.fingerprint.sentences.length;
+          if (concatLen > candidateSents.length)
+            break;
+          if (concatLen < candidateSents.length)
+            continue;
+          const concat = [];
+          for (const gi of group)
+            concat.push(...previousNodes[gi].fingerprint.sentences);
+          if (!sentenceArraysEqual(concat, candidateSents))
+            break;
+          for (const gi of group)
+            claimedPrevIds.add(previousNodes[gi].id);
+          pinned.push({
+            id: previousNodes[group[0]].id,
+            position: candidate.position,
+            fingerprint: candidate.fingerprint,
+            block: candidate.block,
+            mutation: `merge-${group.length}-way`
+          });
+          unmatched.splice(ui, 1);
+          merged = true;
+          progress = true;
+          break;
+        }
+      }
+      if (merged)
+        break;
+    }
+  }
+}
+function applyTypeChangeRule(unmatched, previousNodes, claimedPrevIds, pinned) {
+  let progress = true;
+  while (progress) {
+    progress = false;
+    for (let ui = 0; ui < unmatched.length; ui++) {
+      const candidate = unmatched[ui];
+      const candidateOrphans = previousNodes.filter((p) => {
+        if (claimedPrevIds.has(p.id))
+          return false;
+        if (p.fingerprint.type === candidate.fingerprint.type)
+          return false;
+        if (!isSameContent(p.fingerprint, candidate.fingerprint))
+          return false;
+        const idx = previousNodes.findIndex((x) => x.id === p.id);
+        const lo = slotLowBound(previousNodes, claimedPrevIds, pinned, idx);
+        const hi = slotHighBound(previousNodes, claimedPrevIds, pinned, idx);
+        return candidate.position > lo && candidate.position < hi;
+      });
+      if (candidateOrphans.length === 0)
+        continue;
+      const best = nearestBy(candidateOrphans, (o) => o.fingerprint.position, candidate.position);
+      claimedPrevIds.add(best.id);
+      pinned.push({
+        id: best.id,
+        position: candidate.position,
+        fingerprint: candidate.fingerprint,
+        block: candidate.block,
+        mutation: `type-change-${best.fingerprint.type}-to-${candidate.fingerprint.type}`
+      });
+      unmatched.splice(ui, 1);
+      progress = true;
+      ui--;
+    }
+  }
+}
+function applyEditRule(unmatched, previousNodes, claimedPrevIds, pinned) {
+  const byPos = [...unmatched].sort((a, b) => a.position - b.position);
+  for (const candidate of byPos) {
+    if (!unmatched.includes(candidate))
+      continue;
+    const candidateOrphans = previousNodes.filter((p) => {
+      if (claimedPrevIds.has(p.id))
+        return false;
+      if (p.fingerprint.type !== candidate.fingerprint.type)
+        return false;
+      if (!shareAnySentenceTuple(p.fingerprint.sentences, candidate.fingerprint.sentences))
+        return false;
+      const idx = previousNodes.findIndex((x) => x.id === p.id);
+      const lo = slotLowBound(previousNodes, claimedPrevIds, pinned, idx);
+      const hi = slotHighBound(previousNodes, claimedPrevIds, pinned, idx);
+      return candidate.position > lo && candidate.position < hi;
+    });
+    if (candidateOrphans.length !== 1)
+      continue;
+    const orphan = candidateOrphans[0];
+    claimedPrevIds.add(orphan.id);
+    pinned.push({
+      id: orphan.id,
+      position: candidate.position,
+      fingerprint: candidate.fingerprint,
+      block: candidate.block,
+      mutation: "edited"
+    });
+    unmatched.splice(unmatched.indexOf(candidate), 1);
+  }
+}
+function applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned) {
+  let progress = true;
+  while (progress) {
+    progress = false;
+    for (let ui = 0; ui < unmatched.length; ui++) {
+      const candidate = unmatched[ui];
+      const matchingOrphans = previousNodes.filter((orphan) => {
+        if (claimedPrevIds.has(orphan.id))
+          return false;
+        if (orphan.fingerprint.type !== candidate.fingerprint.type)
+          return false;
+        const idx = previousNodes.findIndex((x) => x.id === orphan.id);
+        const prevAnchor = findPinnedNeighbor(previousNodes, claimedPrevIds, idx, -1);
+        const nextAnchor = findPinnedNeighbor(previousNodes, claimedPrevIds, idx, 1);
+        const prevNewPos = prevAnchor ? findPinnedPosition(pinned, prevAnchor.id) : -1;
+        const nextNewPos = nextAnchor ? findPinnedPosition(pinned, nextAnchor.id) : Infinity;
+        return candidate.position > prevNewPos && candidate.position < nextNewPos;
+      });
+      if (matchingOrphans.length === 0)
+        continue;
+      const scored = matchingOrphans.map((orphan) => ({
+        orphan,
+        score: sentenceSignalOverlapScore(orphan.fingerprint, candidate.fingerprint)
+      })).sort((a, b) => b.score - a.score);
+      const topScore = scored[0].score;
+      const tied = scored.filter((s) => s.score === topScore);
+      if (tied.length > 1 && topScore === 0)
+        continue;
+      const best = nearestBy(
+        tied.map((t) => t.orphan),
+        (o) => o.fingerprint.position,
+        candidate.position
+      );
+      claimedPrevIds.add(best.id);
+      pinned.push({
+        id: best.id,
+        position: candidate.position,
+        fingerprint: candidate.fingerprint,
+        block: candidate.block,
+        mutation: "slot-preserved"
+      });
+      unmatched.splice(ui, 1);
+      ui--;
+      progress = true;
+    }
+  }
+}
+function applyGraveyardRestoreRule(unmatched, graveyard, claimedGraveIds, pinned) {
+  for (let ui = unmatched.length - 1; ui >= 0; ui--) {
+    const candidate = unmatched[ui];
+    const ghosts = graveyard.filter(
+      (g) => !claimedGraveIds.has(g.id) && isExactMatch2(g.fingerprint, candidate.fingerprint)
+    );
+    if (ghosts.length === 0)
+      continue;
+    const best = nearestBy(ghosts, (g) => g.fingerprint.position, candidate.position);
+    claimedGraveIds.add(best.id);
+    pinned.push({
+      id: best.id,
+      position: candidate.position,
+      fingerprint: candidate.fingerprint,
+      block: candidate.block,
+      mutation: "graveyard-restore"
+    });
+    unmatched.splice(ui, 1);
+  }
+}
+function applyInsertRule(unmatched, pinned, mintId) {
+  for (let i = unmatched.length - 1; i >= 0; i--) {
+    const candidate = unmatched[i];
+    pinned.push({
+      id: mintId(),
+      position: candidate.position,
+      fingerprint: candidate.fingerprint,
+      block: candidate.block,
+      mutation: "inserted"
+    });
+    unmatched.splice(i, 1);
+  }
+}
+function findPinnedNeighbor(previousNodes, claimedPrevIds, startIdx, direction) {
+  for (let i = startIdx + direction; i >= 0 && i < previousNodes.length; i += direction) {
+    if (claimedPrevIds.has(previousNodes[i].id))
+      return previousNodes[i];
+  }
+  return null;
+}
+function findPinnedPosition(pinned, id) {
+  const entry = pinned.find((p) => p.id === id);
+  return entry ? entry.position : -1;
+}
+function slotLowBound(previousNodes, claimedPrevIds, pinned, orphanIdx) {
+  const prev = findPinnedNeighbor(previousNodes, claimedPrevIds, orphanIdx, -1);
+  return prev ? findPinnedPosition(pinned, prev.id) : -1;
+}
+function slotHighBound(previousNodes, claimedPrevIds, pinned, orphanIdx) {
+  const next = findPinnedNeighbor(previousNodes, claimedPrevIds, orphanIdx, 1);
+  return next ? findPinnedPosition(pinned, next.id) : Infinity;
+}
+function nearestBy(items, project, target) {
+  let best = items[0];
+  let bestDist = Math.abs(project(best) - target);
+  for (const item of items) {
+    const d = Math.abs(project(item) - target);
+    if (d < bestDist) {
+      best = item;
+      bestDist = d;
+    }
+  }
+  return best;
+}
+function defaultMintId() {
+  return Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
+}
+
+// ../core/src/node-identity/graph.ts
+var GRAPH_VERSION = 1;
+var GRAVEYARD_CAP = 50;
+function hashBody(body) {
+  return `${body.length.toString(16)}-${simpleHash2(body)}`;
+}
+function reconcile(graph, blocks, options) {
+  const previous = graph?.nodes ?? [];
+  const graveyard = graph?.graveyard ?? [];
+  const mintId = options.mintId ?? makeMinter(collectIds(previous, graveyard));
+  const match = previous.length === 0 && graveyard.length === 0 ? bootstrapMatch(blocks, mintId) : matchNodes(previous, blocks, { graveyard, mintId });
+  const ordered = [...match.pinned].sort((a, b) => a.position - b.position);
+  const next = {
+    version: GRAPH_VERSION,
+    path: options.path,
+    bodyHash: hashBody(options.body),
+    nodes: ordered.map((p) => ({ id: p.id, fingerprint: p.fingerprint })),
+    graveyard: capGraveyard(match.nextGraveyard)
+  };
+  const changed = graph === null || serializeNodeGraph(graph) !== serializeNodeGraph(next);
+  return {
+    blocks: ordered.map((p) => ({ ...p.block, id: p.id })),
+    graph: next,
+    changed,
+    match
+  };
+}
+function bootstrapMatch(blocks, mintId) {
+  const seeded = bootstrapPreviousNodes(blocks, mintId);
+  return {
+    pinned: blocks.map((block, i) => ({
+      id: seeded[i].id,
+      position: block.position,
+      fingerprint: seeded[i].fingerprint,
+      block,
+      mutation: "inserted"
+    })),
+    unmatched: [],
+    orphaned: [],
+    graveyardRestored: [],
+    nextGraveyard: [],
+    summary: {
+      totalBlocks: blocks.length,
+      pinnedCount: blocks.length,
+      unmatchedCount: 0,
+      orphanedCount: 0,
+      preserved: 0,
+      fresh: blocks.length
+    }
+  };
+}
+function capGraveyard(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of entries) {
+    if (seen.has(e.id))
+      continue;
+    seen.add(e.id);
+    out.push(e);
+    if (out.length >= GRAVEYARD_CAP)
+      break;
+  }
+  return out;
+}
+function collectIds(...groups) {
+  const used = /* @__PURE__ */ new Set();
+  for (const group of groups)
+    for (const e of group)
+      used.add(e.id);
+  return used;
+}
+function makeMinter(used) {
+  const taken = new Set(used);
+  return () => {
+    for (let attempt = 0; attempt < 1e3; attempt++) {
+      const id = Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+      if (!taken.has(id)) {
+        taken.add(id);
+        return id;
+      }
+    }
+    throw new Error("node-identity: could not mint an unused id in 1000 attempts");
+  };
+}
+function serializeNodeGraph(graph) {
+  const lines = [];
+  lines.push("{");
+  lines.push(`  "version": ${graph.version},`);
+  lines.push(`  "path": ${JSON.stringify(graph.path)},`);
+  lines.push(`  "bodyHash": ${JSON.stringify(graph.bodyHash)},`);
+  lines.push(`  "nodes": [`);
+  lines.push(...entryLines(graph.nodes));
+  lines.push(`  ],`);
+  lines.push(`  "graveyard": [`);
+  lines.push(...entryLines(graph.graveyard));
+  lines.push(`  ]`);
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+function entryLines(entries) {
+  return entries.map((e, i) => {
+    const comma = i === entries.length - 1 ? "" : ",";
+    return `    ${JSON.stringify({ id: e.id, fp: packFingerprint(e.fingerprint) })}${comma}`;
+  });
+}
+function parseNodeGraph(text) {
+  if (!text)
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object")
+    return null;
+  if (raw.version !== GRAPH_VERSION)
+    return null;
+  if (!Array.isArray(raw.nodes) || !Array.isArray(raw.graveyard))
+    return null;
+  const nodes = raw.nodes.map(unpackEntry).filter(isEntry);
+  const graveyard = raw.graveyard.map(unpackEntry).filter(isEntry);
+  if (nodes.length !== raw.nodes.length)
+    return null;
+  return {
+    version: GRAPH_VERSION,
+    path: typeof raw.path === "string" ? raw.path : "",
+    bodyHash: typeof raw.bodyHash === "string" ? raw.bodyHash : "",
+    nodes,
+    graveyard
+  };
+}
+function isEntry(e) {
+  return e !== null;
+}
+function packFingerprint(fp) {
+  const out = {
+    type: fp.type,
+    position: fp.position,
+    charCount: fp.charCount,
+    sentenceCount: fp.sentenceCount,
+    wordCount: fp.wordCount,
+    sentences: fp.sentences.map((s) => ({ c: s.c, f: s.f, l: s.l, t: s.t, w: s.w })),
+    structureSig: fp.structureSig
+  };
+  if (fp.level !== void 0)
+    out.level = fp.level;
+  if (fp.language !== void 0)
+    out.language = fp.language;
+  if (fp.childCount !== void 0)
+    out.childCount = fp.childCount;
+  if (fp.childTypes !== void 0)
+    out.childTypes = fp.childTypes;
+  return out;
+}
+function unpackEntry(raw) {
+  if (!raw || typeof raw.id !== "string" || !raw.fp)
+    return null;
+  const fp = raw.fp;
+  if (typeof fp.type !== "string" || !Array.isArray(fp.sentences))
+    return null;
+  const sentences = fp.sentences.map((s) => ({
+    c: s.c ?? 0,
+    f: s.f ?? "",
+    l: s.l ?? "",
+    t: s.t ?? "-",
+    wls: Array.isArray(s.wls) ? s.wls : Array.isArray(s.w) ? s.w.map((w) => w.length) : [],
+    w: Array.isArray(s.w) ? s.w : []
+  }));
+  return {
+    id: raw.id,
+    fingerprint: {
+      type: fp.type,
+      position: fp.position ?? 0,
+      parentPosition: null,
+      ordinalInParent: 0,
+      charCount: fp.charCount ?? 0,
+      sentenceCount: fp.sentenceCount ?? sentences.length,
+      wordCount: fp.wordCount ?? 0,
+      sentences,
+      structureSig: fp.structureSig ?? { bold: 0, italic: 0, links: 0, code: 0 },
+      prevType: null,
+      nextType: null,
+      parentType: null,
+      firstWords: [],
+      lastWords: [],
+      ...fp.level !== void 0 ? { level: fp.level } : {},
+      ...fp.language !== void 0 ? { language: fp.language } : {},
+      ...fp.childCount !== void 0 ? { childCount: fp.childCount } : {},
+      ...fp.childTypes !== void 0 ? { childTypes: fp.childTypes } : {}
+    }
+  };
+}
+function sidecarPathFor(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!normalized || normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized))
+    return null;
+  if (normalized.split("/").some((seg) => seg === ".." || seg === ""))
+    return null;
+  return `.greprag/node-identity/${normalized}.json`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTAINER_TYPES,
+  GRAPH_VERSION,
+  GRAVEYARD_CAP,
+  ZERO_STRUCTURE,
+  bootstrapPreviousNodes,
+  fingerprint,
+  fingerprintAll,
+  hashBody,
+  isExactMatch,
+  isSameContent,
+  makeMinter,
+  markdownToBlocks,
+  matchNodes,
+  parseNodeGraph,
+  rebuildPreviousFromResult,
+  reconcile,
+  sentenceArraysEqual,
+  sentenceSignalOverlapScore,
+  sentenceTuplesEqual,
+  serializeNodeGraph,
+  shareAnySentenceTuple,
+  sidecarPathFor,
+  simpleHash,
+  splitSentences,
+  tokenizeWords
+});