rapier-markdown-kit 1.1.99 → 1.1.101

package/dist/kit/ledger/hash.mjs

@@ -21,33 +21,27 @@ const K = new Uint32Array([
   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
 ]);
-// The rounds run on plain 32-bit locals: no array is made per block, so a megabyte (a painting's text) hashes about five times
-// faster than through destructured arrays, with the same digest.
-const W = new Int32Array(64);
+const rotate = (x, n) => (x >>> n) | (x << (32 - n));
 export function sha256(text) {
-  const bytes = new TextEncoder().encode(text), length = bytes.length;
-  const padded = new Uint8Array(Math.ceil((length + 9) / 64) * 64), end = padded.length;
-  padded.set(bytes); padded[length] = 0x80;
-  const high = Math.floor(length * 8 / 0x100000000), low = (length * 8) >>> 0;
-  padded[end - 8] = high >>> 24; padded[end - 7] = high >>> 16; padded[end - 6] = high >>> 8; padded[end - 5] = high;
-  padded[end - 4] = low >>> 24; padded[end - 3] = low >>> 16; padded[end - 2] = low >>> 8; padded[end - 1] = low;
-  let h0 = 0x6a09e667 | 0, h1 = 0xbb67ae85 | 0, h2 = 0x3c6ef372 | 0, h3 = 0xa54ff53a | 0, h4 = 0x510e527f | 0, h5 = 0x9b05688c | 0, h6 = 0x1f83d9ab | 0, h7 = 0x5be0cd19 | 0;
-  const w = W;
-  for (let offset = 0; offset < end; offset += 64) {
-    for (let i = 0, j = offset; i < 16; i++, j += 4) w[i] = padded[j] << 24 | padded[j + 1] << 16 | padded[j + 2] << 8 | padded[j + 3];
+  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);
     for (let i = 16; i < 64; i++) {
       const x = w[i - 15], y = w[i - 2];
-      w[i] = (w[i - 16] + ((x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3) + w[i - 7] + ((y >>> 17 | y << 15) ^ (y >>> 19 | y << 13) ^ y >>> 10)) | 0;
+      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 = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, k = h7;
+    let [a,b,c,d,e,f,g,k] = h;
     for (let i = 0; i < 64; i++) {
-      const t1 = (k + ((e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7)) + (e & f ^ ~e & g) + K[i] + w[i]) | 0;
-      const t2 = (((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (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;
+      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;
     }
-    h0 = (h0 + a) | 0; h1 = (h1 + b) | 0; h2 = (h2 + c) | 0; h3 = (h3 + d) | 0; h4 = (h4 + e) | 0; h5 = (h5 + f) | 0; h6 = (h6 + g) | 0; h7 = (h7 + k) | 0;
+    for (const [i, value] of [a,b,c,d,e,f,g,k].entries()) h[i] += value;
   }
-  let out = '';
-  for (const x of [h0, h1, h2, h3, h4, h5, h6, h7]) out += (x >>> 0).toString(16).padStart(8, '0');
-  return out;
+  return [...h].map(x => x.toString(16).padStart(8, '0')).join('');
 }

package/dist/kit/ledger/history.mjs

@@ -1,7 +1,7 @@
 // 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 {diffChars, diffLines} from '../../agent/diff.mjs';
+import {projectInverseSource} from './inverse-source.mjs';
 import {textRoot, rootAfter} from './hash.mjs';
 import {authoredHistory} from './transport.mjs';
 import {plainData} from './data.mjs';
@@ -41,6 +41,39 @@ export function groupHistoryActs(acts) {
 	return groups;
 }
 
+// A picture's codec replacement travels with its original navigation step.
+// Match every complete replacement exactly before moving any source bytes.
+export function pictureHistorySplices({source, records}, target, redo) {
+	const id = target?.transaction?.id, at = records.indexOf(target);
+	if (!id || at < 0 || target.transaction.operation === 'document.finish-picture' || !Array.isArray(target.splices)) return null;
+	const later = records.slice(at + 1).filter(row => row?.transaction?.operation === 'document.finish-picture' && Array.isArray(row.splices) && row.splices.length);
+	if (!later.length) return null;
+	const own = new Set(later.filter(row => row.transaction.sourceTransactionId === id));
+	const step = redo ? target.splices : target.splices.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
+	const plan = moveOthers => {
+		let text = source;
+		const rows = [], moved = new Set();
+		const only = needle => { const found = text.indexOf(needle); return found >= 0 && text.indexOf(needle, found + 1) < 0 ? found : -1; };
+		const apply = row => { const next = _rapierTransformSplices(text, [row]); if (next === null) throw Error('picture_target'); text = next; rows.push(row); };
+		const swap = (record, back) => {
+			const found = record.splices.map(splice => { const from = back ? splice.inserted : splice.removed; return from ? only(from) : -1; });
+			if (found.every(position => position < 0)) return false;
+			if (found.some(position => position < 0)) throw Error('partial_picture');
+			for (const splice of record.splices) {
+				const from = back ? splice.inserted : splice.removed, to = back ? splice.removed : splice.inserted;
+				apply({pos: only(from), removed: from, inserted: to});
+			}
+			return true;
+		};
+		for (const record of later.slice().reverse()) if ((moveOthers || own.has(record)) && swap(record, true)) moved.add(record);
+		for (const splice of step) apply(splice);
+		for (const record of later) if (own.has(record) ? redo : moved.has(record)) swap(record, false);
+		return rows;
+	};
+	try { const rows = plan(false); return !own.size && rows.length === step.length ? null : rows; } catch (_) {}
+	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) {
@@ -118,7 +151,7 @@ export function replayHistory(input) {
 	const prepared = prepareHistory(input);
 	if (!prepared.ok) return prepared;
 	const {source, initialSource, metadata, initialMetadata, revision, earliestRevision, complete, rows, effects} = prepared;
-	const acts = rows.map(({record}) => historyAct(record, effects));
+	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,
 		effectiveActIds: effects.effectiveActIds.slice(), groups: groupHistoryActs(acts)};
 }
@@ -151,9 +184,7 @@ function historyRangeBefore(range, splice) {
 		touched: true};
 }
 
-export function historyProjection(input, {from = 0, to = input?.source?.length, actId} = {}) {
-	const prepared = prepareHistory(input);
-	if (!prepared.ok) return prepared;
+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;
 	const acts = [];
@@ -168,7 +199,7 @@ export function historyProjection(input, {from = 0, to = input?.source?.length,
 		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 (touched || record.metadata || prepared.effects.references.get(record.transaction.id)?.length)
+		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});
 	}
 	if (actId != null && !before) return historyFailure('act_unavailable');
@@ -177,6 +208,21 @@ export function historyProjection(input, {from = 0, to = input?.source?.length,
 		earliestRevision: prepared.earliestRevision, complete: prepared.complete, acts, groups: groupHistoryActs(acts), ...(before ? {before} : {})};
 }
 
+export function historyProjection(input, {from = 0, to = input?.source?.length, actId} = {}) {
+	const prepared = prepareHistory(input);
+	if (!prepared.ok) return prepared;
+	return projectHistoryRange(prepared, from, to, actId);
+}
+
+// Several ranges share one proved source snapshot for this call.
+export function historyProjections(input, ranges) {
+	const prepared = prepareHistory(input);
+	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)))};
+}
+
 // Project all reading places in one replay. Typing only invalidates this transient view.
 export function historyPlaces(input, blocks) {
 	const prepared = prepareHistory(input);
@@ -198,11 +244,11 @@ export function historyPlaces(input, blocks) {
 				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) block.acts.push({...historyAct(record), before: previous, after});
+			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.map(({record}) => historyAct(record));
+	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 = [];
@@ -228,37 +274,6 @@ export function historyPlaces(input, blocks) {
 		reversed: acts.filter(act => present.get(act.id) !== true).map(act => act.id)};
 }
 
-function minimalHistorySplice(before, after, pos = 0) {
-	let first = 0, a = before.length, b = after.length;
-	while (first < a && first < b && before[first] === after[first]) first++;
-	if (!historyBoundary(before, first) || !historyBoundary(after, first)) first--;
-	while (a > first && b > first && before[a - 1] === after[b - 1]) { a--; b--; }
-	if (!historyBoundary(before, a) || !historyBoundary(after, b)) { a++; b++; }
-	return {pos: pos + first, removed: before.slice(first, a), inserted: after.slice(first, b)};
-}
-
-// Split only at byte-identical runs inside the recorded replacement, never by proportional character positions.
-function historyHunks(row) {
-	if (row.removed === row.inserted) return [];
-	if (!row.removed || !row.inserted) return [{...row}];
-	const size = row.removed.length + row.inserted.length;
-	const parts = size <= 16384 ? diffChars(row.removed, row.inserted, {maxEditLength: 256})
-		: size <= 1024 * 1024 ? diffLines(row.removed, row.inserted, {maxEditLength: 128}) : null;
-	if (!parts) return [minimalHistorySplice(row.removed, row.inserted, row.pos)];
-	const hunks = [];
-	let offset = 0, start = 0, removed = '', inserted = '';
-	const flush = () => { if (removed || inserted) hunks.push({pos: row.pos + start, removed, inserted}); removed = ''; inserted = ''; };
-	for (const part of parts) {
-		if (part.added || part.removed) {
-			if (!removed && !inserted) start = offset;
-			if (part.added) inserted += part.value;
-			else { removed += part.value; offset += part.value.length; }
-		} else { flush(); offset += part.value.length; }
-	}
-	flush();
-	return hunks.length <= 64 ? hunks.reverse() : [minimalHistorySplice(row.removed, row.inserted, row.pos)];
-}
-
 // Runs retain only exact replacement ancestry. A later replacement owns an ambiguous hunk whole.
 export function selectiveUndo(input, actIds, options = {}) {
 	const prepared = prepareHistory(input);
@@ -283,244 +298,12 @@ export function selectiveUndo(input, actIds, options = {}) {
 		sourceTransactionIds: [...selected], metadata, afterMetadata, effectChanged, unchanged: !metadata && !effectChanged,
 		superseded: [], overlaps: []};
 	try {
-		let pieces = prepared.initialSource ? [{text: prepared.initialSource, owner: null, lineage: []}] : [];
-		const all = [], byId = new Map(), byAct = new Map(), processed = [], keptInverseAncestors = new Set();
-		const textOf = rows => rows.map(row => row.text || '').join('');
-		const boundary = pos => {
-			let offset = 0;
-			for (let index = 0; index < pieces.length; index++) {
-				const row = pieces[index];
-				if (!row.text) continue;
-				const end = offset + row.text.length;
-				if (pos > offset && pos < end) {
-					const at = pos - offset;
-					pieces.splice(index, 1, {...row, text: row.text.slice(0, at)}, {...row, text: row.text.slice(at)});
-				break;
-				}
-				offset = end;
-			}
-			offset = 0;
-			let first = pieces.length, last = pieces.length;
-			for (let index = 0; index < pieces.length; index++) {
-				if (offset === pos) { first = index; last = index; while (last < pieces.length && !pieces[last].text) last++; return {first, last}; }
-				offset += pieces[index].text?.length || 0;
-			}
-			if (offset !== pos) throw Error('range');
-			return {first, last};
-		};
-		const owns = (piece, hunk) => piece === hunk.marker || piece.owner === hunk.id ||
-			piece.restoredBy?.includes(hunk.id) || hunk.restoredMarkers?.has(piece);
-		const effectiveBefore = (hunk, effects, visiting = new Set()) => {
-			if (visiting.has(hunk.id)) return null;
-			visiting.add(hunk.id); let text = '';
-			for (const piece of hunk.before) {
-				if (!piece.text) continue;
-				const owner = byId.get(piece.owner);
-				if (owner && !effects.active.has(owner.actId) && !owner.kept) {
-					if (piece.text !== owner.inserted) return null;
-					const prior = effectiveBefore(owner, effects, new Set(visiting));
-					if (prior === null) return null;
-					text += prior;
-				} else text += piece.text;
-			}
-			return text;
-		};
-		const reactivate = (actIds, effects) => {
-			for (const hunk of all) {
-				if (!actIds.has(hunk.actId) || hunk.derived || prepared.effects.references.get(hunk.actId)?.length) continue;
-				if (keptInverseAncestors.has(hunk.id)) continue;
-				const later = [...hunk.supersededBy].some(id => {
-					const next = byId.get(id);
-					return next && effects.active.has(next.actId) && !prepared.effects.references.get(next.actId)?.length;
-				});
-				if (later || pieces.some(piece => piece.text && piece.owner === hunk.id) || (!hunk.inserted && hunk.active)) continue;
-				const marker = pieces.indexOf(hunk.marker);
-				if (marker < 0) throw Error('reactivation');
-				const pos = textOf(pieces.slice(0, marker)).length, current = textOf(pieces);
-				const removed = effectiveBefore(hunk, effects);
-				if (removed === null || current.slice(pos, pos + removed.length) !== removed) throw Error('reactivation');
-				boundary(pos + removed.length);
-				const start = boundary(pos), end = boundary(pos + removed.length);
-				const at = start.last, count = Math.max(0, end.first - at);
-				if (textOf(pieces.slice(at, at + count)) !== removed) throw Error('reactivation');
-				const replacedOwners = new Set(pieces.slice(at, at + count).map(piece => piece.owner).filter(Boolean));
-				pieces.splice(at, count, ...(hunk.inserted ? [{text: hunk.inserted, owner: hunk.id, lineage: hunk.lineage.slice()}] : []));
-				for (const owner of replacedOwners) if (owner !== hunk.id && !pieces.some(piece => piece.text && piece.owner === owner)) {
-					const prior = byId.get(owner); if (prior) prior.active = false;
-				}
-				hunk.active = true; delete hunk.undoneBy;
-			}
-		};
 		const transported = records.some(row => row.authored) ? authoredHistory(prepared.initialSource, records, selected) : null;
-		const projectedRows = transported ? transported.records.map(record => ({record, splices: record.splices,
+		const rows = transported ? transported.records.map(record => ({record, splices: record.splices,
 			sourceIndices: transported.sourceIndices.get(record.transaction.id)})) : prepared.rows;
-		for (const {record, splices, sourceIndices} of projectedRows) {
-			const tx = record.transaction, references = new Set(prepared.effects.references.get(tx.id) || []);
-			const actSource = options.keepHunk && selected.has(tx.id) ? textOf(pieces) : null;
-			processed.push(record);
-			if (references.size) {
-				// Exact inverse rows restore the previous run identities. Retain the inverse's
-				// own transient marker too, so reversing it restores that same ancestry again.
-				const targets = all.filter(hunk => hunk.active && references.has(hunk.actId));
-				let restored = targets.length ? pieces.slice() : null;
-				const inverses = [], priorSplices = options.keepHunk ? [] : null;
-				for (let index = targets.length - 1; restored && index >= 0; index--) {
-					const target = targets[index], first = restored.indexOf(target.marker);
-					if (first < 0) { restored = null; break; }
-					let last = first;
-					for (let at = first; at < restored.length; at++) if (owns(restored[at], target)) last = at;
-					const pos = textOf(restored.slice(0, first)).length;
-					const before = restored.slice(first, last + 1), replacement = [];
-					for (const piece of before) {
-						if (piece === target.marker) replacement.push(...target.before);
-						else if (!owns(piece, target)) replacement.push(piece);
-					}
-					const id = tx.id + '#inverse:' + index, lineage = new Set([id]);
-					for (const piece of before) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
-					const hunk = {id, actId: tx.id, removed: textOf(before), inserted: textOf(replacement), before, reversedHunk: target.id,
-						chosen: selected.has(tx.id), lineage: [...lineage], supersededBy: new Set(), active: true,
-						restoredMarkers: new Set(replacement.filter(piece => !piece.text))};
-					if (hunk.chosen && options.keepHunk) {
-						const spliceIndex = splices.findIndex(row => row.pos <= pos && row.pos + row.removed.length >= pos);
-						const keep = options.keepHunk({actId: tx.id, spliceIndex: Math.max(0, spliceIndex), hunkIndex: index,
-							splice: {pos, removed: hunk.removed, inserted: hunk.inserted}, beforeSource: textOf(restored), actSource, priorSplices});
-						if (typeof keep !== 'boolean') throw Error('hunk_selection');
-						hunk.chosen = !keep;
-					}
-					hunk.kept = selected.has(tx.id) && !hunk.chosen;
-					// A semantic owner retaining this inverse also retains the exact ancestors
-					// it restored; effect reactivation must not change them behind that owner.
-					if (hunk.kept) for (let prior = target; prior; prior = byId.get(prior.reversedHunk)) keptInverseAncestors.add(prior.id);
-					hunk.marker = {mark: hunk};
-					const insertion = replacement.map(piece => piece.text ? {...piece,
-						lineage: [...new Set([...(piece.lineage || []), id])],
-						restoredBy: [...(piece.restoredBy || []), id]} : piece);
-					restored.splice(first, last + 1 - first, hunk.marker, ...insertion);
-					inverses.push(hunk); priorSplices?.push({pos, removed: hunk.removed, inserted: hunk.inserted});
-				}
-				if (restored && textOf(restored) === _rapierTransformSplices(textOf(pieces), splices)) {
-					pieces = restored;
-					for (const target of targets) { target.active = false; target.undoneBy = tx.id; }
-					for (const piece of pieces) if (piece.mark) {
-						piece.mark.active = true; delete piece.mark.undoneBy;
-					}
-					for (const hunk of inverses) { all.push(hunk); byId.set(hunk.id, hunk); }
-					byAct.set(tx.id, inverses);
-					continue;
-				}
-			}
-
-			if (references.size) {
-				const previous = _rapierHistoryEffects(processed.slice(0, -1)), current = _rapierHistoryEffects(processed);
-				const activated = new Set(current.effectiveActIds.filter(id => !previous.active.has(id) &&
-					id !== tx.id && !current.references.get(id)?.length));
-				if (activated.size) {
-					const before = pieces, priorStates = all.map(hunk => [hunk, hunk.active, hunk.undoneBy]); pieces = pieces.slice();
-					try {
-						reactivate(activated, current);
-						if (textOf(pieces) === _rapierTransformSplices(textOf(before), splices)) continue;
-					} catch (_) {}
-					pieces = before;
-					for (const [hunk, active, undoneBy] of priorStates) { hunk.active = active; hunk.undoneBy = undoneBy; }
-				}
-			}
-			const priorSplices = options.keepHunk ? [] : null;
-			for (let rowIndex = 0; rowIndex < splices.length; rowIndex++) {
-				const original = splices[rowIndex];
-				let rows;
-				if (options.splitSplice) {
-					const beforeSource = textOf(pieces), parts = options.splitSplice({actId: tx.id, beforeSource, splice: original});
-					// Semantic boundaries only refine this act's exact bytes, never its history.
-					if (!Array.isArray(parts) || _rapierTransformSplices(beforeSource, parts) !== _rapierTransformSplices(beforeSource, [original]))
-						throw Error('hunk_projection');
-					rows = parts.flatMap(historyHunks);
-				} else rows = historyHunks(original);
-				for (let index = 0; index < rows.length; index++) {
-					const row = rows[index];
-					const derived = (sourceIndices?.[rowIndex] ?? rowIndex) === record.derivedCommentIndex;
-					let chosen = selected.has(tx.id) && !derived;
-					boundary(row.pos + row.removed.length);
-					const start = boundary(row.pos), end = boundary(row.pos + row.removed.length);
-					let at = start.last, count = Math.max(0, end.first - at);
-					if (!row.removed.length) {
-						// A new insertion at a replacement's left boundary stays before that replacement.
-						const marker = pieces.slice(start.first, start.last).findIndex(item => item.mark?.inserted.length);
-						at = marker < 0 ? start.last : start.first + marker; count = 0;
-					}
-					const removed = pieces.slice(at, at + count);
-					if (textOf(removed) !== row.removed) throw Error('replay');
-					// A semantic owner may retain a drawing hunk while prose in that same act undoes.
-					// The predicate only selects transient hunks; every original row still replays.
-					if (chosen && options.keepHunk) {
-						const keep = options.keepHunk({actId: tx.id, spliceIndex: rowIndex, hunkIndex: index,
-							splice: {pos: row.pos, removed: row.removed, inserted: row.inserted}, beforeSource: textOf(pieces), actSource, priorSplices});
-						if (typeof keep !== 'boolean') throw Error('hunk_selection');
-						chosen = !keep;
-					}
-					const id = tx.id + '#' + rowIndex + ':' + index;
-					const lineage = new Set([id]);
-					for (const piece of removed) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
-					const hunk = {id, actId: tx.id, removed: row.removed, inserted: row.inserted, before: removed, derived,
-						chosen, kept: selected.has(tx.id) && !chosen, lineage: [...lineage], supersededBy: new Set(), active: true};
-					hunk.marker = {mark: hunk};
-					all.push(hunk); byId.set(id, hunk);
-					if (!byAct.has(tx.id)) byAct.set(tx.id, []);
-					byAct.get(tx.id).push(hunk);
-					for (const parent of lineage) {
-						const earlier = byId.get(parent);
-						if (earlier && earlier !== hunk) earlier.supersededBy.add(id);
-					}
-					pieces.splice(at, count, hunk.marker, ...(row.inserted ? [{text: row.inserted, owner: id, lineage: [...lineage]}] : []));
-					priorSplices?.push({pos: row.pos, removed: row.removed, inserted: row.inserted});
-				}
-			}
-		}
-		if (textOf(pieces) !== prepared.source) throw Error('head');
-		const origins = new Map();
-		let offset = 0;
-		for (const piece of pieces) if (piece.text) { origins.set(piece, offset); offset += piece.text.length; }
-		const superseded = [];
-		for (let index = all.length - 1; index >= 0; index--) {
-			const hunk = all[index];
-			const inheritedInactive = !hunk.derived && !hunk.kept && !keptInverseAncestors.has(hunk.id) && !projectedEffects.active.has(hunk.actId) &&
-				!prepared.effects.references.get(hunk.actId)?.length;
-			if (!hunk.chosen && !inheritedInactive) continue;
-			hunk.active = prepared.effects.active.has(hunk.actId);
-			const laterActIds = [...new Set([...hunk.supersededBy].filter(id =>
-				(byId.get(id)?.kept || byId.get(id)?.active && projectedEffects.active.has(byId.get(id)?.actId))).map(id => byId.get(id).actId))];
-			const marker = pieces.indexOf(hunk.marker);
-			if ((!hunk.active && !inheritedInactive) || laterActIds.length || marker < 0) {
-				if (hunk.chosen) superseded.push({actId: hunk.actId, hunk: hunk.id, laterActIds: hunk.undoneBy ? [hunk.undoneBy] : laterActIds,
-					reason: hunk.active ? 'later_edit' : 'already_undone'});
-				continue;
-			}
-			for (let at = pieces.length - 1; at >= 0; at--) if (pieces[at] !== hunk.marker && owns(pieces[at], hunk)) pieces.splice(at, 1);
-			pieces.splice(pieces.indexOf(hunk.marker), 1, ...hunk.before);
-			// Restoring an inverse can restore a deletion marker without any owned
-			// text. That exact marker already represents the active deletion.
-			for (const piece of hunk.before) if (piece.mark) { piece.mark.active = true; delete piece.mark.undoneBy; }
-		}
-		// A hidden withdrawal can have no splice of its own. Reversing that withdrawal
-		// reactivates the original hunk at its retained marker, never at a text search.
-		reactivate(new Set(records.filter(record => !prepared.effects.active.has(record.transaction.id) &&
-			projectedEffects.active.has(record.transaction.id)).map(record => record.transaction.id)), projectedEffects);
-		const after = textOf(pieces), changes = [];
-		let cursor = 0, inserted = '';
-		for (const piece of pieces) {
-			if (!piece.text) continue;
-			const origin = origins.get(piece);
-			if (origin == null) { inserted += piece.text; continue; }
-			if (origin < cursor) throw Error('source_order');
-			const removed = prepared.source.slice(cursor, origin);
-			if (removed !== inserted) changes.push(minimalHistorySplice(removed, inserted, cursor));
-			inserted = ''; cursor = origin + piece.text.length;
-		}
-		const removed = prepared.source.slice(cursor);
-		if (removed !== inserted) changes.push(minimalHistorySplice(removed, inserted, cursor));
-		const splices = changes.length <= 64 ? changes.reverse() : [minimalHistorySplice(prepared.source, after)];
-		if (_rapierTransformSplices(prepared.source, splices) !== after) throw Error('plan');
-		return {ok: true, splices, after, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
-			effectChanged, unchanged: after === prepared.source && !metadata && !effectChanged, superseded,
-			overlaps: superseded.filter(row => row.reason === 'later_edit')};
+		const result = projectInverseSource({...prepared, rows}, selected, projectedEffects, options);
+		if (!result.ok) return result;
+		return {...result, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
+			effectChanged, unchanged: result.after === prepared.source && !metadata && !effectChanged};
 	} catch (_) { return historyFailure('history_invalid'); }
 }