rapier-html 1.2.40 → 1.2.43

package/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "rapier-html",
-  "version": "1.2.40",
+  "version": "1.2.43",
   "path": "dist/rapier.html",
-  "bytes": 5923993,
-  "sha256": "b0fc95b2633a468feba1c5dc1d7e59d49bc147ff48ae50c2eaa891296eacf23e",
-  "builtAt": "2026-10-24T09:33:09.207Z",
+  "bytes": 5832352,
+  "sha256": "233e582745310b79d57c2fc26435ed02c00d657f6c1f7d8b676b2d678522e3cd",
+  "builtAt": "2026-10-25T00:05:03.516Z",
   "node": "v22.23.4",
   "canonical": true,
   "packing": "zopfli",
@@ -31,15 +31,15 @@
       "delivery": "built-in",
       "kind": "files",
       "element": "rapier-plugin-mermaid",
-      "bytes": 677968,
-      "packedBytes": 224584,
+      "bytes": 720263,
+      "packedBytes": 240280,
       "files": [
         {
           "id": "rapier-mermaid-core",
-          "name": "pele-1.6.0.js",
-          "version": "1.6.0",
-          "bytes": 677968,
-          "sri": "wvZ8yi9fl1G4U3tYTRguH7dHJxCgl7Rgu/Bb+sz+ip80toql8Bc0N2aLeJCCtUMS"
+          "name": "pele-1.9.0-native-1.js",
+          "version": "1.9.0-native-1",
+          "bytes": 720263,
+          "sri": "zPE63bYrlp1ZqlwxePk6pclPq6VoxZ7o769Lz109vEo8OEPtvOl1GPrMDj0OhtVB"
         }
       ]
     },
@@ -48,15 +48,15 @@
       "delivery": "built-in",
       "kind": "files",
       "element": "rapier-plugin-mermaid-zenuml",
-      "bytes": 1888111,
-      "packedBytes": 249770,
+      "bytes": 420431,
+      "packedBytes": 110835,
       "files": [
         {
           "id": "rapier-mermaid-zenuml",
-          "name": "rapier-zenuml-4.5.0-3.js",
-          "version": "4.5.0-3",
-          "bytes": 1888111,
-          "sri": "/JAYBQPgTaslQtUck91RnxcqXI8V8T0iYa+dRwc9StJhd0MPJGLTOCLj9aNDRHDG"
+          "name": "rapier-zenuml-svg-4.5.0-1.js",
+          "version": "4.5.0-svg-1",
+          "bytes": 420431,
+          "sri": "Dma7QZLWfZx3gWM0ie8JpjR4KwOXqndKcIJywkdxJ2shsdw/gDRFByjGlUv+eNoQ"
         }
       ]
     },
@@ -145,15 +145,15 @@
       "delivery": "built-in",
       "kind": "files",
       "element": "rapier-plugin-font-subset",
-      "bytes": 1214779,
-      "packedBytes": 441276,
+      "bytes": 1207570,
+      "packedBytes": 439575,
       "files": [
         {
           "id": "rapier-font-subset",
           "name": "rapier-font-subset-3.js",
           "version": "3",
-          "bytes": 1214779,
-          "sri": "iAjccOClLDb549FPCJnflzsNIlLa4G4N/SRm/GnIvhcUyQd0COW2672AA2Mldcnz"
+          "bytes": 1207570,
+          "sri": "eyBreJCziFoHQdGSPtvd0S2IRcHna191kq83/ps/rafZwWWd6reInBALyPdLQmdL"
         }
       ]
     }

package/README.md

@@ -7,8 +7,8 @@ Turn Markdown into one offline HTML file that contains the full Rapier editor.
   <img src="https://raw.githubusercontent.com/jackskip22/rapier-plugins/main/assets/write-390-light.png" alt="The Rapier editor on a phone: a launch plan with an agent's change marked" width="320">
 </picture>
 
-Try it: `npx rapier-html@1.2.40 notes.md`, then open `notes.rapier.html` in any browser.
-Install: `npm install rapier-html@1.2.40`.
+Try it: `npx rapier-html@1.2.43 notes.md`, then open `notes.rapier.html` in any browser.
+Install: `npm install rapier-html@1.2.43`.
 
 It opens on a phone or computer, with no account. People read, edit, draw and paint; agents hand over documents, show
 what changed and get the edited copy back.
@@ -26,14 +26,14 @@ The file needs no hosted workspace.
 Needs Node 22 or newer.
 
 ```sh
-npx -- rapier-html@1.2.40 notes.md                          # the editor, notes.md inside it, written beside the file
-npx -- rapier-html@1.2.40 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
-npx -- rapier-html@1.2.40 notes.md --include draw,math     # carries Draw and Math (default: what the document needs)
-npx -- rapier-html@1.2.40 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
-npx -- rapier-html@1.2.40 revised.md --compare original.md # opens showing what changed
-npx -- rapier-html@1.2.40 notes.md --return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT" # Send back
-npx -- rapier-html@1.2.40 notes.md out.html                 # a named output
-npm install rapier-html@1.2.40                              # as a library: writePage, unwrap
+npx -- rapier-html@1.2.43 notes.md                          # the editor, notes.md inside it, written beside the file
+npx -- rapier-html@1.2.43 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
+npx -- rapier-html@1.2.43 notes.md --include draw,math     # carries Draw and Math (default: what the document needs)
+npx -- rapier-html@1.2.43 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
+npx -- rapier-html@1.2.43 revised.md --compare original.md # opens showing what changed
+npx -- rapier-html@1.2.43 notes.md --return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT" # Send back
+npx -- rapier-html@1.2.43 notes.md out.html                 # a named output
+npm install rapier-html@1.2.43                              # as a library: writePage, unwrap
 ```
 
 The first `--` is for npm, so `--help` reaches the command. It never overwrites a file.

package/dist/ledger/data.mjs

@@ -44,11 +44,13 @@ function* quoted(text, whole = true) {
   }
   yield '"';
 }
-function* dataParts(value, depth, active, sorted) {
+function* dataParts(value, depth, active, sorted, known = null) {
   if (typeof value === 'string') { yield* quoted(value); return; }
   if (value === null || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0)) {
     yield JSON.stringify(value); return;
   }
+  const text = known?.(value, depth);
+  if (text !== undefined) { yield text; return; }
   const {array, descriptors, keys} = fields(value, depth, active, sorted);
   active.add(value);
   yield array ? '[' : '{';
@@ -56,14 +58,69 @@ function* dataParts(value, depth, active, sorted) {
     if (i) yield ',';
     const key = keys[i];
     if (!array) { yield* quoted(key, false); yield ':'; }
-    yield* dataParts(descriptors[key].value, depth + 1, active, sorted);
+    yield* dataParts(descriptors[key].value, depth + 1, active, sorted, known);
   }
   yield array ? ']' : '}';
   active.delete(value);
 }
 export function canonicalParts(value, depth = 0, active = new Set()) { return dataParts(value, depth, active, true); }
 export function jsonParts(value) { return dataParts(value, 0, new Set(), false); }
+export function jsonPartsKnown(value, known) { return dataParts(value, 0, new Set(), false, known); }
+export function jsonTextAt(value, depth) { return Array.from(dataParts(value, depth, new Set(), false)).join(''); }
 export function canonicalJSON(value, depth = 0, active = new Set()) { return Array.from(canonicalParts(value, depth, active)).join(''); }
+const ownedRows = new WeakSet(), rowCanonical = new Map();
+let rowCanonicalChars = 0;
+const ROW_CANONICAL_LIMIT = 32 * 1024 * 1024;
+function freezeData(value) {
+  if (!value || typeof value !== 'object' || ownedRows.has(value) || ownedLedgers.has(value)) return value;
+  for (const key of Object.keys(value)) freezeData(value[key]);
+  return Object.freeze(value);
+}
+export function ownRow(row) { if (!ownedRows.has(row)) { freezeData(row); ownedRows.add(row); } return row; }
+const ownedLedgers = new WeakSet();
+export function ownLedger(ledger) {
+  if (ledger && typeof ledger === 'object' && !ownedLedgers.has(ledger)) { freezeData(ledger); ownedLedgers.add(ledger); }
+  return ledger;
+}
+export function isOwnedLedger(ledger) { return !!ledger && ownedLedgers.has(ledger); }
+const rowText = new WeakMap();
+function canonicalRow(row, depth) {
+  if (!ownedRows.has(row)) return canonicalJSON(row, depth);
+  const own = rowText.get(row);
+  if (own?.depth === depth) return own.json;
+  const json = keyedRow(row, depth);
+  rowText.set(row, {depth, json});
+  return json;
+}
+function keyedRow(row, depth) {
+  const id = typeof row.transaction?.id === 'string' ? row.transaction.id : null, seen = JSON.stringify(row);
+  const hit = id === null ? null : rowCanonical.get(id);
+  if (hit && hit.depth === depth && hit.seen.includes(seen)) return hit.json;
+  const json = canonicalJSON(row, depth);
+  if (id !== null && 2 * seen.length + json.length <= ROW_CANONICAL_LIMIT / 4) {
+    const size = entry => entry.seen.reduce((sum, text) => sum + text.length, entry.json.length);
+    const seenAlso = hit && hit.depth === depth && hit.json === json ? [hit.seen.at(-1), seen] : [seen];
+    if (hit) { rowCanonical.delete(id); rowCanonicalChars -= size(hit); }
+    const entry = {depth, seen: seenAlso, json};
+    rowCanonical.set(id, entry); rowCanonicalChars += size(entry);
+    for (const [key, value] of rowCanonical) {
+      if (rowCanonicalChars <= ROW_CANONICAL_LIMIT) break;
+      rowCanonical.delete(key); rowCanonicalChars -= size(value);
+    }
+  }
+  return json;
+}
+const plainRowArrays = new WeakSet();
+export function* canonicalRowsParts(rows, depth = 0) {
+  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 < rows.length; i++) { if (i) yield ','; yield canonicalRow(rows[i], depth + 1); }
+  yield ']';
+}
 export function exactKeys(value, keys) {
   return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
 }

package/dist/ledger/format.mjs

@@ -4,16 +4,16 @@ import {pictureHistorySplices} from './history.mjs';
 import {HistorySource} from './source.mjs';
 import {authoredHistory} from './transport.mjs';
 import {textRoot, rootAfter, sha256, sha256PartsAsync, createSHA256} from './hash.mjs';
-import {canonicalJSON, canonicalParts, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
+import {canonicalJSON, canonicalParts, canonicalRowsParts, ownRow, ownLedger, isOwnedLedger, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
 import {diff} from './diff/diff.mjs';
 import {minimalHistorySplice} from './inverse-source.mjs';
 import {evaluateWill} from './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) ||
@@ -27,32 +27,47 @@ 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 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 plainData(input);
+  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 plainData(input);
+  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 plainData(input);
+  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 = plainData(shell);
+  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: ''}});
+  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);
+  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');
@@ -67,7 +82,7 @@ function readLedgerState(input, expectedText, expectedMetadata) {
 }
 function* proveLedger(ledger, native = false) {
   const {sha256: claimed, ...payload} = ledger;
-  if (claimed !== (yield* checksum(canonicalParts(payload), native))) throw fault('envelope checksum differs');
+  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');
@@ -151,6 +166,11 @@ function* sourceFacts(text, native = false) {
   return {utf8Bytes: bytes, sha256: digest, contentRoot: text.length + ':' +
     (fnv >>> 0).toString(36) + ':' + (((b << 16) | a) >>> 0).toString(36)};
 }
+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};
@@ -162,23 +182,40 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   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;
+  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;
@@ -187,20 +224,26 @@ 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(canonicalParts(payload), native)};
-  proofs.set(ledger, {shell: canonicalJSON({...ledger, start: {...ledger.start, text: ''}}), startText,
+  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),
     source: new HistorySource(text)});
   return {ledger, contentRoot, utf8Bytes: headBytes};
@@ -250,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) {
@@ -261,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/ledger/history.mjs

@@ -363,7 +363,7 @@ export function selectiveUndo(input, actIds, options = {}) {
 		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).outcome !== 'applied')
+			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};

package/dist/ledger/inverse-source.mjs

@@ -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;
@@ -280,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)} : {})};