rapier-markdown-kit 1.1.98 → 1.1.101

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

@@ -0,0 +1,610 @@
+// SPDX-License-Identifier: MIT
+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 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;
+  }
+
+  function record(a0, a1, b0, b1, unit, part, coarse = false) {
+    if (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) => {
+      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 (parts?.length && level === 0) {
+      let at = start;
+      for (const part of parts) {
+        if (!spend() || out.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;
+    }
+    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;
+      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 (b === end) break;
+    }
+    return out;
+  }
+
+  // Unique anchors and fallback equal pairs share one bounded subsequence search.
+  function matches(a, b) {
+    const found = [], 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]);
+      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];
+        (positions[key] ||= [0]).push(j);
+      }
+      for (let i = a0; i < a1; i++) {
+        const list = positions[a[i][2]]; if (list) list[0]++;
+      }
+      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]];
+        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; }
+          const j = list[p];
+          let lo = 0, hi = tails.length;
+          while (lo < hi) {
+            if (!spend()) break search;
+            const middle = lo + hi >>> 1;
+            if (tails[middle][1] < j) lo = middle + 1; else hi = middle;
+          }
+          tails[lo] = [i, j, tails[lo - 1]];
+        }
+      }
+      if (budget.left < 0) continue;
+      const chain = [];
+      for (let node = tails.at(-1); node; node = node[2]) chain.push(node);
+      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]);
+        x = i + 1; y = j + 1;
+      }
+      if (unique) pending.push([x, a1, y, b1]);
+    }
+    return found.sort((x, y) => x[0] - y[0]);
+  }
+
+  function walk(a0, a1, b0, b1, level, ap, bp, context) {
+    if (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--;
+      a1 -= n; b1 -= n;
+    }
+    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;
+    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);
+      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);
+        } else if (structural) {
+          const p = a[ai]?.[3], q = b[bi]?.[3];
+          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);
+        else if (level === 2 && !raw && i - ai <= 1 && j - bi <= 1 && x1 - x0 + y1 - y0 < 100) {
+          const start = result.length;
+          walk(x0, x1, y0, y1, 3, null, null, context);
+          const edits = result.slice(start);
+          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;
+            }
+          }
+        } 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);
+      }
+      ai = i + 1; bi = j + 1;
+    }
+  }
+
+  // Surviving source pieces keep the occurrence witnessed by the host.
+  function operations(rows) {
+    if (!Array.isArray(rows)) return null;
+    const pieces = [[0, before.length]];
+    let length = before.length, steps = 1e7;
+    const verify = n => {
+      if ((steps -= n) >= 0) return true;
+      budget.left = -1; return false;
+    };
+    const split = at => {
+      let position = 0;
+      for (let i = 0; i < pieces.length; i++) {
+        const [start, end, text] = pieces[i], size = end - start;
+        if (position === at) return i;
+        if (position + size > at) {
+          const n = at - position;
+          pieces.splice(i, 1, [start, start + n, text], [start + n, end, text]);
+          return i + 1;
+        }
+        position += size;
+      }
+      return pieces.length;
+    };
+    for (const row of rows) {
+      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;
+      if (row.removed === row.inserted) continue;
+      pieces.splice(left, right - left, [0, row.inserted.length, row.inserted]);
+      length += row.inserted.length - row.removed.length;
+    }
+    if (length !== after.length) return null;
+    const spans = [];
+    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 (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; }
+        while (tail > x && (!safe(before, tail) || !safe(after, at + tail - start))) { tail--; if (!verify(1)) return null; }
+        if (tail > x) {
+          if (a !== x || b !== y) spans.push([a, x, b, y]);
+          a = tail; b = at + tail - start;
+        }
+      }
+      at += size;
+    }
+    if (a !== before.length || b !== after.length) spans.push([a, before.length, b, after.length]);
+    return spans;
+  }
+
+  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 || []);
+      aliases = new Map();
+      const oldByKey = new Map(pa.filter(p => p.key).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);
+        if (old?.nameAt && p.nameAt && old.kind === p.kind && !oldNames.has(p.name) && !newNames.has(old.name)) aliases.set(p, old);
+      }
+    } catch { structures = undefined; code = true; }
+  }
+  const evidence = options.from && operations(options.from);
+  if (evidence) for (const span of evidence) walk(...span, structures ? 0 : raw === 'char' ? 3 : 1, pa, pb);
+  else walk(0, before.length, 0, after.length, structures ? 0 : raw === 'char' ? 3 : raw === 'word' ? 2 : 1,
+    structures?.[0]?.parts, structures?.[1]?.parts);
+
+  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.
+    const deleted = new Map();
+    const moveKey = (item, side, text, parts = []) => {
+      check(parts.length);
+      return parts.some(p => p.start === item[side][0] && p.end <= item[side][1] && p.name === item[3][2] && !/\S/.test(text.slice(p.end, item[side][1])))
+        ? item[3][1] + '\0' + item[3][2] : text.slice(...item[side]).trim();
+    };
+    for (const item of result) if (item[3][0] === 0 && !item[2]) {
+      const value = before.slice(...item[0]), key = moveKey(item, 0, before, pa);
+      if (item[3][2] || value.trim().length >= 4 && /[\n ]/.test(value)) deleted.set(key, deleted.has(key) ? null : item);
+    }
+    for (const item of result) if (item[3][0] === 2 && !item[2]) {
+      const value = after.slice(...item[1]), key = moveKey(item, 1, after, pb);
+      let old = deleted.get(key), score = 0;
+      if (!old && !structures && key.length >= 24) for (const [prior, candidate] of deleted) {
+        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);
+        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;
+      }
+      const outer = result; result = [];
+      walk(...x, ...y, 1);
+      const inner = result; result = outer;
+      // Equal boundary fragments make the exact extent recoverable without display context.
+      if (inner.length && (inner[0][0][0] === x[0] || inner[0][1][0] === y[0] ||
+        inner.at(-1)[0][1] === x[1] || inner.at(-1)[1][1] === y[1] || inner.some(c => c[2]))) continue;
+      const move = [3, item[3][2] ? item[3][1] : code ? 'line' : 'block', item[3][2], [x, y]];
+      old[4] = []; item[4] = [];
+      const fragment = (a0, a1, b0, b1, group) => {
+        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;
+      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]];
+        wording[2] = item[3][2]; wording[3] = move[3];
+        if (wording[0] !== edit[3][0]) wording[0] = 1;
+        fragment(a, edit[0][0], b, edit[1][0], move);
+        fragment(...edit[0], ...edit[1], wording);
+        a = edit[0][1]; b = edit[1][1];
+      }
+      fragment(a, x[1], b, y[1], move);
+      fragment(x[1], old[0][1], 0, 0, [0, 'char']);
+      fragment(0, 0, y[1], item[1][1], [2, 'char']);
+    }
+    result = result.flatMap(item => item[4] || [item]);
+
+    if (structures) {
+      check(la.length * Math.ceil(Math.log2(la.length + 1)) + lb.length + pa.length + pb.length);
+      const mapped = {}; let cursor = 0, delta = 0;
+      for (const link of [...la].sort((a, b) => a.at[0] - b.at[0])) {
+        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});
+      for (const [p, old] of aliases) {
+        if (before.slice(...old.nameAt) === after.slice(...p.nameAt)) continue;
+        check(la.length + lb.length);
+        const left = la.filter(l => l.key === old.key), right = lb.filter(l => l.key === p.key);
+        if (left.length !== right.length) continue;
+        const x = [old.nameAt], y = [p.nameAt], owned = [];
+        for (let i = 0; i < left.length; i++) {
+          x.push(left[i].at); y.push(right[i].at);
+          if (left[i].labelAt && right[i].labelAt && before.slice(...left[i].labelAt) === before.slice(...old.nameAt) &&
+            after.slice(...right[i].labelAt) === after.slice(...p.nameAt)) { x.push(left[i].labelAt); y.push(right[i].labelAt); }
+        }
+        x.sort((a, b) => a[0] - b[0]); y.sort((a, b) => a[0] - b[0]);
+        let complete = true;
+        for (let i = 0; i < x.length; i++) {
+          check(result.length * 2);
+          if (result.some(c => c[3]?.[0] !== 3 && (overlaps(c[0], x[i]) || overlaps(c[1], y[i])) && !inside(c, x[i], y[i]))) { complete = false; break; }
+          const found = result.filter(c => c[3][0] < 3 && inside(c, x[i], y[i]));
+          if (!found.length) { complete = false; break; }
+          owned.push(...found);
+        }
+        if (!complete) continue;
+        check(result.length + owned.length * 2);
+        const owners = new Set(owned.map(c => c[3]).filter(Boolean)), members = new Set(owned);
+        if (result.some(c => owners.has(c[3]) && !members.has(c))) continue;
+        const group = [4, p.kind, old.name, [[...old.nameAt], [...p.nameAt]]];
+        for (const item of owned) item[3] = group;
+      }
+    }
+  } } catch (error) {
+    if (error !== null) throw error;
+    result = result.flatMap(item => item[4] || [item]);
+  }
+
+  const changes = [], edits = [];
+  let normalized;
+  const meaning = structures?.[0]?.meaning;
+  const format = typeof meaning === 'string' && meaning === structures[1].meaning;
+  for (let i = 0; i < result.length; i++) {
+    const item = result[i];
+    if (raw === 'char' && !evidence) {
+      const a = item[0], b = item[1], next = result[i + 1];
+      if (item[3][0] !== 1) {
+        const room = Math.min((next?.[0][0] ?? before.length) - a[1], (next?.[1][0] ?? after.length) - b[1]);
+        let n = 0;
+        while (n < room && before[a[0] + n] === after[b[0] + n] && spend()) n++;
+        while (n && (!safe(before, a[0] + n) || !safe(before, a[1] + n) || !safe(after, b[0] + n) || !safe(after, b[1] + n))) n--;
+        a[0] += n; a[1] += n; b[0] += n; b[1] += n;
+      }
+      const p = normalized;
+      if (p && p[0][0] === p[0][1] && item[3][0] === 2 && p[0][0] === a[0] && p[1][1] === b[0]) {
+        p[1][1] = b[1]; if (item[2]) edits.at(-1).coarse = true; continue;
+      }
+      normalized = item;
+    }
+    const group = item[3];
+    if (!raw && !group[3]) group[3] = [[...item[0]], [...item[1]]];
+    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]++;
+      }
+      group[4] = []; changes.push(group);
+      if (format) group[0] = 5;
+    }
+    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) {
+      if (change[0] === 5) continue;
+      if (!spend(pa.length + pb.length + lb.length)) break;
+      const range = change[3];
+      const older = pa.filter(p => p.start <= range[0][0] && p.end >= range[0][1]), newer = pb.filter(p => p.start <= range[1][0] && p.end >= range[1][1]);
+      const part = (change[0] === 0 ? older : newer).at(-1) || older.at(-1);
+      if (!change[2] && part?.name) { change[2] = part.name; change[1] = part.kind; }
+      const names = new Set([change[2], ...older.map(p => p.name), ...newer.map(p => p.name)]), breaks = [], affects = [];
+      for (const {at, to} of lb) {
+        if (!names.has(to)) continue;
+        if (!newNames.has(to)) { if (oldNames.has(to)) breaks.push({at, to}); continue; }
+        if (!spend(edits.length + pb.length) || edits.some(c => overlaps(at, c.after))) continue;
+        const p = pb.filter(p => p.start <= at[0] && p.end >= at[1] && /^(paragraph|call|item|task|cell|declaration)$/.test(p.kind)).at(-1);
+        affects.push(p && !edits.some(c => p.start < c.after[1] && p.end > c.after[0]) ? [p.start, p.end] : at);
+      }
+      if (breaks.length) change[6] = breaks;
+      if (affects.length) change[5] = affects;
+    }
+  }
+  if (options._stats) Object.assign(options._stats, {work: Math.max(0, initial - Math.max(0, budget.left)), coarse: edits.some(c => c.coarse)});
+  // Concern tuples: kind, unit, name, context, edits, affects, breaks.
+  return {edits, changes: changes.map(([kind, unit, name, context, owned, affects, breaks], i) => ({
+    id: i + 1, kind: ['delete', 'replace', 'insert', 'move', 'rename', 'format'][kind], unit, edits: owned,
+    ...(name ? {name} : {}), ...(context ? {context: {before: context[0], after: context[1]}} : {}),
+    ...(affects ? {affects} : {}), ...(breaks ? {breaks} : {})
+  }))};
+}
+
+export function merge(base, mine, theirs, options = {}) {
+  if (mine === theirs || base === theirs || base === mine) return {text: base === mine ? theirs : mine, conflicts: []};
+  const budget = {...options, _unit: 'char', _structure: true,
+    _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 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)]}));
+  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);
+            }
+          }
+          return map;
+        });
+        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;
+        }
+        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;
+        }
+        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;
+        }
+        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.
+      for (const side of [0, 1]) {
+        const destinations = new Map();
+        spend(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;
+      }
+    } catch (error) { if (error !== null) throw error; return complete(); }
+  }
+  const changes = options._edits || [mine, theirs].map(text => diff(base, text, budget).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]));
+  edits.sort((a, b) => a[0] - b[0] || a[3] - b[3] || a[1] - b[1]);
+  const conflicts = [];
+  let at = 0, text = '';
+  for (let index = 0; index < edits.length;) {
+    const start = edits[index][0], sides = [['', start], ['', start]];
+    let end = start, changed = 0;
+    for (;;) {
+      const edit = edits[index++], side = edit[3], row = sides[side];
+      if (edit[1] >= end) {
+        if (edit[1] > end) sides[1 - side][2] = null;
+        end = edit[1]; row[2] = edit;
+      }
+      row[0] += base.slice(row[1], edit[0]) + edit[2]; changed |= 1 << side;
+      row[1] = edit[1];
+      if (index === edits.length) break;
+      const [a, b, t, side2] = edits[index], peer = sides[1 - side2][2];
+      if (!(a < end || a === start || peer &&
+        (a === end && peer[0] === end || a === b && peer[0] < end &&
+          a - end < t.length && (peer[2] + base.slice(end, a)).endsWith(t)))) break;
+    }
+    for (const row of sides) row[0] += base.slice(row[1], end);
+    text += base.slice(at, start);
+    const from = text.length;
+    text += sides[changed & 1 ? 0 : 1][0];
+    if (changed === 3 && sides[0][0] !== sides[1][0]) conflicts.push({at: [from, text.length], theirs: sides[1][0]});
+    at = end;
+  }
+  return {text: text + base.slice(at), conflicts};
+}