rapier-markdown-kit 1.1.101 → 1.1.104

package/dist/kit/ledger/hash.mjs

@@ -1,12 +1,20 @@
 // SPDX-License-Identifier: MIT
 // The editor's path-dependent root, plus synchronous SHA-256 for file readers (including offline wrappers).
 export function textRoot(text) {
-  let fnv = 0x811c9dc5, a = 1, b = 0;
-  for (let i = 0; i < text.length; i++) {
-    const c = text.charCodeAt(i);
-    fnv = Math.imul(fnv ^ c, 16777619); a = (a + c) % 65521; b = (b + a) % 65521;
+  return textRootParts([text]);
+}
+// The same UTF-16 root over shared source pieces, without joining a historical body.
+export function textRootParts(parts) {
+  let fnv = 0x811c9dc5, a = 1, b = 0, length = 0;
+  for (const text of parts) {
+    length += text.length;
+    for (let i = 0; i < text.length;) {
+      const end = Math.min(text.length, i + 4096);
+      for (; i < end; i++) { const c = text.charCodeAt(i); fnv = Math.imul(fnv ^ c, 16777619); a += c; b += a; }
+      a %= 65521; b %= 65521;
+    }
   }
-  return text.length + ':' + (fnv >>> 0).toString(36) + ':' + (((b << 16) | a) >>> 0).toString(36);
+  return length + ':' + (fnv >>> 0).toString(36) + ':' + (((b << 16) | a) >>> 0).toString(36);
 }
 export function rootAfter(root, row) {
   return textRoot(String(root || '') + ':' + row.pos + ':' + textRoot(row.removed) + ':' + textRoot(row.inserted));
@@ -22,26 +30,75 @@ const K = new Uint32Array([
   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
 ]);
 const rotate = (x, n) => (x >>> n) | (x << (32 - n));
-export function sha256(text) {
-  const bytes = new TextEncoder().encode(text);
-  const padded = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
-  padded.set(bytes); padded[bytes.length] = 0x80;
-  const data = new DataView(padded.buffer), bits = bytes.length * 8;
-  data.setUint32(padded.length - 8, Math.floor(bits / 0x100000000)); data.setUint32(padded.length - 4, bits >>> 0);
-  const h = new Uint32Array([0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19]), w = new Uint32Array(64);
-  for (let offset = 0; offset < padded.length; offset += 64) {
-    for (let i = 0; i < 16; i++) w[i] = data.getUint32(offset + i * 4);
+// 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() {
+  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 compress = (input, offset) => {
+    for (let i = 0; i < 16; i++) {
+      const at = offset + i * 4;
+      w[i] = (input[at] << 24) | (input[at + 1] << 16) | (input[at + 2] << 8) | input[at + 3];
+    }
     for (let i = 16; i < 64; i++) {
       const x = w[i - 15], y = w[i - 2];
       w[i] = w[i - 16] + (rotate(x, 7) ^ rotate(x, 18) ^ (x >>> 3)) + w[i - 7] + (rotate(y, 17) ^ rotate(y, 19) ^ (y >>> 10));
     }
-    let [a,b,c,d,e,f,g,k] = h;
+    let a=h[0], b=h[1], c=h[2], d=h[3], e=h[4], f=h[5], g=h[6], k=h[7];
     for (let i = 0; i < 64; i++) {
       const t1 = (k + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + ((e & f) ^ (~e & g)) + K[i] + w[i]) >>> 0;
       const t2 = ((rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
       k = g; g = f; f = e; e = (d + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0;
     }
-    for (const [i, value] of [a,b,c,d,e,f,g,k].entries()) h[i] += value;
-  }
-  return [...h].map(x => x.toString(16).padStart(8, '0')).join('');
+    h[0]+=a; h[1]+=b; h[2]+=c; h[3]+=d; h[4]+=e; h[5]+=f; h[6]+=g; h[7]+=k;
+  };
+  const feed = (input, size) => {
+    bytes += size;
+    let at = 0;
+    if (used) {
+      const take = Math.min(64 - used, size);
+      block.set(input.subarray(0, take), used); used += take; at = take;
+      if (used === 64) { compress(block, 0); used = 0; }
+    }
+    for (; at + 64 <= size; at += 64) compress(input, at);
+    if (at < size) { block.set(input.subarray(at, size), 0); used = size - at; }
+  };
+  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;
+    }
+  };
+  return {
+    update(value) {
+      if (finished) throw new Error('SHA-256 is finished');
+      let text = high + String(value === undefined ? '' : value); high = '';
+      if (text.length && (text.charCodeAt(text.length - 1) & 0xfc00) === 0xd800) { high = text.slice(-1); text = text.slice(0, -1); }
+      write(text); return this;
+    },
+    digest() {
+      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('');
+    },
+    get bytes() { return bytes; },
+  };
+}
+export function sha256Parts(parts) {
+  const hash = createSHA256();
+  for (const part of parts) hash.update(part);
+  return hash.digest();
 }
+export function sha256(text) { return createSHA256().update(text).digest(); }

package/dist/kit/ledger/history.mjs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 // Transient projections and selective inverses of the existing canonical journal.
-import {_rapierTransformSplices, _rapierRecordSplices, _rapierRecordMetadata, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata} from './journal-records.mjs';
-import {projectInverseSource} from './inverse-source.mjs';
-import {textRoot, rootAfter} from './hash.mjs';
+import {_rapierTransformSplices, _rapierRecordSplices, _rapierRecordMetadata, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata, _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';
 
@@ -12,16 +12,16 @@ const historyBoundary = (source, at) => historyInteger(at) && at <= source.lengt
 	(source.charCodeAt(at - 1) & 0xFC00) === 0xD800 && (source.charCodeAt(at) & 0xFC00) === 0xDC00);
 
 function historyAct(record, effects = null) {
-	const tx = record.transaction;
-	return {id: tx.id, actor: {...tx.actor}, createdAt: tx.createdAt, baseRevision: tx.baseRevision, revision: tx.revision,
-		operation: tx.operation || 'document.change',
+	const tx = record.transaction, copy = value => value && typeof value === 'object' ? plainData(value) : value;
+	return {id: tx.id, actor: Object.fromEntries(Object.entries(tx.actor).map(([key, value]) => [key, copy(value)])), createdAt: tx.createdAt, baseRevision: tx.baseRevision, revision: tx.revision,
+		operation: copy(tx.operation) || 'document.change',
 		...(tx.turnId ? {turnId: tx.turnId} : {}),
-		...(tx.contribution ? {contribution: tx.contribution} : {}),
+		...(tx.contribution ? {contribution: copy(tx.contribution)} : {}),
 		...(tx.sourceTransactionId ? {sourceTransactionId: tx.sourceTransactionId} : {}),
 		...(tx.sourceTransactionIds?.length ? {sourceTransactionIds: tx.sourceTransactionIds.slice()} : {}),
 		...(tx.reverts ? {reverts: tx.reverts} : {}), ...(tx.reapplies ? {reapplies: tx.reapplies} : {}),
-		...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {label: record.changeSet.label} : {}),
-		...(Array.isArray(tx.affectedBlockIds) ? {affectedBlockIds: tx.affectedBlockIds.slice()} : {}),
+		...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {label: copy(record.changeSet.label)} : {}),
+		...(Array.isArray(tx.affectedBlockIds) ? {affectedBlockIds: tx.affectedBlockIds.map(copy)} : {}),
 		...(record.metadata ? {metadata: plainData(record.metadata)} : {}),
 		...(effects ? {active: effects.active.has(tx.id)} : {})};
 }
@@ -74,76 +74,75 @@ export function pictureHistorySplices({source, records}, target, redo) {
 	try { return plan(true); } catch (_) { return null; }
 }
 
-// Reading an admitted repair can recover pre-existing lone UTF-16 units. This is
-// not a document mutation; the forward replay and roots still validate every row.
-function historyPreviousSource(source, splices) {
-	let value = source;
-	for (let index = splices.length - 1; index >= 0; index--) {
-		const row = splices[index];
-		if (!row || !historyInteger(row.pos) || typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
-			row.pos > value.length || row.inserted.length > value.length - row.pos ||
-			value.slice(row.pos, row.pos + row.inserted.length) !== row.inserted) return null;
-		value = value.slice(0, row.pos) + row.removed + value.slice(row.pos + row.inserted.length);
-	}
-	return value;
-}
-
-// This is a projection of the existing records. No source snapshots or provenance survive the call.
+// Keep only the latest source observation. Inactive live documents must not retain
+// every revision's source tree. The weak key also lets the latest input be collected.
+// Mutable caller data is compared/captured before this cache can be consulted.
+let preparedHistories = new WeakMap();
 function prepareHistory(input) {
 	try {
 		if (!input || typeof input.source !== 'string' || !Array.isArray(input.records) || !_rapierValidMetadata(input.metadata)) return historyFailure('history_invalid');
-		const source = input.source, records = plainData(input.records), ids = new Set(), rows = [];
-		const effects = _rapierHistoryEffects(records);
-		if (!effects.ok) return historyFailure('history_invalid');
+		const source = input.source, metadata = {...input.metadata}, index = _rapierPrepareHistoryRecords(input.records);
+		if (!index.ok) return historyFailure('history_invalid');
+		const {records, effects} = index;
 		const revision = input.revision ?? records.at(-1)?.transaction?.revision ?? 0;
-		if (!historyInteger(revision)) return historyFailure('history_invalid');
-		let prior = input.earliestRevision ?? records[0]?.transaction?.baseRevision ?? revision, complete = prior === 0;
-		if (!historyInteger(prior)) return historyFailure('history_invalid');
-		for (const record of records) {
-			const tx = record?.transaction, actor = tx?.actor;
-			if (!tx || typeof tx.id !== 'string' || !tx.id || ids.has(tx.id) || !historyInteger(tx.baseRevision) ||
+		let prior = input.earliestRevision ?? records[0]?.transaction?.baseRevision ?? revision;
+		if (!historyInteger(revision) || !historyInteger(prior)) return historyFailure('history_invalid');
+		const earliest = prior, suppliedComplete = input.complete !== false, cached = preparedHistories.get(records);
+		if (cached && cached.source === source && cached.revision === revision && cached.earliest === earliest &&
+			cached.suppliedComplete === suppliedComplete && cached.metadata.filename === metadata.filename && cached.metadata.docKind === metadata.docKind) return cached;
+		let complete = prior === 0;
+		const rows = [], byId = new Map();
+		for (const owned of index.rows) {
+			const {record, splices, metadata: effect} = owned, tx = record?.transaction, actor = tx?.actor;
+			if (!tx || typeof tx.id !== 'string' || !tx.id || byId.has(tx.id) || !historyInteger(tx.baseRevision) ||
 				!historyInteger(tx.revision) || tx.revision !== tx.baseRevision + 1 || tx.baseRevision < prior ||
 				!actor || !['human', 'agent', 'system'].includes(actor.kind) || typeof actor.id !== 'string' || !actor.id ||
 				!(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 splices = _rapierRecordSplices(record, records), metadata = _rapierRecordMetadata(record, records);
-			if (!splices || metadata === undefined || (!splices.length &&
-				!Object.values(metadata || {}).some(pair => pair.before !== pair.after) && !effects.references.get(tx.id)?.length)) return historyFailure('history_unavailable');
-			rows.push({record, splices, metadata}); ids.add(tx.id); prior = tx.revision;
+			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');
+			const row = {record, splices, metadata: effect};
+			rows.push(row); byId.set(tx.id, row); prior = tx.revision;
 		}
 		if (prior !== revision) return historyFailure('history_unavailable');
-		let initialSource = source, initialMetadata = {...input.metadata};
-		for (let index = rows.length - 1; index >= 0; index--) {
-			initialSource = historyPreviousSource(initialSource, rows[index].splices);
-			initialMetadata = _rapierTransformMetadata(initialMetadata, rows[index].metadata, true);
-			if (initialSource === null || !initialMetadata) return historyFailure('history_invalid');
+		let initial = new HistorySource(source), initialMetadata = {...metadata};
+		for (let at = rows.length - 1; at >= 0; at--) {
+			const row = rows[at];
+			row.afterSource = initial; row.afterMetadata = initialMetadata;
+			initial = initial.before(row.splices);
+			initialMetadata = _rapierTransformMetadata(initialMetadata, row.metadata, true);
+			if (!initial || !initialMetadata) return historyFailure('history_invalid');
+			row.beforeSource = initial; row.beforeMetadata = initialMetadata;
 		}
-		const earliestRevision = rows[0]?.record.transaction.baseRevision ?? revision;
-		let replay = initialSource, root = earliestRevision === 0 ? textRoot(initialSource) : null, rootRevision = earliestRevision;
+		const earliestRevision = records[0]?.transaction.baseRevision ?? revision;
+		let root = earliestRevision === 0 ? textRootParts(initial.parts()) : null, rootRevision = earliestRevision;
 		for (const {record, splices} of rows) {
 			const hashed = Object.hasOwn(record, 'beforeHash') || Object.hasOwn(record, 'afterHash');
 			if (hashed && (![record.beforeHash, record.afterHash].every(value =>
 				typeof value === 'string' && /^\d+:[a-z0-9]+:[a-z0-9]+$/.test(value)) ||
-				(splices.length ? record.beforeHash === record.afterHash : record.beforeHash !== record.afterHash)))
-				return historyFailure('history_invalid');
-			// Roots bind revision zero to the full source. A retained suffix has only a path root;
-			// omitted neutral pairs change that root, so a stated revision gap begins a new chain.
+				(splices.length ? record.beforeHash === record.afterHash : record.beforeHash !== record.afterHash))) return historyFailure('history_invalid');
+			// Revision gaps begin a new path root; a continuous revision-zero prefix
+			// still binds every untouched source byte through the initial text root.
 			if (record.transaction.baseRevision !== rootRevision) root = null;
 			if (hashed) {
 				if (root !== null && record.beforeHash !== root) return historyFailure('history_invalid');
 				root = record.beforeHash;
 			}
-			replay = _rapierTransformSplices(replay, splices);
-			if (replay === null) return historyFailure('history_invalid');
-			if (root !== null) for (const row of splices) root = rootAfter(root, row);
+			if (root !== null) for (const splice of splices) root = rootAfter(root, splice);
 			if (hashed && root !== record.afterHash) return historyFailure('history_invalid');
 			rootRevision = record.transaction.revision;
 		}
-		if (records.some(row => Object.hasOwn(row, 'authored'))) authoredHistory(initialSource, rows.map(({record, splices}) => ({...record, splices})));
-		const metadata = _rapierReplayMetadata(initialMetadata, records);
-		if (replay !== source || !metadata || ['filename', 'docKind'].some(key => metadata[key] !== input.metadata[key])) return historyFailure('history_invalid');
-		return {ok: true, source, initialSource, metadata, initialMetadata, effects, rows, revision, earliestRevision, complete: input.complete !== false && complete && earliestRevision === 0};
+		let initialText;
+		const initialSource = () => initialText ??= initial.slice();
+		if (records.some(row => Object.hasOwn(row, 'authored'))) authoredHistory(initialSource(), rows.map(({record, splices}) => ({...record, splices})));
+		const replayedMetadata = index.replayMetadata(initialMetadata);
+		if (!replayedMetadata || ['filename', 'docKind'].some(key => replayedMetadata[key] !== metadata[key])) return historyFailure('history_invalid');
+		const resolvedRecords = Object.freeze(rows.map(({record, splices}) => record.splices === splices ? record : Object.freeze({...record, splices}))); 
+		const prepared = {ok: true, source, records: resolvedRecords, get initialSource() { return initialSource(); }, initial, metadata, initialMetadata, effects, rows, byId,
+			revision, earliest, suppliedComplete, earliestRevision, complete: suppliedComplete && complete && earliestRevision === 0};
+		preparedHistories = new WeakMap([[records, prepared]]);
+		return prepared;
 	} catch (_) { return historyFailure('history_invalid'); }
 }
 
@@ -152,23 +151,17 @@ export function replayHistory(input) {
 	if (!prepared.ok) return prepared;
 	const {source, initialSource, metadata, initialMetadata, revision, earliestRevision, complete, rows, effects} = prepared;
 	const acts = rows.filter(({record}) => !effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record, effects));
-	return {ok: true, source, initialSource, metadata, initialMetadata, revision, earliestRevision, complete, acts,
+	return {ok: true, source, initialSource, metadata: {...metadata}, initialMetadata: {...initialMetadata}, revision, earliestRevision, complete, acts,
 		effectiveActIds: effects.effectiveActIds.slice(), groups: groupHistoryActs(acts)};
 }
 
 export function sourceBefore(input, actId) {
 	const prepared = prepareHistory(input);
 	if (!prepared.ok) return prepared;
-	let source = prepared.source, metadata = {...prepared.metadata};
-	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index];
-		source = historyPreviousSource(source, splices);
-		if (source === null) return historyFailure('history_invalid');
-		metadata = _rapierTransformMetadata(metadata, prepared.rows[index].metadata, true);
-		if (record.transaction.id === actId) return {ok: true, source, metadata, revision: record.transaction.baseRevision,
-			act: historyAct(record, prepared.effects), complete: prepared.complete, earliestRevision: prepared.earliestRevision};
-	}
-	return historyFailure('act_unavailable');
+	const row = prepared.byId.get(actId);
+	if (!row) return historyFailure('act_unavailable');
+	return {ok: true, source: row.beforeSource.slice(), metadata: {...row.beforeMetadata}, revision: row.record.transaction.baseRevision,
+		act: historyAct(row.record, prepared.effects), complete: prepared.complete, earliestRevision: prepared.earliestRevision};
 }
 
 function historyRangeBefore(range, splice) {
@@ -186,21 +179,23 @@ function historyRangeBefore(range, splice) {
 
 function projectHistoryRange(prepared, from, to, actId) {
 	if (!historyBoundary(prepared.source, from) || !historyBoundary(prepared.source, to) || to < from) return historyFailure('range_invalid');
-	let text = prepared.source, range = {from, to}, before = null;
+	let range = {from, to}, before = null;
 	const acts = [];
 	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index], after = {...range, source: text.slice(range.from, range.to)};
+		const {record, splices, beforeSource, afterSource} = prepared.rows[index], afterRange = range;
 		let touched = false;
 		for (let at = splices.length - 1; at >= 0; at--) {
 			const mapped = historyRangeBefore(range, splices[at]); touched ||= mapped.touched;
 			range = {from: mapped.from, to: mapped.to};
 		}
-		text = historyPreviousSource(text, splices);
-		if (text === null) return historyFailure('history_invalid');
-		const previous = {...range, source: text.slice(range.from, range.to)};
-		if (record.transaction.id === actId) before = previous;
-		if (!prepared.effects.pictures.has(record.transaction.id) && (touched || record.metadata || prepared.effects.references.get(record.transaction.id)?.length))
-			acts.push({...historyAct(record, prepared.effects), before: previous, after});
+		const include = !prepared.effects.pictures.has(record.transaction.id) &&
+			(touched || record.metadata || prepared.effects.references.get(record.transaction.id)?.length);
+		if (include || record.transaction.id === actId) {
+			const previous = {...range, source: beforeSource.slice(range.from, range.to)};
+			if (record.transaction.id === actId) before = previous;
+			if (include) acts.push({...historyAct(record, prepared.effects), before: previous,
+				after: {...afterRange, source: afterSource.slice(afterRange.from, afterRange.to)}});
+		}
 	}
 	if (actId != null && !before) return historyFailure('act_unavailable');
 	acts.reverse();
@@ -220,10 +215,47 @@ export function historyProjections(input, ranges) {
 	if (!prepared.ok) return prepared;
 	if (!Array.isArray(ranges)) return historyFailure('range_invalid');
 	return {ok: true, projections: ranges.map(({from = 0, to = prepared.source.length, actId} = {}) =>
-		structuredClone(projectHistoryRange(prepared, from, to, actId)))};
+		projectHistoryRange(prepared, from, to, actId))};
+}
+
+// Block intervals stay ordered under reverse splices. A fixed balanced tree can
+// shift an untouched suffix lazily and visit only intervals crossing the edit.
+function historyBlockIndex(projected) {
+	const items = projected.map(block => ({block, range: {from: block.from, to: block.to}, shift: 0}))
+		.sort((a, b) => a.range.from - b.range.from);
+	const refresh = node => {
+		node.minFrom = node.left?.minFrom ?? node.range.from;
+		node.maxTo = Math.max(node.range.to, node.left?.maxTo ?? -1, node.right?.maxTo ?? -1);
+	};
+	const build = (from, to, parent = null) => {
+		if (from === to) return null;
+		const mid = Math.floor((from + to) / 2), node = items[mid];
+		node.parent = parent; node.left = build(from, mid, node); node.right = build(mid + 1, to, node);
+		refresh(node); return node;
+	};
+	const root = build(0, items.length);
+	const shift = (node, delta) => {
+		if (!node || !delta) return;
+		node.range = {from: node.range.from + delta, to: node.range.to + delta};
+		node.minFrom += delta; node.maxTo += delta; node.shift += delta;
+	};
+	const move = (node, splice, touch) => {
+		if (!node || node.maxTo < splice.pos) return;
+		const end = splice.pos + splice.inserted.length;
+		if (node.minFrom > end) { shift(node, splice.removed.length - splice.inserted.length); return; }
+		if (node.shift) { shift(node.left, node.shift); shift(node.right, node.shift); node.shift = 0; }
+		const mapped = historyRangeBefore(node.range, splice);
+		if (mapped.touched) touch(node);
+		node.range = {from: mapped.from, to: mapped.to};
+		move(node.left, splice, touch); move(node.right, splice, touch); refresh(node);
+	};
+	return {move: (splice, touch) => move(root, splice, touch), range(node) {
+		let delta = 0;
+		for (let parent = node.parent; parent; parent = parent.parent) delta += parent.shift;
+		return {from: node.range.from + delta, to: node.range.to + delta};
+	}};
 }
 
-// Project all reading places in one replay. Typing only invalidates this transient view.
 export function historyPlaces(input, blocks) {
 	const prepared = prepareHistory(input);
 	if (!prepared.ok) return prepared;
@@ -231,47 +263,43 @@ export function historyPlaces(input, blocks) {
 		!historyBoundary(prepared.source, block.from) || !historyBoundary(prepared.source, block.to) || block.to < block.from))
 		return historyFailure('range_invalid');
 	const projected = blocks.map(block => ({id: block.id, from: block.from, to: block.to,
-		source: prepared.source.slice(block.from, block.to), range: {from: block.from, to: block.to}, acts: []}));
-	let text = prepared.source;
+		source: prepared.source.slice(block.from, block.to), acts: []}));
+	const ranges = historyBlockIndex(projected);
 	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index], before = historyPreviousSource(text, splices);
-		if (before === null) return historyFailure('history_invalid');
-		for (const block of projected) {
-			const after = {...block.range, source: text.slice(block.range.from, block.range.to)};
-			let touched = false;
-			for (let at = splices.length - 1; at >= 0; at--) {
-				const mapped = historyRangeBefore(block.range, splices[at]);
-				block.range = {from: mapped.from, to: mapped.to}; touched ||= mapped.touched;
-			}
-			const previous = {...block.range, source: before.slice(block.range.from, block.range.to)};
-			if (touched && previous.source !== after.source && !prepared.effects.pictures.has(record.transaction.id)) block.acts.push({...historyAct(record), before: previous, after});
-		}
-		text = before;
-	}
-	const acts = prepared.rows.filter(({record}) => !prepared.effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record));
-	const present = new Map(), effects = new Map();
-	for (const act of acts) {
-		const changes = [];
-		const set = (id, value) => {
-			const prior = present.get(id) === true;
-			present.set(id, value); changes.push({id, before: prior, after: value});
-		};
-		if (act.reapplies) {
-			for (const change of effects.get(act.reapplies) || [{id: act.reapplies, after: true}]) set(change.id, change.after);
-		} else {
-			const ids = act.sourceTransactionIds || (act.sourceTransactionId ? [act.sourceTransactionId] : act.reverts ? [act.reverts] : []);
-			for (const id of ids) {
-				for (const change of (effects.get(id) || [{id, before: false, after: true}]).slice().reverse()) {
-					if (present.get(change.id) === change.after) set(change.id, change.before);
+		const {record, splices, beforeSource, afterSource} = prepared.rows[index], touched = new Map();
+		for (let at = splices.length - 1; at >= 0; at--) ranges.move(splices[at], node => {
+			if (touched.has(node) || prepared.effects.pictures.has(record.transaction.id)) return;
+			// Earlier splices in this reverse walk only shifted this interval. Recover
+			// its coordinates at the record's after-state before recording the first touch.
+			let after = {...node.range};
+			for (let prior = at + 1; prior < splices.length; prior++) {
+				const row = splices[prior];
+				if (after.from >= row.pos + row.removed.length) {
+					const delta = row.inserted.length - row.removed.length;
+					after = {from: after.from + delta, to: after.to + delta};
 				}
 			}
+			touched.set(node, after);
+		});
+		for (const [node, afterRange] of touched) {
+			const beforeRange = ranges.range(node), previous = {...beforeRange, source: beforeSource.slice(beforeRange.from, beforeRange.to)},
+				after = {...afterRange, source: afterSource.slice(afterRange.from, afterRange.to)};
+			if (previous.source !== after.source) node.block.acts.push({...historyAct(record), before: previous, after});
 		}
-		set(act.id, true); effects.set(act.id, changes);
 	}
-	for (const block of projected) { block.acts.reverse(); delete block.range; }
+
+	const acts = prepared.rows.filter(({record}) => !prepared.effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record));
+	// Native Redo consumes its Undo as navigation while keeping that receipt in
+	// the reading history. All material withdrawals use the canonical blockers,
+	// including independent inverses holding the same original act suppressed.
+	const reversed = new Set();
+	for (const {record} of prepared.rows) if (prepared.effects.active.has(record.transaction.id) && !record.transaction.reapplies)
+		for (const id of prepared.effects.references.get(record.transaction.id) || []) reversed.add(id);
+
+	for (const block of projected) block.acts.reverse();
 	return {ok: true, source: prepared.source, initialSource: prepared.initialSource, revision: prepared.revision,
 		earliestRevision: prepared.earliestRevision, complete: prepared.complete, acts, blocks: projected,
-		reversed: acts.filter(act => present.get(act.id) !== true).map(act => act.id)};
+		reversed: acts.filter(act => reversed.has(act.id)).map(act => act.id)};
 }
 
 // Runs retain only exact replacement ancestry. A later replacement owns an ambiguous hunk whole.
@@ -282,26 +310,26 @@ export function selectiveUndo(input, actIds, options = {}) {
 	if (!options || typeof options !== 'object' || Array.isArray(options) ||
 		(options.keepHunk !== undefined && typeof options.keepHunk !== 'function') ||
 		(options.splitSplice !== undefined && typeof options.splitSplice !== 'function')) return historyFailure('act_invalid');
-	const requested = new Set(actIds), available = new Set(prepared.rows.map(({record}) => record.transaction.id));
+	const requested = new Set(actIds), available = prepared.byId;
 	if ([...requested].some(id => !available.has(id))) return historyFailure('act_unavailable');
 	const selected = new Set([...requested].filter(id => prepared.effects.active.has(id)));
-	const records = prepared.rows.map(({record, splices}) => ({...record, splices}));
+	const records = prepared.records;
 	let inverseId = 'planned-inverse'; while (available.has(inverseId)) inverseId += ':';
 	const inverse = {splices: [], transaction: {id: inverseId, sourceTransactionIds: [...selected]}};
 	const projectedEffects = selected.size ? _rapierHistoryEffects([...records, inverse]) : prepared.effects;
 	const afterMetadata = _rapierMetadataState(prepared.initialMetadata, records, projectedEffects);
 	if (!afterMetadata) return historyFailure('history_invalid');
 	const metadata = _rapierMetadataDelta(prepared.metadata, afterMetadata), effectChanged = selected.size > 0;
-	const authoredEffectChanged = records.some(record => !prepared.effects.references.get(record.transaction.id)?.length &&
+	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 (!authoredEffectChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
+	if (!sourceEffectChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
 		sourceTransactionIds: [...selected], metadata, afterMetadata, effectChanged, unchanged: !metadata && !effectChanged,
 		superseded: [], overlaps: []};
 	try {
 		const transported = records.some(row => row.authored) ? authoredHistory(prepared.initialSource, records, selected) : null;
 		const rows = transported ? transported.records.map(record => ({record, splices: record.splices,
 			sourceIndices: transported.sourceIndices.get(record.transaction.id)})) : prepared.rows;
-		const result = projectInverseSource({...prepared, rows}, selected, projectedEffects, options);
+		const result = projectInverseSource(transported ? {...prepared, rows, records: transported.records} : prepared, selected, projectedEffects, options);
 		if (!result.ok) return result;
 		return {...result, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
 			effectChanged, unchanged: result.after === prepared.source && !metadata && !effectChanged};