rapier-html 1.2.3 → 1.2.5

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,9 @@ 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) {
@@ -172,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;

package/dist/ledger/history.mjs

@@ -3,8 +3,8 @@
 import {_rapierTransformSplices, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierPrepareHistoryRecords} from './journal-records.mjs';
 import {projectInverseSource, HistorySource} from './inverse-source.mjs';
 import {textRootParts, rootAfter} from './hash.mjs';
-import {authoredHistory} from './transport.mjs';
-import {plainData} from './data.mjs';
+import {authoredHistory, authoredPlacements} from './transport.mjs';
+import {plainData, canonicalJSON} from './data.mjs';
 
 const historyFailure = reason => ({ok: false, reason});
 const historyInteger = value => Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
@@ -104,8 +104,11 @@ function prepareHistory(input) {
 				!(tx.createdAt === null || historyInteger(tx.createdAt)) ||
 				(tx.turnId != null && (typeof tx.turnId !== 'string' || !tx.turnId || tx.turnId.length > 160))) return historyFailure('history_invalid');
 			if (tx.baseRevision !== prior) complete = false;
+			const coincidentWitness = !splices.length && record.authored && Array.isArray(record.authored.splices) &&
+				record.authored.splices.some(row => row.removed.length);
 			if (!splices || effect === undefined || (!splices.length &&
-				!Object.values(effect || {}).some(pair => pair.before !== pair.after) && !effects.references.get(tx.id)?.length)) return historyFailure('history_unavailable');
+				!Object.values(effect || {}).some(pair => pair.before !== pair.after) && !effects.references.get(tx.id)?.length &&
+				!coincidentWitness)) return historyFailure('history_unavailable');
 			const row = {record, splices, metadata: effect};
 			rows.push(row); byId.set(tx.id, row); prior = tx.revision;
 		}
@@ -293,10 +296,13 @@ export function historyPlaces(input, blocks) {
 			if (!slices.has(key)) slices.set(key, source.slice(from, to));
 			return slices.get(key);
 		};
+		// One record's act is read once; the blocks it touched share its fields (a whole-document delete touches every block).
+		let act = null;
 		for (const [node, afterRange] of touched) {
 			const beforeRange = ranges.range(node), previous = {...beforeRange, source: cut(beforeSource, 'b', beforeRange.from, beforeRange.to)},
 				after = {...afterRange, source: cut(afterSource, 'a', afterRange.from, afterRange.to)};
-			if (previous.source !== after.source) node.block.acts.push({...historyAct(record), before: previous, after});
+			// A point (where words were deleted) has no words to compare: the act that touched it wrote there.
+			if (previous.source !== after.source || afterRange.from === afterRange.to) node.block.acts.push({...(act ||= historyAct(record)), before: previous, after});
 		}
 	}
 
@@ -334,7 +340,27 @@ export function selectiveUndo(input, actIds, options = {}) {
 	const metadata = _rapierMetadataDelta(prepared.metadata, afterMetadata), effectChanged = selected.size > 0;
 	const sourceEffectChanged = records.some(record => record.splices.length && !prepared.effects.references.get(record.transaction.id)?.length &&
 		prepared.effects.active.has(record.transaction.id) !== projectedEffects.active.has(record.transaction.id));
-	if (!sourceEffectChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
+	// One shared replacement is visible while any of its authors is active. That
+	// includes an author stored with no second physical splice, and an inverse
+	// whose only effect is to make such an author active again.
+	let coverVisibilityChanged = false;
+	if (!sourceEffectChanged && selected.size) {
+		let origins = null;
+		try { origins = authoredPlacements(prepared.initialSource, records); } catch { origins = null; }
+		const groups = new Map();
+		if (origins) for (const record of records) {
+			const tx = record.transaction, origin = origins.get(tx.id);
+			if (!origin?.splices.some(row => row.removed.length) || tx.reverts || tx.reapplies ||
+				tx.sourceTransactionId || tx.sourceTransactionIds?.length) continue;
+			const key = canonicalJSON({basis: origin.basis, splices: origin.splices});
+			if (!groups.has(key)) groups.set(key, []);
+			groups.get(key).push(tx.id);
+		}
+		const covered = (effects, ids) => ids.some(id => effects.active.has(id));
+		for (const ids of groups.values()) if (ids.length > 1 && covered(prepared.effects, ids) !== covered(projectedEffects, ids))
+			coverVisibilityChanged = true;
+	}
+	if (!sourceEffectChanged && !coverVisibilityChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
 		sourceTransactionIds: [...selected], metadata, afterMetadata, effectChanged, unchanged: !metadata && !effectChanged,
 		superseded: [], overlaps: []};
 	try {