rapier-html 1.1.104 → 1.2.3

package/BUILD.json

@@ -1,10 +1,10 @@
 {
   "package": "rapier-html",
-  "version": "1.1.104",
+  "version": "1.2.3",
   "path": "dist/rapier.html",
-  "bytes": 3565876,
-  "sha256": "11ef86ddc14ffd60276d7266331ae27bd47c3a4a395aedf8c8601a3a395ae5d9",
-  "builtAt": "2026-10-12T17:02:11.693Z",
+  "bytes": 5086203,
+  "sha256": "864fe7a94b5c3064653e2a7423449f439c0ab864062ec1644a88dee90c042af6",
+  "builtAt": "2026-10-14T16:53:28.260Z",
   "node": "v22.23.3",
   "canonical": true,
   "packing": "zopfli",
@@ -14,32 +14,39 @@
       "delivery": "built-in",
       "kind": "script",
       "element": "rapier-plugin-math",
-      "bytes": 714051,
-      "packedBytes": 495012,
+      "bytes": 749536,
+      "packedBytes": 504166,
       "files": [
         {
           "id": "rapier-math",
-          "name": "rapier-math-1.1.0.js",
-          "version": "1.1.0",
-          "bytes": 714051,
-          "sri": "dYIPrqCf4rrTcAKw1Zzzo7vujbNtk2C7Zik/tIYOaLVT0U66WOXcGNE6waFbKych"
+          "name": "rapier-math-2.2.0.js",
+          "version": "2.2.0",
+          "bytes": 749536,
+          "sri": "pzYte7azbAoS8XSwIKjFg7mxGOxAxBKo9/IUy07H4j0WoyguAS/zwkR1O6kDXq9S"
         }
       ]
     },
     {
       "id": "mermaid",
       "delivery": "built-in",
-      "kind": "script",
+      "kind": "files",
       "element": "rapier-plugin-mermaid",
-      "bytes": 292169,
-      "packedBytes": 102242,
+      "bytes": 7384142,
+      "packedBytes": 1563922,
       "files": [
         {
-          "id": "rapier-mermaid",
-          "name": "rapier-diagrams-1.1.104.js",
-          "version": "1.1.104",
-          "bytes": 292169,
-          "sri": "b+ByE92VMwroMyB4gJIAdisjv+ONeQERVFCCP9nBfchHTUxACYXg1YNbdm2bp7FT"
+          "id": "rapier-mermaid-core",
+          "name": "mermaid.min.js",
+          "version": "12.1.0",
+          "bytes": 5493176,
+          "sri": "EbBpjO7rlR6eqZEcG7GaPpyk9H9WrMyPWX4d3KvPYltgt8Z8l0z6R56B1qP40pR4"
+        },
+        {
+          "id": "rapier-mermaid-zenuml",
+          "name": "rapier-zenuml-4.5.0-1.js",
+          "version": "4.5.0-1",
+          "bytes": 1890966,
+          "sri": "MVn/Or1nIHTDvy84lSSJAH2Fx1Y7AGoaMfd7hW7i3LJe7M/dau8VDFnF8Q+X0qOl"
         }
       ]
     },

package/README.md

@@ -2,7 +2,7 @@
 
 Turn Markdown into one offline HTML file with the full Rapier editor. It opens in any browser on a phone or
 computer, with no account. People read, edit, draw and paint watercolor. Agents deliver documents, show what
-changed and receive the person's edited copy through the door. Start with `npx rapier-html@1.1.104 notes.md`.
+changed and receive the person's edited copy through the door. Start with `npx rapier-html@1.2.3 notes.md`.
 
 Use it for a plan to rearrange, an illustrated guide to annotate, a draft to continue writing, or a revision
 to review. Text and drawings stay editable, and the file remains usable independently of a hosted workspace.
@@ -18,14 +18,14 @@ to review. Text and drawings stay editable, and the file remains usable independ
 Node 22 or newer.
 
 ```sh
-npx -- rapier-html@1.1.104 notes.md                          # the editor, notes.md inside it, written beside the file
-npx -- rapier-html@1.1.104 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
-npx -- rapier-html@1.1.104 notes.md --view notes             # opens the Notes library
-npx -- rapier-html@1.1.104 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
-npx -- rapier-html@1.1.104 revised.md --compare original.md # opens showing what changed
-npx -- rapier-html@1.1.104 notes.md --return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT" # Send back
-npx -- rapier-html@1.1.104 notes.md out.html                 # a named output
-npm install rapier-html@1.1.104                              # as a library: wrap, unwrap
+npx -- rapier-html@1.2.3 notes.md                          # the editor, notes.md inside it, written beside the file
+npx -- rapier-html@1.2.3 notes.md --view draw              # opens on Draw: sketch and paint, the document behind it
+npx -- rapier-html@1.2.3 notes.md --view notes             # opens the Notes library
+npx -- rapier-html@1.2.3 notes.md --drawing sketch.svg     # carries a drawing, opened on Draw over the document
+npx -- rapier-html@1.2.3 revised.md --compare original.md # opens showing what changed
+npx -- rapier-html@1.2.3 notes.md --return "$RETURN_URL" --return-expires-at "$RETURN_EXPIRES_AT" # Send back
+npx -- rapier-html@1.2.3 notes.md out.html                 # a named output
+npm install rapier-html@1.2.3                              # as a library: wrap, unwrap
 ```
 
 The first `--` is for npm, so `--help` reaches the command. It never overwrites a file.
@@ -46,8 +46,8 @@ Collaborate over MCP and WebMCP, use optional encrypted sync to your own Cloudfl
 editor and lightweight reader (about 190 kB gzipped). The agent edits live; the person sees its presence and
 changes, taps a change to see the before and undoes anything. Use `show {target:"comparison"}` to show a diff deliberately.
 
-1. **Work together live.** Connect to `https://mcp.rapier.website/mcp`, then call `open` to share one document with the person.
-2. **Deliver an offline editor.** Run `npx rapier-html@1.1.104 notes.md` to put the document and editor in one HTML file ([rapier-html](https://github.com/jackskip22/rapier-plugins/tree/main/npm/rapier-html)).
+1. **Work together live.** Connect to `https://mcp.rapier.website/door/mcp`, then call `open` to share one document with the person.
+2. **Deliver an offline editor.** Run `npx rapier-html@1.2.3 notes.md` to put the document and editor in one HTML file ([rapier-html](https://github.com/jackskip22/rapier-plugins/tree/main/npm/rapier-html)).
 3. **Embed in your app.** Install [rapier-embed](https://github.com/jackskip22/rapier-plugins/tree/main/npm/rapier-embed); mount the editor or reader, with your app's agent over WebMCP in the editor.
 4. **Keep portable Markdown.** Use [rapier-markdown-kit](https://github.com/jackskip22/rapier-plugins/tree/main/npm/rapier-markdown-kit) for pictures, editable SVG drawings and layout in one `.md` file. Respect [Will/1](https://github.com/jackskip22/will) `keep`, `append` and `edit` regions.
 5. **Encode JPEG XL.** Install [rapier-jxl](https://github.com/jackskip22/rapier-jxl) to encode pixels, photographs and existing JPEGs in JavaScript.

package/dist/ledger/LICENSE

@@ -21,8 +21,11 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 Files under this licence carry `SPDX-License-Identifier: MIT` in their first lines: the standard's
-grammar, marks and reference style (`spec/md-layout.mjs`, `spec/md-marks.mjs`, `spec/md-source.mjs`, `spec/flowchart.mjs`, `spec/markdown-style.css`), the layout model and line planner
-(`layout/model.mjs`, `layout/line-plan.mjs`, `layout/typography.mjs`, `layout/preparation.mjs`),
+grammar, marks and reference style (`spec/md-layout.mjs`, `spec/md-marks.mjs`, `spec/md-source.mjs`, `spec/flowchart.mjs`, `spec/markdown-style.css`), ink geometry
+(`spec/ink.mjs`),
+the layout model and line planner (`layout/model.mjs`, `layout/line-plan.mjs`, `layout/typography.mjs`, `layout/preparation.mjs`,
+`layout/prepared-paragraph.mjs`, `layout/hyphenation.mjs`, `layout/paragraph-fit.mjs`), the animated-picture reader and playback
+the HTML blocks use (`images/gif.mjs`, `images/playback.mjs`),
 the portable HTML and document metadata helpers (`spec/html-blocks.mjs`, `spec/frontmatter.mjs`,
 `spec/document-settings.mjs`, `spec/document-fonts.mjs`), the Will grammar (`agent/will.mjs`), the picture appendix reader and writer
 (`spec/md-assets.mjs`), the two shared-page reference readers (`tools/read-shared-page.mjs`,

package/dist/ledger/carried.mjs

@@ -73,7 +73,7 @@ export function readDocument(source) {
 export function readBase(value) {
   if (!value || typeof value !== 'object') throw fault('comparison base SHA-256 differs from its text');
   // Capture each caller-owned field once; admission and serialization use these same scalars.
-  const {text, sha256: digest, revision, name, by, at} = value;
+  const {text, sha256: digest, revision, name, by, at, fonts} = value;
   if (typeof text !== 'string' || typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest) || sha256(text) !== digest)
     throw fault('comparison base SHA-256 differs from its text');
   if (typeof revision !== 'string' || !revision || revision.length > 256 || /[\u0000-\u001f\u007f]/.test(revision))
@@ -84,7 +84,8 @@ export function readBase(value) {
     throw fault('a comparison needs its author name');
   if (typeof at !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(at) || !Number.isFinite(Date.parse(at)))
     throw fault('the time of a comparison is an ISO 8601 UTC timestamp');
-  return {text, sha256: digest, revision, name, by, at};
+  if (fonts != null && typeof fonts !== 'string') throw fault('invalid comparison font resources');
+  return {text, sha256: digest, revision, name, by, at, ...(fonts ? {fonts} : {})};
 }
 const escapeAttribute = value => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 const readAttribute = value => value.replace(/&(quot|lt|gt|amp);/g, (_, name) => ({quot: '"', lt: '<', gt: '>', amp: '&'})[name]);
@@ -93,7 +94,8 @@ export function writeBase(text, value) {
   const base = readBase(value);
   if (base.text === text) return '';
   return '<script type="text/markdown" id="rapier-base"' + ['name', 'sha256', 'revision', 'by', 'at']
-    .map(key => ' data-' + key + '="' + escapeAttribute(base[key]) + '"').join('') + '>' + encodeCarried(base.text) + '</script>';
+    .map(key => ' data-' + key + '="' + escapeAttribute(base[key]) + '"').join('') +
+    (base.fonts ? ' data-fonts="' + escapeAttribute(JSON.stringify(base.fonts)) + '"' : '') + '>' + encodeCarried(base.text) + '</script>';
 }
 export function readBaseElements(elements) {
   const rows = [...elements].filter(element => element.id === 'rapier-base');
@@ -102,7 +104,10 @@ export function readBaseElements(elements) {
   if (rows.length !== 1 || row.type !== 'text/markdown' || (row.tagName && row.tagName.toLowerCase() !== 'script'))
     throw fault('duplicate or executable comparison base');
   const get = name => row.getAttribute ? row.getAttribute('data-' + name) : row[name];
-  return readBase({text: decodeCarried(row.textContent), ...Object.fromEntries(['name', 'sha256', 'revision', 'by', 'at'].map(key => [key, get(key)]))});
+  let fonts;
+  try { const value = get('fonts'); if (value != null) fonts = JSON.parse(value); }
+  catch (_) { throw fault('invalid comparison font resources'); }
+  return readBase({text: decodeCarried(row.textContent), fonts, ...Object.fromEntries(['name', 'sha256', 'revision', 'by', 'at'].map(key => [key, get(key)]))});
 }
 export function takeBase(html) {
   const elements = [];
@@ -115,7 +120,7 @@ export function takeBase(html) {
       seen.add(key); values[key] = value;
     }
     elements.push({id: values.id, type: values.type, textContent: content,
-      ...Object.fromEntries(['name', 'sha256', 'revision', 'by', 'at'].map(key => [key, values['data-' + key]]))});
+      ...Object.fromEntries(['name', 'sha256', 'revision', 'by', 'at', 'fonts'].map(key => [key, values['data-' + key]]))});
     return '';
   });
   return {html: stripped, base: readBaseElements(elements)};

package/dist/ledger/diff.mjs

@@ -68,7 +68,7 @@ export function diff(before, after, options = {}) {
   const initial = budget.left, raw = options._unit;
   let result = [], code = options.as === 'code', structures, pa, pb, la, lb, aliases;
   const spend = (n = 1) => (budget.left -= n) >= 0;
-  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c);
+  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c), within = (text, at) => letter(text[at - 1]) && letter(text[at]);
   const overlaps = (a, b) => a[0] < b[1] && a[1] > b[0];
   const inside = (c, a, b) => [a, b].every((range, side) => c[side][0] === c[side][1] ||
     c[side][0] >= range[0] && c[side][1] <= range[1]);
@@ -146,7 +146,11 @@ export function diff(before, after, options = {}) {
         if (!count) continue;
         // A chain is admitted only after visiting every candidate. Reject a
         // search whose mandatory visits cannot fit before allocating its nodes.
-        if ((unique || count) > Math.min(131072 - nodes, budget.left)) { budget.left = -1; continue; }
+        if ((unique || count) > Math.min(131072 - nodes, budget.left)) {
+          // Repetitive text has too many equal pairs; a shortest script needs no anchors.
+          if (!shortest(a, b, a0, a1, b0, b1, found) && budget.left >= 0) (found.coarse ||= new Set()).add(a0);
+          continue;
+        }
       }
       search: for (let i = a0; i < a1; i++) {
         const list = positions[a[i]];
@@ -178,6 +182,27 @@ export function diff(before, after, options = {}) {
     return found;
   }
 
+  // Myers' greedy search: O((N + M) D) steps; each frontier is kept for the backward pass.
+  function shortest(a, b, a0, a1, b0, b1, found) {
+    const n = a1 - a0, m = b1 - b0, v = new Int32Array(2 * (n + m) + 3), o = n + m + 1, trace = [];
+    for (let d = 0; d <= 2048 && spend(2 * d + 1); d++) {
+      trace.push(v.slice(o - d, o + d + 1));
+      for (let k = -d; k <= d; k += 2) {
+        let x = k === -d || k !== d && v[o + k - 1] < v[o + k + 1] ? v[o + k + 1] : v[o + k - 1] + 1, y = x - k;
+        while (x < n && y < m && a[a0 + x] === b[b0 + y] && spend()) { x++; y++; }
+        v[o + k] = x;
+        if (x < n || y < m) continue;
+        for (x = n, y = m; d >= 0; d--) {
+          const w = trace[d], k = x - y, prev = k === -d || k !== d && w[d + k - 1] < w[d + k + 1] ? k + 1 : k - 1;
+          const px = d ? w[d + prev] : 0, py = px - prev;
+          while (x > px && y > py) if (a[a0 + --x] === b[b0 + --y]) found[a0 + x] = b0 + y;
+          x = px; y = py;
+        }
+        return true;
+      }
+    }
+  }
+
   // A search step scans at most one fixed-size source chunk.
   function common(a, b, end, step) {
     let n = 0;
@@ -195,14 +220,18 @@ export function diff(before, after, options = {}) {
     const structural = level <= 0 && level > -128 && (ap?.length || bp?.length);
     if (!structural && raw !== 'word') {
       let n = common(a0, b0, Math.min(a1 - a0, b1 - b0), 1);
-      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n))) { if (!spend()) { n = 0; break; } n--; }
+      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n) || !raw && level < 3 && (within(before, a0 + n) || within(after, b0 + n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
       if (level === 1 && n) {
         const next = Math.max(0, before.lastIndexOf('\n', a0 + n - 1) + 1 - a0);
         spend(Math.ceil((n - next) / 256)); n = next;
       }
       a0 += n; b0 += n;
       n = common(a1 - 1, b1 - 1, Math.min(a1 - a0, b1 - b0), -1);
-      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n))) { if (!spend()) { n = 0; break; } n--; }
+      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n) || !raw && level < 3 && (within(before, a1 - n) || within(after, b1 - n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
       if (level === 1) while (n && (before[a1 - n - 1] !== '\n' || after[b1 - n - 1] !== '\n' || before[a1 - n] === '\n' || after[b1 - n] === '\n')) { if (!spend()) { n = 0; break; } n--; }
       a1 -= n; b1 -= n;
       if (budget.left < 0) { record(a0, a1, b0, b1, 'block', context, true); return; }
@@ -220,7 +249,7 @@ export function diff(before, after, options = {}) {
       if (j === undefined) continue;
       const x0 = x[ai], x1 = x[i], y0 = y[bi], y1 = y[j];
       if (ai < i || bi < j) {
-        if (budget.left < 0) record(x0, x1, y0, y1, unit, context, true);
+        if (budget.left < 0 || pairs.coarse?.has(ai)) record(x0, x1, y0, y1, unit, context, true);
         else if (structural && (ai === i || bi === j)) {
           for (let k = ai; k < i; k++) record(x[k], x[k + 1], y0, y0, unit, ownersA[k] || context);
           for (let k = bi; k < j; k++) record(x1, x1, y[k], y[k + 1], unit, ownersB[k] || context);
@@ -233,12 +262,9 @@ export function diff(before, after, options = {}) {
           const start = result.length;
           walk(x0, x1, y0, y1, 3, null, null, context);
           const edits = result.slice(start);
+          // A letter-sized correction stays a letter; any other word change marks the whole word.
           if (edits.length !== 1 || edits[0][0][1] - edits[0][0][0] + edits[0][1][1] - edits[0][1][0] > Math.max(2, (x1 - x0 + y1 - y0) / 3)) {
-            const reading = [[x0, x1], [y0, y1]], group = [edits[0][3][0], context?.kind || 'word', edits[0][3][2], reading];
-            for (const edit of edits) {
-              if (group[0] !== edit[3][0]) group[0] = 1;
-              edit[3] = group;
-            }
+            result.length = start; record(x0, x1, y0, y1, unit, context);
           }
         } else record(x0, x1, y0, y1, unit, context);
       }
@@ -328,6 +354,23 @@ export function diff(before, after, options = {}) {
   else walk(0, before.length, 0, after.length, structures ? 0 : raw === 'char' ? 3 : raw === 'word' ? 2 : 1,
     structures?.[0]?.parts, structures?.[1]?.parts);
 
+  // A separator-only piece beside another edit joins it; equal separators at its ends stay unchanged.
+  if (!raw) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
+    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+      let n = 0;
+      while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n]) n++;
+      if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
+        for (const span of p.slice(0, 2)) { span[0] += n; span[1] += n; }
+    }
+    if (p[2] || q[2] || p[0][1] !== q[0][0] || p[1][1] !== q[1][0] ||
+      ![p, q].some(r => !/\S/.test(before.slice(...r[0]) + after.slice(...r[1])))) continue;
+    const x = [p[0][0], q[0][1]], y = [p[1][0], q[1][1]], keep = /\S/.test(before.slice(...q[0]) + after.slice(...q[1])) ? q : p;
+    while (x[0] < x[1] && y[0] < y[1] && /\s/.test(before[x[1] - 1]) && before[x[1] - 1] === after[y[1] - 1] &&
+      safe(before, x[1] - 1) && safe(after, y[1] - 1)) { x[1]--; y[1]--; }
+    keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
+    result.splice(i - 1, 2, [x, y, false, keep[3]]);
+  }
   try { if (!raw && budget.left >= 0) {
     const check = n => { if (!spend(n)) throw null; };
     // Split transported text at wording boundaries; positions and words own distinct edits.
@@ -353,11 +396,14 @@ export function diff(before, after, options = {}) {
         if (n * 5 > Math.max(prior.length, key.length) * 3 && n >= score) { old = n === score ? null : candidate; score = n; }
       }
       if (!old || old[4]) continue;
-      const x = [...old[0]], y = [...item[1]], left = before.slice(...x).match(/\s*$/)[0], right = after.slice(...y).match(/\s*$/)[0];
-      let common = 0;
-      while (common < Math.min(left.length, right.length) && left[common] === right[common]) common++;
-      if (common && safe(before, x[1] - left.length + common) && safe(after, y[1] - right.length + common)) {
-        x[1] -= left.length - common; y[1] -= right.length - common;
+      // Separators that only one end carries stay outside the transported text.
+      const x = [...old[0]], y = [...item[1]];
+      for (const end of [0, 1]) {
+        const pattern = end ? /\s*$/ : /^\s*/, left = before.slice(...x).match(pattern)[0], right = after.slice(...y).match(pattern)[0];
+        let common = 0;
+        while (common < Math.min(left.length, right.length) && left.at(end ? common : -1 - common) === right.at(end ? common : -1 - common)) common++;
+        const dx = (left.length - common) * (end ? -1 : 1), dy = (right.length - common) * (end ? -1 : 1);
+        if (safe(before, x[end] + dx) && safe(after, y[end] + dy)) { x[end] += dx; y[end] += dy; }
       }
       const outer = result; result = [];
       walk(...x, ...y, 1);
@@ -371,7 +417,8 @@ export function diff(before, after, options = {}) {
         if (a0 < a1) old[4].push([[a0, a1], [old[1][0], old[1][0]], false, group]);
         if (b0 < b1) item[4].push([[item[0][0], item[0][0]], [b0, b1], false, group]);
       };
-      let a = old[0][0], b = item[1][0], wording;
+      fragment(old[0][0], x[0], 0, 0, [0, 'char']); fragment(0, 0, item[1][0], y[0], [2, 'char']);
+      let a = x[0], b = y[0], wording;
       for (const edit of inner) {
         if (edit[3][3]) wording = edit[3];
         else if (a !== edit[0][0] || b !== edit[1][0]) wording = [edit[3][0], edit[3][1]];
@@ -428,6 +475,14 @@ export function diff(before, after, options = {}) {
     result = result.flatMap(item => item[4] || [item]);
   }
 
+  // Whole-word replacements separated only by spaces read and restore as one phrase.
+  if (!raw && !code) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], gap = before.slice(p[0][1], q[0][0]);
+    if (p[3][0] !== 1 || q[3][0] !== 1 || p[3][3] || q[3][3] || p[2] || q[2] || !/^[^\S\r\n]+$/.test(gap) ||
+      gap !== after.slice(p[1][1], q[1][0]) || within(before, p[0][0]) || within(after, p[1][0]) ||
+      within(before, q[0][1]) || within(after, q[1][1])) continue;
+    p[0][1] = q[0][1]; p[1][1] = q[1][1]; result.splice(i, 1);
+  }
   const changes = [], edits = [];
   let normalized;
   const meaning = structures?.[0]?.meaning;
@@ -453,9 +508,11 @@ export function diff(before, after, options = {}) {
     if (!raw && !group[3]) group[3] = [[...item[0]], [...item[1]]];
     if (!group[4]) {
       const context = group[3];
+      // Context completes a word only where an edge falls inside it.
       if (!raw) for (const [text, span] of [[before, context[0]], [after, context[1]]]) {
-        while (span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
-        while (span[1] < text.length && spend() && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
+        const start = within(text, span[0]), end = within(text, span[1]);
+        while (start && span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
+        while (end && span[1] < text.length && spend() && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
       }
       group[4] = []; changes.push(group);
       if (format) group[0] = 5;
@@ -463,20 +520,6 @@ export function diff(before, after, options = {}) {
     group[4].push(edits.length);
     edits.push({before: item[0], after: item[1], ...(item[2] ? {coarse: true} : {})});
   }
-  if (!raw && !structures && !code && !evidence) for (let i = 0; i < changes.length; i++) {
-    let end = i + 1;
-    for (; end < changes.length; end++) {
-      const a = changes[end - 1], b = changes[end];
-      const gap = before.slice(a[3][0][1], b[3][0][0]);
-      if (a[0] !== 1 || b[0] !== 1 || a[1] !== 'word' || b[1] !== 'word' ||
-        /\S|\r|\n/.test(gap) || gap !== after.slice(a[3][1][1], b[3][1][0])) break;
-    }
-    if (end - i < 4) continue;
-    const group = changes[i]; group[1] = 'sentence';
-    for (const next of changes.splice(i + 1, end - i - 1)) {
-      group[4].push(...next[4]); group[3][0][1] = next[3][0][1]; group[3][1][1] = next[3][1][1];
-    }
-  }
   if (structures && !raw && budget.left >= 0) {
     const oldNames = new Set(pa.filter(p => p.nameAt).map(p => p.name)), newNames = new Set(pb.filter(p => p.nameAt).map(p => p.name));
     for (const change of changes) {

package/dist/ledger/format.mjs

@@ -62,6 +62,15 @@ function readLedgerState(input, expectedText, expectedMetadata) {
       (expectedText !== undefined && text !== expectedText)) throw fault('history does not describe this document');
   return {value: {ledger, text, metadata, root, revision, complete: ledger.complete}, prepared, source};
 }
+// A stored copy may hold the head text alone. Its start is that text with every record reversed; readLedger proves it.
+export function ledgerWithStart(input, text) {
+  let source = new HistorySource(documentText(text));
+  for (let i = input.records.length - 1; i >= 0; i--) {
+    source = source.apply(input.records[i].splices, true);
+    if (source === null) throw fault('history does not reverse from this document');
+  }
+  return {...input, start: {...input.start, text: source.slice()}};
+}
 export function readLedger(input, expectedText, expectedMetadata) {
   return readLedgerState(input, expectedText, expectedMetadata).value;
 }
@@ -182,8 +191,8 @@ export async function prepareLedgerAsync(input, {yield: yieldWork, signal} = {})
   return step.value;
 }
 // Derived navigation, never a second history. A target older than start is intentionally unavailable.
-export function historyEnvelope(input, segmentIdentity = []) {
-  const {value: {ledger, text, metadata}, prepared, source} = readLedgerState(input);
+export function historyEnvelope(input, segmentIdentity = [], expectedText, expectedMetadata) {
+  const {value: {ledger, text, metadata}, prepared, source} = readLedgerState(input, expectedText, expectedMetadata);
   const {byId, effects: {pictures}} = prepared;
   let branch = [], cursor = 0;
   for (const {transaction: tx} of ledger.records) {
@@ -198,7 +207,7 @@ export function historyEnvelope(input, segmentIdentity = []) {
   }
   const step = (source, id, redo) => {
     const target = byId.get(id), folded = pictures.size
-      ? pictureHistorySplices({source: source.slice(), records: prepared.records}, target, redo) : null;
+      ? pictureHistorySplices({get source() { return source.slice(); }, records: prepared.records}, target, redo) : null;
     return source.apply(folded || target.splices, !folded && !redo);
   };
   let traversed = source, traversedMetadata = {...metadata};

package/dist/ledger/hash.mjs

@@ -30,13 +30,11 @@ const K = new Uint32Array([
   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
 ]);
 const rotate = (x, n) => (x >>> n) | (x << (32 - n));
-// A bounded encoder and one compression block. No full UTF-8 or padded-input copy.
-// Updates retain a trailing high surrogate so an arbitrary string boundary stays exact.
-export function createSHA256() {
+// One bounded SHA-256 compression state for file bytes and encoded source text.
+export function sha256State() {
   const h = new Uint32Array([0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19]);
-  const w = new Uint32Array(64), block = new Uint8Array(64), encoded = new Uint8Array(65536);
-  const encoder = new TextEncoder();
-  let used = 0, bytes = 0, high = '', finished = false;
+  const w = new Uint32Array(64), block = new Uint8Array(64);
+  let used = 0, bytes = 0, finished = false;
   const compress = (input, offset) => {
     for (let i = 0; i < 16; i++) {
       const at = offset + i * 4;
@@ -65,13 +63,37 @@ export function createSHA256() {
     for (; at + 64 <= size; at += 64) compress(input, at);
     if (at < size) { block.set(input.subarray(at, size), 0); used = size - at; }
   };
+  return {
+    update(input) {
+      if (finished || !(input instanceof Uint8Array)) throw new TypeError('SHA-256 needs bytes before finish');
+      if (!Number.isSafeInteger(bytes + input.length)) throw new Error('SHA-256 input length is not exact');
+      feed(input, input.length);
+    },
+    finish() {
+      if (finished) throw new Error('SHA-256 is already finished');
+      finished = true;
+      block[used++] = 0x80; block.fill(0, used);
+      if (used > 56) { compress(block, 0); block.fill(0); }
+      const view = new DataView(block.buffer);
+      view.setUint32(56, Math.floor(bytes / 0x20000000)); view.setUint32(60, (bytes * 8) >>> 0);
+      compress(block, 0);
+      return Array.from(h, x => x.toString(16).padStart(8, '0')).join('');
+    },
+    get bytes() { return bytes; },
+  };
+}
+// UTF-16 chunks share that byte state. Retain a trailing high surrogate so a
+// caller can split a character between updates without changing its UTF-8 digest.
+export function createSHA256() {
+  const hash = sha256State(), encoded = new Uint8Array(65536), encoder = new TextEncoder();
+  let high = '', finished = false;
   const write = text => {
     for (let at = 0; at < text.length;) {
       // Bound both the substring and byte allocation; encodeInto never cuts a scalar.
       let end = Math.min(text.length, at + 32768);
       if (end < text.length && (text.charCodeAt(end - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(end) & 0xfc00) === 0xdc00) end--;
       const part = encoder.encodeInto(text.slice(at, end), encoded);
-      feed(encoded, part.written); at += part.read;
+      hash.update(encoded.subarray(0, part.written)); at += part.read;
     }
   };
   return {
@@ -85,15 +107,9 @@ export function createSHA256() {
       if (finished) throw new Error('SHA-256 is finished');
       if (high) { write(high); high = ''; }
       finished = true;
-      const bits = bytes * 8;
-      block[used++] = 0x80; block.fill(0, used);
-      if (used > 56) { compress(block, 0); block.fill(0); }
-      const view = new DataView(block.buffer);
-      view.setUint32(56, Math.floor(bits / 0x100000000)); view.setUint32(60, bits >>> 0);
-      compress(block, 0);
-      return Array.from(h, x => x.toString(16).padStart(8, '0')).join('');
+      return hash.finish();
     },
-    get bytes() { return bytes; },
+    get bytes() { return hash.bytes; },
   };
 }
 export function sha256Parts(parts) {

package/dist/ledger/history.mjs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 // Transient projections and selective inverses of the existing canonical journal.
-import {_rapierTransformSplices, _rapierRecordSplices, _rapierRecordMetadata, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata, _rapierPrepareHistoryRecords} from './journal-records.mjs';
+import {_rapierTransformSplices, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierPrepareHistoryRecords} from './journal-records.mjs';
 import {projectInverseSource, HistorySource} from './inverse-source.mjs';
 import {textRootParts, rootAfter} from './hash.mjs';
 import {authoredHistory} from './transport.mjs';
@@ -43,11 +43,15 @@ export function groupHistoryActs(acts) {
 
 // A picture's codec replacement travels with its original navigation step.
 // Match every complete replacement exactly before moving any source bytes.
-export function pictureHistorySplices({source, records}, target, redo) {
+export function pictureHistorySplices(input, target, redo) {
+	const {records} = input;
 	const id = target?.transaction?.id, at = records.indexOf(target);
 	if (!id || at < 0 || target.transaction.operation === 'document.finish-picture' || !Array.isArray(target.splices)) return null;
 	const later = records.slice(at + 1).filter(row => row?.transaction?.operation === 'document.finish-picture' && Array.isArray(row.splices) && row.splices.length);
 	if (!later.length) return null;
+	// A caller may hold a persistent source tree: request its text only when
+	// a later picture replacement can actually affect this navigation step.
+	const source = input.source;
 	const own = new Set(later.filter(row => row.transaction.sourceTransactionId === id));
 	const step = redo ? target.splices : target.splices.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
 	const plan = moveOthers => {
@@ -116,7 +120,9 @@ function prepareHistory(input) {
 			row.beforeSource = initial; row.beforeMetadata = initialMetadata;
 		}
 		const earliestRevision = records[0]?.transaction.baseRevision ?? revision;
-		let root = earliestRevision === 0 ? textRootParts(initial.parts()) : null, rootRevision = earliestRevision;
+		// The window's owner may name its root (the source store mints it once per text); otherwise hash the initial text.
+		let root = earliestRevision === 0 ? (typeof input.earliestRoot === 'string' && input.earliestRoot || textRootParts(initial.parts())) : null,
+			rootRevision = earliestRevision;
 		for (const {record, splices} of rows) {
 			const hashed = Object.hasOwn(record, 'beforeHash') || Object.hasOwn(record, 'afterHash');
 			if (hashed && (![record.beforeHash, record.afterHash].every(value =>
@@ -281,9 +287,15 @@ export function historyPlaces(input, blocks) {
 			}
 			touched.set(node, after);
 		});
+		// Blocks one splice covers share its range (a whole-document delete maps every block to all it removed): slice each range once.
+		const slices = new Map(), cut = (source, side, from, to) => {
+			const key = side + from + ':' + to;
+			if (!slices.has(key)) slices.set(key, source.slice(from, to));
+			return slices.get(key);
+		};
 		for (const [node, afterRange] of touched) {
-			const beforeRange = ranges.range(node), previous = {...beforeRange, source: beforeSource.slice(beforeRange.from, beforeRange.to)},
-				after = {...afterRange, source: afterSource.slice(afterRange.from, afterRange.to)};
+			const beforeRange = ranges.range(node), previous = {...beforeRange, source: cut(beforeSource, 'b', beforeRange.from, beforeRange.to)},
+				after = {...afterRange, source: cut(afterSource, 'a', afterRange.from, afterRange.to)};
 			if (previous.source !== after.source) node.block.acts.push({...historyAct(record), before: previous, after});
 		}
 	}