rapier-markdown-kit 1.2.33 → 1.2.42

package/dist/kit/ledger/format.mjs

@@ -3,10 +3,12 @@ import {_rapierPrepareHistoryRecords, _rapierValidMetadata, _rapierTransformMeta
 import {pictureHistorySplices} from './history.mjs';
 import {HistorySource} from './source.mjs';
 import {authoredHistory} from './transport.mjs';
-import {textRoot, rootAfter, sha256, sha256Parts, createSHA256} from './hash.mjs';
-import {canonicalJSON, canonicalParts, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
+import {textRoot, rootAfter, sha256, sha256PartsAsync, createSHA256} from './hash.mjs';
+import {canonicalJSON, canonicalParts, canonicalRowsParts, ownRow, ownLedger, isOwnedLedger, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
+import {diff} from '../../packages/rapier-diff/diff.mjs';
+import {minimalHistorySplice} from './inverse-source.mjs';
+import {evaluateWill} from '../../agent/will.mjs';
 export {textRoot, rootAfter};
-const digest = value => sha256Parts(canonicalParts(value));
 const rootShape = value => typeof value === 'string' && /^\d+:[a-z0-9]+:[a-z0-9]+$/.test(value);
 function* checkedRecords(ledger, prepared) {
   if (!prepared.ok || ledger.records.length !== prepared.records.length) throw fault('record chain differs');
@@ -25,43 +27,77 @@ function* checkedRecords(ledger, prepared) {
   }
   if (ledger.head.revision !== revision || ledger.head.root !== root) throw fault('history does not describe this document');
 }
+function* envelopeParts(envelope) {
+  const keys = Object.keys(envelope).sort();
+  yield '{';
+  for (let i = 0; i < keys.length; i++) {
+    if (i) yield ',';
+    yield JSON.stringify(keys[i]); yield ':';
+    yield* keys[i] === 'records' ? canonicalRowsParts(envelope.records, 1) : canonicalParts(envelope[keys[i]], 1, new Set());
+  }
+  yield '}';
+}
 const proofs = new WeakMap();
-function readLedgerState(input, expectedText, expectedMetadata) {
-  const ledger = plainData(input);
+function ownedRows(ledger) {
+  if (ledger && Array.isArray(ledger.records)) for (const row of ledger.records) if (row && typeof row === 'object') ownRow(row);
+  return ledger;
+}
+function copiedLedger(input, proof) {
+  if (!proof || !input || typeof input !== 'object') return ownedRows(plainData(input));
+  const fields = Object.getOwnPropertyDescriptors(input), start = fields.start;
+  if (!start || !Object.hasOwn(start, 'value') || !start.value || typeof start.value !== 'object') return ownedRows(plainData(input));
+  const parts = Object.getOwnPropertyDescriptors(start.value), text = parts.text;
+  if (!text || !Object.hasOwn(text, 'value') || text.value !== proof.startText) return ownedRows(plainData(input));
+  const shell = Object.create(Object.getPrototypeOf(input), {...fields, start: {...start,
+    value: Object.create(Object.getPrototypeOf(start.value), {...parts, text: {...text, value: ''}})}});
+  const ledger = ownedRows(plainData(shell));
+  ledger.start.text = proof.startText;
+  return ledger;
+}
+function ledgerAdmission(input) {
+  const held = input && typeof input === 'object' ? proofs.get(input) : undefined;
+  if (held && isOwnedLedger(input)) return {ledger: input, shell: held.shell, proof: held};
+  const ledger = copiedLedger(input, held);
   if (!exactKeys(ledger, ['format','documentAuthority','start','records','head','complete','sha256']) || ledger.format !== 'rapier-ledger/2' ||
       typeof ledger.documentAuthority !== 'string' || !ledger.documentAuthority || ledger.documentAuthority.length > 256 ||
       typeof ledger.complete !== 'boolean' || !Array.isArray(ledger.records) ||
       !exactKeys(ledger.start, ['text','revision','root','sha256','metadata']) || !exactKeys(ledger.head, ['revision','root','sha256','metadata'])) throw fault('unsupported or invalid envelope');
-  const shell = canonicalJSON({...ledger, start: {...ledger.start, text: ''}});
-  let proof = typeof input === 'object' ? proofs.get(input) : undefined;
-  if (!proof || proof.shell !== shell || proof.startText !== ledger.start.text) {
-    proof = {shell, startText: ledger.start.text, ...proveLedger(ledger)};
-    if (typeof input === 'object') proofs.set(input, proof);
-  }
-  proofs.set(ledger, proof);
+  const shell = Array.from(envelopeParts({...ledger, start: {...ledger.start, text: ''}})).join('');
+  const proof = held?.shell === shell && held.startText === ledger.start.text ? held : null;
+  return {ledger, shell, proof};
+}
+function ledgerResult(ledger, proof, expectedText, expectedMetadata) {
+  proofs.set(ledger, proof); ownLedger(ledger);
   const {text, metadata, root, revision, prepared, source} = proof;
   if (expectedMetadata !== undefined && (!_rapierValidMetadata(expectedMetadata) || canonicalJSON(metadata) !== canonicalJSON(expectedMetadata)))
     throw fault('metadata does not describe this document');
   if (expectedText !== undefined && text !== expectedText) throw fault('history does not describe this document');
-  return {value: {ledger, text, metadata: {...metadata}, root, revision, complete: ledger.complete}, prepared, source};
+  return {value: {ledger, text, metadata: {...metadata}, root, revision, complete: ledger.complete}, prepared, source, proof};
+}
+function readLedgerState(input, expectedText, expectedMetadata) {
+  const {ledger, shell, proof: held} = ledgerAdmission(input);
+  const proof = held || {shell, startText: ledger.start.text, ...finish(proveLedger(ledger))};
+  if (typeof input === 'object') proofs.set(input, proof);
+  return ledgerResult(ledger, proof, expectedText, expectedMetadata);
 }
-function proveLedger(ledger) {
+function* proveLedger(ledger, native = false) {
   const {sha256: claimed, ...payload} = ledger;
-  if (claimed !== digest(payload)) throw fault('envelope checksum differs');
-  let text = documentText(ledger.start.text), root = ledger.start.root, revision = ledger.start.revision;
+  if (claimed !== (yield* checksum(envelopeParts(payload), native))) throw fault('envelope checksum differs');
+  let text = ledger.start.text, root = ledger.start.root, revision = ledger.start.revision;
+  const startFacts = yield* sourceFacts(text, native);
   if (!_rapierValidMetadata(ledger.start.metadata) || !_rapierValidMetadata(ledger.head.metadata)) throw fault('invalid document metadata');
-  if (!nonnegative(revision) || !rootShape(root) || (revision === 0 && root !== textRoot(text)) || ledger.start.sha256 !== sha256(text) ||
+  if (!nonnegative(revision) || !rootShape(root) || (revision === 0 && root !== startFacts.contentRoot) || ledger.start.sha256 !== startFacts.sha256 ||
       (ledger.complete && revision !== 0)) throw fault('invalid start');
   const prepared = _rapierPrepareHistoryRecords(ledger.records);
   if (!prepared.ok) throw fault('record chain differs');
-  let source = new HistorySource(text), bytes = utf8Length(text);
+  let source = new HistorySource(text), bytes = startFacts.utf8Bytes;
   for (const record of checkedRecords(ledger, prepared)) {
     const next = source.apply(record.splices);
     if (next === null) throw fault('splice does not replay');
     source = next;
     for (const row of record.splices) bytes += utf8Length(row.inserted) - utf8Length(row.removed);
     if (bytes > 64 * 1024 * 1024) throw fault('document exceeds the editor text limit');
-    root = record.afterHash; revision = record.transaction.revision;
+    root = record.afterHash; revision = record.transaction.revision; yield;
   }
   text = source.slice();
   if (ledger.records.some(row => Object.hasOwn(row, 'authored'))) {
@@ -69,7 +105,8 @@ function proveLedger(ledger) {
   }
   const metadata = prepared.replayMetadata(ledger.start.metadata);
   if (!metadata || canonicalJSON(metadata) !== canonicalJSON(ledger.head.metadata)) throw fault('metadata does not describe this document');
-  if (ledger.head.revision !== revision || ledger.head.root !== root || ledger.head.sha256 !== sha256(text)) throw fault('history does not describe this document');
+  const headFacts = ledger.records.every(row => !row.splices.length) ? startFacts : yield* sourceFacts(text, native);
+  if (ledger.head.revision !== revision || ledger.head.root !== root || ledger.head.sha256 !== headFacts.sha256) throw fault('history does not describe this document');
   return {text, metadata, root, revision, prepared, source};
 }
 export function ledgerWithStart(input, text) {
@@ -83,14 +120,25 @@ export function ledgerWithStart(input, text) {
 export function readLedger(input, expectedText, expectedMetadata) {
   return readLedgerState(input, expectedText, expectedMetadata).value;
 }
-function* checksum(parts) {
+export async function readLedgerAsync(input, expectedText, expectedMetadata, options = {}) {
+  options.signal?.throwIfAborted();
+  const {ledger, shell, proof: held} = ledgerAdmission(input);
+  const metadata = expectedMetadata === undefined ? undefined : plainData(expectedMetadata);
+  const proof = held || {shell, startText: ledger.start.text,
+    ...await finishAsync(proveLedger(ledger, !!globalThis.crypto?.subtle), options)};
+  options.signal?.throwIfAborted();
+  if (typeof input === 'object') proofs.set(input, proof);
+  return ledgerResult(ledger, proof, expectedText, metadata).value;
+}
+function* checksum(parts, native = false) {
+  if (native) return yield {parts};
   const hash = createSHA256();
   for (const part of parts) { hash.update(part); yield; }
   return hash.digest();
 }
-function* sourceFacts(text) {
+function* sourceFacts(text, native = false) {
   if (typeof text !== 'string') throw fault('document is not whole-character text');
-  const hash = createSHA256();
+  const hash = native ? null : createSHA256();
   let fnv = 0x811c9dc5, a = 1, b = 0, bytes = 0;
   for (let at = 0; at < text.length;) {
     const start = at, end = Math.min(text.length, at + 65536);
@@ -112,26 +160,34 @@ function* sourceFacts(text) {
       a %= 65521; b %= 65521;
     }
     if (bytes > 64 * 1024 * 1024) throw fault('document exceeds the editor text limit');
-    hash.update(text.slice(start, end)); yield;
+    hash?.update(text.slice(start, end)); yield;
   }
-  return {utf8Bytes: bytes, sha256: hash.digest(), contentRoot: text.length + ':' +
+  const digest = hash ? hash.digest() : yield {parts: [text], byteLength: bytes};
+  return {utf8Bytes: bytes, sha256: digest, contentRoot: text.length + ':' +
     (fnv >>> 0).toString(36) + ':' + (((b << 16) | a) >>> 0).toString(36)};
 }
-function* produceLedger({text, metadata, records, documentAuthority, revision, root, complete = false, earlier = records} = {}) {
+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);
+function* produceLedger({text, metadata, records, documentAuthority, revision, root, complete = false, earlier = records} = {}, native = false) {
   if (!_rapierValidMetadata(metadata)) throw fault('document metadata required');
   metadata = {...metadata};
   if (!Array.isArray(records) || !Array.isArray(earlier)) throw fault('records required');
   const prepared = _rapierPrepareHistoryRecords(records, earlier);
   if (!prepared.ok) throw fault('navigation target was not retained');
-  const headFacts = yield* sourceFacts(text);
+  const headFacts = yield* sourceFacts(text, native);
   let bytes = headFacts.utf8Bytes;
   const expanded = [];
   for (const {record, splices: rows, metadata: effect} of prepared.rows) {
     if (!rows || effect === undefined) throw fault('navigation target was not retained');
-    expanded.push({transaction: plainData(record.transaction), splices: rows.map(row => ({pos: row.pos, removed: row.removed, inserted: row.inserted})),
+    const held = expandedRows.get(record);
+    if (held && sameSplices(held.rows, rows) && sameEffect(held.effect, effect)) { expanded.push(held.row); yield; continue; }
+    expanded.push(ownRow({transaction: plainData(record.transaction), splices: rows.map(row => ({pos: row.pos, removed: row.removed, inserted: row.inserted})),
       beforeHash: record.beforeHash, afterHash: record.afterHash, ...(Object.hasOwn(record, 'authored') ? {authored: plainData(record.authored)} : {}), ...(effect ? {metadata: plainData(effect)} : {}),
       ...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {changeSet: {label: typeof record.changeSet.label === 'string' ? record.changeSet.label : plainData(record.changeSet.label)}} : {}),
-      ...(record.derivedCommentIndex == null ? {} : {derivedCommentIndex: typeof record.derivedCommentIndex === 'string' ? record.derivedCommentIndex : plainData(record.derivedCommentIndex)})});
+      ...(record.derivedCommentIndex == null ? {} : {derivedCommentIndex: typeof record.derivedCommentIndex === 'string' ? record.derivedCommentIndex : plainData(record.derivedCommentIndex)})}));
+    expandedRows.set(record, {row: expanded.at(-1), rows, effect});
     yield;
   }
   const headBytes = bytes;
@@ -153,7 +209,7 @@ 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);
+  const startFacts = unchangedText ? headFacts : 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,
@@ -165,7 +221,11 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   }
   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(canonicalParts(payload))};
+  const ledger = {...payload, sha256: yield* checksum(envelopeParts(payload), native)};
+  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),
+    source: new HistorySource(text)});
   return {ledger, contentRoot, utf8Bytes: headBytes};
 }
 function finish(producer) {
@@ -174,13 +234,14 @@ function finish(producer) {
   return step.value;
 }
 export function exportLedger(input) { return finish(produceLedger(input)).ledger; }
-export async function prepareLedgerAsync(input, {yield: yieldWork, signal} = {}) {
-  const producer = produceLedger(input);
-  let step;
+async function finishAsync(producer, {yield: yieldWork, signal} = {}) {
+  let step, digest;
   do {
     signal?.throwIfAborted();
-    step = producer.next();
-    if (!step.done && yieldWork) {
+    step = producer.next(digest); digest = undefined;
+    if (!step.done && step.value) digest = await sha256PartsAsync(step.value.parts,
+      {yield: yieldWork, signal, byteLength: step.value.byteLength});
+    else if (!step.done && yieldWork) {
       const pending = yieldWork();
       if (pending) await pending;
     }
@@ -188,8 +249,10 @@ export async function prepareLedgerAsync(input, {yield: yieldWork, signal} = {})
   signal?.throwIfAborted();
   return step.value;
 }
-export function historyEnvelope(input, segmentIdentity = [], expectedText, expectedMetadata) {
-  const {value: {ledger, text, metadata}, prepared, source} = readLedgerState(input, expectedText, expectedMetadata);
+export function prepareLedgerAsync(input, options = {}) {
+  return finishAsync(produceLedger(input, !!globalThis.crypto?.subtle), options);
+}
+function historyNavigation(ledger, text, metadata, prepared, source) {
   const {byId, effects: {pictures}} = prepared;
   let branch = [], cursor = 0;
   for (const {transaction: tx} of ledger.records) {
@@ -232,8 +295,13 @@ export function historyEnvelope(input, segmentIdentity = [], expectedText, expec
       if (active === null || !activeMetadata || (i + 1 === cursor && (active.length !== text.length || !active.matches(0, text) || canonicalJSON(activeMetadata) !== canonicalJSON(metadata)))) throw fault('complete branch differs');
     }
   }
+  return {branch, cursor};
+}
+export function historyEnvelope(input, segmentIdentity = [], expectedText, expectedMetadata) {
+  const {value: {ledger, text, metadata}, prepared, source, proof} = readLedgerState(input, expectedText, expectedMetadata);
+  const {branch, cursor} = proof.navigation ??= historyNavigation(ledger, text, metadata, prepared, source);
   return {schemaVersion: 5, documentAuthority: ledger.documentAuthority, documentRevision: ledger.head.revision,
-    ledger: ledger.records, branch, cursor, earliestRevision: ledger.start.revision, earliestHash: ledger.start.root,
+    ledger: ledger.records, branch: branch.slice(), cursor, earliestRevision: ledger.start.revision, earliestHash: ledger.start.root,
     sourceRootId: ledger.head.root, earliestMetadata: {...ledger.start.metadata}, documentMetadata: {...metadata}, segmentIdentity, historyComplete: ledger.complete,
     trimReason: ledger.complete ? '' : 'carried_start', trimmedBytes: 0};
 }
@@ -249,15 +317,14 @@ export function agentActorId(door, agent) {
 export function replaceLedgerText(input, text, {actor = {kind: 'system', id: 'rapier'}, operation = 'document.replace', at} = {}) {
   const current = readLedger(input); documentText(text);
   if (current.text === text) return current.ledger;
-  let start = 0, a = current.text.length, b = text.length;
-  while (start < a && start < b && current.text[start] === text[start]) start++;
-  if (start && /[\uDC00-\uDFFF]/.test(current.text[start] || text[start] || '')) start--;
-  while (a > start && b > start && current.text[a - 1] === text[b - 1]) { a--; b--; }
-  if (/[\uDC00-\uDFFF]/.test(current.text[a] || text[b] || '')) { a++; b++; }
-  const splices = [{pos: start, removed: current.text.slice(start, a), inserted: text.slice(start, b)}];
-  const revision = current.revision + 1, root = rootAfter(current.root, splices[0]);
+  const splices = diff(current.text, text, {_unit: 'word'}).edits.map(edit =>
+    minimalHistorySplice(current.text.slice(...edit.before), text.slice(...edit.after), edit.before[0])).reverse();
+  const revision = current.revision + 1, root = splices.reduce(rootAfter, current.root);
+  if (actor.kind === 'agent' && current.metadata.docKind === 'markdown' && evaluateWill(current.text, splices).outcome !== 'applied')
+    throw fault('will_violation');
+  const identity = sha256(canonicalJSON({before: current.ledger.sha256, text, actor, operation, at: at ?? null}));
   const record = {beforeHash: current.root, afterHash: root, splices, transaction: {
-    id: current.ledger.documentAuthority.slice(0, 48) + ':export:' + revision.toString(36),
+    id: current.ledger.documentAuthority.slice(0, 48) + ':export:' + identity,
     documentAuthority: current.ledger.documentAuthority, baseRevision: current.revision, revision,
     actor, transport: 'platform', operation, requestId: null, sourceTransactionId: null,
     affectedBlockIds: [], parent: current.ledger.records.at(-1)?.transaction.id ?? null,

package/dist/kit/ledger/hash.mjs

@@ -111,9 +111,50 @@ export function sha256Parts(parts) {
   for (const part of parts) hash.update(part);
   return hash.digest();
 }
-const LONG_TEXT = 65536, DIGESTS = new Map();
+export async function sha256PartsAsync(parts, {yield: yieldWork, signal, byteLength} = {}) {
+  const encoder = new TextEncoder(), chunks = [];
+  let bytes = byteLength === undefined ? null : new Uint8Array(byteLength);
+  let high = '', length = 0;
+  const write = text => {
+    if (bytes) {
+      const result = encoder.encodeInto(text, bytes.subarray(length));
+      if (result.read !== text.length) throw new RangeError('SHA-256 byte length differs');
+      length += result.written;
+    } else {
+      const chunk = encoder.encode(text); chunks.push(chunk); length += chunk.length;
+    }
+  };
+  for (const value of parts) {
+    let text = high + String(value === undefined ? '' : value); high = '';
+    if (text.length && (text.charCodeAt(text.length - 1) & 0xfc00) === 0xd800) {
+      high = text.slice(-1); text = text.slice(0, -1);
+    }
+    for (let at = 0; at < text.length;) {
+      signal?.throwIfAborted();
+      let end = Math.min(text.length, at + 32768);
+      if (end < text.length && (text.charCodeAt(end - 1) & 0xfc00) === 0xd800 &&
+          (text.charCodeAt(end) & 0xfc00) === 0xdc00) end--;
+      write(text.slice(at, end)); at = end;
+      const pending = yieldWork?.(); if (pending) await pending;
+    }
+  }
+  if (high) write(high);
+  if (bytes && length !== bytes.length) throw new RangeError('SHA-256 byte length differs');
+  bytes ||= new Uint8Array(length);
+  let at = 0;
+  for (const chunk of chunks) {
+    signal?.throwIfAborted(); bytes.set(chunk, at); at += chunk.length;
+    const pending = yieldWork?.(); if (pending) await pending;
+  }
+  chunks.length = 0;
+  signal?.throwIfAborted();
+  const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+  signal?.throwIfAborted();
+  return Array.from(new Uint8Array(digest), value => value.toString(16).padStart(2, '0')).join('');
+}
+const LONG_TEXT = 65536, DOCUMENT_TEXT = 1048576, DIGESTS = new Map();
 export function sha256(text) {
-  if (typeof text !== 'string' || text.length < LONG_TEXT) return createSHA256().update(text).digest();
+  if (typeof text !== 'string' || text.length < LONG_TEXT || text.length >= DOCUMENT_TEXT) return createSHA256().update(text).digest();
   let digest = DIGESTS.get(text);
   if (digest === undefined) {
     digest = createSHA256().update(text).digest();

package/dist/kit/ledger/history.mjs

@@ -5,6 +5,7 @@ import {sourceView, HistorySource} from './source.mjs';
 import {textRootParts, rootAfter} from './hash.mjs';
 import {authoredHistory, authoredPlacements} from './transport.mjs';
 import {plainData, canonicalJSON} from './data.mjs';
+import {evaluateWill} from '../../agent/will.mjs';
 
 const historyFailure = reason => ({ok: false, reason});
 const historyInteger = value => Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
@@ -323,6 +324,8 @@ export function selectiveUndo(input, actIds, options = {}) {
 		(options.splitSplice !== undefined && typeof options.splitSplice !== 'function')) return historyFailure('act_invalid');
 	const requested = new Set(actIds), available = prepared.byId;
 	if ([...requested].some(id => !available.has(id))) return historyFailure('act_unavailable');
+	if (options.actor?.kind === 'agent' && [...requested].some(id => available.get(id).record.transaction.actor.kind !== 'agent'))
+		return historyFailure('act_forbidden');
 	const selected = new Set([...requested].filter(id => prepared.effects.active.has(id)));
 	const records = prepared.records;
 	let inverseId = 'planned-inverse'; while (available.has(inverseId)) inverseId += ':';
@@ -359,6 +362,9 @@ export function selectiveUndo(input, actIds, options = {}) {
 			sourceIndices: transported.sourceIndices.get(record.transaction.id)})) : prepared.rows;
 		const result = projectInverseSource(transported ? {...prepared, rows, records: transported.records} : prepared, selected, projectedEffects, options);
 		if (!result.ok) return result;
+		if (options.actor?.kind === 'agent' && prepared.metadata.docKind === 'markdown' &&
+			evaluateWill(prepared.source, result.splices, {restores: result.splices}).outcome !== 'applied')
+			return historyFailure('will_refused');
 		return {...result, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
 			effectChanged, unchanged: result.after === prepared.source && !metadata && !effectChanged};
 	} catch (_) { return historyFailure('history_invalid'); }

package/dist/kit/ledger/inverse-source.mjs

@@ -10,7 +10,7 @@ const historyBoundary = (source, at) => Number.isSafeInteger(at) && at >= 0 && !
 	!(at > 0 && at < source.length && (source.charCodeAt(at - 1) & 0xFC00) === 0xD800 &&
 	(source.charCodeAt(at) & 0xFC00) === 0xDC00);
 
-function minimalHistorySplice(before, after, pos = 0) {
+export function minimalHistorySplice(before, after, pos = 0) {
 	let first = 0, a = before.length, b = after.length;
 	while (first < a && first < b && before[first] === after[first]) first++;
 	if (!historyBoundary(before, first) || !historyBoundary(after, first)) first--;
@@ -32,6 +32,8 @@ function historyHunks(row) {
 }
 
 
+const differentActors = (a, b) => !!a && !!b && (a.kind !== b.kind || a.id !== b.id);
+
 export function projectInverseSource(prepared, selected, projectedEffects, options = {}) {
 	const records = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
 	if (!options.origins && !records.some(record => !prepared.effects.references.get(record.transaction.id)?.length &&
@@ -40,6 +42,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 	try {
 		let pieces = prepared.initialSource ? [{text: prepared.initialSource, owner: null, lineage: []}] : [];
 		const all = [], byId = new Map(), byAct = new Map(), processed = [], keptInverseAncestors = new Set();
+		const actorOf = new Map(records.map(record => [record.transaction.id, record.transaction.actor]));
 		const recordsForCover = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
 		const coverGroups = new Map();
 		let coverOrigins = null;
@@ -262,7 +265,11 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					const start = boundary(row.pos), end = boundary(row.pos + row.removed.length);
 					let at = start.last, count = Math.max(0, end.first - at);
 					if (!row.removed.length) {
-						const marker = pieces.slice(start.first, start.last).findIndex(item => item.mark?.inserted.length);
+						const run = pieces.slice(start.first, start.last), next = pieces[start.last];
+						let before = start.first - 1; while (before >= 0 && !pieces[before].text) before--;
+						const leftAct = before >= 0 ? byId.get(pieces[before].owner)?.actId : undefined;
+						const sameAct = leftAct !== undefined && run.some(item => item.mark?.actId === leftAct);
+						const marker = run.findIndex(item => item.mark?.inserted.length && (next && owns(next, item.mark) || !sameAct));
 						at = marker < 0 ? start.last : start.first + marker; count = 0;
 					}
 					const removed = pieces.slice(at, at + count);
@@ -276,6 +283,12 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					const id = tx.id + '#' + rowIndex + ':' + index;
 					const lineage = new Set([id]);
 					for (const piece of removed) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
+					if (!row.removed.length && !count && at > 0 && /[\p{L}\p{N}\p{M}]/u.test(row.inserted)) {
+						const left = pieces[at - 1], right = pieces[at];
+						const inner = left?.text && right?.text && left.owner === right.owner ? byId.get(left.owner) : null;
+						if (inner && inner.actId !== tx.id && inner.removed && differentActors(actorOf.get(inner.actId), tx.actor) && /[\p{L}\p{N}\p{M}]$/u.test(left.text) && /^[\p{L}\p{N}\p{M}]/u.test(right.text))
+							for (const parent of [inner.id, ...(left.lineage || [])]) lineage.add(parent);
+					}
 					const hunk = {id, actId: tx.id, removed: row.removed, inserted: row.inserted, before: removed, derived,
 						chosen, kept: selected.has(tx.id) && !chosen, lineage: [...lineage], supersededBy: new Set(), active: true,
 						...(coverIdsFor(tx.id) ? {coverIds: coverIdsFor(tx.id)} : {})};

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

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 import {fields, scalar, plainPrototype} from './data.mjs';
 import {transformText} from './source.mjs';
+import {dataImage} from '../../spec/md-assets.mjs';
 
 const _RAPIER_TRANSACTION_ACTOR_LIMIT = 160;
 const _RAPIER_TRANSACTION_OPERATION_LIMIT = 96;
@@ -75,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;
@@ -99,9 +100,12 @@ 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;
@@ -109,10 +113,27 @@ function _rapierRecordIndex(records) {
 	return {byId, 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; }
 }
 
@@ -162,7 +183,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; }
 }
 
@@ -175,10 +196,10 @@ function _rapierPictureFinish(record, original, earlier, lookup) {
 	if (!reference || !/^\]\[[a-z0-9-]+\]$/i.test(reference.inserted) || reference.removed === reference.inserted) return false;
 	const definition = rows.find(row => row !== reference), oldLabel = reference.removed.slice(2, -1), newLabel = reference.inserted.slice(2, -1);
 	const body = (text, label) => {
-		const prefix = '[' + label + ']: data:image/svg+xml;base64,';
+		const prefix = '[' + label + ']: ';
 		if (typeof text !== 'string' || !text.startsWith(prefix)) return null;
 		const value = text.slice(prefix.length), end = value.indexOf(' '), bytes = end < 0 ? value : value.slice(0, end), title = end < 0 ? '' : value.slice(end);
-		return /^[A-Za-z0-9+/]+={0,2}$/.test(bytes) && !/[\r\n]/.test(title) ? title : null;
+		return dataImage(bytes)?.codec === 'image/svg+xml' && !/[\r\n]/.test(title) ? title : null;
 	};
 	const title = body(definition.removed, oldLabel);
 	if (title === null || body(definition.inserted, newLabel) !== title) return false;
@@ -292,6 +313,7 @@ function _rapierWalkHistoryEffects(records, lookup, visit = null, observe = null
 				}
 			}
 			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};
 			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) {
@@ -505,9 +527,10 @@ const _rapierPrepareHistoryRecords = (() => {
 
 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/kit/ledger/merge.mjs

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: MIT
 import {readLedger, exportLedger, rootAfter} from './format.mjs';
 import {_rapierTransformSplices, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState} from './journal-records.mjs';
-import {mergeText} from './text-merge.mjs';
+import {mergeText, willMergeConflict} from './text-merge.mjs';
 import {transposeAuthored, authoredPlacements} from './transport.mjs';
-import {parseWill, stripOneTerminator} from '../../agent/will.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON, fault} from './data.mjs';
 export function transportInterval(start, end, splices) {
@@ -58,17 +57,6 @@ function checkpointList(read) {
   }
   return list;
 }
-function kept(text) {
-  const will = parseWill(text);
-  if (will.fault) return {fault: will.fault, text};
-  return will.regions.filter(region => region.law !== 'edit').map(({law, intent, start, end}) =>
-    law === 'keep' ? {law, intent, text: text.slice(start, end)} : {law, intent});
-}
-function appended(from, to) {
-  const regions = text => parseWill(text).regions.filter(region => region.law === 'append');
-  const was = regions(from), now = regions(to), core = (text, region) => stripOneTerminator(text.slice(region.start, region.end));
-  return was.length === now.length && was.every((region, index) => core(to, now[index]).startsWith(core(from, region)));
-}
 function expandRetainedStart(shorter, longer) {
   if (shorter.ledger.documentAuthority !== longer.ledger.documentAuthority ||
       shorter.ledger.start.revision <= longer.ledger.start.revision) return null;
@@ -191,10 +179,8 @@ export function merge(first, second) {
     const local = localIds.get(record.transaction.id);
     if (local) mappedIds.set(record.transaction.id, local.transaction.id);
   }
-  const incomingKept = canonicalJSON(kept(theirs.text));
-  const keepDiffers = incomingKept !== canonicalJSON(kept(ours.text)) && incomingKept !== canonicalJSON(kept(common.text)) ||
-    !appended(common.text, theirs.text) && !appended(ours.text, theirs.text);
-  let conflicted = keepDiffers && unseen.length > 0, incomingSource = common.text;
+  const keepDiffers = willMergeConflict(common.text, ours.text, theirs.text);
+  let conflicted = keepDiffers, incomingSource = common.text;
   if (!conflicted) for (const record of incoming) {
     const beforeSource = incomingSource;
     incomingSource = _rapierTransformSplices(incomingSource, record.splices);

package/dist/kit/ledger/text-merge.mjs

@@ -1,4 +1,28 @@
 // SPDX-License-Identifier: MIT
+import {parseWill, stripOneTerminator} from '../../agent/will.mjs';
+
+export function willMergeConflict(base, ours, theirs) {
+	const snapshot = text => {
+		const will = parseWill(text);
+		return {fault: will.fault, regions: will.regions.filter(region => region.law !== 'edit').map(region => ({
+			law: region.law, intent: region.intent, text: text.slice(region.start, region.end),
+		}))};
+	};
+	const a = snapshot(ours), b = snapshot(theirs);
+	if (a.fault || b.fault) return ours !== theirs;
+	const kept = value => JSON.stringify(value.regions.map(({law, intent, text}) => ({law, intent, ...(law === 'keep' ? {text} : {})})));
+	if (kept(a) !== kept(b)) return true;
+	if (base === null) return false;
+	const prior = snapshot(base);
+	if (prior.fault) return base !== ours || base !== theirs;
+	const appended = value => {
+		const before = prior.regions.filter(region => region.law === 'append'), after = value.regions.filter(region => region.law === 'append');
+		return before.length === after.length && before.every((region, index) =>
+			stripOneTerminator(after[index].text).startsWith(stripOneTerminator(region.text)));
+	};
+	return !appended(a) || !appended(b);
+}
+
 function textFault(code, message) { return Object.assign(new Error(message), {code}); }
 export function canonicalNote(text) {
 	if (typeof text !== 'string') throw textFault('note_text', 'A note must be text');
@@ -430,8 +454,9 @@ export function mergeText(base, ours, theirs, options = {}) {
 	canonicalNote(ours); canonicalNote(theirs); if (base !== null) canonicalNote(base);
 	const unchanged = value => ({text: value, clean: !value.includes(TEXT_CONFLICT), conflicts: value.includes(TEXT_CONFLICT) ? [{kind: 'existing-conflict', advisory: true}] : []});
 	if (ours === theirs) return unchanged(ours);
-	if (base === ours) return unchanged(theirs);
-	if (base === theirs) return unchanged(ours);
+	const willConflict = willMergeConflict(base, ours, theirs);
+	if (!willConflict && base === ours) return unchanged(theirs);
+	if (!willConflict && base === theirs) return unchanged(ours);
 	const conflicts = []; let text = '', a, b;
 	const conflict = (before, a, b, kind) => {
 		const ab = inspectTextConflicts(a), bb = inspectTextConflicts(b);
@@ -468,6 +493,7 @@ export function mergeText(base, ours, theirs, options = {}) {
 	const [units, oursUnits, theirsUnits] = base === null ? [] : [base, ours, theirs].map(textUnits);
 	const declared = base !== null && textDeclarations(units);
 	if (base === null) conflict(null, ours, theirs, 'no-ancestor');
+	else if (willConflict) conflict(base, ours, theirs, 'will');
 	else if (textDeclarations(oursUnits) !== declared || textDeclarations(theirsUnits) !== declared) conflict(base, ours, theirs, 'document-bindings');
 	else {
 		const reordered = textPermuted(units, oursUnits, theirsUnits);

package/dist/kit/rapier-ledger.mjs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
-import {exportLedger, replaceLedgerText, readLedger, ledgerWithStart, textRoot, rootAfter, historyEnvelope, agentActorId} from './ledger/format.mjs';
-export {exportLedger, replaceLedgerText, readLedger, ledgerWithStart, textRoot, rootAfter, historyEnvelope, agentActorId};
+import {exportLedger, prepareLedgerAsync, replaceLedgerText, readLedger, readLedgerAsync, ledgerWithStart, textRoot, rootAfter, historyEnvelope, agentActorId} from './ledger/format.mjs';
+export {exportLedger, prepareLedgerAsync, replaceLedgerText, readLedger, readLedgerAsync, ledgerWithStart, textRoot, rootAfter, historyEnvelope, agentActorId};
 import {authorship, readAuthorship, ledgerFromAuthorship} from './ledger/authorship.mjs';
 export {authorship, readAuthorship, ledgerFromAuthorship};
 import {merge, transportInterval, transportTouchedInterval} from './ledger/merge.mjs';