gutterpress 0.9.0-alpha.2 → 0.10.0-alpha.4

package/dist/cli-hp9r2pzt.js

@@ -0,0 +1,2343 @@
+import {
+  requireChromiumExecutable
+} from "./cli-c41yr7he.js";
+import {
+  __require
+} from "./cli-37x76zdn.js";
+
+// src/lib/browser-pool.ts
+var RENDER_TIMEOUT_MS = 60 * 60 * 1000;
+var browserPromise = null;
+async function launchBrowser(timeoutMs) {
+  const executablePath = await requireChromiumExecutable();
+  const puppeteer = (await import("puppeteer-core")).default;
+  const extraChromiumArgs = (process.env.GUTTERPRESS_CHROMIUM_ARGS ?? "").split(/\s+/).filter(Boolean);
+  return puppeteer.launch({
+    headless: true,
+    executablePath,
+    args: extraChromiumArgs,
+    protocolTimeout: timeoutMs
+  });
+}
+function prewarmBrowser(timeoutMs) {
+  if (browserPromise)
+    return;
+  const p = launchBrowser(timeoutMs);
+  browserPromise = p;
+  p.then((browser) => {
+    browser.on("disconnected", () => {
+      if (browserPromise === p)
+        browserPromise = null;
+    });
+  }).catch(() => {
+    if (browserPromise === p)
+      browserPromise = null;
+  });
+}
+async function getBrowser(timeoutMs) {
+  if (!browserPromise)
+    prewarmBrowser(timeoutMs);
+  return browserPromise;
+}
+async function closeBrowser() {
+  const p = browserPromise;
+  browserPromise = null;
+  if (!p)
+    return;
+  try {
+    const b = await p;
+    await b.close();
+  } catch {}
+}
+
+// src/engine/shared/cdp.ts
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import WebSocket from "ws";
+var CANDIDATES = [
+  process.env.GUTTERPRESS_CHROMIUM,
+  process.env.PUPPETEER_EXECUTABLE_PATH,
+  "/opt/pw-browsers/chromium",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser",
+  "/usr/bin/google-chrome",
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+].filter(Boolean);
+function findChromium() {
+  for (const c of CANDIDATES)
+    if (existsSync(c))
+      return c;
+  throw new Error(`No Chromium found. Set GUTTERPRESS_CHROMIUM. Looked in:
+  ${CANDIDATES.join(`
+  `)}`);
+}
+var REQUIRED_MILESTONE = 148;
+function assertMilestone(product, origin, hint = "") {
+  const milestone = Number(/Chrome\/(\d+)/.exec(product)?.[1] ?? 0);
+  if (milestone < REQUIRED_MILESTONE) {
+    throw new Error(`The Gutterpress engine requires Chromium ${REQUIRED_MILESTONE}+; found ${product} ${origin}.` + (hint ? `
+${hint}` : ""));
+  }
+}
+function readyProbeExpr(timeoutMs) {
+  return `(async () => {
+      await document.fonts.ready;
+      if (window.__gpReadyPending) {
+        await new Promise((res) => {
+          const t = setTimeout(res, ${timeoutMs});
+          document.addEventListener('gp:ready', () => { clearTimeout(t); res(); }, { once: true });
+        });
+      }
+      // two rAFs: let layout settle after fonts swap
+      await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+      return true;
+    })()`;
+}
+var DEFAULT_PRINT_OPTS = {
+  printBackground: true,
+  preferCSSPageSize: true,
+  generateTaggedPDF: true,
+  generateDocumentOutline: true
+};
+async function launchChromium(opts = {}) {
+  const bin = findChromium();
+  const userDataDir = mkdtempSync(join(tmpdir(), "gp-cdp-"));
+  const args = [
+    "--remote-debugging-port=0",
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-gpu",
+    "--no-sandbox",
+    "--hide-scrollbars",
+    "--allow-file-access-from-files",
+    "--font-render-hinting=none",
+    ...opts.headless === false ? [] : ["--headless=new"],
+    ...opts.args ?? [],
+    "about:blank"
+  ];
+  const proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const wsUrl = await readDevToolsUrl(proc);
+  const conn = await Connection.open(wsUrl);
+  const teardown = async () => {
+    const exited = new Promise((r) => proc.once("exit", () => r()));
+    try {
+      await Promise.race([
+        conn.send("Browser.close").then(() => exited),
+        new Promise((_, rej) => setTimeout(() => rej(new Error("Browser.close timed out")), 5000))
+      ]);
+    } catch {
+      proc.kill("SIGKILL");
+      await exited;
+    }
+    conn.close();
+    rmSync(userDataDir, { recursive: true, force: true });
+  };
+  return checkMilestoneAndWrap(conn, wsUrl, `at ${bin}`, teardown);
+}
+async function connectChromium(wsUrl) {
+  const conn = await Connection.open(wsUrl);
+  return checkMilestoneAndWrap(conn, wsUrl, "via connected browser", async () => {
+    conn.close();
+  }, `Set CHROMIUM_PATH (or PUPPETEER_EXECUTABLE_PATH) to a ${REQUIRED_MILESTONE}+ binary.`);
+}
+async function checkMilestoneAndWrap(conn, wsUrl, origin, teardown, overrideHint = `Set GUTTERPRESS_CHROMIUM to a ${REQUIRED_MILESTONE}+ binary.`) {
+  const version = await conn.send("Browser.getVersion", {});
+  try {
+    assertMilestone(version.product, origin, overrideHint);
+  } catch (e) {
+    await teardown();
+    throw e;
+  }
+  const milestone = Number(/Chrome\/(\d+)/.exec(version.product)?.[1] ?? 0);
+  return {
+    wsUrl,
+    version: version.product,
+    milestone,
+    async newPage() {
+      const { targetId } = await conn.send("Target.createTarget", { url: "about:blank" });
+      const { sessionId } = await conn.send("Target.attachToTarget", { targetId, flatten: true });
+      const s = new SessionImpl(conn, sessionId, targetId);
+      await s.send("Page.enable");
+      await s.send("Runtime.enable");
+      return s;
+    },
+    close: teardown
+  };
+}
+function readDevToolsUrl(proc) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    const timer = setTimeout(() => reject(new Error(`Chromium did not report a DevTools URL:
+${buf}`)), 20000);
+    proc.stderr.on("data", (d) => {
+      buf += String(d);
+      const m = /ws:\/\/[^\s]+/.exec(buf);
+      if (m) {
+        clearTimeout(timer);
+        resolve(m[0]);
+      }
+    });
+    proc.once("exit", (code) => {
+      clearTimeout(timer);
+      reject(new Error(`Chromium exited (${code}) before listening:
+${buf}`));
+    });
+  });
+}
+
+class Connection {
+  ws;
+  id = 0;
+  pending = new Map;
+  listeners = new Map;
+  constructor(ws) {
+    this.ws = ws;
+    ws.on("message", (raw) => this.dispatch(JSON.parse(String(raw))));
+  }
+  static async open(url) {
+    const ws = new WebSocket(url, { maxPayload: 512 * 1024 * 1024 });
+    await new Promise((res, rej) => {
+      ws.once("open", () => res());
+      ws.once("error", rej);
+    });
+    return new Connection(ws);
+  }
+  dispatch(msg) {
+    if (msg.id !== undefined) {
+      const p = this.pending.get(msg.id);
+      if (!p)
+        return;
+      this.pending.delete(msg.id);
+      if (msg.error)
+        p.reject(new Error(`${msg.error.message} (${msg.error.code})`));
+      else
+        p.resolve(msg.result);
+      return;
+    }
+    const key = msg.sessionId ? `${msg.sessionId}:${msg.method}` : msg.method;
+    for (const fn of this.listeners.get(key) ?? [])
+      fn(msg.params);
+    for (const fn of this.listeners.get(msg.method) ?? [])
+      fn(msg.params);
+  }
+  send(method, params = {}, sessionId) {
+    const id = ++this.id;
+    const payload = { id, method, params };
+    if (sessionId)
+      payload.sessionId = sessionId;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  on(key, fn) {
+    let set = this.listeners.get(key);
+    if (!set)
+      this.listeners.set(key, set = new Set);
+    set.add(fn);
+    return () => set.delete(fn);
+  }
+  close() {
+    this.ws.close();
+  }
+}
+
+class SessionImpl {
+  conn;
+  sessionId;
+  targetId;
+  constructor(conn, sessionId, targetId) {
+    this.conn = conn;
+    this.sessionId = sessionId;
+    this.targetId = targetId;
+  }
+  send(method, params = {}) {
+    return this.conn.send(method, params, this.sessionId);
+  }
+  on(event, fn) {
+    return this.conn.on(`${this.sessionId}:${event}`, fn);
+  }
+  async evaluate(expression) {
+    const res = await this.send("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (res.exceptionDetails) {
+      const e = res.exceptionDetails;
+      throw new Error(`evaluate failed: ${e.exception?.description ?? e.text}`);
+    }
+    return res.result.value;
+  }
+  async waitForLoad(fn) {
+    const done = new Promise((resolve) => {
+      const off = this.on("Page.loadEventFired", () => {
+        off();
+        resolve();
+      });
+    });
+    await fn();
+    await done;
+  }
+  async setContent(html, baseUrl = "http://gutterpress.spike/") {
+    await this.waitForLoad(async () => {
+      const { frameTree } = await this.send("Page.getFrameTree");
+      await this.send("Page.setDocumentContent", {
+        frameId: frameTree.frame.id,
+        html
+      });
+    });
+  }
+  async navigate(url) {
+    await this.waitForLoad(async () => {
+      await this.send("Page.navigate", { url });
+    });
+  }
+  async waitForReady(timeoutMs = 15000) {
+    await this.evaluate(readyProbeExpr(timeoutMs));
+  }
+  async printToPDF(opts = {}) {
+    const res = await this.send("Page.printToPDF", {
+      ...DEFAULT_PRINT_OPTS,
+      transferMode: "ReturnAsStream",
+      ...opts
+    });
+    if (!res.stream)
+      return Uint8Array.from(Buffer.from(res.data, "base64"));
+    const chunks = [];
+    try {
+      for (;; ) {
+        const c = await this.send("IO.read", { handle: res.stream, size: 8 * 1024 * 1024 });
+        if (c.data)
+          chunks.push(Buffer.from(c.data, c.base64Encoded ? "base64" : "binary"));
+        if (c.eof)
+          break;
+      }
+    } finally {
+      await this.send("IO.close", { handle: res.stream }).catch(() => {});
+    }
+    return new Uint8Array(Buffer.concat(chunks));
+  }
+  async close() {
+    await this.conn.send("Target.closeTarget", { targetId: this.targetId });
+  }
+}
+
+// src/engine/compiler/build.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/engine/shared/gcpm-extract.ts
+var NESTED_AT_RULES = /^@(media|supports|layer|scope|container|document)\b/i;
+function scanRules(css) {
+  const out = [];
+  let i = 0;
+  let start = 0;
+  let depth = 0;
+  let bodyStart = -1;
+  while (i < css.length) {
+    const c = css[i];
+    if (c === "/" && css[i + 1] === "*") {
+      const end = css.indexOf("*/", i + 2);
+      i = end === -1 ? css.length : end + 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i = skipString(css, i);
+      continue;
+    }
+    if (c === "{") {
+      if (depth === 0)
+        bodyStart = i;
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === "}") {
+      depth--;
+      if (depth === 0) {
+        out.push({
+          prelude: stripComments(css.slice(start, bodyStart)).trim(),
+          body: css.slice(bodyStart + 1, i)
+        });
+        start = i + 1;
+      }
+      i++;
+      continue;
+    }
+    if (c === ";" && depth === 0) {
+      const stmt = stripComments(css.slice(start, i)).trim();
+      if (stmt)
+        out.push({ statement: stmt });
+      start = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+function stripComments(s) {
+  let out = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "/" && s[i + 1] === "*") {
+      const end = s.indexOf("*/", i + 2);
+      i = end === -1 ? s.length : end + 2;
+      continue;
+    }
+    if (s[i] === '"' || s[i] === "'") {
+      const end = skipString(s, i);
+      out += s.slice(i, end);
+      i = end;
+      continue;
+    }
+    out += s[i++];
+  }
+  return out;
+}
+function skipString(css, i) {
+  const quote = css[i];
+  i++;
+  while (i < css.length) {
+    if (css[i] === "\\")
+      i += 2;
+    else if (css[i] === quote)
+      return i + 1;
+    else
+      i++;
+  }
+  return i;
+}
+function parseDeclarations(body) {
+  const decls = {};
+  let i = 0;
+  let start = 0;
+  let depth = 0;
+  const push = (chunk) => {
+    const s = stripComments(chunk).trim();
+    if (!s)
+      return;
+    const colon = indexOfTopLevel(s, ":");
+    if (colon <= 0)
+      return;
+    const rawProp = s.slice(0, colon).trim();
+    const prop = rawProp.startsWith("--") ? rawProp : rawProp.toLowerCase();
+    const value = s.slice(colon + 1).trim().replace(/\s*!important$/i, "");
+    if (prop)
+      decls[prop] = value;
+  };
+  while (i < body.length) {
+    const c = body[i];
+    if (c === "/" && body[i + 1] === "*") {
+      const end = body.indexOf("*/", i + 2);
+      i = end === -1 ? body.length : end + 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i = skipString(body, i);
+      continue;
+    }
+    if (c === "(" || c === "{" || c === "[")
+      depth++;
+    else if (c === ")" || c === "}" || c === "]")
+      depth--;
+    else if (c === ";" && depth === 0) {
+      push(body.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  push(body.slice(start));
+  return decls;
+}
+function indexOfTopLevel(s, ch) {
+  let depth = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i = skipString(s, i) - 1;
+      continue;
+    }
+    if (c === "(")
+      depth++;
+    else if (c === ")")
+      depth--;
+    else if (c === ch && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function extract(css) {
+  const model = {
+    pageRules: [],
+    stringSets: [],
+    pageAssignments: [],
+    breaks: [],
+    xrefs: [],
+    counterResets: [],
+    pageNames: [],
+    warnings: []
+  };
+  walk(css, model);
+  resolveGeometryVars(model, collectRootCustomProperties(css));
+  const names = new Set;
+  for (const r of model.pageRules)
+    if (r.name)
+      names.add(r.name);
+  for (const a of model.pageAssignments)
+    names.add(a.page);
+  model.pageNames = [...names];
+  return model;
+}
+var GEOMETRY_PROPS = [
+  "size",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "bleed",
+  "marks"
+];
+function collectRootCustomProperties(css) {
+  const props = new Map;
+  const walkForRoot = (body) => {
+    for (const rule of scanRules(body)) {
+      if ("statement" in rule)
+        continue;
+      const { prelude, body: ruleBody } = rule;
+      if (NESTED_AT_RULES.test(prelude)) {
+        walkForRoot(ruleBody);
+        continue;
+      }
+      if (!prelude.startsWith("@")) {
+        const selectors = splitTopLevel(prelude, ",");
+        if (selectors.some((s) => s.trim() === ":root")) {
+          const decls = parseDeclarations(ruleBody);
+          for (const [k, v] of Object.entries(decls)) {
+            if (k.startsWith("--"))
+              props.set(k, v);
+          }
+        }
+      }
+    }
+  };
+  walkForRoot(css);
+  return props;
+}
+function matchParen(s, open) {
+  let depth = 0;
+  let i = open;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i = skipString(s, i);
+      continue;
+    }
+    if (c === "(")
+      depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function resolveVarsInValue(value, customProps, stack = new Set) {
+  let out = "";
+  let i = 0;
+  while (i < value.length) {
+    const isVarStart = /^var\(/i.test(value.slice(i, i + 4)) && (i === 0 || !/[\w-]/.test(value[i - 1]));
+    if (!isVarStart) {
+      out += value[i];
+      i++;
+      continue;
+    }
+    const open = i + 3;
+    const close = matchParen(value, open);
+    if (close === -1) {
+      out += value.slice(i);
+      break;
+    }
+    const inner = value.slice(open + 1, close);
+    const commaIdx = indexOfTopLevel(inner, ",");
+    const name = (commaIdx === -1 ? inner : inner.slice(0, commaIdx)).trim();
+    const fallback = commaIdx === -1 ? undefined : inner.slice(commaIdx + 1).trim();
+    if (!/^--[\w-]+$/.test(name)) {
+      return { text: out, unresolved: `var(${inner}) is not a valid custom property reference` };
+    }
+    if (stack.has(name)) {
+      return { text: out, unresolved: `var(${name}) is circular` };
+    }
+    const rootValue = customProps.get(name);
+    if (rootValue !== undefined) {
+      const nested = resolveVarsInValue(rootValue, customProps, new Set(stack).add(name));
+      if (nested.unresolved)
+        return { text: out, unresolved: nested.unresolved };
+      out += nested.text;
+    } else if (fallback !== undefined) {
+      if (/\bvar\(/i.test(fallback)) {
+        return {
+          text: out,
+          unresolved: `var(${name}, ${fallback}) — a fallback containing another var() is not resolved`
+        };
+      }
+      out += fallback;
+    } else {
+      return {
+        text: out,
+        unresolved: `${name} is not defined at :root and var() has no fallback`
+      };
+    }
+    i = close + 1;
+  }
+  return { text: out };
+}
+function resolveGeometryVars(model, customProps) {
+  for (const rule of model.pageRules) {
+    for (const prop of GEOMETRY_PROPS) {
+      const value = rule.decls[prop];
+      if (!value || !/\bvar\(/i.test(value))
+        continue;
+      const { text, unresolved } = resolveVarsInValue(value, customProps);
+      if (unresolved) {
+        throw new Error(`${rule.raw} { ${prop}: ${value} } — cannot resolve ${unresolved}. ` + `Define the custom property at :root, add a literal var(--x, fallback) fallback, or use a literal value.`);
+      }
+      const unparsable = unparsableGeometry(prop, text);
+      if (unparsable) {
+        throw new Error(`${rule.raw} { ${prop}: ${value} } — resolves to \`${text.trim()}\`, ${unparsable}. ` + `Use a value this engine can read (a length like 0.75in/12pt/10mm, or a named page size for \`size\`).`);
+      }
+      rule.decls[prop] = text;
+    }
+  }
+}
+function unparsableGeometry(prop, text) {
+  const t = text.trim();
+  if (prop === "size") {
+    if (!t)
+      return "which is empty";
+    return parseSize(t) ? undefined : "which is not a page size";
+  }
+  if (prop === "margin" || prop.startsWith("margin-")) {
+    if (!t)
+      return "which is empty";
+    const parts = t.split(/\s+/);
+    if (prop !== "margin" && parts.length !== 1)
+      return "which is not a single length";
+    if (parts.length > 4)
+      return "which is not a valid margin";
+    const bad = parts.filter((p) => toPt(p) === undefined);
+    if (bad.length)
+      return `which this engine cannot read as a length (\`${bad[0]}\`)`;
+    return;
+  }
+  if (prop === "bleed") {
+    if (!t)
+      return "which is empty";
+    if (/^(auto|none)$/i.test(t))
+      return;
+    return toPt(t) === undefined ? "which this engine cannot read as a length" : undefined;
+  }
+  return;
+}
+function walk(css, model) {
+  for (const rule of scanRules(css)) {
+    if ("statement" in rule)
+      continue;
+    const { prelude, body } = rule;
+    if (NESTED_AT_RULES.test(prelude)) {
+      walk(body, model);
+      continue;
+    }
+    if (/^@page\b/i.test(prelude)) {
+      model.pageRules.push(parsePageRule(prelude, body));
+      continue;
+    }
+    if (prelude.startsWith("@"))
+      continue;
+    parseQualifiedRule(prelude, body, model);
+  }
+}
+function parsePageRule(prelude, body) {
+  const sel = prelude.replace(/^@page\s*/i, "").trim();
+  const nameMatch = /^([A-Za-z_][\w-]*)/.exec(sel);
+  const pseudos = [...sel.matchAll(/:([A-Za-z-]+)(\([^)]*\))?/g)].map((m) => m[1] + (m[2] ?? ""));
+  const rule = {
+    name: nameMatch?.[1],
+    pseudos,
+    decls: {},
+    marginBoxes: {},
+    raw: `@page ${sel}`.trim()
+  };
+  let rest = "";
+  let i = 0;
+  while (i < body.length) {
+    const at = findNextAtRule(body, i);
+    if (at === -1) {
+      rest += body.slice(i);
+      break;
+    }
+    rest += body.slice(i, at);
+    const open = body.indexOf("{", at);
+    if (open === -1) {
+      rest += body.slice(at);
+      break;
+    }
+    const name = body.slice(at + 1, open).trim().toLowerCase();
+    let depth = 1;
+    let j = open + 1;
+    while (j < body.length && depth > 0) {
+      const c = body[j];
+      if (c === "/" && body[j + 1] === "*") {
+        const end = body.indexOf("*/", j + 2);
+        j = end === -1 ? body.length : end + 2;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        j = skipString(body, j);
+        continue;
+      }
+      if (c === "{")
+        depth++;
+      else if (c === "}")
+        depth--;
+      j++;
+    }
+    rule.marginBoxes[`@${name}`] = parseDeclarations(body.slice(open + 1, j - 1));
+    i = j;
+  }
+  rule.decls = parseDeclarations(rest);
+  return rule;
+}
+function findNextAtRule(body, start) {
+  let i = start;
+  while (i < body.length) {
+    const c = body[i];
+    if (c === "/" && body[i + 1] === "*") {
+      const end = body.indexOf("*/", i + 2);
+      i = end === -1 ? body.length : end + 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i = skipString(body, i);
+      continue;
+    }
+    if (c === "@")
+      return i;
+    i++;
+  }
+  return -1;
+}
+function parseQualifiedRule(selector, body, model) {
+  const decls = parseDeclarations(body);
+  for (const [prop, value] of Object.entries(decls)) {
+    if (prop === "string-set") {
+      for (const entry of splitTopLevel(value, ",")) {
+        const m = /^\s*([A-Za-z_][\w-]*)\s+(.+)$/.exec(entry);
+        if (m && m[1] !== undefined && m[2] !== undefined)
+          model.stringSets.push({ selector, name: m[1], value: m[2].trim() });
+      }
+    } else if (prop === "page") {
+      if (value && value !== "auto")
+        model.pageAssignments.push({ selector, page: value.trim() });
+    } else if (prop === "break-before" || prop === "break-after" || prop === "break-inside") {
+      model.breaks.push({ selector, prop, value });
+    } else if (prop === "counter-reset") {
+      const m = /\bpage\s+(-?\d+)/.exec(value);
+      if (m)
+        model.counterResets.push({ selector, start: Number(m[1]) });
+    } else if (prop === "content") {
+      for (const fn of ["target-counter", "target-text", "leader", "string"]) {
+        if (new RegExp(`\\b${fn}\\s*\\(`).test(value)) {
+          model.xrefs.push({ selector, content: value, fn });
+        }
+      }
+    }
+  }
+}
+function splitTopLevel(s, sep) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i = skipString(s, i) - 1;
+      continue;
+    }
+    if (c === "(")
+      depth++;
+    else if (c === ")")
+      depth--;
+    else if (c === sep && depth === 0) {
+      out.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(s.slice(start));
+  return out.map((x) => x.trim()).filter(Boolean);
+}
+var UNITS_PER_PT = {
+  pt: 1,
+  px: 0.75,
+  in: 72,
+  pc: 12,
+  cm: 72 / 2.54,
+  mm: 72 / 25.4,
+  q: 72 / 101.6
+};
+function toPt(value) {
+  const m = /^(-?[\d.]+)([a-z%]*)$/i.exec(value.trim());
+  if (!m)
+    return;
+  const n = Number(m[1]);
+  const unit = (m[2] || "px").toLowerCase();
+  const factor = UNITS_PER_PT[unit];
+  return factor === undefined ? undefined : n * factor;
+}
+var PAGE_SIZES = {
+  a5: [419.53, 595.28],
+  a4: [595.28, 841.89],
+  a3: [841.89, 1190.55],
+  b5: [498.9, 708.66],
+  b4: [708.66, 1000.63],
+  "jis-b5": [515.91, 728.5],
+  "jis-b4": [728.5, 1031.81],
+  letter: [612, 792],
+  legal: [612, 1008],
+  ledger: [1224, 792]
+};
+function parseSize(value) {
+  const parts = value.trim().split(/\s+/);
+  let landscape = false;
+  const lens = [];
+  let named;
+  for (const p of parts) {
+    const key = p.toLowerCase();
+    if (key === "landscape")
+      landscape = true;
+    else if (key === "portrait")
+      continue;
+    else if (PAGE_SIZES[key])
+      named = PAGE_SIZES[key];
+    else {
+      const pt = toPt(p);
+      if (pt !== undefined)
+        lens.push(pt);
+    }
+  }
+  let w, h;
+  if (named)
+    [w, h] = named;
+  else if (lens.length === 1)
+    [w, h] = [lens[0], lens[0]];
+  else if (lens.length >= 2)
+    [w, h] = [lens[0], lens[1]];
+  else
+    return;
+  if (landscape && h > w)
+    [w, h] = [h, w];
+  return { width: w, height: h };
+}
+function parseMargin(value) {
+  const parts = value.trim().split(/\s+/).map((p) => toPt(p) ?? 0);
+  const a = parts[0] ?? 0;
+  const b = parts[1] ?? a;
+  const c = parts[2] ?? a;
+  const d = parts[3] ?? b;
+  return { top: a, right: b, bottom: c, left: d };
+}
+function resolvePage(model, ctx = {}) {
+  const wanted = new Set(ctx.pseudos ?? []);
+  const applicable = model.pageRules.filter((r) => r.name ? r.name === ctx.name : true).filter((r) => r.pseudos.every((p) => wanted.has(p))).sort((a, b) => specificity(a) - specificity(b));
+  const decls = {};
+  const marginBoxes = {};
+  const margin = { top: 72, right: 72, bottom: 72, left: 72 };
+  for (const rule of applicable) {
+    for (const [prop, value] of Object.entries(rule.decls)) {
+      if (prop === "margin")
+        Object.assign(margin, parseMargin(value));
+      else if (prop === "margin-top" || prop === "margin-right" || prop === "margin-bottom" || prop === "margin-left") {
+        const side = prop.slice(7);
+        margin[side] = toPt(value) ?? margin[side];
+      }
+    }
+    Object.assign(decls, rule.decls);
+    for (const [box, d] of Object.entries(rule.marginBoxes)) {
+      marginBoxes[box] = { ...marginBoxes[box] ?? {}, ...d };
+    }
+  }
+  const size = parseSize(decls.size ?? "letter") ?? { width: 612, height: 792 };
+  return {
+    decls,
+    marginBoxes,
+    geometry: {
+      width: size.width,
+      height: size.height,
+      margin,
+      bleed: decls.bleed ? toPt(decls.bleed) ?? 0 : 0,
+      marks: (decls.marks ?? "none").split(/\s+/).filter((m) => m && m !== "none")
+    }
+  };
+}
+function specificity(r) {
+  return (r.name ? 2 : 0) + r.pseudos.length;
+}
+
+// src/engine/shared/synthesis.ts
+var RECTO_VERSO_VALUES = /^(right|recto|left|verso)$/;
+function isRectoVersoBreak(decl) {
+  return decl.prop === "break-before" && RECTO_VERSO_VALUES.test(decl.value.trim());
+}
+function wantsRecto(value) {
+  return /^(right|recto)$/.test(value.trim());
+}
+function planRectoBlanks(sites) {
+  let shift = 0;
+  return sites.map((site) => {
+    if (site.page <= 0)
+      return false;
+    const effective = site.page + shift;
+    const onRecto = effective % 2 === 1;
+    const wrong = site.wantsRecto ? !onRecto : onRecto;
+    if (wrong)
+      shift++;
+    return wrong;
+  });
+}
+var WHICH_VALUES = new Set(["first", "start", "last", "first-except"]);
+function parseWhich(raw) {
+  const w = (raw ?? "").trim();
+  return WHICH_VALUES.has(w) ? w : "first";
+}
+function stringValueAt(entries, page, which = "first") {
+  let entry = "";
+  const onPage = [];
+  for (const e of entries) {
+    if (e.page < page)
+      entry = e.value;
+    else if (e.page === page)
+      onPage.push(e.value);
+    else
+      break;
+  }
+  switch (which) {
+    case "start":
+      return entry;
+    case "last":
+      return onPage.length ? onPage[onPage.length - 1] : entry;
+    case "first-except":
+      return onPage.length ? "" : entry;
+    case "first":
+      return onPage.length ? onPage[0] : entry;
+  }
+}
+function stringSymbols(entries, pageCount, which = "first") {
+  const symbols = [];
+  for (let p = 1;p <= pageCount; p++)
+    symbols.push(stringValueAt(entries, p, which));
+  return symbols;
+}
+function cssQuote(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function counterStyleName(name, which) {
+  return which === "first" ? `gp-${name}` : `gp-${name}--${which}`;
+}
+function pageCounterValues(resets, pageCount) {
+  const byPage = new Map;
+  for (const r of resets)
+    if (r.page >= 1)
+      byPage.set(r.page, r.start);
+  const values = [];
+  let value = 0;
+  for (let p = 1;p <= pageCount; p++) {
+    if (byPage.has(p))
+      value = byPage.get(p) - 1;
+    value++;
+    values.push(value);
+  }
+  return values;
+}
+function restartedPageValues(resetSites, pageMap, pageCount) {
+  const resets = resetSites.map((s) => ({ page: pageMap[s.id] ?? 0, start: s.start })).filter((r) => r.page > 0);
+  return resets.length ? pageCounterValues(resets, pageCount) : null;
+}
+function toFolioPage(physicalPage, pageValues) {
+  if (!pageValues)
+    return physicalPage;
+  return pageValues[physicalPage - 1] ?? physicalPage;
+}
+var LEADER_START = "";
+var LEADER_END = "";
+function leaderMarker(glue) {
+  return `${LEADER_START}${glue}${LEADER_END}`;
+}
+function generatedContentCss(selectors) {
+  const rules = new Set;
+  for (const raw of selectors) {
+    for (const one of raw.split(",")) {
+      const selector = one.trim();
+      if (!selector)
+        continue;
+      const m = /^(.*?)(::?)(after|before)\s*$/i.exec(selector);
+      if (!m)
+        continue;
+      const [, base, colons, pseudo] = m;
+      if (base === undefined || colons === undefined || pseudo === undefined)
+        continue;
+      const where = pseudo.toLowerCase();
+      rules.add(`${base.trim()}[data-gp-${where}]${colons}${where} { content: attr(data-gp-${where}); }`);
+    }
+  }
+  rules.add(`[data-gp-after]::after { content: attr(data-gp-after); }`);
+  rules.add(`[data-gp-before]::before { content: attr(data-gp-before); }`);
+  return [...rules].join(`
+`);
+}
+
+// src/engine/shared/content-value.ts
+var FUNC = /^([a-z-]+)\(/i;
+function parseContent(value) {
+  const parts = [];
+  let i = 0;
+  const s = value.trim();
+  while (i < s.length) {
+    const c = s[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = closeString(s, i);
+      parts.push({ type: "literal", value: unquote(s.slice(i, end)) });
+      i = end;
+      continue;
+    }
+    const rest = s.slice(i);
+    const fn = FUNC.exec(rest);
+    if (fn && fn[1] !== undefined) {
+      const open = i + fn[0].length - 1;
+      const close = matchParen2(s, open);
+      const args = splitTopLevel(s.slice(open + 1, close), ",");
+      parts.push(toPart(fn[1].toLowerCase(), args));
+      i = close + 1;
+      continue;
+    }
+    const word = /^[^\s"']+/.exec(rest)[0];
+    parts.push({ type: "keyword", value: word });
+    i += word.length;
+  }
+  return parts;
+}
+function toPart(name, args) {
+  switch (name) {
+    case "counter":
+      return { type: "counter", name: args[0] ?? "page", style: args[1] ?? "decimal" };
+    case "string":
+      return { type: "string", name: args[0] ?? "", which: args[1] ?? "first" };
+    case "target-counter":
+      return {
+        type: "target-counter",
+        url: args[0] ?? "",
+        counter: args[1] ?? "page",
+        style: args[2] ?? "decimal"
+      };
+    case "target-text":
+      return { type: "target-text", url: args[0] ?? "", which: args[1] ?? "content" };
+    case "leader":
+      return { type: "leader", glue: unquote(args[0] ?? '"."') };
+    case "attr": {
+      const [a, as] = (args[0] ?? "").split(/\s+/);
+      return { type: "attr", name: a ?? "", as };
+    }
+    case "content":
+      return { type: "content", which: args[0] ?? "text" };
+    default:
+      return { type: "keyword", value: `${name}(${args.join(",")})` };
+  }
+}
+function closeString(s, i) {
+  const q = s[i++];
+  while (i < s.length) {
+    if (s[i] === "\\")
+      i += 2;
+    else if (s[i] === q)
+      return i + 1;
+    else
+      i++;
+  }
+  return i;
+}
+function matchParen2(s, open) {
+  let depth = 0;
+  for (let i = open;i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i = closeString(s, i) - 1;
+      continue;
+    }
+    if (c === "(")
+      depth++;
+    else if (c === ")" && --depth === 0)
+      return i;
+  }
+  return s.length - 1;
+}
+function unquote(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))
+    return t.slice(1, -1).replace(/\\(.)/g, "$1");
+  return t;
+}
+function resolveUrlArg(arg, ctx) {
+  const m = /^attr\(\s*([\w-]+)(?:\s+url)?\s*\)$/i.exec(arg.trim());
+  if (m && m[1] !== undefined)
+    return ctx.attr?.(m[1]) ?? "";
+  return unquote(arg);
+}
+var ROMAN = [
+  [1000, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+function formatCounter(n, style = "decimal") {
+  switch (style.trim()) {
+    case "decimal-leading-zero":
+      return n < 10 ? `0${n}` : String(n);
+    case "lower-roman":
+    case "upper-roman": {
+      let v = n;
+      let out = "";
+      for (const [num, sym] of ROMAN)
+        while (v >= num)
+          out += sym, v -= num;
+      return style === "upper-roman" ? out.toUpperCase() : out;
+    }
+    case "lower-alpha":
+    case "upper-alpha": {
+      let v = n;
+      let out = "";
+      while (v > 0) {
+        const r = (v - 1) % 26;
+        out = String.fromCharCode(97 + r) + out;
+        v = Math.floor((v - 1) / 26);
+      }
+      return style === "upper-alpha" ? out.toUpperCase() : out;
+    }
+    case "none":
+      return "";
+    default:
+      return String(n);
+  }
+}
+function evaluateContent(parts, ctx) {
+  let out = "";
+  for (const p of parts) {
+    switch (p.type) {
+      case "literal":
+        out += p.value;
+        break;
+      case "counter":
+        out += formatCounter(p.name === "pages" ? ctx.pages ?? 0 : ctx.page ?? 0, p.style);
+        break;
+      case "string":
+        out += ctx.strings?.(p.name, p.which) ?? "";
+        break;
+      case "target-counter": {
+        const url = resolveUrlArg(p.url, ctx);
+        const page = ctx.targetPage?.(url);
+        out += page === undefined ? "?" : formatCounter(page, p.style);
+        break;
+      }
+      case "target-text": {
+        const url = resolveUrlArg(p.url, ctx);
+        out += ctx.targetText?.(url, p.which) ?? "";
+        break;
+      }
+      case "attr":
+        out += ctx.attr?.(p.name) ?? "";
+        break;
+      case "content":
+        out += ctx.text ?? "";
+        break;
+      case "leader":
+        out += ctx.leader?.(p.glue) ?? "";
+        break;
+      case "keyword":
+        if (p.value === "normal" || p.value === "none")
+          break;
+        out += p.value;
+        break;
+    }
+  }
+  return out;
+}
+function evaluate(value, ctx) {
+  return evaluateContent(parseContent(value), ctx);
+}
+function needsMeasurement(value) {
+  return parseContent(value).some((p) => p.type === "target-counter" || p.type === "target-text" || p.type === "leader");
+}
+
+// src/engine/shared/pdf-inspect.ts
+import {
+  PDFArray,
+  PDFDict,
+  PDFDocument,
+  PDFHexString,
+  PDFName,
+  PDFNumber,
+  PDFRef,
+  PDFString
+} from "pdf-lib";
+function boxOf(page, name) {
+  const arr = page.node.get(PDFName.of(name));
+  if (!(arr instanceof PDFArray))
+    return;
+  return arr.asArray().map((n) => n.asNumber());
+}
+async function inspectPdf(bytes) {
+  const doc = await PDFDocument.load(bytes, { updateMetadata: false });
+  const pages = doc.getPages();
+  const pageRefIndex = new Map;
+  pages.forEach((p, i) => pageRefIndex.set(p.ref.toString(), i));
+  const boxes = pages.map((p) => ({
+    media: boxOf(p, "MediaBox") ?? [],
+    crop: boxOf(p, "CropBox"),
+    bleed: boxOf(p, "BleedBox"),
+    trim: boxOf(p, "TrimBox")
+  }));
+  const resolvePageIndex = (dest) => {
+    let d = dest;
+    if (d instanceof PDFDict)
+      d = d.get(PDFName.of("D")) ?? d;
+    if (!(d instanceof PDFArray))
+      return;
+    const first = d.get(0);
+    if (first instanceof PDFRef)
+      return pageRefIndex.get(first.toString());
+    if (first instanceof PDFNumber)
+      return first.asNumber();
+    return;
+  };
+  const namedDests = {};
+  const catalog = doc.catalog;
+  const walkNameTree = (node) => {
+    if (!node)
+      return;
+    const names = node.lookupMaybe(PDFName.of("Names"), PDFArray);
+    if (names) {
+      for (let i = 0;i + 1 < names.size(); i += 2) {
+        const key = names.lookup(i);
+        const val = names.lookup(i + 1);
+        const idx = resolvePageIndex(val);
+        if (idx !== undefined)
+          namedDests[String(key).replace(/^\((.*)\)$/, "$1")] = idx;
+      }
+    }
+    const kids = node.lookupMaybe(PDFName.of("Kids"), PDFArray);
+    if (kids)
+      for (let i = 0;i < kids.size(); i++)
+        walkNameTree(kids.lookup(i, PDFDict));
+  };
+  const namesDict = catalog.lookupMaybe(PDFName.of("Names"), PDFDict);
+  walkNameTree(namesDict?.lookupMaybe(PDFName.of("Dests"), PDFDict));
+  const legacyDests = catalog.lookupMaybe(PDFName.of("Dests"), PDFDict);
+  if (legacyDests) {
+    for (const [k, v] of legacyDests.entries()) {
+      const idx = resolvePageIndex(doc.context.lookup(v));
+      if (idx !== undefined)
+        namedDests[k.asString().replace(/^\//, "")] = idx;
+    }
+  }
+  const linkTargets = {};
+  for (const page of pages) {
+    const annots = page.node.lookup(PDFName.of("Annots"));
+    if (!(annots instanceof PDFArray))
+      continue;
+    for (let i = 0;i < annots.size(); i++) {
+      const a = annots.lookup(i, PDFDict);
+      if (!a)
+        continue;
+      if (a.get(PDFName.of("Subtype"))?.toString() !== "/Link")
+        continue;
+      let dest = a.get(PDFName.of("Dest"));
+      if (!dest) {
+        const action = a.lookup(PDFName.of("A"));
+        if (action instanceof PDFDict)
+          dest = action.get(PDFName.of("D"));
+      }
+      if (dest instanceof PDFRef)
+        dest = doc.context.lookup(dest);
+      let target;
+      if (dest instanceof PDFName || dest instanceof PDFString || dest instanceof PDFHexString) {
+        const key2 = String(dest).replace(/^[/(]|\)$/g, "");
+        target = namedDests[key2];
+      } else {
+        target = resolvePageIndex(dest);
+      }
+      if (target === undefined)
+        continue;
+      const rect = a.lookupMaybe(PDFName.of("Rect"), PDFArray);
+      const key = rect ? rect.asArray().map((n) => Math.round(n.asNumber() * 100) / 100).join(",") : `annot-${Object.keys(linkTargets).length}`;
+      linkTargets[key] = target;
+    }
+  }
+  const outline = [];
+  const outlines = catalog.lookupMaybe(PDFName.of("Outlines"), PDFDict);
+  const walkOutline = (node) => {
+    let cur = node?.lookupMaybe(PDFName.of("First"), PDFDict);
+    while (cur) {
+      const titleObj = cur.get(PDFName.of("Title"));
+      const title = titleObj ? String(titleObj).replace(/^\((.*)\)$/, "$1").replace(/^/, "") : "";
+      let dest = cur.get(PDFName.of("Dest"));
+      if (!dest) {
+        const action = cur.lookupMaybe(PDFName.of("A"), PDFDict);
+        dest = action?.get(PDFName.of("D"));
+      }
+      if (dest instanceof PDFRef)
+        dest = doc.context.lookup(dest);
+      const page = resolvePageIndex(dest);
+      if (page !== undefined)
+        outline.push({ title, page });
+      walkOutline(cur.lookupMaybe(PDFName.of("First"), PDFDict) ? cur : undefined);
+      cur = cur.lookupMaybe(PDFName.of("Next"), PDFDict);
+    }
+  };
+  walkOutline(outlines);
+  return { pageCount: pages.length, boxes, linkTargets, namedDests, outline };
+}
+
+// src/lib/embedded-assets.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdtemp, mkdir, writeFile, readFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname, join as join2, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/assets/favicon.ico
+var favicon_default = "./favicon-wkbm9cjn.ico";
+
+// src/assets/manifest.schema.json
+var manifest_schema_default = "./manifest.schema-zxgxnbg7.json";
+
+// src/assets/preview/scripts/preview-interface.js
+var preview_interface_default = "./preview-interface-435cczt5.js";
+
+// src/assets/preview/scripts/preview-bridge.js
+var preview_bridge_default = "./preview-bridge-fz7vpk8m.js";
+
+// src/assets/preview/scripts/preview-shell.js
+var preview_shell_default = "./preview-shell-c5mfa3q0.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-cem7dmr5.js";
+
+// src/assets/engine/gutterpress-agent.js
+var gutterpress_agent_default = "./gutterpress-agent-1ctgfz92.js";
+
+// src/assets/templates/book/manifest.yaml
+var manifest_default = "./manifest-n1gh3qw5.yaml";
+
+// src/assets/templates/book/chapter-01.md
+var chapter_01_default = "./chapter-01-rkpyvjna.md";
+
+// src/assets/templates/zine/manifest.yaml
+var manifest_default2 = "./manifest-n1gh3qw5.yaml";
+
+// src/assets/templates/zine/chapter-01.md
+var chapter_01_default2 = "./chapter-01-7jwqg1ct.md";
+
+// src/assets/templates/technical/manifest.yaml
+var manifest_default3 = "./manifest-n1gh3qw5.yaml";
+
+// src/assets/templates/technical/chapter-01.md
+var chapter_01_default3 = "./chapter-01-6fn9pvd0.md";
+
+// src/assets/themes/clean-book/theme.css
+var theme_default = "./theme-j2bagrfx.css";
+
+// src/assets/themes/clean-book/theme.json
+var theme_default2 = "./theme-xt0hjb1b.json";
+
+// src/assets/themes/zine/theme.css
+var theme_default3 = "./theme-h5recz6c.css";
+
+// src/assets/themes/zine/theme.json
+var theme_default4 = "./theme-cd6efzjw.json";
+
+// src/assets/themes/technical-doc/theme.css
+var theme_default5 = "./theme-nn6d53zy.css";
+
+// src/assets/themes/technical-doc/theme.json
+var theme_default6 = "./theme-tqfypc1w.json";
+
+// src/lib/embedded-assets.ts
+var __libdir = dirname(fileURLToPath(import.meta.url));
+var abs = (p) => resolve(__libdir, p);
+var filePath = (v) => v;
+var EMBEDDED_ASSETS = {
+  "favicon.ico": abs(favicon_default),
+  "manifest.schema.json": abs(filePath(manifest_schema_default)),
+  "preview/scripts/preview-interface.js": abs(filePath(preview_interface_default)),
+  "preview/scripts/preview-bridge.js": abs(filePath(preview_bridge_default)),
+  "preview/scripts/preview-shell.js": abs(filePath(preview_shell_default)),
+  "profiles/CGATS21_CRPC1.icc": abs(filePath(CGATS21_CRPC1_default)),
+  "engine/gutterpress-viewer.js": abs(filePath(gutterpress_viewer_default)),
+  "engine/gutterpress-agent.js": abs(filePath(gutterpress_agent_default)),
+  "templates/book/manifest.yaml": abs(filePath(manifest_default)),
+  "templates/book/chapter-01.md": abs(filePath(chapter_01_default)),
+  "templates/zine/manifest.yaml": abs(filePath(manifest_default2)),
+  "templates/zine/chapter-01.md": abs(filePath(chapter_01_default2)),
+  "templates/technical/manifest.yaml": abs(filePath(manifest_default3)),
+  "templates/technical/chapter-01.md": abs(filePath(chapter_01_default3)),
+  "themes/clean-book/theme.css": abs(filePath(theme_default)),
+  "themes/clean-book/theme.json": abs(filePath(theme_default2)),
+  "themes/zine/theme.css": abs(filePath(theme_default3)),
+  "themes/zine/theme.json": abs(filePath(theme_default4)),
+  "themes/technical-doc/theme.css": abs(filePath(theme_default5)),
+  "themes/technical-doc/theme.json": abs(filePath(theme_default6))
+};
+var extractPromise = null;
+async function extractAssets() {
+  const root = await mkdtemp(join2(tmpdir2(), "gutterpress-assets-"));
+  for (const [relPath, srcPath] of Object.entries(EMBEDDED_ASSETS)) {
+    const dest = join2(root, relPath);
+    await mkdir(dirname(dest), { recursive: true });
+    const bytes = await readFile(srcPath);
+    await writeFile(dest, bytes);
+  }
+  return root;
+}
+var SENTINEL_ASSET = "engine/gutterpress-viewer.js";
+async function getAssetsDir() {
+  if (extractPromise) {
+    try {
+      const root = await extractPromise;
+      if (existsSync2(join2(root, SENTINEL_ASSET))) {
+        return root;
+      }
+    } catch {}
+    extractPromise = null;
+  }
+  extractPromise = extractAssets();
+  return extractPromise;
+}
+async function getAssetPath(relPath) {
+  const root = await getAssetsDir();
+  return join2(root, relPath);
+}
+
+// src/engine/compiler/tier2.ts
+var DEFAULT_SLUG_PT = 18;
+function classify(model) {
+  const tier2Strings = [];
+  const tier3Strings = [];
+  const tier3Reasons = [];
+  const consumed = consumedStrings(model);
+  for (const decl of model.stringSets) {
+    if (!consumed.has(decl.name))
+      continue;
+    if (startsRun(model, decl.selector))
+      tier2Strings.push(decl.name);
+    else {
+      tier3Strings.push(decl.name);
+      tier3Reasons.push(`string "${decl.name}" is set by \`${decl.selector}\` outside a named-page run — page granularity requires measurement`);
+    }
+  }
+  for (const x of model.xrefs) {
+    if (needsMeasurement(x.content))
+      tier3Reasons.push(`\`${x.selector}\` uses ${x.fn}() — requires measurement`);
+  }
+  return { tier2Strings, tier3Strings, tier3Reasons };
+}
+function pseudoVariants(model) {
+  const set = new Set;
+  for (const rule of model.pageRules)
+    for (const p of rule.pseudos)
+      set.add(p);
+  return [...set];
+}
+function consumedStrings(model) {
+  const names = new Set;
+  for (const rule of model.pageRules)
+    for (const decls of Object.values(rule.marginBoxes))
+      if (decls.content) {
+        for (const part of parseContent(decls.content))
+          if (part.type === "string")
+            names.add(part.name);
+      }
+  return names;
+}
+function startsRun(model, selector) {
+  const sel = selector.trim();
+  if (model.pageAssignments.some((a) => a.selector.trim() === sel))
+    return true;
+  return model.breaks.some((b) => b.selector.trim() === sel && b.prop === "break-before" && /^(page|always|left|right|recto|verso)$/.test(b.value.trim()));
+}
+function pageGeometry(model, opts) {
+  const base = resolvePage(model);
+  const trim = { width: base.geometry.width, height: base.geometry.height };
+  const bleed = opts.bleedPt ?? base.geometry.bleed;
+  const wantsMarks = base.geometry.marks.length > 0 || opts.marks === true;
+  const slug = wantsMarks ? opts.slugPt ?? DEFAULT_SLUG_PT : 0;
+  return {
+    trim,
+    bleed,
+    slug,
+    marks: base.geometry.marks.length ? base.geometry.marks : wantsMarks ? ["crop"] : [],
+    media: {
+      width: trim.width + 2 * (bleed + slug),
+      height: trim.height + 2 * (bleed + slug)
+    }
+  };
+}
+var declsToCss = (d, indent = "    ") => Object.entries(d).map(([k, v]) => `${indent}${k}: ${v};`).join(`
+`);
+function bleedMargin(authored, g) {
+  return authored === 0 ? g.slug : authored + g.bleed + g.slug;
+}
+function marginBoxInset(name, inset) {
+  if (!inset)
+    return {};
+  if (name.startsWith("@top"))
+    return { "padding-top": `${inset}pt` };
+  if (name.startsWith("@bottom"))
+    return { "padding-bottom": `${inset}pt` };
+  if (name.startsWith("@left"))
+    return { "padding-left": `${inset}pt` };
+  if (name.startsWith("@right"))
+    return { "padding-right": `${inset}pt` };
+  return {};
+}
+function synthesize(input) {
+  const { model } = input;
+  const geometry = pageGeometry(model, input);
+  const inset = geometry.bleed + geometry.slug;
+  const { tier3Reasons } = classify(model);
+  const notes = [];
+  const out = [
+    "/* gp.gen.css — generated by the Gutterpress compiler (Tier 2).",
+    "   Derived from the author's own @page/GCPM declarations; the author's",
+    "   files are never modified. Inspect freely, do not edit. */",
+    ""
+  ];
+  if (inset > 0) {
+    const names = [undefined, ...model.pageNames];
+    const variants = [[], ...pseudoVariants(model).map((p) => [p])];
+    for (const name of names) {
+      for (const pseudos of variants) {
+        const isBase = name === undefined && pseudos.length === 0;
+        const authorWroteIt = model.pageRules.some((r) => r.name === name && r.pseudos.length === pseudos.length && r.pseudos.every((p) => pseudos.includes(p)));
+        if (!isBase && !authorWroteIt)
+          continue;
+        const resolved = resolvePage(model, { name, pseudos });
+        const pseudo = pseudos.length ? `:${pseudos.join(":")}` : "";
+        const lines = [
+          `  size: ${round(geometry.media.width)}pt ${round(geometry.media.height)}pt;`
+        ];
+        for (const side of ["top", "right", "bottom", "left"]) {
+          lines.push(`  margin-${side}: ${round(bleedMargin(resolved.geometry.margin[side], geometry))}pt;`);
+        }
+        out.push(`@page ${name ?? ""}${pseudo} {`, ...lines, `}`.replace("@page  ", "@page "));
+      }
+    }
+    const seen = new Set;
+    for (const rule of model.pageRules)
+      for (const name of Object.keys(rule.marginBoxes))
+        seen.add(name);
+    for (const name of seen) {
+      const d = marginBoxInset(name, inset);
+      if (!Object.keys(d).length)
+        continue;
+      out.push(`@page {`, `  ${name} {`, declsToCss(d, "    "), `  }`, `}`);
+    }
+    notes.push(`bleed ${round(geometry.bleed)}pt + slug ${round(geometry.slug)}pt: media ${round(geometry.media.width)}×${round(geometry.media.height)}pt, trim ${round(geometry.trim.width)}×${round(geometry.trim.height)}pt`);
+    if (geometry.bleed > 0)
+      notes.push("Chromium clips page content to the content box, so art can only reach the bleed area on " + "pages whose authored margin is 0 (covers, plates) — those keep a slug-only margin so the " + "content box IS the bleed box. On pages with real margins, bleed is geometry only.");
+  }
+  return {
+    css: out.join(`
+`) + `
+`,
+    geometry,
+    needsTier3: tier3Reasons.length > 0,
+    notes: [...notes, ...tier3Reasons]
+  };
+}
+function round(n) {
+  return Math.round(n * 1000) / 1000;
+}
+
+// src/engine/compiler/postprocess.ts
+import { PDFDocument as PDFDocument2, PDFName as PDFName2, PDFNumber as PDFNumber2, rgb } from "pdf-lib";
+async function postprocess(input, opts) {
+  const doc = await PDFDocument2.load(input, { updateMetadata: false });
+  const g = opts.geometry;
+  const inset = g.bleed + g.slug;
+  const media = [0, 0, g.media.width, g.media.height];
+  const bleedBox = [
+    g.slug,
+    g.slug,
+    g.media.width - g.slug,
+    g.media.height - g.slug
+  ];
+  const trimBox = [
+    inset,
+    inset,
+    g.media.width - inset,
+    g.media.height - inset
+  ];
+  let padded = 0;
+  if (opts.signature && opts.signature > 1) {
+    const remainder = doc.getPageCount() % opts.signature;
+    if (remainder !== 0) {
+      padded = opts.signature - remainder;
+      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");
+  for (const page of doc.getPages()) {
+    const node = page.node;
+    const set = (name, box) => node.set(PDFName2.of(name), doc.context.obj(box.map((v) => PDFNumber2.of(round2(v)))));
+    set("MediaBox", media);
+    set("CropBox", media);
+    if (g.bleed > 0 || g.slug > 0) {
+      set("BleedBox", bleedBox);
+      set("TrimBox", trimBox);
+    } else {
+      set("TrimBox", media);
+    }
+    if (wantMarks && g.slug > 0)
+      drawCropMarks(page, g);
+  }
+  if (opts.title)
+    doc.setTitle(opts.title);
+  if (opts.author)
+    doc.setAuthor(opts.author);
+  if (opts.subject)
+    doc.setSubject(opts.subject);
+  if (opts.keywords?.length)
+    doc.setKeywords(opts.keywords);
+  const bytes = await doc.save({ useObjectStreams: true });
+  return {
+    bytes,
+    pageCount: doc.getPageCount(),
+    padded,
+    boxes: { media, bleed: bleedBox, trim: trimBox }
+  };
+}
+function drawCropMarks(page, g) {
+  const inset = g.bleed + g.slug;
+  const len = Math.min(g.slug, 18);
+  const gap = g.bleed;
+  const w = g.media.width;
+  const h = g.media.height;
+  const color = rgb(0, 0, 0);
+  const thickness = 0.25;
+  const line = (x, y, dx, dy) => page.drawLine({
+    start: { x, y },
+    end: { x: x + dx, y: y + dy },
+    thickness,
+    color
+  });
+  const xs = [inset, w - inset];
+  const ys = [inset, h - inset];
+  for (const x of xs) {
+    for (const y of ys) {
+      const sx = x === inset ? -1 : 1;
+      const sy = y === inset ? -1 : 1;
+      line(x + sx * gap, y, sx * len, 0);
+      line(x, y + sy * gap, 0, sy * len);
+    }
+  }
+}
+function round2(n) {
+  return Math.round(n * 1000) / 1000;
+}
+
+// src/engine/compiler/build.ts
+var BLANK_PAGE = "gp--blank";
+var DESC_JS = `(el) => {
+    const cls = typeof el.className === "string" && el.className
+      ? "." + el.className.trim().split(/\\s+/).join(".") : "";
+    const src = el.tagName === "IMG" ? " src=" + (el.getAttribute("src") || "").slice(-40) : "";
+    return el.tagName.toLowerCase() + cls + src;
+  }`;
+function pagePseudoContexts(model) {
+  const used = new Set(pseudoVariants(model));
+  const standard = new Set(["left", "right", "recto", "verso", "first", "blank"]);
+  const choices = (a, b) => [
+    undefined,
+    ...used.has(a) ? [a] : [],
+    ...used.has(b) ? [b] : []
+  ];
+  const physical = choices("left", "right");
+  const progression = choices("recto", "verso");
+  const first = used.has("first") ? [false, true] : [false];
+  const blank = used.has("blank") ? [false, true] : [false];
+  const standardContexts = [];
+  for (const p of physical)
+    for (const r of progression)
+      for (const f of first)
+        for (const b of blank)
+          standardContexts.push([
+            ...p ? [p] : [],
+            ...r ? [r] : [],
+            ...f ? ["first"] : [],
+            ...b ? ["blank"] : []
+          ]);
+  const authoredExactSets = [
+    [],
+    ...model.pageRules.map((rule) => rule.pseudos.filter((pseudo) => !standard.has(pseudo)))
+  ];
+  const contexts = new Map;
+  for (const exact of authoredExactSets) {
+    for (const common of standardContexts) {
+      const context = [...new Set([...exact, ...common])].sort();
+      contexts.set(context.join("\x00"), context);
+    }
+  }
+  return [...contexts.values()];
+}
+async function build(opts) {
+  const log = opts.onProgress ?? (() => {});
+  const AGENT = await readFile2(await getAssetPath("engine/gutterpress-agent.js"), "utf8");
+  const VIEWER = await readFile2(await getAssetPath("engine/gutterpress-viewer.js"), "utf8");
+  const browser = opts.browser ?? await launchChromium();
+  const ownsBrowser = !opts.browser;
+  const page = await browser.newPage();
+  const notes = [];
+  const diagnostics = [];
+  const diagnose = (code, message, severity = "warning") => diagnostics.push({ code, severity, message });
+  let prints = 0;
+  try {
+    const url = /^(https?|file):\/\//.test(opts.input) ? opts.input : pathToFileURL(resolve2(opts.input)).href;
+    await page.navigate(url);
+    await page.evaluate(AGENT);
+    await page.waitForReady();
+    const cssText = await page.evaluate(`window.__gp.collectCss()`);
+    const model = extract(cssText);
+    const { tier3Reasons } = classify(model);
+    const baseGeom = resolvePage(model).geometry;
+    const sheetViewport = {
+      width: Math.max(1, Math.round(baseGeom.width * 96 / 72)),
+      height: Math.max(1, Math.round(baseGeom.height * 96 / 72)),
+      deviceScaleFactor: 1,
+      mobile: false
+    };
+    await page.send("Emulation.setDeviceMetricsOverride", sheetViewport);
+    await page.send("Emulation.setEmulatedMedia", { media: "print" });
+    log(`print media emulated for audits and measurement`);
+    const tier2 = synthesize({
+      model,
+      marks: opts.marks,
+      slugPt: opts.slugPt,
+      bleedPt: opts.bleedPt
+    });
+    notes.push(...tier2.notes);
+    let genCss = tier2.css;
+    if (genCss.trim().length > 200) {
+      await page.evaluate(`window.__gp.addCss("gp-gen-css", ${JSON.stringify(genCss)})`);
+      log(`tier 2: bleed/marks geometry`);
+    }
+    const widthOffenders = await findWidthOffenders(page, model, 2 * (tier2.geometry.bleed + tier2.geometry.slug), sheetViewport);
+    const describe = (list) => list.map((o) => {
+      const fix = o.left !== undefined && o.left < -1 ? "keep it inside the page content box" : "give it an explicit width";
+      return `  ${o.desc} — ${Math.round(o.px)}px > ${Math.round(widthOffenders.limitPx)}px content box (${fix})`;
+    }).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):
+${describe(widthOffenders.boxes)}`;
+      if (opts.allowShrink) {
+        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."}`);
+        log(`WARNING: ${msg}`);
+      } else {
+        throw new Error(`${msg}
+Fix the offending widths, or pass allowShrink to build anyway.`);
+      }
+    }
+    if (widthOffenders.intrinsics.length) {
+      const msg = `${widthOffenders.intrinsics.length} auto-width image(s) with an intrinsic width past the ` + `page content box — if the output prints smaller than the CSS declares, give these an ` + `explicit width (e.g. width: 100%):
+${describe(widthOffenders.intrinsics)}`;
+      for (const o of widthOffenders.intrinsics)
+        diagnose("engine.width.intrinsic", `${o.desc} has no width set and is naturally wider than the page — if the printed output comes out smaller than your CSS says, give it an explicit width (e.g. width: 100%).`);
+      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;
+    let tier = tier2.geometry.bleed > 0 || tier2.geometry.slug > 0 ? 2 : 1;
+    let passes = 1;
+    let pageMap = {};
+    let converged = true;
+    let bytes;
+    let predictedForResult = null;
+    let resetSitesForResult = [];
+    if (needsMeasure) {
+      tier = 3;
+      const maxPasses = opts.maxPasses ?? 4;
+      const sources = await page.evaluate(`window.__gp.stringSources(${JSON.stringify(model.stringSets.map((s) => ({ selector: s.selector, name: s.name, value: s.value })))})`);
+      const rectoSites = rectoDecls.length ? await page.evaluate(`window.__gp.forcedBreakSites(${JSON.stringify(rectoDecls)})`) : [];
+      const hasBlankSites = rectoSites.length > 0;
+      const xrefSelectors = model.xrefs.filter((x) => needsMeasurement(x.content)).map((x) => x.selector);
+      const sites = await page.evaluate(`window.__gp.xrefSites(${JSON.stringify(xrefSelectors)})`);
+      const resetSites = model.counterResets.length ? await page.evaluate(`window.__gp.counterResetSites(${JSON.stringify(model.counterResets)})`) : [];
+      resetSitesForResult = resetSites;
+      const targets = new Set;
+      for (const s of sources)
+        targets.add(s.id);
+      for (const s of sites)
+        if (s.href.startsWith("#"))
+          targets.add(s.href.slice(1));
+      for (const s of rectoSites)
+        targets.add(s.id);
+      for (const s of resetSites)
+        targets.add(s.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);
+      for (const href of brokenXrefs)
+        diagnose("engine.xref.broken", `The link "${href}" doesn't point at anything in this book, so its page number will print blank. Check the spelling, or add that id to the heading you meant.`);
+      if (brokenXrefs.length)
+        log(`WARNING: ${brokenXrefs.length} broken cross-reference href(s): ${brokenXrefs.join(", ")}`);
+      if (rectoSites.length) {
+        const measure = async () => {
+          prints++;
+          const facts = await inspectPdf(await printPdf(page));
+          return Object.fromEntries(Object.entries(facts.namedDests).map(([k, v]) => [k, v + 1]));
+        };
+        let map = await measure();
+        const wrong = (site, p) => wantsRecto(site.value) ? p % 2 === 0 : p % 2 === 1;
+        const plan = planRectoBlanks(rectoSites.map((site) => ({
+          page: map[site.id] ?? 0,
+          wantsRecto: wantsRecto(site.value)
+        })));
+        const planned = rectoSites.filter((_, i) => plan[i]).map((site) => site.id);
+        if (planned.length) {
+          const earlyBlankCss = counterStyleCss(model, [], {}, 0, [], true);
+          if (earlyBlankCss) {
+            await page.evaluate(`window.__gp.addCss("gp-gen-strings", ${JSON.stringify(earlyBlankCss)})`);
+          }
+        }
+        if (planned.length) {
+          await page.evaluate(`window.__gp.applyRectoSpacers(${JSON.stringify(planned)}, ${JSON.stringify(BLANK_PAGE)})`);
+          log(`tier 3: ${planned.length} blank page(s) so forced breaks land on the right side`);
+          for (let attempt = 0;attempt < 3; attempt++) {
+            map = await measure();
+            const bad = rectoSites.filter((site) => {
+              const p = map[site.id];
+              return p ? wrong(site, p) : false;
+            });
+            if (!bad.length)
+              break;
+            for (const site of bad) {
+              const i = planned.indexOf(site.id);
+              if (i >= 0)
+                planned.splice(i, 1);
+              else
+                planned.push(site.id);
+            }
+            await page.evaluate(`window.__gp.applyRectoSpacers(${JSON.stringify(planned)}, ${JSON.stringify(BLANK_PAGE)})`);
+            if (attempt === 2)
+              notes.push(`Could not place ${bad.length} recto/verso break(s) after 3 attempts.`);
+          }
+        }
+      }
+      const applySynthesis = async (map, pageCount) => {
+        const pageValues = restartedPageValues(resetSites, map, pageCount);
+        const generated = [];
+        for (const site of sites) {
+          const decl = model.xrefs.find((x) => x.selector === site.selector);
+          if (!decl)
+            continue;
+          const where = /::?before$/.test(site.selector) ? "before" : "after";
+          const text = evaluate(decl.content, {
+            attr: (n) => n === "href" ? site.href : undefined,
+            targetPage: (u) => {
+              const physical = map[u.replace(/^#/, "")];
+              return physical === undefined ? undefined : toFolioPage(physical, pageValues);
+            },
+            targetText: (u) => targetText[u.replace(/^#/, "")],
+            leader: leaderMarker
+          });
+          generated.push({ id: site.id, where, text });
+        }
+        if (generated.length) {
+          const contentCss = generatedContentCss(model.xrefs.map((x) => x.selector));
+          await page.evaluate(`window.__gp.setGenerated(${JSON.stringify(generated)}, ${JSON.stringify(contentCss)})`);
+          const g = tier2.geometry;
+          const contentWidthPx = (g.trim.width - resolvePage(model).geometry.margin.left - resolvePage(model).geometry.margin.right) * 96 / 72;
+          await page.evaluate(`window.__gp.fillLeaders(${contentWidthPx})`);
+        }
+        const mapCss = counterStyleCss(model, sources, map, pageCount, resetSites, hasBlankSites);
+        if (mapCss) {
+          await page.evaluate(`window.__gp.addCss("gp-gen-strings", ${JSON.stringify(mapCss)})`);
+          genCss = genCss.split(`
+/* Tier 3 */`)[0] + `
+/* Tier 3 */
+${mapCss}`;
+        }
+      };
+      const predicted = await predictPageMap(browser, url, AGENT, VIEWER, {
+        stringSets: model.stringSets.map((s) => ({ selector: s.selector, name: s.name, value: s.value })),
+        rectoDecls,
+        xrefSelectors,
+        resets: model.counterResets,
+        targets: [...targets]
+      }, sheetViewport);
+      if (predicted)
+        predictedForResult = { pageMap: predicted.pageMap, pageCount: predicted.pageCount };
+      let previous = "";
+      if (predicted) {
+        log(`tier 3: predicted page map from the viewer in ${predicted.ms.toFixed(0)}ms ` + `(${predicted.pageCount}pp, ${Object.keys(predicted.pageMap).length}/${targets.size} targets resolved)`);
+        await applySynthesis(predicted.pageMap, predicted.pageCount);
+        previous = mapSignature(predicted.pageMap, predicted.pageCount);
+      }
+      converged = false;
+      for (let pass = 1;pass <= maxPasses; pass++) {
+        passes = pass;
+        prints++;
+        bytes = await printPdf(page);
+        const facts = await inspectPdf(bytes);
+        pageMap = Object.fromEntries(Object.entries(facts.namedDests).filter(([k]) => targets.has(k)).map(([k, v]) => [k, v + 1]));
+        log(`tier 3: pass ${pass} measured ${Object.keys(pageMap).length}/${targets.size} targets (${facts.pageCount}pp)`);
+        const signature = mapSignature(pageMap, facts.pageCount);
+        if (signature === previous) {
+          converged = true;
+          log(`tier 3: fixpoint after ${pass} pass${pass === 1 ? "" : "es"}` + (predicted && pass === 1 ? " — the predicted print shipped, no reprint" : ""));
+          break;
+        }
+        previous = signature;
+        await applySynthesis(pageMap, facts.pageCount);
+      }
+      if (!converged) {
+        notes.push(`Tier 3 did not reach a fixpoint in ${passes} passes — page numbers in generated text may be one pass stale.`);
+        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,
+        named: namedContentHeightsPx
+      })}, ${opts.dpiFloor ?? 300})`);
+      for (const w of audit) {
+        if (w.kind === "overheight")
+          diagnose("engine.content.overheight", `${w.what} is taller than one page (${w.detail}): print splits it across pages while the on-screen preview clips it, so the two will not agree here.`);
+        else
+          diagnose("engine.image.low-dpi", `${w.what} is below the ${opts.dpiFloor ?? 300} DPI print bar (${w.detail}) — it may look soft or pixelated in print.`);
+      }
+      if (audit.length)
+        log(`audit: ${audit.length} print-quality warning(s)`);
+    }
+    {
+      const { leaks, multicol, layerTraps } = JSON.parse(await page.evaluate(`(() => {
+          const desc = ${DESC_JS};
+          const leaks = [];
+          const multicol = [];
+          const layerTraps = [];
+          const seenLayerTraps = new Set();
+
+          const stackingReasons = (el, cs) => {
+            const reasons = [];
+            const positioned = cs.position !== "static";
+            const parentDisplay = el.parentElement
+              ? getComputedStyle(el.parentElement).display
+              : "";
+            const flexOrGridItem = /^(inline-)?(flex|grid)$/.test(parentDisplay);
+            if (cs.isolation === "isolate") reasons.push("isolation: isolate");
+            if (Number.parseFloat(cs.opacity) < 1) reasons.push("opacity: " + cs.opacity);
+            if (cs.mixBlendMode !== "normal") reasons.push("mix-blend-mode: " + cs.mixBlendMode);
+            if (cs.position === "fixed" || cs.position === "sticky")
+              reasons.push("position: " + cs.position);
+            if (cs.zIndex !== "auto" && (positioned || flexOrGridItem))
+              reasons.push("z-index: " + cs.zIndex);
+            for (const prop of [
+              "transform", "scale", "rotate", "translate", "filter",
+              "backdropFilter", "perspective", "clipPath", "mask", "maskImage",
+            ]) {
+              const value = cs[prop];
+              if (value && value !== "none")
+                reasons.push(prop.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()) + ": " + value);
+            }
+            if (/\\b(layout|paint|strict|content)\\b/.test(cs.contain))
+              reasons.push("contain: " + cs.contain);
+            if (cs.containerType && cs.containerType !== "normal")
+              reasons.push("container-type: " + cs.containerType);
+            if (/\\b(transform|opacity|filter|perspective|clip-path|mask)\\b/.test(cs.willChange))
+              reasons.push("will-change: " + cs.willChange);
+            return reasons;
+          };
+
+          for (const el of document.querySelectorAll("*")) {
+            const cs = getComputedStyle(el);
+            if (leaks.length < 20) {
+              const tag = el.tagName;
+              const id = el.id || "";
+              const cls = typeof el.className === "string" ? el.className : "";
+              if (
+                tag !== "GP-ANCHOR" &&
+                !id.startsWith("gp-") &&
+                !id.startsWith("__gp") &&
+                // gp-* CLASSES are author-facing vocabulary (MARKER_CSS's
+                // .gp-pin is abspos by design and must stay visible to this
+                // leak check); only the engine's own print-document class is
+                // excluded. Engine-internal DOM identifies itself via ids or
+                // __gp classes, never bare gp-* classes.
+                !/(^|\\s)(gp-recto-spacer|__gp)/.test(cls) &&
+                !el.closest("#gp-instrumentation") &&
+                cs.position === "absolute" &&
+                el.getClientRects().length !== 0 // not a display:none subtree
+              ) {
+                const op = el.offsetParent;
+                if (op === null || op === document.body) leaks.push(desc(el));
+              }
+            }
+            if (
+              multicol.length < 20 &&
+              !(cs.columnCount === "auto" && cs.columnWidth === "auto") &&
+              cs.columnFill === "balance" &&
+              el.getBoundingClientRect().height > ${minContentHeightPx} + 1
+            ) {
+              multicol.push(desc(el));
+            }
+
+            if (
+              layerTraps.length < 20 &&
+              el.classList.contains("gp-behind") &&
+              el.getClientRects().length !== 0
+            ) {
+              const boundary = el.closest(".page, .spread");
+              if (boundary) {
+                for (let ancestor = el.parentElement; ancestor; ancestor = ancestor.parentElement) {
+                  const ancestorStyle = getComputedStyle(ancestor);
+                  const reasons = stackingReasons(ancestor, ancestorStyle);
+                  const clips = ancestorStyle.overflowX !== "visible" ||
+                    ancestorStyle.overflowY !== "visible";
+                  if ((reasons.length || clips) && !seenLayerTraps.has(ancestor)) {
+                    seenLayerTraps.add(ancestor);
+                    const effects = [];
+                    if (reasons.length)
+                      effects.push("creates a stacking context (" + reasons.join(", ") + ")");
+                    if (clips)
+                      effects.push(
+                        "clips descendants (overflow-x: " + ancestorStyle.overflowX +
+                        ", overflow-y: " + ancestorStyle.overflowY + ")"
+                      );
+                    layerTraps.push({
+                      behind: desc(el),
+                      ancestor: desc(ancestor),
+                      detail: effects.join(" and "),
+                    });
+                    if (layerTraps.length >= 20) break;
+                  }
+                  if (ancestor === boundary) break;
+                }
+              }
+            }
+          }
+          return JSON.stringify({ leaks, multicol, layerTraps });
+        })()`));
+      for (const d of leaks)
+        diagnose("engine.abspos.leak", `${d} uses position: absolute with nothing positioned around it, so it is placed against the whole document rather than the page it sits on in your markdown — it can print on a completely different page.`);
+      if (leaks.length)
+        log(`audit: ${leaks.length} abspos containing-block leak(s)`);
+      for (const trap of layerTraps)
+        diagnose("engine.layer.trapped", `${trap.behind} cannot paint behind the page as intended because ancestor ${trap.ancestor} ${trap.detail}. Remove or narrowly scope that containment style around the .gp-behind element.`);
+      if (layerTraps.length)
+        log(`audit: ${layerTraps.length} trapped layer warning(s)`);
+      for (const d of multicol)
+        diagnose("engine.multicol.dead-column", `${d} runs over more than one page in columns, and only the last page's columns get balanced — earlier pages are left with an empty column. Add column-fill: auto to ${d}.`);
+      if (multicol.length)
+        log(`audit: ${multicol.length} fragmenting multicol warning(s)`);
+    }
+    if (bytes === undefined) {
+      prints++;
+      bytes = await printPdf(page);
+    }
+    const post = await postprocess(bytes, {
+      geometry: tier2.geometry,
+      signature: opts.signature,
+      marks: opts.marks,
+      title: opts.title,
+      author: opts.author
+    });
+    log(`postprocess: ${post.pageCount} pages` + (post.padded ? ` (+${post.padded} signature pad)` : ""));
+    return {
+      bytes: post.bytes,
+      tier,
+      passes,
+      pageCount: post.pageCount,
+      genCss,
+      geometry: tier2.geometry,
+      notes,
+      diagnostics,
+      post,
+      pageMap,
+      converged,
+      prints,
+      predicted: predictedForResult,
+      resetSites: resetSitesForResult,
+      viewport: { width: sheetViewport.width, height: sheetViewport.height }
+    };
+  } finally {
+    await page.close();
+    if (ownsBrowser)
+      await browser.close();
+  }
+}
+async function printPdf(page) {
+  await page.waitForReady();
+  return page.printToPDF();
+}
+async function findWidthOffenders(page, model, bleedSlugExtensionPt, restoreViewport) {
+  const contexts = [
+    resolvePage(model),
+    ...model.pageNames.filter((n) => !n.startsWith("gp-")).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;
+  await page.evaluate(`Promise.allSettled(
+    [...document.images].map((i) => i.decode().catch(() => {}))
+  )`);
+  try {
+    await page.send("Emulation.setDeviceMetricsOverride", {
+      width: Math.ceil(limitPx),
+      height: 1080,
+      deviceScaleFactor: 1,
+      mobile: false
+    });
+    const boxes = JSON.parse(await page.evaluate(`(() => {
+        const LIMIT = ${limitPx} + 1;
+        const desc = ${DESC_JS};
+        const out = [];
+        for (const el of document.querySelectorAll("*")) {
+          const r = el.getBoundingClientRect();
+          const right = Math.max(r.right, r.left + r.width);
+          // Flag right-edge overflow (fixed-width blocks, negative-margin
+          // pulls) AND left-edge protrusion (negative left with an ordinary
+          // 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;
+          let deepest = true;
+          for (const c of el.children) {
+            if (c.getBoundingClientRect().width >= r.width - 1) { deepest = false; break; }
+          }
+          if (!deepest) continue;
+          out.push({ desc: desc(el), px: Math.max(r.width, right), left: r.left });
+          if (out.length >= 20) break;
+        }
+        return JSON.stringify(out);
+      })()`));
+    const replaced = JSON.parse(await page.evaluate(`(() => {
+        const LIMIT = ${limitPx} + 1;
+        const desc = ${DESC_JS};
+        const out = [];
+        for (const el of document.querySelectorAll("img, canvas, video")) {
+          const intrinsic = el.naturalWidth ?? el.videoWidth ?? el.width ?? 0;
+          if (!intrinsic || intrinsic <= LIMIT) continue;
+          let widthIsAuto = true;
+          try {
+            widthIsAuto = String(el.computedStyleMap().get("width")) === "auto";
+          } catch (_) { /* Typed OM unavailable: keep the conservative flag */ }
+          if (!widthIsAuto) continue;
+          out.push({ desc: desc(el), px: intrinsic });
+          if (out.length >= 20) break;
+        }
+        return JSON.stringify(out);
+      })()`));
+    return { limitPx, boxes, intrinsics: replaced };
+  } finally {
+    await page.send("Emulation.setDeviceMetricsOverride", restoreViewport);
+  }
+}
+function findBrokenXrefRefs(sites, resolved) {
+  const seen = new Set;
+  const out = [];
+  for (const s of sites) {
+    if (!s.href.startsWith("#"))
+      continue;
+    if (s.href.slice(1) in resolved)
+      continue;
+    if (seen.has(s.href))
+      continue;
+    seen.add(s.href);
+    out.push(s.href);
+  }
+  return out;
+}
+function mapSignature(map, pageCount) {
+  return Object.keys(map).sort().map((k) => `${k}=${map[k]}`).join("|") + `|pageCount=${pageCount}`;
+}
+async function predictPageMap(browser, url, agentScript, viewerScript, args, sheetViewport) {
+  const t0 = performance.now();
+  let page;
+  try {
+    page = await browser.newPage();
+    await page.send("Emulation.setDeviceMetricsOverride", sheetViewport);
+    await page.navigate(url);
+    await page.evaluate(agentScript);
+    await page.waitForReady();
+    await page.evaluate(`window.__GP_MANUAL__ = true;`);
+    await page.evaluate(viewerScript);
+    await page.evaluate(`window.__gp.stringSources(${JSON.stringify(args.stringSets)})`);
+    if (args.rectoDecls.length)
+      await page.evaluate(`window.__gp.forcedBreakSites(${JSON.stringify(args.rectoDecls)})`);
+    await page.evaluate(`window.__gp.xrefSites(${JSON.stringify(args.xrefSelectors)})`);
+    if (args.resets.length)
+      await page.evaluate(`window.__gp.counterResetSites(${JSON.stringify(args.resets)})`);
+    const result = await page.evaluate(`(async () => {
+      const api = await window.Gutterpress.fragmentDocument({});
+      const pageMap = {};
+      for (const id of ${JSON.stringify(args.targets)}) {
+        const el = document.getElementById(id);
+        if (!el) continue;
+        // an id may name an injected zero-size <gp-anchor>; measure its
+        // host instead (same as the compiler agent's own anchorHost()).
+        const target = el.tagName === "GP-ANCHOR" ? el.parentElement ?? el : el;
+        pageMap[id] = api.pageOf(target) + 1;
+      }
+      return { pageMap, pageCount: api.totalPages };
+    })()`);
+    return { ...result, ms: performance.now() - t0 };
+  } catch {
+    return null;
+  } finally {
+    if (page)
+      await page.close();
+  }
+}
+function counterStyleCss(model, sources, pageMap, pageCount, resetSites = [], hasBlank = false) {
+  const consumed = consumedStrings(model);
+  const byName = new Map;
+  for (const s of sources) {
+    const page = pageMap[s.id];
+    if (!page || !consumed.has(s.name))
+      continue;
+    const list = byName.get(s.name) ?? [];
+    list.push({ page, value: s.text });
+    byName.set(s.name, list);
+  }
+  for (const entries of byName.values())
+    entries.sort((a, b) => a.page - b.page);
+  const pageValues = restartedPageValues(resetSites, pageMap, pageCount);
+  if (!consumed.size && !pageValues && !hasBlank)
+    return "";
+  if (!byName.size && !pageValues && !hasBlank)
+    return "";
+  const pairs = new Map;
+  for (const rule of model.pageRules) {
+    for (const decls of Object.values(rule.marginBoxes)) {
+      if (!decls.content)
+        continue;
+      for (const part of parseContent(decls.content)) {
+        if (part.type !== "string" || !byName.has(part.name))
+          continue;
+        const which = parseWhich(part.which);
+        pairs.set(counterStyleName(part.name, which), { name: part.name, which });
+      }
+    }
+  }
+  const out = [];
+  for (const [styleName, pair] of pairs) {
+    const symbols = stringSymbols(byName.get(pair.name), pageCount, pair.which);
+    out.push(`@counter-style ${styleName} { system: fixed; suffix: ""; symbols: ${symbols.map(cssQuote).join(" ")}; }`);
+  }
+  const pageCounterStyles = new Map;
+  const pageCounterStyleName = (style) => `gp-page--${style}`;
+  const rewrite = (content) => parseContent(content).map((part) => {
+    if (part.type === "string")
+      return `counter(page, ${counterStyleName(part.name, parseWhich(part.which))})`;
+    if (part.type === "literal")
+      return cssQuote(part.value);
+    if (part.type === "counter") {
+      if (part.name === "page" && pageValues) {
+        const styleName = pageCounterStyleName(part.style);
+        if (!pageCounterStyles.has(styleName))
+          pageCounterStyles.set(styleName, pageValues.map((v) => formatCounter(v, part.style)));
+        return `counter(page, ${styleName})`;
+      }
+      return `counter(${part.name}${part.style !== "decimal" ? `, ${part.style}` : ""})`;
+    }
+    if (part.type === "keyword")
+      return part.value;
+    return "";
+  }).filter(Boolean).join(" ");
+  const names = [undefined, ...model.pageNames];
+  const variants = [[], ...pseudoVariants(model).map((p) => [p])];
+  for (const name of names) {
+    for (const pseudos of variants) {
+      const resolved = resolvePage(model, { name, pseudos });
+      const lines = [];
+      for (const [box, decls] of Object.entries(resolved.marginBoxes)) {
+        if (!decls.content)
+          continue;
+        const hasString = /\bstring\s*\(/.test(decls.content);
+        const hasPageCounter = pageValues && /\bcounter\(\s*page\b(?!s)/.test(decls.content);
+        const needsRewrite = hasString || hasPageCounter;
+        lines.push(`  ${box} { content: ${needsRewrite ? rewrite(decls.content) : decls.content}; }`);
+      }
+      if (!lines.length)
+        continue;
+      const pseudo = pseudos.length ? `:${pseudos.join(":")}` : "";
+      out.push(`@page ${name ?? ""}${pseudo} {
+${lines.join(`
+`)}
+}`.replace("@page  ", "@page "));
+    }
+  }
+  if (hasBlank) {
+    const blank = resolvePage(model, { pseudos: ["blank"] });
+    const lines = [];
+    for (const [box, decls] of Object.entries(blank.marginBoxes)) {
+      if (!decls.content)
+        continue;
+      const hasString = /\bstring\s*\(/.test(decls.content);
+      const hasPageCounter = pageValues && /\bcounter\(\s*page\b(?!s)/.test(decls.content);
+      const needsRewrite = hasString || hasPageCounter;
+      lines.push(`  ${box} { content: ${needsRewrite ? rewrite(decls.content) : decls.content}; }`);
+    }
+    out.push(`@page ${BLANK_PAGE} {
+${lines.length ? lines.join(`
+`) : "  /* author declared no @page :blank */"}
+}`);
+  }
+  for (const [styleName, symbols] of pageCounterStyles) {
+    out.push(`@counter-style ${styleName} { system: fixed; suffix: ""; symbols: ${symbols.map(cssQuote).join(" ")}; }`);
+  }
+  return out.join(`
+`);
+}
+
+export { RENDER_TIMEOUT_MS, prewarmBrowser, getBrowser, closeBrowser, getAssetPath, REQUIRED_MILESTONE, assertMilestone, connectChromium, build };