rapier-html 1.2.3 → 1.2.5

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};
+}

package/dist/ledger/diff/moves.mjs

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+import {separate, phrases} from './concerns.mjs';
+
+// Moves bind equal transported fragments at both ends; renames group a binding's sites.
+export function moves(c) {
+  const {before, after, spend, safe, budget, raw, code, tokens, matches, walk, structures, pa, pb, la, aliases} = 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]);
+  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 = []) => {
+      const [from, to] = item[side];
+      let k = 0, hi = parts.length;
+      while (k < hi) { const mid = k + hi >>> 1; if (parts[mid].start < from) k = mid + 1; else hi = mid; }
+      for (; k < parts.length && parts[k].start <= to; k++) {
+        const p = parts[k]; check(1);
+        if (p.end <= to && p.name === item[3][2] && !/\S/.test(text.slice(from, p.start) + text.slice(p.end, to))) return item[3][1] + '\0' + item[3][2];
+      }
+      return text.slice(from, to).trim();
+    };
+    for (const item of c.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 c.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;
+      // Edited wording still travels: plain text, or a prose part of the same kind.
+      const text = value.trim(), prose = !structures || /^(paragraph|item|task|row|quote|section)$/.test(item[3][1]);
+      if (!old && prose && text.length >= 24) for (const candidate of deleted.values()) {
+        check(1);
+        if (!candidate || candidate[4] || candidate[3][1] !== item[3][1]) continue;
+        const prior = before.slice(...candidate[0]).trim();
+        const a = tokens(prior, 0, prior.length, 2), b = tokens(text, 0, text.length, 2);
+        if (!a || !b) throw null;
+        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, text.length) * 3 && n >= score) { old = n === score ? null : candidate; score = n; }
+      }
+      if (!old || old[4]) continue;
+      // Separators that only one end carries stay outside the transported text.
+      const x = [...old[0]], y = [...item[1]];
+      for (const end of [0, 1]) {
+        const pattern = end ? /\s*$/ : /^\s*/, left = before.slice(...x).match(pattern)[0], right = after.slice(...y).match(pattern)[0];
+        let common = 0;
+        while (common < Math.min(left.length, right.length) && left.at(end ? common : -1 - common) === right.at(end ? common : -1 - common)) common++;
+        const dx = (left.length - common) * (end ? -1 : 1), dy = (right.length - common) * (end ? -1 : 1);
+        if (safe(before, x[end] + dx) && safe(after, y[end] + dy)) { x[end] += dx; y[end] += dy; }
+      }
+      const outer = c.result; c.result = [];
+      walk(...x, ...y, 1);
+      // A changed heading can occupy a whole line while its marker still anchors the move.
+      if (c.result.length && (c.result[0][0][0] === x[0] || c.result[0][1][0] === y[0] ||
+        c.result.at(-1)[0][1] === x[1] || c.result.at(-1)[1][1] === y[1])) {
+        c.result = []; walk(...x, ...y, 2);
+      }
+      separate(c, x[1], y[1]);
+      phrases(c);
+      const inner = c.result; c.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]);
+      };
+      // Unmatched outer separators travel with the move, so restoring it alone keeps blocks apart.
+      fragment(old[0][0], x[0], 0, 0, move); fragment(0, 0, item[1][0], y[0], move);
+      let a = x[0], b = y[0], wording;
+      for (const edit of inner) {
+        if (edit[3][3]) wording = edit[3];
+        else if (a !== edit[0][0] || b !== edit[1][0]) wording = [edit[3][0], edit[3][1]];
+        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, move);
+      fragment(0, 0, y[1], item[1][1], move);
+    }
+    c.result = c.result.flatMap(item => item[4] || [item]);
+
+    if (structures) {
+      check(la.length * Math.ceil(Math.log2(la.length + 1)) + c.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 < c.result.length && c.result[cursor][0][1] <= link.at[0]) { delta = c.result[cursor][1][1] - c.result[cursor][0][1]; cursor++; }
+        if (cursor === c.result.length || c.result[cursor][0][0] >= link.at[1]) mapped[[link.at[0] + delta, link.at[1] + delta]] = link.to;
+      }
+      c.lb = c.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 + c.lb.length);
+        const left = la.filter(l => l.key === old.key), right = c.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(c.result.length * 2);
+          if (c.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 = c.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(c.result.length + owned.length * 2);
+        const owners = new Set(owned.map(c => c[3]).filter(Boolean)), members = new Set(owned);
+        if (c.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;
+    c.result = c.result.flatMap(item => item[4] || [item]);
+  }
+}

package/dist/ledger/diff/structure.mjs

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+// Capture only the reader contract before another observation can reuse its objects.
+export function observe(text, reader, spend, safe, references = true, lenient = false) {
+  let value;
+  try { value = reader(text); } catch (error) { return {invalid: true, threw: true, error}; }
+  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; }
+}