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

package/dist/index-mvehxh0e.js

@@ -0,0 +1,708 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/lib/build-error.ts
+var EXIT_CODES = {
+  OK: 0,
+  FINDINGS: 1,
+  USAGE: 2,
+  PIPELINE: 3
+};
+
+class BuildError extends Error {
+  exitCode;
+  constructor(message, exitCode = EXIT_CODES.PIPELINE, options) {
+    super(message, options);
+    this.name = "BuildError";
+    this.exitCode = exitCode;
+  }
+}
+
+// src/lib/chromium.ts
+import { existsSync } from "node:fs";
+
+// src/lib/tool-probe.ts
+import { platform } from "node:os";
+
+// src/lib/exec.ts
+import { spawn } from "node:child_process";
+import { join, resolve as resolvePath, delimiter } from "node:path";
+function buildEnhancedPath(dir, existingPath, sep = delimiter) {
+  return `${dir}${sep}${existingPath}`;
+}
+var localBin = resolvePath(join(import.meta.dirname, "..", "..", "node_modules", ".bin"));
+var enhancedPath = buildEnhancedPath(localBin, process.env.PATH ?? "");
+function enhancedEnv() {
+  return { ...process.env, PATH: enhancedPath };
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, { stdio: "inherit", cwd: opts.cwd, env: enhancedEnv() });
+    p.on("error", reject);
+    p.on("exit", (code) => {
+      if (code === 0)
+        return resolve();
+      const cwd = opts.cwd ?? process.cwd();
+      reject(new Error(`${cmd} ${args.join(" ")} (cwd=${cwd}) exited ${code}`));
+    });
+  });
+}
+var EXIT_FLUSH_GRACE_MS = 2000;
+function keepTail(buffer, chunk, limit) {
+  const joined = buffer + chunk;
+  return limit !== undefined && joined.length > limit ? joined.slice(-limit) : joined;
+}
+function spawnCapture(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: opts.cwd,
+      env: opts.env
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let exited = false;
+    let exitCode = null;
+    let exitSignal = null;
+    let killTimer;
+    let graceTimer;
+    const settle = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      if (killTimer)
+        clearTimeout(killTimer);
+      if (graceTimer)
+        clearTimeout(graceTimer);
+      fn();
+    };
+    const armKill = () => {
+      if (!opts.timeoutMs)
+        return;
+      if (killTimer)
+        clearTimeout(killTimer);
+      killTimer = setTimeout(() => {
+        settle(() => {
+          p.kill("SIGKILL");
+          reject(new Error(opts.timeoutMode === "idle" ? `${cmd} produced no output for ${opts.timeoutMs}ms and was stopped` : `${cmd} ${args.join(" ")} timed out after ${opts.timeoutMs}ms`));
+        });
+      }, opts.timeoutMs);
+      killTimer.unref();
+    };
+    armKill();
+    const finish = () => settle(() => resolve({ code: exitCode, signal: exitSignal, stdout, stderr }));
+    const armGrace = () => {
+      if (graceTimer)
+        clearTimeout(graceTimer);
+      graceTimer = setTimeout(finish, opts.exitGraceMs ?? EXIT_FLUSH_GRACE_MS);
+      graceTimer.unref();
+    };
+    const onData = (stream) => (d) => {
+      const text = d.toString();
+      if (stream === "stdout")
+        stdout = keepTail(stdout, text, opts.captureLimit);
+      else
+        stderr = keepTail(stderr, text, opts.captureLimit);
+      opts.onChunk?.(stream, text);
+      if (exited)
+        armGrace();
+      else if (opts.timeoutMode === "idle")
+        armKill();
+    };
+    p.stdout.on("data", onData("stdout"));
+    p.stderr.on("data", onData("stderr"));
+    p.on("error", (err) => settle(() => reject(err)));
+    p.on("exit", (code, signal) => {
+      exited = true;
+      exitCode = code;
+      exitSignal = signal;
+      if (killTimer) {
+        clearTimeout(killTimer);
+        killTimer = undefined;
+      }
+      armGrace();
+    });
+    p.on("close", finish);
+  });
+}
+async function execCapture(cmd, args, opts = {}) {
+  const { code, signal, stdout, stderr } = await spawnCapture(cmd, args, {
+    cwd: opts.cwd,
+    env: enhancedEnv(),
+    timeoutMs: opts.timeoutMs
+  });
+  if (code === 0)
+    return { stdout, stderr };
+  throw new Error(code === null ? `${cmd} was killed by signal ${signal}
+${stderr}` : `${cmd} exited ${code}
+${stderr}`);
+}
+
+// src/lib/tool-probe.ts
+var IS_WINDOWS = platform() === "win32";
+var PROBE_CMD = IS_WINDOWS ? "where.exe" : "which";
+async function isToolAvailable(tool) {
+  try {
+    await execCapture(PROBE_CMD, [tool]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findTool(tool) {
+  try {
+    const { stdout } = await execCapture(PROBE_CMD, [tool]);
+    const firstLine = stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
+    return firstLine?.trim() || undefined;
+  } catch {
+    return;
+  }
+}
+
+// src/lib/install-hints.ts
+var INSTALL_HINTS = {
+  chromium: {
+    label: "Google Chrome, Chromium, or Microsoft Edge",
+    body: `  macOS:   brew install --cask google-chrome
+` + `  Ubuntu:  sudo apt install -y chromium-browser
+` + "  Windows: https://www.google.com/chrome/  (Edge is auto-detected if pre-installed)"
+  },
+  gs: {
+    label: "Ghostscript",
+    body: `  macOS:   brew install ghostscript
+` + `  Ubuntu:  sudo apt install -y ghostscript
+` + "  Windows: https://www.ghostscript.com/releases/gsdnld.html  (standard installs are auto-detected; or: choco install ghostscript)"
+  },
+  qpdf: {
+    label: "qpdf",
+    body: `  macOS:   brew install qpdf
+` + `  Ubuntu:  sudo apt install -y qpdf
+` + "  Windows: choco install qpdf  (or: https://github.com/qpdf/qpdf/releases)"
+  }
+};
+function fullInstallHint(tool) {
+  const hint = INSTALL_HINTS[tool];
+  return `Install ${hint.label}:
+${hint.body}`;
+}
+
+// src/lib/chromium.ts
+var SYSTEM_PATHS = [
+  process.env.CHROMIUM_PATH,
+  process.env.PUPPETEER_EXECUTABLE_PATH,
+  "/usr/bin/google-chrome",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser",
+  "/snap/bin/chromium",
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/opt/homebrew/bin/chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+  "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+  process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe` : undefined,
+  "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+  "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+  process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\Microsoft\\Edge\\Application\\msedge.exe` : undefined,
+  process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe` : undefined
+].filter(Boolean);
+var PATH_CANDIDATES = [
+  "google-chrome",
+  "google-chrome-stable",
+  "chromium",
+  "chromium-browser",
+  "chrome",
+  "chrome.exe",
+  "msedge",
+  "msedge.exe",
+  "brave",
+  "brave-browser",
+  "brave.exe",
+  "vivaldi",
+  "vivaldi-stable",
+  "vivaldi.exe",
+  "opera",
+  "opera-stable",
+  "opera.exe"
+];
+async function resolveChromiumExecutable() {
+  for (const candidate of SYSTEM_PATHS) {
+    if (existsSync(candidate))
+      return candidate;
+  }
+  for (const candidate of PATH_CANDIDATES) {
+    const found = await findTool(candidate);
+    if (found)
+      return found;
+  }
+  return;
+}
+async function requireChromiumExecutable() {
+  const found = await resolveChromiumExecutable();
+  if (found)
+    return found;
+  throw new Error([
+    "No Chrome / Chromium / Edge binary found. Gutterpress needs a Chromium-based browser to render PDFs.",
+    "",
+    "Install one of:",
+    INSTALL_HINTS.chromium.body,
+    "",
+    "Or point to an existing install:",
+    "  CHROMIUM_PATH=/path/to/chrome gutterpress build ...",
+    "",
+    "The Gutterpress desktop app uses its own bundled browser for BOTH",
+    "PDF export and needs no separate install.",
+    "This message is about the CLI, which does need one."
+  ].join(`
+`));
+}
+
+// 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 as spawn2 } from "node:child_process";
+import { existsSync as existsSync2, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } 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 (existsSync2(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(join2(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 = spawn2(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/lib/embedded-assets.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdtemp, mkdir, writeFile, readFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname, join as join3, 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-fnqb2y4v.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(join3(tmpdir2(), "gutterpress-assets-"));
+  for (const [relPath, srcPath] of Object.entries(EMBEDDED_ASSETS)) {
+    const dest = join3(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 (existsSync3(join3(root, SENTINEL_ASSET))) {
+        return root;
+      }
+    } catch {}
+    extractPromise = null;
+  }
+  extractPromise = extractAssets();
+  return extractPromise;
+}
+async function getAssetPath(relPath) {
+  const root = await getAssetsDir();
+  return join3(root, relPath);
+}
+
+export { EXIT_CODES, BuildError, run, spawnCapture, execCapture, isToolAvailable, findTool, INSTALL_HINTS, fullInstallHint, resolveChromiumExecutable, requireChromiumExecutable, RENDER_TIMEOUT_MS, prewarmBrowser, getBrowser, closeBrowser, getAssetPath, REQUIRED_MILESTONE, assertMilestone, readyProbeExpr, DEFAULT_PRINT_OPTS, launchChromium, connectChromium };