print-check-cli 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025-2026, Ryan Calacsan
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# print-check-cli
+
+[![CI](https://github.com/ryancalacsan/print-check-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/ryancalacsan/print-check-cli/actions/workflows/ci.yml)
+
+A Node.js + TypeScript CLI tool that validates print-ready PDF files. Runs eight checks and reports pass/warn/fail results in the terminal.
+
+## Checks
+
+| Check | What it validates |
+|---|---|
+| **Bleed & Trim** | TrimBox/BleedBox presence and minimum bleed dimensions |
+| **Fonts** | Font embedding status (embedded, subset, or missing) |
+| **Color Space** | CMYK compliance, RGB detection, spot color reporting |
+| **Resolution** | Raster image DPI against a configurable minimum |
+| **PDF/X Compliance** | PDF/X standard detection (OutputIntents, version, output condition) — info only |
+| **Total Ink Coverage** | Maximum ink density (C+M+Y+K %) against configurable limit |
+| **Transparency** | Detects unflattened transparency (groups, soft masks, blend modes) |
+| **Page Size** | Verifies consistent page dimensions and optional expected size match |
+
+## Usage
+
+```
+print-check <file.pdf ...> [options]
+
+Options:
+  --min-dpi <number>       Minimum acceptable DPI (default: 300)
+  --color-space <mode>     Expected color space: cmyk | any (default: cmyk)
+  --bleed <mm>             Required bleed in mm (default: 3)
+  --max-tac <percent>      Maximum total ink coverage % (default: 300)
+  --page-size <WxH>        Expected page size in mm (e.g. 210x297)
+  --checks <list>          Comma-separated checks to run (default: all)
+  --severity <overrides>   Per-check severity: check:level,... (fail|warn|off)
+  --profile <name>         Print profile: standard | magazine | newspaper | large-format
+  --verbose                Show detailed per-page results
+  --format <type>          Output format: text | json (default: text)
+  -V, --version            Output version
+  -h, --help               Show help
+```
+
+### Examples
+
+```bash
+# Run all checks with defaults
+print-check flyer.pdf
+
+# Verbose output with custom DPI threshold
+print-check flyer.pdf --verbose --min-dpi 150
+
+# Run only font and bleed checks
+print-check flyer.pdf --checks fonts,bleed
+
+# Skip color space enforcement
+print-check flyer.pdf --color-space any
+
+# JSON output for CI pipelines
+print-check flyer.pdf --format json
+
+# Use a built-in profile
+print-check flyer.pdf --profile magazine
+
+# Profile with explicit override
+print-check flyer.pdf --profile newspaper --min-dpi 300
+
+# Check multiple files at once
+print-check flyer.pdf poster.pdf brochure.pdf
+
+# Use shell globbing to check all PDFs in a directory
+print-check *.pdf
+
+# Multiple files with JSON output (outputs an array of reports)
+print-check *.pdf --format json
+```
+
+### Profiles
+
+Built-in profiles provide preset thresholds for common print scenarios. Explicit CLI flags override profile defaults.
+
+| Profile | minDpi | colorSpace | bleedMm | maxTac | Use case |
+|---------|--------|------------|---------|--------|----------|
+| `standard` | 300 | cmyk | 3 | 300 | General commercial print (default) |
+| `magazine` | 300 | cmyk | 5 | 300 | Magazine / perfect-bound |
+| `newspaper` | 150 | any | 0 | 240 | Newsprint / low-fidelity |
+| `large-format` | 150 | cmyk | 5 | 300 | Banners, posters, signage |
+
+### Exit codes
+
+- `0` — all checks passed (or warned)
+- `1` — one or more checks failed
+
+### Severity Overrides
+
+Override the default severity for any check using `--severity`:
+
+```bash
+# Downgrade font failures to warnings (exit 0)
+print-check flyer.pdf --severity fonts:warn
+
+# Skip transparency check entirely
+print-check flyer.pdf --severity transparency:off
+
+# Multiple overrides
+print-check flyer.pdf --severity fonts:warn,transparency:off
+```
+
+| Level | Behavior |
+|-------|----------|
+| `fail` | Default — no change to check result |
+| `warn` | Downgrade any `fail` result to `warn` (exit 0) |
+| `off` | Skip the check entirely |
+
+Available check names: `bleed`, `fonts`, `colorspace`, `resolution`, `pdfx`, `tac`, `transparency`, `pagesize`.
+
+## Configuration
+
+Create a config file to set default options for your project:
+
+### `.printcheckrc` / `.printcheckrc.json`
+```json
+{
+  "minDpi": 300,
+  "colorSpace": "cmyk",
+  "bleed": 5,
+  "maxTac": 300,
+  "checks": "bleed,fonts,colorspace",
+  "profile": "magazine",
+  "severity": {
+    "fonts": "warn",
+    "transparency": "off"
+  }
+}
+```
+
+### `printcheck.config.js`
+```js
+export default {
+  minDpi: 150,
+  colorSpace: "any",
+  bleed: 0,
+  profile: "newspaper",
+};
+```
+
+Config files are auto-discovered from the current directory upward.
+CLI flags always override config file values.
+
+## Tech Stack
+
+| Package | Purpose |
+|---|---|
+| [mupdf](https://www.npmjs.com/package/mupdf) (mupdf.js) | PDF engine — WASM-powered, deep PDF object traversal |
+| [pdf-lib](https://www.npmjs.com/package/pdf-lib) | Supplemental — reading page boxes (TrimBox, BleedBox, etc.) |
+| [commander](https://www.npmjs.com/package/commander) | CLI framework |
+| [picocolors](https://www.npmjs.com/package/picocolors) | Terminal colors |
+| [zod](https://www.npmjs.com/package/zod) | CLI option validation |
+| [tsup](https://www.npmjs.com/package/tsup) | TypeScript build |
+| [vitest](https://www.npmjs.com/package/vitest) | Testing |
+
+## Project Structure
+
+```
+src/
+├── index.ts                # CLI entry point (Commander setup)
+├── types.ts                # Shared interfaces (CheckResult, CheckOptions, etc.)
+├── checks/
+│   ├── index.ts            # Re-exports all checks
+│   ├── bleed-trim.ts       # Page box validation (pdf-lib)
+│   ├── fonts.ts            # Font embedding check (mupdf)
+│   ├── colorspace.ts       # Color space detection (mupdf)
+│   ├── resolution.ts       # Image DPI check (mupdf)
+│   ├── pdfx-compliance.ts  # PDF/X standard detection (mupdf)
+│   ├── tac.ts              # Total ink coverage check (mupdf)
+│   ├── transparency.ts     # Transparency detection check (mupdf)
+│   └── page-size.ts        # Page size consistency check (pdf-lib)
+├── engine/
+│   ├── pdf-engine.ts       # Unified PDF document loader (mupdf + pdf-lib)
+│   └── pdf-utils.ts        # Safe wrappers for mupdf PDFObject API
+└── reporter/
+    ├── console.ts          # Terminal output formatter
+    └── json.ts             # JSON output formatter (--format json)
+```
+
+## Development
+
+```bash
+npm install           # Install dependencies
+npm run dev -- <file> # Run via tsx (no build needed)
+npm run build         # Build to dist/
+npm test              # Run vitest
+```
+
+## Known Limitations (MVP)
+
+- **mupdf PDFObject nulls** — mupdf.js returns PDFObject wrappers with `.isNull() === true` rather than JavaScript `null`. All mupdf access goes through `src/engine/pdf-utils.ts` safe wrappers to handle this.
+

package/dist/index.js

@@ -0,0 +1,974 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { z as z2 } from "zod";
+import * as fs3 from "fs";
+import * as path2 from "path";
+
+// src/checks/bleed-trim.ts
+var PT_TO_MM = 25.4 / 72;
+var checkBleedTrim = async (engines, options) => {
+  const { pdfLib } = engines;
+  const pages = pdfLib.getPages();
+  const details = [];
+  let worstStatus = "pass";
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
+    const pageNum = i + 1;
+    const mediaBox = page.getMediaBox();
+    const trimBox = page.getTrimBox();
+    const bleedBox = page.getBleedBox();
+    const hasTrimBox = trimBox.x !== mediaBox.x || trimBox.y !== mediaBox.y || trimBox.width !== mediaBox.width || trimBox.height !== mediaBox.height;
+    const hasBleedBox = bleedBox.x !== mediaBox.x || bleedBox.y !== mediaBox.y || bleedBox.width !== mediaBox.width || bleedBox.height !== mediaBox.height;
+    if (!hasTrimBox && !hasBleedBox) {
+      details.push({
+        page: pageNum,
+        message: "No TrimBox or BleedBox defined (only MediaBox found)",
+        status: "warn"
+      });
+      if (worstStatus === "pass") worstStatus = "warn";
+      continue;
+    }
+    if (!hasTrimBox) {
+      details.push({
+        page: pageNum,
+        message: "No TrimBox defined",
+        status: "warn"
+      });
+      if (worstStatus === "pass") worstStatus = "warn";
+      continue;
+    }
+    const refBox = hasBleedBox ? bleedBox : mediaBox;
+    const bleedLeft = (trimBox.x - refBox.x) * PT_TO_MM;
+    const bleedBottom = (trimBox.y - refBox.y) * PT_TO_MM;
+    const bleedRight = (refBox.x + refBox.width - (trimBox.x + trimBox.width)) * PT_TO_MM;
+    const bleedTop = (refBox.y + refBox.height - (trimBox.y + trimBox.height)) * PT_TO_MM;
+    const minBleed = Math.min(bleedLeft, bleedBottom, bleedRight, bleedTop);
+    const requiredMm = options.bleedMm;
+    if (minBleed < requiredMm) {
+      const sides = [];
+      if (bleedLeft < requiredMm) sides.push(`left: ${bleedLeft.toFixed(1)}mm`);
+      if (bleedRight < requiredMm)
+        sides.push(`right: ${bleedRight.toFixed(1)}mm`);
+      if (bleedTop < requiredMm) sides.push(`top: ${bleedTop.toFixed(1)}mm`);
+      if (bleedBottom < requiredMm)
+        sides.push(`bottom: ${bleedBottom.toFixed(1)}mm`);
+      details.push({
+        page: pageNum,
+        message: `Insufficient bleed (need ${requiredMm}mm): ${sides.join(", ")}`,
+        status: "fail"
+      });
+      worstStatus = "fail";
+    } else {
+      details.push({
+        page: pageNum,
+        message: `Bleed OK (min ${minBleed.toFixed(1)}mm)`,
+        status: "pass"
+      });
+    }
+  }
+  const summary = worstStatus === "pass" ? `All pages have ${options.bleedMm}mm+ bleed` : worstStatus === "warn" ? "TrimBox or BleedBox missing on some pages" : "Insufficient bleed on some pages";
+  return { check: "Bleed & Trim", status: worstStatus, summary, details };
+};
+
+// src/engine/pdf-utils.ts
+function safeResolve(obj) {
+  if (!obj || obj.isNull()) return void 0;
+  return obj.resolve();
+}
+function safeGet(obj, key) {
+  if (!obj || obj.isNull()) return void 0;
+  const val = obj.get(key);
+  if (!val || val.isNull()) return void 0;
+  return val;
+}
+function safeGetResolved(obj, key) {
+  const val = safeGet(obj, key);
+  return val ? safeResolve(val) : void 0;
+}
+function safeName(obj) {
+  if (!obj || obj.isNull()) return void 0;
+  if (obj.isName()) return obj.asName();
+  return void 0;
+}
+function safeString(obj) {
+  if (!obj || obj.isNull()) return void 0;
+  if (obj.isString()) return obj.asString();
+  if (obj.isName()) return obj.asName();
+  return void 0;
+}
+function safeForEach(obj, callback) {
+  if (!obj || obj.isNull()) return;
+  obj.forEach(callback);
+}
+
+// src/checks/fonts.ts
+function collectFonts(fontDict, pageNum, seen) {
+  const fonts = [];
+  safeForEach(fontDict, (value, key) => {
+    const font = safeResolve(value);
+    if (!font) return;
+    const baseFontName = safeName(safeGet(font, "BaseFont")) ?? key;
+    if (seen.has(baseFontName)) return;
+    seen.add(baseFontName);
+    const subtype = safeName(safeGet(font, "Subtype"));
+    if (subtype === "Type0") {
+      const descendants = safeGet(font, "DescendantFonts");
+      if (descendants) {
+        for (let i = 0; i < descendants.length; i++) {
+          const cidFont = safeResolve(descendants.get(i));
+          if (!cidFont) continue;
+          const cidName = safeName(safeGet(cidFont, "BaseFont")) ?? baseFontName;
+          const descriptor2 = safeGetResolved(cidFont, "FontDescriptor");
+          const embedded2 = hasEmbeddedFile(descriptor2);
+          const subset2 = /^[A-Z]{6}\+/.test(cidName);
+          fonts.push({ name: cidName, embedded: embedded2, subset: subset2, page: pageNum });
+        }
+      }
+      return;
+    }
+    const descriptor = safeGetResolved(font, "FontDescriptor");
+    const embedded = hasEmbeddedFile(descriptor);
+    const subset = /^[A-Z]{6}\+/.test(baseFontName);
+    fonts.push({ name: baseFontName, embedded, subset, page: pageNum });
+  });
+  return fonts;
+}
+function hasEmbeddedFile(descriptor) {
+  if (!descriptor) return false;
+  return !!(safeGet(descriptor, "FontFile") || safeGet(descriptor, "FontFile2") || safeGet(descriptor, "FontFile3"));
+}
+var checkFonts = async (engines) => {
+  const { mupdf: doc } = engines;
+  const details = [];
+  const seen = /* @__PURE__ */ new Set();
+  const allFonts = [];
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    const pageObj = doc.findPage(i);
+    const resources = safeGetResolved(pageObj, "Resources");
+    if (!resources) continue;
+    const fontDict = safeGetResolved(resources, "Font");
+    if (!fontDict) continue;
+    const pageFonts = collectFonts(fontDict, i + 1, seen);
+    allFonts.push(...pageFonts);
+  }
+  let worstStatus = "pass";
+  const notEmbedded = allFonts.filter((f) => !f.embedded);
+  const subsetOnly = allFonts.filter((f) => f.embedded && f.subset);
+  for (const font of notEmbedded) {
+    details.push({
+      page: font.page,
+      message: `Font "${font.name}" is not embedded`,
+      status: "fail"
+    });
+    worstStatus = "fail";
+  }
+  for (const font of subsetOnly) {
+    details.push({
+      page: font.page,
+      message: `Font "${font.name}" is subset-embedded`,
+      status: "warn"
+    });
+    if (worstStatus === "pass") worstStatus = "warn";
+  }
+  for (const font of allFonts.filter((f) => f.embedded && !f.subset)) {
+    details.push({
+      page: font.page,
+      message: `Font "${font.name}" is fully embedded`,
+      status: "pass"
+    });
+  }
+  const embeddedCount = allFonts.filter((f) => f.embedded).length;
+  const subsetCount = subsetOnly.length;
+  const summary = worstStatus === "fail" ? `${notEmbedded.length} font(s) not embedded` : `${embeddedCount} fonts embedded (${subsetCount} subset)`;
+  return { check: "Fonts", status: worstStatus, summary, details };
+};
+
+// src/checks/colorspace.ts
+import * as mupdf from "mupdf";
+var checkColorSpace = async (engines, options) => {
+  if (options.colorSpace === "any") {
+    return {
+      check: "Color Space",
+      status: "pass",
+      summary: "Color space check skipped (--color-space any)",
+      details: []
+    };
+  }
+  const { mupdf: doc } = engines;
+  const details = [];
+  let worstStatus = "pass";
+  const rgbPages = [];
+  const spotColors = [];
+  const trailer = doc.getTrailer();
+  const root = safeGetResolved(trailer, "Root");
+  const outputIntents = safeGet(root, "OutputIntents");
+  if (outputIntents) {
+    for (let i = 0; i < outputIntents.length; i++) {
+      const intent = safeResolve(outputIntents.get(i));
+      if (!intent) continue;
+      const subtype = safeName(safeGet(intent, "S"));
+      const condition = safeString(safeGet(intent, "OutputConditionIdentifier"));
+      details.push({
+        message: `OutputIntent: ${subtype} \u2014 ${condition ?? "unknown"}`,
+        status: "pass"
+      });
+    }
+  }
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    const pageNum = i + 1;
+    const page = doc.loadPage(i);
+    const device = new mupdf.Device({
+      fillPath(_path, _evenOdd, _ctm, colorspace, _color, _alpha) {
+        classifyColorSpace(colorspace, pageNum, "fill path", _color);
+      },
+      strokePath(_path, _stroke, _ctm, colorspace, _color, _alpha) {
+        classifyColorSpace(colorspace, pageNum, "stroke path", _color);
+      },
+      fillText(_text, _ctm, colorspace, _color, _alpha) {
+        classifyColorSpace(colorspace, pageNum, "fill text", _color);
+      },
+      strokeText(_text, _stroke, _ctm, colorspace, _color, _alpha) {
+        classifyColorSpace(colorspace, pageNum, "stroke text", _color);
+      },
+      fillImage(image, _ctm, _alpha) {
+        const cs = image.getColorSpace();
+        if (cs) {
+          const w = image.getWidth();
+          const h = image.getHeight();
+          classifyColorSpace(cs, pageNum, `image (${w}\xD7${h}px)`);
+        }
+      },
+      fillImageMask(_image, _ctm, colorspace, _color, _alpha) {
+        classifyColorSpace(colorspace, pageNum, "image mask", _color);
+      }
+    });
+    page.runPageContents(device, mupdf.Matrix.identity);
+  }
+  function classifyColorSpace(cs, pageNum, source, color) {
+    if (cs.isRGB()) {
+      if (color && color.length >= 3) {
+        const [r, g, b] = color;
+        if (r === g && g === b) return;
+      }
+      if (!rgbPages.includes(pageNum)) rgbPages.push(pageNum);
+      details.push({
+        page: pageNum,
+        message: `RGB ${source}`,
+        status: "fail"
+      });
+      worstStatus = "fail";
+    } else if (cs.isDeviceN()) {
+      const name = cs.getName();
+      if (!spotColors.includes(name)) spotColors.push(name);
+    } else if (cs.getType() === "Separation") {
+      const name = cs.getName();
+      if (!spotColors.includes(name)) spotColors.push(name);
+    } else if (cs.isGray() || cs.isCMYK()) {
+    } else {
+      details.push({
+        page: pageNum,
+        message: `Unknown color space "${cs.getName()}" in ${source}`,
+        status: "warn"
+      });
+      if (worstStatus === "pass") worstStatus = "warn";
+    }
+  }
+  if (spotColors.length > 0) {
+    details.push({
+      message: `Spot colors found: ${spotColors.join(", ")}`,
+      status: "pass"
+    });
+  }
+  const summary = worstStatus === "pass" ? "All color spaces are CMYK-compatible" : rgbPages.length > 0 ? `RGB detected on pages ${[...new Set(rgbPages)].join(", ")}` : "Non-CMYK color spaces detected";
+  return { check: "Color Space", status: worstStatus, summary, details };
+};
+
+// src/checks/resolution.ts
+import * as mupdf2 from "mupdf";
+var checkResolution = async (engines, options) => {
+  const { mupdf: doc } = engines;
+  const details = [];
+  let worstStatus = "pass";
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    const pageNum = i + 1;
+    const page = doc.loadPage(i);
+    const placements = [];
+    const device = new mupdf2.Device({
+      fillImage(image, ctm, _alpha) {
+        placements.push({ image, ctm });
+      },
+      fillImageMask(image, ctm, _colorspace, _color, _alpha) {
+        placements.push({ image, ctm });
+      }
+    });
+    page.run(device, mupdf2.Matrix.identity);
+    for (const { image, ctm } of placements) {
+      const pixelWidth = image.getWidth();
+      const pixelHeight = image.getHeight();
+      if (!pixelWidth || !pixelHeight) continue;
+      const [a, b, c, d] = ctm;
+      const renderedWidthPt = Math.sqrt(a * a + b * b);
+      const renderedHeightPt = Math.sqrt(c * c + d * d);
+      const renderedWidthIn = renderedWidthPt / 72;
+      const renderedHeightIn = renderedHeightPt / 72;
+      const dpiX = renderedWidthIn > 0 ? pixelWidth / renderedWidthIn : 0;
+      const dpiY = renderedHeightIn > 0 ? pixelHeight / renderedHeightIn : 0;
+      const effectiveDpi = Math.min(dpiX, dpiY);
+      const roundedDpi = Math.round(effectiveDpi);
+      const label = `${pixelWidth}\xD7${pixelHeight}px image`;
+      const threshold = options.minDpi;
+      const warnThreshold = threshold * 0.9;
+      if (effectiveDpi < warnThreshold) {
+        details.push({
+          page: pageNum,
+          message: `${label}: ${roundedDpi} DPI (min: ${threshold})`,
+          status: "fail"
+        });
+        worstStatus = "fail";
+      } else if (effectiveDpi < threshold) {
+        details.push({
+          page: pageNum,
+          message: `${label}: ${roundedDpi} DPI (near threshold: ${threshold})`,
+          status: "warn"
+        });
+        if (worstStatus === "pass") worstStatus = "warn";
+      } else {
+        details.push({
+          page: pageNum,
+          message: `${label}: ${roundedDpi} DPI`,
+          status: "pass"
+        });
+      }
+    }
+  }
+  if (details.length === 0) {
+    return {
+      check: "Resolution",
+      status: "pass",
+      summary: "No raster images found",
+      details: []
+    };
+  }
+  const failedDetails = details.filter((d) => d.status === "fail");
+  const summary = worstStatus === "pass" ? `All images meet ${options.minDpi} DPI minimum` : worstStatus === "warn" ? `Some images near DPI threshold (${options.minDpi})` : failedDetails.map((d) => `Page ${d.page}: ${d.message}`).slice(0, 3).join("; ");
+  return { check: "Resolution", status: worstStatus, summary, details };
+};
+
+// src/checks/pdfx-compliance.ts
+var checkPdfxCompliance = async (engines, _options) => {
+  const details = [];
+  const doc = engines.mupdf;
+  const trailer = doc.getTrailer();
+  const root = safeGetResolved(trailer, "Root");
+  const outputIntents = safeGetResolved(root, "OutputIntents");
+  let pdfxVersion;
+  let pdfxCondition;
+  const infoDict = safeGetResolved(trailer, "Info");
+  if (infoDict) {
+    const versionStr = safeString(safeGet(infoDict, "GTS_PDFXVersion"));
+    if (versionStr) {
+      pdfxVersion = versionStr;
+      details.push({
+        message: `PDF/X version: ${versionStr}`,
+        status: "pass"
+      });
+    }
+  }
+  if (outputIntents && outputIntents.isArray()) {
+    const len = outputIntents.length;
+    for (let i = 0; i < len; i++) {
+      const raw = outputIntents.get(i);
+      const intent = raw && !raw.isNull() ? safeResolve(raw) : void 0;
+      if (!intent) continue;
+      const subtype = safeName(safeGet(intent, "S")) ?? "unknown";
+      const conditionId = safeString(safeGet(intent, "OutputConditionIdentifier")) ?? "";
+      const info = safeString(safeGet(intent, "Info"));
+      const registryName = safeString(safeGet(intent, "RegistryName"));
+      const isPdfx = subtype.startsWith("GTS_PDFX");
+      const parts = [subtype];
+      if (conditionId) parts.push(conditionId);
+      if (info) parts.push(info);
+      if (registryName) parts.push(registryName);
+      const label = isPdfx ? "PDF/X OutputIntent" : "OutputIntent";
+      details.push({
+        message: `${label}: ${parts.join(" \u2014 ")}`,
+        status: "pass"
+      });
+      if (isPdfx && conditionId) {
+        pdfxCondition = conditionId;
+      }
+    }
+  }
+  if (details.length === 0) {
+    return {
+      check: "PDF/X Compliance",
+      status: "pass",
+      summary: "No PDF/X compliance detected",
+      details: [{ message: "No PDF/X compliance detected", status: "pass" }]
+    };
+  }
+  let summary;
+  if (pdfxVersion && pdfxCondition) {
+    summary = `${pdfxVersion} (${pdfxCondition})`;
+  } else if (pdfxVersion) {
+    summary = pdfxVersion;
+  } else if (pdfxCondition) {
+    summary = `PDF/X (${pdfxCondition})`;
+  } else {
+    summary = "No PDF/X compliance detected";
+  }
+  return {
+    check: "PDF/X Compliance",
+    status: "pass",
+    summary,
+    details
+  };
+};
+
+// src/checks/tac.ts
+import * as mupdf3 from "mupdf";
+var checkTac = async (engines, options) => {
+  const { mupdf: doc } = engines;
+  const details = [];
+  let worstStatus = "pass";
+  let globalMaxTac = 0;
+  let globalMaxPage = 1;
+  const maxTac = options.maxTac;
+  const warnThreshold = maxTac * 0.9;
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    let recordTac2 = function(tac) {
+      if (tac > pageMaxTac) pageMaxTac = tac;
+    }, handleVectorColor2 = function(colorspace, color) {
+      if (!colorspace.isCMYK()) return;
+      const tac = (color[0] + color[1] + color[2] + color[3]) * 100;
+      recordTac2(tac);
+    };
+    var recordTac = recordTac2, handleVectorColor = handleVectorColor2;
+    const pageNum = i + 1;
+    const page = doc.loadPage(i);
+    let pageMaxTac = 0;
+    const device = new mupdf3.Device({
+      fillPath(_path, _evenOdd, _ctm, colorspace, color, _alpha) {
+        handleVectorColor2(colorspace, color);
+      },
+      strokePath(_path, _stroke, _ctm, colorspace, color, _alpha) {
+        handleVectorColor2(colorspace, color);
+      },
+      fillText(_text, _ctm, colorspace, color, _alpha) {
+        handleVectorColor2(colorspace, color);
+      },
+      strokeText(_text, _stroke, _ctm, colorspace, color, _alpha) {
+        handleVectorColor2(colorspace, color);
+      },
+      fillImageMask(_image, _ctm, colorspace, color, _alpha) {
+        handleVectorColor2(colorspace, color);
+      },
+      fillImage(image, _ctm, _alpha) {
+        const cs = image.getColorSpace();
+        if (!cs || !cs.isCMYK()) return;
+        const pixmap = image.toPixmap();
+        const w = pixmap.getWidth();
+        const h = pixmap.getHeight();
+        const n = pixmap.getNumberOfComponents();
+        const samples = pixmap.getPixels();
+        const totalPixels = w * h;
+        const step = Math.max(1, Math.floor(totalPixels / 1e4));
+        const stride = n + (pixmap.getAlpha() ? 1 : 0);
+        let imageMaxTac = 0;
+        for (let px = 0; px < totalPixels; px += step) {
+          const offset = px * stride;
+          const c = samples[offset] / 255;
+          const m = samples[offset + 1] / 255;
+          const y = samples[offset + 2] / 255;
+          const k = samples[offset + 3] / 255;
+          const tac = (c + m + y + k) * 100;
+          if (tac > imageMaxTac) imageMaxTac = tac;
+        }
+        recordTac2(imageMaxTac);
+      }
+    });
+    page.runPageContents(device, mupdf3.Matrix.identity);
+    if (pageMaxTac > globalMaxTac) {
+      globalMaxTac = pageMaxTac;
+      globalMaxPage = pageNum;
+    }
+    if (pageMaxTac > 0) {
+      const tacRounded2 = Math.round(pageMaxTac);
+      let status;
+      if (pageMaxTac > maxTac) {
+        status = "fail";
+      } else if (pageMaxTac > warnThreshold) {
+        status = "warn";
+      } else {
+        status = "pass";
+      }
+      details.push({
+        page: pageNum,
+        message: `Max TAC: ${tacRounded2}% (limit: ${maxTac}%)`,
+        status
+      });
+      if (status === "fail") {
+        worstStatus = "fail";
+      } else if (status === "warn" && worstStatus === "pass") {
+        worstStatus = "warn";
+      }
+    }
+  }
+  const tacRounded = Math.round(globalMaxTac);
+  const summary = globalMaxTac === 0 ? `All content within TAC limit (${maxTac}%)` : globalMaxTac > maxTac ? `Max TAC: ${tacRounded}% on page ${globalMaxPage} (limit: ${maxTac}%)` : `All content within TAC limit (${maxTac}%)`;
+  return {
+    check: "Total Ink Coverage",
+    status: worstStatus,
+    summary,
+    details
+  };
+};
+
+// src/checks/transparency.ts
+import * as mupdf4 from "mupdf";
+var checkTransparency = async (engines) => {
+  const { mupdf: doc } = engines;
+  const details = [];
+  const pagesWithTransparency = [];
+  const pageCount = doc.countPages();
+  for (let i = 0; i < pageCount; i++) {
+    let recordAlpha2 = function(alpha) {
+      if (alpha < 1) {
+        info.hasAlpha = true;
+        if (!info.alphaValues.includes(alpha)) {
+          info.alphaValues.push(alpha);
+        }
+      }
+    };
+    var recordAlpha = recordAlpha2;
+    const pageNum = i + 1;
+    const page = doc.loadPage(i);
+    const info = {
+      blendModes: /* @__PURE__ */ new Set(),
+      hasAlpha: false,
+      alphaValues: [],
+      hasSoftMask: false
+    };
+    const device = new mupdf4.Device({
+      fillPath(_path, _evenOdd, _ctm, _colorspace, _color, alpha) {
+        recordAlpha2(alpha);
+      },
+      strokePath(_path, _stroke, _ctm, _colorspace, _color, alpha) {
+        recordAlpha2(alpha);
+      },
+      fillText(_text, _ctm, _colorspace, _color, alpha) {
+        recordAlpha2(alpha);
+      },
+      strokeText(_text, _stroke, _ctm, _colorspace, _color, alpha) {
+        recordAlpha2(alpha);
+      },
+      fillImageMask(_image, _ctm, _colorspace, _color, alpha) {
+        recordAlpha2(alpha);
+      },
+      fillImage(_image, _ctm, alpha) {
+        recordAlpha2(alpha);
+      },
+      beginGroup(_bbox, _colorspace, _isolated, _knockout, blendmode, alpha) {
+        if (blendmode !== "Normal") {
+          info.blendModes.add(blendmode);
+        }
+        recordAlpha2(alpha);
+      },
+      beginMask(_bbox, _luminosity, _colorspace, _color) {
+        info.hasSoftMask = true;
+      }
+    });
+    page.runPageContents(device, mupdf4.Matrix.identity);
+    const parts = [];
+    if (info.blendModes.size > 0) {
+      const modes = Array.from(info.blendModes).join(", ");
+      parts.push(`Blend mode (${modes})`);
+    }
+    if (info.hasAlpha) {
+      const minAlpha = Math.min(...info.alphaValues);
+      parts.push(`Alpha transparency (${minAlpha})`);
+    }
+    if (info.hasSoftMask) {
+      parts.push("soft mask");
+    }
+    if (parts.length > 0) {
+      pagesWithTransparency.push(pageNum);
+      details.push({
+        page: pageNum,
+        message: `Page ${pageNum}: ${parts.join(", ")}`,
+        status: "warn"
+      });
+    }
+  }
+  const status = pagesWithTransparency.length > 0 ? "warn" : "pass";
+  const summary = pagesWithTransparency.length > 0 ? `Transparency detected on ${pagesWithTransparency.length === 1 ? "page" : "pages"} ${pagesWithTransparency.join(", ")}` : "No transparency detected";
+  return {
+    check: "Transparency",
+    status,
+    summary,
+    details
+  };
+};
+
+// src/checks/page-size.ts
+var PT_TO_MM2 = 25.4 / 72;
+var TOLERANCE_MM = 0.5;
+function dimToMm(pt) {
+  return pt * PT_TO_MM2;
+}
+function fmtMm(mm) {
+  return mm.toFixed(0);
+}
+function withinTolerance(a, b) {
+  return Math.abs(a - b) <= TOLERANCE_MM;
+}
+var checkPageSize = async (engines, options) => {
+  const { pdfLib } = engines;
+  const pages = pdfLib.getPages();
+  const details = [];
+  let worstStatus = "pass";
+  const pageDims = [];
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
+    const mediaBox = page.getMediaBox();
+    const trimBox = page.getTrimBox();
+    const hasTrimBox = trimBox.x !== mediaBox.x || trimBox.y !== mediaBox.y || trimBox.width !== mediaBox.width || trimBox.height !== mediaBox.height;
+    const box = hasTrimBox ? trimBox : mediaBox;
+    const wMm = dimToMm(box.width);
+    const hMm = dimToMm(box.height);
+    pageDims.push({ wMm, hMm });
+  }
+  let expectedW;
+  let expectedH;
+  if (options.pageSize) {
+    const parts = options.pageSize.split("x");
+    if (parts.length === 2) {
+      expectedW = parseFloat(parts[0]);
+      expectedH = parseFloat(parts[1]);
+    }
+  }
+  for (let i = 0; i < pageDims.length; i++) {
+    const { wMm, hMm } = pageDims[i];
+    const pageNum = i + 1;
+    const sizeStr = `${fmtMm(wMm)} \xD7 ${fmtMm(hMm)} mm`;
+    if (expectedW !== void 0 && expectedH !== void 0) {
+      const matchesExpected = withinTolerance(wMm, expectedW) && withinTolerance(hMm, expectedH);
+      if (!matchesExpected) {
+        details.push({
+          page: pageNum,
+          message: `Page ${pageNum}: ${sizeStr} (expected ${expectedW}x${expectedH} mm)`,
+          status: "fail"
+        });
+        worstStatus = "fail";
+      } else {
+        details.push({
+          page: pageNum,
+          message: `Page ${pageNum}: ${sizeStr}`,
+          status: "pass"
+        });
+      }
+    } else {
+      const ref = pageDims[0];
+      const consistent = withinTolerance(wMm, ref.wMm) && withinTolerance(hMm, ref.hMm);
+      if (!consistent) {
+        details.push({
+          page: pageNum,
+          message: `Page ${pageNum}: ${sizeStr}`,
+          status: "warn"
+        });
+        if (worstStatus === "pass") worstStatus = "warn";
+      } else {
+        details.push({
+          page: pageNum,
+          message: `Page ${pageNum}: ${sizeStr}`,
+          status: "pass"
+        });
+      }
+    }
+  }
+  const refSize = pageDims[0];
+  const summary = worstStatus === "pass" ? `All pages are ${fmtMm(refSize.wMm)} \xD7 ${fmtMm(refSize.hMm)} mm` : worstStatus === "warn" ? "Inconsistent page sizes detected" : "Page size mismatch";
+  return { check: "Page Size", status: worstStatus, summary, details };
+};
+
+// src/engine/pdf-engine.ts
+import * as fs from "fs";
+import * as mupdf5 from "mupdf";
+import { PDFDocument as PDFDocument2 } from "pdf-lib";
+async function loadPdf(filePath) {
+  const buffer = fs.readFileSync(filePath);
+  const mupdfDoc = mupdf5.PDFDocument.openDocument(
+    buffer,
+    "application/pdf"
+  );
+  const pdfLibDoc = await PDFDocument2.load(buffer, {
+    ignoreEncryption: true
+  });
+  return { mupdf: mupdfDoc, pdfLib: pdfLibDoc };
+}
+
+// src/reporter/console.ts
+import pc from "picocolors";
+var STATUS_ICON = {
+  pass: pc.green("\u2713"),
+  warn: pc.yellow("\u26A0"),
+  fail: pc.red("\u2717")
+};
+var STATUS_COLOR = {
+  pass: pc.green,
+  warn: pc.yellow,
+  fail: pc.red
+};
+function printReport(fileName, results, verbose) {
+  console.log();
+  console.log(` ${pc.bold("print-check results:")} ${fileName}`);
+  console.log(pc.dim("\u2500".repeat(45)));
+  for (const result of results) {
+    const icon = STATUS_ICON[result.status];
+    const color = STATUS_COLOR[result.status];
+    const checkName = result.check.padEnd(16);
+    console.log(` ${icon} ${pc.bold(checkName)} ${color(result.summary)}`);
+    if (verbose && result.details.length > 0) {
+      for (const detail of result.details) {
+        const detailIcon = STATUS_ICON[detail.status];
+        const pagePrefix = detail.page ? `Page ${detail.page}: ` : "";
+        console.log(`     ${detailIcon} ${pc.dim(pagePrefix)}${detail.message}`);
+      }
+    }
+  }
+  console.log(pc.dim("\u2500".repeat(45)));
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const parts = [];
+  if (passed > 0) parts.push(pc.green(`${passed} passed`));
+  if (warned > 0) parts.push(pc.yellow(`${warned} warned`));
+  if (failed > 0) parts.push(pc.red(`${failed} failed`));
+  console.log(` ${parts.join(pc.dim(" \xB7 "))}`);
+  console.log();
+}
+
+// src/reporter/json.ts
+function buildJsonReport(fileName, results) {
+  return {
+    file: fileName,
+    results,
+    summary: {
+      passed: results.filter((r) => r.status === "pass").length,
+      warned: results.filter((r) => r.status === "warn").length,
+      failed: results.filter((r) => r.status === "fail").length
+    }
+  };
+}
+
+// src/profiles.ts
+var PROFILE_NAMES = [
+  "standard",
+  "magazine",
+  "newspaper",
+  "large-format"
+];
+var PROFILES = {
+  standard: { minDpi: 300, colorSpace: "cmyk", bleedMm: 3, maxTac: 300, pageSize: void 0 },
+  magazine: { minDpi: 300, colorSpace: "cmyk", bleedMm: 5, maxTac: 300, pageSize: void 0 },
+  newspaper: { minDpi: 150, colorSpace: "any", bleedMm: 0, maxTac: 240, pageSize: void 0 },
+  "large-format": { minDpi: 150, colorSpace: "cmyk", bleedMm: 5, maxTac: 300, pageSize: void 0 }
+};
+
+// src/config.ts
+import { z } from "zod";
+import * as fs2 from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+var ConfigSchema = z.object({
+  minDpi: z.number().int().positive().optional(),
+  colorSpace: z.enum(["cmyk", "any"]).optional(),
+  bleed: z.number().nonnegative().optional(),
+  maxTac: z.number().positive().optional(),
+  pageSize: z.string().optional(),
+  checks: z.string().optional(),
+  verbose: z.boolean().optional(),
+  format: z.enum(["text", "json"]).optional(),
+  profile: z.enum(PROFILE_NAMES).optional(),
+  severity: z.record(z.string(), z.enum(["fail", "warn", "off"])).optional()
+});
+var CONFIG_FILES = [
+  ".printcheckrc",
+  ".printcheckrc.json",
+  "printcheck.config.js"
+];
+function findConfigFile(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    for (const name of CONFIG_FILES) {
+      const candidate = path.join(dir, name);
+      if (fs2.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function loadConfig() {
+  const filePath = findConfigFile(process.cwd());
+  if (!filePath) return null;
+  const ext = path.extname(filePath);
+  let raw;
+  if (ext === ".js") {
+    const module = await import(pathToFileURL(filePath).href);
+    raw = module.default;
+  } else {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    raw = JSON.parse(content);
+  }
+  const parsed = ConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    console.error(`Invalid config file (${filePath}):`, parsed.error.format());
+    process.exit(1);
+  }
+  return { options: parsed.data, filePath };
+}
+
+// src/index.ts
+function parseSeverityString(val) {
+  if (!val.trim()) return {};
+  const result = {};
+  for (const pair of val.split(",")) {
+    const [check, level] = pair.split(":").map((s) => s.trim());
+    if (check && level) result[check] = level;
+  }
+  return result;
+}
+function applySeverityOverride(result, override) {
+  if (!override || override === "fail") return result;
+  if (override === "warn" && result.status === "fail") {
+    return {
+      ...result,
+      status: "warn",
+      details: result.details.map(
+        (d) => d.status === "fail" ? { ...d, status: "warn" } : d
+      )
+    };
+  }
+  return result;
+}
+var ALL_CHECKS = {
+  bleed: checkBleedTrim,
+  fonts: checkFonts,
+  colorspace: checkColorSpace,
+  resolution: checkResolution,
+  pdfx: checkPdfxCompliance,
+  tac: checkTac,
+  transparency: checkTransparency,
+  pagesize: checkPageSize
+};
+var OptionsSchema = z2.object({
+  minDpi: z2.coerce.number().int().positive().optional(),
+  colorSpace: z2.enum(["cmyk", "any"]).optional(),
+  bleed: z2.coerce.number().nonnegative().optional(),
+  maxTac: z2.coerce.number().positive().optional(),
+  pageSize: z2.string().optional(),
+  checks: z2.string().default("all").transform((val) => val === "all" ? Object.keys(ALL_CHECKS) : val.split(",").map((s) => s.trim())),
+  verbose: z2.boolean().default(false),
+  format: z2.enum(["text", "json"]).default("text"),
+  profile: z2.enum(PROFILE_NAMES).optional(),
+  severity: z2.union([z2.string().transform(parseSeverityString), z2.record(z2.string(), z2.enum(["fail", "warn", "off"]))]).default({})
+});
+var program = new Command();
+program.name("print-check").description("Validate print-ready PDF files").version("1.0.0").argument("<files...>", "PDF file(s) to check").option("--min-dpi <number>", "Minimum acceptable DPI").option("--color-space <mode>", "Expected color space: cmyk | any").option("--bleed <mm>", "Required bleed in mm").option("--max-tac <percent>", "Maximum total ink coverage %").option("--page-size <WxH>", "Expected page size in mm (e.g. 210x297)").option("--checks <list>", "Comma-separated checks to run", "all").option("--verbose", "Show detailed per-page results", false).option("--format <type>", "Output format: text | json", "text").option("--profile <name>", "Print profile: standard | magazine | newspaper | large-format").option("--severity <overrides>", "Per-check severity: check:level,... (fail|warn|off)").action(async (files, rawOpts) => {
+  const config = await loadConfig();
+  const stripped = {};
+  for (const [key, value] of Object.entries(rawOpts)) {
+    if (value !== void 0) stripped[key] = value;
+  }
+  const configSeverity = config?.options?.severity || {};
+  const cliSeverity = typeof stripped.severity === "string" ? parseSeverityString(stripped.severity) : {};
+  const mergedSeverity = { ...configSeverity, ...cliSeverity };
+  const merged = {
+    ...config?.options,
+    ...stripped,
+    severity: Object.keys(mergedSeverity).length > 0 ? mergedSeverity : void 0
+  };
+  const parsed = OptionsSchema.safeParse(merged);
+  if (!parsed.success) {
+    console.error("Invalid options:", parsed.error.format());
+    process.exit(1);
+  }
+  const opts = parsed.data;
+  if (config && opts.verbose) {
+    console.log(`Using config: ${config.filePath}`);
+  }
+  const base = opts.profile ? PROFILES[opts.profile] : PROFILES.standard;
+  const checkOptions = {
+    minDpi: opts.minDpi !== void 0 ? opts.minDpi : base.minDpi,
+    colorSpace: opts.colorSpace !== void 0 ? opts.colorSpace : base.colorSpace,
+    bleedMm: opts.bleed !== void 0 ? opts.bleed : base.bleedMm,
+    maxTac: opts.maxTac !== void 0 ? opts.maxTac : base.maxTac,
+    pageSize: opts.pageSize !== void 0 ? opts.pageSize : base.pageSize
+  };
+  const checksToRun = opts.checks.filter((name) => {
+    if (!ALL_CHECKS[name]) {
+      console.warn(`Unknown check: "${name}" (skipping)`);
+      return false;
+    }
+    if (opts.severity[name] === "off") return false;
+    return true;
+  });
+  if (checksToRun.length === 0) {
+    console.error("No valid checks to run.");
+    process.exit(1);
+  }
+  const allReports = [];
+  let anyFail = false;
+  for (const file of files) {
+    const filePath = path2.resolve(file);
+    if (!fs3.existsSync(filePath)) {
+      console.error(`File not found: ${filePath}`);
+      anyFail = true;
+      continue;
+    }
+    const engines = await loadPdf(filePath);
+    const results = [];
+    for (const name of checksToRun) {
+      try {
+        const raw = await ALL_CHECKS[name](engines, checkOptions);
+        results.push(applySeverityOverride(raw, opts.severity[name]));
+      } catch (err) {
+        const raw = {
+          check: name,
+          status: "fail",
+          summary: `Error: ${err instanceof Error ? err.message : String(err)}`,
+          details: []
+        };
+        results.push(applySeverityOverride(raw, opts.severity[name]));
+      }
+    }
+    if (results.some((r) => r.status === "fail")) anyFail = true;
+    if (opts.format === "json") {
+      allReports.push(buildJsonReport(path2.basename(filePath), results));
+    } else {
+      if (files.indexOf(file) > 0) {
+        console.log();
+      }
+      printReport(path2.basename(filePath), results, opts.verbose);
+    }
+  }
+  if (opts.format === "json") {
+    if (allReports.length === 1) {
+      console.log(JSON.stringify(allReports[0], null, 2));
+    } else {
+      console.log(JSON.stringify(allReports, null, 2));
+    }
+  }
+  process.exit(anyFail ? 1 : 0);
+});
+program.parse();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "print-check-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "print-check": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "pdf",
+    "print",
+    "prepress",
+    "cli"
+  ],
+  "author": "Ryan Calacsan (https://github.com/ryancalacsan)",
+  "license": "ISC",
+  "description": "CLI tool to validate print-ready PDF files",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ryancalacsan/print-check-cli.git"
+  },
+  "homepage": "https://github.com/ryancalacsan/print-check-cli#readme",
+  "bugs": {
+    "url": "https://github.com/ryancalacsan/print-check-cli/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "commander": "^14.0.2",
+    "mupdf": "^1.27.0",
+    "pdf-lib": "^1.17.1",
+    "picocolors": "^1.1.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}