rapier-html 1.2.40 → 1.2.43

package/dist/ledger/journal-records.mjs

@@ -76,7 +76,7 @@ function _rapierValidAuthored(origin) {
 		!/[\uD800-\uDFFF]/u.test(row.removed) && !/[\uD800-\uDFFF]/u.test(row.inserted));
 }
 
-function _rapierRecordIndex(records) {
+function _rapierRecordIndex(records, shared = false) {
 	const byId = new Map(), splices = new Map(), metadata = new Map();
 	for (const record of records) {
 		const id = record?.transaction?.id;
@@ -100,20 +100,41 @@ function _rapierRecordIndex(records) {
 		}
 		cache.set(current, value);
 		for (let i = path.length - 1; i >= 0; i--) {
-			if (path[i].transaction.reverts && value != null) value = effects
-				? Object.fromEntries(Object.entries(value).map(([key, pair]) => [key, {before: pair.after, after: pair.before}]))
-				: value.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
+			if (path[i].transaction.reverts && value != null) {
+				value = effects
+					? Object.fromEntries(Object.entries(value).map(([key, pair]) => [key, {before: pair.after, after: pair.before}]))
+					: value.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
+				if (shared) { for (const row of Object.values(value)) Object.freeze(row); Object.freeze(value); }
+			}
 			cache.set(path[i], value);
 		}
 		return value;
 	};
-	return {byId, splices: record => resolve(record, false), metadata: record => resolve(record, true)};
+	const extend = more => { for (const record of more) { const id = record?.transaction?.id; if (!byId.has(id)) byId.set(id, []); byId.get(id).push(record); } };
+	return {byId, extend, splices: record => resolve(record, false), metadata: record => resolve(record, true)};
+}
+
+const _rapierLedgerIndexes = new WeakMap();
+function _rapierLedgerIndex(ledger) {
+	const records = ledger || [];
+	if (!Array.isArray(records)) return _rapierRecordIndex(records);
+	const held = _rapierLedgerIndexes.get(records);
+	if (held && held.records.length === records.length && held.records.at(-1) === records.at(-1) &&
+		(held.checked || held.records.every((record, at) => record === records[at]))) {
+		if (!held.checked) { held.checked = true; queueMicrotask(() => { held.checked = false; }); }
+		return held.index;
+	}
+	if (!records.every(record => record && typeof record === 'object' && Object.isFrozen(record) && Object.isFrozen(record.transaction ?? {})))
+		return _rapierRecordIndex(records);
+	const index = _rapierRecordIndex(records, true);
+	_rapierLedgerIndexes.set(records, {records: records.slice(), index});
+	return index;
 }
 
 function _rapierRecordSplices(entry, ledger) {
 	try {
 		if (entry && Array.isArray(entry.splices)) return entry.splices;
-		return _rapierRecordIndex(ledger || []).splices(entry);
+		return _rapierLedgerIndex(ledger).splices(entry);
 	} catch (_) { return null; }
 }
 
@@ -163,7 +184,7 @@ function _rapierRecordMetadata(entry, ledger) {
 	try {
 		if (Object.hasOwn(entry, 'metadata')) return _rapierValidMetadataEffect(entry.metadata) ? entry.metadata : undefined;
 		if (Array.isArray(entry.splices)) return null;
-		return _rapierRecordIndex(ledger || []).metadata(entry);
+		return _rapierLedgerIndex(ledger).metadata(entry);
 	} catch (_) { return undefined; }
 }
 
@@ -213,87 +234,89 @@ function _rapierPictureFinish(record, original, earlier, lookup) {
 	});
 }
 
-function _rapierWalkHistoryEffects(records, lookup, visit = null, observe = null) {
-	try {
-		if (!Array.isArray(records)) return {ok: false};
-		const nodes = new Map(), references = new Map(), pictures = new Map(), byId = new Map(), finished = new Set(), earlier = [];
-		const update = (target, delta) => {
-			const pending = [[target, delta]];
-			while (pending.length) {
-				const [id, change] = pending.pop(), node = nodes.get(id), was = node.active;
-				node.blockers += change;
-				if (node.blockers < 0) throw Error('effect');
-				node.active = node.blockers === 0;
-				if (was !== node.active) for (const ref of node.references) pending.push([ref, node.active ? 1 : -1]);
-			}
-		};
-		const activity = new Map();
-		const active = id => {
-			if (visit) return nodes.get(id).active;
-			const pending = [[id, 0]];
-			while (pending.length) {
-				const frame = pending.at(-1), target = frame[0];
-				if (activity.has(target)) { pending.pop(); continue; }
-				const dependents = nodes.get(target).dependents;
-				if (frame[1] === dependents.length) { activity.set(target, true); pending.pop(); continue; }
-				const next = dependents[frame[1]];
-				if (!activity.has(next)) pending.push([next, 0]);
-				else if (activity.get(next)) { activity.set(target, false); pending.pop(); }
-				else frame[1]++;
-			}
-			return activity.get(id);
-		};
-		const lastUndo = new Map(), contexts = new Map(), order = [];
-		const contextOf = origin => {
-			if (!origin) return null;
-			if (!_rapierValidAuthored(origin)) throw Error('origin');
-			const known = new Set(), pending = origin.basis.slice();
-			while (pending.length) {
-				const id = pending.pop(), context = contexts.get(id);
-				if (!context) throw Error('origin');
-				if (known.has(id)) continue;
-				known.add(id);
-				if (context.basis) pending.push(...context.basis);
-				else for (let index = 0; index < context.index; index++) known.add(order[index]);
-			}
-			const inactive = new Set();
-			for (let index = order.length - 1; index >= 0; index--) {
-				const id = order[index];
-				if (!known.has(id) || inactive.has(id)) continue;
-				for (const ref of references.get(id)) {
-					if (!known.has(ref)) throw Error('origin');
-					inactive.add(ref);
-				}
+function _rapierHistoryWalker(records, lookup, visit = null, observe = null) {
+	let nodes = new Map(), references = new Map(), pictures = new Map();
+	const byId = new Map(), finished = new Set(), earlier = [];
+	const update = (target, delta) => {
+		const pending = [[target, delta]];
+		while (pending.length) {
+			const [id, change] = pending.pop(), node = nodes.get(id), was = node.active;
+			node.blockers += change;
+			if (node.blockers < 0) throw Error('effect');
+			node.active = node.blockers === 0;
+			if (was !== node.active) for (const ref of node.references) pending.push([ref, node.active ? 1 : -1]);
+		}
+	};
+	const activity = new Map();
+	const active = id => {
+		if (visit) return nodes.get(id).active;
+		const pending = [[id, 0]];
+		while (pending.length) {
+			const frame = pending.at(-1), target = frame[0];
+			if (activity.has(target)) { pending.pop(); continue; }
+			const dependents = nodes.get(target).dependents;
+			if (frame[1] === dependents.length) { activity.set(target, true); pending.pop(); continue; }
+			const next = dependents[frame[1]];
+			if (!activity.has(next)) pending.push([next, 0]);
+			else if (activity.get(next)) { activity.set(target, false); pending.pop(); }
+			else frame[1]++;
+		}
+		return activity.get(id);
+	};
+	const lastUndo = new Map(), contexts = new Map(), order = [];
+	const contextOf = origin => {
+		if (!origin) return null;
+		if (!_rapierValidAuthored(origin)) throw Error('origin');
+		const known = new Set(), pending = origin.basis.slice();
+		while (pending.length) {
+			const id = pending.pop(), context = contexts.get(id);
+			if (!context) throw Error('origin');
+			if (known.has(id)) continue;
+			known.add(id);
+			if (context.basis) pending.push(...context.basis);
+			else for (let index = 0; index < context.index; index++) known.add(order[index]);
+		}
+		const inactive = new Set();
+		for (let index = order.length - 1; index >= 0; index--) {
+			const id = order[index];
+			if (!known.has(id) || inactive.has(id)) continue;
+			for (const ref of references.get(id)) {
+				if (!known.has(ref)) throw Error('origin');
+				inactive.add(ref);
 			}
-			return {known, inactive};
-		};
-		for (const record of records) {
+		}
+		return {known, inactive};
+	};
+	const walker = {observe, failed: false};
+	walker.add = record => {
+		if (walker.failed) return false;
+		try {
 			const tx = record?.transaction;
-			if (!tx || typeof tx.id !== 'string' || !tx.id || nodes.has(tx.id) || (tx.reverts && tx.reapplies)) return {ok: false};
+			if (!tx || typeof tx.id !== 'string' || !tx.id || nodes.has(tx.id) || (tx.reverts && tx.reapplies)) { walker.failed = true; return false; }
 			const supplied = tx.sourceTransactionIds || (tx.sourceTransactionId ? [tx.sourceTransactionId] : []);
 			if (!Array.isArray(supplied) || new Set(supplied).size !== supplied.length ||
-				(tx.sourceTransactionIds && tx.sourceTransactionId && (supplied.length !== 1 || supplied[0] !== tx.sourceTransactionId))) return {ok: false};
+				(tx.sourceTransactionIds && tx.sourceTransactionId && (supplied.length !== 1 || supplied[0] !== tx.sourceTransactionId))) { walker.failed = true; return false; }
 			let refs = supplied;
 			if (tx.operation === 'document.finish-picture' && tx.sourceTransactionId) {
 				const owner = tx.sourceTransactionId;
 				if (!nodes.has(owner) || !active(owner) || finished.has(owner) ||
-					!_rapierPictureFinish(record, byId.get(owner), earlier, lookup ||= _rapierRecordIndex(records))) return {ok: false};
+					!_rapierPictureFinish(record, byId.get(owner), earlier, lookup ||= _rapierRecordIndex(records))) { walker.failed = true; return false; }
 				pictures.set(tx.id, owner); finished.add(owner); refs = [];
 			}
 			if (tx.reverts || tx.reapplies) {
 				const target = tx.reverts || tx.reapplies;
-				if (!nodes.has(target) || (supplied.length && (supplied.length !== 1 || supplied[0] !== target))) return {ok: false};
+				if (!nodes.has(target) || (supplied.length && (supplied.length !== 1 || supplied[0] !== target))) { walker.failed = true; return false; }
 				if (tx.reverts) refs = [target];
 				else {
 					const context = contextOf(record.authored || tx.authored);
 					const undo = (lastUndo.get(target) || []).findLast(id => context
 						? context.known.has(id) && !context.inactive.has(id) : active(id));
-					if (!undo) return {ok: false};
+					if (!undo) { walker.failed = true; return false; }
 					refs = [undo];
 				}
 			}
-			if (refs.some(id => typeof id !== 'string' || !nodes.has(id) || pictures.has(id))) return {ok: false};
-			if (tx.actor?.kind === 'agent' && refs.some(id => byId.get(id).transaction.actor?.kind !== 'agent')) return {ok: false};
+			if (refs.some(id => typeof id !== 'string' || !nodes.has(id) || pictures.has(id))) { walker.failed = true; return false; }
+			if (tx.actor?.kind === 'agent' && refs.some(id => byId.get(id).transaction.actor?.kind !== 'agent')) { walker.failed = true; return false; }
 			nodes.set(tx.id, {active: true, blockers: 0, references: refs, dependents: []}); references.set(tx.id, refs.slice());
 			byId.set(tx.id, record); earlier.push(record);
 			for (const ref of refs) {
@@ -308,23 +331,45 @@ function _rapierWalkHistoryEffects(records, lookup, visit = null, observe = null
 				lastUndo.get(tx.reverts).push(tx.id);
 			}
 			if (visit) visit(record, nodes, refs);
-			if (observe) observe(record, refs, active);
-		}
-		if (!visit) for (let i = order.length - 1; i >= 0; i--) {
-			const node = nodes.get(order[i]); node.active = node.blockers === 0;
-			if (node.active) for (const ref of node.references) nodes.get(ref).blockers++;
+			if (walker.observe) walker.observe(record, refs, active);
+			return true;
+		} catch (_) { walker.failed = true; return false; }
+	};
+	walker.finish = () => {
+		if (walker.failed) return {ok: false};
+		const blockers = new Map(), effectiveActIds = [];
+		for (let i = order.length - 1; i >= 0; i--) {
+			const id = order[i], node = nodes.get(id), on = visit ? node.active : !(blockers.get(id) > 0);
+			if (!visit && on) for (const ref of node.references) blockers.set(ref, (blockers.get(ref) || 0) + 1);
+			if (on && !pictures.has(id)) effectiveActIds.push(id);
 		}
-		const effectiveActIds = [...nodes].filter(([id, node]) => node.active && !pictures.has(id)).map(([id]) => id);
-		return {ok: true, effectiveActIds, active: new Set(effectiveActIds), references, pictures};
-	} catch (_) { return {ok: false}; }
+		effectiveActIds.reverse();
+		const result = {ok: true, effectiveActIds, active: new Set(effectiveActIds), references, pictures};
+		walker.shared = true;
+		return result;
+	};
+	const add = walker.add;
+	walker.add = record => {
+		if (walker.shared) { references = new Map(references); pictures = new Map(pictures); walker.shared = false; }
+		return add(record);
+	};
+	return walker;
+}
+
+function _rapierWalkHistoryEffects(records, lookup, visit = null, observe = null) {
+	if (!Array.isArray(records)) return {ok: false};
+	const walker = _rapierHistoryWalker(records, lookup, visit, observe);
+	for (const record of records) if (!walker.add(record)) return {ok: false};
+	return walker.finish();
 }
 
 function _rapierHistoryEffects(records, visit = null) {
 	return _rapierWalkHistoryEffects(records, null, visit);
 }
 
-function _rapierMetadataProof(lookup) {
-	const values = {}, required = {}, assignments = {filename: [], docKind: []};
+function _rapierMetadataProof(lookup, from = null) {
+	const values = {...from?.values}, required = {...from?.required},
+		assignments = {filename: [...(from?.assignments.filename || [])], docKind: [...(from?.assignments.docKind || [])]};
 	const requireInitial = (key, value) => {
 		if (Object.hasOwn(required, key) && required[key] !== value) throw Error('metadata_effect');
 		required[key] = value;
@@ -351,7 +396,7 @@ function _rapierMetadataProof(lookup) {
 		if (!_rapierValidMetadata(initial) || Object.keys(required).some(key => initial[key] !== required[key])) return null;
 		return {...initial, ...values};
 	};
-	return {observe, replay};
+	return {observe, replay, fork: other => _rapierMetadataProof(other || lookup, {values, required, assignments})};
 }
 
 function _rapierMetadataState(initial, records, effects = _rapierHistoryEffects(records)) {
@@ -458,16 +503,79 @@ const _rapierPrepareHistoryRecords = (() => {
 			frame.descriptors = descriptors; frame.fields = fields;
 			frame.leaving = true; active.add(value); pending.push(frame);
 			for (let at = fields.length - 1; at >= 0; at--) {
-				const key = fields[at]; pending.push({value: descriptors[key].value, parent: frame, key, depth: frame.depth + 1});
+				const key = fields[at], child = descriptors[key].value;
+				const prior = array && child && typeof child === 'object' ? copies.get(child) : undefined;
+				if (prior?.immutable && !active.has(child) && frame.depth + 1 + prior.height <= 64) {
+					finish({parent: frame, key}, prior.copy, true, prior.height); continue;
+				}
+				pending.push({value: child, parent: frame, key, depth: frame.depth + 1});
 			}
 		}
 		return result.value;
 	};
+	let resumable = [];
+	const rowOf = (lookup, record) => {
+		const splices = lookup.splices(record), metadata = lookup.metadata(record);
+		if (splices && !Object.isFrozen(splices)) {
+			for (const row of splices) Object.freeze(row);
+			Object.freeze(splices);
+		}
+		if (metadata && !Object.isFrozen(metadata)) {
+			for (const pair of Object.values(metadata)) Object.freeze(pair);
+			Object.freeze(metadata);
+		}
+		return Object.freeze({record, splices, metadata});
+	};
+	const observe = (records, basis, byId, rows, effects, proof) => {
+		for (const refs of effects.references.values()) Object.freeze(refs);
+		const effectView = Object.freeze({ok: true, effectiveActIds: Object.freeze(effects.effectiveActIds),
+			active: view(effects.active), references: view(effects.references), pictures: view(effects.pictures)});
+		const observation = Object.freeze({ok: effects.ok, records, rows: Object.freeze(rows), effects: effectView, byId: view(byId),
+			replayMetadata: initial => effects.ok ? proof.replay(initial) : null,
+			validRecord: (index, documentAuthority, maxDocumentBytes, utf8Length, allowGap = false) => {
+				if (!effects.ok || !Number.isSafeInteger(index) || index < 0 || index >= records.length) return false;
+				const row = rows[index], tx = row.record.transaction;
+				return _rapierCheckLedgerRecord(row.record, records[index - 1] || null, documentAuthority, maxDocumentBytes, utf8Length, allowGap,
+					{...row, duplicate: false, semantic: !!(tx.reverts || tx.reapplies || tx.sourceTransactionId || tx.sourceTransactionIds?.length)});
+			}});
+		prepared = new WeakMap([[records, {basis, observation}]]);
+		return observation;
+	};
+	const authorityOf = state => state.records[0]?.transaction?.documentAuthority;
+	const keep = state => { resumable = [state, ...resumable.filter(row => row !== state && row.records[0] !== state.records[0] &&
+		authorityOf(row) === authorityOf(state))].slice(0, 4); };
+	const extend = records => {
+		const base = resumable.find(row => row.records.length < records.length && row.records[0] === records[0] &&
+			row.records.every((record, at) => record === records[at]));
+		if (!base) return null;
+		resumable = resumable.filter(row => row !== base);
+		const more = records.slice(base.records.length), byId = new Map(base.byId);
+		for (const record of more) {
+			const id = record?.transaction?.id;
+			if (typeof id !== 'string' || !id || byId.has(id)) return null;
+			byId.set(id, record);
+		}
+		const {lookup, walker} = base;
+		lookup.extend(more);
+		const rows = base.rows.concat(more.map(record => rowOf(lookup, record)));
+		const proof = base.proof.fork(lookup);
+		walker.observe = proof.observe;
+		for (const record of more) if (!walker.add(record)) return null;
+		const effects = walker.finish();
+		if (!effects.ok) return null;
+		if (rows.every(row => row.splices && row.metadata !== undefined)) keep({records, lookup, walker, proof, byId, rows});
+		return observe(records, records, byId, rows, effects, proof);
+	};
 	return (input, earlier = input) => {
 		try {
 			if (!Array.isArray(input) || !Array.isArray(earlier)) return {ok: false};
 			const records = capture(input), basis = input === earlier ? records : capture(earlier), previous = prepared.get(records);
 			if (previous?.basis === basis) return previous.observation;
+			if (basis === records) {
+				let grown = null;
+				try { grown = extend(records); } catch (_) { grown = null; }
+				if (grown) return grown;
+			}
 			const byId = new Map();
 			for (const record of records) {
 				const id = record?.transaction?.id;
@@ -475,41 +583,24 @@ const _rapierPrepareHistoryRecords = (() => {
 				byId.set(id, record);
 			}
 			const lookup = _rapierRecordIndex(basis), proof = _rapierMetadataProof(lookup);
-			const rows = records.map(record => {
-				const splices = lookup.splices(record), metadata = lookup.metadata(record);
-				if (splices && !Object.isFrozen(splices)) {
-					for (const row of splices) Object.freeze(row);
-					Object.freeze(splices);
-				}
-				if (metadata && !Object.isFrozen(metadata)) {
-					for (const pair of Object.values(metadata)) Object.freeze(pair);
-					Object.freeze(metadata);
-				}
-				return Object.freeze({record, splices, metadata});
-			});
-			const effects = _rapierWalkHistoryEffects(records, lookup, null, proof.observe);
+			const rows = records.map(record => rowOf(lookup, record));
+			const walker = _rapierHistoryWalker(records, lookup, null, proof.observe);
+			for (const record of records) if (!walker.add(record)) return {ok: false};
+			const effects = walker.finish();
 			if (!effects.ok) return {ok: false};
-			for (const refs of effects.references.values()) Object.freeze(refs);
-			const effectView = Object.freeze({ok: true, effectiveActIds: Object.freeze(effects.effectiveActIds),
-				active: view(effects.active), references: view(effects.references), pictures: view(effects.pictures)});
-			const observation = Object.freeze({ok: effects.ok, records, rows: Object.freeze(rows), effects: effectView, byId: view(byId),
-				replayMetadata: initial => effects.ok ? proof.replay(initial) : null,
-				validRecord: (index, documentAuthority, maxDocumentBytes, utf8Length, allowGap = false) => {
-					if (!effects.ok || !Number.isSafeInteger(index) || index < 0 || index >= records.length) return false;
-					const row = rows[index], tx = row.record.transaction;
-					return _rapierCheckLedgerRecord(row.record, records[index - 1] || null, documentAuthority, maxDocumentBytes, utf8Length, allowGap,
-						{...row, duplicate: false, semantic: !!(tx.reverts || tx.reapplies || tx.sourceTransactionId || tx.sourceTransactionIds?.length)});
-				}});
-			prepared = new WeakMap([[records, {basis, observation}]]); return observation;
+			if (basis === records && rows.every(row => row.splices && row.metadata !== undefined))
+				keep({records, lookup, walker, proof, byId, rows});
+			return observe(records, basis, byId, rows, effects, proof);
 		} catch (_) { return {ok: false}; }
 	};
 })();
 
 const _rapierJournalRecord = (() => {
 	const copies = new WeakMap();
+	const fixed = value => { if (value && typeof value === 'object') { for (const key of Object.keys(value)) fixed(value[key]); Object.freeze(value); } return value; };
 	return record => {
 		let copy = copies.get(record);
-		if (!copy) { copy = JSON.parse(JSON.stringify(record)); copies.set(record, copy); }
+		if (!copy) { copy = fixed(JSON.parse(JSON.stringify(record))); copies.set(record, copy); }
 		return copy;
 	};
 })();

package/dist/ledger/md-assets.mjs

@@ -100,7 +100,7 @@ export function* blockWindows(source, bodyOffset, parser, env, keepNul = false)
     return end < body.length ? sourceOffset(end + 1) : undefined;
   }});
   let lines = 0;
-  for (let at = 0; at < body.length; at++) if (body.charCodeAt(at) === 10) lines++;
+  for (let at = body.indexOf('\n'); at !== -1; at = body.indexOf('\n', at + 1)) lines++;
   if (lines <= BLOCK_WINDOW) {
     state = new parser.block.State(body, parser, env, tokens);
     state.rapierSourceSlice = (from, to) => source.slice(sourceOffset(from), sourceOffset(to));
@@ -179,8 +179,7 @@ export function* blockWindows(source, bodyOffset, parser, env, keepNul = false)
   }
 }
 
-const PERCENT_PAYLOAD = Array.from({length: 128}, (_, code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 ||
-  code >= 97 && code <= 122 || '-._~:/?@+$,;='.includes(String.fromCharCode(code)));
+const INVALID_PERCENT_PAYLOAD = /[^A-Za-z0-9._~:\/?@+$,;=%-]/;
 const isHexUnit = code => code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
 let lastScan = null;
 export function dataImage(url) {
@@ -197,13 +196,11 @@ function scanDataImage(url) {
     ...(prepared.encoding ? {encoding: prepared.encoding} : {})};
   if (/^data:image\/svg\+xml,/i.test(url)) {
     const payloadStart = 19;
-    let byteLength = 0;
-    for (let at = payloadStart; at < url.length; at++, byteLength++) {
-      const code = url.charCodeAt(at);
-      if (code === 37) {
-        if (!isHexUnit(url.charCodeAt(at + 1)) || !isHexUnit(url.charCodeAt(at + 2))) return null;
-        at += 2;
-      } else if (!(code < 128 && PERCENT_PAYLOAD[code])) return null;
+    if (INVALID_PERCENT_PAYLOAD.test(url)) return null;
+    let byteLength = url.length - payloadStart;
+    for (let at = url.indexOf('%', payloadStart); at !== -1; at = url.indexOf('%', at + 3)) {
+      if (!isHexUnit(url.charCodeAt(at + 1)) || !isHexUnit(url.charCodeAt(at + 2))) return null;
+      byteLength -= 2;
     }
     return byteLength && byteLength <= IMAGE_LIMITS.bytes
       ? {codec: 'image/svg+xml', byteLength, payloadStart, encoding: 'percent'} : null;

package/dist/ledger/will.mjs

@@ -215,7 +215,7 @@ export function willTransition(beforeText, afterText, splices, markerSplices = s
 	return null;
 }
 
-export function evaluateWill(beforeText, splices) {
+export function evaluateWill(beforeText, splices, {restores = null} = {}) {
 	const invalid = rule => ({outcome: 'invalid', reason: 'precondition', rule});
 	if (typeof beforeText !== 'string' || !beforeText.isWellFormed()) return invalid('invalid_unicode');
 	if (!Array.isArray(splices)) return invalid('malformed_splice');
@@ -231,7 +231,7 @@ export function evaluateWill(beforeText, splices) {
 		if (afterText.slice(row.pos, end) !== row.removed) return invalid('source_mismatch');
 		afterText = afterText.slice(0, row.pos) + row.inserted + afterText.slice(end);
 	}
-	const refusal = splices.length && willTransition(beforeText, afterText, splices);
+	const refusal = splices.length && willTransition(beforeText, afterText, splices, splices, {restores});
 	return refusal ? {outcome: 'refused', reason: 'document_law', ...refusal} : {outcome: 'applied'};
 }