gutterpress 0.0.0

package/dist/cli-h7phg3ka.js

@@ -0,0 +1,746 @@
+import {
+  package_default
+} from "./cli-hvqjs342.js";
+import {
+  __require
+} from "./cli-37x76zdn.js";
+
+// src/utils/logger.ts
+var currentLevel = "INFO";
+var LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function emit(level, message, ...args) {
+  if (LEVELS[level] < LEVELS[currentLevel])
+    return;
+  const colors = {
+    DEBUG: "\x1B[36m",
+    INFO: "\x1B[32m",
+    WARN: "\x1B[33m",
+    ERROR: "\x1B[31m"
+  };
+  const reset = "\x1B[0m";
+  const timestamp = new Date().toISOString().slice(11, 19);
+  const prefix = `${colors[level]}[${timestamp}] ${level}${reset}:`;
+  if (level === "ERROR") {
+    console.error(prefix, message, ...args);
+  } else {
+    console.log(prefix, message, ...args);
+  }
+}
+function debug(message, ...args) {
+  emit("DEBUG", message, ...args);
+}
+function info(message, ...args) {
+  emit("INFO", message, ...args);
+}
+function warn(message, ...args) {
+  emit("WARN", message, ...args);
+}
+function error(message, ...args) {
+  emit("ERROR", message, ...args);
+}
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var log = {
+  info(msg, ...args) {
+    console.log(`${CYAN}info${RESET}  ${msg}`, ...args);
+  },
+  warn(msg, ...args) {
+    console.warn(`${YELLOW}warn${RESET}  ${msg}`, ...args);
+  },
+  error(msg, ...args) {
+    console.error(`${RED}${BOLD}error${RESET} ${msg}`, ...args);
+  },
+  success(msg, ...args) {
+    console.log(`${GREEN}ok${RESET}    ${msg}`, ...args);
+  }
+};
+
+// src/lib/remote-auth/token-store.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function credentialHostKey(hostOrUrl) {
+  const trimmed = String(hostOrUrl ?? "").trim();
+  if (!trimmed)
+    return "";
+  const scp = /^[\w.-]+@([\w.][\w.-]*):/.exec(trimmed);
+  if (scp)
+    return stripWww(scp[1].toLowerCase());
+  const candidate = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  try {
+    const url = new URL(candidate);
+    if (!url.hostname)
+      return "";
+    const host = url.port ? `${url.hostname}:${url.port}`.toLowerCase() : url.hostname.toLowerCase();
+    return stripWww(host);
+  } catch {
+    return "";
+  }
+}
+function stripWww(host) {
+  return host.startsWith("www.") && host.length > 4 ? host.slice(4) : host;
+}
+function defaultConfigDir() {
+  const override = process.env.GUTTERPRESS_CONFIG_DIR?.trim();
+  if (override)
+    return override;
+  if (process.platform === "win32" && process.env.APPDATA) {
+    return path.join(process.env.APPDATA, "gutterpress");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  return path.join(xdg || path.join(os.homedir(), ".config"), "gutterpress");
+}
+
+class FileTokenStore {
+  filePath;
+  queue = Promise.resolve();
+  constructor(filePath) {
+    this.filePath = filePath ?? path.join(defaultConfigDir(), "credentials.json");
+  }
+  async read() {
+    let raw;
+    try {
+      raw = await readFile(this.filePath, "utf8");
+    } catch (e) {
+      if (e?.code === "ENOENT") {
+        return { version: 1, credentials: {} };
+      }
+      throw e;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && parsed.credentials)
+        return parsed;
+    } catch {
+      await writeFile(`${this.filePath}.corrupt`, raw, {
+        encoding: "utf8",
+        mode: 384
+      }).catch(() => {});
+    }
+    return { version: 1, credentials: {} };
+  }
+  async write(data) {
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    const tmpPath = `${this.filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(data, null, 2), {
+      encoding: "utf8",
+      mode: 384
+    });
+    await rename(tmpPath, this.filePath);
+    await chmod(this.filePath, 384);
+  }
+  enqueue(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  get(host) {
+    return this.enqueue(async () => {
+      try {
+        const data = await this.read();
+        return data.credentials[normalizeHost(host)] ?? null;
+      } catch {
+        return null;
+      }
+    });
+  }
+  set(host, credential) {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      data.credentials[normalizeHost(host)] = credential;
+      await this.write(data);
+    });
+  }
+  delete(host) {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      delete data.credentials[normalizeHost(host)];
+      await this.write(data);
+    });
+  }
+  list() {
+    return this.enqueue(async () => {
+      try {
+        const data = await this.read();
+        return Object.values(data.credentials);
+      } catch {
+        return [];
+      }
+    });
+  }
+}
+function normalizeHost(host) {
+  return host.trim().toLowerCase();
+}
+function extractUrlCredential(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { cleanUrl: url };
+  }
+  if (!/^https?:$/.test(parsed.protocol))
+    return { cleanUrl: url };
+  if (!parsed.username && !parsed.password)
+    return { cleanUrl: url };
+  const token = parsed.password ? decodeURIComponent(parsed.password) : decodeURIComponent(parsed.username);
+  const username = parsed.password ? decodeURIComponent(parsed.username) : undefined;
+  parsed.username = "";
+  parsed.password = "";
+  const credential = {
+    host: credentialHostKey(parsed.toString()),
+    kind: "token",
+    token,
+    ...username ? { username } : {},
+    createdAt: Date.now()
+  };
+  return { cleanUrl: parsed.toString(), credential };
+}
+
+// src/lib/diagnostics.ts
+import { platform as platform2, arch, release } from "node:os";
+
+// 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 includes its own browser and needs no separate browser installation."
+  ].join(`
+`));
+}
+
+// src/lib/ghostscript.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2, writeFile as writeFile2, unlink, rename as rename2, readdir } from "node:fs/promises";
+import { join as join2, basename, resolve } from "node:path";
+var WINDOWS_GHOSTSCRIPT_NAMES = ["gswin64c", "gswin32c", "gs"];
+var POSIX_GHOSTSCRIPT_NAMES = ["gs"];
+function envValue(env, name) {
+  const direct = env[name]?.trim();
+  if (direct)
+    return direct;
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key]?.trim() || undefined : undefined;
+}
+async function findWindowsGhostscriptInstall(env) {
+  const roots = [
+    envValue(env, "ProgramW6432"),
+    envValue(env, "ProgramFiles"),
+    "C:\\Program Files",
+    envValue(env, "ProgramFiles(x86)"),
+    "C:\\Program Files (x86)"
+  ];
+  const seen = new Set;
+  for (const root of roots) {
+    if (!root || seen.has(root.toLowerCase()))
+      continue;
+    seen.add(root.toLowerCase());
+    const installRoot = join2(root, "gs");
+    let versions;
+    try {
+      versions = (await readdir(installRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && /^gs\d/i.test(entry.name)).sort((a, b) => b.name.localeCompare(a.name, undefined, { numeric: true }));
+    } catch {
+      continue;
+    }
+    for (const version of versions) {
+      for (const executable of ["gswin64c.exe", "gswin32c.exe"]) {
+        const candidate = join2(installRoot, version.name, "bin", executable);
+        if (existsSync2(candidate))
+          return candidate;
+      }
+    }
+  }
+  return;
+}
+async function resolveGhostscript(targetPlatform = process.platform, env = process.env) {
+  const override = envValue(env, "GHOSTSCRIPT_PATH");
+  if (override && existsSync2(override))
+    return override;
+  const names = targetPlatform === "win32" ? WINDOWS_GHOSTSCRIPT_NAMES : POSIX_GHOSTSCRIPT_NAMES;
+  for (const name of names) {
+    const found = await findTool(name);
+    if (found)
+      return found;
+  }
+  return targetPlatform === "win32" ? findWindowsGhostscriptInstall(env) : undefined;
+}
+async function stripAnnotations(pdfPath, stagingDir) {
+  const tmp = join2(stagingDir, "annotations-stripped.pdf");
+  try {
+    await run("qpdf", [pdfPath, tmp, "--flatten-annotations=all"]);
+    await rename2(tmp, pdfPath);
+  } finally {
+    await unlink(tmp).catch(() => {});
+  }
+}
+function makePdfxDefPs(params) {
+  const pdfxVersion = params.pdfx === "x3" ? "PDF/X-3:2002" : "PDF/X-1:2001";
+  const pdfxConformance = params.pdfx === "x1a" ? "PDF/X-1a:2001" : null;
+  const outputCondition = "CGATS21_CRPC1";
+  const outputConditionId = params.pdfx === "x1a" ? "CGATS TR001" : outputCondition;
+  const maxTacNorm = ((params.maxTac ?? 240) / 100).toFixed(1);
+  const normalizedIccPath = params.iccPath.replace(/\\/g, "/");
+  const iccComponents = 4;
+  const docInfoConformance = pdfxConformance ? `/GTS_PDFXConformance (${pdfxConformance})
+` : "";
+  return `
+%!
+% pdfx_def.ps generated by gutterpress
+% Based on the Ghostscript PDF/X approach with custom GCR for TAC limiting
+
+/ICCProfile (${normalizedIccPath}) def
+
+% Maximum TAC = ${maxTacNorm} (${params.maxTac ?? 240}%)
+/MaxTAC ${maxTacNorm} def
+
+% UCR (Undercolor Removal) - aggressive GCR to reduce CMY in dark areas
+% Takes K value, returns amount to subtract from CMY
+/UCR {
+  % For dark colors, remove more CMY
+  dup 0.2 gt {
+    0.2 sub 1.5 mul  % Remove 150% of K above 0.2 from CMY
+    1 min 0 max
+  } {
+    pop 0
+  } ifelse
+} bind def
+
+% BG (Black Generation) - standard K generation
+/BG {
+  % Pass through K value
+} bind def
+
+% Set UCR and BG functions for color conversion
+<< /UCRFunction { UCR } /BGFunction { BG } >> setpagedevice
+
+[/Title (${params.title})
+/Creator (gutterpress)
+/GTS_PDFXVersion (${pdfxVersion})
+/Trapped /False
+${docInfoConformance}/DOCINFO pdfmark
+
+[/_objdef {icc_PDFX} /type /stream /OBJ pdfmark
+[{icc_PDFX} << /N ${iccComponents} >> /PUT pdfmark
+[{icc_PDFX} ICCProfile (r) file /PUT pdfmark
+
+[/_objdef {OutputIntent_PDFX} /type /dict /OBJ pdfmark
+
+[{OutputIntent_PDFX} <<
+  /Type /OutputIntent
+  /S /GTS_PDFX
+  /OutputConditionIdentifier (${outputConditionId})
+  /OutputCondition (${outputCondition})
+  /Info (${outputCondition})
+  /RegistryName (http://www.color.org)
+  /DestOutputProfile {icc_PDFX}
+>> /PUT pdfmark
+
+[{Catalog} << /OutputIntents [ {OutputIntent_PDFX} ] >> /PUT pdfmark
+`;
+}
+async function stampCreator(pdfPath) {
+  const { PDFDocument } = await import("pdf-lib");
+  const bytes = await readFile2(pdfPath);
+  const doc = await PDFDocument.load(bytes, { updateMetadata: false });
+  doc.setCreator("gutterpress");
+  const out = await doc.save();
+  await writeFile2(pdfPath, out);
+}
+async function convertToPdfxCmyk(inputPdf, outPdf, config) {
+  const iccPath = resolve(config.iccPath);
+  const tmpDef = join2(config.stagingDir, "pdfx-def.ps");
+  const args = [
+    "-dSAFER",
+    `--permit-file-read=${iccPath}`,
+    "-dBATCH",
+    "-dNOPAUSE",
+    "-sDEVICE=pdfwrite",
+    "-dPDFX",
+    "-dCompatibilityLevel=1.3",
+    "-dEmbedAllFonts=true",
+    "-dSubsetFonts=true",
+    "-dCompressFonts=true",
+    "-dDetectDuplicateImages=true",
+    "-dDownsampleColorImages=false",
+    "-dDownsampleGrayImages=false",
+    "-dDownsampleMonoImages=false",
+    "-sProcessColorModel=DeviceCMYK",
+    "-sColorConversionStrategy=CMYK",
+    "-dOverrideICC=true",
+    `-sOutputICCProfile=${iccPath}`,
+    `-sOutputFile=${outPdf}`,
+    tmpDef,
+    inputPdf
+  ];
+  try {
+    await writeFile2(tmpDef, makePdfxDefPs({
+      iccPath,
+      pdfx: config.pdfx,
+      title: config.title ?? basename(outPdf),
+      maxTac: config.maxTac
+    }), "utf8");
+    const ghostscript = await resolveGhostscript();
+    if (!ghostscript) {
+      throw new Error("Ghostscript executable not found. Install Ghostscript or set GHOSTSCRIPT_PATH to its command-line executable.");
+    }
+    await run(ghostscript, args);
+  } finally {
+    await unlink(tmpDef).catch(() => {});
+  }
+}
+
+// src/lib/version.ts
+var PACKAGE_META = {
+  version: package_default.version ?? "unknown",
+  dependencies: package_default.dependencies ?? {},
+  devDependencies: package_default.devDependencies ?? {}
+};
+var PACKAGE_VERSION = PACKAGE_META.version;
+
+// src/lib/diagnostics.ts
+var INSTALL_HINTS2 = {
+  chromium: `${fullInstallHint("chromium")}
+Or set CHROMIUM_PATH=/path/to/chrome`,
+  gs: `${fullInstallHint("gs")}
+Or set GHOSTSCRIPT_PATH=/path/to/ghostscript`,
+  qpdf: fullInstallHint("qpdf")
+};
+var TOOLS_TO_PROBE = [
+  {
+    id: "gs",
+    bin: "gs",
+    name: "Ghostscript",
+    hintKey: "gs",
+    usedBy: [
+      { feature: "PDF/X CMYK conversion (build --format pdfx)", severity: "required" },
+      { feature: "validate: pdf.print.ink-coverage, asset.image-tac", severity: "optional" }
+    ]
+  },
+  {
+    id: "qpdf",
+    bin: "qpdf",
+    name: "qpdf",
+    hintKey: "qpdf",
+    usedBy: [
+      { feature: "PDF/X annotation stripping (build --format pdfx)", severity: "required" },
+      { feature: "validate: PDF/X OutputIntent + metadata checks", severity: "optional" }
+    ]
+  }
+];
+var GET_VERSION_TIMEOUT_MS = 2000;
+async function getVersion(bin, args = ["--version"]) {
+  try {
+    const { stdout, stderr } = await execCapture(bin, args, { timeoutMs: GET_VERSION_TIMEOUT_MS });
+    const combined = (stdout || stderr).trim();
+    return combined.split(/\r?\n/)[0]?.trim() || undefined;
+  } catch {
+    return;
+  }
+}
+async function getSystemDiagnostics() {
+  const libVersion = PACKAGE_VERSION;
+  const chromiumPath = await resolveChromiumExecutable();
+  const chromiumVersion = undefined;
+  const chromium = {
+    id: "chromium",
+    name: "Chromium-based browser",
+    bin: "chrome / chromium / msedge",
+    found: !!chromiumPath,
+    path: chromiumPath,
+    version: chromiumVersion,
+    usedBy: [
+      { feature: "Save PDF (every PDF render)", severity: "required" }
+    ],
+    installHint: INSTALL_HINTS2.chromium
+  };
+  const ghostscriptPath = await resolveGhostscript();
+  const tools = await Promise.all(TOOLS_TO_PROBE.map(async (t) => {
+    if (t.id === "gs") {
+      return {
+        id: t.id,
+        name: t.name,
+        bin: t.bin,
+        found: !!ghostscriptPath,
+        path: ghostscriptPath,
+        version: ghostscriptPath ? await getVersion(ghostscriptPath) : undefined,
+        usedBy: t.usedBy,
+        installHint: INSTALL_HINTS2[t.hintKey]
+      };
+    }
+    const [path2, available] = await Promise.all([
+      findTool(t.bin),
+      isToolAvailable(t.bin)
+    ]);
+    const found = available || !!path2;
+    const version = found ? await getVersion(t.bin) : undefined;
+    return {
+      id: t.id,
+      name: t.name,
+      bin: t.bin,
+      found,
+      path: path2,
+      version,
+      usedBy: t.usedBy,
+      installHint: INSTALL_HINTS2[t.hintKey]
+    };
+  }));
+  return {
+    libVersion,
+    platform: {
+      os: platform2(),
+      arch: arch(),
+      release: release(),
+      node: process.versions.node
+    },
+    tools: [chromium, ...tools],
+    configDir: defaultConfigDir(),
+    docsUrl: "https://github.com/dimm-city/gutterpress/blob/main/examples/gutterpress-user-guide/08-system-setup.md"
+  };
+}
+
+export { setLogLevel, debug, info, warn, error, log, spawnCapture, execCapture, isToolAvailable, INSTALL_HINTS, resolveChromiumExecutable, requireChromiumExecutable, resolveGhostscript, stripAnnotations, stampCreator, convertToPdfxCmyk, PACKAGE_META, PACKAGE_VERSION, credentialHostKey, defaultConfigDir, FileTokenStore, extractUrlCredential, getSystemDiagnostics };