rapier-markdown-kit 1.2.42 → 1.2.44

package/dist/kit/ledger/data.mjs

@@ -110,11 +110,15 @@ function keyedRow(row, depth) {
   }
   return json;
 }
+const plainRowArrays = new WeakSet();
 export function* canonicalRowsParts(rows, depth = 0) {
-  const {array, keys} = fields(rows, depth, new Set());
-  if (!array) { yield* canonicalParts(rows, depth); return; }
+  if (!(depth <= 64 && plainRowArrays.has(rows))) {
+    const {array} = fields(rows, depth, new Set());
+    if (!array) { yield* canonicalParts(rows, depth); return; }
+    if (Object.isFrozen(rows) && depth <= 64) plainRowArrays.add(rows);
+  }
   yield '[';
-  for (let i = 0; i < keys.length; i++) { if (i) yield ','; yield canonicalRow(rows[keys[i]], depth + 1); }
+  for (let i = 0; i < rows.length; i++) { if (i) yield ','; yield canonicalRow(rows[i], depth + 1); }
   yield ']';
 }
 export function exactKeys(value, keys) {

package/dist/kit/ledger/format.mjs

@@ -10,10 +10,10 @@ import {minimalHistorySplice} from './inverse-source.mjs';
 import {evaluateWill} from '../../agent/will.mjs';
 export {textRoot, rootAfter};
 const rootShape = value => typeof value === 'string' && /^\d+:[a-z0-9]+:[a-z0-9]+$/.test(value);
-function* checkedRecords(ledger, prepared) {
+function* checkedRecords(ledger, prepared, from = null) {
   if (!prepared.ok || ledger.records.length !== prepared.records.length) throw fault('record chain differs');
-  let root = ledger.start.root, revision = ledger.start.revision;
-  for (let index = 0; index < prepared.records.length; index++) {
+  let root = from ? from.root : ledger.start.root, revision = from ? from.revision : ledger.start.revision;
+  for (let index = from ? from.index : 0; index < prepared.records.length; index++) {
     const record = ledger.records[index];
     if (!Array.isArray(record.splices) || !prepared.validRecord(index,
         ledger.documentAuthority, 64 * 1024 * 1024, utf8Length, !ledger.complete) ||
@@ -170,6 +170,7 @@ const expandedRows = new WeakMap();
 const sameSplices = (a, b) => a === b || a.length === b.length &&
   a.every((row, i) => row.pos === b[i].pos && row.removed === b[i].removed && row.inserted === b[i].inserted);
 const sameEffect = (a, b) => a === b || !!a && !!b && canonicalJSON(a) === canonicalJSON(b);
+let recentLedgers = [];
 function* produceLedger({text, metadata, records, documentAuthority, revision, root, complete = false, earlier = records} = {}, native = false) {
   if (!_rapierValidMetadata(metadata)) throw fault('document metadata required');
   metadata = {...metadata};
@@ -191,16 +192,30 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
     yield;
   }
   const headBytes = bytes;
+  let base = recentLedgers.find(row => row.rows.length <= expanded.length && row.rows.every((value, at) => value === expanded[at]));
   let startSource = new HistorySource(text), startMetadata = {...metadata};
-  for (let i = expanded.length - 1; i >= 0; i--) {
+  for (let i = expanded.length - 1; i >= (base ? base.rows.length : 0); i--) {
     startSource = startSource.apply(expanded[i].splices, true);
-    startMetadata = _rapierTransformMetadata(startMetadata, expanded[i].metadata, true);
+    if (expanded[i].metadata) startMetadata = _rapierTransformMetadata(startMetadata, expanded[i].metadata, true);
     if (startSource === null || !startMetadata) throw fault('history does not reverse from this document');
     for (const row of expanded[i].splices) bytes += utf8Length(row.removed) - utf8Length(row.inserted);
     if (bytes > 64 * 1024 * 1024) throw fault('document exceeds the editor text limit');
     yield;
   }
-  const startText = startSource.slice();
+  if (base && (bytes !== base.headBytes || startSource.length !== base.headText.length || !startSource.matches(0, base.headText) ||
+      canonicalJSON(startMetadata) !== base.headMetadata)) {
+    base = null; bytes = headBytes; startSource = new HistorySource(text); startMetadata = {...metadata};
+    for (let i = expanded.length - 1; i >= 0; i--) {
+      startSource = startSource.apply(expanded[i].splices, true);
+      if (expanded[i].metadata) startMetadata = _rapierTransformMetadata(startMetadata, expanded[i].metadata, true);
+      if (startSource === null || !startMetadata) throw fault('history does not reverse from this document');
+      for (const row of expanded[i].splices) bytes += utf8Length(row.removed) - utf8Length(row.inserted);
+      if (bytes > 64 * 1024 * 1024) throw fault('document exceeds the editor text limit');
+      yield;
+    }
+  }
+  if (base) { startMetadata = {...base.startMetadata}; bytes = base.startBytes; }
+  const startText = base ? base.startText : startSource.slice();
   const unchangedText = expanded.every(row => !row.splices.length);
   const contentRoot = headFacts.contentRoot;
   revision ??= expanded.at(-1)?.transaction.revision ?? 0;
@@ -209,19 +224,24 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   const startRevision = expanded[0]?.transaction.baseRevision ?? revision, startRoot = expanded[0]?.beforeHash ?? root;
   if (typeof documentAuthority !== 'string' || !documentAuthority || documentAuthority.length > 256) throw fault('unsupported or invalid envelope');
   if (!nonnegative(startRevision) || !rootShape(startRoot)) throw fault('invalid start');
-  const startFacts = unchangedText ? headFacts : yield* sourceFacts(startText, native);
+  const startFacts = unchangedText ? headFacts : base ? base.startFacts : yield* sourceFacts(startText, native);
   if (startRevision === 0 && startRoot !== startFacts.contentRoot) throw fault('invalid start');
   const headSHA = headFacts.sha256, startSHA = startFacts.sha256;
   const payload = {format: 'rapier-ledger/2', documentAuthority,
     start: {text: startText, revision: startRevision, root: startRoot, sha256: startSHA, metadata: startMetadata},
     records: expanded, head: {revision, root, sha256: headSHA, metadata: {...metadata}}, complete: complete === true && startRevision === 0 && expanded.every((row, i) => !i || row.transaction.baseRevision === expanded[i - 1].transaction.revision)};
-  for (const _record of checkedRecords(payload, prepared)) yield;
+  const from = base && base.documentAuthority === documentAuthority && base.complete === payload.complete &&
+    base.startRoot === startRoot && base.startRevision === startRevision ? {index: base.rows.length, root: base.chainRoot, revision: base.chainRevision} : null;
+  for (const _record of checkedRecords(payload, prepared, from)) yield;
   if (expanded.some(row => Object.hasOwn(row, 'authored'))) {
     try { authoredHistory(startText, expanded); } catch (_) { throw fault('authored origin differs'); }
   }
   const replayedMetadata = prepared.replayMetadata(startMetadata);
   if (!replayedMetadata || canonicalJSON(replayedMetadata) !== canonicalJSON(metadata)) throw fault('metadata does not describe this document');
   const ledger = {...payload, sha256: yield* checksum(envelopeParts(payload), native)};
+  recentLedgers = [{rows: expanded, headText: text, headMetadata: canonicalJSON(metadata), headBytes, startText, startMetadata: {...startMetadata},
+    startFacts, startBytes: bytes, documentAuthority, complete: payload.complete, startRoot, startRevision, chainRoot: payload.head.root,
+    chainRevision: payload.head.revision}, ...recentLedgers.filter(row => row.rows[0] !== expanded[0] && row.documentAuthority === documentAuthority)].slice(0, 4);
   ownLedger(ledger);
   proofs.set(ledger, {shell: Array.from(envelopeParts({...ledger, start: {...ledger.start, text: ''}})).join(''), startText,
     text, metadata: {...metadata}, root, revision, prepared: _rapierPrepareHistoryRecords(ledger.records),
@@ -273,7 +293,7 @@ function historyNavigation(ledger, text, metadata, prepared, source) {
   let traversed = source, traversedMetadata = {...metadata};
   for (let i = cursor - 1; i >= 0; i--) {
     traversed = step(traversed, branch[i], false);
-    traversedMetadata = _rapierTransformMetadata(traversedMetadata, byId.get(branch[i]).metadata, true);
+    if (byId.get(branch[i]).metadata) traversedMetadata = _rapierTransformMetadata(traversedMetadata, byId.get(branch[i]).metadata, true);
     if (traversed === null || !traversedMetadata) throw fault('undo branch does not reverse');
   }
   if (ledger.complete) {
@@ -284,7 +304,7 @@ function historyNavigation(ledger, text, metadata, prepared, source) {
   traversed = source; traversedMetadata = {...metadata};
   for (let i = cursor; i < branch.length; i++) {
     traversed = step(traversed, branch[i], true);
-    traversedMetadata = _rapierTransformMetadata(traversedMetadata, byId.get(branch[i]).metadata);
+    if (byId.get(branch[i]).metadata) traversedMetadata = _rapierTransformMetadata(traversedMetadata, byId.get(branch[i]).metadata);
     if (traversed === null || !traversedMetadata) throw fault('redo branch does not replay');
   }
   if (ledger.complete && pictures.size) {

package/dist/kit/ledger/journal-records.mjs

@@ -110,7 +110,8 @@ function _rapierRecordIndex(records, shared = false) {
 		}
 		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();
@@ -233,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) {
@@ -328,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;
@@ -371,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)) {
@@ -478,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;
@@ -495,32 +583,14 @@ 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}; }
 	};
 })();

package/dist/kit/render-markdown.mjs

@@ -55,18 +55,23 @@ function createMarkdownRenderer(runtime) {
   window?.addEventListener?.('rapier:original-file-ready', scheduleWikiEmbeds);
   const wikiMode = options => options.wikiEmbedding ? 'links' : options.wikiLinks !== undefined ? options.wikiLinks
     : globalThis.RapierOriginalFolderCore?.currentOriginal?.() ? 'label' : false;
+let codeLeft = Infinity;
 function initMarkdownIt() {
 	if (typeof window.markdownit !== 'function') throw new Error('markdownit');
 	if (typeof _rapierMarkdownPreview === 'function') globalThis.rapierRenderPreview = _rapierMarkdownPreview;
 
 	md = window.markdownit({
 		...RAPIER_MARKDOWN_SPEC.options,
-		highlight: (code, lang) => lang && _rapierHighlightAdmitted(code) ? _rapierCodeHtml(code, lang) : '',
+		highlight: (code, lang) => lang && _rapierHighlightAdmitted(code) && (codeLeft -= code.length) >= 0 ? _rapierCodeHtml(code, lang) : '',
 	});
 
 	_rapierApplyMarkdownSpec(md, window);
 	globalThis.RapierImageAssets.installMarkdownImages(md);
 	_rapierInstallSemanticProbe(md);
+	md.core.ruler.after('block', 'rapier_part_decorations', state => {
+		if (state.env.rapierPartDecorations && !/[<$\\]/.test(state.src) && !state.src.includes('^['))
+			state.tokens = _rapierPartDecorationGroups(state.tokens).flat();
+	});
 	_rapierInstallMarkdownMath(md, RAPIER_MARKDOWN_SPEC.rules.mathBlock);
 
 	const markOpenDefault = md.renderer.rules.mark_open ||
@@ -138,7 +143,7 @@ function initMarkdownIt() {
 				'" data-rapier-image-source="' + esc(encodeURIComponent(token.content)) + '">' + esc(label) + '</span>';
 		}
 		const note = embed && !env.rapierWikiEmbedding;
-		if (note) scheduleWikiEmbeds();
+		if (note && !env.rapierPassive) scheduleWikiEmbeds();
 		return '<span class="rapier-source-token rapier-source-token--wiki' + (note ? '-embed' : '') +
 			'" data-rapier-source="' + esc(encodeURIComponent(token.content)) + '" data-rapier-visible="' + esc(encodeURIComponent(label)) +
 			'"><a href="' + esc(href) + '">' + esc(label) + '</a></span>';
@@ -371,12 +376,12 @@ function initMarkdownIt() {
 			const mathProvider = env.rapierProviders === false ? null : _rapierProviders.math;
 			const mathNeeded = provider?.requiresMath?.(src) === true;
 			const mathReady = !mathNeeded || mathProvider?.status === 'ready';
-			if (!mathReady && !mathProvider?.request?.() && env.rapierProviders !== false && !_mathPromptedOnce) {
+			if (!mathReady && !env.rapierPassive && !mathProvider?.request?.() && env.rapierProviders !== false && !_mathPromptedOnce) {
 				_mathPromptedOnce = true;
 				try { _rapierUiMath.request(); } catch (_) {}
 			}
 			const ready = diagramReady && mathReady;
-			if (!diagramReady && !provider?.request?.() && env.rapierProviders !== false && !_diagramPromptedOnce) {
+			if (!diagramReady && !env.rapierPassive && !provider?.request?.() && env.rapierProviders !== false && !_diagramPromptedOnce) {
 				_diagramPromptedOnce = true;
 				try { _rapierUiDiagram.request(); } catch (_) {}
 			}
@@ -420,7 +425,7 @@ function initMarkdownIt() {
 			if (env.rapierPage) return sourceHtml;
 			const mathProvider = env.rapierProviders === false ? null : _rapierProviders.math;
 			if (!mathProvider || mathProvider.status !== 'ready' || typeof mathProvider.renderToString !== 'function') {
-				if (!mathProvider?.request?.() && env.rapierProviders !== false && !_mathPromptedOnce) {
+				if (!env.rapierPassive && !mathProvider?.request?.() && env.rapierProviders !== false && !_mathPromptedOnce) {
 					_mathPromptedOnce = true;
 					try { _rapierUiMath.request(); } catch (_) {}
 				}
@@ -454,10 +459,215 @@ function initMarkdownIt() {
 	globalThis.RapierImageAssets.configureParser(md, _rapierSplitOpeningFrontmatter);
 	const render = md.renderer.render;
 	md.renderer.render = function (tokens, options, env) {
-		return render.call(this, _rapierCloseOpenDetails(tokens), options, env);
+		return render.call(this, _rapierHideForeignParagraphs(_rapierCloseOpenDetails(tokens)), options, env);
 	};
 }
 
+function _rapierHtmlTagStack(html, stack = []) {
+	if (!html) return stack;
+	const swallow = _rapierHtmlTagStack.swallow || (_rapierHtmlTagStack.swallow = new Set('select template textarea title style xmp plaintext noscript iframe noembed noframes script svg math'.split(' ')));
+	const rawTags = _rapierHtmlTagStack.raw || (_rapierHtmlTagStack.raw = new Set('script style textarea title xmp iframe noembed noframes noscript plaintext'.split(' ')));
+	let i = 0;
+	while (i < html.length) {
+		const top = stack.at(-1);
+		if (top && top.raw) {
+			const closer = new RegExp('</' + top.name + '(?=[\\t\\n\\f\\r />])', 'ig');
+			closer.lastIndex = i;
+			const found = closer.exec(html);
+			if (!found) break;
+			i = found.index;
+		}
+		const open = html.indexOf('<', i);
+		if (open < 0) break;
+		if (html.startsWith('<!--', open)) {
+			const end = html.indexOf('-->', open + 4);
+			if (end < 0) break;
+			i = end + 3;
+			continue;
+		}
+		if (html.startsWith('<!', open) || html.startsWith('<?', open)) {
+			const end = html.indexOf('>', open + 2);
+			i = end < 0 ? html.length : end + 1;
+			continue;
+		}
+		const match = /^<\/?([A-Za-z][A-Za-z0-9:-]*)/.exec(html.slice(open));
+		if (!match) { i = open + 1; continue; }
+		const name = match[1].toLowerCase();
+		let end = open + match[0].length, quote = '';
+		for (; end < html.length; end++) {
+			const character = html[end];
+			if (quote) { if (character === quote) quote = ''; }
+			else if (character === '"' || character === "'") quote = character;
+			else if (character === '>') break;
+		}
+		if (end >= html.length) break;
+		if (html[open + 1] === '/') {
+			let at = stack.length - 1;
+			while (at >= 0 && stack[at].name !== name && !swallow.has(stack[at].name)) at--;
+			if (at >= 0 && stack[at].name === name) stack.length = at;
+		} else stack.push({name, at: open, tagEnd: end + 1, raw: rawTags.has(name)});
+		i = end + 1;
+	}
+	return stack;
+}
+function _rapierForeignOpen(stack) {
+	for (let index = 0; index < stack.length; index++) {
+		const name = stack[index].name;
+		if (name === 'svg' || name === 'math') return true;
+	}
+	return false;
+}
+function _rapierSealBlockHtml(html) {
+	if (!html || html.indexOf('<') < 0) return html;
+	const stack = _rapierHtmlTagStack(html);
+	const swallow = _rapierHtmlTagStack.swallow;
+	const foreign = _rapierSealBlockHtml.foreign || (_rapierSealBlockHtml.foreign = new Set(['svg', 'math']));
+	const cut = stack.find(frame => swallow.has(frame.name) && (frame.raw || foreign.has(frame.name)));
+	if (cut) {
+		const wrappers = stack.filter(frame => frame.at < cut.at);
+		return html.slice(0, cut.at) + _rapierSealBlockTail(html.slice(cut.at), wrappers);
+	}
+	const stale = stack.filter(frame => swallow.has(frame.name));
+	if (!stale.length) return html;
+	let out = html;
+	for (const frame of stale.sort((left, right) => right.at - left.at))
+		out = out.slice(0, frame.at) + escapeRapierHtmlText(out.slice(frame.at, frame.tagEnd)) + out.slice(frame.tagEnd);
+	return out;
+}
+
+function _rapierSealBlockTail(tail, wrappers) {
+	const open = wrappers.map(frame => frame.name);
+	let out = '', i = 0;
+	while (i < tail.length) {
+		const at = tail.indexOf('<', i);
+		if (at < 0) { out += escapeRapierHtmlText(tail.slice(i)); break; }
+		out += escapeRapierHtmlText(tail.slice(i, at));
+		const match = /^<\/([A-Za-z][A-Za-z0-9:-]*)\s*>/.exec(tail.slice(at));
+		if (match && open.at(-1) === match[1].toLowerCase()) {
+			out += match[0];
+			open.pop();
+			i = at + match[0].length;
+			continue;
+		}
+		out += escapeRapierHtmlText(tail[at]);
+		i = at + 1;
+	}
+	return out;
+}
+
+function _rapierRenderTokenHtml(tokens, index, env) {
+	const token = tokens[index], rule = md.renderer.rules[token.type];
+	return token.type === 'inline' ? md.renderer.renderInline(token.children, md.options, env)
+		: rule ? rule(tokens, index, md.options, env, md.renderer) : md.renderer.renderToken(tokens, index, md.options);
+}
+
+function _rapierTokenBlocks(tokens) {
+	const blocks = [];
+	let start = 0, depth = 0;
+	for (let index = 0; index < tokens.length; index++) {
+		depth += tokens[index].nesting || 0;
+		if (depth <= 0) { blocks.push([start, index + 1]); start = index + 1; depth = 0; }
+	}
+	if (start < tokens.length) blocks.push([start, tokens.length]);
+	return blocks;
+}
+function _rapierScanHtmlBlocks(tokens, start, end, stack) {
+	for (let index = start; index < end; index++) {
+		if (tokens[index].type === 'html_block') _rapierHtmlTagStack(tokens[index].content || '', stack);
+	}
+	return stack;
+}
+function _rapierForeignSealRanges(tokens) {
+	const blocks = _rapierTokenBlocks(tokens);
+	const ranges = [];
+	const scanLater = ([start, end], frames) => {
+		if (tokens[start].type !== 'paragraph_open') return _rapierScanHtmlBlocks(tokens, start, end, frames);
+		for (const child of tokens[start + 1] && tokens[start + 1].children || [])
+			if (child.type === 'html_inline') _rapierHtmlTagStack(child.content || '', frames);
+		return frames;
+	};
+	for (let index = 0; index < blocks.length; index++) {
+		const stack = _rapierScanHtmlBlocks(tokens, blocks[index][0], blocks[index][1], []);
+		if (!_rapierForeignOpen(stack)) { ranges.push(blocks[index]); continue; }
+		const frames = stack.map(frame => ({name: frame.name, raw: frame.raw}));
+		let joined = -1;
+		for (let later = index + 1; later < blocks.length && later <= index + 512; later++) {
+			scanLater(blocks[later], frames);
+			if (!_rapierForeignOpen(frames)) { joined = later; break; }
+		}
+		if (joined < 0) { ranges.push(blocks[index]); continue; }
+		const range = [blocks[index][0], blocks[joined][1]];
+		for (let later = index + 1; later <= joined; later++) {
+			const [start, end] = blocks[later];
+			if (tokens[start].type === 'paragraph_open' && tokens[end - 1].type === 'paragraph_close' &&
+				(tokens[start + 1] && tokens[start + 1].children || []).some(child => child.type === 'html_inline'))
+				(range.hide || (range.hide = new Set())).add(start).add(end - 1);
+		}
+		ranges.push(range);
+		index = joined;
+	}
+	return ranges;
+}
+function _rapierHideForeignParagraphs(tokens) {
+	let out = tokens;
+	for (const range of _rapierForeignSealRanges(tokens)) {
+		if (!range.hide) continue;
+		if (out === tokens) out = tokens.slice();
+		for (const index of range.hide) out[index] = Object.assign(Object.create(Object.getPrototypeOf(tokens[index])), tokens[index], {hidden: true});
+	}
+	return out;
+}
+function _rapierMergeForeignBlocks(blocks, source, parser) {
+	const text = String(source || '');
+	const out = [];
+	const inline = new Map();
+	const scanLater = (row, frames) => {
+		if (!row) return frames;
+		if (row.type === 'html_block') return _rapierHtmlTagStack(String(row.raw || ''), frames);
+		if (row.type !== 'paragraph' || String(row.raw || '').indexOf('<') < 0) return frames;
+		let children = inline.get(row);
+		if (!children) {
+			if (!parser && !md) initMarkdownIt();
+			const parsed = (parser || md).parseInline(String(row.raw || ''), {});
+			children = parsed[0] && parsed[0].children || [];
+			inline.set(row, children);
+		}
+		for (const child of children) if (child.type === 'html_inline') _rapierHtmlTagStack(child.content || '', frames);
+		return frames;
+	};
+	let index = 0;
+	while (index < blocks.length) {
+		const block = blocks[index];
+		const stack = [];
+		if (block && block.type === 'html_block') _rapierHtmlTagStack(String(block.raw || ''), stack);
+		if (!_rapierForeignOpen(stack)) { out.push(block); index++; continue; }
+		const frames = stack.map(frame => ({name: frame.name, raw: frame.raw}));
+		let joined = -1;
+		for (let later = index + 1; later < blocks.length && later <= index + 512; later++) {
+			scanLater(blocks[later], frames);
+			if (!_rapierForeignOpen(frames)) { joined = later; break; }
+		}
+		if (joined < 0) { out.push(block); index++; continue; }
+		const start = Number(block._sourceStart), end = Number(blocks[joined]._sourceEnd);
+		const raw = Number.isFinite(start) && Number.isFinite(end) && start >= 0 && end >= start && end <= text.length
+			? text.slice(start, end)
+			: blocks.slice(index, joined + 1).map(row => String(row && row.raw || '')).join('\n\n');
+		out.push({...block, raw, _sourceEnd: Number.isFinite(end) ? end : block._sourceEnd, rendered: null});
+		index = joined + 1;
+	}
+	out._rapierFacts = Array.isArray(blocks && blocks._rapierFacts) ? blocks._rapierFacts.slice() : [];
+	return out;
+}
+function _rapierRenderSealedHtml(tokens, env) {
+	let html = '';
+	for (const range of _rapierForeignSealRanges(tokens)) {
+		let block = '';
+		for (let index = range[0]; index < range[1]; index++) block += range.hide && range.hide.has(index) ? (tokens[index].nesting < 0 ? '\n' : '') : _rapierRenderTokenHtml(tokens, index, env);
+		html += _rapierSealBlockHtml(block);
+	}
+	return html;
+}
+
 function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	const root = document.createElement('template').content.ownerDocument.createElement('div');
 	root.setAttribute('data-rapier-semantic-root', 'true');
@@ -476,24 +686,28 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	}
 
 	const markdown = _rapierSplitOpeningFrontmatter(canonical).body;
-	const env = {rapierImagePresentation: options.imagePresentation === true, ...(options.page ? {rapierPage: true} : {}), ...(options.providers === false ? {rapierProviders: false} : {})};
+	const env = {rapierImagePresentation: options.imagePresentation === true, rapierPassive: options.passive === true, ...(options.page ? {rapierPage: true} : {}), ...(options.providers === false ? {rapierProviders: false} : {})};
 	if (options.wikiEmbedding) env.rapierWikiEmbedding = true;
 	const wikiLinks = wikiMode(options);
 	if (wikiLinks) env.rapierWikiLinks = wikiLinks;
 	if (options.mathEquations) env.rapierMathEquations = options.mathEquations;
 	const nesting = md && options.maxNesting > 0 ? options.maxNesting : 0;
-	let cutAt = -1, rendered;
-	if (nesting || md && options.closeDetails) {
+	let cutAt = -1, rendered = '';
+	codeLeft = options.codeBudget >= 0 ? options.codeBudget : Infinity;
+	try {
+	if (!md) rendered = '<pre><code>' + escapeRapierHtmlText(markdown) + '</code></pre>';
+	else {
 		const saved = md.options.maxNesting;
 		if (nesting) md.options.maxNesting = nesting;
 		try {
-			const tokens = md.parse(markdown, env);
+			let tokens = md.parse(markdown, env);
 			if (nesting) cutAt = _rapierNestingCutAt(tokens, nesting);
-			rendered = md.renderer.render(options.closeDetails ? _rapierCloseOpenDetails(tokens) : tokens, md.options, env);
+			tokens = _rapierCloseOpenDetails(tokens);
+			rendered = _rapierRenderSealedHtml(tokens, env);
+			if (md.renderer.rapierTransformHtml) rendered = md.renderer.rapierTransformHtml(rendered);
 		} finally { md.options.maxNesting = saved; }
-	} else rendered = md
-		? md.render(markdown, env)
-		: '<pre><code>' + escapeRapierHtmlText(markdown) + '</code></pre>';
+	}
+	} finally { codeLeft = Infinity; }
 	if (md && env.footnotes && Array.isArray(env.footnotes.list) && env.footnotes.list.length) {
 		const labels = env.footnotes.list.map((item, index) =>
 			String(item && item.label || ('inline-' + (index + 1))));
@@ -503,14 +717,14 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	if (cutAt >= 0) _rapierAppendNestingCut(root, markdown, cutAt);
 	_rapierApplyBlockDirection(root);
 
-	_rapierAssignHeadingSlugs(root, RAPIER_RENDERED_HEADING_SELECTOR, false);
+	_rapierAssignHeadingSlugs(root, RAPIER_RENDERED_HEADING_SELECTOR, false, options.carry?.slugs, options.carry?.headingIds);
 	_rapierDisambiguateRenderedAnchors(root);
 
 	root.querySelectorAll('pre > code').forEach(_rapierNormalizeCodeElement);
-	_rapierMarkTableCaptions(root);
+	_rapierMarkTableCaptions(root, options.carry);
 	_rapierMarkFigureCaptions(root);
 	_rapierMarkListContinuations(_rapierChildElements(root));
-	_rapierDecorateJumpLists(root);
+	_rapierDecorateJumpLists(root, options.carry);
 	return root;
 }
 
@@ -543,12 +757,13 @@ async function _rapierRenderSemanticRootAsync(canonical, metadata, options = {})
 	let {tokens, env} = parsed, labels = env.footnotes?.list?.map((item, index) => String(item?.label || ('inline-' + (index + 1))));
 	const cutAt = nesting ? _rapierNestingCutAt(tokens, nesting) : -1;
 	tokens = _rapierCloseOpenDetails(tokens);
-	env = {...env, rapierImagePresentation: options.imagePresentation === true};
+	env = {...env, rapierImagePresentation: options.imagePresentation === true, rapierPassive: options.passive === true};
 	await pause(work, .3);
 	const inert = document.createElement('template').content.ownerDocument;
 	const root = inert.createElement('div'), part = inert.createElement('div'), boundary = htmlBoundary();
 	root.setAttribute('data-rapier-semantic-root', 'true');
 	let html = '', began = performance.now(), complete = false;
+	codeLeft = options.codeBudget >= 0 ? options.codeBudget : Infinity;
 	const append = () => {
 		if (md.renderer.rapierTransformHtml) html = md.renderer.rapierTransformHtml(html);
 		if (labels?.length) html = _relabelFootnoteHtml(html, labels);
@@ -556,37 +771,90 @@ async function _rapierRenderSemanticRootAsync(canonical, metadata, options = {})
 		while (part.firstChild) root.appendChild(part.firstChild);
 		html = '';
 	};
+	const finishBlock = block => {
+		const sealed = _rapierSealBlockHtml(block);
+		html += sealed;
+		if (boundary(sealed) && html.length >= 16384) append();
+	};
 	try {
-		for (let index = 0; index < tokens.length; index++) {
-			const token = tokens[index], rule = md.renderer.rules[token.type];
-			let rendered = token.type === 'inline' ? md.renderer.renderInline(token.children, md.options, env)
-				: rule ? rule(tokens, index, md.options, env, md.renderer) : md.renderer.renderToken(tokens, index, md.options);
-			html += rendered;
-			if (boundary(rendered) && html.length >= 16384) append();
-			if (performance.now() - began >= 8) {
-				await pause(work, .3 + .2 * (index + 1) / tokens.length);
-				began = performance.now();
+		for (const range of _rapierForeignSealRanges(tokens)) {
+			let block = '';
+			for (let index = range[0]; index < range[1]; index++) {
+				block += range.hide && range.hide.has(index) ? (tokens[index].nesting < 0 ? '\n' : '') : _rapierRenderTokenHtml(tokens, index, env);
+				if (performance.now() - began >= 8) {
+					await pause(work, .3 + .2 * (index + 1) / tokens.length);
+					began = performance.now();
+				}
 			}
+			finishBlock(block);
 		}
 		if (html) append();
 		if (cutAt >= 0) _rapierAppendNestingCut(root, markdown, cutAt);
 		parsed = tokens = env = labels = null;
-		await finishAsync(_rapierSemanticDecorations(root), work);
+		await finishAsync(_rapierSemanticDecorations(root, options.carry), work);
 		await pause(work, .6);
 		complete = true;
 		return root;
-	} finally { if (!complete) { root.replaceChildren(); part.replaceChildren(); } }
+	} finally { codeLeft = Infinity; if (!complete) { root.replaceChildren(); part.replaceChildren(); } }
+}
+
+function _rapierPartDecorationGroups(tokens) {
+	const groups = [];
+	for (let at = 0; at < tokens.length; at++) {
+		const first = tokens[at];
+		if (first.type !== 'heading_open' && first.type !== 'table_open') continue;
+		const close = first.type === 'heading_open' ? 'heading_close' : 'table_close';
+		let end = at + 1;
+		while (end < tokens.length && !(tokens[end].type === close && tokens[end].level === first.level)) end++;
+		end++;
+		if (first.type === 'table_open' && tokens[end]?.type === 'paragraph_open' && tokens[end].level === first.level) {
+			while (end < tokens.length && !(tokens[end].type === 'paragraph_close' && tokens[end].level === first.level)) end++;
+			end++;
+		}
+		groups.push(tokens.slice(at, end));
+		at = end - 1;
+	}
+	return groups;
+}
+
+function _rapierReadPartDecorations(canonical, metadata, options = {}) {
+	const carry = options.carry || {slugs: Object.create(null), captions: 0, continued: true}, captionStart = carry.captions || 0;
+	const markdown = _rapierSplitOpeningFrontmatter(canonical).body, env = {rapierImagePresentation: options.imagePresentation === true, rapierPassive: true, rapierPartDecorations: true,
+		...(options.page ? {rapierPage: true} : {}), ...(options.providers === false ? {rapierProviders: false} : {})};
+	if (options.wikiEmbedding) env.rapierWikiEmbedding = true;
+	const wikiLinks = wikiMode(options);
+	if (wikiLinks) env.rapierWikiLinks = wikiLinks;
+	if (options.mathEquations) env.rapierMathEquations = options.mathEquations;
+	const saved = md.options.maxNesting;
+	let tokens;
+	try {
+		if (options.maxNesting > 0) md.options.maxNesting = options.maxNesting;
+		tokens = md.parse(markdown, env);
+	} finally { md.options.maxNesting = saved; }
+	if (tokens.some(token => token.type === 'html_block' || token.type === 'math_block' || token.type.startsWith('footnote_') ||
+			token.type === 'inline' && token.children?.some(child => child.type === 'html_inline' || child.type === 'math_inline' || child.type.startsWith('footnote_')))) {
+		const root = _rapierRenderSemanticRoot(canonical, metadata, {...options, carry, codeBudget: 0, passive: true});
+		return Object.freeze({headingIds: Object.freeze([...root.querySelectorAll(RAPIER_RENDERED_HEADING_SELECTOR)].map(heading => heading.id)), captionStart});
+	}
+	const html = [];
+	for (const group of _rapierPartDecorationGroups(tokens)) html.push('<div>', md.renderer.render(group, md.options, env), '</div>');
+	const root = document.createElement('template').content.ownerDocument.createElement('div');
+	root.innerHTML = sanitizeRapierHtml(html.join(''), 'export');
+	_rapierAssignHeadingSlugs(root, RAPIER_RENDERED_HEADING_SELECTOR, false, carry.slugs);
+	const headingIds = Object.freeze([...root.querySelectorAll(RAPIER_RENDERED_HEADING_SELECTOR)].map(heading => heading.id));
+	_rapierMarkTableCaptions(root, carry);
+	return Object.freeze({headingIds, captionStart});
 }
 
-function* _rapierSemanticDecorations(root) {
+function* _rapierSemanticDecorations(root, carry = null) {
 	yield* _rapierApplyBlockDirectionSteps(root); yield;
-	yield* _rapierAssignHeadingSlugsSteps(root, RAPIER_RENDERED_HEADING_SELECTOR, false); yield;
+	yield* _rapierAssignHeadingSlugsSteps(root, RAPIER_RENDERED_HEADING_SELECTOR, false, carry?.slugs, carry?.headingIds); yield;
 	yield* _rapierDisambiguateRenderedAnchorsSteps(root); yield;
 	for (const code of root.querySelectorAll('pre > code')) { _rapierNormalizeCodeElement(code); yield; }
-	yield* _rapierMarkTableCaptionsSteps(root); yield;
+	yield* _rapierMarkTableCaptionsSteps(root, carry); yield;
 	yield* _rapierMarkFigureCaptionsSteps(root); yield;
 	yield* _rapierMarkListContinuationsSteps(_rapierChildElements(root)); yield;
-	yield* _rapierDecorateJumpListsSteps(root); yield;
+	yield* _rapierDecorateJumpListsSteps(root, carry); yield;
 }
 
 function _rapierInstallSemanticProbe(instance) {
@@ -931,17 +1199,23 @@ function _rapierFirstStrongDir(text) {
 
 const _RAPIER_DIR_BLOCKS = 'p,h1,h2,h3,h4,h5,h6,li,blockquote,ul,ol,dt,dd,td,th';
 
-function _rapierAssignHeadingSlugs(root, selector, reserveExisting) { return finish(_rapierAssignHeadingSlugsSteps(root, selector, reserveExisting)); }
+function _rapierAssignHeadingSlugs(root, selector, reserveExisting, taken, assigned) { return finish(_rapierAssignHeadingSlugsSteps(root, selector, reserveExisting, taken, assigned)); }
 
-function* _rapierAssignHeadingSlugsSteps(root, selector = RAPIER_RENDERED_HEADING_SELECTOR, reserveExisting = true) {
+function* _rapierAssignHeadingSlugsSteps(root, selector = RAPIER_RENDERED_HEADING_SELECTOR, reserveExisting = true, taken = null, assigned = null) {
 	if (!root || !root.querySelectorAll) return;
-	const used = Object.create(null);
+	const used = taken || Object.create(null);
 	const headings = _rapierDormantHeadings(root, selector, true);
+	if (assigned && assigned.length !== headings.length) {
+		try { console.warn('[rapier-reader] Part heading facts do not match its rendered headings; assigning ordinary heading IDs.'); } catch (_) {}
+		assigned = null;
+	}
 	const headingSet = new Set(headings);
 	if (reserveExisting) for (const element of _rapierDormantHeadings(root.isConnected ? document : root, '[id]', true)) { yield;
 		if (!headingSet.has(element) && element.id) used[element.id] = 0;
 	}
+	let index = 0;
 	for (const heading of headings) { yield;
+		if (assigned) { heading.id = assigned[index++]; continue; }
 		const base = _rapierHeadingSlugBase(heading.textContent);
 		const owned = typeof _rapierChromeOwnsId === 'function' && _rapierChromeOwnsId(base);
 		heading.id = _rapierNextHeadingSlug(owned ? 'heading-' + base : base, used);
@@ -1042,9 +1316,9 @@ function _rapierDecodeHash(hash) {
 	catch (_) { return raw; }
 }
 
-function _rapierDecorateJumpLists(root) { return finish(_rapierDecorateJumpListsSteps(root)); }
+function _rapierDecorateJumpLists(root, carry) { return finish(_rapierDecorateJumpListsSteps(root, carry)); }
 
-function* _rapierDecorateJumpListsSteps(root) {
+function* _rapierDecorateJumpListsSteps(root, carry = null) {
 	for (const list of root.querySelectorAll('ul')) { yield;
 		if (list.closest('li')) continue;
 		const items = Array.from(list.children).filter(item => item.tagName === 'LI');
@@ -1067,7 +1341,7 @@ function* _rapierDecorateJumpListsSteps(root) {
 		}
 	}
 
-	const first = root.firstElementChild, only = first && !first.nextElementSibling ? first : null;
+	const first = root.firstElementChild, only = !carry && first && !first.nextElementSibling ? first : null;
 	if (only && only.tagName === 'P' && /^(?:jump\s+to|contents|table\s+of\s+contents):?$/i.test(String(only.textContent || '').trim())) {
 		only.classList.add('rapier-jump-label-candidate');
 	}
@@ -1109,11 +1383,11 @@ function* _rapierMarkListContinuationsSteps(blocks, mark = (element, name) => el
 	}
 }
 
-function _rapierMarkTableCaptions(root) { return finish(_rapierMarkTableCaptionsSteps(root)); }
+function _rapierMarkTableCaptions(root, carry) { return finish(_rapierMarkTableCaptionsSteps(root, carry)); }
 
-function* _rapierMarkTableCaptionsSteps(root) {
+function* _rapierMarkTableCaptionsSteps(root, carry = null) {
 	const used = new Set(Array.from(root.querySelectorAll('[id]'), element => element.id));
-	let ordinal = 0;
+	let ordinal = carry?.captions || 0;
 	for (const table of root.querySelectorAll('table')) { yield;
 		const sibling = table.nextElementSibling;
 		if (!sibling || sibling.tagName !== 'P') continue;
@@ -1126,6 +1400,7 @@ function* _rapierMarkTableCaptionsSteps(root) {
 		const existing = (table.getAttribute('aria-describedby') || '').trim();
 		table.setAttribute('aria-describedby', existing ? existing + ' ' + id : id);
 	}
+	if (carry) carry.captions = ordinal;
 }
 
 
@@ -1829,7 +2104,7 @@ function renderWithMathML(source, metadata = {}) {
 	return {html, equations};
 }
 
-  return {renderWithMathML, _rapierClipboardPayloadAsync, _rapierPlainTextFileAsync, _rapierCloneRootAsync, _rapierPortablePlainTextAsync, _rapierHeldPicturesAsWordsAsync, _rapierRenderSemanticRootAsync, _rapierProjectPortableRootAsync, _rapierPortableHtmlAsync, _rapierCalloutInfo, _rapierRemoveCalloutMarker, _rapierMathSource, _rapierFlattenPortableDetails, _rapierProjectPortableRoot, _rapierPortableHtml, _rapierNormalizeInlineText, _rapierPortableInlineText, _rapierPortableListText, _rapierPortableTableText, _rapierPortablePlainText, _rapierPlainTextFile, _rapierHeldPicturesAsWords, _rapierSourceTokenValue, _rapierResolveSoftBreakTokens, _rapierInertParse, _rapierUnwrapElement, _rapierBidiStrong, render: (source, metadata = {}) => { if (!md) initMarkdownIt(); return _rapierRenderSemanticRoot(source, metadata).innerHTML; }, initMarkdownIt, _rapierRenderSemanticRoot, _rapierInstallSemanticProbe, _rapierApplyImageGeometry, _rapierImageAltSize, _rapierImageAltSourceParts, _rapierImageAltText, _rapierImageSizeAttributes, _rapierRawHtmlFragment, _rapierApplyBlockDirection, _rapierFirstStrongDir, _rapierAssignHeadingSlugs, _rapierDisambiguateRenderedAnchors, _rapierDecodeHash, _rapierDecorateJumpLists, _rapierMarkFigureCaptions, _rapierMarkListContinuations, _rapierMarkTableCaptions, _rapierNormalizeCodeElement, _rapierLanguageClass, _relabelFootnoteHtml, _footnoteIdFromLabel, wrapDisplayMath, parser: () => md};
+  return {_rapierReadPartDecorations, renderWithMathML, _rapierClipboardPayloadAsync, _rapierPlainTextFileAsync, _rapierCloneRootAsync, _rapierPortablePlainTextAsync, _rapierHeldPicturesAsWordsAsync, _rapierRenderSemanticRootAsync, _rapierProjectPortableRootAsync, _rapierPortableHtmlAsync, _rapierCalloutInfo, _rapierRemoveCalloutMarker, _rapierMathSource, _rapierFlattenPortableDetails, _rapierProjectPortableRoot, _rapierPortableHtml, _rapierNormalizeInlineText, _rapierPortableInlineText, _rapierPortableListText, _rapierPortableTableText, _rapierPortablePlainText, _rapierPlainTextFile, _rapierHeldPicturesAsWords, _rapierSourceTokenValue, _rapierResolveSoftBreakTokens, _rapierInertParse, _rapierUnwrapElement, _rapierBidiStrong, _rapierSealBlockHtml, _rapierMergeForeignBlocks, render: (source, metadata = {}) => { if (!md) initMarkdownIt(); return _rapierRenderSemanticRoot(source, metadata).innerHTML; }, initMarkdownIt, _rapierRenderSemanticRoot, _rapierInstallSemanticProbe, _rapierApplyImageGeometry, _rapierImageAltSize, _rapierImageAltSourceParts, _rapierImageAltText, _rapierImageSizeAttributes, _rapierRawHtmlFragment, _rapierApplyBlockDirection, _rapierFirstStrongDir, _rapierAssignHeadingSlugs, _rapierDisambiguateRenderedAnchors, _rapierDecodeHash, _rapierDecorateJumpLists, _rapierMarkFigureCaptions, _rapierMarkListContinuations, _rapierMarkTableCaptions, _rapierNormalizeCodeElement, _rapierLanguageClass, _relabelFootnoteHtml, _footnoteIdFromLabel, wrapDisplayMath, parser: () => md};
 }
 export {RAPIER_TABLE_CAPTION_PREFIX_RE as tableCaptionPrefix, RAPIER_PORTABLE_HIGHLIGHT_HEX as portableHighlightHex, _RAPIER_RTL_SCRIPT as rtlScripts, createMarkdownRenderer};
 

package/dist/kit/render-sanitize.mjs

@@ -69,7 +69,8 @@ function cleanDocumentStyle(tag, value, context, classes = '') {
 		const property = part.slice(0, colon).trim().toLowerCase(), body = part.slice(colon + 1).trim();
 		const diagramProperty = diagram && /^--(?:_[a-z0-9_-]+|pele-[a-z0-9-]+)$/.test(property);
 		if (!DOCUMENT_STYLE_PROPERTIES.has(property) && !/^--md-[a-z0-9-]+$/.test(property) && !diagramProperty && !(diagram && property === 'font')) return;
-		if (!body || /[\\\u0000-\u0008\u000b\u000e-\u001f{}@]|\/\*|\*\//.test(body)) return;
+		if (!body || /[\u0000-\u0008\u000b\u000e-\u001f{}@]|\/\*|\*\//.test(body) ||
+			/["'\\]/.test(body.replace(/"(?:[^"\\\n\r\f]|\\["\\])*"|'(?:[^'\\\n\r\f]|\\['\\])*'/g, ''))) return;
 		const withoutLocal = body.replace(/\burl\(\s*(['"]?)#[a-z0-9_.:-]+\1\s*\)/gi, '');
 		if (/(?:url|image|image-set|-webkit-image-set|element|paint|attr|expression)\s*\(/i.test(withoutLocal)) return;
 		kept.push(part.trim());
@@ -304,6 +305,31 @@ function _rapierInstallSanitizeHooks() {
 		if (level) node.setAttribute('data-rapier-word-level', String(level));
 		else if (node.nodeName === 'SPAN' && wordListIsMarker(style)) node.setAttribute('data-rapier-word-marker', '1');
 	});
+	DOMPurify.addHook('uponSanitizeElement', node => {
+		if (_rapierSanitizeRuntime.context !== 'paste' || !node || node.nodeName !== 'TABLE') return;
+		node.removeAttribute('data-rapier-paste-word-header');
+		try {
+			const own = (node.getAttribute('style') || '') + ' ' + (node.getAttribute('class') || '');
+			const word = /mso-yfti-|MsoTable/i.test(own) || !!node.querySelector('[style*="mso-"],[class*="Mso"]');
+			if (!word || node.tHead || node.querySelector('th')) return;
+			const row = Array.from(node.querySelectorAll('tr')).find(candidate => candidate.closest('table') === node);
+			if (!row) return;
+			const cells = Array.from(row.children).filter(cell => cell.nodeName === 'TD' || cell.nodeName === 'TH');
+			if (!cells.length) return;
+			let bold = false;
+			for (const cell of cells) {
+				const walker = node.ownerDocument.createTreeWalker(cell, NodeFilter.SHOW_TEXT);
+				for (let text = walker.nextNode(); text; text = walker.nextNode()) {
+					if (!/\S/.test(text.nodeValue || '')) continue;
+					const parent = text.parentElement;
+					const style = parent?.getAttribute?.('style') || '';
+					if (!(parent && (parent.closest('b,strong') || /font-weight\s*:\s*(?:bold|[6-9]00|1000)\b/i.test(style)))) return;
+					bold = true;
+				}
+			}
+			if (bold) node.setAttribute('data-rapier-paste-word-header', '');
+		} catch (_) {}
+	});
 }
 
 function _rapierInstallDocumentSanitizeHooks() {
@@ -414,9 +440,17 @@ function sanitize(value, context, fragment) {
 	if (purifyConfigured.get(DOMPurify) !== options) { DOMPurify.setConfig(options); purifyConfigured.set(DOMPurify, options); }
 	const previous = _rapierSanitizeRuntime.context;
 	_rapierSanitizeRuntime.context = selected;
+	ensureScratchParseHook();
+	const scratch = [];
+	const outerSink = scratchSink;
+	scratchSink = scratch;
+	let result;
 	try {
-		return DOMPurify.sanitize(value == null ? '' : String(value));
+		result = DOMPurify.sanitize(value == null ? '' : String(value));
+		return result;
 	} finally {
+		scratchSink = outerSink;
+		releaseScratchMedia(scratch, result);
 		if (labels) {
 			DOMPurify.removeHook('uponSanitizeElement', diagramLabelElement);
 			DOMPurify.removeHook('uponSanitizeAttribute', diagramLabelAttribute);
@@ -426,6 +460,37 @@ function sanitize(value, context, fragment) {
 	}
 }
 
+let scratchSink = null;
+function ensureScratchParseHook() {
+	if (typeof DOMParser !== 'function' || DOMParser.prototype.parseFromString._rapierScratch) return;
+	const original = DOMParser.prototype.parseFromString;
+	function wrapped(source, type) {
+		const doc = original.call(this, source, type);
+		scratchSink?.push(doc);
+		return doc;
+	}
+	wrapped._rapierScratch = true;
+	DOMParser.prototype.parseFromString = wrapped;
+}
+
+function releaseScratchMedia(docs, result) {
+	const kept = result && typeof result === 'object' ? result.nodeType === 9 ? result : result.ownerDocument : null;
+	for (const doc of docs) {
+		if (!doc || doc === kept || !doc.querySelectorAll) continue;
+		for (const el of [...doc.querySelectorAll('video, audio')]) releaseMediaElement(el);
+	}
+}
+function releaseMediaElement(el) {
+	if (!el || (el.nodeName !== 'VIDEO' && el.nodeName !== 'AUDIO')) return;
+	try {
+		el.pause();
+		el.removeAttribute('src');
+		for (const source of el.querySelectorAll('source')) source.removeAttribute('src');
+		el.load();
+	} catch (_) {}
+	el.remove();
+}
+
 function escapeRapierHtmlText(value) {
 	return String(value == null ? '' : value)
 		.replace(/&/g, '&')

package/dist/kit/render.mjs

@@ -289,15 +289,21 @@ function* _rapierProjectStyledRootSteps(semanticRoot, options) {
 		if (code) {
 			const lang = _rapierLanguageClass(code) || String(metadata.codeLang || '');
 			code.classList.add('artifact-code');
-			if (metadata.docKind === 'code') _rapierPaintCode(code, _rapierArtifactHighlight(code.textContent || '', lang));
+			if (metadata.docKind === 'code') {
+				const colored = _rapierArtifactHighlight(code.textContent || '', lang);
+				_rapierPaintCode(code, opts.sanitized ? sanitizeRapierHtml(colored, 'export') : colored);
+			}
 			if (lang) code.classList.add('language-' + String(lang).replace(/[^a-z0-9_-]/gi, ''));
 		}
 	} else {
+		let codeLeft = opts.codeBudget >= 0 ? opts.codeBudget : Infinity;
 		for (const code of root.querySelectorAll('pre > code')) { yield;
 			if (code.parentElement?.classList.contains('diagram-source') &&
 					code.closest('.diagram-block')?.getAttribute('data-diagram-state') === 'ready') continue;
 			const lang = _rapierLanguageClass(code) || 'text';
-			_rapierPaintCode(code, _rapierArtifactHighlight(code.textContent || '', lang));
+			if ((codeLeft -= code.textContent.length) < 0) { code.replaceChildren(document.createTextNode(code.textContent)); continue; }
+			const colored = _rapierArtifactHighlight(code.textContent || '', lang);
+			_rapierPaintCode(code, opts.sanitized ? sanitizeRapierHtml(colored, 'export') : colored);
 		}
 
 		for (const table of root.querySelectorAll('table')) { yield;
@@ -336,6 +342,13 @@ function* _rapierProjectStyledRootSteps(semanticRoot, options) {
 
 	yield* _rapierPrefixPortableAnchorsSteps(root, opts.baseName || metadata.filename || 'document');
 
+	if (opts.sanitized) {
+		for (const cache of root.querySelectorAll('.diagram-cache')) {
+			yield;
+			cache.innerHTML = sanitizeRapierHtml(cache.innerHTML, 'export');
+		}
+		return root;
+	}
 	return yield* cleanTree(root, sanitizeRapierHtml, 'export');
 }
 
@@ -712,7 +725,7 @@ function* _rapierSharedPageLayoutSteps(root) {
 	for (const image of root.querySelectorAll('img[data-rapier-image-layout]')) {
 		yield;
 		const layout = globalThis.RapierMarkdownLayout.parseLayoutAttribute(image.getAttribute('data-rapier-image-layout'));
-		if (layout?.wrap !== 'around' && layout?.wrap !== 'box') continue;
+		if (layout?.wrap !== 'around' && layout?.wrap !== 'beside' && layout?.wrap !== 'box') continue;
 		const paragraph = _rapierSharePictureParagraph(image);
 		if (!paragraph) continue;
 		const owner = globalThis.RapierMarkdownLayout.wrapNeighbour(paragraph, _rapierShareWrapKind);
@@ -1445,6 +1458,8 @@ function _rapierProjectArtifactLayout(root, metadata, geometry, preparation) {
     if (layout.wrap === 'box') {
       value = boxProfile(image);
       if (!value && rotateRad) value = geometry.rasterTiltProfile(image.naturalWidth, image.naturalHeight, rotateRad);
+    } else if (layout.wrap === 'beside') {
+      value = rotateRad ? geometry.rasterTiltProfile(image.naturalWidth, image.naturalHeight, rotateRad) : null;
     } else {
       const occupancy = typeof geometry.parseProfile === 'function' && geometry.parseProfile(image.getAttribute('data-rapier-occupancy'));
       value = occupancy || geometry.alphaProfile(image);
@@ -1468,7 +1483,7 @@ function _rapierProjectArtifactLayout(root, metadata, geometry, preparation) {
     for (const image of root.querySelectorAll('img[data-rapier-image-layout]')) {
       if (exclude.has(image) || !image.complete || !image.naturalWidth || !image.naturalHeight) continue;
       const layout = metadata.parseLayoutAttribute(image.getAttribute('data-rapier-image-layout'));
-      if (!layout?.rotate || ['around', 'box', 'behind', 'front'].includes(layout.wrap)) continue;
+      if (!layout?.rotate || ['around', 'beside', 'box', 'behind', 'front'].includes(layout.wrap)) continue;
       const width = image.offsetWidth, height = image.offsetHeight;
       if (!(width > 0 && height > 0)) continue;
       const paragraph = image.closest('p');
@@ -1606,7 +1621,7 @@ function _rapierProjectArtifactLayout(root, metadata, geometry, preparation) {
       const origin = box(root).top, obstacles = [], anchors = new Map(), wrapped = new Set(), placed = [], positionedImages = new Set();
       for (const element of children) {
         const layout = metadata.parseLayoutAttribute(element.getAttribute('data-md-layout'));
-        const image = ['around', 'box', 'behind', 'front'].includes(layout?.wrap) && element.tagName === 'P'
+        const image = ['around', 'beside', 'box', 'behind', 'front'].includes(layout?.wrap) && element.tagName === 'P'
           ? element.querySelector('img[data-rapier-image-layout]') : null;
         if (!image?.complete || !image.naturalWidth || !image.naturalHeight || !imageOnly(element, image)) continue;
 
@@ -1652,7 +1667,9 @@ function _rapierProjectArtifactLayout(root, metadata, geometry, preparation) {
                   obstacle.y + obstacle.height > y - room && obstacle.y < y + rectangle.height + room)
                 y = obstacle.y + obstacle.height + room;
             }
-            obstacles.push(...geometry.linesSlices(geometry.pictureSlices(profile(image, layout), left, y, rectangle.width, rectangle.height, scale), layout, lines, y, rectangle.height));
+            let slices = geometry.pictureSlices(profile(image, layout), left, y, rectangle.width, rectangle.height, scale);
+            if (layout.wrap === 'beside') slices = geometry.besideSlices(slices, bounds.left + inset, bounds.left + inset + width, left, rectangle.width);
+            obstacles.push(...geometry.linesSlices(slices, layout, lines, y, rectangle.height));
           }
           placed.push({source, image, rectangle, left, y, wrap: layout.wrap,
             visualLeft: left + visualDeltaX, visualTop: y + visualDeltaY, visualWidth: fit.fit.width, visualHeight: fit.fit.height,
@@ -1733,7 +1750,7 @@ function _rapierArtifactLayoutScript(root, nonce = '', {pictures = true} = {}) {
   const dependencies = globalThis.RapierArtifactLayoutDependencies;
   const layoutOf = element => globalThis.RapierMarkdownLayout.parseLayoutAttribute(element.getAttribute('data-md-layout'));
   const pictureLayoutOf = image => globalThis.RapierMarkdownLayout.parseLayoutAttribute(image.getAttribute('data-rapier-image-layout'));
-  const wrapping = pictures && ([...root.querySelectorAll('p[data-md-layout]')].some(element => ['around', 'box', 'behind', 'front'].includes(layoutOf(element)?.wrap)) ||
+  const wrapping = pictures && ([...root.querySelectorAll('p[data-md-layout]')].some(element => ['around', 'beside', 'box', 'behind', 'front'].includes(layoutOf(element)?.wrap)) ||
        [...root.querySelectorAll('img[data-rapier-image-layout]')].some(image => pictureLayoutOf(image)?.rotate));
   const typography = _rapierArtifactTypographyScript(root);
   if (!wrapping && !typography) return '';

package/dist/layout/model.mjs

@@ -309,6 +309,19 @@ export function pictureSlices(profile, x, y, width, height, scale = 1) {
   return slices;
 }
 
+export function besideSlices(slices, columnLeft, columnRight, pictureLeft, pictureWidth) {
+  if (!Array.isArray(slices) || !(columnRight > columnLeft) || !(pictureWidth > 0) || !finite(pictureLeft)) return slices;
+  const blockLeft = pictureLeft + pictureWidth / 2 <= (columnLeft + columnRight) / 2;
+  return slices.map(slice => {
+    if (!slice || !finite(slice.x) || !finite(slice.width)) return slice;
+    if (blockLeft) {
+      const right = slice.x + slice.width;
+      return {...slice, x: columnLeft, width: Math.max(0, right - columnLeft)};
+    }
+    return {...slice, width: Math.max(0, columnRight - slice.x)};
+  });
+}
+
 export {slotSequence, columnsFilled};
 export function slotsForBand(width, obstacles, top, height, minWidth = 40) {
   if (!finite(width) || width <= 0 || !finite(top) || !finite(height) || height <= 0 ||

package/dist/spec/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/spec/md-layout.mjs

@@ -3,7 +3,7 @@
 export const fields = new Set(['align', 'width', 'lines', 'wrap', 'x', 'y', 'rotate', 'opacity', 'first', 'indent', 'marker', 'lock', 'hyphens', 'caps', 'hanging', 'before', 'after', 'line']);
 export const SPACING_FIELDS = Object.freeze(['before', 'after', 'line']);
 export const alignments = new Set(['left', 'center', 'right', 'justify']);
-export const wraps = new Set(['around', 'box', 'behind', 'front']);
+export const wraps = new Set(['around', 'beside', 'box', 'behind', 'front']);
 const has = (value, key) => Object.hasOwn(value, key);
 const percent = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100;
 const lineCount = value => Number.isInteger(value) && value >= 1 && value <= 12;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapier-markdown-kit",
-  "version": "1.2.42",
+  "version": "1.2.44",
   "description": "Read, render and write Self-contained Markdown: one .md file that carries its pictures, drawings and layout, and that any Markdown app can read. HTML renderer, stylesheet, text layout, Will/1 agent permissions, and an edit history with authorship and offline merge. MIT, no dependencies.",
   "keywords": [
     "markdown",