@pdfme/cli 5.5.10-dev.125

package/dist/index.js

@@ -0,0 +1,3107 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { PDFDocument } from "@pdfme/pdf-lib";
+import { generate } from "@pdfme/generator";
+import { pdf2img, pdf2size } from "@pdfme/converter";
+import { DEFAULT_FONT_NAME, checkGenerateProps, checkTemplate, getDefaultFont, isUrlSafeToFetch } from "@pdfme/common";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import * as schemas from "@pdfme/schemas";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+//#region src/contract.ts
+var CliError = class extends Error {
+	code;
+	exitCode;
+	details;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "CliError";
+		this.code = options.code ?? "ECLI";
+		this.exitCode = options.exitCode ?? 1;
+		this.details = options.details;
+		if (options.cause !== void 0) this.cause = options.cause;
+	}
+};
+function fail(message, options = {}) {
+	throw new CliError(message, options);
+}
+function printJson(value) {
+	console.log(JSON.stringify(value, null, 2));
+}
+async function runWithContract(options, task) {
+	try {
+		return await task();
+	} catch (error) {
+		return handleCommandError(error, options.json);
+	}
+}
+function handleCommandError(error, json) {
+	const normalized = normalizeCliError(error);
+	if (json) {
+		const payload = {
+			ok: false,
+			error: {
+				code: normalized.code,
+				message: normalized.message
+			}
+		};
+		if (normalized.details !== void 0) payload.error.details = normalized.details;
+		printJson(payload);
+	} else console.error(`Error: ${normalized.message}`);
+	process.exit(normalized.exitCode);
+}
+function assertNoUnknownFlags(rawArgs, argsDefinition) {
+	const booleanFlags = /* @__PURE__ */ new Set();
+	const valueFlags = /* @__PURE__ */ new Set();
+	const negatedBooleanFlags = /* @__PURE__ */ new Set();
+	for (const [name, definition] of Object.entries(argsDefinition)) {
+		if (definition.type === "positional") continue;
+		for (const flag of getFlagVariants(name, definition.alias)) if (definition.type === "boolean") {
+			booleanFlags.add(flag);
+			if (flag.startsWith("--") && !name.startsWith("no")) negatedBooleanFlags.add(`--no-${flag.slice(2)}`);
+		} else valueFlags.add(flag);
+	}
+	for (let i = 0; i < rawArgs.length; i++) {
+		const token = rawArgs[i];
+		if (token === "--") break;
+		if (!token.startsWith("-") || token === "-") continue;
+		const [flag, inlineValue] = splitFlagToken(token);
+		if (booleanFlags.has(flag) || negatedBooleanFlags.has(flag)) {
+			if (inlineValue !== void 0) fail(`Boolean flag ${flag} does not take a value.`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			continue;
+		}
+		if (valueFlags.has(flag)) {
+			if (inlineValue !== void 0) {
+				if (inlineValue.length === 0) fail(`Missing value for argument ${flag}.`, {
+					code: "EARG",
+					exitCode: 1
+				});
+			} else {
+				const next = rawArgs[i + 1];
+				if (!next || next === "--" || next.startsWith("-")) fail(`Missing value for argument ${flag}.`, {
+					code: "EARG",
+					exitCode: 1
+				});
+				i++;
+			}
+			continue;
+		}
+		fail(`Unknown argument: ${flag}`, {
+			code: "EARG",
+			exitCode: 1
+		});
+	}
+}
+function isOptionProvided(rawArgs, name, alias) {
+	const allowedFlags = new Set(getFlagVariants(name, alias));
+	return rawArgs.some((token) => {
+		if (!token.startsWith("-") || token === "-") return false;
+		const [flag] = splitFlagToken(token);
+		return allowedFlags.has(flag);
+	});
+}
+function parseEnumArg(optionName, value, allowedValues) {
+	if (typeof value !== "string" || !allowedValues.includes(value)) fail(`Invalid value for --${optionName}: expected one of ${allowedValues.join(", ")}, received ${formatValue(value)}.`, {
+		code: "EARG",
+		exitCode: 1
+	});
+	return value;
+}
+function parsePositiveNumberArg(optionName, value) {
+	const parsed = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) fail(`Invalid value for --${optionName}: expected a positive number, received ${formatValue(value)}.`, {
+		code: "EARG",
+		exitCode: 1
+	});
+	return parsed;
+}
+function normalizeCliError(error) {
+	if (error instanceof CliError) return error;
+	if (error instanceof Error) {
+		const errorCode = typeof error.code === "string" ? error.code : void 0;
+		if (errorCode && errorCode.startsWith("E")) return new CliError(error.message, {
+			code: "EIO",
+			exitCode: 3,
+			details: { errno: errorCode },
+			cause: error
+		});
+		return new CliError(error.message, {
+			code: "ERUNTIME",
+			exitCode: 2,
+			cause: error
+		});
+	}
+	return new CliError(String(error), {
+		code: "ERUNTIME",
+		exitCode: 2
+	});
+}
+function splitFlagToken(token) {
+	const eqIndex = token.indexOf("=");
+	if (eqIndex === -1) return [token, void 0];
+	return [token.slice(0, eqIndex), token.slice(eqIndex + 1)];
+}
+function getFlagVariants(name, alias) {
+	const flags = /* @__PURE__ */ new Set();
+	addFlagVariants(flags, name);
+	for (const item of toArray(alias)) addFlagVariants(flags, item);
+	return [...flags];
+}
+function addFlagVariants(flags, value) {
+	if (value.length === 1) {
+		flags.add(`-${value}`);
+		return;
+	}
+	flags.add(`--${value}`);
+	flags.add(`--${toKebabCase(value)}`);
+	flags.add(`--${toCamelCase(value)}`);
+}
+function toArray(value) {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function toKebabCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function toCamelCase(value) {
+	return value.replace(/[-_ ]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+}
+function formatValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+}
+//#endregion
+//#region src/schema-plugins.ts
+function isPlugin(value) {
+	if (!value || typeof value !== "object") return false;
+	const plugin = value;
+	return typeof plugin.pdf === "function" && typeof plugin.ui === "function" && typeof plugin.propPanel === "object" && plugin.propPanel !== null && typeof plugin.propPanel.defaultSchema === "object" && plugin.propPanel.defaultSchema !== null && typeof plugin.propPanel.defaultSchema.type === "string";
+}
+function collectPluginsByType(value, plugins, seen) {
+	if (!value || typeof value !== "object") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	if (isPlugin(value)) {
+		const type = value.propPanel.defaultSchema.type;
+		if (!(type in plugins)) plugins[type] = value;
+		return;
+	}
+	for (const child of Object.values(value)) collectPluginsByType(child, plugins, seen);
+}
+function buildSchemaPlugins() {
+	const plugins = {};
+	collectPluginsByType(schemas, plugins, /* @__PURE__ */ new WeakSet());
+	return plugins;
+}
+var schemaPlugins = buildSchemaPlugins();
+var schemaTypes = new Set(Object.keys(schemaPlugins));
+//#endregion
+//#region src/utils.ts
+function readJsonFile(filePath) {
+	const resolvedPath = resolve(filePath);
+	if (!existsSync(resolvedPath)) fail(`File not found: ${resolvedPath}`, {
+		code: "EIO",
+		exitCode: 3
+	});
+	try {
+		const content = readFileSync(resolvedPath, "utf8");
+		return JSON.parse(content);
+	} catch (error) {
+		fail(`Failed to parse JSON file: ${resolvedPath}. ${error instanceof Error ? error.message : String(error)}`, {
+			code: "EIO",
+			exitCode: 3,
+			cause: error
+		});
+	}
+}
+function loadInput(args) {
+	const positionalFile = args._[0];
+	if (positionalFile && !args.template && !args.inputs) {
+		const jobFilePath = resolve(positionalFile);
+		const data = readJsonFile(jobFilePath);
+		if ("template" in data && "inputs" in data) return {
+			template: data.template,
+			inputs: data.inputs,
+			options: data.options,
+			templateDir: dirname(jobFilePath)
+		};
+		fail("Positional file must be a unified format with \"template\" and \"inputs\" keys. Use -t and -i for separate files.", {
+			code: "EARG",
+			exitCode: 1
+		});
+	}
+	if (args.template) {
+		if (!args.inputs) fail("--inputs (-i) is required when using --template (-t).", {
+			code: "EARG",
+			exitCode: 1
+		});
+		const templatePath = resolve(args.template);
+		return {
+			template: readJsonFile(templatePath),
+			inputs: readJsonFile(resolve(args.inputs)),
+			templateDir: dirname(templatePath)
+		};
+	}
+	fail("No input provided. Use a unified job file or pass --template/-t with --inputs/-i.", {
+		code: "EARG",
+		exitCode: 1
+	});
+}
+function resolveBasePdf(template, basePdfArg, templateDir) {
+	if (basePdfArg) {
+		const resolvedBasePdf = resolve(basePdfArg);
+		if (!existsSync(resolvedBasePdf)) fail(`Base PDF file not found: ${resolvedBasePdf}`, {
+			code: "EIO",
+			exitCode: 3
+		});
+		const pdfData = new Uint8Array(readFileSync(resolvedBasePdf));
+		return {
+			...template,
+			basePdf: pdfData
+		};
+	}
+	const basePdf = template.basePdf;
+	if (typeof basePdf === "string" && basePdf.endsWith(".pdf") && !basePdf.startsWith("data:")) {
+		const resolvedBasePdf = templateDir ? resolve(templateDir, basePdf) : resolve(basePdf);
+		if (!existsSync(resolvedBasePdf)) fail(`Base PDF file not found: ${resolvedBasePdf}`, {
+			code: "EIO",
+			exitCode: 3
+		});
+		const pdfData = new Uint8Array(readFileSync(resolvedBasePdf));
+		return {
+			...template,
+			basePdf: pdfData
+		};
+	}
+	return template;
+}
+function getImageOutputPaths(pdfOutputPath, pageCount, imageFormat) {
+	const dir = dirname(pdfOutputPath);
+	const base = basename(pdfOutputPath, extname(pdfOutputPath));
+	const ext = imageFormat === "jpeg" ? "jpg" : "png";
+	return Array.from({ length: pageCount }, (_, i) => join(dir, `${base}-${i + 1}.${ext}`));
+}
+function writeOutput(filePath, data) {
+	try {
+		const dir = dirname(filePath);
+		if (dir && dir !== "." && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(filePath, data instanceof ArrayBuffer ? new Uint8Array(data) : data);
+	} catch (error) {
+		fail(`Failed to write file: ${filePath}. ${error instanceof Error ? error.message : String(error)}`, {
+			code: "EIO",
+			exitCode: 3,
+			cause: error
+		});
+	}
+}
+function readPdfFile(filePath) {
+	const resolvedPath = resolve(filePath);
+	if (!existsSync(resolvedPath)) fail(`PDF file not found: ${resolvedPath}`, {
+		code: "EIO",
+		exitCode: 3
+	});
+	try {
+		return new Uint8Array(readFileSync(resolvedPath));
+	} catch (error) {
+		fail(`Failed to read PDF file: ${resolvedPath}. ${error instanceof Error ? error.message : String(error)}`, {
+			code: "EIO",
+			exitCode: 3,
+			cause: error
+		});
+	}
+}
+var PAPER_SIZES = {
+	A3: [297, 420],
+	A4: [210, 297],
+	A5: [148, 210],
+	A6: [105, 148],
+	B4: [250, 353],
+	B5: [176, 250],
+	Letter: [216, 279],
+	Legal: [216, 356],
+	Tabloid: [279, 432]
+};
+function detectPaperSize(width, height) {
+	const tolerance = 2;
+	for (const [name, [w, h]] of Object.entries(PAPER_SIZES)) if (Math.abs(width - w) <= tolerance && Math.abs(height - h) <= tolerance || Math.abs(width - h) <= tolerance && Math.abs(height - w) <= tolerance) return `${name} ${width < height ? "portrait" : "landscape"}`;
+	return null;
+}
+function parsePageRange(rangeStr, totalPages) {
+	const pages = /* @__PURE__ */ new Set();
+	for (const part of rangeStr.split(",")) {
+		const trimmed = part.trim();
+		if (!trimmed) fail(`Invalid page range: ${JSON.stringify(rangeStr)}. Empty segments are not allowed.`, {
+			code: "EARG",
+			exitCode: 1
+		});
+		if (trimmed.includes("-")) {
+			const [startStr, endStr] = trimmed.split("-");
+			if (!startStr || !endStr || !/^\d+$/.test(startStr) || !/^\d+$/.test(endStr)) fail(`Invalid page range segment: ${JSON.stringify(trimmed)}. Use formats like "1-3" or "2".`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			const start = Number.parseInt(startStr, 10);
+			const end = Number.parseInt(endStr, 10);
+			if (start < 1 || end < 1 || start > end || end > totalPages) fail(`Invalid page range segment: ${JSON.stringify(trimmed)}. Pages must be between 1 and ${totalPages}.`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			for (let i = start; i <= end; i++) pages.add(i);
+		} else {
+			if (!/^\d+$/.test(trimmed)) fail(`Invalid page range segment: ${JSON.stringify(trimmed)}. Use formats like "1-3" or "2".`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			const p = Number.parseInt(trimmed, 10);
+			if (p < 1 || p > totalPages) fail(`Invalid page number: ${p}. Pages must be between 1 and ${totalPages}.`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			pages.add(p);
+		}
+	}
+	return [...pages].sort((a, b) => a - b);
+}
+async function readJsonFromStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const content = Buffer.concat(chunks).toString("utf8").trim();
+	if (!content) fail("No JSON input received on stdin.", {
+		code: "EARG",
+		exitCode: 1
+	});
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		fail(`Failed to parse JSON from stdin. ${error instanceof Error ? error.message : String(error)}`, {
+			code: "EIO",
+			exitCode: 3,
+			cause: error
+		});
+	}
+}
+function ensureSafeDefaultOutputPath(options) {
+	const issue = getSafeDefaultOutputPathIssue(options);
+	if (issue) fail(issue, {
+		code: "EARG",
+		exitCode: 1
+	});
+}
+function getSafeDefaultOutputPathIssue(options) {
+	const { filePath, rawArgs, optionName, optionAlias, defaultValue, force = false } = options;
+	if (force || isOptionProvided(rawArgs, optionName, optionAlias) || filePath !== defaultValue) return;
+	const resolvedPath = resolve(filePath);
+	if (!existsSync(resolvedPath)) return;
+	return `Refusing to overwrite implicit default output file: ${resolvedPath}. Use -o to choose an explicit path or --force to overwrite.`;
+}
+function inspectWriteTarget(filePath) {
+	const resolvedPath = resolve(filePath);
+	const parentDir = dirname(resolvedPath);
+	const exists = existsSync(resolvedPath);
+	let existingType;
+	if (exists) {
+		const stat = statSync(resolvedPath);
+		if (stat.isFile()) existingType = "file";
+		else if (stat.isDirectory()) existingType = "directory";
+		else existingType = "other";
+	}
+	const checkedPath = exists && existingType === "file" ? resolvedPath : findExistingParent$1(parentDir);
+	const checkedType = getFsEntryType(checkedPath);
+	try {
+		accessSync(checkedPath, constants.W_OK);
+		return {
+			path: filePath,
+			resolvedPath,
+			parentDir,
+			exists,
+			existingType,
+			writable: true,
+			checkedPath: checkedPath !== resolvedPath ? checkedPath : void 0,
+			checkedType
+		};
+	} catch (error) {
+		return {
+			path: filePath,
+			resolvedPath,
+			parentDir,
+			exists,
+			existingType,
+			writable: false,
+			checkedPath: checkedPath !== resolvedPath ? checkedPath : void 0,
+			checkedType,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function findExistingParent$1(path) {
+	let current = path;
+	while (!existsSync(current)) {
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return current;
+}
+function getFsEntryType(path) {
+	const stat = statSync(path);
+	if (stat.isFile()) return "file";
+	if (stat.isDirectory()) return "directory";
+	return "other";
+}
+//#endregion
+//#region src/diagnostics.ts
+var KNOWN_TEMPLATE_KEYS = new Set([
+	"author",
+	"basePdf",
+	"columns",
+	"pdfmeVersion",
+	"schemas"
+]);
+var KNOWN_JOB_KEYS = new Set([
+	"template",
+	"inputs",
+	"options"
+]);
+function findClosestType(type) {
+	let bestMatch = null;
+	let bestDist = Infinity;
+	for (const known of schemaTypes) {
+		const dist = levenshtein(type.toLowerCase(), known.toLowerCase());
+		if (dist < bestDist && dist <= 3) {
+			bestDist = dist;
+			bestMatch = known;
+		}
+	}
+	return bestMatch;
+}
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+	for (let i = 0; i <= m; i++) dp[i][0] = i;
+	for (let j = 0; j <= n; j++) dp[0][j] = j;
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+	return dp[m][n];
+}
+function validateTemplate(template) {
+	const errors = [];
+	const warnings = [];
+	try {
+		checkTemplate(template);
+	} catch (error) {
+		errors.push(error instanceof Error ? error.message : String(error));
+	}
+	const schemaPages = normalizeSchemaPages$2(template.schemas);
+	if (schemaPages.length === 0) return {
+		errors,
+		warnings,
+		pages: 0,
+		fields: 0
+	};
+	const totalFields = schemaPages.reduce((sum, page) => sum + page.length, 0);
+	let pageWidth = 210;
+	let pageHeight = 297;
+	if (template.basePdf && typeof template.basePdf === "object" && "width" in template.basePdf) {
+		pageWidth = template.basePdf.width;
+		pageHeight = template.basePdf.height;
+	}
+	const allNames = /* @__PURE__ */ new Map();
+	for (let pageIdx = 0; pageIdx < schemaPages.length; pageIdx++) {
+		const page = schemaPages[pageIdx];
+		if (!Array.isArray(page)) continue;
+		const pageNames = /* @__PURE__ */ new Set();
+		for (const schema of page) {
+			if (typeof schema !== "object" || schema === null) continue;
+			const name = schema.name;
+			const type = schema.type;
+			const position = schema.position;
+			const width = schema.width;
+			const height = schema.height;
+			if (type && !schemaTypes.has(type)) {
+				const suggestion = findClosestType(type);
+				const hint = suggestion ? ` Did you mean: ${suggestion}?` : "";
+				errors.push(`Field "${name}" has unknown type "${type}".${hint} Available types: ${[...schemaTypes].join(", ")}`);
+			}
+			if (name && pageNames.has(name)) errors.push(`Duplicate field name "${name}" on page ${pageIdx + 1}`);
+			if (name) {
+				pageNames.add(name);
+				if (!allNames.has(name)) allNames.set(name, []);
+				allNames.get(name).push(pageIdx + 1);
+			}
+			if (position && width !== void 0 && height !== void 0) {
+				if (position.x + width > pageWidth + 1) warnings.push(`Field "${name}" at (${position.x},${position.y}) extends beyond page width (${pageWidth}mm)`);
+				if (position.y + height > pageHeight + 1) warnings.push(`Field "${name}" at (${position.x},${position.y}) extends beyond page height (${pageHeight}mm)`);
+				if (position.x < 0 || position.y < 0) warnings.push(`Field "${name}" has negative position (${position.x},${position.y})`);
+			}
+		}
+	}
+	for (const [name, pages] of allNames) if (pages.length > 1) warnings.push(`Field name "${name}" appears on multiple pages: ${pages.join(", ")}`);
+	return {
+		errors,
+		warnings,
+		pages: schemaPages.length,
+		fields: totalFields
+	};
+}
+function inspectTemplate(template, templateDir) {
+	const flattenedSchemas = normalizeSchemaPages$2(template.schemas).flat();
+	const collectedSchemaTypes = getUniqueStringValues(flattenedSchemas.map((schema) => schema.type));
+	const requiredFonts = getUniqueStringValues(flattenedSchemas.map((schema) => schema.fontName));
+	return {
+		schemaTypes: collectedSchemaTypes,
+		requiredPlugins: collectedSchemaTypes.filter((type) => schemaTypes.has(type)),
+		requiredFonts,
+		basePdf: summarizeBasePdf(template.basePdf, templateDir)
+	};
+}
+function collectInputHints(template) {
+	const hintMap = /* @__PURE__ */ new Map();
+	const schemaPages = normalizeSchemaPages$2(template.schemas);
+	const radioGroupMembers = collectRadioGroupMembers(schemaPages);
+	for (let pageIdx = 0; pageIdx < schemaPages.length; pageIdx++) for (const schema of schemaPages[pageIdx]) {
+		const name = typeof schema.name === "string" ? schema.name : "";
+		const type = typeof schema.type === "string" ? schema.type : "";
+		const readOnly = schema.readOnly === true;
+		if (!name || !type || readOnly) continue;
+		const hint = buildFieldInputHint(schema, pageIdx + 1, radioGroupMembers);
+		const key = [
+			hint.name,
+			hint.type,
+			hint.expectedInput.kind,
+			JSON.stringify(hint.expectedInput.example ?? null),
+			hint.expectedInput.format ?? "",
+			hint.expectedInput.canonicalFormat ?? "",
+			hint.expectedInput.contentKind ?? "",
+			hint.expectedInput.rule ?? "",
+			(hint.expectedInput.variableNames ?? []).join("\0"),
+			(hint.expectedInput.allowedValues ?? []).join("\0"),
+			hint.expectedInput.groupName ?? "",
+			(hint.expectedInput.groupMemberNames ?? []).join("\0"),
+			String(hint.expectedInput.columnCount ?? ""),
+			(hint.expectedInput.columnHeaders ?? []).join("\0"),
+			hint.expectedInput.acceptsJsonString === true ? "1" : "0"
+		].join("
");
+		const existing = hintMap.get(key);
+		if (existing) {
+			existing.pages = [...new Set([...existing.pages, pageIdx + 1])].sort((a, b) => a - b);
+			existing.required = existing.required || hint.required;
+			continue;
+		}
+		hintMap.set(key, hint);
+	}
+	return [...hintMap.values()].sort((a, b) => a.name.localeCompare(b.name) || a.type.localeCompare(b.type));
+}
+function validateInputContracts(template, inputs) {
+	const issues = getInputContractIssues(template, inputs);
+	if (issues.length > 0) fail(issues[0], {
+		code: "EVALIDATE",
+		exitCode: 1
+	});
+}
+function getInputContractIssues(template, inputs) {
+	const hints = collectInputHints(template);
+	const issues = [];
+	for (let inputIndex = 0; inputIndex < inputs.length; inputIndex++) {
+		const input = inputs[inputIndex] ?? {};
+		for (const hint of hints) {
+			const issue = getInputContractIssue(hint, input, inputIndex);
+			if (issue) issues.push(issue);
+		}
+		issues.push(...getRadioGroupSelectionIssues(hints, input, inputIndex));
+	}
+	return issues;
+}
+async function loadValidationSource(file, options) {
+	const data = await loadValidationInput(file, options.noInputMessage);
+	const record = assertRecordObject(data.json, "Validation input");
+	const hasTemplate = "template" in record;
+	const hasInputs = "inputs" in record;
+	if (hasTemplate || hasInputs) {
+		if (!hasTemplate || !hasInputs) fail("Unified job validation requires both \"template\" and \"inputs\" keys.", {
+			code: "EARG",
+			exitCode: 1
+		});
+		return {
+			mode: "job",
+			template: assertRecordObject(record.template, "Unified job template"),
+			inputs: record.inputs,
+			options: record.options,
+			templateDir: data.templateDir,
+			jobWarnings: Object.keys(record).filter((key) => !KNOWN_JOB_KEYS.has(key)).sort().map((key) => `Unknown unified job field: ${key}`)
+		};
+	}
+	return {
+		mode: "template",
+		template: assertRecordObject(record, "Template"),
+		templateDir: data.templateDir,
+		jobWarnings: []
+	};
+}
+async function loadValidationInput(file, noInputMessage) {
+	if (!file || file === "-") {
+		if (file === "-" || !process.stdin.isTTY) return { json: await readJsonFromStdin() };
+		fail(noInputMessage, {
+			code: "EARG",
+			exitCode: 1
+		});
+	}
+	const resolvedFile = resolve(file);
+	return {
+		json: readJsonFile(resolvedFile),
+		templateDir: dirname(resolvedFile)
+	};
+}
+function assertRecordObject(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${label} must be a JSON object.`, {
+		code: "EARG",
+		exitCode: 1
+	});
+	return value;
+}
+function normalizeSchemaPages$2(rawSchemas) {
+	if (!Array.isArray(rawSchemas)) return [];
+	return rawSchemas.map((page) => {
+		if (Array.isArray(page)) return page.filter((schema) => typeof schema === "object" && schema !== null);
+		if (typeof page === "object" && page !== null) return Object.values(page).filter((schema) => typeof schema === "object" && schema !== null);
+		return [];
+	});
+}
+function buildFieldInputHint(schema, page, radioGroupMembers) {
+	const type = schema.type;
+	if (type === "multiVariableText") {
+		const variableNames = getUniqueStringValues(Array.isArray(schema.variables) ? schema.variables : []);
+		return {
+			name: schema.name,
+			type,
+			pages: [page],
+			required: schema.required === true,
+			expectedInput: {
+				kind: "jsonStringObject",
+				variableNames,
+				example: buildMultiVariableTextExample(variableNames)
+			}
+		};
+	}
+	if (type === "checkbox") return {
+		name: schema.name,
+		type,
+		pages: [page],
+		required: schema.required === true,
+		expectedInput: {
+			kind: "enumString",
+			allowedValues: ["false", "true"],
+			example: "true"
+		}
+	};
+	if (type === "radioGroup") {
+		const groupName = typeof schema.group === "string" ? schema.group : "";
+		const groupMemberNames = groupName ? radioGroupMembers.get(groupName) ?? [] : [];
+		return {
+			name: schema.name,
+			type,
+			pages: [page],
+			required: schema.required === true,
+			expectedInput: {
+				kind: "enumString",
+				allowedValues: ["false", "true"],
+				example: "true",
+				...groupName ? { groupName } : {},
+				...groupMemberNames.length > 0 ? { groupMemberNames } : {}
+			}
+		};
+	}
+	if (type === "select") {
+		const allowedValues = getUniqueOrderedStringValues(Array.isArray(schema.options) ? schema.options : []);
+		if (allowedValues.length > 0) return {
+			name: schema.name,
+			type,
+			pages: [page],
+			required: schema.required === true,
+			expectedInput: {
+				kind: "enumString",
+				allowedValues,
+				example: allowedValues[0]
+			}
+		};
+	}
+	const barcodeRule = getBarcodeRule(type);
+	if (barcodeRule) return {
+		name: schema.name,
+		type,
+		pages: [page],
+		required: schema.required === true,
+		expectedInput: {
+			kind: "string",
+			contentKind: "barcodeText",
+			rule: barcodeRule
+		}
+	};
+	const assetContentKind = getAssetContentKind(type);
+	if (assetContentKind) return {
+		name: schema.name,
+		type,
+		pages: [page],
+		required: schema.required === true,
+		expectedInput: {
+			kind: "string",
+			contentKind: assetContentKind
+		}
+	};
+	if (type === "table") {
+		const columnHeaders = getOrderedStringValues(Array.isArray(schema.head) ? schema.head : []);
+		const columnCount = getTableColumnCount(schema, columnHeaders);
+		return {
+			name: schema.name,
+			type,
+			pages: [page],
+			required: schema.required === true,
+			expectedInput: {
+				kind: "stringMatrix",
+				...columnCount > 0 ? { columnCount } : {},
+				...columnHeaders.length > 0 ? { columnHeaders } : {},
+				example: buildTableInputExample(columnHeaders, columnCount),
+				acceptsJsonString: true
+			}
+		};
+	}
+	if (type === "date" || type === "time" || type === "dateTime") {
+		const canonicalFormat = getCanonicalDateStoredFormat(type);
+		return {
+			name: schema.name,
+			type,
+			pages: [page],
+			required: schema.required === true,
+			expectedInput: {
+				kind: "string",
+				format: getDateHintFormat(schema, canonicalFormat),
+				canonicalFormat,
+				example: getDateInputExample(type)
+			}
+		};
+	}
+	return {
+		name: schema.name,
+		type,
+		pages: [page],
+		required: schema.required === true,
+		expectedInput: { kind: "string" }
+	};
+}
+function buildMultiVariableTextExample(variableNames) {
+	return JSON.stringify(Object.fromEntries(variableNames.map((variableName) => [variableName, variableName.toUpperCase()])));
+}
+function buildTableInputExample(columnHeaders, columnCount) {
+	if (columnCount <= 0) return [];
+	return [Array.from({ length: columnCount }, (_, index) => {
+		const header = columnHeaders[index];
+		return header ? `${header} value` : `cell-${index + 1}`;
+	})];
+}
+function getTableColumnCount(schema, columnHeaders) {
+	if (columnHeaders.length > 0) return columnHeaders.length;
+	if (Array.isArray(schema.headWidthPercentages) && schema.headWidthPercentages.length > 0) return schema.headWidthPercentages.length;
+	return parseTableStringMatrix(schema.content)?.[0]?.length ?? 0;
+}
+function getAssetContentKind(type) {
+	switch (type) {
+		case "image": return "imageDataUrl";
+		case "signature": return "signatureImageDataUrl";
+		case "svg": return "svgMarkup";
+		default: return null;
+	}
+}
+function getBarcodeRule(type) {
+	switch (type) {
+		case "qrcode": return "Any non-empty string up to 499 characters.";
+		case "japanpost": return "Start with 7 digits, then continue with digits, A-Z, or hyphen (-).";
+		case "ean13": return "12 or 13 digits; if 13 digits are provided, the final check digit must be valid.";
+		case "ean8": return "7 or 8 digits; if 8 digits are provided, the final check digit must be valid.";
+		case "code39": return "Use uppercase A-Z, digits, spaces, and symbols - . $ / + %.";
+		case "code128": return "Text must not contain Kanji, Hiragana, Katakana, or full-width ASCII characters.";
+		case "nw7": return "Start and end with A-D; inner characters may be digits or - . $ : / +.";
+		case "itf14": return "13 or 14 digits; if 14 digits are provided, the final check digit must be valid.";
+		case "upca": return "11 or 12 digits; if 12 digits are provided, the final check digit must be valid.";
+		case "upce": return "Must start with 0 and be 7 or 8 digits total; if 8 digits are provided, the final check digit must be valid.";
+		case "gs1datamatrix": return "Include (01) followed by a GTIN of 8, 12, 13, or 14 digits with a valid check digit; total length must be 52 characters or fewer.";
+		case "pdf417": return "Any non-empty string up to 1000 characters.";
+		default: return null;
+	}
+}
+function getCanonicalDateStoredFormat(type) {
+	switch (type) {
+		case "date": return "yyyy/MM/dd";
+		case "time": return "HH:mm";
+		case "dateTime": return "yyyy/MM/dd HH:mm";
+	}
+}
+function getDateHintFormat(schema, canonicalFormat) {
+	const formatValue = typeof schema.format === "string" ? schema.format.trim() : "";
+	if (!formatValue || formatValue === "undefined") return canonicalFormat;
+	return formatValue;
+}
+function getDateInputExample(type) {
+	switch (type) {
+		case "date": return "2026/03/28";
+		case "time": return "14:30";
+		case "dateTime": return "2026/03/28 14:30";
+	}
+}
+function getInputContractIssue(hint, input, inputIndex) {
+	if (hint.expectedInput.kind === "jsonStringObject") return getMultiVariableTextInputIssue(hint, input, inputIndex);
+	if (hint.expectedInput.kind === "enumString") return getEnumStringInputIssue(hint, input, inputIndex);
+	if (hint.expectedInput.kind === "stringMatrix") return getStringMatrixInputIssue(hint, input, inputIndex);
+	if (isCanonicalDateHint(hint)) return getCanonicalDateInputIssue(hint, input, inputIndex);
+	return null;
+}
+function getMultiVariableTextInputIssue(hint, input, inputIndex) {
+	const rawValue = input[hint.name];
+	const variableNames = hint.expectedInput.variableNames ?? [];
+	const example = hint.expectedInput.example ?? "{}";
+	if (rawValue === void 0 || rawValue === "") {
+		if (!hint.required || variableNames.length === 0) return null;
+		return buildMultiVariableTextErrorMessage({
+			hint,
+			inputIndex,
+			extra: `Missing variables: ${variableNames.join(", ")}.`,
+			example
+		});
+	}
+	if (typeof rawValue !== "string") return buildMultiVariableTextErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(rawValue)}.`,
+		example
+	});
+	let parsedValue;
+	try {
+		parsedValue = JSON.parse(rawValue);
+	} catch {
+		return buildMultiVariableTextErrorMessage({
+			hint,
+			inputIndex,
+			extra: `Received ${describeValue(rawValue)}.`,
+			example
+		});
+	}
+	if (typeof parsedValue !== "object" || parsedValue === null || Array.isArray(parsedValue)) return buildMultiVariableTextErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(parsedValue)}.`,
+		example
+	});
+	if (!hint.required || variableNames.length === 0) return null;
+	const values = parsedValue;
+	const missingVariables = variableNames.filter((variableName) => !values[variableName]);
+	if (missingVariables.length > 0) return buildMultiVariableTextErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Missing variables: ${missingVariables.join(", ")}.`,
+		example
+	});
+	return null;
+}
+function getRadioGroupSelectionIssues(hints, input, inputIndex) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const hint of hints) {
+		if (hint.type !== "radioGroup" || !hint.expectedInput.groupName || (hint.expectedInput.groupMemberNames?.length ?? 0) <= 1) continue;
+		const groupName = hint.expectedInput.groupName;
+		const existing = groups.get(groupName);
+		if (existing) existing.push(hint);
+		else groups.set(groupName, [hint]);
+	}
+	const issues = [];
+	for (const [groupName, groupHints] of groups) {
+		const selectedNames = groupHints.filter((hint) => input[hint.name] === "true").map((hint) => hint.name);
+		if (selectedNames.length <= 1) continue;
+		issues.push(buildRadioGroupSelectionErrorMessage({
+			groupName,
+			inputIndex,
+			groupMemberNames: groupHints[0]?.expectedInput.groupMemberNames ?? groupHints.map((hint) => hint.name),
+			selectedNames
+		}));
+	}
+	return issues;
+}
+function getEnumStringInputIssue(hint, input, inputIndex) {
+	const rawValue = input[hint.name];
+	const allowedValues = hint.expectedInput.allowedValues ?? [];
+	const example = hint.expectedInput.example;
+	if (rawValue === void 0 || rawValue === "") return null;
+	if (typeof rawValue !== "string") return buildEnumStringErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(rawValue)}.`,
+		example
+	});
+	if (allowedValues.length === 0 || allowedValues.includes(rawValue)) return null;
+	return buildEnumStringErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(rawValue)}.`,
+		example
+	});
+}
+function getStringMatrixInputIssue(hint, input, inputIndex) {
+	const rawValue = input[hint.name];
+	const example = hint.expectedInput.example;
+	if (rawValue === void 0 || rawValue === "") return null;
+	const issue = getStringMatrixShapeIssue(typeof rawValue === "string" && hint.expectedInput.acceptsJsonString === true ? parseTableStringMatrix(rawValue) ?? rawValue : rawValue, hint.expectedInput.columnCount);
+	if (!issue) return null;
+	return buildStringMatrixErrorMessage({
+		hint,
+		inputIndex,
+		extra: issue,
+		example
+	});
+}
+function isCanonicalDateHint(hint) {
+	return (hint.type === "date" || hint.type === "time" || hint.type === "dateTime") && typeof hint.expectedInput.canonicalFormat === "string" && hint.expectedInput.canonicalFormat.length > 0;
+}
+function getCanonicalDateInputIssue(hint, input, inputIndex) {
+	const rawValue = input[hint.name];
+	const example = hint.expectedInput.example;
+	if (rawValue === void 0 || rawValue === "") return null;
+	if (typeof rawValue !== "string") return buildCanonicalDateErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(rawValue)}.`,
+		example
+	});
+	if (isValidCanonicalDateValue(rawValue, hint.type)) return null;
+	return buildCanonicalDateErrorMessage({
+		hint,
+		inputIndex,
+		extra: `Received ${describeValue(rawValue)}.`,
+		example
+	});
+}
+function getStringMatrixShapeIssue(value, expectedColumnCount) {
+	if (!Array.isArray(value)) return `Received ${describeValue(value)}.`;
+	const columnCount = expectedColumnCount ?? getFirstArrayLength(value);
+	for (let rowIndex = 0; rowIndex < value.length; rowIndex++) {
+		const row = value[rowIndex];
+		if (!Array.isArray(row)) return `Row ${rowIndex + 1} must be an array of strings. Received ${describeValue(row)}.`;
+		if (columnCount > 0 && row.length !== columnCount) return `Row ${rowIndex + 1} must contain ${columnCount} cells. Received ${row.length}.`;
+		for (let colIndex = 0; colIndex < row.length; colIndex++) {
+			const cell = row[colIndex];
+			if (typeof cell !== "string") return `Cell [${rowIndex + 1}, ${colIndex + 1}] must be a string. Received ${describeValue(cell)}.`;
+		}
+	}
+	return null;
+}
+function getFirstArrayLength(rows) {
+	for (const row of rows) if (Array.isArray(row)) return row.length;
+	return 0;
+}
+function parseTableStringMatrix(rawValue) {
+	if (typeof rawValue !== "string") return null;
+	try {
+		return JSON.parse(rawValue);
+	} catch {
+		return null;
+	}
+}
+function isValidCanonicalDateValue(value, type) {
+	switch (type) {
+		case "date": return isValidCanonicalDate(value);
+		case "time": return isValidCanonicalTime(value);
+		case "dateTime": return isValidCanonicalDateTime(value);
+	}
+}
+function isValidCanonicalDate(value) {
+	const match = value.match(/^(\d{4})\/(\d{2})\/(\d{2})$/);
+	if (!match) return false;
+	const [, year, month, day] = match;
+	if (!isValidCalendarDate(Number(year), Number(month), Number(day))) return false;
+	const parsed = parseRendererDateValue(value, "date");
+	return parsed !== null && formatCanonicalDateValue(parsed, "date") === value;
+}
+function isValidCanonicalTime(value) {
+	const match = value.match(/^(\d{2}):(\d{2})$/);
+	if (!match) return false;
+	const [, hours, minutes] = match;
+	return isValidClockTime(Number(hours), Number(minutes));
+}
+function isValidCanonicalDateTime(value) {
+	const match = value.match(/^(\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2})$/);
+	if (!match) return false;
+	const [, year, month, day, hours, minutes] = match;
+	if (!isValidCalendarDate(Number(year), Number(month), Number(day)) || !isValidClockTime(Number(hours), Number(minutes))) return false;
+	const parsed = parseRendererDateValue(value, "dateTime");
+	return parsed !== null && formatCanonicalDateValue(parsed, "dateTime") === value;
+}
+function isValidCalendarDate(year, month, day) {
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return false;
+	if (month < 1 || month > 12 || day < 1) return false;
+	const candidate = new Date(year, month - 1, day);
+	return candidate.getFullYear() === year && candidate.getMonth() === month - 1 && candidate.getDate() === day;
+}
+function isValidClockTime(hours, minutes) {
+	return Number.isInteger(hours) && Number.isInteger(minutes) && hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59;
+}
+function parseRendererDateValue(value, type) {
+	const parsed = type === "time" ? /* @__PURE__ */ new Date(`2021-01-01T${value}`) : new Date(value);
+	return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function formatCanonicalDateValue(date, type) {
+	const year = String(date.getFullYear()).padStart(4, "0");
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	const hours = String(date.getHours()).padStart(2, "0");
+	const minutes = String(date.getMinutes()).padStart(2, "0");
+	switch (type) {
+		case "date": return `${year}/${month}/${day}`;
+		case "time": return `${hours}:${minutes}`;
+		case "dateTime": return `${year}/${month}/${day} ${hours}:${minutes}`;
+	}
+}
+function buildMultiVariableTextErrorMessage(args) {
+	const variableLabel = args.hint.expectedInput.variableNames && args.hint.expectedInput.variableNames.length > 0 ? ` with variables: ${args.hint.expectedInput.variableNames.join(", ")}` : "";
+	return `Field "${args.hint.name}" (multiVariableText) in input ${args.inputIndex + 1} expects a JSON string object${variableLabel}. Example: ${args.example}. ${args.extra}`;
+}
+function buildEnumStringErrorMessage(args) {
+	const allowedValues = (args.hint.expectedInput.allowedValues ?? []).map((value) => JSON.stringify(value));
+	const allowedLabel = allowedValues.length > 0 ? ` one of: ${allowedValues.join(", ")}` : " a supported string value";
+	const exampleLabel = args.example !== void 0 ? ` Example: ${JSON.stringify(args.example)}.` : "";
+	return `Field "${args.hint.name}" (${args.hint.type}) in input ${args.inputIndex + 1} expects${allowedLabel}.${exampleLabel} ${args.extra}`.trim();
+}
+function buildStringMatrixErrorMessage(args) {
+	const columnCount = args.hint.expectedInput.columnCount;
+	const columnHeaders = args.hint.expectedInput.columnHeaders ?? [];
+	const columnLabel = typeof columnCount === "number" && columnCount > 0 ? ` with ${columnCount} cells per row` : "";
+	const headerLabel = columnHeaders.length > 0 ? ` Column headers: ${columnHeaders.join(", ")}.` : "";
+	const exampleLabel = args.example !== void 0 ? ` Example: ${JSON.stringify(args.example)}.` : "";
+	const compatibilityLabel = args.hint.expectedInput.acceptsJsonString === true ? " JSON string input is also accepted for compatibility." : "";
+	return `Field "${args.hint.name}" (${args.hint.type}) in input ${args.inputIndex + 1} expects a JSON array of string arrays${columnLabel}.${headerLabel}${exampleLabel}${compatibilityLabel} ${args.extra}`.trim();
+}
+function buildCanonicalDateErrorMessage(args) {
+	const displayFormat = args.hint.expectedInput.format;
+	const displayLabel = typeof displayFormat === "string" && displayFormat.length > 0 && displayFormat !== args.hint.expectedInput.canonicalFormat ? ` Display format hint: ${displayFormat}.` : "";
+	const exampleLabel = args.example !== void 0 ? ` Example: ${JSON.stringify(args.example)}.` : "";
+	return `Field "${args.hint.name}" (${args.hint.type}) in input ${args.inputIndex + 1} expects canonical stored content in format ${args.hint.expectedInput.canonicalFormat}.${displayLabel}${exampleLabel} ${args.extra}`.trim();
+}
+function buildRadioGroupSelectionErrorMessage(args) {
+	return `Radio group "${args.groupName}" in input ${args.inputIndex + 1} allows at most one "true" value across fields: ${args.groupMemberNames.join(", ")}. Received "true" for: ${args.selectedNames.join(", ")}. Set one field to "true" and the others to "false".`;
+}
+function describeValue(value) {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		return `${trimmed.startsWith("{") || trimmed.startsWith("[") ? "string" : "plain string"} ${JSON.stringify(value)}`;
+	}
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "number" || typeof value === "boolean") return `${typeof value} ${JSON.stringify(value)}`;
+	return typeof value;
+}
+function getUniqueStringValues(values) {
+	return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))].sort();
+}
+function getUniqueOrderedStringValues(values) {
+	return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function getOrderedStringValues(values) {
+	return values.filter((value) => typeof value === "string" && value.length > 0);
+}
+function collectRadioGroupMembers(schemaPages) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const page of schemaPages) for (const schema of page) {
+		if (schema.readOnly === true || schema.type !== "radioGroup") continue;
+		const name = typeof schema.name === "string" ? schema.name : "";
+		const groupName = typeof schema.group === "string" ? schema.group : "";
+		if (!name || !groupName) continue;
+		const existing = groups.get(groupName);
+		if (existing) {
+			if (!existing.includes(name)) existing.push(name);
+		} else groups.set(groupName, [name]);
+	}
+	return groups;
+}
+function summarizeBasePdf(basePdf, templateDir) {
+	if (typeof basePdf === "string") {
+		if (basePdf.startsWith("data:")) return { kind: "dataUri" };
+		if (basePdf.endsWith(".pdf")) return {
+			kind: "pdfPath",
+			path: basePdf,
+			resolvedPath: templateDir ? resolve(templateDir, basePdf) : resolve(basePdf)
+		};
+		return { kind: "string" };
+	}
+	if (basePdf && typeof basePdf === "object") {
+		if ("width" in basePdf && "height" in basePdf) {
+			const width = typeof basePdf.width === "number" ? basePdf.width : void 0;
+			const height = typeof basePdf.height === "number" ? basePdf.height : void 0;
+			return {
+				kind: "blank",
+				width,
+				height,
+				paperSize: width !== void 0 && height !== void 0 ? detectPaperSize(width, height) : null
+			};
+		}
+		return { kind: "object" };
+	}
+	return { kind: "missing" };
+}
+//#endregion
+//#region src/fonts.ts
+var CACHE_DIR = join(homedir(), ".pdfme", "fonts");
+var NOTO_SANS_JP_URL = "https://github.com/google/fonts/raw/main/ofl/notosansjp/NotoSansJP%5Bwght%5D.ttf";
+var NOTO_CACHE_FILE = join(CACHE_DIR, "NotoSansJP-Regular.ttf");
+var REMOTE_FONT_TIMEOUT_MS = 15e3;
+var MAX_REMOTE_FONT_BYTES = 32 * 1024 * 1024;
+function ensureCacheDir() {
+	if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+}
+async function downloadNotoSansJP(verbose) {
+	if (existsSync(NOTO_CACHE_FILE)) {
+		if (verbose) console.error("Using cached NotoSansJP from", NOTO_CACHE_FILE);
+		return new Uint8Array(readFileSync(NOTO_CACHE_FILE));
+	}
+	ensureCacheDir();
+	console.error("Downloading NotoSansJP for CJK support...");
+	try {
+		const response = await fetch(NOTO_SANS_JP_URL);
+		if (!response.ok) {
+			console.error(`Warning: Failed to download NotoSansJP (HTTP ${response.status})`);
+			return null;
+		}
+		const buffer = new Uint8Array(await response.arrayBuffer());
+		writeFileSync(NOTO_CACHE_FILE, buffer);
+		console.error("Cached NotoSansJP to", NOTO_CACHE_FILE);
+		return buffer;
+	} catch (error) {
+		console.error("Warning: Could not download NotoSansJP. CJK text may not render correctly.", error instanceof Error ? error.message : "");
+		return null;
+	}
+}
+function parseCustomFonts(fontArgs) {
+	const font = {};
+	for (let i = 0; i < fontArgs.length; i++) {
+		const arg = fontArgs[i];
+		const eqIndex = arg.indexOf("=");
+		if (eqIndex === -1) fail(`Invalid --font format ${JSON.stringify(arg)}. Expected name=path, for example "NotoSansJP=./fonts/NotoSansJP.ttf".`, {
+			code: "EARG",
+			exitCode: 1
+		});
+		const name = arg.slice(0, eqIndex);
+		const filePath = resolve(arg.slice(eqIndex + 1));
+		if (!existsSync(filePath)) fail(`Font file not found: ${filePath}`, {
+			code: "EIO",
+			exitCode: 3
+		});
+		if (extname(filePath).toLowerCase() !== ".ttf") fail(`Unsupported font format for ${filePath}. @pdfme/cli currently guarantees only .ttf custom fonts.`, {
+			code: "EUNSUPPORTED",
+			exitCode: 1
+		});
+		font[name] = {
+			data: new Uint8Array(readFileSync(filePath)),
+			fallback: i === 0,
+			subset: true
+		};
+	}
+	return font;
+}
+function analyzeExplicitFontRecord(fontRecord, templateDir) {
+	const issues = [];
+	const warnings = [];
+	const sources = [];
+	for (const fontName of Object.keys(fontRecord).sort()) {
+		const result = analyzeExplicitFontSource(fontName, fontRecord[fontName], templateDir);
+		sources.push(result.source);
+		issues.push(...result.issues);
+		warnings.push(...result.warnings);
+	}
+	return {
+		sources,
+		issues,
+		warnings
+	};
+}
+async function normalizeExplicitFontOption(jobFont, templateDir) {
+	if (jobFont === void 0) return;
+	if (typeof jobFont !== "object" || jobFont === null || Array.isArray(jobFont)) fail("Unified job options.font must be an object.", {
+		code: "EARG",
+		exitCode: 1
+	});
+	const normalized = {};
+	const fontRecord = jobFont;
+	for (const fontName of Object.keys(fontRecord).sort()) normalized[fontName] = await normalizeExplicitFontSource(fontName, fontRecord[fontName], templateDir);
+	return normalized;
+}
+function analyzeExplicitFontSource(fontName, value, templateDir) {
+	const issues = [];
+	const warnings = [];
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		issues.push(`Font config for ${fontName} must be an object with a "data" field.`);
+		return {
+			source: {
+				fontName,
+				kind: "invalid",
+				needsNetwork: false,
+				dataType: getValueType(value)
+			},
+			issues,
+			warnings
+		};
+	}
+	const data = value.data;
+	if (data === void 0) {
+		issues.push(`Font config for ${fontName} is missing "data".`);
+		return {
+			source: {
+				fontName,
+				kind: "invalid",
+				needsNetwork: false,
+				dataType: "missing"
+			},
+			issues,
+			warnings
+		};
+	}
+	if (typeof data === "string") {
+		if (data.startsWith("data:")) return analyzeDataUriFontSource(fontName, data);
+		const parsedUrl = tryParseUrl(data);
+		if (parsedUrl) {
+			if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") return analyzeUrlFontSource(fontName, parsedUrl);
+			issues.push(`Font source for ${fontName} uses unsupported URL protocol "${parsedUrl.protocol}". Use a local .ttf path, a data URI, or an https URL.`);
+			return {
+				source: {
+					fontName,
+					kind: "invalid",
+					needsNetwork: false,
+					dataType: "string"
+				},
+				issues,
+				warnings
+			};
+		}
+		return analyzeLocalFontSource(fontName, data, templateDir);
+	}
+	if (data instanceof Uint8Array || data instanceof ArrayBuffer) return {
+		source: {
+			fontName,
+			kind: "inlineBytes",
+			needsNetwork: false,
+			dataType: getValueType(data)
+		},
+		issues,
+		warnings
+	};
+	issues.push(`Font source for ${fontName} has unsupported data type ${getValueType(data)}.`);
+	return {
+		source: {
+			fontName,
+			kind: "invalid",
+			needsNetwork: false,
+			dataType: getValueType(data)
+		},
+		issues,
+		warnings
+	};
+}
+function analyzeLocalFontSource(fontName, pathValue, templateDir) {
+	const issues = [];
+	const warnings = [];
+	const resolvedPath = templateDir ? resolve(templateDir, pathValue) : resolve(pathValue);
+	const exists = existsSync(resolvedPath);
+	const formatHint = detectPathFormatHint(resolvedPath);
+	const formatResult = evaluateFontFormat(fontName, formatHint, `Font file for ${fontName}`);
+	if (!exists) issues.push(`Font file for ${fontName} not found: ${resolvedPath}`);
+	if (formatResult.issue) issues.push(formatResult.issue);
+	if (formatResult.warning) warnings.push(formatResult.warning);
+	return {
+		source: {
+			fontName,
+			kind: "localPath",
+			path: pathValue,
+			resolvedPath,
+			exists,
+			formatHint,
+			supportedFormat: formatResult.supportedFormat,
+			needsNetwork: false,
+			dataType: "string"
+		},
+		issues,
+		warnings
+	};
+}
+function analyzeUrlFontSource(fontName, url) {
+	const issues = [];
+	const warnings = [];
+	const provider = detectRemoteFontProvider(url);
+	const formatHint = detectPathFormatHint(url.pathname);
+	const formatResult = evaluateFontFormat(fontName, formatHint, `Font URL for ${fontName}`);
+	if (provider === "googleFontsStylesheet") issues.push(`Font URL for ${fontName} uses the unsupported Google Fonts stylesheet API. Use the direct fonts.gstatic.com asset URL or download the font locally.`);
+	if (!isUrlSafeToFetch(url.toString())) issues.push(`Font URL for ${fontName} is invalid or unsafe. Only http: and https: URLs pointing to public hosts are allowed.`);
+	if (provider !== "googleFontsStylesheet" && formatResult.issue) issues.push(formatResult.issue);
+	if (provider !== "googleFontsStylesheet" && formatResult.warning) warnings.push(formatResult.warning);
+	return {
+		source: {
+			fontName,
+			kind: "url",
+			provider,
+			url: url.toString(),
+			formatHint,
+			supportedFormat: formatResult.supportedFormat,
+			needsNetwork: true,
+			dataType: "string"
+		},
+		issues,
+		warnings
+	};
+}
+function analyzeDataUriFontSource(fontName, dataUri) {
+	const issues = [];
+	const warnings = [];
+	const mediaType = getDataUriMediaType(dataUri);
+	const formatHint = detectDataUriFormatHint(mediaType);
+	const formatResult = evaluateFontFormat(fontName, formatHint, `Font data URI for ${fontName}`);
+	if (formatResult.issue) issues.push(formatResult.issue);
+	if (formatResult.warning) warnings.push(formatResult.warning);
+	return {
+		source: {
+			fontName,
+			kind: "dataUri",
+			mediaType,
+			formatHint,
+			supportedFormat: formatResult.supportedFormat,
+			needsNetwork: false,
+			dataType: "string"
+		},
+		issues,
+		warnings
+	};
+}
+async function normalizeExplicitFontSource(fontName, value, templateDir) {
+	const analysis = analyzeExplicitFontSource(fontName, value, templateDir);
+	for (const issue of analysis.issues) {
+		const code = issue.includes("not found") ? "EIO" : issue.includes("unsupported") || issue.includes("unsafe") || issue.includes("uses .") ? "EUNSUPPORTED" : "EARG";
+		fail(issue, {
+			code,
+			exitCode: code === "EIO" ? 3 : 1
+		});
+	}
+	const record = value;
+	const data = record.data;
+	if (analysis.source.kind === "localPath") return {
+		...record,
+		data: new Uint8Array(readFileSync(analysis.source.resolvedPath))
+	};
+	if (analysis.source.kind === "url") return {
+		...record,
+		data: await fetchRemoteFontSource(analysis.source)
+	};
+	if (analysis.source.kind === "dataUri" || analysis.source.kind === "inlineBytes") {
+		const normalizedData = typeof data === "string" ? data : data instanceof Uint8Array ? data : data;
+		return {
+			...record,
+			data: normalizedData
+		};
+	}
+	fail(`Font source for ${fontName} has unsupported data type ${getValueType(data)}.`, {
+		code: "EARG",
+		exitCode: 1
+	});
+}
+async function fetchRemoteFontSource(source) {
+	const url = source.url;
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(REMOTE_FONT_TIMEOUT_MS) });
+		if (!response.ok) failRemoteFontFetch(source, `Failed to fetch remote font data from ${url}. HTTP ${response.status}`);
+		const contentLengthHeader = response.headers.get("content-length");
+		const declaredLength = contentLengthHeader ? Number(contentLengthHeader) : NaN;
+		if (Number.isFinite(declaredLength) && declaredLength > MAX_REMOTE_FONT_BYTES) failRemoteFontFetch(source, `Remote font data from ${url} exceeds the ${MAX_REMOTE_FONT_BYTES}-byte safety limit.`);
+		return await readResponseBodyWithLimit(response, source);
+	} catch (error) {
+		if (error instanceof CliError) throw error;
+		failRemoteFontFetch(source, `Failed to fetch remote font data from ${url}. ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function failRemoteFontFetch(source, message) {
+	fail(message, {
+		code: "EFONT",
+		exitCode: 2,
+		details: {
+			fontName: source.fontName,
+			url: source.url,
+			provider: source.provider,
+			timeoutMs: REMOTE_FONT_TIMEOUT_MS,
+			maxBytes: MAX_REMOTE_FONT_BYTES
+		}
+	});
+}
+async function readResponseBodyWithLimit(response, source) {
+	if (!response.body) {
+		const buffer = new Uint8Array(await response.arrayBuffer());
+		if (buffer.byteLength > MAX_REMOTE_FONT_BYTES) failRemoteFontFetch(source, `Remote font data from ${source.url} exceeds the ${MAX_REMOTE_FONT_BYTES}-byte safety limit.`);
+		return buffer;
+	}
+	const reader = response.body.getReader();
+	const chunks = [];
+	let total = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (!value) continue;
+		total += value.byteLength;
+		if (total > MAX_REMOTE_FONT_BYTES) failRemoteFontFetch(source, `Remote font data from ${source.url} exceeds the ${MAX_REMOTE_FONT_BYTES}-byte safety limit.`);
+		chunks.push(value);
+	}
+	const merged = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return merged;
+}
+function tryParseUrl(value) {
+	try {
+		return new URL(value);
+	} catch {
+		return null;
+	}
+}
+function detectRemoteFontProvider(url) {
+	const hostname = url.hostname.toLowerCase();
+	if (hostname === "fonts.gstatic.com" || hostname.endsWith(".fonts.gstatic.com")) return "googleFontsAsset";
+	if (hostname === "fonts.googleapis.com" || hostname.endsWith(".fonts.googleapis.com")) return "googleFontsStylesheet";
+	return "genericPublic";
+}
+function getDataUriMediaType(value) {
+	const match = value.match(/^data:([^;,]+)/i);
+	return match ? match[1] : void 0;
+}
+function detectPathFormatHint(value) {
+	const extension = extname(value).toLowerCase();
+	return extension ? extension.slice(1) : null;
+}
+function detectDataUriFormatHint(mediaType) {
+	if (!mediaType) return null;
+	const lower = mediaType.toLowerCase();
+	if (lower.includes("ttf") || lower.endsWith("/sfnt")) return "ttf";
+	if (lower.includes("otf")) return "otf";
+	if (lower.includes("ttc")) return "ttc";
+	return null;
+}
+function evaluateFontFormat(fontName, formatHint, sourceLabel) {
+	if (formatHint === "ttf") return { supportedFormat: true };
+	if (formatHint === null) return { warning: `${sourceLabel} does not clearly advertise a .ttf format. @pdfme/cli currently guarantees only .ttf custom fonts.` };
+	return {
+		supportedFormat: false,
+		issue: `${sourceLabel} uses .${formatHint}. @pdfme/cli currently guarantees only .ttf custom fonts for ${fontName}.`
+	};
+}
+function getValueType(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (value instanceof Uint8Array) return "Uint8Array";
+	if (value instanceof ArrayBuffer) return "ArrayBuffer";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+async function resolveFont(options) {
+	const { fontArgs, hasCJK, noAutoFont, verbose, hasExplicitFontConfig = false } = options;
+	if (fontArgs && fontArgs.length > 0) return parseCustomFonts(fontArgs);
+	const defaultFont = getDefaultFont();
+	if (!hasCJK || hasExplicitFontConfig) return defaultFont;
+	if (noAutoFont) fail("CJK text detected, but automatic NotoSansJP download is disabled by --noAutoFont and no explicit font source was provided. Provide --font or options.font.", {
+		code: "EFONT",
+		exitCode: 2,
+		details: {
+			fontName: "NotoSansJP",
+			cacheFile: NOTO_CACHE_FILE,
+			autoFont: false
+		}
+	});
+	const notoData = await downloadNotoSansJP(verbose);
+	if (!notoData) fail("CJK text detected, but NotoSansJP could not be resolved automatically. Re-run with network access, warm the font cache, or provide --font / options.font.", {
+		code: "EFONT",
+		exitCode: 2,
+		details: {
+			fontName: "NotoSansJP",
+			cacheFile: NOTO_CACHE_FILE,
+			downloadUrl: NOTO_SANS_JP_URL,
+			autoFont: true
+		}
+	});
+	return {
+		NotoSansJP: {
+			data: notoData,
+			fallback: true,
+			subset: true
+		},
+		...Object.fromEntries(Object.entries(defaultFont).map(([k, v]) => [k, {
+			...v,
+			fallback: false
+		}]))
+	};
+}
+//#endregion
+//#region src/cjk-detect.ts
+var CJK_RANGES = [
+	[19968, 40959],
+	[13312, 19903],
+	[12352, 12447],
+	[12448, 12543],
+	[44032, 55215],
+	[12288, 12351],
+	[65280, 65519]
+];
+function containsCJK(text) {
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		for (const [start, end] of CJK_RANGES) if (code >= start && code <= end) return true;
+	}
+	return false;
+}
+function detectCJKInTemplate(template) {
+	if (!Array.isArray(template.schemas)) return false;
+	for (const page of template.schemas) {
+		if (!Array.isArray(page)) continue;
+		for (const schema of page) {
+			if (typeof schema !== "object" || schema === null) continue;
+			if (typeof schema.content === "string" && containsCJK(schema.content)) return true;
+		}
+	}
+	return false;
+}
+function detectCJKInInputs(inputs) {
+	if (!Array.isArray(inputs)) return false;
+	for (const input of inputs) {
+		if (typeof input !== "object" || input === null) continue;
+		for (const value of Object.values(input)) if (typeof value === "string" && containsCJK(value)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/grid.ts
+var schemaColorCache = /* @__PURE__ */ new Map();
+function hashString(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i++) hash = hash * 31 + value.charCodeAt(i) >>> 0;
+	return hash;
+}
+function hslToHex(hue, saturation, lightness) {
+	const s = saturation / 100;
+	const l = lightness / 100;
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const h = hue / 60;
+	const x = c * (1 - Math.abs(h % 2 - 1));
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (h >= 0 && h < 1) {
+		r = c;
+		g = x;
+	} else if (h < 2) {
+		r = x;
+		g = c;
+	} else if (h < 3) {
+		g = c;
+		b = x;
+	} else if (h < 4) {
+		g = x;
+		b = c;
+	} else if (h < 5) {
+		r = x;
+		b = c;
+	} else {
+		r = c;
+		b = x;
+	}
+	const m = l - c / 2;
+	const toHex = (channel) => Math.round((channel + m) * 255).toString(16).padStart(2, "0");
+	return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function getSchemaColor(type) {
+	const normalizedType = type.trim().toLowerCase();
+	const cached = schemaColorCache.get(normalizedType);
+	if (cached) return cached;
+	const hash = hashString(normalizedType);
+	const color = hslToHex(hash % 360, 65 + hash % 12, 42 + (hash >> 8) % 10);
+	schemaColorCache.set(normalizedType, color);
+	return color;
+}
+function drawGridLines(ctx, pxPerMm, pageWidthMm, pageHeightMm, imgWidth, imgHeight, gridSizeMm, withLabels) {
+	ctx.strokeStyle = "rgba(128, 128, 128, 0.3)";
+	ctx.lineWidth = 1;
+	for (let x = 0; x <= pageWidthMm; x += gridSizeMm) {
+		const px = x * pxPerMm;
+		ctx.beginPath();
+		ctx.moveTo(px, 0);
+		ctx.lineTo(px, imgHeight);
+		ctx.stroke();
+		if (withLabels && x % (gridSizeMm * 2) === 0 && x > 0) {
+			ctx.fillStyle = "rgba(100, 100, 100, 0.7)";
+			ctx.font = `${Math.max(9, pxPerMm * 2.5)}px sans-serif`;
+			ctx.fillText(`${x}`, px + 2, 12);
+		}
+	}
+	for (let y = 0; y <= pageHeightMm; y += gridSizeMm) {
+		const px = y * pxPerMm;
+		ctx.beginPath();
+		ctx.moveTo(0, px);
+		ctx.lineTo(imgWidth, px);
+		ctx.stroke();
+		if (withLabels && y % (gridSizeMm * 2) === 0 && y > 0) {
+			ctx.fillStyle = "rgba(100, 100, 100, 0.7)";
+			ctx.font = `${Math.max(9, pxPerMm * 2.5)}px sans-serif`;
+			ctx.fillText(`${y}`, 2, px - 2);
+		}
+	}
+}
+function drawSchemaOverlays(ctx, schemas, pxPerMm) {
+	for (const schema of schemas) {
+		const color = getSchemaColor(schema.type);
+		const x = schema.position.x * pxPerMm;
+		const y = schema.position.y * pxPerMm;
+		const w = schema.width * pxPerMm;
+		const h = schema.height * pxPerMm;
+		ctx.strokeStyle = color;
+		ctx.lineWidth = 2;
+		ctx.setLineDash([4, 2]);
+		ctx.strokeRect(x, y, w, h);
+		ctx.setLineDash([]);
+		const label = `${schema.name} (${schema.type})`;
+		const fontSize = Math.max(10, Math.min(14, pxPerMm * 3));
+		ctx.font = `${fontSize}px sans-serif`;
+		const metrics = ctx.measureText(label);
+		const labelHeight = fontSize + 4;
+		const labelWidth = metrics.width + 6;
+		ctx.fillStyle = color;
+		ctx.globalAlpha = .85;
+		ctx.fillRect(x, y - labelHeight, labelWidth, labelHeight);
+		ctx.globalAlpha = 1;
+		ctx.fillStyle = "#FFFFFF";
+		ctx.fillText(label, x + 3, y - 3);
+	}
+}
+async function loadAndPrepareCanvas(imageBuffer) {
+	const { createCanvas, loadImage } = await import("@napi-rs/canvas");
+	const img = await loadImage(Buffer.from(imageBuffer));
+	const canvas = createCanvas(img.width, img.height);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(img, 0, 0);
+	return {
+		canvas,
+		ctx,
+		img
+	};
+}
+function bufferToArrayBuffer(buffer) {
+	const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+	new Uint8Array(arrayBuffer).set(buffer);
+	return arrayBuffer;
+}
+/**
+* Draw grid lines and schema boundary overlays on a generated PDF page image.
+* Used by `pdfme generate --grid`.
+*/
+async function drawGridOnImage(imageBuffer, schemas, gridSizeMm, pageWidthMm, pageHeightMm, imageType) {
+	const { canvas, ctx, img } = await loadAndPrepareCanvas(imageBuffer);
+	const pxPerMm = img.width / pageWidthMm;
+	drawGridLines(ctx, pxPerMm, pageWidthMm, pageHeightMm, img.width, img.height, gridSizeMm, false);
+	drawSchemaOverlays(ctx, schemas, pxPerMm);
+	const mimeType = imageType === "jpeg" ? "image/jpeg" : "image/png";
+	return bufferToArrayBuffer(canvas.toBuffer(mimeType));
+}
+/**
+* Draw grid lines with mm coordinate labels on a plain PDF image.
+* Used by `pdfme pdf2img --grid`.
+*/
+async function drawGridOnPdfImage(imageBuffer, gridSizeMm, pageWidthMm, pageHeightMm, imageType) {
+	const { canvas, ctx, img } = await loadAndPrepareCanvas(imageBuffer);
+	drawGridLines(ctx, img.width / pageWidthMm, pageWidthMm, pageHeightMm, img.width, img.height, gridSizeMm, true);
+	const mimeType = imageType === "jpeg" ? "image/jpeg" : "image/png";
+	return bufferToArrayBuffer(canvas.toBuffer(mimeType));
+}
+//#endregion
+//#region src/commands/generate.ts
+var generateArgs = {
+	file: {
+		type: "positional",
+		description: "Unified JSON file: { template, inputs }",
+		required: false
+	},
+	template: {
+		type: "string",
+		alias: "t",
+		description: "Template JSON file"
+	},
+	inputs: {
+		type: "string",
+		alias: "i",
+		description: "Input data JSON file"
+	},
+	output: {
+		type: "string",
+		alias: "o",
+		description: "Output PDF path",
+		default: "output.pdf"
+	},
+	force: {
+		type: "boolean",
+		description: "Allow overwriting the implicit default output path",
+		default: false
+	},
+	image: {
+		type: "boolean",
+		description: "Also output PNG images per page",
+		default: false
+	},
+	imageFormat: {
+		type: "string",
+		description: "Image format: png | jpeg",
+		default: "png"
+	},
+	scale: {
+		type: "string",
+		description: "Image render scale",
+		default: "1"
+	},
+	grid: {
+		type: "boolean",
+		description: "Overlay grid + schema boundaries on images",
+		default: false
+	},
+	gridSize: {
+		type: "string",
+		description: "Grid spacing in mm",
+		default: "10"
+	},
+	font: {
+		type: "string",
+		description: "Custom font(s): name=path (comma-separated for multiple)"
+	},
+	basePdf: {
+		type: "string",
+		description: "Override basePdf with PDF file path"
+	},
+	noAutoFont: {
+		type: "boolean",
+		description: "Disable automatic CJK font download",
+		default: false
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output",
+		default: false
+	}
+};
+var generate_default = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Generate PDF from template and inputs"
+	},
+	args: generateArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, generateArgs);
+			const imageFormat = parseEnumArg("imageFormat", args.imageFormat, ["png", "jpeg"]);
+			const scale = parsePositiveNumberArg("scale", args.scale);
+			const gridSize = parsePositiveNumberArg("gridSize", args.gridSize);
+			ensureSafeDefaultOutputPath({
+				filePath: args.output,
+				rawArgs,
+				optionName: "output",
+				optionAlias: "o",
+				defaultValue: "output.pdf",
+				force: Boolean(args.force)
+			});
+			const { template: rawTemplate, inputs, options: rawJobOptions, templateDir } = loadInput({
+				_: args.file ? [args.file] : [],
+				template: args.template,
+				inputs: args.inputs
+			});
+			const template = resolveBasePdf(rawTemplate, args.basePdf, templateDir);
+			const mode = args.file ? "job" : "template+inputs";
+			const templatePageCount = normalizeSchemaPages$1(template.schemas).length;
+			const jobOptions = normalizeJobOptions(rawJobOptions);
+			assertSupportedSchemaTypes(template);
+			const resolvedFont = await resolveFont({
+				fontArgs: args.font ? args.font.split(",").map((value) => value.trim()).filter(Boolean) : void 0,
+				hasCJK: detectCJKInTemplate(template) || detectCJKInInputs(inputs),
+				noAutoFont: Boolean(args.noAutoFont),
+				verbose: Boolean(args.verbose),
+				hasExplicitFontConfig: hasExplicitFontEntries(jobOptions.font)
+			});
+			const font = await normalizeExplicitFontOption(mergeFontConfig(jobOptions.font, resolvedFont), templateDir) ?? resolvedFont;
+			const generateOptions = {
+				...jobOptions,
+				font
+			};
+			try {
+				checkGenerateProps({
+					template,
+					inputs,
+					options: generateOptions
+				});
+			} catch (error) {
+				fail(`Invalid generation input. ${error instanceof Error ? error.message : String(error)}`, {
+					code: "EVALIDATE",
+					exitCode: 1,
+					cause: error
+				});
+			}
+			validateInputContracts(template, inputs);
+			if (args.verbose) {
+				console.error(`Input: ${describeGenerateInput(args.file, args.template, args.inputs)}`);
+				console.error(`Mode: ${mode}`);
+				console.error(`Template pages: ${templatePageCount}`);
+				console.error(`Inputs: ${inputs.length} set(s)`);
+				console.error(`Output: ${args.output}`);
+				console.error(`Images: ${args.image || args.grid ? `enabled (${imageFormat}, scale=${scale}, grid=${args.grid ? `${gridSize}mm` : "disabled"})` : "disabled"}`);
+				console.error(`Fonts: ${Object.keys(font).join(", ")}`);
+				if (args.basePdf) console.error(`Base PDF override: ${args.basePdf}`);
+			}
+			const pdf = await generate({
+				template,
+				inputs,
+				options: generateOptions,
+				plugins: schemaPlugins
+			});
+			const pageCount = (await PDFDocument.load(pdf, { updateMetadata: false })).getPageCount();
+			writeOutput(args.output, pdf);
+			const result = {
+				command: "generate",
+				mode,
+				templatePageCount,
+				inputCount: inputs.length,
+				pageCount,
+				outputPath: args.output,
+				outputBytes: pdf.byteLength
+			};
+			if (args.image || args.grid) {
+				const images = await pdf2img(pdf, {
+					scale,
+					imageType: imageFormat
+				});
+				const imagePaths = getImageOutputPaths(args.output, images.length, imageFormat);
+				if (args.grid) {
+					const renderedPageSizes = await pdf2size(pdf);
+					for (let i = 0; i < images.length; i++) {
+						const templateSchemas = template.schemas ?? [];
+						const pageSchemas = templateSchemas[i % templateSchemas.length] ?? [];
+						const size = renderedPageSizes[i] ?? renderedPageSizes[0] ?? {
+							width: 210,
+							height: 297
+						};
+						const gridImage = await drawGridOnImage(images[i], pageSchemas, gridSize, size.width, size.height, imageFormat);
+						writeOutput(imagePaths[i], gridImage);
+					}
+				} else for (let i = 0; i < images.length; i++) writeOutput(imagePaths[i], images[i]);
+				result.imagePaths = imagePaths;
+			}
+			if (args.json) printJson({
+				ok: true,
+				...result
+			});
+			else {
+				console.log(`\u2713 Output: ${args.output} (${formatBytes(pdf.byteLength)})`);
+				if (result.imagePaths) for (const img of result.imagePaths) console.log(`\u2713 Image: ${img}`);
+			}
+		});
+	}
+});
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function normalizeJobOptions(rawJobOptions) {
+	if (rawJobOptions === void 0) return {};
+	if (typeof rawJobOptions !== "object" || rawJobOptions === null || Array.isArray(rawJobOptions)) fail("Unified job options must be a JSON object.", {
+		code: "EARG",
+		exitCode: 1
+	});
+	return rawJobOptions;
+}
+function mergeFontConfig(jobFont, resolvedFont) {
+	if (jobFont === void 0) return resolvedFont;
+	if (typeof jobFont !== "object" || jobFont === null || Array.isArray(jobFont)) fail("Unified job options.font must be an object.", {
+		code: "EARG",
+		exitCode: 1
+	});
+	return {
+		...jobFont,
+		...resolvedFont
+	};
+}
+function hasExplicitFontEntries(jobFont) {
+	if (typeof jobFont !== "object" || jobFont === null || Array.isArray(jobFont)) return false;
+	return Object.keys(jobFont).length > 0;
+}
+function assertSupportedSchemaTypes(template) {
+	const unsupported = [];
+	for (const page of normalizeSchemaPages$1(template.schemas)) for (const schema of page) {
+		const type = schema.type;
+		if (typeof type === "string" && !schemaTypes.has(type)) {
+			const name = typeof schema.name === "string" && schema.name.length > 0 ? schema.name : null;
+			unsupported.push(name ? `Field "${name}" has unknown type "${type}"` : `Unknown schema type "${type}"`);
+		}
+	}
+	if (unsupported.length > 0) fail(`Invalid generation input. ${unsupported.join("; ")}`, {
+		code: "EVALIDATE",
+		exitCode: 1
+	});
+}
+function describeGenerateInput(file, template, inputs) {
+	if (file) return file;
+	if (template || inputs) return `${template ?? "(missing template)"} + ${inputs ?? "(missing inputs)"}`;
+	return "(unknown)";
+}
+function normalizeSchemaPages$1(rawSchemas) {
+	if (!Array.isArray(rawSchemas)) return [];
+	return rawSchemas.map((page) => {
+		if (Array.isArray(page)) return page.filter((schema) => typeof schema === "object" && schema !== null);
+		if (typeof page === "object" && page !== null) return Object.values(page).filter((schema) => typeof schema === "object" && schema !== null);
+		return [];
+	});
+}
+//#endregion
+//#region src/commands/validate.ts
+var validateArgs = {
+	file: {
+		type: "positional",
+		description: "Template JSON file, unified job file, or \"-\" for stdin",
+		required: false
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output",
+		default: false
+	},
+	strict: {
+		type: "boolean",
+		description: "Treat warnings as errors",
+		default: false
+	}
+};
+var validate_default = defineCommand({
+	meta: {
+		name: "validate",
+		description: "Validate a pdfme template JSON file"
+	},
+	args: validateArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, validateArgs);
+			const source = await loadValidationSource(args.file, { noInputMessage: "No validation input provided. Pass a file path or pipe JSON via stdin." });
+			const templateUnknownKeys = Object.keys(source.template).filter((key) => !KNOWN_TEMPLATE_KEYS.has(key)).sort();
+			const inspection = inspectTemplate(source.template, source.templateDir);
+			const resolvedTemplate = resolveBasePdf(source.template, void 0, source.templateDir);
+			const result = validateTemplate(resolvedTemplate);
+			result.warnings.push(...source.jobWarnings);
+			if (templateUnknownKeys.length > 0) result.warnings.push(`Unknown template top-level field(s): ${templateUnknownKeys.join(", ")}`);
+			if (source.mode === "job") {
+				try {
+					checkGenerateProps({
+						template: resolvedTemplate,
+						inputs: source.inputs,
+						options: source.options
+					});
+				} catch (error) {
+					result.errors.unshift(error instanceof Error ? error.message : String(error));
+				}
+				result.errors.push(...getInputContractIssues(resolvedTemplate, source.inputs ?? []));
+			}
+			const valid = result.errors.length === 0 && (!args.strict || result.warnings.length === 0);
+			const inputCount = source.mode === "job" ? source.inputs?.length ?? 0 : void 0;
+			if (args.verbose) {
+				console.error(`Input: ${describeValidationInput(args.file)}`);
+				console.error(`Mode: ${source.mode}`);
+				console.error(`Template pages: ${result.pages}`);
+				console.error(`Fields: ${result.fields}`);
+				if (inputCount !== void 0) console.error(`Inputs: ${inputCount} set(s)`);
+				console.error(`Valid: ${valid ? "yes" : "no"}`);
+				console.error(`Strict: ${args.strict ? "enabled" : "disabled"}`);
+				console.error(`Errors: ${result.errors.length}`);
+				console.error(`Warnings: ${result.warnings.length}`);
+			}
+			if (args.json) printJson({
+				ok: true,
+				command: "validate",
+				valid,
+				mode: source.mode,
+				templatePageCount: result.pages,
+				fieldCount: result.fields,
+				...inputCount !== void 0 ? { inputCount } : {},
+				errors: result.errors,
+				warnings: result.warnings,
+				inspection,
+				inputHints: collectInputHints(source.template)
+			});
+			else {
+				if (result.errors.length === 0 && result.warnings.length === 0) console.log(`\u2713 Template is valid (${result.pages} page(s), ${result.fields} field(s))`);
+				for (const err of result.errors) console.log(`\u2717 Error: ${err}`);
+				for (const warn of result.warnings) console.log(`\u26a0 Warning: ${warn}`);
+			}
+			if (!valid) process.exit(1);
+		});
+	}
+});
+function describeValidationInput(file) {
+	if (!file || file === "-") return "stdin";
+	return file;
+}
+//#endregion
+//#region src/commands/pdf2img.ts
+var pdf2imgArgs = {
+	file: {
+		type: "positional",
+		description: "Input PDF file",
+		required: false
+	},
+	output: {
+		type: "string",
+		alias: "o",
+		description: "Output directory"
+	},
+	grid: {
+		type: "boolean",
+		description: "Overlay mm grid on images",
+		default: false
+	},
+	gridSize: {
+		type: "string",
+		description: "Grid spacing in mm",
+		default: "10"
+	},
+	scale: {
+		type: "string",
+		description: "Render scale",
+		default: "1"
+	},
+	imageFormat: {
+		type: "string",
+		description: "Image format: png | jpeg",
+		default: "png"
+	},
+	pages: {
+		type: "string",
+		description: "Page range (e.g., 1-3, 1,3,5)"
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output (includes size info)",
+		default: false
+	}
+};
+var pdf2img_default = defineCommand({
+	meta: {
+		name: "pdf2img",
+		description: "Convert PDF pages to images"
+	},
+	args: pdf2imgArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, pdf2imgArgs);
+			if (!args.file) fail("No input PDF provided.", {
+				code: "EARG",
+				exitCode: 1
+			});
+			const scale = parsePositiveNumberArg("scale", args.scale);
+			const gridSize = parsePositiveNumberArg("gridSize", args.gridSize);
+			const imageFormat = parseEnumArg("imageFormat", args.imageFormat, ["png", "jpeg"]);
+			const pdfData = readPdfFile(args.file);
+			const sizes = await pdf2size(pdfData);
+			const pageIndices = args.pages ? parsePageRange(args.pages, sizes.length).map((page) => page - 1) : Array.from({ length: sizes.length }, (_, index) => index);
+			const allImages = await pdf2img(pdfData, {
+				scale,
+				imageType: imageFormat
+			});
+			const inputBase = basename(args.file, extname(args.file));
+			const ext = imageFormat === "jpeg" ? "jpg" : "png";
+			let outputDir = ".";
+			if (args.output) {
+				outputDir = args.output;
+				if (existsSync(outputDir)) {
+					if (!statSync(outputDir).isDirectory()) fail(`Output path must be a directory for pdf2img: ${args.output}`, {
+						code: "EIO",
+						exitCode: 3
+					});
+				} else mkdirSync(outputDir, { recursive: true });
+			}
+			if (args.verbose) {
+				console.error(`Input: ${args.file}`);
+				console.error(`Pages: ${sizes.length}`);
+				console.error(`Selected pages: ${pageIndices.map((pageIdx) => pageIdx + 1).join(", ")}`);
+				console.error(`Output: ${outputDir}`);
+				console.error(`Image format: ${imageFormat}`);
+				console.error(`Scale: ${scale}`);
+				console.error(`Grid: ${args.grid ? `enabled (${gridSize}mm)` : "disabled"}`);
+			}
+			const results = [];
+			for (const pageIdx of pageIndices) {
+				let imageData = allImages[pageIdx];
+				const size = sizes[pageIdx] ?? {
+					width: 210,
+					height: 297
+				};
+				if (args.grid) imageData = await drawGridOnPdfImage(imageData, gridSize, size.width, size.height, imageFormat);
+				const outputPath = join(outputDir, `${inputBase}-${pageIdx + 1}.${ext}`);
+				writeOutput(outputPath, imageData);
+				const paperSize = detectPaperSize(size.width, size.height);
+				results.push({
+					outputPath,
+					pageNumber: pageIdx + 1,
+					width: Math.round(size.width * 100) / 100,
+					height: Math.round(size.height * 100) / 100
+				});
+				if (!args.json) {
+					const sizeLabel = paperSize ? `, ${paperSize}` : "";
+					console.log(`\u2713 ${outputPath} (${size.width.toFixed(0)}\u00d7${size.height.toFixed(0)}mm${sizeLabel})`);
+				}
+			}
+			if (args.json) printJson({
+				ok: true,
+				command: "pdf2img",
+				pageCount: sizes.length,
+				selectedPageCount: results.length,
+				outputDir,
+				outputPaths: results.map((result) => result.outputPath),
+				pages: results
+			});
+		});
+	}
+});
+//#endregion
+//#region src/commands/pdf2size.ts
+var pdf2sizeArgs = {
+	file: {
+		type: "positional",
+		description: "Input PDF file",
+		required: false
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output",
+		default: false
+	}
+};
+var pdf2size_default = defineCommand({
+	meta: {
+		name: "pdf2size",
+		description: "Get page dimensions of a PDF file"
+	},
+	args: pdf2sizeArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, pdf2sizeArgs);
+			if (!args.file) fail("No input PDF provided.", {
+				code: "EARG",
+				exitCode: 1
+			});
+			const sizes = await pdf2size(readPdfFile(args.file));
+			if (args.verbose) {
+				console.error(`Input: ${args.file}`);
+				console.error(`Pages: ${sizes.length}`);
+			}
+			const result = sizes.map((size, index) => ({
+				pageNumber: index + 1,
+				width: Math.round(size.width * 100) / 100,
+				height: Math.round(size.height * 100) / 100
+			}));
+			if (args.json) printJson({
+				ok: true,
+				command: "pdf2size",
+				pageCount: result.length,
+				pages: result
+			});
+			else for (let i = 0; i < sizes.length; i++) {
+				const size = sizes[i];
+				const paperSize = detectPaperSize(size.width, size.height);
+				const sizeLabel = paperSize ? ` (${paperSize})` : "";
+				console.log(`Page ${i + 1}: ${size.width.toFixed(0)} \u00d7 ${size.height.toFixed(0)} mm${sizeLabel}`);
+			}
+		});
+	}
+});
+//#endregion
+//#region src/version.ts
+var CLI_VERSION = "0.1.0-alpha.0";
+//#endregion
+//#region src/example-templates.ts
+function getExamplesBaseUrl() {
+	return process.env.PDFME_EXAMPLES_BASE_URL ?? "https://playground.pdfme.com/template-assets";
+}
+async function fetchJson(url) {
+	const response = await fetch(url, { signal: AbortSignal.timeout(15e3) });
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return await response.json();
+}
+async function getExampleManifest() {
+	let lastError;
+	for (const url of getManifestUrls()) try {
+		return {
+			manifest: normalizeManifest(await fetchJson(url)),
+			source: "remote",
+			url
+		};
+	} catch (error) {
+		lastError = error;
+	}
+	throw new Error(`Could not load examples manifest. ${formatError(lastError)}`);
+}
+async function fetchExampleTemplateWithSource(name, options = {}) {
+	const entry = (options.manifest ?? (await getExampleManifest()).manifest).templates.find((template) => template.name === name);
+	if (!entry) throw new Error(`Template "${name}" is not present in the examples manifest.`);
+	const relativePath = entry.path;
+	const templateUrl = `${getExamplesBaseUrl().replace(/\/$/, "")}/${relativePath}`;
+	return {
+		template: await fetchJson(templateUrl),
+		source: "remote",
+		url: templateUrl
+	};
+}
+function getManifestUrls() {
+	const baseUrl = getExamplesBaseUrl().replace(/\/$/, "");
+	return [`${baseUrl}/manifest.json`, `${baseUrl}/index.json`];
+}
+function normalizeManifest(raw) {
+	if (Array.isArray(raw)) return {
+		schemaVersion: 1,
+		cliVersion: CLI_VERSION,
+		templates: normalizeEntries(raw)
+	};
+	if (typeof raw !== "object" || raw === null) throw new Error("Examples manifest must be a JSON object or array.");
+	const record = raw;
+	const rawTemplates = Array.isArray(record.templates) ? record.templates : Array.isArray(record.entries) ? record.entries : void 0;
+	if (!rawTemplates) throw new Error("Examples manifest is missing templates.");
+	return {
+		schemaVersion: typeof record.schemaVersion === "number" && Number.isFinite(record.schemaVersion) ? record.schemaVersion : 1,
+		cliVersion: typeof record.cliVersion === "string" ? record.cliVersion : CLI_VERSION,
+		templates: normalizeEntries(rawTemplates)
+	};
+}
+function normalizeEntries(rawTemplates) {
+	return rawTemplates.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => {
+		const name = typeof entry.name === "string" ? entry.name : "";
+		return {
+			name,
+			author: typeof entry.author === "string" && entry.author.length > 0 ? entry.author : "pdfme",
+			path: typeof entry.path === "string" && entry.path.length > 0 ? entry.path : `${name}/template.json`,
+			thumbnailPath: typeof entry.thumbnailPath === "string" && entry.thumbnailPath.length > 0 ? entry.thumbnailPath : `${name}/thumbnail.png`,
+			pageCount: typeof entry.pageCount === "number" && Number.isFinite(entry.pageCount) ? entry.pageCount : 0,
+			fieldCount: typeof entry.fieldCount === "number" && Number.isFinite(entry.fieldCount) ? entry.fieldCount : 0,
+			schemaTypes: normalizeStringArray(entry.schemaTypes),
+			fontNames: normalizeStringArray(entry.fontNames),
+			hasCJK: typeof entry.hasCJK === "boolean" ? entry.hasCJK : false,
+			basePdfKind: typeof entry.basePdfKind === "string" && entry.basePdfKind.length > 0 ? entry.basePdfKind : "unknown"
+		};
+	}).filter((entry) => entry.name.length > 0);
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function formatError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/example-fonts.ts
+var OFFICIAL_EXAMPLE_FONT_URLS = {
+	NotoSansJP: "https://fonts.gstatic.com/s/notosansjp/v53/-F6jfjtqLzI2JPCgQBnw7HFyzSD-AsregP8VFBEj75vY0rw-oME.ttf",
+	NotoSerifJP: "https://fonts.gstatic.com/s/notoserifjp/v30/xn71YHs72GKoTvER4Gn3b5eMRtWGkp6o7MjQ2bwxOubAILO5wBCU.ttf",
+	"PinyonScript-Regular": "https://fonts.gstatic.com/s/pinyonscript/v22/6xKpdSJbL9-e9LuoeQiDRQR8aOLQO4bhiDY.ttf"
+};
+function collectTemplateFontNames(template) {
+	const schemas = template.schemas;
+	if (!Array.isArray(schemas)) return [];
+	const fontNames = /* @__PURE__ */ new Set();
+	for (const page of schemas) {
+		const pageSchemas = Array.isArray(page) ? page : typeof page === "object" && page !== null ? Object.values(page) : [];
+		for (const schema of pageSchemas) {
+			if (typeof schema !== "object" || schema === null) continue;
+			const fontName = schema.fontName;
+			if (typeof fontName === "string" && fontName.length > 0) fontNames.add(fontName);
+		}
+	}
+	return [...fontNames].sort();
+}
+function getOfficialExampleFonts(template) {
+	const entries = collectTemplateFontNames(template).flatMap((fontName) => {
+		const url = OFFICIAL_EXAMPLE_FONT_URLS[fontName];
+		return url ? [[fontName, {
+			data: url,
+			fallback: false,
+			subset: true
+		}]] : [];
+	});
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+}
+//#endregion
+//#region src/commands/examples.ts
+var examplesArgs = {
+	name: {
+		type: "positional",
+		description: "Template name to output",
+		required: false
+	},
+	list: {
+		type: "boolean",
+		description: "List available templates",
+		default: false
+	},
+	output: {
+		type: "string",
+		alias: "o",
+		description: "Output file path"
+	},
+	withInputs: {
+		type: "boolean",
+		alias: "w",
+		description: "Output unified format with sample inputs",
+		default: false
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output",
+		default: false
+	}
+};
+function generateSampleInputs(template) {
+	const fields = normalizeSchemaPages(template.schemas).flat();
+	if (fields.length === 0) return [{}];
+	const input = {};
+	for (const schema of fields) {
+		if (typeof schema !== "object" || schema === null) continue;
+		const name = schema.name;
+		const content = schema.content;
+		if (schema.readOnly) continue;
+		if (name) input[name] = content || `Sample ${name}`;
+	}
+	return [input];
+}
+var examples_default = defineCommand({
+	meta: {
+		name: "examples",
+		description: "List and output example pdfme templates"
+	},
+	args: examplesArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, examplesArgs);
+			let manifestResult;
+			try {
+				manifestResult = await getExampleManifest();
+			} catch (error) {
+				fail(`Failed to load examples manifest. ${error instanceof Error ? error.message : String(error)}`, {
+					code: "EIO",
+					exitCode: 3,
+					cause: error
+				});
+			}
+			const templateEntries = manifestResult.manifest.templates;
+			const templateNames = templateEntries.map((entry) => entry.name).filter((name) => typeof name === "string" && name.length > 0).sort();
+			if (args.verbose) {
+				console.error(`Base URL: ${getExamplesBaseUrl()}`);
+				console.error(`Manifest source: ${manifestResult.source}`);
+				if (manifestResult.url) console.error(`Manifest URL: ${manifestResult.url}`);
+				console.error(`Templates: ${templateNames.length}`);
+			}
+			if (args.list || !args.name) {
+				if (args.json) printJson({
+					ok: true,
+					command: "examples",
+					mode: "list",
+					templateCount: templateNames.length,
+					source: manifestResult.source,
+					baseUrl: getExamplesBaseUrl(),
+					manifest: manifestResult.manifest
+				});
+				else {
+					console.log("Available templates:");
+					for (const name of templateNames) console.log(`  ${name}`);
+				}
+				return;
+			}
+			if (!templateEntries.find((template) => template.name === args.name)) fail(`Template "${args.name}" not found. Available templates: ${templateNames.join(", ")}`, {
+				code: "EARG",
+				exitCode: 1
+			});
+			let templateResult;
+			try {
+				templateResult = await fetchExampleTemplateWithSource(args.name, { manifest: manifestResult.manifest });
+			} catch (error) {
+				fail(`Failed to load example template "${args.name}". ${error instanceof Error ? error.message : String(error)}`, {
+					code: "EIO",
+					exitCode: 3,
+					cause: error
+				});
+			}
+			const output = args.withInputs ? buildExampleJob(templateResult.template) : templateResult.template;
+			const mode = args.withInputs ? "job" : "template";
+			const stats = countTemplateStats(templateResult.template);
+			const inputCount = args.withInputs ? output.inputs?.length ?? 0 : void 0;
+			if (args.verbose) {
+				console.error(`Template: ${args.name}`);
+				console.error(`Template source: ${templateResult.source}`);
+				if (templateResult.url) console.error(`Template URL: ${templateResult.url}`);
+				console.error(`Mode: ${mode}`);
+				console.error(`Template pages: ${stats.templatePageCount}`);
+				console.error(`Fields: ${stats.fieldCount}`);
+				if (inputCount !== void 0) console.error(`Inputs: ${inputCount} set(s)`);
+				console.error(`Output: ${args.output ?? "stdout"}`);
+			}
+			if (args.output) {
+				writeOutput(args.output, new TextEncoder().encode(JSON.stringify(output, null, 2)));
+				if (args.json) printJson({
+					ok: true,
+					command: "examples",
+					name: args.name,
+					mode,
+					source: templateResult.source,
+					templatePageCount: stats.templatePageCount,
+					fieldCount: stats.fieldCount,
+					...inputCount !== void 0 ? { inputCount } : {},
+					outputPath: args.output
+				});
+				else {
+					const label = args.withInputs ? "Job file" : "Template";
+					console.log(`\u2713 ${label} written to ${args.output}`);
+				}
+				return;
+			}
+			if (args.json) printJson({
+				ok: true,
+				command: "examples",
+				name: args.name,
+				source: templateResult.source,
+				mode,
+				templatePageCount: stats.templatePageCount,
+				fieldCount: stats.fieldCount,
+				...inputCount !== void 0 ? { inputCount } : {},
+				data: output
+			});
+			else console.log(JSON.stringify(output, null, 2));
+		});
+	}
+});
+function buildExampleJob(template) {
+	const job = {
+		template,
+		inputs: generateSampleInputs(template)
+	};
+	const font = getOfficialExampleFonts(template);
+	if (font) job.options = { font };
+	return job;
+}
+function countTemplateStats(template) {
+	const schemaPages = normalizeSchemaPages(template.schemas);
+	return {
+		templatePageCount: schemaPages.length,
+		fieldCount: schemaPages.reduce((count, page) => count + page.length, 0)
+	};
+}
+function normalizeSchemaPages(rawSchemas) {
+	if (!Array.isArray(rawSchemas)) return [];
+	return rawSchemas.map((page) => {
+		if (Array.isArray(page)) return page.filter((schema) => typeof schema === "object" && schema !== null);
+		if (typeof page === "object" && page !== null) return Object.entries(page).map(([name, schema]) => typeof schema === "object" && schema !== null ? {
+			...schema,
+			name: schema.name ?? name
+		} : null).filter((schema) => schema !== null);
+		return [];
+	});
+}
+//#endregion
+//#region src/commands/doctor.ts
+var doctorArgs = {
+	target: {
+		type: "positional",
+		description: "Optional job/template JSON file, or \"fonts\" for font-focused diagnosis",
+		required: false
+	},
+	file: {
+		type: "positional",
+		description: "Job/template JSON file for \"doctor fonts\", or \"-\" for stdin",
+		required: false
+	},
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Verbose output",
+		default: false
+	},
+	json: {
+		type: "boolean",
+		description: "Machine-readable JSON output",
+		default: false
+	},
+	noAutoFont: {
+		type: "boolean",
+		description: "Simulate generate with automatic CJK font download disabled",
+		default: false
+	},
+	output: {
+		type: "string",
+		alias: "o",
+		description: "Simulate generate output PDF path for runtime/path diagnosis",
+		default: "output.pdf"
+	},
+	force: {
+		type: "boolean",
+		description: "Simulate generate --force for implicit default output path checks",
+		default: false
+	},
+	image: {
+		type: "boolean",
+		description: "Simulate generate --image when previewing runtime output paths",
+		default: false
+	},
+	imageFormat: {
+		type: "string",
+		description: "Image format to use when previewing runtime output paths: png | jpeg",
+		default: "png"
+	}
+};
+var doctor_default = defineCommand({
+	meta: {
+		name: "doctor",
+		description: "Diagnose the local pdfme CLI environment and input readiness"
+	},
+	args: doctorArgs,
+	async run({ args, rawArgs }) {
+		return runWithContract({ json: Boolean(args.json) }, async () => {
+			assertNoUnknownFlags(rawArgs, doctorArgs);
+			const invocation = resolveDoctorInvocation(args);
+			const imageFormat = parseEnumArg("imageFormat", args.imageFormat, ["png", "jpeg"]);
+			const environment = getEnvironmentReport();
+			if (invocation.target === "environment") {
+				const issues = collectEnvironmentIssues(environment);
+				const warnings = collectEnvironmentWarnings(environment);
+				const healthy = issues.length === 0;
+				if (args.verbose) printDoctorEnvironmentVerbose(environment, healthy, issues, warnings);
+				if (args.json) printJson({
+					ok: true,
+					command: "doctor",
+					target: "environment",
+					healthy,
+					environment,
+					issues,
+					warnings
+				});
+				else printEnvironmentReport(environment, issues, warnings);
+				if (!healthy) process.exit(1);
+				return;
+			}
+			const source = await loadValidationSource(invocation.file, { noInputMessage: invocation.target === "fonts" ? "No font diagnostic input provided. Pass a file path or pipe JSON via stdin." : "No diagnostic input provided. Pass a file path or pipe JSON via stdin." });
+			const diagnosis = buildInputDiagnosis(source, environment, Boolean(args.noAutoFont), {
+				includeBasePdfIssue: invocation.target === "input",
+				includeRuntimeIssue: invocation.target === "input",
+				runtime: {
+					output: args.output,
+					force: Boolean(args.force),
+					image: Boolean(args.image),
+					imageFormat,
+					rawArgs
+				}
+			});
+			if (args.verbose) printDoctorInputVerbose(invocation, source, diagnosis);
+			const payload = invocation.target === "fonts" ? {
+				ok: true,
+				command: "doctor",
+				target: "fonts",
+				healthy: diagnosis.healthy,
+				mode: source.mode,
+				templatePageCount: diagnosis.validation.pages,
+				fieldCount: diagnosis.validation.fields,
+				...source.mode === "job" ? { inputCount: source.inputs?.length ?? 0 } : {},
+				environment,
+				validation: createValidationPayload(diagnosis.validation),
+				inspection: {
+					schemaTypes: diagnosis.inspection.schemaTypes,
+					requiredPlugins: diagnosis.inspection.requiredPlugins,
+					requiredFonts: diagnosis.inspection.requiredFonts
+				},
+				inputHints: collectInputHints(source.template),
+				diagnosis: { fonts: createFontPayload(diagnosis.fontDiagnosis) },
+				issues: diagnosis.issues,
+				warnings: diagnosis.warnings
+			} : {
+				ok: true,
+				command: "doctor",
+				target: "input",
+				healthy: diagnosis.healthy,
+				mode: source.mode,
+				templatePageCount: diagnosis.validation.pages,
+				fieldCount: diagnosis.validation.fields,
+				...source.mode === "job" ? { inputCount: source.inputs?.length ?? 0 } : {},
+				estimatedPageCount: diagnosis.runtimeDiagnosis.estimatedPages,
+				environment,
+				validation: createValidationPayload(diagnosis.validation),
+				inspection: diagnosis.inspection,
+				inputHints: collectInputHints(source.template),
+				diagnosis: {
+					basePdf: diagnosis.basePdfDiagnosis,
+					fonts: createFontPayload(diagnosis.fontDiagnosis),
+					runtime: diagnosis.runtimeDiagnosis,
+					plugins: {
+						required: diagnosis.inspection.requiredPlugins,
+						unsupportedSchemaTypes: diagnosis.inspection.schemaTypes.filter((type) => !diagnosis.inspection.requiredPlugins.includes(type))
+					}
+				},
+				issues: diagnosis.issues,
+				warnings: diagnosis.warnings
+			};
+			if (args.json) printJson(payload);
+			else if (invocation.target === "fonts") printFontReport(payload);
+			else printInputReport(payload);
+			if (!diagnosis.healthy) process.exit(1);
+		});
+	}
+});
+function resolveDoctorInvocation(args) {
+	const positionals = Array.isArray(args._) ? args._ : [];
+	if (args.target === "fonts") {
+		if (positionals.length > 2) fail(`Unexpected extra positional argument: ${JSON.stringify(positionals[2])}. Usage: pdfme doctor fonts <job-or-template>.`, {
+			code: "EARG",
+			exitCode: 1
+		});
+		return {
+			target: "fonts",
+			file: args.file
+		};
+	}
+	if (positionals.length > 1) fail(`Unexpected extra positional argument: ${JSON.stringify(positionals[1])}. Usage: pdfme doctor [job-or-template].`, {
+		code: "EARG",
+		exitCode: 1
+	});
+	if (args.target) return {
+		target: "input",
+		file: args.target
+	};
+	return { target: "environment" };
+}
+function buildInputDiagnosis(source, environment, noAutoFont, options) {
+	const inspection = inspectTemplate(source.template, source.templateDir);
+	const validation = validateTemplate(source.template);
+	validation.warnings.push(...source.jobWarnings);
+	const templateUnknownKeys = Object.keys(source.template).filter((key) => !KNOWN_TEMPLATE_KEYS.has(key)).sort();
+	if (templateUnknownKeys.length > 0) validation.warnings.push(`Unknown template top-level field(s): ${templateUnknownKeys.join(", ")}`);
+	const fontDiagnosis = diagnoseFonts(source, environment, noAutoFont, inspection.requiredFonts);
+	const basePdfDiagnosis = diagnoseBasePdf(source.template.basePdf, source.templateDir);
+	const runtimeDiagnosis = diagnoseRuntime(source, options.runtime);
+	const issues = [...validation.errors];
+	const warnings = [...validation.warnings, ...fontDiagnosis.warnings];
+	if (options.includeBasePdfIssue && basePdfDiagnosis.issue) issues.push(basePdfDiagnosis.issue);
+	issues.push(...fontDiagnosis.issues);
+	if (options.includeRuntimeIssue && runtimeDiagnosis.output.issue) issues.push(runtimeDiagnosis.output.issue);
+	if (source.mode === "job" && fontDiagnosis.effectiveOptions) {
+		try {
+			checkGenerateProps({
+				template: source.template,
+				inputs: source.inputs,
+				options: fontDiagnosis.effectiveOptions
+			});
+		} catch (error) {
+			issues.unshift(error instanceof Error ? error.message : String(error));
+		}
+		issues.push(...getInputContractIssues(source.template, source.inputs ?? []));
+	}
+	return {
+		validation: {
+			valid: validation.errors.length === 0,
+			pages: validation.pages,
+			fields: validation.fields,
+			errors: validation.errors,
+			warnings: validation.warnings
+		},
+		inspection,
+		basePdfDiagnosis,
+		fontDiagnosis,
+		runtimeDiagnosis,
+		issues,
+		warnings,
+		healthy: issues.length === 0
+	};
+}
+function createValidationPayload(validation) {
+	return {
+		valid: validation.valid,
+		errors: validation.errors,
+		warnings: validation.warnings
+	};
+}
+function createFontPayload(fontDiagnosis) {
+	return {
+		hasCJK: fontDiagnosis.hasCJK,
+		requiredFonts: fontDiagnosis.requiredFonts,
+		explicitFonts: fontDiagnosis.explicitFonts,
+		effectiveFonts: fontDiagnosis.effectiveFonts,
+		missingFonts: fontDiagnosis.missingFonts,
+		explicitSources: fontDiagnosis.explicitSources,
+		implicitSources: fontDiagnosis.implicitSources,
+		autoNotoSansJP: {
+			needed: fontDiagnosis.autoFontNeeded,
+			cached: fontDiagnosis.autoFontCached,
+			cacheFile: NOTO_CACHE_FILE
+		}
+	};
+}
+function getEnvironmentReport() {
+	const fontCacheDir = dirname(NOTO_CACHE_FILE);
+	const cwdStatus = getWritableStatus(process.cwd());
+	const tempStatus = getWritableStatus(tmpdir());
+	const fontCacheStatus = getWritableStatus(fontCacheDir);
+	return {
+		nodeVersion: process.version,
+		cliVersion: CLI_VERSION,
+		platform: process.platform,
+		arch: process.arch,
+		cwd: cwdStatus,
+		tempDir: tempStatus,
+		homeDir: homedir(),
+		fontCache: {
+			file: NOTO_CACHE_FILE,
+			dir: fontCacheDir,
+			cached: existsSync(NOTO_CACHE_FILE),
+			writable: fontCacheStatus.writable,
+			checkedPath: fontCacheStatus.checkedPath,
+			error: fontCacheStatus.error
+		}
+	};
+}
+function getWritableStatus(path) {
+	const checkedPath = findExistingParent(path);
+	try {
+		accessSync(checkedPath, constants.W_OK);
+		return {
+			path,
+			writable: true,
+			checkedPath: checkedPath !== path ? checkedPath : void 0
+		};
+	} catch (error) {
+		return {
+			path,
+			writable: false,
+			checkedPath: checkedPath !== path ? checkedPath : void 0,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function findExistingParent(path) {
+	let current = path;
+	while (!existsSync(current)) {
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return current;
+}
+function collectEnvironmentIssues(environment) {
+	const issues = [];
+	if (!environment.cwd.writable) issues.push(`Current working directory is not writable: ${environment.cwd.path}`);
+	if (!environment.tempDir.writable) issues.push(`Temporary directory is not writable: ${environment.tempDir.path}`);
+	return issues;
+}
+function collectEnvironmentWarnings(environment) {
+	const warnings = [];
+	if (!environment.fontCache.writable) warnings.push(`Font cache directory is not writable: ${environment.fontCache.dir}`);
+	if (!environment.fontCache.cached) warnings.push(`NotoSansJP is not cached at ${environment.fontCache.file}`);
+	return warnings;
+}
+function diagnoseBasePdf(basePdf, templateDir) {
+	const summary = summarizeBasePdf(basePdf, templateDir);
+	if (summary.kind !== "pdfPath" || !summary.resolvedPath) return summary;
+	const exists = existsSync(summary.resolvedPath);
+	return {
+		...summary,
+		exists,
+		issue: exists ? void 0 : `Base PDF file not found: ${summary.resolvedPath}`
+	};
+}
+function diagnoseRuntime(source, options) {
+	const estimatedPages = source.mode === "job" ? (source.inputs?.length ?? 0) * getTemplatePageCount(source.template) : getTemplatePageCount(source.template);
+	const output = diagnoseOutputPath(options);
+	return {
+		estimatedPages,
+		output,
+		imageOutputs: {
+			enabled: options.image,
+			format: options.imageFormat,
+			paths: options.image ? getImageOutputPaths(options.output, estimatedPages, options.imageFormat) : [],
+			directory: dirname(output.resolvedPath)
+		}
+	};
+}
+function diagnoseOutputPath(options) {
+	const inspection = inspectWriteTarget(options.output);
+	const implicitDefaultIssue = getSafeDefaultOutputPathIssue({
+		filePath: options.output,
+		rawArgs: options.rawArgs,
+		optionName: "output",
+		optionAlias: "o",
+		defaultValue: "output.pdf",
+		force: options.force
+	});
+	let issue = implicitDefaultIssue;
+	if (!issue && inspection.exists && inspection.existingType === "directory") issue = `Output path points to a directory: ${inspection.resolvedPath}. Choose a file path like out.pdf.`;
+	else if (!issue && inspection.exists && inspection.existingType === "other") issue = `Output path is not a regular file: ${inspection.resolvedPath}.`;
+	else if (!issue && inspection.checkedType && inspection.checkedType !== "directory" && inspection.existingType !== "file") issue = `Output directory cannot be created because an existing path segment is not a directory: ${inspection.checkedPath ?? inspection.parentDir}.`;
+	else if (!issue && !inspection.writable) issue = inspection.exists && inspection.existingType === "file" ? `Output file is not writable: ${inspection.resolvedPath}.` : `Output directory is not writable for ${inspection.resolvedPath}: ${inspection.checkedPath ?? inspection.parentDir}.`;
+	return {
+		...inspection,
+		implicitDefaultProtected: Boolean(implicitDefaultIssue),
+		issue
+	};
+}
+function getTemplatePageCount(template) {
+	return Array.isArray(template.schemas) ? template.schemas.length : 0;
+}
+function diagnoseFonts(source, environment, noAutoFont, requiredFonts) {
+	const hasCJK = detectCJKInTemplate(source.template) || detectCJKInInputs(source.inputs ?? []);
+	const issues = [];
+	const warnings = [];
+	const autoFontCached = existsSync(NOTO_CACHE_FILE);
+	const explicit = normalizeExplicitFontConfig(source.options, source.templateDir);
+	issues.push(...explicit.issues);
+	warnings.push(...explicit.warnings);
+	const autoFontNeeded = hasCJK && explicit.fontNames.length === 0;
+	if (autoFontNeeded && noAutoFont) issues.push("CJK text detected, but automatic NotoSansJP download is disabled by --noAutoFont and no explicit font source was provided.");
+	else if (autoFontNeeded && !autoFontCached && !environment.fontCache.writable) issues.push(`CJK text detected and NotoSansJP is not cached at ${NOTO_CACHE_FILE}, but the font cache directory is not writable: ${environment.fontCache.dir}. Provide --font / options.font or warm the cache in a writable HOME.`);
+	else if (autoFontNeeded && !autoFontCached) warnings.push(`CJK text detected and NotoSansJP is not cached at ${NOTO_CACHE_FILE}. Generate will require network access to fetch it.`);
+	const resolvedFont = autoFontNeeded ? {
+		NotoSansJP: {
+			data: new Uint8Array(),
+			fallback: true,
+			subset: true
+		},
+		[DEFAULT_FONT_NAME]: {
+			data: new Uint8Array(),
+			fallback: false,
+			subset: true
+		}
+	} : { [DEFAULT_FONT_NAME]: {
+		data: new Uint8Array(),
+		fallback: true,
+		subset: true
+	} };
+	const effectiveFont = explicit.fontRecord ? {
+		...explicit.fontRecord,
+		...resolvedFont
+	} : resolvedFont;
+	const effectiveFonts = Object.keys(effectiveFont).sort();
+	const missingFonts = requiredFonts.filter((fontName) => !effectiveFonts.includes(fontName));
+	if (source.mode === "template" && missingFonts.length > 0) issues.push(`Template references font(s) that are not available by default: ${missingFonts.join(", ")}. Provide them via generate --font or unified job options.font.`);
+	return {
+		hasCJK,
+		requiredFonts,
+		explicitFonts: explicit.fontNames,
+		effectiveFonts,
+		missingFonts,
+		autoFontNeeded,
+		autoFontCached,
+		issues,
+		warnings,
+		explicitSources: explicit.sources,
+		implicitSources: buildImplicitFontSources(autoFontNeeded, autoFontCached),
+		effectiveOptions: explicit.optionsRecord ? {
+			...explicit.optionsRecord,
+			font: effectiveFont
+		} : { font: effectiveFont }
+	};
+}
+function normalizeExplicitFontConfig(options, templateDir) {
+	if (options === void 0) return {
+		issues: [],
+		warnings: [],
+		fontNames: [],
+		sources: []
+	};
+	if (typeof options !== "object" || options === null || Array.isArray(options)) return {
+		issues: ["Unified job options must be a JSON object."],
+		warnings: [],
+		fontNames: [],
+		sources: []
+	};
+	const optionsRecord = options;
+	const font = optionsRecord.font;
+	if (font === void 0) return {
+		issues: [],
+		warnings: [],
+		fontNames: [],
+		optionsRecord,
+		sources: []
+	};
+	if (typeof font !== "object" || font === null || Array.isArray(font)) return {
+		issues: ["Unified job options.font must be an object."],
+		warnings: [],
+		fontNames: [],
+		optionsRecord,
+		sources: []
+	};
+	const fontRecord = font;
+	const sourceDiagnostics = analyzeExplicitFontRecord(fontRecord, templateDir);
+	return {
+		issues: sourceDiagnostics.issues,
+		warnings: sourceDiagnostics.warnings,
+		fontNames: Object.keys(fontRecord).sort(),
+		fontRecord,
+		optionsRecord,
+		sources: sortFontSources(sourceDiagnostics.sources.map(toDoctorExplicitSource))
+	};
+}
+function toDoctorExplicitSource(source) {
+	return {
+		...source,
+		source: "explicit"
+	};
+}
+function buildImplicitFontSources(autoFontNeeded, autoFontCached) {
+	const sources = [{
+		fontName: DEFAULT_FONT_NAME,
+		source: "implicit",
+		kind: "default",
+		formatHint: "ttf",
+		supportedFormat: true,
+		needsNetwork: false
+	}];
+	if (autoFontNeeded) sources.push({
+		fontName: "NotoSansJP",
+		source: "implicit",
+		kind: autoFontCached ? "autoCache" : "autoDownload",
+		path: NOTO_CACHE_FILE,
+		resolvedPath: NOTO_CACHE_FILE,
+		exists: autoFontCached,
+		formatHint: "ttf",
+		supportedFormat: true,
+		needsNetwork: !autoFontCached
+	});
+	return sortFontSources(sources);
+}
+function sortFontSources(sources) {
+	return [...sources].sort((a, b) => a.fontName.localeCompare(b.fontName) || a.kind.localeCompare(b.kind));
+}
+function printEnvironmentReport(environment, issues, warnings) {
+	const header = issues.length === 0 ? "✓ Environment looks ready" : "✗ Environment has blocking issues";
+	console.log(header);
+	console.log(`Node: ${environment.nodeVersion}`);
+	console.log(`CLI: ${environment.cliVersion}`);
+	console.log(`Platform: ${environment.platform} ${environment.arch}`);
+	console.log(`cwd: ${environment.cwd.path} (${environment.cwd.writable ? "writable" : "not writable"})`);
+	console.log(`temp: ${environment.tempDir.path} (${environment.tempDir.writable ? "writable" : "not writable"})`);
+	console.log(`font cache: ${environment.fontCache.file} (${environment.fontCache.cached ? "cached" : "not cached"})`);
+	for (const issue of issues) console.log(`\u2717 Issue: ${issue}`);
+	for (const warning of warnings) console.log(`\u26a0 Warning: ${warning}`);
+}
+function printDoctorEnvironmentVerbose(environment, healthy, issues, warnings) {
+	console.error("Target: environment");
+	console.error(`Healthy: ${healthy ? "yes" : "no"}`);
+	console.error(`Node: ${environment.nodeVersion}`);
+	console.error(`CLI: ${environment.cliVersion}`);
+	console.error(`Platform: ${environment.platform} ${environment.arch}`);
+	console.error(`cwd: ${environment.cwd.path}`);
+	console.error(`temp: ${environment.tempDir.path}`);
+	console.error(`Font cache: ${environment.fontCache.cached ? "cached" : "not cached"} (${environment.fontCache.file})`);
+	console.error(`Issues: ${issues.length}`);
+	console.error(`Warnings: ${warnings.length}`);
+}
+function printInputReport(payload) {
+	const healthy = Boolean(payload.healthy);
+	const inspection = payload.inspection;
+	const diagnosis = payload.diagnosis;
+	const issues = payload.issues;
+	const warnings = payload.warnings;
+	console.log(healthy ? "✓ Doctor checks passed" : "✗ Doctor found blocking issues");
+	console.log(`Mode: ${payload.mode}`);
+	console.log(`Template pages: ${payload.templatePageCount}`);
+	console.log(`Fields: ${payload.fieldCount}`);
+	console.log(`Schema types: ${inspection.schemaTypes.join(", ") || "(none)"}`);
+	if (diagnosis.runtime) {
+		console.log(`Output: ${diagnosis.runtime.output.path} (${diagnosis.runtime.output.writable ? "writable" : "not writable"})`);
+		if (diagnosis.runtime.imageOutputs.enabled) console.log(`Images: ${diagnosis.runtime.imageOutputs.paths.length} ${diagnosis.runtime.imageOutputs.format.toUpperCase()} file(s) in ${diagnosis.runtime.imageOutputs.directory}`);
+	}
+	for (const issue of issues) console.log(`\u2717 Issue: ${issue}`);
+	for (const warning of warnings) console.log(`\u26a0 Warning: ${warning}`);
+}
+function printDoctorInputVerbose(invocation, source, diagnosis) {
+	console.error(`Target: ${invocation.target}`);
+	console.error(`Input: ${describeDoctorInput(invocation.file)}`);
+	console.error(`Mode: ${source.mode}`);
+	console.error(`Template pages: ${diagnosis.validation.pages}`);
+	console.error(`Fields: ${diagnosis.validation.fields}`);
+	if (source.mode === "job") console.error(`Inputs: ${source.inputs?.length ?? 0} set(s)`);
+	if (invocation.target === "input") {
+		console.error(`Estimated pages: ${diagnosis.runtimeDiagnosis.estimatedPages}`);
+		console.error(`Output: ${diagnosis.runtimeDiagnosis.output.path}`);
+		console.error(`Images: ${diagnosis.runtimeDiagnosis.imageOutputs.enabled ? `enabled (${diagnosis.runtimeDiagnosis.imageOutputs.format}, ${diagnosis.runtimeDiagnosis.imageOutputs.paths.length} file(s))` : "disabled"}`);
+	}
+	console.error(`Healthy: ${diagnosis.healthy ? "yes" : "no"}`);
+	console.error(`Issues: ${diagnosis.issues.length}`);
+	console.error(`Warnings: ${diagnosis.warnings.length}`);
+}
+function printFontReport(payload) {
+	const healthy = Boolean(payload.healthy);
+	const diagnosis = payload.diagnosis;
+	const issues = payload.issues;
+	const warnings = payload.warnings;
+	console.log(healthy ? "✓ Font checks passed" : "✗ Font checks found blocking issues");
+	console.log(`Mode: ${payload.mode}`);
+	console.log(`Required fonts: ${diagnosis.fonts.requiredFonts.join(", ") || "(none)"}`);
+	console.log(`Explicit fonts: ${diagnosis.fonts.explicitFonts.join(", ") || "(none)"}`);
+	console.log(`Effective fonts: ${diagnosis.fonts.effectiveFonts.join(", ") || "(none)"}`);
+	for (const source of diagnosis.fonts.explicitSources) console.log(`- explicit ${source.fontName}: ${source.kind}${source.path ? ` (${source.path})` : source.url ? ` (${source.url})` : ""}`);
+	for (const source of diagnosis.fonts.implicitSources) console.log(`- implicit ${source.fontName}: ${source.kind}${source.path ? ` (${source.path})` : ""}`);
+	for (const issue of issues) console.log(`\u2717 Issue: ${issue}`);
+	for (const warning of warnings) console.log(`\u26a0 Warning: ${warning}`);
+}
+function describeDoctorInput(file) {
+	if (!file || file === "-") return "stdin";
+	return file;
+}
+//#endregion
+//#region src/index.ts
+runMain(defineCommand({
+	meta: {
+		name: "pdfme",
+		version: CLI_VERSION,
+		description: "CLI tool for pdfme - generate PDFs, convert images, validate templates"
+	},
+	subCommands: {
+		generate: generate_default,
+		validate: validate_default,
+		pdf2img: pdf2img_default,
+		pdf2size: pdf2size_default,
+		examples: examples_default,
+		doctor: doctor_default
+	}
+}));
+//#endregion
+
+//# sourceMappingURL=index.js.map