rapier-html 1.1.104 → 1.2.5

package/dist/ledger/diff/concerns.mjs

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MIT
+import {letter, within, prev, next} from './tokens.mjs';
+
+// Separator-only pieces join the edit beside them; adjacent blocks each carry their own line break.
+export function separate(c, endA = c.before.length, endB = c.after.length) {
+  const {before, after, safe, raw, spend} = c;
+  // A separator-only piece beside another edit joins it; equal separators at its ends stay unchanged.
+  if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
+    const p = c.result[i - 1], q = c.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] && spend()) 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;
+    // CRLF steps as one separator.
+    for (let k; x[0] < x[1] && y[0] < y[1] && /\s/.test(before[x[1] - 1]) && before[x[1] - 1] === after[y[1] - 1] &&
+      (k = before.endsWith('\r\n', x[1]) && after.endsWith('\r\n', y[1]) ? 2 : 1) <= Math.min(x[1] - x[0], y[1] - y[0]) &&
+      safe(before, x[1] - k) && safe(after, y[1] - k);) { x[1] -= k; y[1] -= k; }
+    keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
+    c.result.splice(i - 1, 2, [x, y, false, keep[3]]);
+  }
+  // Repeated closing lines can attach to the wrong block. Rotate an exact insertion/deletion to the
+  // next blank-line boundary, without crossing another edit or splitting a character.
+  if (!raw) for (let i = 0; i < c.result.length; i++) {
+    const p = c.result[i], q = c.result[i + 1], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1;
+    if (side < 0 || p[2]) continue;
+    const text = side ? after : before;
+    const room = Math.min((q?.[0][0] ?? endA) - p[0][1], (q?.[1][0] ?? endB) - p[1][1]);
+    let n = 0, shift = 0;
+    while (n < room && text[p[side][0] + n] === text[p[side][1] + n] && spend()) {
+      n++;
+      if (text[p[side][0] + n - 1] === '\n' && /^\r?\n/.test(text.slice(p[side][0] + n))) { shift = n; break; }
+    }
+    if (shift && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + shift) && safe(k ? after : before, span[1] + shift)))
+      for (const span of p.slice(0, 2)) { span[0] += shift; span[1] += shift; }
+  }
+  // Adjacent blocks deleted or inserted together: when the first carries the line break before it, each carries
+  // its own, so any one restores apart from its neighbours.
+  if (!raw) for (let i = 1; i < c.result.length; i++) {
+    const p = c.result[i - 1], q = c.result[i], kind = p[3][0], side = kind ? 1 : 0, text = side ? after : before;
+    if (kind % 2 || q[3][0] !== kind || p[2] || q[2] || p[side][1] !== q[side][0] || p[1 - side][0] !== q[1 - side][0]) continue;
+    const blank = /^\r?\n/.test(text.slice(...p[side])) && !/^\r?\n/.test(text.slice(...q[side])) && /(\r?\n)(?:[ \t]*\r?\n)+$/.exec(text.slice(...p[side]));
+    if (blank && blank.index > 0) p[side][1] = q[side][0] -= blank[0].length - blank[1].length;
+  }
+}
+
+// Refine the outer walk and each move's inner walk before assigning transport ownership.
+export function phrases(c) {
+  const {before, after, raw, code} = c;
+  // Whole-word replacements separated only by spaces read and restore as one phrase, and one number stays one number.
+  if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
+    const p = c.result[i - 1], q = c.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] || gap !== after.slice(p[1][1], q[1][0])) continue;
+    // A time, a date, a version or a decimal is one number.
+    const number = /^(?:[.,:/-]\d*)+$/.test(gap) && /\d/.test(before[p[0][1] - 1] + after[p[1][1] - 1]) && /\d/.test(before[q[0][0]] + after[q[1][0]]);
+    if (!number && (code || !/^[^\S\r\n]+$/.test(gap) || 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]; c.result.splice(i, 1);
+  }
+  // Paired inline markers added or removed around unchanged text on one line are one concern.
+  if (!raw && !code) for (let i = 1; i < c.result.length; i++) {
+    const p = c.result[i - 1], q = c.result[i], kind = p[3][0], side = kind ? 1 : 0, text = side ? after : before;
+    if (kind % 2 || kind !== q[3][0] || p[2] || q[2] || p[3][3] || q[3][3]) continue;
+    const open = text.slice(...p[side]), close = text.slice(...q[side]), inner = text.slice(p[side][1], q[side][0]);
+    if (!inner.trim() || inner.includes('\n') || !(open === close && /^(?:[*_]{1,3}|~~|==|`+)$/.test(open) ||
+      open === '[' && /^\]\([^\s()]*\)$/.test(close))) continue;
+    p[3] = q[3] = [kind, 'word', p[3][2], [[p[0][0], q[0][1]], [p[1][0], q[1][1]]]];
+  }
+}
+
+// Readable concerns: phrases, numbers and paired markers, then the public edits and changes with context.
+export function concerns(c) {
+  phrases(c);
+  const {before, after, spend, safe, budget, raw, code, evidence, structures, initial, options, pa, pb} = c, lb = c.lb;
+  const overlaps = (a, b) => a[0] < b[1] && a[1] > b[0];
+  // Siblings are ordered and disjoint: the parts holding a range are found by descent, outermost first.
+  const containing = (parts, from, to, out = []) => {
+    let lo = 0, hi = parts.length;
+    while (lo < hi) { const mid = lo + hi >>> 1; if (parts[mid].end < to) lo = mid + 1; else hi = mid; }
+    for (let k = lo; k < parts.length && parts[k].start <= from && spend(); k++)
+      if (parts[k].end >= to) { out.push(parts[k]); containing(parts[k].children, from, to, out); }
+    return out;
+  };
+  // Edits are ordered and disjoint on the after side.
+  const touched = (edits, range) => {
+    let lo = 0, hi = edits.length;
+    while (lo < hi) { const mid = lo + hi >>> 1; if (edits[mid].after[1] <= range[0]) lo = mid + 1; else hi = mid; }
+    return lo < edits.length && overlaps(range, edits[lo].after);
+  };
+  const changes = [], edits = [];
+  let normalized;
+  const meaning = structures?.[0]?.meaning;
+  const format = typeof meaning === 'string' && meaning === structures[1].meaning;
+  for (let i = 0; i < c.result.length; i++) {
+    const item = c.result[i];
+    if (raw === 'char' && !evidence) {
+      const a = item[0], b = item[1], next = c.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];
+      // Context completes a word only where an edge falls inside it.
+      if (!raw) for (const [text, span] of [[before, context[0]], [after, context[1]]]) {
+        const start = within(text, span[0]), end = within(text, span[1]);
+        for (let c; start && letter(c = prev(text, span[0])) && spend() && safe(text, span[0] - c.length);) span[0] -= c.length;
+        for (let c; end && letter(c = next(text, span[1])) && spend() && safe(text, span[1] + c.length);) span[1] += c.length;
+      }
+      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 (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));
+    const linksTo = new Map();
+    if (spend(pa.length + pb.length + lb.length)) lb.forEach((link, k) => linksTo.set(link.to, [...linksTo.get(link.to) || [], k]));
+    for (const change of changes) {
+      if (change[0] === 5) continue;
+      if (budget.left < 0) break;
+      const range = change[3];
+      const older = containing(structures[0].parts, ...range[0]), newer = containing(structures[1].parts, ...range[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 k of [...names].flatMap(name => linksTo.get(name) || []).sort((a, b) => a - b)) {
+        const {at, to} = lb[k];
+        if (!newNames.has(to)) { if (oldNames.has(to)) breaks.push({at, to}); continue; }
+        if (!spend() || touched(edits, at)) continue;
+        const p = containing(structures[1].parts, ...at).filter(p => /^(paragraph|call|item|task|cell|declaration)$/.test(p.kind)).at(-1);
+        affects.push(p && !touched(edits, [p.start, p.end]) ? [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. Wording inside a move shares its context.
+  const moves = new Map(changes.map((change, i) => change[0] === 3 && [change[3], i + 1]).filter(Boolean));
+  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]}} : {}),
+    ...(kind !== 3 && moves.has(context) ? {move: moves.get(context)} : {}),
+    ...(affects ? {affects} : {}), ...(breaks ? {breaks} : {})
+  }))};
+}

package/dist/ledger/diff/diff.mjs

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// One comparison: observe structure, walk the source into exact records, find moves and renames, then read them as
+// concerns. Each stage lives in its own module and shares one comparison context.
+import {observe} from './structure.mjs';
+import {boundaries, tokenizer, wordSegmenter} from './tokens.mjs';
+import {matcher} from './matching.mjs';
+import {walker} from './walk.mjs';
+import {moves} from './moves.mjs';
+import {separate, concerns} from './concerns.mjs';
+
+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 spend = (n = 1) => (budget.left -= n) >= 0, safe = boundaries(), raw = options._unit;
+  // Internal records: [before range, after range, coarse, concern, transported fragments].
+  const c = {before, after, options, budget, spend, safe, raw, chars: options.unit === 'char', initial: budget.left,
+    segmenter: wordSegmenter(), result: [], code: options.as === 'code'};
+  // A Markdown fence holds code inside prose; only code outside fences makes the text code.
+  if (options.as !== 'prose' && options.as !== 'code') c.code = /(?:^|\n)\s*(?:[{}]|(?:function|class|const|let|var|import|export|def|fn|func|package)\s+\w[^]{0,80}[({=:;])/
+    .test((before.slice(0, 4096) + '\n' + after.slice(0, 4096)).replace(/^ {0,3}(`{3,}|~{3,})[^]*?(?:^ {0,3}\1[`~]*[ \t]*$|(?![^]))/gm, ''));
+  let fallback;
+  if (options.structure && (!raw || options._structure)) {
+    let structures;
+    try {
+      structures = options._observed || [observe(before, options.structure, spend, safe), observe(after, options.structure, spend, safe)];
+      if (structures.some(value => !value || value.invalid)) throw null;
+      const [pa, pb] = structures.map(value => value.flat), aliases = new Map();
+      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);
+        if (old?.nameAt && p.nameAt && old.kind === p.kind && !oldNames.has(p.name) && !newNames.has(old.name)) aliases.set(p, old);
+      }
+      Object.assign(c, {structures, pa, pb, la: structures[0].links, lb: structures[1].links, aliases});
+    } catch {
+      // A failed reader preserves an explicit prose choice and reports why structure was not used.
+      const failed = structures?.find(value => !value || value.invalid);
+      fallback = {structure: failed?.threw ? 'threw' : budget.left < 0 ? 'limit' : 'invalid', ...(failed?.threw ? {error: failed.error} : {})};
+      c.code = options.as !== 'prose';
+    }
+  }
+  c.tokens = tokenizer(c); c.matches = matcher(spend, budget);
+  const {walk, operations} = Object.assign(c, walker(c)), {structures, pa, pb} = c;
+  const evidence = c.evidence = options.from && operations(options.from);
+  if (options.from && !evidence) (fallback ||= {}).from = budget.left < 0 ? 'limit' : 'invalid';
+  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 === 'word' ? 2 : 1,
+    structures?.[0]?.parts, structures?.[1]?.parts);
+  separate(c);
+  moves(c);
+  // A heading edit can re-record its children. Compare both walks after transport is known: unchanged moved
+  // fragments cost nothing, so a smaller plain walk cannot discard a move just by aligning some of its lines.
+  if (structures && !evidence && !raw && c.result.some(r => r[0][0] === r[0][1]) && c.result.some(r => r[1][0] === r[1][1]) &&
+    budget.left >= c.initial - budget.left) {
+    const size = (rows, transport = false) => rows.reduce((n, r) => n + (!transport && r[3][0] === 3 ? 0 : r[0][1] - r[0][0] + r[1][1] - r[1][0]), 0);
+    const walked = c.result, links = c.lb, cost = size(walked);
+    if (cost) {
+      c.result = []; c.lb = structures[1].links;
+      walk(0, before.length, 0, after.length, 1);
+      separate(c); moves(c);
+      const plain = size(c.result);
+      if (budget.left < 0 || c.result.some(r => r[2]) || plain > cost ||
+        plain === cost && size(c.result, true) >= size(walked, true)) { c.result = walked; c.lb = links; }
+    }
+  }
+  const {edits, changes} = concerns(c);
+  return {edits, ...(fallback && !raw ? {fallback} : {}), changes};
+}

package/dist/ledger/diff/index.mjs

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+// The package entry: compare two texts, or merge two edits of one base.
+import {diff} from './diff.mjs';
+import {merge} from './merge.mjs';
+export {diff, merge};

package/dist/ledger/diff/matching.mjs

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+// Subsequence search over token keys, bounded by a shared work budget.
+export function matcher(spend, budget) {
+  // Unique anchors and fallback equal pairs share one bounded subsequence search. Repetitive text, where equal pairs
+  // are too many to visit, anchors on runs of tokens found once on each side, then on positions, then on a shortest
+  // script; only a range none of them can afford within the work limit stays coarse.
+  function matches(a, b) {
+    const found = new Array(a.length), pending = [[0, a.length, 0, b.length]];
+    // Patience chain over candidate pairs in a order; unique anchors split the range into searched gaps.
+    const chain = (pairs, a0, a1, b0, b1, split, near) => {
+      const tails = [];
+      for (const [i, j] of pairs) {
+        let lo = 0, hi = tails.length;
+        while (lo < hi) { const middle = lo + hi >>> 1; if (tails[middle][1] < j) lo = middle + 1; else hi = middle; }
+        tails[lo] = [i, j, tails[lo - 1]];
+      }
+      const kept = [];
+      for (let node = tails.at(-1); node; node = node[2]) kept.push(node);
+      let x = a0, y = b0;
+      for (const [i, j] of kept.reverse()) {
+        found[i] = j;
+        if (split && x < i && y < j) pending.push([x, i, y, j, near]);
+        x = i + 1; y = j + 1;
+      }
+      if (split && x < a1 && y < b1) pending.push([x, a1, y, b1, near]);
+    };
+    while (pending.length) {
+      let [a0, a1, b0, b1, near] = pending.pop();
+      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;
+      // Between anchored runs the change is usually small; a token found once by chance must not misalign it.
+      if (near && shortest(a, b, a0, a1, b0, b1, found, 4 * (a1 - a0 + b1 - b0))) continue;
+      const positions = new Map();
+      for (let j = b0; j < b1; j++) {
+        const list = positions.get(b[j]);
+        if (list) list.push(j); else positions.set(b[j], [0, j]);
+      }
+      for (let i = a0; i < a1; i++) {
+        const list = positions.get(a[i]); if (list) list[0]++;
+      }
+      let unique = 0, count = 0;
+      for (const list of positions.values()) {
+        count += list[0] * (list.length - 1);
+        if (list[0] === 1 && list.length === 2) unique++;
+      }
+      if (!count) continue;
+      // With no unique anchors, equal-length repeated runs prefer their witnessed positions to an arbitrary LIS.
+      if (!unique && a1 - a0 === b1 - b0) {
+        const anchors = diagonal(a, b, a0, a1, b0, b1);
+        if (anchors) { chain(anchors, a0, a1, b0, b1, true, true); continue; }
+      }
+      // Charge the chain before building it: one that cannot be afforded falls through to cheaper anchors.
+      const chained = unique || count, cost = chained * Math.ceil(Math.log2(chained + 2));
+      if (cost <= budget.left) {
+        const pairs = [];
+        for (let i = a0; i < a1; i++) {
+          const list = positions.get(a[i]);
+          if (!list || unique && (list[0] !== 1 || list.length !== 2)) continue;
+          for (let p = list.length - 1; p > 0; p--) pairs.push([i, list[p]]);
+        }
+        spend(cost);
+        chain(pairs, a0, a1, b0, b1, unique > 0);
+        continue;
+      }
+      // Few changes make a shortest script cheap (about n + d²); try that first at a bounded cost.
+      if (shortest(a, b, a0, a1, b0, b1, found, a1 - a0 + b1 - b0)) continue;
+      const anchors = runs(a, b, a0, a1, b0, b1) || diagonal(a, b, a0, a1, b0, b1);
+      if (anchors) chain(anchors, a0, a1, b0, b1, true, true);
+      else if (!shortest(a, b, a0, a1, b0, b1, found) && budget.left >= 0) (found.coarse ||= new Set()).add(a0);
+    }
+    return found;
+  }
+
+  // Runs of k tokens found once on each side anchor text whose single tokens all repeat. Window hashes are checked
+  // token by token, so a collision costs work, never correctness.
+  function runs(a, b, a0, a1, b0, b1) {
+    const ids = new Map(), id = key => ids.get(key) ?? (ids.set(key, ids.size), ids.size - 1);
+    const left = Int32Array.from({length: a1 - a0}, (_, k) => id(a[a0 + k])), right = Int32Array.from({length: b1 - b0}, (_, k) => id(b[b0 + k]));
+    for (const k of [16, 4, 64]) {
+      if (k > Math.min(left.length, right.length) || !spend(2 * (left.length + right.length))) return;
+      // A prime modulus below 2^31 and a base below 2^21 keep every product exact in a double.
+      const P = 2147483647, B = 1000003;
+      let power = 1;
+      for (let n = 1; n < k; n++) power = power * B % P;
+      const windows = list => {
+        const seen = new Map();
+        let hash = 0;
+        for (let n = 0; n < list.length; n++) {
+          if (n >= k) hash = (hash + P - (list[n - k] + 1) * power % P) % P;
+          hash = (hash * B + list[n] + 1) % P;
+          if (n >= k - 1) seen.set(hash, seen.has(hash) ? -1 : n - k + 1);
+        }
+        return seen;
+      };
+      const mine = windows(left), theirs = windows(right), pairs = [];
+      for (const [hash, i] of mine) {
+        const j = theirs.get(hash);
+        if (i < 0 || j === undefined || j < 0) continue;
+        let n = 0;
+        while (n < k && left[i + n] === right[j + n]) n++;
+        if (n === k) pairs.push([a0 + i, b0 + j]);
+      }
+      // Overlapping windows add nothing a gap's equal-run trim does not find; keep one per k tokens.
+      pairs.sort((p, q) => p[0] - q[0]);
+      const spaced = [];
+      for (const pair of pairs) if (!spaced.length || pair[0] >= spaced.at(-1)[0] + k) spaced.push(pair);
+      if (spaced.length && spend(pairs.length + spaced.length * Math.ceil(Math.log2(spaced.length + 2)))) return spaced;
+    }
+  }
+
+  // Repeated lines align by position: tokens equal on the start diagonal before a split and on the end diagonal after
+  // it, at the split that keeps the most. Used only when they cover at least half of the shorter side.
+  function diagonal(a, b, a0, a1, b0, b1) {
+    const n = a1 - a0, m = b1 - b0, shift = m - n, size = Math.min(n, m);
+    if (!spend(2 * (n + m))) return;
+    // head[s]: equal pairs on the start diagonal among the first s tokens; tail[s]: on the end diagonal from s on.
+    const head = new Int32Array(n + 1), tail = new Int32Array(n + 2);
+    for (let i = 0; i < n; i++) head[i + 1] = head[i] + (i < m && a[a0 + i] === b[b0 + i]);
+    for (let i = n - 1; i >= 0; i--) tail[i] = tail[i + 1] + (i + shift >= 0 && a[a0 + i] === b[b0 + i + shift]);
+    // A deletion (shift < 0) skips -shift tokens of a between the diagonals.
+    let best = -1, split = 0;
+    for (let s = 0; s <= n; s++) {
+      const rest = Math.min(n, s + Math.max(0, -shift)), kept = head[s] + tail[rest];
+      if (kept > best) { best = kept; split = s; }
+    }
+    if (best * 2 < size) return;
+    const pairs = [], rest = Math.min(n, split + Math.max(0, -shift));
+    for (let i = 0; i < split; i++) if (i < m && a[a0 + i] === b[b0 + i]) pairs.push([a0 + i, b0 + i]);
+    for (let i = rest; i < n; i++) if (i + shift >= 0 && a[a0 + i] === b[b0 + i + shift]) pairs.push([a0 + i, b0 + i + shift]);
+    return pairs;
+  }
+
+  // Myers' greedy search: O((N + M) D) steps; each frontier is kept for the backward pass. An attempt can stop at
+  // its own share of the work and report no script.
+  function shortest(a, b, a0, a1, b0, b1, found, share = Infinity) {
+    const n = a1 - a0, m = b1 - b0, v = new Int32Array(2 * (n + m) + 3), o = n + m + 1, trace = [];
+    const step = (k = 1) => (share -= k) >= 0 && spend(k);
+    for (let d = 0; step(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]) { if (!step()) return; 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 matches;
+}

package/dist/ledger/diff/merge.mjs

@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: MIT
+import {diff} from './diff.mjs';
+import {observe} from './structure.mjs';
+import {boundaries, words, wordSegmenter} from './tokens.mjs';
+
+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 = 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
+    // A reader that throws gives no structure: the texts merge by source coordinates.
+    ? [base, mine, base, theirs].map(text => observe(text, options.structure, spend, safe, false, true)).map(tree => tree?.threw ? null : tree) : [];
+  const repeatedBase = trees.splice(2, 1)[0];
+  const equal = (a, b) => a.length === b.length && a.every((item, i) => item === b[i]);
+  if (trees.some(Boolean) || repeatedBase) {
+    try {
+      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));
+            });
+            // Each occurrence keeps its base text on one side, or the whole list does.
+            if (!equal(values[0], values[1]) && !equal(values[0], values[2]) && !(values.every(list => list.length === values[0].length) &&
+              values[0].every((text, k) => text === values[1][k] || text === values[2][k]))) throw null;
+          }
+          return maps;
+        };
+        // A part renamed on one side keeps its reader key and aligns with its base part.
+        const keyed = new Map(rows[0].filter(part => part.nameAt && part.key != null).map(part => [part.key, part]));
+        const own = new Set(rows[0].map(part => part.id)), renamed = new Map();
+        for (const side of [1, 2]) {
+          const names = new Set(rows[side].map(part => part.id));
+          for (const part of rows[side]) {
+            const old = keyed.get(part.key);
+            if (old && part.nameAt && old.kind === part.kind && !own.has(part.id) && !names.has(old.id)) renamed.set(part, old.id);
+          }
+        }
+        const id = part => renamed.get(part) ?? part.id;
+        const maps = index(id), orders = rows.map(list => list.map(id));
+        // A vanished or added copy of a repeated name keeps the order; only a different order of shared names is a reorder.
+        const within = (a, b) => { let k = 0; for (const name of b) if (name === a[k]) k++; return k === a.length; };
+        const reordered = [1, 2].map(side => {
+          const a = orders[0].filter(name => maps[side].has(name)), b = orders[side].filter(name => maps[0].has(name));
+          check(a.length + b.length); return !within(a, b) && !within(b, a);
+        });
+        index((part, side) => {
+          check(1);
+          if (part.nameAt) return part.kind.length + ':' + part.kind + sources[side].slice(...part.nameAt);
+        });
+        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 child = align([part, maps[1].get(name), maps[2].get(name)]);
+          if (child) children.set(name, child);
+        }
+        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(id(part)) || (maps[0].get(id(part)).common ?? {ranges: maps.map(map => map.get(id(part)))}));
+            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();
+        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;
+      }
+      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 (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, 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();
+  // An edit reaches over the words it touches; edits whose reaches overlap form one group, so letters
+  // joined from both branches never form a word neither wrote.
+  const spans = words(wordSegmenter(), base);
+  const word = at => {
+    let low = 0, high = spans.length;
+    while (low < high) { const mid = low + high >> 1; if (spans[mid][1] <= at) low = mid + 1; else high = mid; }
+    return spans[low]?.[0] <= at ? spans[low] : null;
+  };
+  const edits = [mine, theirs].flatMap((text, side) => changes[side].map(({before: [from, to], after}) =>
+    [from, to, text.slice(...after), side, from && (word(from - 1)?.[0] ?? from), word(to)?.[1] ?? to]));
+  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, reach = start, changed = 0;
+    for (;;) {
+      const edit = edits[index++], side = edit[3], row = sides[side];
+      reach = Math.max(reach, edit[5]);
+      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, from] = edits[index], peer = sides[1 - side2][2];
+      // One branch's insertion and replacement at the same base position are one contiguous edit.
+      if (!(a < end || a === start || from < reach || edits[index - 1][0] === a && edits[index - 1][3] === side2 || 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};
+}