gutterpress 0.11.17-alpha.2 → 0.11.17-alpha.4

package/dist/{cli-70xgehq2.js → cli-8apk8571.js}

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

package/dist/cli-ht1bcqdd.js

@@ -0,0 +1,493 @@
+import {
+  __require
+} from "./cli-37x76zdn.js";
+
+// src/lib/black-text-gray.ts
+var MAX_CHANNEL = 0.12;
+var MAX_SPREAD = 0.04;
+function isNearBlack([r, g, b]) {
+  const max = Math.max(r, g, b);
+  return max <= MAX_CHANNEL && max - Math.min(r, g, b) <= MAX_SPREAD;
+}
+var WS = new Set([0, 9, 10, 12, 13, 32]);
+var DELIM = new Set("()<>[]{}/%".split("").map((c) => c.charCodeAt(0)));
+function* tokenize(s) {
+  let i = 0;
+  const n = s.length;
+  while (i < n) {
+    const c = s.charCodeAt(i);
+    if (WS.has(c)) {
+      i++;
+      continue;
+    }
+    const start = i;
+    if (c === 37) {
+      while (i < n && s[i] !== `
+` && s[i] !== "\r")
+        i++;
+      continue;
+    }
+    if (c === 40) {
+      let depth = 0;
+      while (i < n) {
+        const d = s[i++];
+        if (d === "\\")
+          i++;
+        else if (d === "(")
+          depth++;
+        else if (d === ")" && --depth === 0)
+          break;
+      }
+      yield { text: s.slice(start, i), start, end: i, op: false };
+      continue;
+    }
+    if (c === 60 && s[i + 1] === "<") {
+      i += 2;
+      yield { text: "<<", start, end: i, op: false };
+      continue;
+    }
+    if (c === 62 && s[i + 1] === ">") {
+      i += 2;
+      yield { text: ">>", start, end: i, op: false };
+      continue;
+    }
+    if (c === 60) {
+      while (i < n && s[i] !== ">")
+        i++;
+      i++;
+      yield { text: s.slice(start, i), start, end: i, op: false };
+      continue;
+    }
+    if (c === 91 || c === 93 || c === 62 || c === 123 || c === 125 || c === 41) {
+      i++;
+      yield { text: s[start], start, end: i, op: false };
+      continue;
+    }
+    i++;
+    while (i < n && !WS.has(s.charCodeAt(i)) && !DELIM.has(s.charCodeAt(i)))
+      i++;
+    const text = s.slice(start, i);
+    const isOperand = c === 47 || /^[+-]?(\d+\.?\d*|\.\d+)$/.test(text);
+    yield { text, start, end: i, op: !isOperand };
+    if (text === "ID") {
+      const m = /\sEI(?=\s|$)/g;
+      m.lastIndex = i;
+      const hit = m.exec(s);
+      i = hit ? hit.index + hit[0].length : n;
+    }
+  }
+}
+var LARGE_TEXT_PT = 24;
+var SIZE_EPS = 0.05;
+var area = (m) => Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+
+class TextScale {
+  ctm;
+  font = 0;
+  tm = 1;
+  stack = [];
+  constructor(ctm) {
+    this.ctm = ctm;
+  }
+  get unit() {
+    return this.ctm;
+  }
+  get size() {
+    return this.font * this.tm * this.ctm;
+  }
+  op(op, nums) {
+    switch (op) {
+      case "q":
+        this.stack.push([this.ctm, this.font]);
+        return false;
+      case "Q": {
+        const p = this.stack.pop();
+        if (p)
+          [this.ctm, this.font] = p;
+        return true;
+      }
+      case "cm":
+        if (nums.length === 6)
+          this.ctm *= area(nums);
+        return true;
+      case "BT":
+        this.tm = 1;
+        return true;
+      case "Tm":
+        if (nums.length === 6)
+          this.tm = area(nums);
+        return true;
+      case "Tf":
+        this.font = Math.abs(nums[nums.length - 1] ?? 0) || 0;
+        return true;
+    }
+    return false;
+  }
+}
+function rewriteBlackText(src, ctx = {}) {
+  let fill = null;
+  let stroke = null;
+  const stack = [];
+  const scale = new TextScale(ctx.baseScale ?? 1);
+  let inText = false;
+  let fillDirty = false;
+  let strokeDirty = false;
+  const spans = [];
+  let lastOp = "";
+  let rect = null;
+  const edits = [];
+  let operands = [];
+  const rgbOf = () => {
+    if (operands.length !== 3)
+      return null;
+    const v = operands.map((t) => Number(t.text));
+    return v.some((x) => Number.isNaN(x)) ? null : { rgb: v, raw: operands.map((t) => t.text).join(" ") };
+  };
+  const isSmall = () => scale.size <= LARGE_TEXT_PT + SIZE_EPS;
+  let fillIns = null;
+  let strokeIns = null;
+  const syncOne = (colour, dirty, ins, at, gray, op) => {
+    if (!colour || !isNearBlack(colour.rgb))
+      return [dirty, ins];
+    const small = isSmall();
+    if (small && !dirty) {
+      const e = { start: at, end: at, text: ` ${gray}` };
+      edits.push(e);
+      return [true, e];
+    }
+    if (!small && dirty) {
+      if (ins)
+        ins.text = "";
+      else
+        edits.push({ start: at, end: at, text: ` ${colour.raw} ${op}` });
+      return [false, null];
+    }
+    return [dirty, ins];
+  };
+  const sync = (at) => {
+    [fillDirty, fillIns] = syncOne(fill, fillDirty, fillIns, at, "0 g", "rg");
+    [strokeDirty, strokeIns] = syncOne(stroke, strokeDirty, strokeIns, at, "0 G", "RG");
+  };
+  const flush = (s) => {
+    for (const r of s.rects) {
+      if (r.thickness > 0.2 * s.maxSmall)
+        continue;
+      edits.push({ start: r.start, end: r.start, text: "q 0 g " }, { start: r.end, end: r.end, text: " Q" });
+    }
+  };
+  for (const t of tokenize(src)) {
+    if (!t.op) {
+      operands.push(t);
+      continue;
+    }
+    const op = t.text;
+    const nums = operands.map((o) => Number(o.text));
+    const sizeMayHaveChanged = scale.op(op, nums);
+    switch (op) {
+      case "q":
+        stack.push([fill, stroke]);
+        break;
+      case "Q": {
+        const p = stack.pop();
+        if (p)
+          [fill, stroke] = p;
+        break;
+      }
+      case "BT":
+        inText = true;
+        fillDirty = strokeDirty = false;
+        fillIns = strokeIns = null;
+        sync(t.end);
+        break;
+      case "Tf":
+      case "Tm":
+        if (inText && sizeMayHaveChanged)
+          sync(t.end);
+        break;
+      case "ET":
+        if (inText) {
+          let ins = "";
+          if (fillDirty && fill)
+            ins += `${fill.raw} rg `;
+          if (strokeDirty && stroke)
+            ins += `${stroke.raw} RG `;
+          if (ins)
+            edits.push({ start: t.start, end: t.start, text: ins });
+        }
+        inText = false;
+        fillIns = strokeIns = null;
+        break;
+      case "rg":
+      case "RG": {
+        const c = rgbOf();
+        const isFill = op === "rg";
+        if (isFill)
+          fill = c;
+        else
+          stroke = c;
+        if (inText && c && isNearBlack(c.rgb) && isSmall()) {
+          edits.push({ start: operands[0].start, end: t.end, text: isFill ? "0 g" : "0 G" });
+          if (isFill)
+            fillDirty = true;
+          else
+            strokeDirty = true;
+        } else if (inText) {
+          if (isFill)
+            fillDirty = false;
+          else
+            strokeDirty = false;
+        }
+        break;
+      }
+      case "g":
+      case "k":
+      case "sc":
+      case "scn":
+      case "cs":
+        fill = null;
+        if (inText)
+          fillDirty = false;
+        break;
+      case "G":
+      case "K":
+      case "SC":
+      case "SCN":
+      case "CS":
+        stroke = null;
+        if (inText)
+          strokeDirty = false;
+        break;
+      case "Do": {
+        const name = operands[operands.length - 1]?.text;
+        if (name?.startsWith("/"))
+          ctx.onDo?.(name.slice(1), scale.unit);
+        break;
+      }
+      case "BDC":
+      case "BMC":
+        spans.push({ hasSmall: false, maxSmall: 0, rects: [] });
+        break;
+      case "EMC": {
+        const s = spans.pop();
+        if (!s)
+          break;
+        const parent = spans[spans.length - 1];
+        if (s.hasSmall)
+          flush(s);
+        else
+          parent?.rects.push(...s.rects);
+        if (parent && s.hasSmall) {
+          parent.hasSmall = true;
+          parent.maxSmall = Math.max(parent.maxSmall, s.maxSmall);
+        }
+        break;
+      }
+      case "Tj":
+      case "TJ":
+      case "'":
+      case '"': {
+        fillIns = strokeIns = null;
+        const span = spans[spans.length - 1];
+        if (span && inText && isSmall()) {
+          span.hasSmall = true;
+          span.maxSmall = Math.max(span.maxSmall, scale.size);
+        }
+        break;
+      }
+      case "re":
+        rect = !inText && fill && isNearBlack(fill.rgb) && operands.length === 4 && nums.every((x) => !Number.isNaN(x)) ? { start: operands[0].start, thickness: Math.min(Math.abs(nums[2]), Math.abs(nums[3])) * scale.unit } : null;
+        break;
+      case "f":
+      case "F":
+      case "f*":
+        if (rect && lastOp === "re")
+          spans[spans.length - 1]?.rects.push({ ...rect, end: t.end });
+        break;
+    }
+    lastOp = op;
+    operands = [];
+  }
+  return applyEdits(src, edits);
+}
+function applyEdits(s, edits) {
+  if (!edits.length)
+    return s;
+  edits.sort((a, b) => a.start - b.start);
+  let out = "";
+  let pos = 0;
+  for (const e of edits) {
+    out += s.slice(pos, e.start) + e.text;
+    pos = e.end;
+  }
+  return out + s.slice(pos);
+}
+function isRichBlack(c) {
+  const [cy, m, y, k] = c;
+  const lo = Math.min(cy, m, y);
+  return k >= 0.7 && lo >= 0.3 && Math.max(cy, m, y) - lo <= 0.25;
+}
+function countRichBlackText(src, ctx = {}) {
+  const scale = new TextScale(ctx.baseScale ?? 1);
+  let fill = null;
+  const stack = [];
+  let count = 0;
+  let operands = [];
+  for (const t of tokenize(src)) {
+    if (!t.op) {
+      operands.push(t);
+      continue;
+    }
+    const op = t.text;
+    const nums = operands.map((o) => Number(o.text));
+    scale.op(op, nums);
+    switch (op) {
+      case "q":
+        stack.push(fill);
+        break;
+      case "Q":
+        if (stack.length)
+          fill = stack.pop() ?? null;
+        break;
+      case "k":
+        fill = nums.length === 4 && !nums.some(Number.isNaN) ? nums : null;
+        break;
+      case "sc":
+      case "scn":
+        fill = nums.length === 4 && !nums.some(Number.isNaN) ? nums : null;
+        break;
+      case "g":
+      case "rg":
+      case "cs":
+        fill = null;
+        break;
+      case "Do": {
+        const name = operands[operands.length - 1]?.text;
+        if (name?.startsWith("/"))
+          ctx.onDo?.(name.slice(1), scale.unit);
+        break;
+      }
+      case "Tj":
+      case "TJ":
+      case "'":
+      case '"':
+        if (fill && isRichBlack(fill) && scale.size <= LARGE_TEXT_PT + SIZE_EPS)
+          count++;
+        break;
+    }
+    operands = [];
+  }
+  return count;
+}
+async function visitContent(doc, visit) {
+  const { PDFName, PDFRawStream, PDFArray, PDFRef, PDFDict, decodePDFRawStream } = await import("pdf-lib");
+  const ctx = doc.context;
+  const SKIP = ["Filter", "DecodeParms", "Length"].map((k) => PDFName.of(k));
+  let changed = false;
+  const decode = (s) => {
+    try {
+      return Buffer.from(decodePDFRawStream(s).decode()).toString("latin1");
+    } catch {
+      return null;
+    }
+  };
+  const replace = (ref, old, text) => {
+    const entries = {};
+    for (const [k, v] of old.dict.entries())
+      if (!SKIP.includes(k))
+        entries[k.decodeText()] = v;
+    ctx.assign(ref, ctx.flateStream(Buffer.from(text, "latin1"), entries));
+    changed = true;
+  };
+  const formScale = new Map;
+  const formPages = new Map;
+  const formMatrixScale = (form) => {
+    const m = form.dict.lookupMaybe(PDFName.of("Matrix"), PDFArray);
+    const nums = m?.asArray().map((n) => Number(n.toString()));
+    return nums?.length === 6 && !nums.some(Number.isNaN) ? area(nums) : 1;
+  };
+  const pages = doc.getPages();
+  for (let p = 0;p < pages.length; p++) {
+    const page = pages[p];
+    const contents = page.node.Contents();
+    const refs = [];
+    if (contents instanceof PDFArray) {
+      for (let i = 0;i < contents.size(); i++) {
+        const r = contents.get(i);
+        if (r instanceof PDFRef)
+          refs.push(r);
+      }
+    } else if (contents instanceof PDFRawStream) {
+      const r = page.node.get(PDFName.of("Contents"));
+      if (r instanceof PDFRef)
+        refs.push(r);
+    }
+    const streams = refs.map((r) => ctx.lookup(r));
+    if (!refs.length || !streams.every((s) => s instanceof PDFRawStream))
+      continue;
+    const parts = streams.map((s) => decode(s));
+    if (parts.some((q) => q === null))
+      continue;
+    const joined = parts.join(`
+`);
+    const xobjects = page.node.Resources()?.lookupMaybe(PDFName.of("XObject"), PDFDict);
+    const next = visit(joined, {
+      baseScale: 1,
+      pages: [p + 1],
+      onDo: (name, scale) => {
+        const ref = xobjects?.get(PDFName.of(name));
+        const form = ref instanceof PDFRef ? ctx.lookup(ref) : undefined;
+        if (!(ref instanceof PDFRef) || !(form instanceof PDFRawStream))
+          return;
+        if (form.dict.get(PDFName.of("Subtype")) !== PDFName.of("Form"))
+          return;
+        const at = scale * formMatrixScale(form);
+        formScale.set(ref.tag, Math.min(formScale.get(ref.tag) ?? Infinity, at));
+        (formPages.get(ref.tag) ?? formPages.set(ref.tag, new Set).get(ref.tag)).add(p + 1);
+      }
+    });
+    if (next === joined)
+      continue;
+    replace(refs[0], streams[0], next);
+    page.node.set(PDFName.of("Contents"), refs[0]);
+  }
+  for (const [ref, obj] of ctx.enumerateIndirectObjects()) {
+    if (!(obj instanceof PDFRawStream))
+      continue;
+    if (obj.dict.get(PDFName.of("Subtype")) !== PDFName.of("Form"))
+      continue;
+    const text = decode(obj);
+    if (text === null)
+      continue;
+    const next = visit(text, {
+      baseScale: formScale.get(ref.tag) ?? 0,
+      pages: [...formPages.get(ref.tag) ?? []]
+    });
+    if (next !== text)
+      replace(ref, obj, next);
+  }
+  return changed;
+}
+async function blackTextToGray(pdf) {
+  const { PDFDocument } = await import("pdf-lib");
+  const doc = await PDFDocument.load(pdf, { updateMetadata: false });
+  const changed = await visitContent(doc, (src, info) => rewriteBlackText(src, info));
+  return changed ? doc.save({ updateFieldAppearances: false }) : pdf;
+}
+async function findRichBlackText(pdf) {
+  const { PDFDocument } = await import("pdf-lib");
+  const doc = await PDFDocument.load(pdf, { updateMetadata: false });
+  let runs = 0;
+  const pages = new Set;
+  await visitContent(doc, (src, info) => {
+    const n = countRichBlackText(src, info);
+    if (n) {
+      runs += n;
+      for (const p of info.pages)
+        pages.add(p);
+    }
+    return src;
+  });
+  return { runs, pages: [...pages].sort((a, b) => a - b) };
+}
+
+export { LARGE_TEXT_PT, rewriteBlackText, countRichBlackText, blackTextToGray, findRichBlackText };

package/dist/{cli-gymfg04q.js → cli-jyy9pqf3.js}

@@ -681,10 +681,15 @@ function planRectoBlanks(sites) {
     return wrong;
   });
 }
-function signaturePadding(pageCount, signature = 1, reserveLastPage = false) {
+function lastPageMode(print) {
+  return print.lastPage ?? (print.reserveLastPage ? "blank" : undefined);
+}
+function signaturePadding(pageCount, signature = 1, lastPage) {
   const size = signature > 1 ? signature : 1;
+  if (lastPage === "short-by-one")
+    return (size - (pageCount + 1) % size) % size;
   const padded = (size - pageCount % size) % size;
-  return padded === 0 && reserveLastPage ? size : padded;
+  return padded === 0 && lastPage === "blank" ? size : padded;
 }
 var WHICH_VALUES = new Set(["first", "start", "last", "first-except"]);
 function parseWhich(raw) {
@@ -1111,7 +1116,7 @@ import { fileURLToPath } from "node:url";
 var favicon_default = "./favicon-wkbm9cjn.ico";
 
 // src/assets/manifest.schema.json
-var manifest_schema_default = "./manifest.schema-40sfq49z.json";
+var manifest_schema_default = "./manifest.schema-gh0jjve9.json";
 
 // src/assets/preview/scripts/preview-interface.js
 var preview_interface_default = "./preview-interface-c44qk17f.js";
@@ -1126,7 +1131,7 @@ var preview_shell_default = "./preview-shell-xwn84kqr.js";
 var CGATS21_CRPC1_default = "./CGATS21_CRPC1-g0e3k7kr.icc";
 
 // src/assets/engine/gutterpress-viewer.js
-var gutterpress_viewer_default = "./gutterpress-viewer-zkv2stfy.js";
+var gutterpress_viewer_default = "./gutterpress-viewer-1n793gwd.js";
 
 // src/assets/engine/gutterpress-agent.js
 var gutterpress_agent_default = "./gutterpress-agent-cazqstr1.js";
@@ -1156,7 +1161,7 @@ var package_default = "./package-9rv69pxm.json";
 var README_default = "./README-vsnsc1b3.md";
 
 // src/assets/extension-templates/plugin/plugin.js.tpl
-var plugin_js_default = "./plugin.js-m4a7m3t4.tpl";
+var plugin_js_default = "./plugin.js-cswq7wvd.tpl";
 
 // src/assets/extension-templates/plugin/styles/plugin.css
 var plugin_default = "./plugin-spbcem4j.css";
@@ -1171,7 +1176,7 @@ var fixture_default = "./fixture-2qnyqgb5.md";
 var expected_default = "./expected-ycmacem8.html";
 
 // src/assets/extension-templates/plugin/test/plugin.test.js.tpl
-var plugin_test_js_default = "./plugin.test.js-6n8ct5e3.tpl";
+var plugin_test_js_default = "./plugin.test.js-xgxrd8hf.tpl";
 
 // src/assets/extension-templates/theme/package.json
 var package_default2 = "./package-aenwjew3.json";
@@ -1455,7 +1460,7 @@ async function postprocess(input, opts) {
     g.media.width - inset,
     g.media.height - inset
   ];
-  const padded = signaturePadding(doc.getPageCount(), opts.signature, opts.reserveLastPage);
+  const padded = signaturePadding(doc.getPageCount(), opts.signature, opts.lastPage);
   for (let i = 0;i < padded; i++)
     doc.addPage([g.media.width, g.media.height]);
   const wantMarks = opts.marks || g.marks.includes("crop") || g.marks.includes("cross");
@@ -2232,12 +2237,12 @@ ${mapCss}`;
     const post = await postprocess(bytes, {
       geometry: tier2.geometry,
       signature: opts.signature,
-      reserveLastPage: opts.reserveLastPage,
+      lastPage: opts.lastPage,
       marks: opts.marks,
       title: opts.title,
       author: opts.author
     });
-    log(`postprocess: ${post.pageCount} pages` + (post.padded ? ` (+${post.padded} blank${opts.reserveLastPage ? "; last page reserved blank" : ""})` : ""));
+    log(`postprocess: ${post.pageCount} pages` + (post.padded ? ` (+${post.padded} blank${opts.lastPage ? `; last page: ${opts.lastPage}` : ""})` : ""));
     return {
       bytes: post.bytes,
       tier,
@@ -2597,4 +2602,4 @@ ${lines.length ? lines.join(`
 `);
 }
 
-export { getAssetsDir, getAssetPath, MARGIN_BOX_IGNORED_PROPERTIES, build };
+export { lastPageMode, getAssetsDir, getAssetPath, MARGIN_BOX_IGNORED_PROPERTIES, build };

package/dist/{cli-ppc0vz4b.js → cli-pqcb2nnb.js}

@@ -4,7 +4,7 @@ import {
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.11.17-alpha.2",
+  version: "0.11.17-alpha.4",
   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-ppc0vz4b.js";
+} from "./cli-pqcb2nnb.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";
@@ -18,14 +18,14 @@ import {
 import { defineCommand, parseArgs, runMain } from "citty";
 import { statSync } from "node:fs";
 var SUBCOMMANDS = {
-  new: () => import("./new-m5y2wepr.js").then((m) => m.default),
-  preview: () => import("./preview-62y7qhkp.js").then((m) => m.default),
-  build: () => import("./build-1p999cmg.js").then((m) => m.default),
-  publish: () => import("./publish-k2zyt3x6.js").then((m) => m.default),
-  validate: () => import("./validate-fgwwxtbn.js").then((m) => m.default),
-  preflight: () => import("./preflight-bwpqwwny.js").then((m) => m.default),
-  doctor: () => import("./doctor-reqpnn3h.js").then((m) => m.default),
-  ext: () => import("./ext-dsbfejt3.js").then((m) => m.default)
+  new: () => import("./new-bjdf7bhg.js").then((m) => m.default),
+  preview: () => import("./preview-1cschq8s.js").then((m) => m.default),
+  build: () => import("./build-fam0tqg6.js").then((m) => m.default),
+  publish: () => import("./publish-ddqrb8s9.js").then((m) => m.default),
+  validate: () => import("./validate-3hjkgxrz.js").then((m) => m.default),
+  preflight: () => import("./preflight-gvw01661.js").then((m) => m.default),
+  doctor: () => import("./doctor-zre5k5fg.js").then((m) => m.default),
+  ext: () => import("./ext-hfqcg6ax.js").then((m) => m.default)
 };
 var VERSION = package_default.version;
 var main = defineCommand({
@@ -50,7 +50,7 @@ async function preflightRequiredInvocations(rawArgs) {
   const [command, ...commandArgs] = rawArgs;
   try {
     if (command === "new") {
-      const { newArgs } = await import("./new-m5y2wepr.js");
+      const { newArgs } = await import("./new-bjdf7bhg.js");
       rejectUnknownFlags(commandArgs, newArgs, "new");
       const parsed = parseArgs(commandArgs, {
         ...newArgs,
@@ -62,7 +62,7 @@ async function preflightRequiredInvocations(rawArgs) {
       return;
     }
     if (command === "preflight") {
-      const { preflightArgs } = await import("./preflight-bwpqwwny.js");
+      const { preflightArgs } = await import("./preflight-gvw01661.js");
       rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
       const parsed = parseArgs(commandArgs, {
         ...preflightArgs,
@@ -82,7 +82,7 @@ async function preflightRequiredInvocations(rawArgs) {
       }
       if (subcommand.startsWith("-"))
         return;
-      const { EXT_SUBCOMMANDS, extAddArgs, extRemoveArgs, extEnableArgs, extDisableArgs } = await import("./ext-dsbfejt3.js");
+      const { EXT_SUBCOMMANDS, extAddArgs, extRemoveArgs, extEnableArgs, extDisableArgs } = await import("./ext-hfqcg6ax.js");
       if (!EXT_SUBCOMMANDS.includes(subcommand)) {
         throw new UsageError(`gutterpress ext: unknown command "${subcommand}"`);
       }

package/dist/{doctor-reqpnn3h.js → doctor-zre5k5fg.js}

@@ -1,12 +1,12 @@
 import {
   getSystemDiagnostics,
   log
-} from "./cli-70xgehq2.js";
+} from "./cli-8apk8571.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-ppc0vz4b.js";
+} from "./cli-pqcb2nnb.js";
 import"./cli-46ycxe6r.js";
 import"./cli-7fkhgtfn.js";
 import"./cli-37x76zdn.js";

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

@@ -1,5 +1,6 @@
 import { type Browser } from "../shared/cdp.ts";
 import { type GcpmModel } from "../shared/gcpm-extract.ts";
+import { type LastPageMode } from "../shared/synthesis.ts";
 import { type Tier2Output } from "./tier2.ts";
 import { type PostprocessResult } from "./postprocess.ts";
 /**
@@ -19,8 +20,8 @@ export interface BuildOptions {
     input: string;
     output?: string;
     signature?: number;
-    /** guarantee the final page is a blank page added by postprocess */
-    reserveLastPage?: boolean;
+    /** the printer-reserved last page: see `LastPageMode` in shared/synthesis.ts */
+    lastPage?: LastPageMode;
     marks?: boolean;
     slugPt?: number;
     bleedPt?: number;