rapier-html 1.1.104 → 1.2.5

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

package/dist/ledger/diff/tokens.mjs

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+// Space-free scripts (Thai, Lao, Myanmar, Khmer, kana, Han) have no word separator; the platform dictionary finds words.
+export const SPACELESS = /[\u0e00-\u0eff\u1000-\u109f\u1780-\u17ff\u3040-\u30ff\u3400-\u9fff\uf900-\ufaff]/;
+export const words = (segmenter, text) => [...text.matchAll(/[\p{L}\p{N}\p{M}_]+/gu)].flatMap(word => SPACELESS.test(word[0])
+  ? [...segmenter().segment(word[0])].map(s => [word.index + s.index, word.index + s.index + s.segment.length])
+  : [[word.index, word.index + word[0].length]]);
+export const wordSegmenter = () => { let segmenter; return () => segmenter ||= new Intl.Segmenter('en', {granularity: 'word'}); };
+
+// Segment only requested non-ASCII boundaries; observations never share a global document cache.
+export function boundaries() {
+  const segments = Object.create(null);
+  let segmenter, last = [];
+  return function safe(text, at) {
+    if (!at || at === text.length) return true;
+    const a = text.charCodeAt(at - 1), b = text.charCodeAt(at);
+    if ((a & 0xfc00) === 0xd800 && (b & 0xfc00) === 0xdc00 || a === 13 && b === 10) return false;
+    if (a < 0x300 && b < 0x300) return true;
+    // Retreats probe one long cluster many times; answer inside the last cluster without the segmenter.
+    if (last[0] === text && at > last[1] && at < last[2]) return false;
+    const found = (segments[text] ||= (segmenter ||= new Intl.Segmenter('en', {granularity: 'grapheme'})).segment(text)).containing(at);
+    last = [text, found.index, found.index + found.segment.length];
+    return found.index === at;
+  }
+}
+
+// Letters are code points: an astral letter is one letter, never two lone surrogates.
+const pair = (text, at) => (text.charCodeAt(at - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(at) & 0xfc00) === 0xdc00;
+export const prev = (text, at) => text.slice(Math.max(0, at - 1 - pair(text, at - 1)), at), next = (text, at) => text.slice(at, at + 1 + pair(text, at + 1));
+export const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c), within = (text, at) => letter(prev(text, at)) && letter(next(text, at));
+
+// Tokens at a level: 0 parts, 1 lines, 2 words, spaces and marks, 3 characters.
+export function tokenizer(c) {
+  const {spend, safe, segmenter, raw, aliases} = c;
+  return function tokens(text, start, end, level, parts) {
+    // Each source boundary is stored once, alongside comparison keys and optional owners.
+    const keys = [], at = [start], owners = [];
+    const out = [keys, at, owners];
+    const add = (a, b, part, value) => {
+      if (b <= a) return;
+      if (!part && owners[keys.length - 1]?.name && !/\S/.test(text.slice(a, b))) at[at.length - 1] = b;
+      else {
+        at.push(b); if (part) owners[keys.length] = part;
+        const key = part?.name ? '\0' + part.kind + '\0' + (aliases?.get(part)?.name || part.name) : value ?? text.slice(a, b);
+        keys.push(level === 1 && !raw ? key.trimEnd() : key);
+      }
+    };
+    if (parts?.length && level === 0) {
+      let at = start;
+      for (const part of parts) {
+        if (!spend()) 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 ? raw ? /[^\n]*\n|[^\n]+$/g : /[^\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()) return null;
+      const a = match.index, b = Math.min(end, pattern.lastIndex);
+      if (keys.length && !safe(text, a)) {
+        at[at.length - 1] = b; keys[keys.length - 1] = text.slice(at[at.length - 2], b);
+      } else if (level === 2 && b - a > 1 && SPACELESS.test(match[0])) {
+        for (const [c, d] of words(segmenter, text.slice(a, b))) { if (!spend()) return null; add(a + c, a + d); }
+      } else add(a, b, undefined, b === pattern.lastIndex ? match[0] : undefined);
+      if (b === end) break;
+    }
+    return out;
+  };
+}

package/dist/ledger/diff/walk.mjs

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: MIT
+import {words, letter, within, prev, next} from './tokens.mjs';
+
+// Exact source records for a range: lines, then words, then characters, or structural parts when supplied.
+export function walker(c) {
+  const {before, after, spend, safe, budget, raw, chars, code, segmenter, tokens, matches} = c;
+  function record(a0, a1, b0, b1, unit, part, coarse = false) {
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
+    // Internal records: before, after, coarse, concern, transported fragments.
+    c.result.push([[a0, a1], [b0, b1], coarse, [a0 === a1 ? 2 : b0 === b1 ? 0 : 1, part?.kind || unit, part?.name]]);
+  }
+
+  // A line deletion or insertion holding whole named parts and only blank text besides is one record per part,
+  // cut at line starts, so each keeps its own name (and its callers' breaks).
+  function name(from, ownersA, ownersB) {
+    for (let r = from; r < c.result.length; r++) {
+      const [[a0, a1], [b0, b1]] = c.result[r], side = a0 === a1 ? 1 : b0 === b1 ? 0 : -1;
+      if (side < 0) continue;
+      const [s0, s1] = c.result[r][side], text = side ? after : before;
+      const parts = (side ? ownersB : ownersA).filter(part => part?.name && part.start >= s0 && part.end <= s1);
+      if (!parts.length || !spend(s1 - s0)) continue;
+      let blank = text.slice(s0, parts[0].start);
+      for (let k = 1; k <= parts.length; k++) blank += text.slice(parts[k - 1].end, parts[k]?.start ?? s1);
+      if (/\S/.test(blank)) continue;
+      const rows = parts.map((part, k) => {
+        const start = k ? Math.max(parts[k - 1].end, text.lastIndexOf('\n', part.start - 1) + 1) : s0;
+        return [start, part];
+      });
+      c.result.splice(r, 1, ...rows.map(([start, part], k) => {
+        const end = rows[k + 1]?.[0] ?? s1, here = [side ? [a0, a0] : [start, end], side ? [start, end] : [b0, b0]];
+        return [here[0], here[1], false, [side ? 2 : 0, part.kind, part.name]];
+      }));
+      r += rows.length - 1;
+    }
+  }
+
+  // A search step scans at most one fixed-size source chunk.
+  function common(a, b, end, step) {
+    let n = 0;
+    while (n < end && spend()) {
+      const stop = Math.min(end, n + 256);
+      while (n < stop && before.charCodeAt(a) === after.charCodeAt(b)) { n++; a += step; b += step; }
+      if (n < stop) break;
+    }
+    return n;
+  }
+
+  function walk(a0, a1, b0, b1, level, ap, bp, context) {
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
+    if (!spend()) { record(a0, a1, b0, b1, 'block', context, true); return; }
+    const structural = level <= 0 && level > -128 && (ap?.length || bp?.length);
+    if (!structural && raw !== 'word') {
+      let n = common(a0, b0, Math.min(a1 - a0, b1 - b0), 1);
+      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n) || !raw && level < 3 && (within(before, a0 + n) || within(after, b0 + n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1 && n) {
+        const next = Math.max(0, before.lastIndexOf('\n', a0 + n - 1) + 1 - a0);
+        spend(Math.ceil((n - next) / 256)); n = next;
+      }
+      a0 += n; b0 += n;
+      n = common(a1 - 1, b1 - 1, Math.min(a1 - a0, b1 - b0), -1);
+      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n) || !raw && level < 3 && (within(before, a1 - n) || within(after, b1 - n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1) while (n && (before[a1 - n - 1] !== '\n' || after[b1 - n - 1] !== '\n' || before[a1 - n] === '\n' || after[b1 - n] === '\n')) { if (!spend()) { n = 0; break; } n--; }
+      a1 -= n; b1 -= n;
+      if (budget.left < 0) { record(a0, a1, b0, b1, 'block', context, true); return; }
+    }
+    let unit = level >= 3 ? 'char' : level === 2 ? 'word' : 'line';
+    if (!raw && level === 2 && a1 - a0 + b1 - b0 <= 4 && [...before.slice(a0, a1), ...after.slice(b0, b1)].length <= 2 &&
+    letter(prev(before, a0) || prev(after, b0)) && letter(next(before, a1) || next(after, b1))) unit = 'char';
+    if (!structural && (a0 === a1 || b0 === b1)) { record(a0, a1, b0, b1, unit, context); return; }
+    const left = tokens(before, a0, a1, structural ? 0 : Math.max(1, level), ap);
+    const right = tokens(after, b0, b1, structural ? 0 : Math.max(1, level), bp);
+    if (!left || !right) { record(a0, a1, b0, b1, unit, context, true); return; }
+    const [a, x, ownersA] = left, [b, y, ownersB] = right, pairs = matches(a, b);
+    let ai = 0, bi = 0;
+    for (let i = 0; i <= a.length; i++) {
+      const j = i === a.length ? b.length : pairs[i];
+      if (j === undefined) continue;
+      const x0 = x[ai], x1 = x[i], y0 = y[bi], y1 = y[j];
+      if (ai < i || bi < j) {
+        if (budget.left < 0 || pairs.coarse?.has(ai)) record(x0, x1, y0, y1, unit, context, true);
+        else if (structural && (ai === i || bi === j)) {
+          for (let k = ai; k < i; k++) record(x[k], x[k + 1], y0, y0, unit, ownersA[k] || context);
+          for (let k = bi; k < j; k++) record(x1, x1, y[k], y[k + 1], unit, ownersB[k] || context);
+        } else if (structural) {
+          const p = ownersA[ai], q = ownersB[bi];
+          if (i - ai === 1 && j - bi === 1 && p && q && p.kind === q.kind) walk(x0, x1, y0, y1, level - 1, p.children, q.children, q);
+          else {
+            const from = c.result.length;
+            walk(x0, x1, y0, y1, 1, null, null, context);
+            name(from, ownersA.slice(ai, i), ownersB.slice(bi, j));
+          }
+        } else if (level < 2 && raw !== 'line') lines(x.slice(ai, i + 1), y.slice(bi, j + 1), context);
+        else if (level === 2 && chars && !raw && i - ai <= 1 && j - bi <= 1 && x1 - x0 + y1 - y0 < 100) {
+          // A changed token is replaced whole unless the caller asks for the characters inside it.
+          walk(x0, x1, y0, y1, 3, null, null, context);
+        } else record(x0, x1, y0, y1, unit, context);
+      }
+      if (i < a.length) {
+        const p = ownersA[i], q = ownersB[j];
+        if ((p || q || level <= 1 && !raw) && before.slice(x[i], x[i + 1]) !== after.slice(y[j], y[j + 1]))
+          walk(x[i], x[i + 1], y[j], y[j + 1], p || q ? level - 1 : 3, p?.children, q?.children, q || p || context);
+      }
+      ai = i + 1; bi = j + 1;
+    }
+  }
+
+  // Unequal lines pair in order by shared words. A line sharing under a quarter of its words with every candidate is
+  // replaced whole: an inserted line never borrows a neighbour's words, and a rewrite never reads as stray fragments.
+  function lines(x, y, context) {
+    const n = x.length - 1, m = y.length - 1;
+    if (n * m > 4096 || !spend(n * m + x[n] - x[0] + y[m] - y[0])) return row(x[0], x[n], y[0], y[m], context);
+    // A renamed name's sites count as shared words.
+    if (!c.renames) {
+      c.renames = [[], []];
+      for (const [p, old] of c.aliases || []) if (before.slice(...old.nameAt) !== after.slice(...p.nameAt)) {
+        c.renames[0].push(old.nameAt, ...c.la.filter(l => l.key === old.key).map(l => l.at));
+        c.renames[1].push(p.nameAt, ...c.lb.filter(l => l.key === p.key).map(l => l.at));
+      }
+    }
+    const weight = (side, a, b) => {
+      const counts = new Map(), text = side ? after : before;
+      for (const [c, d] of words(segmenter, text.slice(a, b))) counts.set(text.slice(a + c, a + d), (counts.get(text.slice(a + c, a + d)) || 0) + d - c);
+      return [counts, [...counts.values()].reduce((n, v) => n + v, 0), c.renames[side].reduce((n, at) => n + Math.max(0, Math.min(b, at[1]) - Math.max(a, at[0])), 0)];
+    };
+    const left = x.slice(0, -1).map((at, k) => weight(0, at, x[k + 1])), right = y.slice(0, -1).map((at, k) => weight(1, at, y[k + 1]));
+    const best = Array.from({length: n + 1}, () => new Float64Array(m + 1)), pairs = [];
+    for (let k = 1; k <= n; k++) for (let l = 1; l <= m; l++) {
+      const [a, sa, ra] = left[k - 1], [b, sb, rb] = right[l - 1];
+      let shared = sa || sb ? Math.max(ra, rb) : 0.5;
+      for (const [key, v] of a) shared += Math.min(v, b.get(key) || 0);
+      best[k][l] = Math.max(best[k - 1][l], best[k][l - 1], shared * 4 > Math.max(sa, sb) && best[k - 1][l - 1] + shared);
+    }
+    for (let k = n, l = m; k && l;) {
+      if (best[k][l] === best[k - 1][l]) k--;
+      else if (best[k][l] === best[k][l - 1]) l--;
+      else pairs.unshift([--k, --l]);
+    }
+    let k = 0, l = 0;
+    for (const [p, q] of [...pairs, [n, m]]) {
+      // A merge compares one line against one line by character, whatever they share.
+      if (raw === 'char' && p - k === 1 && q - l === 1) row(x[k], x[p], y[l], y[q], context);
+      else if (k < p || l < q) record(x[k], x[p], y[l], y[q], 'line', context);
+      if (p < n) row(x[p], x[p + 1], y[q], y[q + 1], context);
+      k = p + 1; l = q + 1;
+    }
+  }
+
+  // A table row with the same number of cells on both sides changes cell by cell; a character diff stays in its line.
+  function row(a0, a1, b0, b1, context) {
+    if (raw === 'char') return walk(a0, a1, b0, b1, 3, null, null, context);
+    const cells = (text, a, b) => /^[ \t]*\|/.test(text.slice(a, b)) && [...text.slice(a, b).matchAll(/(?<!\\)\|/g)].map(m => a + m.index);
+    const p = !code && cells(before, a0, a1), q = p && cells(after, b0, b1);
+    if (!q || p.length !== q.length || !spend(p.length)) return walk(a0, a1, b0, b1, 2, null, null, context);
+    for (let k = 0; k <= p.length; k++) walk(k ? p[k - 1] + 1 : a0, p[k] ?? a1, k ? q[k - 1] + 1 : b0, q[k] ?? b1, 2, null, null, context);
+  }
+
+  // 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);
+      let at = 0;
+      for (let i = left; i < right; i++) {
+        const [start, end, text = before] = pieces[i];
+        if (!row.removed.startsWith(text.slice(start, end), at)) return null;
+        at += end - start;
+      }
+      if (row.removed === row.inserted) continue;
+      pieces.splice(left, right - left, [0, row.inserted.length, row.inserted]);
+      length += row.inserted.length - row.removed.length;
+    }
+    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) || !after.startsWith((text ?? before).slice(start, end), at)) return null;
+      if (text === undefined) {
+        let x = start, y = at, tail = end;
+        while (x < tail && (!safe(before, x) || !safe(after, y))) { x++; y++; if (!verify(1)) return null; }
+        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;
+  }
+  return {record, name, walk, operations};
+}

package/dist/ledger/format.mjs

@@ -27,12 +27,34 @@ function* checkedRecords(ledger, prepared) {
   }
   if (ledger.head.revision !== revision || ledger.head.root !== root) throw fault('history does not describe this document');
 }
+// A ledger object read again is proved once: a boot reads one stored history through several records. The proof holds only
+// while that object still carries the exact proved data (its start text compared whole, the rest as canonical JSON), so a
+// changed byte is proved again, and refused. The proof lives as long as the object does.
+const proofs = new WeakMap();
 function readLedgerState(input, expectedText, expectedMetadata) {
   const ledger = plainData(input);
+  // The identifier rapier-ledger/2 is unchanged and is not backward compatible. This reader
+  // admits an empty physical splice whose authored rows name the same replacement. A reader
+  // from before that rule rejects the chain. Mixed-version sync throws notes_history_unavailable
+  // and leaves the older store unchanged; that refusal is not a held or caughtUp result.
   if (!exactKeys(ledger, ['format','documentAuthority','start','records','head','complete','sha256']) || ledger.format !== 'rapier-ledger/2' ||
       typeof ledger.documentAuthority !== 'string' || !ledger.documentAuthority || ledger.documentAuthority.length > 256 ||
       typeof ledger.complete !== 'boolean' || !Array.isArray(ledger.records) ||
       !exactKeys(ledger.start, ['text','revision','root','sha256','metadata']) || !exactKeys(ledger.head, ['revision','root','sha256','metadata'])) throw fault('unsupported or invalid envelope');
+  const shell = canonicalJSON({...ledger, start: {...ledger.start, text: ''}});
+  let proof = typeof input === 'object' ? proofs.get(input) : undefined;
+  if (!proof || proof.shell !== shell || proof.startText !== ledger.start.text) {
+    proof = {shell, startText: ledger.start.text, ...proveLedger(ledger)};
+    if (typeof input === 'object') proofs.set(input, proof);
+  }
+  proofs.set(ledger, proof);
+  const {text, metadata, root, revision, prepared, source} = proof;
+  if (expectedMetadata !== undefined && (!_rapierValidMetadata(expectedMetadata) || canonicalJSON(metadata) !== canonicalJSON(expectedMetadata)))
+    throw fault('metadata does not describe this document');
+  if (expectedText !== undefined && text !== expectedText) throw fault('history does not describe this document');
+  return {value: {ledger, text, metadata: {...metadata}, root, revision, complete: ledger.complete}, prepared, source};
+}
+function proveLedger(ledger) {
   const {sha256: claimed, ...payload} = ledger;
   if (claimed !== digest(payload)) throw fault('envelope checksum differs');
   let text = documentText(ledger.start.text), root = ledger.start.root, revision = ledger.start.revision;
@@ -55,12 +77,18 @@ function readLedgerState(input, expectedText, expectedMetadata) {
     try { authoredHistory(ledger.start.text, ledger.records); } catch (_) { throw fault('authored origin differs'); }
   }
   const metadata = prepared.replayMetadata(ledger.start.metadata);
-  if (!metadata || canonicalJSON(metadata) !== canonicalJSON(ledger.head.metadata) ||
-      (expectedMetadata !== undefined && (!_rapierValidMetadata(expectedMetadata) || canonicalJSON(metadata) !== canonicalJSON(expectedMetadata))))
-    throw fault('metadata does not describe this document');
-  if (ledger.head.revision !== revision || ledger.head.root !== root || ledger.head.sha256 !== sha256(text) ||
-      (expectedText !== undefined && text !== expectedText)) throw fault('history does not describe this document');
-  return {value: {ledger, text, metadata, root, revision, complete: ledger.complete}, prepared, source};
+  if (!metadata || canonicalJSON(metadata) !== canonicalJSON(ledger.head.metadata)) throw fault('metadata does not describe this document');
+  if (ledger.head.revision !== revision || ledger.head.root !== root || ledger.head.sha256 !== sha256(text)) throw fault('history does not describe this document');
+  return {text, metadata, root, revision, prepared, source};
+}
+// A stored copy may hold the head text alone. Its start is that text with every record reversed; readLedger proves it.
+export function ledgerWithStart(input, text) {
+  let source = new HistorySource(documentText(text));
+  for (let i = input.records.length - 1; i >= 0; i--) {
+    source = source.apply(input.records[i].splices, true);
+    if (source === null) throw fault('history does not reverse from this document');
+  }
+  return {...input, start: {...input.start, text: source.slice()}};
 }
 export function readLedger(input, expectedText, expectedMetadata) {
   return readLedgerState(input, expectedText, expectedMetadata).value;
@@ -163,9 +191,7 @@ function finish(producer) {
   return step.value;
 }
 export function exportLedger(input) { return finish(produceLedger(input)).ledger; }
-// Both synchronous public export and cooperative recovery use the same producer.
 // Its returned facts were computed while admitting/hashing the exact head, never supplied.
-export function prepareLedger(input) { return finish(produceLedger(input)); }
 export async function prepareLedgerAsync(input, {yield: yieldWork, signal} = {}) {
   const producer = produceLedger(input);
   let step;
@@ -182,8 +208,8 @@ export async function prepareLedgerAsync(input, {yield: yieldWork, signal} = {})
   return step.value;
 }
 // Derived navigation, never a second history. A target older than start is intentionally unavailable.
-export function historyEnvelope(input, segmentIdentity = []) {
-  const {value: {ledger, text, metadata}, prepared, source} = readLedgerState(input);
+export function historyEnvelope(input, segmentIdentity = [], expectedText, expectedMetadata) {
+  const {value: {ledger, text, metadata}, prepared, source} = readLedgerState(input, expectedText, expectedMetadata);
   const {byId, effects: {pictures}} = prepared;
   let branch = [], cursor = 0;
   for (const {transaction: tx} of ledger.records) {
@@ -198,7 +224,7 @@ export function historyEnvelope(input, segmentIdentity = []) {
   }
   const step = (source, id, redo) => {
     const target = byId.get(id), folded = pictures.size
-      ? pictureHistorySplices({source: source.slice(), records: prepared.records}, target, redo) : null;
+      ? pictureHistorySplices({get source() { return source.slice(); }, records: prepared.records}, target, redo) : null;
     return source.apply(folded || target.splices, !folded && !redo);
   };
   let traversed = source, traversedMetadata = {...metadata};

package/dist/ledger/hash.mjs

@@ -30,13 +30,11 @@ const K = new Uint32Array([
   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
 ]);
 const rotate = (x, n) => (x >>> n) | (x << (32 - n));
-// A bounded encoder and one compression block. No full UTF-8 or padded-input copy.
-// Updates retain a trailing high surrogate so an arbitrary string boundary stays exact.
-export function createSHA256() {
+// One bounded SHA-256 compression state for file bytes and encoded source text.
+export function sha256State() {
   const h = new Uint32Array([0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19]);
-  const w = new Uint32Array(64), block = new Uint8Array(64), encoded = new Uint8Array(65536);
-  const encoder = new TextEncoder();
-  let used = 0, bytes = 0, high = '', finished = false;
+  const w = new Uint32Array(64), block = new Uint8Array(64);
+  let used = 0, bytes = 0, finished = false;
   const compress = (input, offset) => {
     for (let i = 0; i < 16; i++) {
       const at = offset + i * 4;
@@ -65,13 +63,37 @@ export function createSHA256() {
     for (; at + 64 <= size; at += 64) compress(input, at);
     if (at < size) { block.set(input.subarray(at, size), 0); used = size - at; }
   };
+  return {
+    update(input) {
+      if (finished || !(input instanceof Uint8Array)) throw new TypeError('SHA-256 needs bytes before finish');
+      if (!Number.isSafeInteger(bytes + input.length)) throw new Error('SHA-256 input length is not exact');
+      feed(input, input.length);
+    },
+    finish() {
+      if (finished) throw new Error('SHA-256 is already finished');
+      finished = true;
+      block[used++] = 0x80; block.fill(0, used);
+      if (used > 56) { compress(block, 0); block.fill(0); }
+      const view = new DataView(block.buffer);
+      view.setUint32(56, Math.floor(bytes / 0x20000000)); view.setUint32(60, (bytes * 8) >>> 0);
+      compress(block, 0);
+      return Array.from(h, x => x.toString(16).padStart(8, '0')).join('');
+    },
+    get bytes() { return bytes; },
+  };
+}
+// UTF-16 chunks share that byte state. Retain a trailing high surrogate so a
+// caller can split a character between updates without changing its UTF-8 digest.
+export function createSHA256() {
+  const hash = sha256State(), encoded = new Uint8Array(65536), encoder = new TextEncoder();
+  let high = '', finished = false;
   const write = text => {
     for (let at = 0; at < text.length;) {
       // Bound both the substring and byte allocation; encodeInto never cuts a scalar.
       let end = Math.min(text.length, at + 32768);
       if (end < text.length && (text.charCodeAt(end - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(end) & 0xfc00) === 0xdc00) end--;
       const part = encoder.encodeInto(text.slice(at, end), encoded);
-      feed(encoded, part.written); at += part.read;
+      hash.update(encoded.subarray(0, part.written)); at += part.read;
     }
   };
   return {
@@ -85,15 +107,9 @@ export function createSHA256() {
       if (finished) throw new Error('SHA-256 is finished');
       if (high) { write(high); high = ''; }
       finished = true;
-      const bits = bytes * 8;
-      block[used++] = 0x80; block.fill(0, used);
-      if (used > 56) { compress(block, 0); block.fill(0); }
-      const view = new DataView(block.buffer);
-      view.setUint32(56, Math.floor(bits / 0x100000000)); view.setUint32(60, bits >>> 0);
-      compress(block, 0);
-      return Array.from(h, x => x.toString(16).padStart(8, '0')).join('');
+      return hash.finish();
     },
-    get bytes() { return bytes; },
+    get bytes() { return hash.bytes; },
   };
 }
 export function sha256Parts(parts) {