rapier-markdown-kit 1.1.102 → 1.1.104

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

@@ -1,4 +1,67 @@
 // 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};
@@ -11,49 +74,46 @@ export function diff(before, after, options = {}) {
     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,35 @@ 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)) { budget.left = -1; 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 +169,63 @@ 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;
+  }
+
+  // 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 found.sort((x, y) => x[0] - y[0]);
+    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))) { 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))) { 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);
         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);
@@ -157,9 +243,9 @@ export function diff(before, after, options = {}) {
         } 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 +278,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 +293,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 +311,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);
@@ -268,7 +348,7 @@ 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; }
       }
@@ -314,7 +394,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);
@@ -374,8 +454,8 @@ export function diff(before, after, options = {}) {
     if (!group[4]) {
       const context = group[3];
       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]++;
+        while (span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
+        while (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;
@@ -433,149 +513,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);
+      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();
       }
-      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);
+      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]));