gutterpress 0.10.0 → 0.10.1-beta.2

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

@@ -1422,19 +1422,19 @@ 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";
 
 // src/assets/engine/gutterpress-viewer.js
-var gutterpress_viewer_default = "./gutterpress-viewer-te8g5grx.js";
+var gutterpress_viewer_default = "./gutterpress-viewer-tma1qwz2.js";
 
 // src/assets/engine/gutterpress-agent.js
 var gutterpress_agent_default = "./gutterpress-agent-cazqstr1.js";
@@ -1768,6 +1768,62 @@ var DESC_JS = `(el) => {
     const src = el.tagName === "IMG" ? " src=" + (el.getAttribute("src") || "").slice(-40) : "";
     return el.tagName.toLowerCase() + cls + src;
   }`;
+var ABS_CONTAINING_BLOCK_JS = `(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);
+  }`;
+var CLIP_EDGES_JS = `((establishesAbsContainingBlock) => {
+    const open = () => ({ left: -Infinity, right: Infinity, top: -Infinity, bottom: Infinity });
+    const rootStyle = getComputedStyle(document.documentElement);
+    const propagates = (a, rootOverflow) =>
+      a === document.documentElement ||
+      (a === document.body && rootOverflow === "visible");
+    return (el) => {
+      const edges = open();
+      const chain = [];
+      const elStyle = getComputedStyle(el);
+      const fixed = elStyle.position === "fixed";
+      let binds = !fixed && elStyle.position !== "absolute";
+      for (let a = el.parentElement; a; a = a.parentElement) {
+        const cs = getComputedStyle(a);
+        if (!fixed && !binds && establishesAbsContainingBlock(cs)) binds = true;
+        const own = open();
+        const clipsX =
+          binds && cs.overflowX !== "visible" && !propagates(a, rootStyle.overflowX);
+        const clipsY =
+          binds && cs.overflowY !== "visible" && !propagates(a, rootStyle.overflowY);
+        if (clipsX || clipsY) {
+          const r = a.getBoundingClientRect();
+          const clipMargin = parseFloat(cs.overflowClipMargin) || 0;
+          if (clipsX) {
+            const grow = cs.overflowX === "clip" ? clipMargin : 0;
+            own.left = r.left + parseFloat(cs.borderLeftWidth) - grow;
+            own.right = r.right - parseFloat(cs.borderRightWidth) + grow;
+            edges.left = Math.max(edges.left, own.left);
+            edges.right = Math.min(edges.right, own.right);
+          }
+          if (clipsY) {
+            const grow = cs.overflowY === "clip" ? clipMargin : 0;
+            own.top = r.top + parseFloat(cs.borderTopWidth) - grow;
+            own.bottom = r.bottom - parseFloat(cs.borderBottomWidth) + grow;
+            edges.top = Math.max(edges.top, own.top);
+            edges.bottom = Math.min(edges.bottom, own.bottom);
+          }
+        }
+        chain.push({ ancestor: a, style: cs, edges: own });
+      }
+      return { edges, chain };
+    };
+  })(${ABS_CONTAINING_BLOCK_JS})`;
 function pagePseudoContexts(model) {
   const used = new Set(pseudoVariants(model));
   const standard = new Set(["left", "right", "recto", "verso", "first", "blank"]);
@@ -2237,25 +2293,11 @@ ${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);
-          };
+          // Which ancestors clip a .gp-behind, and where their edges fall —
+          // the same measured rule the pre-print width check clamps against
+          // (see CLIP_EDGES_JS). This pass walks its \`chain\` so it can name
+          // the ancestor doing the cutting.
+          const clipEdges = ${CLIP_EDGES_JS};
 
           for (const el of document.querySelectorAll("*")) {
             const cs = getComputedStyle(el);
@@ -2298,47 +2340,25 @@ ${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;
+                for (const link of clipEdges(el).chain) {
+                  const ancestor = link.ancestor;
+                  const ancestorStyle = link.style;
                   const reasons = stackingReasons(ancestor, ancestorStyle);
                   // 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.
+                  // border box crosses THIS ancestor's own clip edges, which
+                  // are ±Infinity on any axis it does not bind. 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 (elRect.left < link.edges.left - 1)
+                    cuts.push(Math.round(link.edges.left - elRect.left) + "px past its left clip edge");
+                  if (elRect.right > link.edges.right + 1)
+                    cuts.push(Math.round(elRect.right - link.edges.right) + "px past its right clip edge");
+                  if (elRect.top < link.edges.top - 1)
+                    cuts.push(Math.round(link.edges.top - elRect.top) + "px past its top clip edge");
+                  if (elRect.bottom > link.edges.bottom + 1)
+                    cuts.push(Math.round(elRect.bottom - link.edges.bottom) + "px past its bottom clip edge");
                   if ((reasons.length || cuts.length) && !seenLayerTraps.has(ancestor)) {
                     seenLayerTraps.add(ancestor);
                     const effects = [];
@@ -2443,6 +2463,20 @@ async function findWidthOffenders(page, model, bleedSlugExtensionPt, restoreView
     const boxes = JSON.parse(await page.evaluate(`(() => {
         const LIMIT = ${limitPx} + 1;
         const desc = ${DESC_JS};
+        // Shrink-to-fit only reacts to overflow that ESCAPES: a clipping or
+        // scrolling ancestor contains its subtree's overflow, so the
+        // document's own width never grows and the book prints at 1.0x.
+        // MEASURED (Chrome 151, a marker word read off \`pdftotext -bbox\`
+        // against an unshrunk control): a 900px box inside a 300px
+        // \`overflow: hidden\` shell printed unshrunk, as did the same box
+        // under clip/auto/scroll — and a real 208-page book whose two
+        // "offenders" both sat under \`overflow-x: clip\` printed
+        // coordinate-identical with them restored. WHICH ancestors clip, and
+        // where their edges fall, is CLIP_EDGES_JS's measured rule — shared
+        // with the layer-containment audit, which measures overhang past the
+        // same edges. Only the x edges matter here: shrink-to-fit is a width
+        // response.
+        const clipEdges = ${CLIP_EDGES_JS};
         const out = [];
         for (const el of document.querySelectorAll("*")) {
           const r = el.getBoundingClientRect();
@@ -2452,6 +2486,9 @@ async function findWidthOffenders(page, model, bleedSlugExtensionPt, restoreView
           // width) — both trigger the same whole-document shrink-to-fit,
           // measured: a left bleed alone cost 16%.
           if (right <= LIMIT && r.width <= LIMIT && r.left >= -1) continue;
+          // ...but only where it actually escapes its clipping ancestors.
+          const clip = clipEdges(el).edges;
+          if (Math.min(right, clip.right) <= LIMIT && Math.max(r.left, clip.left) >= -1) continue;
           let deepest = true;
           for (const c of el.children) {
             if (c.getBoundingClientRect().width >= r.width - 1) { deepest = false; break; }

package/dist/{cli-k1065rkg.js → cli-w692g6dx.js}

@@ -4,8 +4,59 @@ import {
   findEnclosingRepoDir
 } from "./cli-v5mp7a6q.js";
 
+// src/lib/git-fs.ts
+import * as nodeFs from "node:fs";
+var MUTABLE_GIT_METADATA = /(?:^|[\\/])\.git[\\/](?:index|HEAD|packed-refs|refs[\\/].+)$/;
+function needsAtomicWrite(file) {
+  return typeof file === "string" && MUTABLE_GIT_METADATA.test(file);
+}
+var tempCounter = 0;
+function tempPathFor(file) {
+  return `${file}.gp${process.pid.toString(36)}-${(tempCounter++).toString(36)}.tmp`;
+}
+function writeFile2(file, data, options, callback) {
+  const cb = typeof options === "function" ? options : callback;
+  const opts = typeof options === "function" ? undefined : options;
+  if (!needsAtomicWrite(file)) {
+    nodeFs.writeFile(file, data, opts, cb);
+    return;
+  }
+  const temp = tempPathFor(file);
+  const failed = (err) => nodeFs.unlink(temp, () => cb(err));
+  nodeFs.writeFile(temp, data, opts, (writeErr) => {
+    if (writeErr)
+      return failed(writeErr);
+    nodeFs.rename(temp, file, (renameErr) => {
+      if (renameErr)
+        return failed(renameErr);
+      cb(null);
+    });
+  });
+}
+async function writeFilePromise(file, data, options) {
+  if (!needsAtomicWrite(file)) {
+    return nodeFs.promises.writeFile(file, data, options);
+  }
+  const temp = tempPathFor(file);
+  try {
+    await nodeFs.promises.writeFile(temp, data, options);
+    await nodeFs.promises.rename(temp, file);
+  } catch (err) {
+    await nodeFs.promises.unlink(temp).catch(() => {});
+    throw err;
+  }
+}
+var promises2 = {
+  ...nodeFs.promises,
+  writeFile: writeFilePromise
+};
+var gitFs = {
+  ...nodeFs,
+  writeFile: writeFile2,
+  promises: promises2
+};
+
 // src/lib/source-provider.ts
-import * as fs from "node:fs";
 import path2 from "node:path";
 import git from "isomorphic-git";
 
@@ -43,11 +94,6 @@ function createFileLogger(logFile, operation, minLevel = "debug") {
     error: (step, message, data) => write("error", step, message, data)
   };
 }
-function resolveLogger(logFile, operation) {
-  if (!logFile)
-    return noop;
-  return createFileLogger(logFile, operation);
-}
 function formatData(data) {
   if (!data)
     return "";
@@ -83,7 +129,7 @@ var repoQueues = new Map;
 function repoLockKey(projectDir) {
   const resolved = path2.resolve(projectDir);
   try {
-    return fs.realpathSync(resolved);
+    return gitFs.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -114,10 +160,10 @@ function gitAuthor(name, email) {
 }
 async function readGitAuthor(dir) {
   const [name, email] = await Promise.all([
-    git.getConfig({ fs, dir, path: "user.name" }).catch(() => {
+    git.getConfig({ fs: gitFs, dir, path: "user.name" }).catch(() => {
       return;
     }),
-    git.getConfig({ fs, dir, path: "user.email" }).catch(() => {
+    git.getConfig({ fs: gitFs, dir, path: "user.email" }).catch(() => {
       return;
     })
   ]);
@@ -134,14 +180,14 @@ async function listWorkdirChanges(dir, cache = {}) {
   const adds = [];
   const removes = [];
   await git.walk({
-    fs,
+    fs: gitFs,
     dir,
     cache,
     trees: [git.WORKDIR(), git.STAGE()],
     map: async (filepath, [workdir, stage]) => {
       if (filepath === ".")
         return;
-      if (!stage && workdir && await git.isIgnored({ fs, dir, filepath })) {
+      if (!stage && workdir && (filepath.startsWith(".git-damaged") || await git.isIgnored({ fs: gitFs, dir, filepath }))) {
         return null;
       }
       const [wType, sType] = await Promise.all([
@@ -165,7 +211,7 @@ async function listWorkdirChanges(dir, cache = {}) {
         if (workdirOid !== stageOid) {
           adds.push(filepath);
         } else {
-          const fileBytes = await fs.promises.readFile(path2.join(dir, filepath));
+          const fileBytes = await gitFs.promises.readFile(path2.join(dir, filepath));
           const { oid: actualOid } = await git.hashBlob({ object: fileBytes });
           if (actualOid !== stageOid)
             adds.push(filepath);
@@ -178,10 +224,10 @@ async function listWorkdirChanges(dir, cache = {}) {
 }
 async function stageChanges(dir, changes, cache) {
   if (changes.adds.length > 0) {
-    await git.add({ fs, dir, cache, filepath: changes.adds });
+    await git.add({ fs: gitFs, dir, cache, filepath: changes.adds });
   }
   for (const filepath of changes.removes) {
-    await git.remove({ fs, dir, cache, filepath });
+    await git.remove({ fs: gitFs, dir, cache, filepath });
   }
 }
 async function hasPendingChanges(dir, cache = {}) {
@@ -196,13 +242,13 @@ async function hasUncommittedChanges(dir, cache = {}) {
 async function stageMatchesHead(dir, cache) {
   let headOid;
   try {
-    headOid = await git.resolveRef({ fs, dir, ref: "HEAD" });
+    headOid = await git.resolveRef({ fs: gitFs, dir, ref: "HEAD" });
   } catch {
     return false;
   }
   let differs = false;
   await git.walk({
-    fs,
+    fs: gitFs,
     dir,
     cache,
     trees: [git.TREE({ ref: headOid }), git.STAGE()],
@@ -244,10 +290,10 @@ class LocalFolderSourceProvider {
     }
     return withRepoLock(dir, async () => {
       const cache = {};
-      await git.init({ fs, dir, defaultBranch: DEFAULT_BRANCH });
+      await git.init({ fs: gitFs, dir, defaultBranch: DEFAULT_BRANCH });
       await stageChanges(dir, await listWorkdirChanges(dir, cache), cache);
       await git.commit({
-        fs,
+        fs: gitFs,
         dir,
         cache,
         message: options.initialMessage?.trim() || "Created project",
@@ -316,7 +362,7 @@ class LocalGitSourceProvider {
     let commits;
     try {
       commits = await git.log({
-        fs,
+        fs: gitFs,
         dir,
         cache: {},
         depth: limit + 2,
@@ -353,7 +399,7 @@ class LocalGitSourceProvider {
   }
   async restoreUnlocked(options) {
     await git.checkout({
-      fs,
+      fs: gitFs,
       dir: this.dir,
       cache: {},
       ref: options.id,
@@ -365,9 +411,9 @@ class LocalGitSourceProvider {
 async function snapshotWorkingTreeUnlocked(options) {
   const dir = options.repoRoot ?? options.projectDir;
   const logger = options.logFile ? createFileLogger(options.logFile, "snapshot") : noopLogger;
-  const cache = {};
+  const cache = options.cache ?? {};
   const stagingMarker = snapshotStagingMarkerPath(dir);
-  const staleStaging = fs.existsSync(stagingMarker);
+  const staleStaging = gitFs.existsSync(stagingMarker);
   const changes = await listWorkdirChanges(dir, cache);
   const workdirClean = changes.adds.length === 0 && changes.removes.length === 0;
   if (workdirClean && !staleStaging) {
@@ -376,8 +422,8 @@ async function snapshotWorkingTreeUnlocked(options) {
   }
   if (workdirClean && staleStaging && await stageMatchesHead(dir, cache)) {
     logger.debug("snapshot", "stale marker outlived a completed commit — clearing, not recommitting");
-    fs.rmSync(stagingMarker, { force: true });
-    const [head2] = await git.log({ fs, dir, cache, depth: 1 });
+    gitFs.rmSync(stagingMarker, { force: true });
+    const [head2] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
     return {
       id: head2.oid,
       message: head2.commit.message.trim(),
@@ -390,18 +436,18 @@ async function snapshotWorkingTreeUnlocked(options) {
     removes: changes.removes.length,
     ...staleStaging ? { recoveredStaleStaging: true } : {}
   });
-  fs.writeFileSync(stagingMarker, "");
+  gitFs.writeFileSync(stagingMarker, "");
   await stageChanges(dir, changes, cache);
   const author = await resolveGitAuthor(dir, options.authorName, options.authorEmail);
   const id = await git.commit({
-    fs,
+    fs: gitFs,
     dir,
     cache,
     message: options.message,
     author
   });
-  fs.rmSync(stagingMarker, { force: true });
-  const [head] = await git.log({ fs, dir, cache, depth: 1 });
+  gitFs.rmSync(stagingMarker, { force: true });
+  const [head] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
   return {
     id,
     message: options.message,
@@ -458,4 +504,4 @@ async function restoreVersionWithBackup(options) {
   });
 }
 
-export { resolveLogger, gitScopeFor, HISTORY_PAGE_LIMIT, withRepoLock, __repoLockQueueSizeForTests, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup };
+export { gitScopeFor, HISTORY_PAGE_LIMIT, withRepoLock, __repoLockQueueSizeForTests, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup };

package/dist/{cli-149edp6b.js → cli-ydpf09d9.js}

@@ -4,7 +4,7 @@ import {
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.10.0",
+  version: "0.10.1-beta.2",
   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.js

@@ -6,7 +6,7 @@ import {
   UsageError,
   package_default,
   rejectUnknownFlags
-} from "./cli-149edp6b.js";
+} from "./cli-ydpf09d9.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
@@ -18,17 +18,16 @@ import {
 import { defineCommand, parseArgs, runMain } from "citty";
 import { statSync } from "node:fs";
 var SUBCOMMANDS = {
-  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)
+  new: () => import("./new-xy2qc300.js").then((m) => m.default),
+  preview: () => import("./preview-h479apj9.js").then((m) => m.default),
+  build: () => import("./build-bj4x0727.js").then((m) => m.default),
+  publish: () => import("./publish-emk644a8.js").then((m) => m.default),
+  lint: () => import("./lint-c8ze8sqw.js").then((m) => m.default),
+  validate: () => import("./validate-be54bdc6.js").then((m) => m.default),
+  audit: () => import("./audit-dce99css.js").then((m) => m.default),
+  preflight: () => import("./preflight-prcvdvmk.js").then((m) => m.default),
+  doctor: () => import("./doctor-7nd6n2aa.js").then((m) => m.default),
+  plugin: () => import("./plugin-g9hwzjsm.js").then((m) => m.default)
 };
 var VERSION = package_default.version;
 var main = defineCommand({
@@ -53,7 +52,7 @@ async function preflightRequiredInvocations(rawArgs) {
   const [command, ...commandArgs] = rawArgs;
   try {
     if (command === "new") {
-      const { newArgs } = await import("./new-hvq0x91q.js");
+      const { newArgs } = await import("./new-xy2qc300.js");
       rejectUnknownFlags(commandArgs, newArgs, "new");
       const parsed2 = parseArgs(commandArgs, {
         ...newArgs,
@@ -65,7 +64,7 @@ async function preflightRequiredInvocations(rawArgs) {
       return;
     }
     if (command === "preflight") {
-      const { preflightArgs } = await import("./preflight-4j00yd0g.js");
+      const { preflightArgs } = await import("./preflight-prcvdvmk.js");
       rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
       const parsed2 = parseArgs(commandArgs, {
         ...preflightArgs,
@@ -89,7 +88,7 @@ async function preflightRequiredInvocations(rawArgs) {
     if (subcommand !== "add") {
       throw new UsageError(`gutterpress plugin: unknown command "${subcommand}"`);
     }
-    const { pluginAddArgs } = await import("./plugin-pssmk0dx.js");
+    const { pluginAddArgs } = await import("./plugin-g9hwzjsm.js");
     rejectUnknownFlags(subcommandArgs, pluginAddArgs, "plugin add");
     const parsed = parseArgs(subcommandArgs, {
       ...pluginAddArgs,

package/dist/{doctor-akvxbtjb.js → doctor-7nd6n2aa.js}

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

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

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

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

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