gutterpress 0.10.0-alpha.4 → 0.10.0

package/dist/{cli-hp9r2pzt.js → cli-zfcryxg8.js}

@@ -891,6 +891,88 @@ function specificity(r) {
   return (r.name ? 2 : 0) + r.pseudos.length;
 }
 
+// src/engine/shared/flush.ts
+var FLUSH_EDGES = ["top", "right", "bottom", "left"];
+function flushKey(edges) {
+  return FLUSH_EDGES.filter((e) => edges.includes(e)).map((e) => e[0]).join("");
+}
+function flushPageName(authorPage, edges) {
+  const safe = authorPage ? authorPage.replace(/[^A-Za-z0-9_-]/g, "_") : "";
+  return `gp--flush${safe ? `-${safe}` : ""}-${flushKey(edges)}`;
+}
+function flushMargins(margin, edges) {
+  return {
+    top: edges.includes("top") ? 0 : margin.top,
+    right: edges.includes("right") ? 0 : margin.right,
+    bottom: edges.includes("bottom") ? 0 : margin.bottom,
+    left: edges.includes("left") ? 0 : margin.left
+  };
+}
+function marginBoxesOnEdges(edges) {
+  const owners = {
+    "top-left-corner": ["top", "left"],
+    "top-left": ["top"],
+    "top-center": ["top"],
+    "top-right": ["top"],
+    "top-right-corner": ["top", "right"],
+    "bottom-left-corner": ["bottom", "left"],
+    "bottom-left": ["bottom"],
+    "bottom-center": ["bottom"],
+    "bottom-right": ["bottom"],
+    "bottom-right-corner": ["bottom", "right"],
+    "left-top": ["left"],
+    "left-middle": ["left"],
+    "left-bottom": ["left"],
+    "right-top": ["right"],
+    "right-middle": ["right"],
+    "right-bottom": ["right"]
+  };
+  return Object.entries(owners).filter(([, own]) => own.some((e) => edges.includes(e))).map(([name]) => name);
+}
+
+// src/engine/shared/margin-box-support.ts
+var MARGIN_BOX_IGNORED_PROPERTIES = new Set([
+  "transform",
+  "rotate",
+  "translate",
+  "scale",
+  "box-shadow"
+]);
+function isIgnoredMarginBoxProperty(property) {
+  return MARGIN_BOX_IGNORED_PROPERTIES.has(property.toLowerCase());
+}
+function marginBoxRectPt(name, g) {
+  const { top, right, bottom, left } = g.margin;
+  const cw = g.width - left - right;
+  const ch = g.height - top - bottom;
+  const third = (n) => n / 3;
+  const T = {
+    "top-left-corner": [0, 0, left, top],
+    "top-left": [left, 0, third(cw), top],
+    "top-center": [left + third(cw), 0, third(cw), top],
+    "top-right": [left + 2 * third(cw), 0, third(cw), top],
+    "top-right-corner": [g.width - right, 0, right, top],
+    "bottom-left-corner": [0, g.height - bottom, left, bottom],
+    "bottom-left": [left, g.height - bottom, third(cw), bottom],
+    "bottom-center": [left + third(cw), g.height - bottom, third(cw), bottom],
+    "bottom-right": [left + 2 * third(cw), g.height - bottom, third(cw), bottom],
+    "bottom-right-corner": [g.width - right, g.height - bottom, right, bottom],
+    "left-top": [0, top, left, third(ch)],
+    "left-middle": [0, top + third(ch), left, third(ch)],
+    "left-bottom": [0, top + 2 * third(ch), left, third(ch)],
+    "right-top": [g.width - right, top, right, third(ch)],
+    "right-middle": [g.width - right, top + third(ch), right, third(ch)],
+    "right-bottom": [g.width - right, top + 2 * third(ch), right, third(ch)]
+  };
+  const [x, y, w, h] = T[name] ?? [0, 0, 0, 0];
+  return { x, y, w, h };
+}
+function marginBoxAlign(name) {
+  if (name.includes("center") || name.includes("middle"))
+    return "center";
+  return /right/.test(name) ? "end" : "start";
+}
+
 // src/engine/shared/synthesis.ts
 var RECTO_VERSO_VALUES = /^(right|recto|left|verso)$/;
 function isRectoVersoBreak(decl) {
@@ -1340,7 +1422,7 @@ 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-435cczt5.js";
+var preview_interface_default = "./preview-interface-0ssk8bmm.js";
 
 // src/assets/preview/scripts/preview-bridge.js
 var preview_bridge_default = "./preview-bridge-fz7vpk8m.js";
@@ -1352,10 +1434,10 @@ var preview_shell_default = "./preview-shell-c5mfa3q0.js";
 var CGATS21_CRPC1_default = "./CGATS21_CRPC1-g0e3k7kr.icc";
 
 // src/assets/engine/gutterpress-viewer.js
-var gutterpress_viewer_default = "./gutterpress-viewer-cem7dmr5.js";
+var gutterpress_viewer_default = "./gutterpress-viewer-te8g5grx.js";
 
 // src/assets/engine/gutterpress-agent.js
-var gutterpress_agent_default = "./gutterpress-agent-1ctgfz92.js";
+var gutterpress_agent_default = "./gutterpress-agent-cazqstr1.js";
 
 // src/assets/templates/book/manifest.yaml
 var manifest_default = "./manifest-n1gh3qw5.yaml";
@@ -1739,8 +1821,7 @@ async function build(opts) {
     await page.evaluate(AGENT);
     await page.waitForReady();
     const cssText = await page.evaluate(`window.__gp.collectCss()`);
-    const model = extract(cssText);
-    const { tier3Reasons } = classify(model);
+    let model = extract(cssText);
     const baseGeom = resolvePage(model).geometry;
     const sheetViewport = {
       width: Math.max(1, Math.round(baseGeom.width * 96 / 72)),
@@ -1751,6 +1832,97 @@ async function build(opts) {
     await page.send("Emulation.setDeviceMetricsOverride", sheetViewport);
     await page.send("Emulation.setEmulatedMedia", { media: "print" });
     log(`print media emulated for audits and measurement`);
+    const flushRoots = await page.evaluate(`window.__gp.flushRoots()`);
+    const flushGroups = new Map;
+    for (const root of flushRoots) {
+      if (flushGroups.has(root.key))
+        continue;
+      const authorPage = root.page === "auto" ? undefined : root.page;
+      flushGroups.set(root.key, {
+        authorPage,
+        edges: root.edges,
+        genName: flushPageName(authorPage, root.edges),
+        key: root.key
+      });
+    }
+    if (flushGroups.size) {
+      const lines = [];
+      for (const group of flushGroups.values()) {
+        const relocated = new Set(marginBoxesOnEdges(group.edges));
+        const pseudoSets = [[]];
+        if (group.authorPage) {
+          for (const rule of model.pageRules) {
+            if (rule.name !== group.authorPage)
+              continue;
+            const pseudo = rule.pseudos.length ? `:${rule.pseudos.join(":")}` : "";
+            if (rule.pseudos.length && !pseudoSets.some((ps) => ps.length === rule.pseudos.length && rule.pseudos.every((x) => ps.includes(x))))
+              pseudoSets.push(rule.pseudos);
+            const body = [];
+            for (const [prop, value] of Object.entries(rule.decls))
+              body.push(`  ${prop}: ${value};`);
+            for (const [box, decls] of Object.entries(rule.marginBoxes)) {
+              if (relocated.has(box.slice(1)))
+                continue;
+              body.push(`  ${box} {`);
+              for (const [prop, value] of Object.entries(decls))
+                body.push(`    ${prop}: ${value};`);
+              body.push(`  }`);
+            }
+            lines.push(`@page ${group.genName}${pseudo} {
+${body.join(`
+`)}
+}`);
+          }
+        }
+        for (const pseudos of pseudoSets) {
+          const pseudo = pseudos.length ? `:${pseudos.join(":")}` : "";
+          const body = [];
+          for (const edge of group.edges)
+            body.push(`  margin-${edge}: 0;`);
+          for (const box of relocated)
+            body.push(`  @${box} { content: none; }`);
+          lines.push(`@page ${group.genName}${pseudo} {
+${body.join(`
+`)}
+}`);
+        }
+        lines.push(`:where(.page, .spread)[data-gp-flush="${group.key}"][data-gp-flush][data-gp-flush][data-gp-flush] { page: ${group.genName}; }`);
+      }
+      const flushCss = lines.join(`
+`);
+      await page.evaluate(`window.__gp.addCss("gp-flush-css", ${JSON.stringify(flushCss)})`);
+      model = extract(`${cssText}
+${flushCss}`);
+      log(`.gp-flush: ${flushRoots.length} pinned root(s) -> ${flushGroups.size} generated page context(s)`);
+    }
+    const { tier3Reasons } = classify(model);
+    const pseudoContexts = pagePseudoContexts(model);
+    const contentHeightPt = (name) => Math.min(...pseudoContexts.map((pseudos) => {
+      const geometry = resolvePage(model, { name, pseudos }).geometry;
+      return geometry.height - geometry.margin.top - geometry.margin.bottom;
+    }));
+    const contentHeightPx = contentHeightPt() * 96 / 72;
+    const namedContentHeightsPx = Object.fromEntries(model.pageNames.map((name) => [name, contentHeightPt(name) * 96 / 72]));
+    const minContentHeightPx = Math.min(contentHeightPt(), ...model.pageNames.map((name) => contentHeightPt(name))) * 96 / 72;
+    const pageVarsCss = [
+      `:root { --gp-content-h: ${contentHeightPx}px; }`,
+      ...model.pageAssignments.map((a) => `${a.selector} { --gp-content-h: ${namedContentHeightsPx[a.page] ?? contentHeightPx}px; }`)
+    ].join(`
+`);
+    await page.evaluate(`window.__gp.addCss("gp-page-vars", ${JSON.stringify(pageVarsCss)})`);
+    log(`page geometry published (--gp-content-h: ${Math.round(contentHeightPx)}px)`);
+    const relocationBoxes = (group, pseudos) => {
+      const ctx = resolvePage(model, { name: group.authorPage, pseudos });
+      return marginBoxesOnEdges(group.edges).map((name) => [name, ctx.marginBoxes[`@${name}`]]).filter((pair) => {
+        const c = pair[1]?.content?.trim();
+        return !!c && c !== "none" && c !== "normal";
+      });
+    };
+    const furnitureRoots = flushRoots.filter((root) => {
+      const group = flushGroups.get(root.key);
+      return pseudoContexts.some((pseudos) => relocationBoxes(group, pseudos).length > 0);
+    });
+    const flushDiagnosed = new Set;
     const tier2 = synthesize({
       model,
       marks: opts.marks,
@@ -1770,11 +1942,15 @@ async function build(opts) {
     }).join(`
 `);
     if (widthOffenders.boxes.length) {
-      const msg = `content wider than the page content box triggers Chromium print ` + `shrink-to-fit (the WHOLE book scales down, silently):
+      const scale = shrinkScale(widthOffenders.boxes, widthOffenders.limitPx);
+      const headline = scale === null ? `content outside the page content box risks Chromium print ` + `shrink-to-fit (the WHOLE book scales down, silently)` : `content wider than the page content box: Chromium print shrink-to-fit ` + `scales the WHOLE document — every page, every measurement — to about ` + `${scale.toFixed(2)}x its declared size (12pt type prints at ` + `${(12 * scale).toFixed(1)}pt). The page size and page count do not ` + `change, so the shrink is invisible in the PDF`;
+      const msg = `${headline}:
 ${describe(widthOffenders.boxes)}`;
       if (opts.allowShrink) {
+        if (scale !== null)
+          diagnose("engine.width.overflow", `${headline}.`);
         for (const o of widthOffenders.boxes)
-          diagnose("engine.width.overflow", `${o.desc} is wider than the page — Chromium shrinks the WHOLE book to fit it. ${o.left < -1 ? "Keep it inside the page content box." : "Give it an explicit width that fits."}`);
+          diagnose("engine.width.overflow", `${o.desc} is ${Math.round(o.px)}px wide, past the ${Math.round(widthOffenders.limitPx)}px page content box. ${o.left < -1 ? "Keep it inside the page content box." : "Give it an explicit width that fits."}`);
         log(`WARNING: ${msg}`);
       } else {
         throw new Error(`${msg}
@@ -1789,7 +1965,7 @@ ${describe(widthOffenders.intrinsics)}`;
       log(`WARNING: ${msg}`);
     }
     const rectoDecls = model.breaks.filter(isRectoVersoBreak);
-    const needsMeasure = tier3Reasons.length > 0 || consumedStrings(model).size > 0 || rectoDecls.length > 0 || model.counterResets.length > 0;
+    const needsMeasure = tier3Reasons.length > 0 || consumedStrings(model).size > 0 || rectoDecls.length > 0 || model.counterResets.length > 0 || furnitureRoots.length > 0;
     let tier = tier2.geometry.bleed > 0 || tier2.geometry.slug > 0 ? 2 : 1;
     let passes = 1;
     let pageMap = {};
@@ -1817,6 +1993,8 @@ ${describe(widthOffenders.intrinsics)}`;
         targets.add(s.id);
       for (const s of resetSites)
         targets.add(s.id);
+      for (const r of furnitureRoots)
+        targets.add(r.id);
       await page.evaluate(`window.__gp.instrument(${JSON.stringify([...targets])})`);
       const targetText = await page.evaluate(`window.__gp.targetTexts(${JSON.stringify([...targets])})`);
       const brokenXrefs = findBrokenXrefRefs(sites, targetText);
@@ -1901,6 +2079,73 @@ ${describe(widthOffenders.intrinsics)}`;
 /* Tier 3 */
 ${mapCss}`;
         }
+        if (furnitureRoots.length) {
+          const pageAt = (id) => map[id] ?? predictedForResult?.pageMap[id];
+          const byName = new Map;
+          for (const s of sources) {
+            const p = pageAt(s.id);
+            if (!p)
+              continue;
+            const list = byName.get(s.name) ?? [];
+            list.push({ page: p, value: s.text });
+            byName.set(s.name, list);
+          }
+          for (const entries of byName.values())
+            entries.sort((a, b) => a.page - b.page);
+          const PXPT = 96 / 72;
+          const items = [];
+          for (const root of furnitureRoots) {
+            const physical = pageAt(root.id);
+            if (!physical)
+              continue;
+            const group = flushGroups.get(root.key);
+            const pseudos = [physical % 2 === 1 ? "right" : "left"];
+            if (physical === 1)
+              pseudos.push("first");
+            const ctx = resolvePage(model, { name: group.authorPage, pseudos });
+            const g = ctx.geometry;
+            const eff = flushMargins(g.margin, group.edges);
+            const boxes = [];
+            for (const [name, decls] of relocationBoxes(group, pseudos)) {
+              const text = evaluate(decls.content, {
+                page: toFolioPage(physical, pageValues),
+                pages: pageCount,
+                strings: (n, w) => stringValueAt(byName.get(n) ?? [], physical, parseWhich(w)),
+                targetPage: (u) => {
+                  const p = pageAt(u.replace(/^#/, ""));
+                  return p === undefined ? undefined : toFolioPage(p, pageValues);
+                }
+              });
+              if (!text) {
+                if (!flushDiagnosed.has(name)) {
+                  flushDiagnosed.add(name);
+                  diagnose("engine.flush.margin-box", `@${name} sits on an edge a .gp-flush pin frees, and its content could not be ` + `re-homed into the page (unsupported content value: ${decls.content}). It will ` + `not print on that page — simplify the box's content, or drop .gp-flush there.`);
+                }
+                continue;
+              }
+              const r = marginBoxRectPt(name, g);
+              const outDecls = {};
+              for (const [prop, value] of Object.entries(decls)) {
+                if (prop.toLowerCase() === "content" || isIgnoredMarginBoxProperty(prop))
+                  continue;
+                outDecls[prop] = value;
+              }
+              boxes.push({
+                box: name,
+                x: (r.x - eff.left) * PXPT,
+                y: (r.y - eff.top) * PXPT,
+                w: r.w * PXPT,
+                h: r.h * PXPT,
+                align: marginBoxAlign(name),
+                text,
+                decls: outDecls
+              });
+            }
+            items.push({ id: root.id, boxes });
+          }
+          if (items.length)
+            await page.evaluate(`window.__gp.setFlushFurniture(${JSON.stringify(items)})`);
+        }
       };
       const predicted = await predictPageMap(browser, url, AGENT, VIEWER, {
         stringSets: model.stringSets.map((s) => ({ selector: s.selector, name: s.name, value: s.value })),
@@ -1939,14 +2184,6 @@ ${mapCss}`;
         log(`tier 3: NOT converged after ${passes} passes`);
       }
     }
-    const pseudoContexts = pagePseudoContexts(model);
-    const contentHeightPt = (name) => Math.min(...pseudoContexts.map((pseudos) => {
-      const geometry = resolvePage(model, { name, pseudos }).geometry;
-      return geometry.height - geometry.margin.top - geometry.margin.bottom;
-    }));
-    const contentHeightPx = contentHeightPt() * 96 / 72;
-    const namedContentHeightsPx = Object.fromEntries(model.pageNames.map((name) => [name, contentHeightPt(name) * 96 / 72]));
-    const minContentHeightPx = Math.min(contentHeightPt(), ...model.pageNames.map((name) => contentHeightPt(name))) * 96 / 72;
     {
       const audit = await page.evaluate(`window.__gp.auditContent(${JSON.stringify({
         default: contentHeightPx,
@@ -2000,6 +2237,26 @@ ${mapCss}`;
             return reasons;
           };
 
+          // Does this box establish the containing block for an absolutely
+          // positioned descendant? Overflow clipping binds an abspos
+          // .gp-pin only from its containing block outward — MEASURED: a
+          // pin whose box lay entirely outside a STATIC overflow:hidden
+          // (and overflow:clip) wrapper printed complete and still behind
+          // the page text; the wrapper's clip never touched it.
+          const establishesAbsContainingBlock = (cs) => {
+            if (cs.position !== "static") return true;
+            for (const prop of [
+              "transform", "translate", "rotate", "scale", "perspective",
+              "filter", "backdropFilter",
+            ]) {
+              const value = cs[prop];
+              if (value && value !== "none") return true;
+            }
+            if (/\\b(layout|paint|strict|content)\\b/.test(cs.contain)) return true;
+            if (cs.containerType && cs.containerType !== "normal") return true;
+            return /\\b(transform|translate|rotate|scale|perspective|filter)\\b/.test(cs.willChange);
+          };
+
           for (const el of document.querySelectorAll("*")) {
             const cs = getComputedStyle(el);
             if (leaks.length < 20) {
@@ -2040,20 +2297,58 @@ ${mapCss}`;
             ) {
               const boundary = el.closest(".page, .spread");
               if (boundary) {
+                const elRect = el.getBoundingClientRect();
+                // Clip binding: an in-flow .gp-behind is bound by every
+                // ancestor's overflow, but an abspos one only from its
+                // containing block outward — static wrappers in between
+                // never clip it (measured; see the pass comment above).
+                let clipBinds = cs.position !== "absolute" && cs.position !== "fixed";
                 for (let ancestor = el.parentElement; ancestor; ancestor = ancestor.parentElement) {
                   const ancestorStyle = getComputedStyle(ancestor);
+                  if (!clipBinds && establishesAbsContainingBlock(ancestorStyle)) clipBinds = true;
                   const reasons = stackingReasons(ancestor, ancestorStyle);
-                  const clips = ancestorStyle.overflowX !== "visible" ||
-                    ancestorStyle.overflowY !== "visible";
-                  if ((reasons.length || clips) && !seenLayerTraps.has(ancestor)) {
+                  // Clipping never reorders layers — it can only CUT the
+                  // art (measured, pass comment above): warn only where the
+                  // border box crosses a binding ancestor's clip edge on an
+                  // axis whose overflow is not \`visible\`. The clip edge is
+                  // the padding box, grown by overflow-clip-margin where
+                  // that axis's value is \`clip\` (px values only; keyword
+                  // forms parse NaN -> 0, i.e. the ungrown padding box).
+                  // 1px epsilon: the measured cut lands exactly at the
+                  // edge, and sub-pixel layout rounding is not an overhang.
+                  const cuts = [];
+                  if (clipBinds && (ancestorStyle.overflowX !== "visible" || ancestorStyle.overflowY !== "visible")) {
+                    const r = ancestor.getBoundingClientRect();
+                    const clipMargin = parseFloat(ancestorStyle.overflowClipMargin) || 0;
+                    if (ancestorStyle.overflowX !== "visible") {
+                      const grow = ancestorStyle.overflowX === "clip" ? clipMargin : 0;
+                      const left = r.left + parseFloat(ancestorStyle.borderLeftWidth) - grow;
+                      const right = r.right - parseFloat(ancestorStyle.borderRightWidth) + grow;
+                      if (elRect.left < left - 1)
+                        cuts.push(Math.round(left - elRect.left) + "px past its left clip edge");
+                      if (elRect.right > right + 1)
+                        cuts.push(Math.round(elRect.right - right) + "px past its right clip edge");
+                    }
+                    if (ancestorStyle.overflowY !== "visible") {
+                      const grow = ancestorStyle.overflowY === "clip" ? clipMargin : 0;
+                      const top = r.top + parseFloat(ancestorStyle.borderTopWidth) - grow;
+                      const bottom = r.bottom - parseFloat(ancestorStyle.borderBottomWidth) + grow;
+                      if (elRect.top < top - 1)
+                        cuts.push(Math.round(top - elRect.top) + "px past its top clip edge");
+                      if (elRect.bottom > bottom + 1)
+                        cuts.push(Math.round(elRect.bottom - bottom) + "px past its bottom clip edge");
+                    }
+                  }
+                  if ((reasons.length || cuts.length) && !seenLayerTraps.has(ancestor)) {
                     seenLayerTraps.add(ancestor);
                     const effects = [];
                     if (reasons.length)
                       effects.push("creates a stacking context (" + reasons.join(", ") + ")");
-                    if (clips)
+                    if (cuts.length)
                       effects.push(
-                        "clips descendants (overflow-x: " + ancestorStyle.overflowX +
-                        ", overflow-y: " + ancestorStyle.overflowY + ")"
+                        "clips it (overflow-x: " + ancestorStyle.overflowX +
+                        ", overflow-y: " + ancestorStyle.overflowY +
+                        ") — the art extends " + cuts.join(" and ") + " and is cut off there"
                       );
                     layerTraps.push({
                       behind: desc(el),
@@ -2121,10 +2416,17 @@ async function printPdf(page) {
   await page.waitForReady();
   return page.printToPDF();
 }
+var MAX_SHRINK = 1.5;
+function shrinkScale(boxes, limitPx) {
+  const maxRight = Math.max(...boxes.map((o) => o.px + Math.min(0, o.left)));
+  if (!(maxRight > limitPx))
+    return null;
+  return Math.max(1 / MAX_SHRINK, limitPx / maxRight);
+}
 async function findWidthOffenders(page, model, bleedSlugExtensionPt, restoreViewport) {
   const contexts = [
     resolvePage(model),
-    ...model.pageNames.filter((n) => !n.startsWith("gp-")).map((n) => resolvePage(model, { name: n }))
+    ...model.pageNames.filter((n) => !n.startsWith("gp-") || n.startsWith("gp--flush-")).map((n) => resolvePage(model, { name: n }))
   ];
   const maxContentPt = Math.max(...contexts.map((c) => c.geometry.width - c.geometry.margin.left - c.geometry.margin.right)) + bleedSlugExtensionPt;
   const limitPx = maxContentPt * 96 / 72;
@@ -2211,6 +2513,7 @@ async function predictPageMap(browser, url, agentScript, viewerScript, args, she
     await page.waitForReady();
     await page.evaluate(`window.__GP_MANUAL__ = true;`);
     await page.evaluate(viewerScript);
+    await page.evaluate(`window.__gp.flushRoots()`);
     await page.evaluate(`window.__gp.stringSources(${JSON.stringify(args.stringSets)})`);
     if (args.rectoDecls.length)
       await page.evaluate(`window.__gp.forcedBreakSites(${JSON.stringify(args.rectoDecls)})`);
@@ -2340,4 +2643,4 @@ ${lines.length ? lines.join(`
 `);
 }
 
-export { RENDER_TIMEOUT_MS, prewarmBrowser, getBrowser, closeBrowser, getAssetPath, REQUIRED_MILESTONE, assertMilestone, connectChromium, build };
+export { RENDER_TIMEOUT_MS, prewarmBrowser, getBrowser, closeBrowser, getAssetPath, MARGIN_BOX_IGNORED_PROPERTIES, REQUIRED_MILESTONE, assertMilestone, connectChromium, build };

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   previewArgs
-} from "./cli-revgt4pr.js";
+} from "./cli-yzf38679.js";
 import {
   UsageError,
   package_default,
   rejectUnknownFlags
-} from "./cli-0r0tq16s.js";
+} from "./cli-149edp6b.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
@@ -18,17 +18,17 @@ import {
 import { defineCommand, parseArgs, runMain } from "citty";
 import { statSync } from "node:fs";
 var SUBCOMMANDS = {
-  new: () => import("./new-kwdwpf0j.js").then((m) => m.default),
-  preview: () => import("./preview-ncgfhqmw.js").then((m) => m.default),
-  build: () => import("./build-hqmwgvdw.js").then((m) => m.default),
-  publish: () => import("./publish-pr0rwh6p.js").then((m) => m.default),
-  lint: () => import("./lint-xjwm5ep8.js").then((m) => m.default),
-  validate: () => import("./validate-54e17rae.js").then((m) => m.default),
-  audit: () => import("./audit-k1vnfwvc.js").then((m) => m.default),
-  preflight: () => import("./preflight-3127y25z.js").then((m) => m.default),
-  repair: () => import("./repair-8270smfw.js").then((m) => m.default),
-  doctor: () => import("./doctor-dxms7ehm.js").then((m) => m.default),
-  plugin: () => import("./plugin-rg4tnn96.js").then((m) => m.default)
+  new: () => import("./new-hvq0x91q.js").then((m) => m.default),
+  preview: () => import("./preview-d4s6gk6p.js").then((m) => m.default),
+  build: () => import("./build-6r502chw.js").then((m) => m.default),
+  publish: () => import("./publish-tkc26en7.js").then((m) => m.default),
+  lint: () => import("./lint-p2sw53d9.js").then((m) => m.default),
+  validate: () => import("./validate-w9vfefrw.js").then((m) => m.default),
+  audit: () => import("./audit-cvarpa72.js").then((m) => m.default),
+  preflight: () => import("./preflight-4j00yd0g.js").then((m) => m.default),
+  repair: () => import("./repair-2va4w12t.js").then((m) => m.default),
+  doctor: () => import("./doctor-akvxbtjb.js").then((m) => m.default),
+  plugin: () => import("./plugin-pssmk0dx.js").then((m) => m.default)
 };
 var VERSION = package_default.version;
 var main = defineCommand({
@@ -53,7 +53,7 @@ async function preflightRequiredInvocations(rawArgs) {
   const [command, ...commandArgs] = rawArgs;
   try {
     if (command === "new") {
-      const { newArgs } = await import("./new-kwdwpf0j.js");
+      const { newArgs } = await import("./new-hvq0x91q.js");
       rejectUnknownFlags(commandArgs, newArgs, "new");
       const parsed2 = parseArgs(commandArgs, {
         ...newArgs,
@@ -65,7 +65,7 @@ async function preflightRequiredInvocations(rawArgs) {
       return;
     }
     if (command === "preflight") {
-      const { preflightArgs } = await import("./preflight-3127y25z.js");
+      const { preflightArgs } = await import("./preflight-4j00yd0g.js");
       rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
       const parsed2 = parseArgs(commandArgs, {
         ...preflightArgs,
@@ -89,7 +89,7 @@ async function preflightRequiredInvocations(rawArgs) {
     if (subcommand !== "add") {
       throw new UsageError(`gutterpress plugin: unknown command "${subcommand}"`);
     }
-    const { pluginAddArgs } = await import("./plugin-rg4tnn96.js");
+    const { pluginAddArgs } = await import("./plugin-pssmk0dx.js");
     rejectUnknownFlags(subcommandArgs, pluginAddArgs, "plugin add");
     const parsed = parseArgs(subcommandArgs, {
       ...pluginAddArgs,

package/dist/{doctor-dxms7ehm.js → doctor-akvxbtjb.js}

@@ -1,12 +1,12 @@
 import {
   getSystemDiagnostics,
   log
-} from "./cli-ra0ed2xt.js";
+} from "./cli-cqtggsng.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-0r0tq16s.js";
+} from "./cli-149edp6b.js";
 import"./cli-c41yr7he.js";
 import"./cli-46ycxe6r.js";
 import"./cli-37x76zdn.js";

package/dist/engine/compiler/build.d.ts

@@ -7,7 +7,7 @@ import { type PostprocessResult } from "./postprocess.ts";
  * set is closed here so a surface's label table can be asserted complete
  * against it rather than drifting silently as checks are added.
  */
-export type BuildDiagnosticCode = "engine.width.overflow" | "engine.width.intrinsic" | "engine.xref.broken" | "engine.abspos.leak" | "engine.layer.trapped" | "engine.multicol.dead-column" | "engine.content.overheight" | "engine.image.low-dpi";
+export type BuildDiagnosticCode = "engine.width.overflow" | "engine.width.intrinsic" | "engine.xref.broken" | "engine.abspos.leak" | "engine.layer.trapped" | "engine.multicol.dead-column" | "engine.content.overheight" | "engine.image.low-dpi" | "engine.flush.margin-box";
 export declare const BUILD_DIAGNOSTIC_CODES: readonly BuildDiagnosticCode[];
 export interface BuildDiagnostic {
     code: BuildDiagnosticCode;

package/dist/engine/shared/flush.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `.gp-flush` policy — shared by the compiler and the viewer, like every rule
+ * that DECIDES something (see synthesis.ts's header).
+ *
+ * A pinned image reaches the paper only if the page's own margin is removed
+ * on that edge: Chromium's printable area IS the page area — MEASURED, a
+ * pinned box pulled into the margin with negative insets fragments onto the
+ * NEXT sheet, one moved there with a transform is clipped away entirely, and
+ * a margin box in a ~zero margin (1px, with padding/height compensation)
+ * simply does not render. So flush is implemented as page GEOMETRY, per page:
+ *
+ *  - The COMPILER aliases the flush root's own page context under a
+ *    generated name (verbatim rule copies — never a resolved flatten, which
+ *    is the "re-implement the @page cascade" trap tier2's history records),
+ *    zeroes the flushed margins on the alias, and assigns the root to it.
+ *  - The VIEWER keeps the author's page context and adjusts the strip
+ *    geometry in JS from these same functions.
+ *
+ * Margin boxes live IN the margin, so the flushed edge's furniture (folio,
+ * running head) cannot render natively there — MEASURED, no compensation
+ * trick survives. Both renderers therefore keep painting that furniture
+ * themselves at its ORIGINAL coordinates: the viewer already synthesizes all
+ * furniture as DOM; the compiler injects the flushed edge's boxes into the
+ * page root as positioned elements with engine-resolved text. Nothing the
+ * author declared is lost — that is the contract this module's box map
+ * exists to keep.
+ */
+import type { PageGeometry } from "./gcpm-extract.ts";
+export declare const FLUSH_EDGES: readonly ["top", "right", "bottom", "left"];
+export type FlushEdge = (typeof FLUSH_EDGES)[number];
+/** Minimal DOM shape needed by `flushEdgesIn` — keeps this module node-safe. */
+interface QueryRoot {
+    querySelector(sel: string): unknown;
+}
+/**
+ * Which edges the flush pins inside `root` ask for, in canonical t/r/b/l
+ * order. A `.gp-flush` without `.gp-pin` or without an edge word is inert by
+ * construction — every selector here requires all three.
+ */
+export declare function flushEdgesIn(root: QueryRoot): FlushEdge[];
+/** Canonical short key for an edge set: "b", "rb", "trbl"… (t/r/b/l order). */
+export declare function flushKey(edges: readonly FlushEdge[]): string;
+/**
+ * Generated page name for (author page context, edge set). The `gp--` double
+ * dash marks an engine-generated page (the `gp--blank` convention); these
+ * exist only in builds that actually contain a flush pin, which is why the
+ * width check may treat them as real author contexts.
+ */
+export declare function flushPageName(authorPage: string | undefined, edges: readonly FlushEdge[]): string;
+/** The page's margins with the flushed edges freed. */
+export declare function flushMargins(margin: PageGeometry["margin"], edges: readonly FlushEdge[]): PageGeometry["margin"];
+/**
+ * Margin boxes that live (wholly or partly) in a flushed edge's margin area —
+ * the set both renderers must keep painting themselves. A corner box belongs
+ * to BOTH of its edges: `bottom-left-corner` dies when either the bottom or
+ * the left margin is freed.
+ */
+export declare function marginBoxesOnEdges(edges: readonly FlushEdge[]): string[];
+export {};

package/dist/engine/shared/margin-box-support.d.ts

@@ -10,3 +10,27 @@
  */
 export declare const MARGIN_BOX_IGNORED_PROPERTIES: ReadonlySet<string>;
 export declare function isIgnoredMarginBoxProperty(property: string): boolean;
+/**
+ * Geometry of each of the 16 margin boxes, per CSS Paged Media §5.3, in pt
+ * SHEET coordinates (origin at the sheet's top-left). One implementation for
+ * both furniture painters: the viewer's `drawMarginBoxes` overlays and the
+ * compiler's `.gp-flush` furniture relocation must place a box at the same
+ * spot or preview and print disagree about where the folio sits.
+ */
+export declare function marginBoxRectPt(name: string, g: {
+    width: number;
+    height: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** Horizontal alignment of a margin box's content within its slot. */
+export declare function marginBoxAlign(name: string): "start" | "center" | "end";