gutterpress 0.10.1-beta.1 → 0.10.1-beta.3

package/dist/api/index.js

@@ -95,12 +95,12 @@ import {
   syncProject,
   testRemoteAccess,
   validateProjectPlugins
-} from "../index-6g72h2n1.js";
+} from "../index-7faw7w8v.js";
 import {
   BuildError,
   DEFAULT_PRINT_OPTS,
   readyProbeExpr
-} from "../index-b2rqw41a.js";
+} from "../index-7hrvksrb.js";
 import {
   AUTO_SNAPSHOT_MESSAGE,
   HISTORY_PAGE_LIMIT,

package/dist/{audit-7a37g51p.js → audit-sse9r5rm.js}

@@ -1,15 +1,15 @@
 import {
   executeAndReport
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/{build-kdaet3pd.js → build-9dn6r6ak.js}

@@ -1,10 +1,10 @@
 import {
   runBuild,
   splitOutPath
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   parseEngine,
@@ -12,8 +12,8 @@ import {
   parsePdfxFlavor,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   BuildError

package/dist/{cli-ak1tagkr.js → cli-eewynen9.js}

@@ -1422,13 +1422,13 @@ var favicon_default = "./favicon-wkbm9cjn.ico";
 var manifest_schema_default = "./manifest.schema-zxgxnbg7.json";
 
 // src/assets/preview/scripts/preview-interface.js
-var preview_interface_default = "./preview-interface-0ssk8bmm.js";
+var preview_interface_default = "./preview-interface-2f5v96hd.js";
 
 // src/assets/preview/scripts/preview-bridge.js
-var preview_bridge_default = "./preview-bridge-fz7vpk8m.js";
+var preview_bridge_default = "./preview-bridge-2nnrs2hy.js";
 
 // src/assets/preview/scripts/preview-shell.js
-var preview_shell_default = "./preview-shell-c5mfa3q0.js";
+var preview_shell_default = "./preview-shell-kyjq59d9.js";
 
 // profiles/CGATS21_CRPC1.icc
 var CGATS21_CRPC1_default = "./CGATS21_CRPC1-g0e3k7kr.icc";

package/dist/{cli-dx6sxj2t.js → cli-jhvkcwvf.js}

@@ -4,7 +4,7 @@ import {
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.10.1-beta.1",
+  version: "0.10.1-beta.3",
   description: "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   author: "itlackey",
   license: "MPL-2.0",

package/dist/{cli-mcb484g3.js → cli-qxebvmrq.js}

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "./cli-dx6sxj2t.js";
+} from "./cli-jhvkcwvf.js";
 import {
   execCapture,
   findTool,

package/dist/{cli-df7gcyns.js → cli-wtyzagaq.js}

@@ -13,12 +13,12 @@ import {
   stampCreator,
   stripAnnotations,
   warn
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   DEBOUNCE,
   UsageError,
   resolvePort
-} from "./cli-dx6sxj2t.js";
+} from "./cli-jhvkcwvf.js";
 import {
   MARGIN_BOX_IGNORED_PROPERTIES,
   RENDER_TIMEOUT_MS,
@@ -27,7 +27,7 @@ import {
   getAssetPath,
   getBrowser,
   prewarmBrowser
-} from "./cli-ak1tagkr.js";
+} from "./cli-eewynen9.js";
 import {
   INSTALL_HINTS,
   execCapture,
@@ -7521,7 +7521,7 @@ class PdfOutput {
       const rawPdf = pdfxMode ? path8.join(stage, "raw.pdf") : path8.resolve(pdfFile);
       await fsp2.mkdir(path8.dirname(path8.resolve(pdfFile)), { recursive: true });
       log.info("Rendering HTML to PDF via the Gutterpress engine (native Chromium pagination)");
-      const { buildNativePdf } = await import("./engine-gkcqdye5.js");
+      const { buildNativePdf } = await import("./engine-57vw8zpd.js");
       const engineDiagnostics = await buildNativePdf(htmlFile, rawPdf, {
         title: config.title,
         author: config.authors.length > 0 ? config.authors.join(", ") : undefined,

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   UsageError,
   package_default,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
+} from "./cli-jhvkcwvf.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
@@ -18,16 +18,16 @@ import {
 import { defineCommand, parseArgs, runMain } from "citty";
 import { statSync } from "node:fs";
 var SUBCOMMANDS = {
-  new: () => import("./new-4cdzfbsj.js").then((m) => m.default),
-  preview: () => import("./preview-k8n2kew7.js").then((m) => m.default),
-  build: () => import("./build-kdaet3pd.js").then((m) => m.default),
-  publish: () => import("./publish-jnhjp2vd.js").then((m) => m.default),
-  lint: () => import("./lint-p6a4bkvh.js").then((m) => m.default),
-  validate: () => import("./validate-prnybpkx.js").then((m) => m.default),
-  audit: () => import("./audit-7a37g51p.js").then((m) => m.default),
-  preflight: () => import("./preflight-r4y3f8f9.js").then((m) => m.default),
-  doctor: () => import("./doctor-vajd5h45.js").then((m) => m.default),
-  plugin: () => import("./plugin-a89tqspy.js").then((m) => m.default)
+  new: () => import("./new-aj8be9p9.js").then((m) => m.default),
+  preview: () => import("./preview-c4d698wn.js").then((m) => m.default),
+  build: () => import("./build-9dn6r6ak.js").then((m) => m.default),
+  publish: () => import("./publish-ft5x1e5v.js").then((m) => m.default),
+  lint: () => import("./lint-bbc9qk1h.js").then((m) => m.default),
+  validate: () => import("./validate-wp7rgg1y.js").then((m) => m.default),
+  audit: () => import("./audit-sse9r5rm.js").then((m) => m.default),
+  preflight: () => import("./preflight-hq060mas.js").then((m) => m.default),
+  doctor: () => import("./doctor-pswwk1nm.js").then((m) => m.default),
+  plugin: () => import("./plugin-raq1arqq.js").then((m) => m.default)
 };
 var VERSION = package_default.version;
 var main = defineCommand({
@@ -52,7 +52,7 @@ async function preflightRequiredInvocations(rawArgs) {
   const [command, ...commandArgs] = rawArgs;
   try {
     if (command === "new") {
-      const { newArgs } = await import("./new-4cdzfbsj.js");
+      const { newArgs } = await import("./new-aj8be9p9.js");
       rejectUnknownFlags(commandArgs, newArgs, "new");
       const parsed2 = parseArgs(commandArgs, {
         ...newArgs,
@@ -64,7 +64,7 @@ async function preflightRequiredInvocations(rawArgs) {
       return;
     }
     if (command === "preflight") {
-      const { preflightArgs } = await import("./preflight-r4y3f8f9.js");
+      const { preflightArgs } = await import("./preflight-hq060mas.js");
       rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
       const parsed2 = parseArgs(commandArgs, {
         ...preflightArgs,
@@ -88,7 +88,7 @@ async function preflightRequiredInvocations(rawArgs) {
     if (subcommand !== "add") {
       throw new UsageError(`gutterpress plugin: unknown command "${subcommand}"`);
     }
-    const { pluginAddArgs } = await import("./plugin-a89tqspy.js");
+    const { pluginAddArgs } = await import("./plugin-raq1arqq.js");
     rejectUnknownFlags(subcommandArgs, pluginAddArgs, "plugin add");
     const parsed = parseArgs(subcommandArgs, {
       ...pluginAddArgs,

package/dist/{doctor-vajd5h45.js → doctor-pswwk1nm.js}

@@ -1,12 +1,12 @@
 import {
   getSystemDiagnostics,
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
+} from "./cli-jhvkcwvf.js";
 import"./cli-c41yr7he.js";
 import"./cli-46ycxe6r.js";
 import"./cli-37x76zdn.js";

package/dist/{engine-gkcqdye5.js → engine-57vw8zpd.js}

@@ -4,7 +4,7 @@ import {
   build,
   connectChromium,
   getBrowser
-} from "./cli-ak1tagkr.js";
+} from "./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   BuildError

package/dist/{engine-0nt35svz.js → engine-8kdwy0jz.js}

@@ -1,13 +1,13 @@
 import {
   build
-} from "./index-kvgq4q3q.js";
+} from "./index-p0ebr7dh.js";
 import {
   BuildError,
   RENDER_TIMEOUT_MS,
   assertMilestone,
   connectChromium,
   getBrowser
-} from "./index-b2rqw41a.js";
+} from "./index-7hrvksrb.js";
 import"./index-37x76zdn.js";
 
 // src/lib/engine.ts

package/dist/{index-6g72h2n1.js → index-7faw7w8v.js}

@@ -17,7 +17,7 @@ import {
   resolveChromiumExecutable,
   run,
   spawnCapture
-} from "./index-b2rqw41a.js";
+} from "./index-7hrvksrb.js";
 import {
   gitFs,
   gitScopeFor,
@@ -3980,7 +3980,7 @@ import git from "isomorphic-git";
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.10.1-beta.1",
+  version: "0.10.1-beta.3",
   description: "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   author: "itlackey",
   license: "MPL-2.0",
@@ -8016,7 +8016,7 @@ class PdfOutput {
       const rawPdf = pdfxMode ? path8.join(stage, "raw.pdf") : path8.resolve(pdfFile);
       await fsp2.mkdir(path8.dirname(path8.resolve(pdfFile)), { recursive: true });
       log.info("Rendering HTML to PDF via the Gutterpress engine (native Chromium pagination)");
-      const { buildNativePdf } = await import("./engine-0nt35svz.js");
+      const { buildNativePdf } = await import("./engine-8kdwy0jz.js");
       const engineDiagnostics = await buildNativePdf(htmlFile, rawPdf, {
         title: config.title,
         author: config.authors.length > 0 ? config.authors.join(", ") : undefined,

package/dist/{index-b2rqw41a.js → index-7hrvksrb.js}

@@ -596,13 +596,13 @@ var favicon_default = "./favicon-wkbm9cjn.ico";
 var manifest_schema_default = "./manifest.schema-zxgxnbg7.json";
 
 // src/assets/preview/scripts/preview-interface.js
-var preview_interface_default = "./preview-interface-0ssk8bmm.js";
+var preview_interface_default = "./preview-interface-2f5v96hd.js";
 
 // src/assets/preview/scripts/preview-bridge.js
-var preview_bridge_default = "./preview-bridge-fz7vpk8m.js";
+var preview_bridge_default = "./preview-bridge-2nnrs2hy.js";
 
 // src/assets/preview/scripts/preview-shell.js
-var preview_shell_default = "./preview-shell-c5mfa3q0.js";
+var preview_shell_default = "./preview-shell-kyjq59d9.js";
 
 // profiles/CGATS21_CRPC1.icc
 var CGATS21_CRPC1_default = "./CGATS21_CRPC1-g0e3k7kr.icc";

package/dist/{index-kvgq4q3q.js → index-p0ebr7dh.js}

@@ -4,7 +4,7 @@ import {
   launchChromium,
   marginBoxAlign,
   marginBoxRectPt
-} from "./index-b2rqw41a.js";
+} from "./index-7hrvksrb.js";
 
 // src/engine/compiler/build.ts
 import { readFile } from "node:fs/promises";

package/dist/index.js

@@ -113,15 +113,15 @@ import {
   syncProject,
   testRemoteAccess,
   validateProjectPlugins
-} from "./index-6g72h2n1.js";
+} from "./index-7faw7w8v.js";
 import {
   BUILD_DIAGNOSTIC_CODES
-} from "./index-kvgq4q3q.js";
+} from "./index-p0ebr7dh.js";
 import {
   BuildError,
   DEFAULT_PRINT_OPTS,
   readyProbeExpr
-} from "./index-b2rqw41a.js";
+} from "./index-7hrvksrb.js";
 import {
   AUTO_SNAPSHOT_MESSAGE,
   HISTORY_PAGE_LIMIT,

package/dist/{lint-p6a4bkvh.js → lint-bbc9qk1h.js}

@@ -1,16 +1,16 @@
 import {
   MANIFEST_FILENAMES,
   runLint
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/{new-4cdzfbsj.js → new-aj8be9p9.js}

@@ -5,16 +5,16 @@ import {
   TARGETS,
   TARGET_IDS,
   scaffoldProject
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   resolveGhostscript
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import {
   isToolAvailable
 } from "./cli-c41yr7he.js";

package/dist/{plugin-a89tqspy.js → plugin-raq1arqq.js}

@@ -1,14 +1,14 @@
 import {
   addNpmPlugin,
   parseNpmPluginSpec
-} from "./cli-df7gcyns.js";
-import"./cli-mcb484g3.js";
+} from "./cli-wtyzagaq.js";
+import"./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/{preflight-r4y3f8f9.js → preflight-hq060mas.js}

@@ -2,16 +2,16 @@ import {
   executeValidation,
   publishTargetFor,
   reportMissingTools
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/{preview-bridge-fz7vpk8m.js → preview-bridge-2nnrs2hy.js}

@@ -82,6 +82,21 @@
   window.addEventListener('contextMenuRequested', function (e) {
     post({ type: 'gutterpress:event', name: 'contextMenuRequested', detail: e.detail });
   });
+  // In-flow block editing (protocol v8). `Requested` is the double-click entry
+  // point — the SPA answers it with a beginBlockEdit command. `Finished`
+  // carries the edited text back for an end the AUTHOR initiated inside the
+  // book (Escape / Cmd+Enter / blur), which the SPA cannot observe. `State`
+  // fires on every open and close, including SPA-initiated ones, and is what
+  // preview-shell.js holds hot-reload swaps on.
+  window.addEventListener('blockEditRequested', function (e) {
+    post({ type: 'gutterpress:event', name: 'blockEditRequested', detail: e.detail });
+  });
+  window.addEventListener('blockEditFinished', function (e) {
+    post({ type: 'gutterpress:event', name: 'blockEditFinished', detail: e.detail });
+  });
+  window.addEventListener('blockEditStateChanged', function (e) {
+    post({ type: 'gutterpress:event', name: 'blockEditStateChanged', detail: e.detail });
+  });
 
   // Announce readiness as soon as previewAPI is defined.
   function announceReady() {

package/dist/{preview-k8n2kew7.js → preview-c4d698wn.js}

@@ -6,10 +6,10 @@ import {
   runBuild,
   splitOutPath,
   startPreviewServer
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   parseEngine,
@@ -18,8 +18,8 @@ import {
   rejectExtraPositionals,
   rejectUnknownFlags,
   resolvePort
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   BuildError

package/dist/{preview-interface-0ssk8bmm.js → preview-interface-2f5v96hd.js}

@@ -5,11 +5,11 @@
 // window.Gutterpress.pageOf(el) (0-based); it fires 'gp:layout' when its
 // pagination completes.
 //
-// The block-overlay fragment-grouping machinery below (blocksMatchingRange)
-// groups by `{chapter, range}` (data-source-range) — the native viewer never
-// clones an element across pages (an element that visually spans pages is
-// still ONE element), so nativeRectsFor resolves rects straight off the
-// single matching element via getClientRects() + pageOf().
+// Blocks are addressed by `{chapter, range}` (data-source-range) — see
+// blocksMatchingRange below. The native viewer never clones an element across
+// pages (an element that visually spans pages is still ONE element), so such a
+// spec resolves to AT MOST ONE element. That is what lets in-flow editing put
+// a single contenteditable on a block that spans a page break.
 
 (function () {
   'use strict';
@@ -625,15 +625,39 @@
     return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
   }
 
-  // ── Block-overlay geometry + masking (protocol v6) ──────────────────────────
-  // docs/inline-editing-plan.md §5.3 / ADR 0009. A block split across pages
-  // exists as MULTIPLE DOM fragments that duplicate every data attribute
-  // (§3.5's split-fragment gotcha applies here too) — `data-source-range` is
-  // duplicated onto every fragment identically, so `{chapter, range}` groups
-  // them (protocol v5 dropped `data-ref` from the wire contract entirely: the
-  // native viewer never mints one at all — it never clones, so there is
-  // nothing to give a shared identity to — and a source range already
-  // uniquely identifies one block).
+  // ── In-flow block editing (protocol v8) ────────────────────────────────────
+  // docs/inline-editing-plan.md §3.1 / ADR 0009 decision 4 (as revised).
+  //
+  // The block's OWN element becomes the editing surface: its rendered HTML is
+  // swapped for that block's markdown source under
+  // `contenteditable="plaintext-only"`, so the caret sits in the real page, in
+  // the book's own typography, and Chromium's fragmenter re-flows the pages
+  // around it as the author types. This replaced a floating CodeMirror panel
+  // positioned in host-SPA coordinates; `getRectsFor()`/`setEditMask()` existed
+  // ONLY to serve that panel and went with it (protocol v8).
+  //
+  // Three properties of the native viewer are what make this work, each
+  // spike-verified rather than assumed (plan §2) — under Paged.js none of them
+  // held, which is why the panel existed:
+  //   1. A block spanning a page break is ONE element with several client
+  //      rects, so it takes ONE contenteditable and the caret crosses the
+  //      break natively (ArrowDown walks into the next page).
+  //   2. `white-space: pre-wrap` + `plaintext-only` round-trips multi-line
+  //      markdown EXACTLY through `textContent` (lists, tables, fences); Enter
+  //      inserts a real "\n" rather than a <div>/<br>, and a rich-HTML paste
+  //      is stripped to text by the browser. So there is no serializer and no
+  //      sanitiser here — text in, text out.
+  //   3. `Gutterpress.refresh()` -> `relayout()` rebuilds the strips from
+  //      scratch and re-measures, so a growing block gets a correct page
+  //      count. This is MANDATORY, not cosmetic: `.gp-strip` is
+  //      `column-fill: auto` and its `.gp-run` clips to the last measured page,
+  //      so content that grows past that is silently invisible rather than
+  //      overlapping (measured: a strip needing 2400px still clipped at its
+  //      900px run width). Never mutate this DOM without scheduling a refresh.
+  //
+  // Nothing here writes to disk. `endBlockEdit()` hands text back and the SPA
+  // decides whether it becomes a patch, behind the commit engine's clean-buffer
+  // gate (ADR 0009 decision 3, unchanged).
 
   function rangedBlocks() {
     return Array.from(document.querySelectorAll('[data-source-range]'));
@@ -644,6 +668,10 @@
     return rangedBlocks().filter(function (el) { return chapterOf(el) === chapter; });
   }
 
+  // The native viewer never clones, so a `{chapter, range}` spec resolves to AT
+  // MOST ONE element — this returns an array only because callers still guard
+  // on emptiness (a range that no longer matches anything: block deleted or
+  // moved since the target was captured).
   function blocksMatchingRange(chapter, range) {
     if (!range) return [];
     return rangedBlocksInChapter(chapter).filter(function (el) {
@@ -652,42 +680,287 @@
     });
   }
 
-  // getRectsFor(): the viewer never clones, so a spec resolves to AT MOST ONE
-  // element. Its fragment rects come straight from getClientRects() — a block
-  // can still visually span pages if the browser's own multicol layout breaks
-  // it there. Resolve each rect against the sheet it actually intersects;
-  // pageOf(el) can only identify the element's starting fragmentainer.
-  function nativeRectsFor(spec) {
-    spec = spec || {};
-    var el = blocksMatchingRange(spec.chapter, spec.range)[0] || null;
-    if (!el) return { rects: [] };
-    var geometryEl = el.tagName && el.tagName.toLowerCase() === 'code' &&
-      el.parentElement && el.parentElement.tagName.toLowerCase() === 'pre'
-      ? el.parentElement
-      : el;
-    if (pages.length === 0) refreshPages();
-    var fallbackPage = pageIndexOf(el);
-    var raw = geometryEl.getClientRects ? Array.from(geometryEl.getClientRects()) : [];
-    if (!raw.length) {
-      var r0 = plainRect(geometryEl);
-      raw = r0 ? [r0] : [];
+  // Re-pagination debounce while typing. Tuned by measurement, not taste:
+  // `relayout()` costs "the same order as mount (tens of ms on a real book)"
+  // per fragment.ts, so it cannot run per keystroke on a long book.
+  var EDIT_REFRESH_MS = 120;
+
+  // The one live edit, or null. At most one at a time — `beginBlockEdit`
+  // commits any predecessor before opening (an author double-clicking straight
+  // from one block to another must not silently drop the first edit).
+  var edit = null;
+  var editRefreshTimer = null;
+
+  function scheduleEditRefresh() {
+    if (editRefreshTimer !== null) clearTimeout(editRefreshTimer);
+    editRefreshTimer = setTimeout(function () {
+      editRefreshTimer = null;
+      repaginate();
+    }, EDIT_REFRESH_MS);
+  }
+
+  // Character offset of the caret within the edit box, or null when the caret
+  // is not in it. Text-space, not node-space, so it survives the box being
+  // re-parented and its text nodes being renormalized.
+  function caretOffset() {
+    if (!edit) return null;
+    var sel = typeof window.getSelection === 'function' ? window.getSelection() : null;
+    if (!sel || sel.rangeCount === 0) return null;
+    var r = sel.getRangeAt(0);
+    if (!edit.el.contains(r.startContainer)) return null;
+    var pre = document.createRange();
+    pre.selectNodeContents(edit.el);
+    pre.setEnd(r.startContainer, r.startOffset);
+    return pre.toString().length;
+  }
+
+  // Depth-first text nodes, by `nodeType === 3` rather than TreeWalker +
+  // NodeFilter: the preview scripts run in hosts that do not expose every DOM
+  // global (the iframe test harness evaluates this file with an explicit,
+  // small global list), and a caret helper is not worth a host requirement.
+  function textNodesIn(root) {
+    var out = [];
+    var stack = [root];
+    while (stack.length) {
+      var node = stack.pop();
+      if (node.nodeType === 3) { out.push(node); continue; }
+      for (var i = node.childNodes.length - 1; i >= 0; i--) stack.push(node.childNodes[i]);
     }
-    var rects = raw.map(function (r) {
-      var page = fallbackPage;
-      var bestArea = 0;
-      for (var i = 0; i < pages.length; i++) {
-        var sheetRect = pages[i].getBoundingClientRect();
-        var width = Math.min(r.right, sheetRect.right) - Math.max(r.left, sheetRect.left);
-        var height = Math.min(r.bottom, sheetRect.bottom) - Math.max(r.top, sheetRect.top);
-        var area = width > 0 && height > 0 ? width * height : 0;
-        if (area > bestArea) {
-          bestArea = area;
-          page = i + 1;
-        }
+    return out;
+  }
+
+  function restoreCaret(offset) {
+    if (!edit || offset === null || offset === undefined) return;
+    var nodes = textNodesIn(edit.el);
+    var seen = 0;
+    for (var n = 0; n < nodes.length; n++) {
+      var node = nodes[n];
+      var len = node.nodeValue ? node.nodeValue.length : 0;
+      if (seen + len >= offset) {
+        var range = document.createRange();
+        range.setStart(node, Math.max(0, Math.min(len, offset - seen)));
+        range.collapse(true);
+        var sel = typeof window.getSelection === 'function' ? window.getSelection() : null;
+        if (!sel) return;
+        try { sel.removeAllRanges(); sel.addRange(range); } catch (_e) { /* best effort */ }
+        return;
       }
-      return { top: r.top, left: r.left, width: r.width, height: r.height, page: page };
+      seen += len;
+    }
+    // Offset past the end (the text shrank): land at the end.
+    var end = document.createRange();
+    end.selectNodeContents(edit.el);
+    end.collapse(false);
+    var sel2 = typeof window.getSelection === 'function' ? window.getSelection() : null;
+    if (!sel2) return;
+    try { sel2.removeAllRanges(); sel2.addRange(end); } catch (_e) { /* best effort */ }
+  }
+
+  function repaginate() {
+    if (!window.Gutterpress || typeof window.Gutterpress.refresh !== 'function') return;
+    // `relayout()` unwraps every strip and rebuilds it, which RE-PARENTS the
+    // edit box — and re-parenting a focused element drops both its focus and
+    // the selection. Unhandled, that means the caret dies on the first
+    // debounced refresh after the author starts typing and every keystroke
+    // after it goes nowhere. Capture in text space, restore after.
+    var offset = caretOffset();
+    try {
+      window.Gutterpress.refresh();
+    } catch (_e) {
+      // A refresh failure must not trap the author inside a broken edit; the
+      // authoritative render still arrives on commit.
+    }
+    // The strips are rebuilt, so cached sheet nodes are stale.
+    pages = [];
+    if (edit && offset !== null) {
+      try { edit.el.focus({ preventScroll: true }); } catch (_e2) { /* best effort */ }
+      restoreCaret(offset);
+    }
+  }
+
+  // Place the caret from the click point, on the SOURCE text now in the box.
+  // Approximate by construction (the point was measured against the RENDERED
+  // text) and that is fine — it puts the caret near what the author aimed at,
+  // which is the whole affordance. Falls back to end-of-block.
+  function placeCaret(el, point) {
+    var range = null;
+    if (point && typeof document.caretRangeFromPoint === 'function') {
+      try {
+        var hit = document.caretRangeFromPoint(point.x, point.y);
+        if (hit && el.contains(hit.startContainer)) range = hit;
+      } catch (_e) { /* fall through to end-of-block */ }
+    }
+    if (!range) {
+      range = document.createRange();
+      range.selectNodeContents(el);
+      range.collapse(false);
+    }
+    try {
+      var sel = typeof window.getSelection === 'function' ? window.getSelection() : null;
+      if (!sel) return;
+      sel.removeAllRanges();
+      sel.addRange(range);
+    } catch (_e) {
+      // Focus is already set, so the box is usable even if seating the caret
+      // failed (a detached selection, a host without Selection support). The
+      // author clicks once more; nothing is lost.
+    }
+  }
+
+  function finishEdit(commit, notify) {
+    if (!edit) return { ended: false, text: null, commit: false };
+    if (editRefreshTimer !== null) {
+      clearTimeout(editRefreshTimer);
+      editRefreshTimer = null;
+    }
+    var el = edit.el;
+    var text = el.textContent || '';
+    var done = { ended: true, text: text, commit: commit === true, chapter: edit.chapter, range: edit.range };
+
+    // Restore the rendered HTML on BOTH paths. On cancel it is the final
+    // state; on commit it avoids showing raw markdown for the ~500ms until the
+    // authoritative re-render swaps the frame.
+    el.removeAttribute('contenteditable');
+    if (edit.hadWhiteSpace) el.style.whiteSpace = edit.whiteSpace;
+    else el.style.removeProperty('white-space');
+    if (!el.getAttribute('style')) el.removeAttribute('style');
+    el.classList.remove('gutterpress-editing');
+    el.innerHTML = edit.html;
+    el.removeEventListener('input', onEditInput);
+    document.removeEventListener('mousedown', onDocumentPointerDown, true);
+    window.removeEventListener('focus', onWindowFocus);
+    edit = null;
+    repaginate();
+
+    if (notify) {
+      window.dispatchEvent(new CustomEvent('blockEditFinished', { detail: done }));
+    }
+    // ALWAYS emitted, on both paths, unlike blockEditFinished above — the
+    // shell holds hot-reload swaps on this and a missed close would freeze the
+    // preview until the next manual action.
+    window.dispatchEvent(new CustomEvent('blockEditStateChanged', { detail: { open: false } }));
+    return done;
+  }
+
+  function onEditInput() {
+    scheduleEditRefresh();
+  }
+
+  // "Clicked away" commits — driven by a POINTER PRESS in the book, never by
+  // `blur`.
+  //
+  // Blur was the obvious signal and it is the wrong one here. The open request
+  // arrives by postMessage from a click in the host SPA (the context menu's
+  // "Edit this block"), so this frame does not hold browsing-context focus when
+  // `startEdit` runs. Focusing the box then races the frame-focus transition:
+  // Chromium settles `activeElement` back to BODY and the element receives a
+  // blur it never earned. Measured end-to-end in the packaged app — the editor
+  // opened and closed 7ms later, committing content the author never saw, so
+  // both entry points looked like they did nothing at all. Guarding on
+  // `document.hasFocus()` does not separate the two cases either: a real click
+  // on another paragraph ALSO lands on BODY with the document focused.
+  //
+  // A pointer press outside the box is unambiguous and needs no focus
+  // bookkeeping. Focus leaving the frame entirely (the author reaches for the
+  // editor pane or another window) is deliberately NOT a commit — the host
+  // drives those ends explicitly through `endBlockEdit`, and the box stays
+  // visibly open meanwhile, which is honest about the state.
+  function onDocumentPointerDown(e) {
+    if (!edit) return;
+    if (e.target && edit.el.contains(e.target)) return;
+    finishEdit(true, true);
+  }
+
+  // Put the caret in the box, and KEEP putting it there until it sticks.
+  //
+  // Opening from the context menu is a postMessage with no user activation, so
+  // this frame cannot focus itself; the host focuses the preview and
+  // preview-shell.js hands that down to this frame (see both). That transition
+  // lands AFTER `startEdit` runs, and Chromium resets `activeElement` to BODY
+  // as it completes — so the `el.focus()` inside `startEdit` is silently undone
+  // and the author's keystrokes go to the app behind the preview. Measured
+  // end-to-end in the packaged app: the box opened with the whole frame chain
+  // focused, `document.activeElement` sat on `BODY.gp-stage`, and typing landed
+  // outside the book. The same `el.focus()` issued a moment later worked, which
+  // is what makes this a race rather than a permission problem.
+  //
+  // So: seat it now, then re-seat across the transition until `activeElement`
+  // IS the box. Bounded and idempotent — it stops on the first success, when
+  // the edit closes, or after the last attempt, and never fights the author
+  // (any element inside the box already counts as seated).
+  var SEAT_DELAYS_MS = [0, 16, 50, 150];
+
+  function seated() {
+    return !!edit && (document.activeElement === edit.el || edit.el.contains(document.activeElement));
+  }
+
+  function seatCaret() {
+    if (!edit || seated()) return;
+    try { edit.el.focus({ preventScroll: true }); } catch (_e) { /* best effort */ }
+    placeCaret(edit.el, edit.caret);
+  }
+
+  function seatCaretRepeatedly() {
+    var target = edit;
+    SEAT_DELAYS_MS.forEach(function (ms) {
+      setTimeout(function () {
+        if (edit !== target) return;
+        seatCaret();
+      }, ms);
     });
-    return { rects: rects };
+  }
+
+  // Whenever this frame gains focus while an edit is open, the caret belongs in
+  // the box — covers orderings where focus arrives later still.
+  function onWindowFocus() {
+    seatCaret();
+  }
+
+  function startEdit(spec) {
+    var el = blocksMatchingRange(spec.chapter, spec.range)[0] || null;
+    if (!el) return { ok: false, reason: 'unresolved' };
+    if (edit) finishEdit(true, true);
+
+    var style = el.style;
+    edit = {
+      el: el,
+      chapter: spec.chapter,
+      range: spec.range,
+      caret: spec.caret,
+      html: el.innerHTML,
+      hadWhiteSpace: !!style.whiteSpace,
+      whiteSpace: style.whiteSpace
+    };
+    // pre-wrap is load-bearing, not cosmetic: without it the source's newlines
+    // collapse and a multi-line block (list, table, fence) is unreadable AND
+    // uneditable line-by-line.
+    style.whiteSpace = 'pre-wrap';
+    el.classList.add('gutterpress-editing');
+    el.setAttribute('contenteditable', 'plaintext-only');
+    el.textContent = typeof spec.text === 'string' ? spec.text : '';
+    el.addEventListener('input', onEditInput);
+    document.addEventListener('mousedown', onDocumentPointerDown, true);
+    window.addEventListener('focus', onWindowFocus);
+    // Pull browsing-context focus into THIS frame first. Without it the caret
+    // is nowhere the author can type: the open request came from a click in
+    // the host document, so focus is still there.
+    try { window.focus(); } catch (_e) { /* focus stays with the host */ }
+    // Focus and caret seating are best-effort. A throw here must not escape:
+    // the edit state is already installed, so an exception would leave the
+    // block stuck in editing mode with the host believing nothing opened.
+    try {
+      el.focus({ preventScroll: true });
+    } catch (_e) {
+      try { el.focus(); } catch (_e2) { /* unfocusable host; the box still edits */ }
+    }
+    placeCaret(el, spec.caret);
+    // The swap from rendered HTML to source text changes the block's extent
+    // immediately, so pagination is already stale before a single keystroke.
+    // This re-parents the box, so seat the caret AFTER it, never before.
+    repaginate();
+    seatCaretRepeatedly();
+    window.dispatchEvent(new CustomEvent('blockEditStateChanged', { detail: { open: true } }));
+    return { ok: true };
   }
 
   var api = {
@@ -802,7 +1075,14 @@
     // (a point inside a .gp-sheet but outside every author box resolves to
     // the sheet's owning .page/.spread). An older SPA simply ignores the
     // extra field; a newer SPA feature-detects by the field's presence.
-    getProtocolVersion: function () { return 7; },
+    // v8: in-flow block editing. ADDED beginBlockEdit()/endBlockEdit() and the
+    // blockEditRequested/blockEditFinished/blockEditStateChanged events;
+    // REMOVED getRectsFor() and
+    // setEditMask(), which existed only to place and de-clutter behind the
+    // floating edit panel this replaces. A v8 lib with a pre-v8 SPA loses the
+    // "Edit this block" action and nothing else; a v8 SPA feature-detects on
+    // the version before offering it.
+    getProtocolVersion: function () { return 8; },
 
     // Resolve the annotated element/selection at a viewport point (protocol
     // v4). Pure read; see buildContextTarget() above for the full contract.
@@ -814,34 +1094,26 @@
       return buildContextTarget(contextPointEl(spec.x, spec.y, spec.topmostOnly));
     },
 
-    // All fragment rects for one logical block (protocol v6, §5.3), targeted
-    // by {chapter, range}. Pure read; never mutates the DOM. Plain,
-    // JSON-cloneable objects only (§3.5) — no DOMRect instances.
-    getRectsFor: function (spec) {
-      return nativeRectsFor(spec);
+    // Open the in-flow editor on one block (protocol v8). `text` is that
+    // block's markdown source, read SPA-side from the authoritative buffer —
+    // this function never derives source from the DOM. `caret` is the optional
+    // viewport point to seat the caret near. Returns
+    // `{ok: false, reason: 'unresolved'}` when the range no longer matches a
+    // live block, so the SPA can drop the request instead of hanging.
+    beginBlockEdit: function (spec) {
+      spec = spec || {};
+      return startEdit(spec);
     },
 
-    // Toggle a masking class on EVERY fragment of a block ({chapter, range}
-    // match, protocol v6, §5.1/§5.3), plus a scroll lock on the book document
-    // element. Purely cosmetic and fully reversible — nothing here may touch
-    // anything layout-affecting; see the class definitions below and ADR
-    // 0009. `masked: false` always removes the lock class too, even if this
-    // particular range has zero live fragments (e.g. called defensively
-    // during teardown after a splice) — it is a document-level toggle, not
-    // scoped per-block, and there is at most one overlay open at a time.
-    setEditMask: function (spec) {
+    // Close it and hand back the current text (protocol v8). Idempotent:
+    // `{ended: false}` when nothing is open. The SPA calls this to force an end
+    // it initiated (a dialog opening over the workspace); ends the author
+    // initiates from inside the book — Escape, Cmd/Ctrl+Enter, blur — arrive
+    // as the `blockEditFinished` event instead, so a keystroke the SPA cannot
+    // see still resolves the edit. Both paths restore the rendered HTML.
+    endBlockEdit: function (spec) {
       spec = spec || {};
-      var els = blocksMatchingRange(spec.chapter, spec.range);
-      for (var i = 0; i < els.length; i++) {
-        if (spec.masked) els[i].classList.add('gutterpress-edit-mask');
-        else els[i].classList.remove('gutterpress-edit-mask');
-      }
-      var root = document.documentElement;
-      if (root && root.classList) {
-        if (spec.masked) root.classList.add('gutterpress-edit-scroll-lock');
-        else root.classList.remove('gutterpress-edit-scroll-lock');
-      }
-      return { count: els.length };
+      return finishEdit(spec.commit !== false, false);
     },
 
     // Publish any debounced reader movement before a host atomically replaces
@@ -1061,23 +1333,29 @@
     } catch (_e) { /* non-fatal: highlight just renders unstyled */ }
   }
 
-  // Block-overlay mask + scroll-lock style (protocol v5, plan §5.1/§5.3).
-  // Preview-only, never part of the PDF build path. Purely cosmetic: dims the
-  // masked fragment(s) so stale rendered text doesn't show behind/beside the
-  // overlay, and disables the book document's own scroll while an overlay is
-  // open (the overlay is positioned in host-SPA coordinates from a rect
-  // snapshot; an unlocked scroll would silently drift it over unrelated
-  // content — see BlockOverlayController). Exact visual treatment (dim vs.
-  // blank) is a placeholder pending design review (plan §7.6 open item).
+  // In-flow editing style (protocol v8, plan §3.1).
+  // Preview-only, never part of the PDF build path. Marks the block being
+  // edited without moving it: `outline` and `box-shadow` are chosen because
+  // they take NO space in layout — a border or padding here would change the
+  // block's extent and repaginate the book on entering edit mode, which is
+  // exactly the divergence this project cares most about. Nothing in this
+  // rule may become layout-affecting.
+  //
+  // No scroll lock and no dimming of the surrounding page: the caret is in the
+  // flow now, so the page can scroll freely and the neighbouring text stays
+  // legible while the author works. Both existed only to prop up the floating
+  // panel this replaced. Exact visual treatment is a design-review item
+  // (plan §6), same as the mask treatment was.
   if (typeof document.createElement === 'function') {
     try {
-      var maskStyle = document.createElement('style');
-      maskStyle.textContent =
-        '.gutterpress-edit-mask{opacity:.2;filter:saturate(.4);pointer-events:none;' +
-        'transition:opacity .12s,filter .12s;}' +
-        'html.gutterpress-edit-scroll-lock{overflow:hidden !important;}';
-      (document.head || document.documentElement).appendChild(maskStyle);
-    } catch (_e) { /* non-fatal: mask just renders unstyled */ }
+      var editStyle = document.createElement('style');
+      editStyle.textContent =
+        '.gutterpress-editing{outline:2px solid Highlight;outline-offset:2px;' +
+        'box-shadow:0 0 0 2px color-mix(in srgb, Highlight 25%, transparent);' +
+        'border-radius:2px;caret-color:currentColor;}' +
+        '.gutterpress-editing:focus{outline-style:solid;}';
+      (document.head || document.documentElement).appendChild(editStyle);
+    } catch (_e) { /* non-fatal: the edit box just renders unmarked */ }
   }
 
   // Click-to-source: emit elementActivated when the user clicks a source-mapped
@@ -1103,6 +1381,10 @@
     // with no replacement menu would be a strict regression. No event is
     // dispatched for 'none' either.
     document.addEventListener('contextmenu', function (e) {
+      // Inside the live in-flow editor the native menu is the useful one
+      // (cut/copy/paste on the source text). Ours offers block actions that
+      // make no sense mid-edit.
+      if (edit && edit.el.contains(e.target)) return;
       var detail = api.getContextTargetAt({ x: e.clientX, y: e.clientY });
       if (detail.kind === 'none') return;
       e.preventDefault();
@@ -1112,6 +1394,47 @@
       window.dispatchEvent(new CustomEvent('contextMenuRequested', { detail: detail }));
     }, true);
 
+    // Double-click to edit (protocol v8, plan §6). The SECOND entry point
+    // alongside the context menu's "Edit this block" — both land on the same
+    // SPA handler, which reads the source slice and calls beginBlockEdit().
+    // Requesting rather than starting is deliberate: only the SPA can read the
+    // authoritative buffer, so the book document never sources its own text.
+    //
+    // Bails while an edit is live so a double-click INSIDE the box keeps its
+    // native meaning (select word). Never preventDefault: on a block that does
+    // not resolve, double-click must keep selecting text as it always has.
+    document.addEventListener('dblclick', function (e) {
+      if (edit) return;
+      var el = e.target && e.target.closest ? e.target.closest('[data-source-range]') : null;
+      if (!el) return;
+      var range = sourceRangeOf(el);
+      var chapter = chapterOf(el);
+      if (!range || !chapter) return;
+      window.dispatchEvent(new CustomEvent('blockEditRequested', {
+        detail: { chapter: chapter, range: range, x: e.clientX, y: e.clientY, via: 'dblclick' }
+      }));
+    }, true);
+
+    // Edit-mode keys. These MUST live inside the book iframe for the same
+    // physical reason the Shift+F10 listener below does: the caret is in a
+    // cross-origin document, so its keystrokes never reach the SPA.
+    // Cmd/Ctrl+Enter commits (Enter alone is a newline — a markdown block can
+    // be multi-line); Escape cancels and restores.
+    document.addEventListener('keydown', function (e) {
+      if (!edit) return;
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        e.stopPropagation();
+        finishEdit(false, true);
+        return;
+      }
+      if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
+        e.preventDefault();
+        e.stopPropagation();
+        finishEdit(true, true);
+      }
+    }, true);
+
     // Shift+F10 / the dedicated ContextMenu key. This listener MUST live
     // inside the book iframe: keyboard events targeted at a focused element
     // in a cross-origin iframe never reach the parent SPA, so an SPA-side

package/dist/{preview-shell-c5mfa3q0.js → preview-shell-kyjq59d9.js}

@@ -19,6 +19,11 @@
   var pendingSwap = null;
   var pendingSwapTimer = null;
   var SCROLL_IDLE_MS = 250;
+  // True while the book iframe has a live in-flow block editor open
+  // (preview-interface.js's blockEditStateChanged, protocol v8). A swap
+  // replaces the whole iframe, so swapping mid-edit would destroy the caret
+  // and the author's uncommitted typing with it — see holdForEdit below.
+  var blockEditOpen = false;
   if (!active) return;
 
   // Transparent bridge relay: forward host-toolbar commands to the active book
@@ -27,26 +32,36 @@
     try {
       if (window.parent !== window && e.source === window.parent) {
         if (active && active.contentWindow) active.contentWindow.postMessage(e.data, '*');
+        // Opening the in-flow editor needs KEYBOARD focus in the book, and a
+        // postMessage carries no user activation the book could focus itself
+        // with. The host focuses this shell frame; this hands it the rest of
+        // the way down to the active book iframe, whose own window-focus
+        // listener then seats the caret.
+        if (e.data && e.data.type === 'gutterpress:cmd' && e.data.cmd === 'beginBlockEdit' && active) {
+          try { active.focus(); } catch (_f) {}
+        }
       } else if (active && e.source === active.contentWindow) {
         var data = e.data;
         if (data && data.type === 'gutterpress:event' && data.name === 'viewportChanged') {
           lastViewportChangeAt = Date.now();
           if (pendingSwap) armPendingSwap();
         }
-        if (active === hotReloadFrame && data && data.type === 'gutterpress:event' && data.name === 'ready') return;
-        if (active === hotReloadFrame && data && data.type === 'gutterpress:event' && data.name === 'renderingComplete') {
-          var detail = {}, sourceDetail = data.detail || {};
-          for (var key in sourceDetail) {
-            if (Object.prototype.hasOwnProperty.call(sourceDetail, key)) detail[key] = sourceDetail[key];
-          }
-          detail.hotReload = true;
-          var startedAt = hotReloadFrame.__gutterpressReloadStartedAt;
-          detail.hotReloadMs = typeof startedAt === 'number' ? Math.max(0, Date.now() - startedAt) : 0;
-          detail.revision = hotReloadFrame.__gutterpressRevision;
-          detail.updateMode = 'full-reload';
-          data = { type: data.type, name: data.name, detail: detail };
-          hotReloadFrame = null;
+        if (data && data.type === 'gutterpress:event' && data.name === 'blockEditStateChanged') {
+          blockEditOpen = !!(data.detail && data.detail.open);
+          // Releasing the hold: a swap that arrived mid-edit is still queued,
+          // so start it now that the caret is gone.
+          if (!blockEditOpen && pendingSwap) armPendingSwap();
         }
+        // A swapped-in frame's own lifecycle events are the shell's business,
+        // not the host's: finish() reports the swap (see reportSwapComplete).
+        // Relaying them too would either double-report or — when the frame
+        // paginates before its `load` event, which is the common case — report
+        // nothing at all, because the message arrives while the frame is still
+        // `building` and matches no branch here.
+        if (
+          active === hotReloadFrame && data && data.type === 'gutterpress:event' &&
+          (data.name === 'ready' || data.name === 'renderingComplete')
+        ) return;
         if (window.parent !== window) window.parent.postMessage(data, '*');
       } else if (retiring && e.source === retiring.contentWindow && window.parent !== window) {
         var retiringData = e.data;
@@ -135,7 +150,33 @@
     building = null;
   }
 
+  // Tell the host the swap is done. This is a synchronous fact the shell knows
+  // — the replacement is paginated (onReady resolved), promoted, and refreshed
+  // — rather than a relayed message whose arrival depends on whether the
+  // frame's pagination beat its own `load` event.
+  function reportSwapComplete(frame, pageState) {
+    if (window.parent === window) return;
+    var startedAt = frame.__gutterpressReloadStartedAt;
+    window.parent.postMessage({
+      type: 'gutterpress:event',
+      name: 'renderingComplete',
+      detail: {
+        totalPages: pageState ? pageState.totalPages : 0,
+        hotReload: true,
+        hotReloadMs: typeof startedAt === 'number' ? Math.max(0, Date.now() - startedAt) : 0,
+        revision: frame.__gutterpressRevision,
+        updateMode: 'full-reload'
+      }
+    }, '*');
+  }
+
   function swap(instance, revision) {
+    // The editor lived in the frame we are about to retire, so the hold is
+    // void whatever the book document last reported. Every update path reaches
+    // swap() through armPendingSwap(), which refuses while an edit is open, so
+    // this only fires when the frame goes away some other way — but a flag
+    // left stuck true would freeze hot reload for the session.
+    blockEditOpen = false;
     discardBuilding();
     var frame = document.createElement('iframe');
     frame.style.visibility = 'hidden';
@@ -175,7 +216,8 @@
       hotReloadFrame = frame;
       building = null;
       var api = fwin(frame) && fwin(frame).previewAPI;
-      if (api && typeof api.refresh === 'function') api.refresh();
+      var pageState = api && typeof api.refresh === 'function' ? api.refresh() : null;
+      reportSwapComplete(frame, pageState);
       frame.style.visibility = 'visible';
       frame.removeAttribute('aria-hidden');
       appliedInstance = instance;
@@ -229,6 +271,13 @@
 
   function armPendingSwap() {
     if (pendingSwapTimer !== null) clearTimeout(pendingSwapTimer);
+    // An open in-flow editor holds the swap indefinitely — there is no timeout
+    // to race, because an author may legitimately sit in one block for
+    // minutes. The hold is released by blockEditStateChanged{open:false},
+    // which preview-interface.js emits on EVERY close path (commit, cancel,
+    // blur, SPA-forced), and defensively by swap() below in case the frame
+    // carrying the editor goes away first.
+    if (blockEditOpen) return;
     var delay = Math.max(0, SCROLL_IDLE_MS - (Date.now() - lastViewportChangeAt));
     if (delay === 0) beginPendingSwap();
     else pendingSwapTimer = setTimeout(beginPendingSwap, delay);
@@ -243,17 +292,23 @@
   // Paged.js's `.pagedjs_page` DOM to find a chapter's live page range and
   // graft a freshly-paginated replacement into it. Paged.js has been removed
   // (native-only-migration-plan.md Phase 6). A native in-place splice was
-  // also tried and removed (2026-08-08 review): grafting a fresh
-  // `.gutterpress-chapter` node in and calling `Gutterpress.refresh()` is not
-  // sound, because `refresh()` -> `relayout()` only re-`measure()`s the
-  // EXISTING strips — it never re-runs `buildStrips()`/`explodeChildren()`.
-  // So any page context the edit introduces (a new `@page`/`page:`
-  // assignment inside the chapter) is silently dropped: measured 2 preview
-  // pages where the same content prints 3 — a preview<->PDF divergence, the
-  // worst failure this project can produce. It also bought nothing: measured
-  // end-to-end (file write -> change visible, 5 samples, 34pp field guide)
-  // the plain full reload (`swap`, below) is 509ms avg vs the incremental
-  // splice's 998ms avg. Every content-update now goes straight to `swap()`.
+  // also tried and removed (2026-08-08 review), and the standing reason is
+  // PERFORMANCE, not soundness: measured end-to-end (file write -> change
+  // visible, 5 samples, 34pp field guide) the plain full reload (`swap`,
+  // below) is 509ms avg vs the incremental splice's 998ms avg. Every
+  // content-update goes straight to `swap()`.
+  //
+  // CORRECTED 2026-08-24: the 2026-08-08 review ALSO recorded a soundness
+  // objection — that `refresh()` -> `relayout()` "only re-measures the
+  // EXISTING strips", silently dropping any page context the edit
+  // introduces. That is false against the current `fragment.ts`, whose
+  // `relayout()` unwraps the strips and re-runs `buildStrips()` from
+  // scratch before re-measuring, precisely so a mutation that adds or
+  // removes a page-context run is seen. Do not cite the old objection as a
+  // reason a DOM mutation cannot be re-paginated — it can, and the inline
+  // editing work depends on it (docs/inline-editing-plan.md, ADR 0009
+  // decision 4 as revised). The perf comparison above still stands on its
+  // own for the full-document reload path.
 
   function markActiveReady() {
     onReady(active, function () {

package/dist/{publish-jnhjp2vd.js → publish-ft5x1e5v.js}

@@ -7,17 +7,17 @@ import {
   publishCredentialKey,
   publishProviderFor,
   runPublish
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   FileTokenStore,
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/schema/manifest.types.d.ts

@@ -194,10 +194,13 @@ export interface ResolvedConfig {
     title: string;
     authors: string[];
     /**
-     * Resolved pagination engine — always "native"; Paged.js has been removed.
-     * See {@link GutterpressManifest.engine}.
+     * Resolved pagination engine. Always `"native"` — `manifest.ts` assigns the
+     * literal, warning and ignoring an author's `engine: paged`. Typed as the
+     * single value it can hold so no consumer can branch on an engine that
+     * cannot run. The INPUT union ({@link GutterpressManifest.engine}) keeps
+     * both spellings, because old manifests must go on parsing.
      */
-    engine: "paged" | "native";
+    engine: "native";
     /** Validated publish-target ids for this book (may be empty). */
     targets: string[];
     styles?: string[];

package/dist/{validate-prnybpkx.js → validate-wp7rgg1y.js}

@@ -1,15 +1,15 @@
 import {
   executeAndReport
-} from "./cli-df7gcyns.js";
+} from "./cli-wtyzagaq.js";
 import {
   log
-} from "./cli-mcb484g3.js";
+} from "./cli-qxebvmrq.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-dx6sxj2t.js";
-import"./cli-ak1tagkr.js";
+} from "./cli-jhvkcwvf.js";
+import"./cli-eewynen9.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gutterpress",
-  "version": "0.10.1-beta.1",
+  "version": "0.10.1-beta.3",
   "description": "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   "author": "itlackey",
   "license": "MPL-2.0",