rapier-markdown-kit 1.1.102 → 1.2.3

package/dist/packages/rapier-diff/index.mjs

@@ -1,59 +1,119 @@
 // SPDX-License-Identifier: MIT
+// Capture only the reader contract before another observation can reuse its objects.
+function observe(text, reader, spend, safe, references = true, lenient = false) {
+  let value;
+  try { value = reader(text); } catch { return null; }
+  try {
+    const flat = [], links = [], meaning = references && value?.meaning;
+    const span = (at, from, end) => {
+      if (!Array.isArray(at) || at.length !== 2 || !at.every(Number.isSafeInteger) ||
+          at[0] < from || at[1] < at[0] || at[1] > end) throw null;
+      if (safe(text, at[0]) && safe(text, at[1])) return [at[0], at[1]];
+      if (!lenient) throw null;
+    };
+    const scalar = (value, key = false) => {
+      if (value != null && typeof value !== 'string' && !(key && (typeof value === 'boolean' || Number.isFinite(value)))) throw false;
+      return value;
+    };
+    let count = 0;
+    function copy(rows, from, end, depth, retained = true) {
+      if (!Array.isArray(rows) || rows.length > 131072 || depth > 128) throw null;
+      const parts = [];
+      let at = from;
+      for (const row of rows) {
+        if (!spend() || count++ >= 131072) throw null;
+        const {start, end: stop, kind, name, key, nameAt, children} = row;
+        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop) ||
+            start < at || stop < start || stop > end) throw null;
+        at = stop;
+        const usable = safe(text, start) && safe(text, stop);
+        if (!usable && !lenient) throw null;
+        const part = {start, end: stop, kind: scalar(kind), name: scalar(name), key: scalar(key, true)};
+        if (nameAt != null) part.nameAt = span(nameAt, start, stop);
+        // Discard unsafe evidence only after validating its complete subtree.
+        if (retained && usable) { parts.push(part); flat.push(part); }
+        part.children = children == null ? [] : copy(children, start, stop, depth + 1, retained && usable);
+      }
+      return parts;
+    }
+    const parts = copy(value?.parts, 0, text.length, 0), rows = references && value.links || [];
+    if (!Array.isArray(rows) || rows.length > 131072) throw null;
+    for (const row of rows) {
+      if (!spend()) throw null;
+      const {at, to, key, labelAt} = row;
+      if (typeof to !== 'string') throw null;
+      const place = span(at, 0, text.length), label = labelAt == null ? null : span(labelAt, 0, text.length), binding = scalar(key, true);
+      if (place) links.push({at: place, to, key: binding, ...(label && {labelAt: label})});
+    }
+    return {parts, flat, links, meaning: typeof meaning === 'string' ? meaning : undefined};
+  } catch (error) { return error === false ? {invalid: true} : null; }
+}
+
+// Segment only requested non-ASCII boundaries; observations never share a global document cache.
+function boundaries() {
+  const segments = Object.create(null);
+  let segmenter;
+  return function safe(text, at) {
+    if (!at || at === text.length) return true;
+    const a = text.charCodeAt(at - 1), b = text.charCodeAt(at);
+    if ((a & 0xfc00) === 0xd800 && (b & 0xfc00) === 0xdc00 || a === 13 && b === 10) return false;
+    if (a < 0x300 && b < 0x300) return true;
+    return (segments[text] ||= (segmenter ||= new Intl.Segmenter('en', {granularity: 'grapheme'})).segment(text)).containing(at).index === at;
+  }
+}
+
 export function diff(before, after, options = {}) {
   if (before === after) return {edits: [], changes: []};
   const budget = options._budget || {left: Number.isFinite(options.limit) ? Math.max(0, options.limit) : 1e7};
   const initial = budget.left, raw = options._unit;
   let result = [], code = options.as === 'code', structures, pa, pb, la, lb, aliases;
   const spend = (n = 1) => (budget.left -= n) >= 0;
-  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c);
+  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c), within = (text, at) => letter(text[at - 1]) && letter(text[at]);
   const overlaps = (a, b) => a[0] < b[1] && a[1] > b[0];
   const inside = (c, a, b) => [a, b].every((range, side) => c[side][0] === c[side][1] ||
     c[side][0] >= range[0] && c[side][1] <= range[1]);
   if (options.as !== 'prose' && options.as !== 'code') code = /(?:^|\n)\s*(?:[{}]|(?:function|class|const|let|var|import|export|def|fn|func|package)\s+\w[^]{0,80}[({=:;])/.test(before.slice(0, 4096) + after.slice(0, 4096));
 
-  // Segment only a requested non-ASCII boundary; cache each input locally.
-  const segments = Object.create(null);
-  let segmenter;
-  function safe(text, at) {
-    if (!at || at === text.length) return true;
-    const a = text.charCodeAt(at - 1), b = text.charCodeAt(at);
-    if ((a & 0xfc00) === 0xd800 && (b & 0xfc00) === 0xdc00 || a === 13 && b === 10) return false;
-    if (a < 0x300 && b < 0x300) return true;
-    return (segments[text] ||= (segmenter ||= new Intl.Segmenter('en', {granularity: 'grapheme'})).segment(text)).containing(at).index === at;
-  }
+  const safe = boundaries();
 
   function record(a0, a1, b0, b1, unit, part, coarse = false) {
-    if (before.slice(a0, a1) === after.slice(b0, b1)) return;
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
     // Internal records: before, after, coarse, concern, transported fragments.
     result.push([[a0, a1], [b0, b1], coarse, [a0 === a1 ? 2 : b0 === b1 ? 0 : 1, part?.kind || unit, part?.name]]);
   }
 
   function tokens(text, start, end, level, parts) {
-    const out = [];
-    const add = (a, b, part) => {
+    // Each source boundary is stored once, alongside comparison keys and optional owners.
+    const keys = [], at = [start], owners = [];
+    const out = [keys, at, owners];
+    const add = (a, b, part, value) => {
       if (b <= a) return;
-      if (!part && out.at(-1)?.[3]?.name && !/\S/.test(text.slice(a, b))) out.at(-1)[1] = b;
-      else out.push([a, b, part?.name ? '\0' + part.kind + '\0' + (aliases?.get(part)?.name || part.name) : level === 1 && !raw ? text.slice(a, b).trimEnd() : text.slice(a, b), part]);
+      if (!part && owners[keys.length - 1]?.name && !/\S/.test(text.slice(a, b))) at[at.length - 1] = b;
+      else {
+        at.push(b); if (part) owners[keys.length] = part;
+        const key = part?.name ? '\0' + part.kind + '\0' + (aliases?.get(part)?.name || part.name) : value ?? text.slice(a, b);
+        keys.push(level === 1 && !raw ? key.trimEnd() : key);
+      }
     };
     if (parts?.length && level === 0) {
       let at = start;
       for (const part of parts) {
-        if (!spend() || out.length > 131072) return null;
+        if (!spend() || keys.length >= 131072) return null;
         if (part.start < at || part.end <= part.start || part.end > end) continue;
         if (at < part.start) add(at, part.start);
         add(part.start, part.end, part); at = part.end;
       }
-      add(at, end); return out;
+      add(at, end); return keys.length > 131072 ? null : out;
     }
     const pattern = level === 1 ? /[^\n]*\n(?:\r?\n)*|[^\n]+$/g : level === 2 ? /[\p{L}\p{M}\p{N}_]+|[^\S\r\n]+|\r\n|[^]/gu : /[^]/gu;
     pattern.lastIndex = start;
     let match;
     while (pattern.lastIndex < end && (match = pattern.exec(text))) {
-      if (!spend() || out.length >= 131072) return null;
+      if (!spend() || keys.length >= 131072) return null;
       const a = match.index, b = Math.min(end, pattern.lastIndex);
-      if (out.length && !safe(text, a)) {
-        out.at(-1)[1] = b; out.at(-1)[2] = text.slice(out.at(-1)[0], b);
-      } else add(a, b);
+      if (keys.length && !safe(text, a)) {
+        at[at.length - 1] = b; keys[keys.length - 1] = text.slice(at[at.length - 2], b);
+      } else add(a, b, undefined, b === pattern.lastIndex ? match[0] : undefined);
       if (b === end) break;
     }
     return out;
@@ -61,24 +121,39 @@ export function diff(before, after, options = {}) {
 
   // Unique anchors and fallback equal pairs share one bounded subsequence search.
   function matches(a, b) {
-    const found = [], pending = [[0, a.length, 0, b.length]];
+    const found = new Array(a.length), pending = [[0, a.length, 0, b.length]];
     let nodes = 0;
     while (pending.length) {
       let [a0, a1, b0, b1] = pending.pop();
-      while (a0 < a1 && b0 < b1 && a[a0][2] === b[b0][2]) found.push([a0++, b0++]);
-      while (a0 < a1 && b0 < b1 && a[a1 - 1][2] === b[b1 - 1][2]) found.push([--a1, --b1]);
+      while (a0 < a1 && b0 < b1 && a[a0] === b[b0]) found[a0++] = b0++;
+      while (a0 < a1 && b0 < b1 && a[a1 - 1] === b[b1 - 1]) found[--a1] = --b1;
       if (a0 === a1 || b0 === b1 || !spend(a1 - a0 + b1 - b0)) continue;
       const positions = Object.create(null), tails = [];
       for (let j = b0; j < b1; j++) {
-        const key = b[j][2];
+        const key = b[j];
         (positions[key] ||= [0]).push(j);
       }
       for (let i = a0; i < a1; i++) {
-        const list = positions[a[i][2]]; if (list) list[0]++;
+        const list = positions[a[i]]; if (list) list[0]++;
+      }
+      let unique = 0;
+      if (a1 - a0 + b1 - b0 > 32) {
+        let count = 0;
+        for (const list of Object.values(positions)) {
+          count += list[0] * (list.length - 1);
+          if (list[0] === 1 && list.length === 2) unique++;
+        }
+        if (!count) continue;
+        // A chain is admitted only after visiting every candidate. Reject a
+        // search whose mandatory visits cannot fit before allocating its nodes.
+        if ((unique || count) > Math.min(131072 - nodes, budget.left)) {
+          // Repetitive text has too many equal pairs; a shortest script needs no anchors.
+          if (!shortest(a, b, a0, a1, b0, b1, found) && budget.left >= 0) (found.coarse ||= new Set()).add(a0);
+          continue;
+        }
       }
-      const unique = a1 - a0 + b1 - b0 > 32 && Object.values(positions).some(list => list[0] === 1 && list.length === 2);
       search: for (let i = a0; i < a1; i++) {
-        const list = positions[a[i][2]];
+        const list = positions[a[i]];
         if (!list || unique && (list[0] !== 1 || list.length !== 2)) continue;
         for (let p = list.length - 1; p > 0; p--) {
           if (!spend() || ++nodes > 131072) { budget.left = -1; break search; }
@@ -98,48 +173,88 @@ export function diff(before, after, options = {}) {
       chain.reverse();
       let x = a0, y = b0;
       for (const [i, j] of chain) {
-        found.push([i, j]);
-        if (unique) pending.push([x, i, y, j]);
+        found[i] = j;
+        if (unique && x < i && y < j) pending.push([x, i, y, j]);
         x = i + 1; y = j + 1;
       }
-      if (unique) pending.push([x, a1, y, b1]);
+      if (unique && x < a1 && y < b1) pending.push([x, a1, y, b1]);
+    }
+    return found;
+  }
+
+  // Myers' greedy search: O((N + M) D) steps; each frontier is kept for the backward pass.
+  function shortest(a, b, a0, a1, b0, b1, found) {
+    const n = a1 - a0, m = b1 - b0, v = new Int32Array(2 * (n + m) + 3), o = n + m + 1, trace = [];
+    for (let d = 0; d <= 2048 && spend(2 * d + 1); d++) {
+      trace.push(v.slice(o - d, o + d + 1));
+      for (let k = -d; k <= d; k += 2) {
+        let x = k === -d || k !== d && v[o + k - 1] < v[o + k + 1] ? v[o + k + 1] : v[o + k - 1] + 1, y = x - k;
+        while (x < n && y < m && a[a0 + x] === b[b0 + y] && spend()) { x++; y++; }
+        v[o + k] = x;
+        if (x < n || y < m) continue;
+        for (x = n, y = m; d >= 0; d--) {
+          const w = trace[d], k = x - y, prev = k === -d || k !== d && w[d + k - 1] < w[d + k + 1] ? k + 1 : k - 1;
+          const px = d ? w[d + prev] : 0, py = px - prev;
+          while (x > px && y > py) if (a[a0 + --x] === b[b0 + --y]) found[a0 + x] = b0 + y;
+          x = px; y = py;
+        }
+        return true;
+      }
     }
-    return found.sort((x, y) => x[0] - y[0]);
+  }
+
+  // A search step scans at most one fixed-size source chunk.
+  function common(a, b, end, step) {
+    let n = 0;
+    while (n < end && spend()) {
+      const stop = Math.min(end, n + 256);
+      while (n < stop && before.charCodeAt(a) === after.charCodeAt(b)) { n++; a += step; b += step; }
+      if (n < stop) break;
+    }
+    return n;
   }
 
   function walk(a0, a1, b0, b1, level, ap, bp, context) {
-    if (before.slice(a0, a1) === after.slice(b0, b1)) return;
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
     if (!spend()) { record(a0, a1, b0, b1, 'block', context, true); return; }
     const structural = level <= 0 && level > -128 && (ap?.length || bp?.length);
     if (!structural && raw !== 'word') {
-      let n = 0, end = Math.min(a1 - a0, b1 - b0);
-      while (n < end && before.charCodeAt(a0 + n) === after.charCodeAt(b0 + n)) n++;
-      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n))) n--;
-      if (level === 1) while (n && before[a0 + n - 1] !== '\n') n--;
-      a0 += n; b0 += n; n = 0; end = Math.min(a1 - a0, b1 - b0);
-      while (n < end && before.charCodeAt(a1 - n - 1) === after.charCodeAt(b1 - n - 1)) n++;
-      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n))) n--;
-      if (level === 1) while (n && (before[a1 - n - 1] !== '\n' || after[b1 - n - 1] !== '\n' || before[a1 - n] === '\n' || after[b1 - n] === '\n')) n--;
+      let n = common(a0, b0, Math.min(a1 - a0, b1 - b0), 1);
+      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n) || !raw && level < 3 && (within(before, a0 + n) || within(after, b0 + n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1 && n) {
+        const next = Math.max(0, before.lastIndexOf('\n', a0 + n - 1) + 1 - a0);
+        spend(Math.ceil((n - next) / 256)); n = next;
+      }
+      a0 += n; b0 += n;
+      n = common(a1 - 1, b1 - 1, Math.min(a1 - a0, b1 - b0), -1);
+      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n) || !raw && level < 3 && (within(before, a1 - n) || within(after, b1 - n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1) while (n && (before[a1 - n - 1] !== '\n' || after[b1 - n - 1] !== '\n' || before[a1 - n] === '\n' || after[b1 - n] === '\n')) { if (!spend()) { n = 0; break; } n--; }
       a1 -= n; b1 -= n;
+      if (budget.left < 0) { record(a0, a1, b0, b1, 'block', context, true); return; }
     }
     let unit = level >= 3 ? 'char' : level === 2 ? 'word' : 'line';
     if (!raw && level === 2 && a1 - a0 + b1 - b0 <= 2 && letter(before[a0 - 1] || after[b0 - 1]) && letter(before[a1] || after[b1])) unit = 'char';
     if (!structural && (a0 === a1 || b0 === b1)) { record(a0, a1, b0, b1, unit, context); return; }
-    const a = tokens(before, a0, a1, structural ? 0 : Math.max(1, level), ap);
-    const b = tokens(after, b0, b1, structural ? 0 : Math.max(1, level), bp);
-    if (!a || !b) { record(a0, a1, b0, b1, unit, context, true); return; }
-    const pairs = matches(a, b);
-    const offset = (ts, i, end) => ts[i]?.[0] ?? end;
+    const left = tokens(before, a0, a1, structural ? 0 : Math.max(1, level), ap);
+    const right = tokens(after, b0, b1, structural ? 0 : Math.max(1, level), bp);
+    if (!left || !right) { record(a0, a1, b0, b1, unit, context, true); return; }
+    const [a, x, ownersA] = left, [b, y, ownersB] = right, pairs = matches(a, b);
     let ai = 0, bi = 0;
-    for (const [i, j] of [...pairs, [a.length, b.length]]) {
-      const x0 = offset(a, ai, a1), x1 = offset(a, i, a1), y0 = offset(b, bi, b1), y1 = offset(b, j, b1);
+    for (let i = 0; i <= a.length; i++) {
+      const j = i === a.length ? b.length : pairs[i];
+      if (j === undefined) continue;
+      const x0 = x[ai], x1 = x[i], y0 = y[bi], y1 = y[j];
       if (ai < i || bi < j) {
-        if (budget.left < 0) record(x0, x1, y0, y1, unit, context, true);
+        if (budget.left < 0 || pairs.coarse?.has(ai)) record(x0, x1, y0, y1, unit, context, true);
         else if (structural && (ai === i || bi === j)) {
-          for (let k = ai; k < i; k++) record(a[k][0], a[k][1], y0, y0, unit, a[k][3] || context);
-          for (let k = bi; k < j; k++) record(x1, x1, b[k][0], b[k][1], unit, b[k][3] || context);
+          for (let k = ai; k < i; k++) record(x[k], x[k + 1], y0, y0, unit, ownersA[k] || context);
+          for (let k = bi; k < j; k++) record(x1, x1, y[k], y[k + 1], unit, ownersB[k] || context);
         } else if (structural) {
-          const p = a[ai]?.[3], q = b[bi]?.[3];
+          const p = ownersA[ai], q = ownersB[bi];
           if (i - ai === 1 && j - bi === 1 && p && q && p.kind === q.kind) walk(x0, x1, y0, y1, level - 1, p.children, q.children, q);
           else walk(x0, x1, y0, y1, 1, null, null, context);
         } else if (level < 2 && raw !== 'line') walk(x0, x1, y0, y1, raw === 'char' ? 3 : 2, null, null, context);
@@ -147,19 +262,16 @@ export function diff(before, after, options = {}) {
           const start = result.length;
           walk(x0, x1, y0, y1, 3, null, null, context);
           const edits = result.slice(start);
+          // A letter-sized correction stays a letter; any other word change marks the whole word.
           if (edits.length !== 1 || edits[0][0][1] - edits[0][0][0] + edits[0][1][1] - edits[0][1][0] > Math.max(2, (x1 - x0 + y1 - y0) / 3)) {
-            const reading = [[x0, x1], [y0, y1]], group = [edits[0][3][0], context?.kind || 'word', edits[0][3][2], reading];
-            for (const edit of edits) {
-              if (group[0] !== edit[3][0]) group[0] = 1;
-              edit[3] = group;
-            }
+            result.length = start; record(x0, x1, y0, y1, unit, context);
           }
         } else record(x0, x1, y0, y1, unit, context);
       }
       if (i < a.length) {
-        const p = a[i][3], q = b[j][3];
-        if (before.slice(a[i][0], a[i][1]) !== after.slice(b[j][0], b[j][1]))
-          walk(a[i][0], a[i][1], b[j][0], b[j][1], p || q ? level - 1 : 3, p?.children, q?.children, q || p || context);
+        const p = ownersA[i], q = ownersB[j];
+        if ((p || q || level <= 1 && !raw) && before.slice(x[i], x[i + 1]) !== after.slice(y[j], y[j + 1]))
+          walk(x[i], x[i + 1], y[j], y[j + 1], p || q ? level - 1 : 3, p?.children, q?.children, q || p || context);
       }
       ai = i + 1; bi = j + 1;
     }
@@ -192,7 +304,12 @@ export function diff(before, after, options = {}) {
       if (!row || !Number.isSafeInteger(row.pos) || typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
         row.pos < 0 || row.pos + row.removed.length > length || !verify(pieces.length * 2 + 1)) return null;
       const left = split(row.pos), right = split(row.pos + row.removed.length);
-      if (pieces.slice(left, right).map(([start, end, text = before]) => text.slice(start, end)).join('') !== row.removed) return null;
+      let at = 0;
+      for (let i = left; i < right; i++) {
+        const [start, end, text = before] = pieces[i];
+        if (!row.removed.startsWith(text.slice(start, end), at)) return null;
+        at += end - start;
+      }
       if (row.removed === row.inserted) continue;
       pieces.splice(left, right - left, [0, row.inserted.length, row.inserted]);
       length += row.inserted.length - row.removed.length;
@@ -202,7 +319,7 @@ export function diff(before, after, options = {}) {
     let a = 0, b = 0, at = 0;
     for (const [start, end, text] of pieces) {
       const size = end - start;
-      if (!verify(1) || (text ?? before).slice(start, end) !== after.slice(at, at + size)) return null;
+      if (!verify(1) || !after.startsWith((text ?? before).slice(start, end), at)) return null;
       if (text === undefined) {
         let x = start, y = at, tail = end;
         while (x < tail && (!safe(before, x) || !safe(after, y))) { x++; y++; if (!verify(1)) return null; }
@@ -220,22 +337,11 @@ export function diff(before, after, options = {}) {
 
   if (options.structure && (!raw || options._structure)) {
     try {
-      structures = [options.structure(before), options.structure(after)];
-      const flatten = parts => {
-        if (parts.length > 131072) throw null;
-        const list = [], pending = [...parts].reverse();
-        while (pending.length && spend()) {
-          const p = pending.pop(); list.push(p);
-          if (p.children) {
-            if (list.length + pending.length + p.children.length > 131072) throw null;
-            pending.push(...[...p.children].reverse());
-          }
-        }
-        return list;
-      };
-      [pa, pb] = structures.map(s => flatten(s.parts)); [la, lb] = structures.map(s => s.links || []);
+      structures = options._observed || [observe(before, options.structure, spend, safe), observe(after, options.structure, spend, safe)];
+      if (structures.some(value => !value || value.invalid)) throw null;
+      [pa, pb] = structures.map(value => value.flat); [la, lb] = structures.map(value => value.links);
       aliases = new Map();
-      const oldByKey = new Map(pa.filter(p => p.key).map(p => [p.key, p]));
+      const oldByKey = new Map(pa.filter(p => p.key != null).map(p => [p.key, p]));
       const oldNames = new Set(pa.map(p => p.name)), newNames = new Set(pb.map(p => p.name));
       for (const p of pb) {
         const old = oldByKey.get(p.key);
@@ -248,6 +354,23 @@ export function diff(before, after, options = {}) {
   else walk(0, before.length, 0, after.length, structures ? 0 : raw === 'char' ? 3 : raw === 'word' ? 2 : 1,
     structures?.[0]?.parts, structures?.[1]?.parts);
 
+  // A separator-only piece beside another edit joins it; equal separators at its ends stay unchanged.
+  if (!raw) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
+    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+      let n = 0;
+      while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n]) n++;
+      if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
+        for (const span of p.slice(0, 2)) { span[0] += n; span[1] += n; }
+    }
+    if (p[2] || q[2] || p[0][1] !== q[0][0] || p[1][1] !== q[1][0] ||
+      ![p, q].some(r => !/\S/.test(before.slice(...r[0]) + after.slice(...r[1])))) continue;
+    const x = [p[0][0], q[0][1]], y = [p[1][0], q[1][1]], keep = /\S/.test(before.slice(...q[0]) + after.slice(...q[1])) ? q : p;
+    while (x[0] < x[1] && y[0] < y[1] && /\s/.test(before[x[1] - 1]) && before[x[1] - 1] === after[y[1] - 1] &&
+      safe(before, x[1] - 1) && safe(after, y[1] - 1)) { x[1]--; y[1]--; }
+    keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
+    result.splice(i - 1, 2, [x, y, false, keep[3]]);
+  }
   try { if (!raw && budget.left >= 0) {
     const check = n => { if (!spend(n)) throw null; };
     // Split transported text at wording boundaries; positions and words own distinct edits.
@@ -268,16 +391,19 @@ export function diff(before, after, options = {}) {
         if (!candidate || candidate[4]) continue;
         const a = tokens(prior, 0, prior.length, 2), b = tokens(key, 0, key.length, 2);
         if (!a || !b) throw null;
-        const n = matches(a, b).reduce((n, [i]) => n + a[i][1] - a[i][0], 0);
+        const n = matches(a[0], b[0]).reduce((n, j, i) => n + a[1][i + 1] - a[1][i], 0);
         check(0);
         if (n * 5 > Math.max(prior.length, key.length) * 3 && n >= score) { old = n === score ? null : candidate; score = n; }
       }
       if (!old || old[4]) continue;
-      const x = [...old[0]], y = [...item[1]], left = before.slice(...x).match(/\s*$/)[0], right = after.slice(...y).match(/\s*$/)[0];
-      let common = 0;
-      while (common < Math.min(left.length, right.length) && left[common] === right[common]) common++;
-      if (common && safe(before, x[1] - left.length + common) && safe(after, y[1] - right.length + common)) {
-        x[1] -= left.length - common; y[1] -= right.length - common;
+      // Separators that only one end carries stay outside the transported text.
+      const x = [...old[0]], y = [...item[1]];
+      for (const end of [0, 1]) {
+        const pattern = end ? /\s*$/ : /^\s*/, left = before.slice(...x).match(pattern)[0], right = after.slice(...y).match(pattern)[0];
+        let common = 0;
+        while (common < Math.min(left.length, right.length) && left.at(end ? common : -1 - common) === right.at(end ? common : -1 - common)) common++;
+        const dx = (left.length - common) * (end ? -1 : 1), dy = (right.length - common) * (end ? -1 : 1);
+        if (safe(before, x[end] + dx) && safe(after, y[end] + dy)) { x[end] += dx; y[end] += dy; }
       }
       const outer = result; result = [];
       walk(...x, ...y, 1);
@@ -291,7 +417,8 @@ export function diff(before, after, options = {}) {
         if (a0 < a1) old[4].push([[a0, a1], [old[1][0], old[1][0]], false, group]);
         if (b0 < b1) item[4].push([[item[0][0], item[0][0]], [b0, b1], false, group]);
       };
-      let a = old[0][0], b = item[1][0], wording;
+      fragment(old[0][0], x[0], 0, 0, [0, 'char']); fragment(0, 0, item[1][0], y[0], [2, 'char']);
+      let a = x[0], b = y[0], wording;
       for (const edit of inner) {
         if (edit[3][3]) wording = edit[3];
         else if (a !== edit[0][0] || b !== edit[1][0]) wording = [edit[3][0], edit[3][1]];
@@ -314,7 +441,7 @@ export function diff(before, after, options = {}) {
         while (cursor < result.length && result[cursor][0][1] <= link.at[0]) { delta = result[cursor][1][1] - result[cursor][0][1]; cursor++; }
         if (cursor === result.length || result[cursor][0][0] >= link.at[1]) mapped[[link.at[0] + delta, link.at[1] + delta]] = link.to;
       }
-      lb = lb.map(l => l.key ? l : {...l, to: mapped[l.at] || l.to});
+      lb = lb.map(l => l.key != null ? l : {...l, to: mapped[l.at] || l.to});
       for (const [p, old] of aliases) {
         if (before.slice(...old.nameAt) === after.slice(...p.nameAt)) continue;
         check(la.length + lb.length);
@@ -348,6 +475,14 @@ export function diff(before, after, options = {}) {
     result = result.flatMap(item => item[4] || [item]);
   }
 
+  // Whole-word replacements separated only by spaces read and restore as one phrase.
+  if (!raw && !code) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], gap = before.slice(p[0][1], q[0][0]);
+    if (p[3][0] !== 1 || q[3][0] !== 1 || p[3][3] || q[3][3] || p[2] || q[2] || !/^[^\S\r\n]+$/.test(gap) ||
+      gap !== after.slice(p[1][1], q[1][0]) || within(before, p[0][0]) || within(after, p[1][0]) ||
+      within(before, q[0][1]) || within(after, q[1][1])) continue;
+    p[0][1] = q[0][1]; p[1][1] = q[1][1]; result.splice(i, 1);
+  }
   const changes = [], edits = [];
   let normalized;
   const meaning = structures?.[0]?.meaning;
@@ -373,9 +508,11 @@ export function diff(before, after, options = {}) {
     if (!raw && !group[3]) group[3] = [[...item[0]], [...item[1]]];
     if (!group[4]) {
       const context = group[3];
+      // Context completes a word only where an edge falls inside it.
       if (!raw) for (const [text, span] of [[before, context[0]], [after, context[1]]]) {
-        while (span[0] && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
-        while (span[1] < text.length && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
+        const start = within(text, span[0]), end = within(text, span[1]);
+        while (start && span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
+        while (end && span[1] < text.length && spend() && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
       }
       group[4] = []; changes.push(group);
       if (format) group[0] = 5;
@@ -383,20 +520,6 @@ export function diff(before, after, options = {}) {
     group[4].push(edits.length);
     edits.push({before: item[0], after: item[1], ...(item[2] ? {coarse: true} : {})});
   }
-  if (!raw && !structures && !code && !evidence) for (let i = 0; i < changes.length; i++) {
-    let end = i + 1;
-    for (; end < changes.length; end++) {
-      const a = changes[end - 1], b = changes[end];
-      const gap = before.slice(a[3][0][1], b[3][0][0]);
-      if (a[0] !== 1 || b[0] !== 1 || a[1] !== 'word' || b[1] !== 'word' ||
-        /\S|\r|\n/.test(gap) || gap !== after.slice(a[3][1][1], b[3][1][0])) break;
-    }
-    if (end - i < 4) continue;
-    const group = changes[i]; group[1] = 'sentence';
-    for (const next of changes.splice(i + 1, end - i - 1)) {
-      group[4].push(...next[4]); group[3][0][1] = next[3][0][1]; group[3][1][1] = next[3][1][1];
-    }
-  }
   if (structures && !raw && budget.left >= 0) {
     const oldNames = new Set(pa.filter(p => p.nameAt).map(p => p.name)), newNames = new Set(pb.filter(p => p.nameAt).map(p => p.name));
     for (const change of changes) {
@@ -433,149 +556,161 @@ export function merge(base, mine, theirs, options = {}) {
     _budget: options._budget || {left: Number.isFinite(options.limit) ? Math.max(0, options.limit) : 1e7}};
   const sources = [base, mine, theirs];
   const complete = () => ({text: mine, conflicts: [{at: [0, mine.length], theirs}]});
-  const spend = n => { if ((budget._budget.left -= n) < 0) throw null; };
-  const trees = options.structure && !options._edits ? [base, mine, base, theirs].map(text => {
-    // Retain source spans, not live objects a caller may reuse on the next parse.
-    try {
-      const value = options.structure(text), parts = [], pending = [[value?.parts, parts, 0, text.length, 0]];
-      let count = 0;
-      while (pending.length) {
-        const [rows, into, from, end, depth] = pending.pop();
-        if (!Array.isArray(rows) || rows.length > 131072 || depth > 128) throw null;
-        let at = from;
-        for (const part of rows) {
-          spend(1);
-          if (++count > 131072 || !Number.isSafeInteger(part?.start) || !Number.isSafeInteger(part.end) ||
-            part.start < at || part.end < part.start || part.end > end) throw null;
-          const copy = {start: part.start, end: part.end, kind: part.kind, name: part.name, key: part.key,
-            id: typeof part.name === 'string' && part.name && typeof part.kind === 'string' ? JSON.stringify([part.kind, part.name]) : null,
-            ...(Array.isArray(part.nameAt) ? {nameAt: [...part.nameAt]} : {}), children: []};
-          into.push(copy); at = part.end;
-          if (part.children) pending.push([part.children, copy.children, part.start, part.end, depth + 1]);
-        }
-      }
-      return parts;
-    } catch { return null; }
-  }) : [];
+  const spend = (n = 1) => (budget._budget.left -= n) >= 0;
+  const check = n => { if (!spend(n)) throw null; };
+  const safe = options.structure && boundaries();
+  const trees = options.structure && !options._edits
+    ? [base, mine, base, theirs].map(text => observe(text, options.structure, spend, safe, false, true)) : [];
   const repeatedBase = trees.splice(2, 1)[0];
-  // Admit transport before comparing coordinates that a move would discard.
-  // The base is still observed twice; later diffs consume only owned snapshots.
-  budget.structure = options.structure && (text => ({parts: trees[sources.indexOf(text)]}));
+  const equal = (a, b) => a.length === b.length && a.every((item, i) => item === b[i]);
   if (trees.some(Boolean) || repeatedBase) {
     try {
-      if (JSON.stringify(trees[0]) !== JSON.stringify(repeatedBase) || !trees.every(Boolean) || budget._budget.left < 0) return complete();
-    } catch { return complete(); }
-    const removed = [new Map(), new Map()], added = [new Map(), new Map()];
-    let container = 0;
-    const equal = (a, b) => a.length === b.length && a.every((item, i) => item === b[i]);
-    const content = (part, side) => sources[side].slice(part.start, part.end);
-    function align(nodes, depth = 0) {
-      const original = content(nodes[0], 0);
-      if (original === content(nodes[1], 1) && original === content(nodes[2], 2)) return;
-      if (depth > 128) throw null;
-      const hidden = nodes.flatMap(node => node.children.filter(part => !part.id));
-      while (hidden.length) {
-        const part = hidden.pop(); spend(1);
-        if (part.id) throw null;
-        for (const child of part.children) hidden.push(child);
-      }
-      const rows = nodes.map(node => node.children.filter(part => part.id));
-      const width = rows.reduce((n, list) => n + list.length, 0);
-      spend(1 + width);
-      let repeated = false;
-      // Display identity and definition spelling obey the same occurrence rule.
-      const index = nameOf => {
-        const duplicates = new Set();
-        const maps = rows.map((list, side) => {
-          const map = new Map();
-          for (const part of list) {
-            const name = nameOf(part, side);
-            if (name) {
-              if (map.has(name)) duplicates.add(name);
-              map.set(name, map.has(name) ? null : part);
+      if (!trees.every(tree => tree && !tree.invalid) || !repeatedBase || repeatedBase.invalid) return complete();
+      const a = trees[0].flat, b = repeatedBase.flat;
+      check(a.length + b.length);
+      if (a.length !== b.length) return complete();
+      for (let i = 0; i < a.length; i++) {
+        const p = a[i], q = b[i];
+        if (p.start !== q.start || p.end !== q.end || p.kind !== q.kind || p.name !== q.name || p.key !== q.key ||
+            p.children.length !== q.children.length || !equal(p.nameAt || [], q.nameAt || [])) return complete();
+      }
+      for (const tree of trees) for (const part of tree.flat)
+        part.id = part.name && part.kind ? part.kind.length + ':' + part.kind + part.name : null;
+      const removed = [new Map(), new Map()], added = [new Map(), new Map()];
+      let container = 0;
+      const content = (part, side) => sources[side].slice(part.start, part.end);
+      function align(nodes) {
+        const original = content(nodes[0], 0);
+        if (original === content(nodes[1], 1) && original === content(nodes[2], 2)) {
+          nodes[0].common = original; return;
+        }
+        const hidden = nodes.flatMap(node => node.children.filter(part => !part.id));
+        while (hidden.length) {
+          const part = hidden.pop(); check(1);
+          if (part.id) throw null;
+          for (const child of part.children) hidden.push(child);
+        }
+        const rows = nodes.map(node => node.children.filter(part => part.id));
+        const width = rows.reduce((n, list) => n + list.length, 0);
+        check(1 + width);
+        let repeated = false;
+        const index = nameOf => {
+          const duplicates = new Set();
+          const maps = rows.map((list, side) => {
+            const map = new Map();
+            for (const part of list) {
+              const name = nameOf(part, side);
+              if (!name) continue;
+              const old = map.get(name);
+              if (!old) map.set(name, part);
+              else {
+                duplicates.add(name);
+                if (Array.isArray(old)) old.push(part); else map.set(name, [old, part]);
+              }
             }
+            return map;
+          });
+          for (const name of duplicates) {
+            repeated = true;
+            const values = maps.map((map, side) => {
+              const part = map.get(name), list = Array.isArray(part) ? part : part ? [part] : [];
+              check(list.length); map.set(name, null);
+              return list.map(part => content(part, side));
+            });
+            if (!equal(values[0], values[1]) || !equal(values[0], values[2])) throw null;
           }
-          return map;
+          return maps;
+        };
+        const maps = index(part => part.id), orders = rows.map(list => list.map(part => part.id));
+        const reordered = [1, 2].map(side => !equal(orders[0].filter(name => maps[side].has(name)),
+          orders[side].filter(name => maps[0].has(name))));
+        index((part, side) => {
+          check(1);
+          if (part.nameAt) return part.kind.length + ':' + part.kind + sources[side].slice(...part.nameAt);
         });
-        for (const name of duplicates) {
-          spend(width); repeated = true;
-          const values = rows.map((list, side) => list.filter(part => nameOf(part, side) === name).map(part => content(part, side)));
-          if (!equal(values[0], values[1]) || !equal(values[0], values[2])) throw null;
+        const parent = container++;
+        for (const side of [1, 2]) {
+          const peer = 3 - side;
+          for (const [name, part] of maps[0]) if (!maps[side].has(name)) {
+            removed[side - 1].set(parent + ':' + name, [part.kind, parent]);
+            const other = maps[peer].get(name);
+            if (part?.nameAt && other?.nameAt && content(part, 0) !== content(other, peer)) throw null;
+          }
+          for (const [name, part] of maps[side]) if (!maps[0].has(name))
+            added[side - 1].set(parent + ':' + name, [part.kind, parent]);
         }
-        return maps;
-      };
-      const maps = index(part => part.id), orders = rows.map(list => list.map(part => part.id));
-      const reordered = [1, 2].map(side => !equal(orders[0].filter(name => maps[side].has(name)),
-        orders[side].filter(name => maps[0].has(name))));
-      index((part, side) => {
-        spend(1);
-        const at = part.nameAt;
-        if (at?.length === 2 && at.every(Number.isSafeInteger) &&
-          at[0] >= part.start && at[1] > at[0] && at[1] <= part.end)
-          return JSON.stringify([part.kind, sources[side].slice(...at)]);
-      });
-      // This number identifies only this already-corresponding container.
-      const parent = container++;
-      for (const side of [1, 2]) {
-        const peer = 3 - side;
-        for (const [name, part] of maps[0]) if (!maps[side].has(name)) {
-          removed[side - 1].set(parent + name, [part.kind, parent]);
-          const other = maps[peer].get(name);
-          if (part?.nameAt && other?.nameAt && content(part, 0) !== content(other, peer)) throw null;
+        let frame = -1;
+        if (reordered.some(Boolean)) {
+          if (repeated || !maps.every(map => map.size === maps[0].size && [...maps[0].keys()].every(name => map.has(name)))) throw null;
+          if (reordered.every(Boolean) && !equal(orders[1], orders[2])) throw null;
+          frame = reordered[0] ? 1 : 2;
+          const gaps = rows.map((list, side) => {
+            let at = nodes[side].start;
+            return [...list.map(part => { const gap = sources[side].slice(at, part.start); at = part.end; return gap; }),
+              sources[side].slice(at, nodes[side].end)];
+          });
+          if (!equal(gaps[3 - frame], gaps[reordered.every(Boolean) ? frame : 0])) throw null;
         }
-        for (const [name, part] of maps[side]) if (!maps[0].has(name))
-          added[side - 1].set(parent + name, [part.kind, parent]);
-      }
-      let frame = -1;
-      if (reordered.some(Boolean)) {
-        if (repeated || !maps.every(map => map.size === maps[0].size && [...maps[0].keys()].every(name => map.has(name)))) throw null;
-        if (reordered.every(Boolean) && !equal(orders[1], orders[2])) throw null;
-        frame = reordered[0] ? 1 : 2;
-        const gaps = rows.map((list, side) => {
-          let at = nodes[side].start;
-          return [...list.map(part => { const gap = sources[side].slice(at, part.start); at = part.end; return gap; }),
-            sources[side].slice(at, nodes[side].end)];
-        });
-        if (!equal(gaps[3 - frame], gaps[reordered.every(Boolean) ? frame : 0])) throw null;
-      }
-      const children = new Map();
-      for (const [name, part] of maps[0]) if (part && maps[1].get(name) && maps[2].get(name)) {
-        const aligned = align([part, maps[1].get(name), maps[2].get(name)], depth + 1);
-        if (aligned) children.set(name, aligned);
-      }
-      if (frame < 0 && !children.size) return;
-      // Each slice still uses its original source coordinates, even after child growth.
-      return sources.map((source, side) => {
-        const layout = frame < 0 ? side : frame;
-        let at = nodes[layout].start, text = '';
-        for (const part of rows[layout]) {
-          text += sources[layout].slice(at, part.start) + (children.get(part.id)?.[side] ?? content(maps[side].get(part.id) || part, side));
-          at = part.end;
+        const children = new Map();
+        for (const [name, part] of maps[0]) if (part && maps[1].get(name) && maps[2].get(name)) {
+          const child = align([part, maps[1].get(name), maps[2].get(name)]);
+          if (child) children.set(name, child);
         }
-        return text + sources[layout].slice(at, nodes[layout].end);
-      });
-    }
-    try {
-      const aligned = align(trees.map((children, side) => ({start: 0, end: sources[side].length, children})));
-      // A possible relocation between containers stays one complete source choice.
+        if (frame < 0 && !children.size) return;
+        // A plan is a tree of range triples; a string is an already-admitted gap.
+        const plan = [];
+        if (frame >= 0) {
+          let at = nodes[frame].start;
+          for (const part of rows[frame]) {
+            plan.push(sources[frame].slice(at, part.start), children.get(part.id) || (maps[0].get(part.id).common ?? {ranges: maps.map(map => map.get(part.id))}));
+            at = part.end;
+          }
+          plan.push(sources[frame].slice(at, nodes[frame].end));
+        } else {
+          let at = nodes.map(node => node.start);
+          for (const child of children.values()) {
+            const ranges = child.nodes;
+            plan.push({ranges: ranges.map((node, side) => ({start: at[side], end: node.start}))}, child);
+            at = ranges.map(node => node.end);
+          }
+          plan.push({ranges: nodes.map((node, side) => ({start: at[side], end: node.end}))});
+        }
+        return {nodes, plan};
+      }
+      const plan = align(trees.map((tree, side) => ({start: 0, end: sources[side].length, children: tree.parts})));
       for (const side of [0, 1]) {
         const destinations = new Map();
-        spend(added[side].size + removed[side].size);
+        check(added[side].size + removed[side].size);
         for (const [kind, parent] of added[side].values())
           destinations.set(kind, destinations.has(kind) && destinations.get(kind) !== parent ? null : parent);
         for (const [kind, parent] of removed[side].values())
           if (destinations.has(kind) && destinations.get(kind) !== parent) throw null;
       }
-      // A shared disappearance with different additions may be competing destinations.
       if ([...removed[0].keys()].some(name => removed[1].has(name)) &&
         (added[0].size !== added[1].size || [...added[0].keys()].some(name => !added[1].has(name)))) throw null;
-      if (aligned) {
-        const result = merge(...aligned, {...budget, structure: undefined, from: undefined});
-        return budget._budget.left < 0 ? complete() : result;
+      if (plan) {
+        // Project original ranges once. Nested moves never rebuild aligned documents.
+        const chunks = [], conflicts = [];
+        let length = 0;
+        function project(item) {
+          if (item.plan) { for (const child of item.plan) project(child); return; }
+          check(1);
+          let text = item;
+          if (typeof item !== 'string') {
+            const result = merge(...item.ranges.map(content), {...budget, structure: undefined, from: undefined});
+            check(0); text = result.text;
+            for (const conflict of result.conflicts)
+              conflicts.push({at: conflict.at.map(at => at + length), theirs: conflict.theirs});
+          }
+          chunks.push(text); length += text.length;
+        }
+        project(plan);
+        return {text: chunks.join(''), conflicts};
       }
     } catch (error) { if (error !== null) throw error; return complete(); }
   }
-  const changes = options._edits || [mine, theirs].map(text => diff(base, text, budget).edits);
+  const changes = options._edits || [mine, theirs].map((text, side) => diff(base, text,
+    {...budget, structure: trees[0] && options.structure, _observed: trees[0] ? [trees[0], trees[side + 1]] : undefined}).edits);
   if (trees.some(Boolean) && budget._budget.left < 0) return complete();
   const edits = [mine, theirs].flatMap((text, side) => changes[side].map(change =>
     [...change.before, text.slice(...change.after), side]));