rapier-html 1.1.99 → 1.1.102

package/dist/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/ledger/history.mjs

@@ -0,0 +1,309 @@
+// 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 {authoredHistory} from './transport.mjs';
+import {plainData} from './data.mjs';
+
+const historyFailure = reason => ({ok: false, reason});
+const historyInteger = value => Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+const historyBoundary = (source, at) => historyInteger(at) && at <= source.length && !(at > 0 && at < source.length &&
+	(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',
+		...(tx.turnId ? {turnId: tx.turnId} : {}),
+		...(tx.contribution ? {contribution: 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.metadata ? {metadata: plainData(record.metadata)} : {}),
+		...(effects ? {active: effects.active.has(tx.id)} : {})};
+}
+
+export function groupHistoryActs(acts) {
+	const groups = [], grouped = new Map();
+	for (const act of acts) {
+		const key = JSON.stringify([act.actor.kind, act.actor.id, act.turnId || null, act.turnId ? null : act.id]);
+		let group = grouped.get(key);
+		if (!group) {
+			group = {id: act.turnId || act.id, actor: {...act.actor}, actIds: [], createdAt: act.createdAt,
+				...(act.turnId ? {turnId: act.turnId} : {})};
+			groups.push(group); grouped.set(key, group);
+		}
+		group.actIds.push(act.id);
+	}
+	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) {
+	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.
+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 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) ||
+				!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 (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');
+		}
+		const earliestRevision = rows[0]?.record.transaction.baseRevision ?? revision;
+		let replay = initialSource, root = earliestRevision === 0 ? textRoot(initialSource) : 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.
+			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 (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};
+	} catch (_) { return historyFailure('history_invalid'); }
+}
+
+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.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)};
+}
+
+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');
+}
+
+function historyRangeBefore(range, splice) {
+	const start = splice.pos, end = start + splice.inserted.length, replacement = splice.removed.length;
+	const touched = range.from === range.to ? start <= range.from && end >= range.to
+		: start === end ? range.from <= start && start <= range.to : start < range.to && end > range.from;
+	if (!touched) {
+		const shift = end <= range.from ? replacement - splice.inserted.length : 0;
+		return {from: range.from + shift, to: range.to + shift, touched: false};
+	}
+	return {from: range.from <= start ? range.from : range.from >= end ? range.from + replacement - splice.inserted.length : start,
+		to: range.to >= end ? range.to + replacement - splice.inserted.length : range.to <= start ? range.to : start + replacement,
+		touched: true};
+}
+
+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 = [];
+	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)};
+		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});
+	}
+	if (actId != null && !before) return historyFailure('act_unavailable');
+	acts.reverse();
+	return {ok: true, from, to, source: prepared.source.slice(from, to), revision: prepared.revision,
+		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);
+	if (!prepared.ok) return prepared;
+	if (!Array.isArray(blocks) || blocks.some(block => !block ||
+		!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;
+	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);
+				}
+			}
+		}
+		set(act.id, true); effects.set(act.id, changes);
+	}
+	for (const block of projected) { block.acts.reverse(); delete block.range; }
+	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)};
+}
+
+// Runs retain only exact replacement ancestry. A later replacement owns an ambiguous hunk whole.
+export function selectiveUndo(input, actIds, options = {}) {
+	const prepared = prepareHistory(input);
+	if (!prepared.ok) return prepared;
+	if (!Array.isArray(actIds) || !actIds.length || actIds.some(id => typeof id !== 'string' || !id)) return historyFailure('act_invalid');
+	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));
+	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}));
+	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 &&
+		prepared.effects.active.has(record.transaction.id) !== projectedEffects.active.has(record.transaction.id));
+	if (!authoredEffectChanged) 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);
+		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'); }
+}