@akii09/pdfx-cli 0.1.2 → 0.1.3

package/dist/index.js

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 import { Command } from "commander";
 
 // src/commands/add.ts
-import path2 from "path";
+import path3 from "path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -489,8 +489,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path8, errorMaps, issueData } = params;
-  const fullPath = [...path8, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -606,11 +606,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path8, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path8;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -4461,30 +4461,156 @@ import chalk from "chalk";
 import ora from "ora";
 import prompts from "prompts";
 
-// src/utils/file-system.ts
-import fs from "fs";
+// src/utils/dependency-validator.ts
+import fs2 from "fs";
 import path from "path";
+import semver from "semver";
+
+// src/utils/read-json.ts
+import fs from "fs";
+function readJsonFile(filePath) {
+  const raw = fs.readFileSync(filePath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    throw new ConfigError(`Invalid JSON in ${filePath}: ${details}`);
+  }
+}
+
+// src/utils/dependency-validator.ts
+var REQUIRED_VERSIONS = {
+  "@react-pdf/renderer": ">=3.0.0",
+  react: ">=16.8.0",
+  node: ">=24.0.0"
+};
+function getPackageJson(cwd = process.cwd()) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs2.existsSync(pkgPath)) {
+    return null;
+  }
+  return readJsonFile(pkgPath);
+}
+function getInstalledVersion(packageName, cwd = process.cwd()) {
+  const pkg = getPackageJson(cwd);
+  if (!pkg) return null;
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const version = deps[packageName];
+  if (!version) return null;
+  return semver.clean(version) || semver.coerce(version)?.version || null;
+}
+function validateReactPdfRenderer(cwd = process.cwd()) {
+  const version = getInstalledVersion("@react-pdf/renderer", cwd);
+  const required = REQUIRED_VERSIONS["@react-pdf/renderer"];
+  if (!version) {
+    return {
+      valid: false,
+      installed: false,
+      requiredVersion: required,
+      message: "@react-pdf/renderer is not installed"
+    };
+  }
+  const isCompatible = semver.satisfies(version, required);
+  return {
+    valid: isCompatible,
+    installed: true,
+    currentVersion: version,
+    requiredVersion: required,
+    message: isCompatible ? "@react-pdf/renderer version is compatible" : `@react-pdf/renderer version ${version} does not meet requirement ${required}`
+  };
+}
+function validateReact(cwd = process.cwd()) {
+  const version = getInstalledVersion("react", cwd);
+  const required = REQUIRED_VERSIONS.react;
+  if (!version) {
+    return {
+      valid: false,
+      installed: false,
+      requiredVersion: required,
+      message: "React is not installed"
+    };
+  }
+  const isCompatible = semver.satisfies(version, required);
+  return {
+    valid: isCompatible,
+    installed: true,
+    currentVersion: version,
+    requiredVersion: required,
+    message: isCompatible ? "React version is compatible" : `React version ${version} does not meet requirement ${required}`
+  };
+}
+function validateNodeVersion() {
+  const version = process.version;
+  const required = REQUIRED_VERSIONS.node;
+  const cleanVersion = semver.clean(version);
+  if (!cleanVersion) {
+    return {
+      valid: false,
+      installed: true,
+      currentVersion: version,
+      requiredVersion: required,
+      message: `Unable to parse Node.js version: ${version}`
+    };
+  }
+  const isCompatible = semver.satisfies(cleanVersion, required);
+  return {
+    valid: isCompatible,
+    installed: true,
+    currentVersion: cleanVersion,
+    requiredVersion: required,
+    message: isCompatible ? "Node.js version is compatible" : `Node.js version ${cleanVersion} does not meet requirement ${required}`
+  };
+}
+function validateTypeScript(cwd = process.cwd()) {
+  const tsVersion = getInstalledVersion("typescript", cwd);
+  if (!tsVersion) {
+    return null;
+  }
+  const typesInstalled = getInstalledVersion("@types/react-pdf", cwd);
+  return {
+    valid: !!typesInstalled,
+    installed: !!typesInstalled,
+    currentVersion: typesInstalled || void 0,
+    requiredVersion: "latest",
+    message: typesInstalled ? "TypeScript types for @react-pdf/renderer are installed" : "@types/react-pdf is recommended for TypeScript projects"
+  };
+}
+function validateDependencies(cwd = process.cwd()) {
+  return {
+    reactPdfRenderer: validateReactPdfRenderer(cwd),
+    react: validateReact(cwd),
+    nodeJs: validateNodeVersion(),
+    typescript: validateTypeScript(cwd) || void 0
+  };
+}
+
+// src/utils/file-system.ts
+import fs3 from "fs";
+import path2 from "path";
 function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
 }
 function writeFile(filePath, content) {
-  const dir = path.dirname(filePath);
+  const dir = path2.dirname(filePath);
   ensureDir(dir);
-  fs.writeFileSync(filePath, content, "utf-8");
+  fs3.writeFileSync(filePath, content, "utf-8");
 }
 function checkFileExists(filePath) {
-  return fs.existsSync(filePath);
+  return fs3.existsSync(filePath);
 }
 function normalizePath(...segments) {
-  return path.resolve(...segments);
+  return path2.resolve(...segments);
 }
 function isPathWithinDirectory(resolvedPath, targetDir) {
   const normalizedTarget = normalizePath(targetDir);
   const normalizedResolved = normalizePath(resolvedPath);
   if (normalizedResolved === normalizedTarget) return true;
-  const prefix = normalizedTarget.endsWith(path.sep) ? normalizedTarget : normalizedTarget + path.sep;
+  const prefix = normalizedTarget.endsWith(path2.sep) ? normalizedTarget : normalizedTarget + path2.sep;
   return normalizedResolved.startsWith(prefix);
 }
 function safePath(targetDir, fileName) {
@@ -4754,18 +4880,6 @@ export function useSafeMemo<T>(factory: () => T, deps: DependencyList): T {
 `;
 }
 
-// src/utils/read-json.ts
-import fs2 from "fs";
-function readJsonFile(filePath) {
-  const raw = fs2.readFileSync(filePath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    const details = error instanceof Error ? error.message : String(error);
-    throw new ConfigError(`Invalid JSON in ${filePath}: ${details}`);
-  }
-}
-
 // src/commands/add.ts
 function readConfig(configPath) {
   const raw = readJsonFile(configPath);
@@ -4810,15 +4924,15 @@ async function fetchComponent(name, registryUrl) {
   return result.data;
 }
 function resolveThemeImport(componentDir, themePath, fileContent) {
-  const absComponentDir = path2.resolve(process.cwd(), componentDir);
-  const absThemePath = path2.resolve(process.cwd(), themePath);
+  const absComponentDir = path3.resolve(process.cwd(), componentDir);
+  const absThemePath = path3.resolve(process.cwd(), themePath);
   const themeImportTarget = absThemePath.replace(/\.tsx?$/, "");
-  let relativePath = path2.relative(absComponentDir, themeImportTarget);
+  let relativePath = path3.relative(absComponentDir, themeImportTarget);
   if (!relativePath.startsWith(".")) {
     relativePath = `./${relativePath}`;
   }
-  const absContextPath = path2.join(path2.dirname(absThemePath), "pdfx-theme-context");
-  let relativeContextPath = path2.relative(absComponentDir, absContextPath);
+  const absContextPath = path3.join(path3.dirname(absThemePath), "pdfx-theme-context");
+  let relativeContextPath = path3.relative(absComponentDir, absContextPath);
   if (!relativeContextPath.startsWith(".")) {
     relativeContextPath = `./${relativeContextPath}`;
   }
@@ -4834,13 +4948,13 @@ function resolveThemeImport(componentDir, themePath, fileContent) {
 }
 async function installComponent(name, config, force) {
   const component = await fetchComponent(name, config.registry);
-  const targetDir = path2.resolve(process.cwd(), config.componentDir);
-  const componentDir = path2.join(targetDir, component.name);
+  const targetDir = path3.resolve(process.cwd(), config.componentDir);
+  const componentDir = path3.join(targetDir, component.name);
   ensureDir(componentDir);
-  const componentRelDir = path2.join(config.componentDir, component.name);
+  const componentRelDir = path3.join(config.componentDir, component.name);
   const filesToWrite = [];
   for (const file of component.files) {
-    const fileName = path2.basename(file.path);
+    const fileName = path3.basename(file.path);
     const filePath = safePath(componentDir, fileName);
     let content = file.content;
     if (config.theme && (content.includes("pdfx-theme") || content.includes("pdfx-theme-context"))) {
@@ -4851,7 +4965,7 @@ async function installComponent(name, config, force) {
   if (!force) {
     const existing = filesToWrite.filter((f) => checkFileExists(f.filePath));
     if (existing.length > 0) {
-      const fileNames = existing.map((f) => path2.basename(f.filePath)).join(", ");
+      const fileNames = existing.map((f) => path3.basename(f.filePath)).join(", ");
       const { overwrite } = await prompts({
         type: "confirm",
         name: "overwrite",
@@ -4867,17 +4981,35 @@ async function installComponent(name, config, force) {
     writeFile(file.filePath, file.content);
   }
   if (config.theme) {
-    const absThemePath = path2.resolve(process.cwd(), config.theme);
-    const contextPath = path2.join(path2.dirname(absThemePath), "pdfx-theme-context.tsx");
+    const absThemePath = path3.resolve(process.cwd(), config.theme);
+    const contextPath = path3.join(path3.dirname(absThemePath), "pdfx-theme-context.tsx");
     if (!checkFileExists(contextPath)) {
-      ensureDir(path2.dirname(contextPath));
+      ensureDir(path3.dirname(contextPath));
       writeFile(contextPath, generateThemeContextFile());
     }
   }
   return;
 }
 async function add(components, options = {}) {
-  const configPath = path2.join(process.cwd(), "pdfx.json");
+  const reactPdfCheck = validateReactPdfRenderer();
+  if (!reactPdfCheck.installed) {
+    console.error(chalk.red("\nError: @react-pdf/renderer is not installed\n"));
+    console.log(chalk.yellow("  PDFx components require @react-pdf/renderer to work.\n"));
+    console.log(chalk.cyan("  Run: pdfx init"));
+    console.log(chalk.dim("  or install manually: npm install @react-pdf/renderer\n"));
+    process.exit(1);
+  }
+  if (!reactPdfCheck.valid) {
+    console.log(
+      chalk.yellow(
+        `
+  \u26A0 Warning: ${reactPdfCheck.message}
+  ${chalk.dim("\u2192")} You may encounter compatibility issues
+`
+      )
+    );
+  }
+  const configPath = path3.join(process.cwd(), "pdfx.json");
   if (!checkFileExists(configPath)) {
     console.error(chalk.red("Error: pdfx.json not found"));
     console.log(chalk.yellow("Run: pdfx init"));
@@ -4933,7 +5065,7 @@ async function add(components, options = {}) {
     console.log(chalk.yellow(`Failed to add: ${failed.join(", ")}`));
   }
   if (failed.length < components.length) {
-    const resolvedDir = path2.resolve(process.cwd(), config.componentDir);
+    const resolvedDir = path3.resolve(process.cwd(), config.componentDir);
     console.log(chalk.green("Done!"));
     console.log(chalk.dim(`Components installed to: ${resolvedDir}
 `));
@@ -4944,13 +5076,13 @@ async function add(components, options = {}) {
 }
 
 // src/commands/diff.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import chalk2 from "chalk";
 import ora2 from "ora";
 var FETCH_TIMEOUT_MS = 1e4;
 async function diff(components) {
-  const configPath = path3.join(process.cwd(), "pdfx.json");
+  const configPath = path4.join(process.cwd(), "pdfx.json");
   if (!checkFileExists(configPath)) {
     console.error(chalk2.red("Error: pdfx.json not found"));
     console.log(chalk2.yellow("Run: pdfx init"));
@@ -4963,7 +5095,7 @@ async function diff(components) {
     process.exit(1);
   }
   const config = configResult.data;
-  const targetDir = path3.resolve(process.cwd(), config.componentDir);
+  const targetDir = path4.resolve(process.cwd(), config.componentDir);
   for (const componentName of components) {
     const nameResult = componentNameSchema.safeParse(componentName);
     if (!nameResult.success) {
@@ -4995,17 +5127,17 @@ async function diff(components) {
       }
       const component = result.data;
       spinner.stop();
-      const componentSubDir = path3.join(targetDir, component.name);
+      const componentSubDir = path4.join(targetDir, component.name);
       for (const file of component.files) {
-        const fileName = path3.basename(file.path);
+        const fileName = path4.basename(file.path);
         const localPath = safePath(componentSubDir, fileName);
         if (!checkFileExists(localPath)) {
           console.log(chalk2.yellow(`  ${fileName}: not installed locally`));
           continue;
         }
-        const localContent = fs3.readFileSync(localPath, "utf-8");
+        const localContent = fs4.readFileSync(localPath, "utf-8");
         const registryContent = config.theme && (file.content.includes("pdfx-theme") || file.content.includes("pdfx-theme-context")) ? resolveThemeImport(
-          path3.join(config.componentDir, component.name),
+          path4.join(config.componentDir, component.name),
           config.theme,
           file.content
         ) : file.content;
@@ -5028,11 +5160,11 @@ async function diff(components) {
 }
 
 // src/commands/init.ts
-import fs4 from "fs";
-import path4 from "path";
-import chalk3 from "chalk";
-import ora3 from "ora";
-import prompts2 from "prompts";
+import fs7 from "fs";
+import path7 from "path";
+import chalk5 from "chalk";
+import ora4 from "ora";
+import prompts3 from "prompts";
 
 // src/constants.ts
 var DEFAULTS = {
@@ -5046,23 +5178,294 @@ var REGISTRY_SUBPATHS = {
   TEMPLATES: "templates"
 };
 
+// src/utils/install-dependencies.ts
+import chalk3 from "chalk";
+import { execa } from "execa";
+import ora3 from "ora";
+import prompts2 from "prompts";
+
+// src/utils/package-manager.ts
+import fs5 from "fs";
+import path5 from "path";
+var PACKAGE_MANAGERS = {
+  pnpm: {
+    name: "pnpm",
+    lockfile: "pnpm-lock.yaml",
+    installCommand: "pnpm add"
+  },
+  yarn: {
+    name: "yarn",
+    lockfile: "yarn.lock",
+    installCommand: "yarn add"
+  },
+  bun: {
+    name: "bun",
+    lockfile: "bun.lockb",
+    installCommand: "bun add"
+  },
+  npm: {
+    name: "npm",
+    lockfile: "package-lock.json",
+    installCommand: "npm install"
+  }
+};
+function detectPackageManager(cwd = process.cwd()) {
+  const managers = ["pnpm", "yarn", "bun", "npm"];
+  for (const manager of managers) {
+    const info = PACKAGE_MANAGERS[manager];
+    const lockfilePath = path5.join(cwd, info.lockfile);
+    if (fs5.existsSync(lockfilePath)) {
+      return info;
+    }
+  }
+  return PACKAGE_MANAGERS.npm;
+}
+function getInstallCommand(packageManager, packages, devDependency = false) {
+  const pm = PACKAGE_MANAGERS[packageManager];
+  const devFlag = devDependency ? packageManager === "npm" ? "--save-dev" : "-D" : "";
+  return `${pm.installCommand} ${packages.join(" ")} ${devFlag}`.trim();
+}
+
+// src/utils/install-dependencies.ts
+async function promptAndInstallReactPdf(validation, cwd = process.cwd()) {
+  if (validation.installed && validation.valid) {
+    return {
+      success: true,
+      message: "@react-pdf/renderer is already installed and compatible"
+    };
+  }
+  const pm = detectPackageManager(cwd);
+  const packageName = "@react-pdf/renderer";
+  const installCmd = getInstallCommand(pm.name, [packageName]);
+  console.log(chalk3.yellow("\n  \u26A0 @react-pdf/renderer is required but not installed\n"));
+  console.log(chalk3.dim(`    This command will run: ${installCmd}
+`));
+  const { shouldInstall } = await prompts2({
+    type: "confirm",
+    name: "shouldInstall",
+    message: "Install @react-pdf/renderer now?",
+    initial: true
+  });
+  if (!shouldInstall) {
+    return {
+      success: false,
+      message: `Installation cancelled. Please install manually:
+  ${chalk3.cyan(installCmd)}`
+    };
+  }
+  const spinner = ora3("Installing @react-pdf/renderer...").start();
+  try {
+    await execa(pm.name, ["add", packageName], {
+      cwd,
+      stdio: "pipe"
+    });
+    spinner.succeed("Installed @react-pdf/renderer");
+    return {
+      success: true,
+      message: "@react-pdf/renderer installed successfully"
+    };
+  } catch (error) {
+    spinner.fail("Failed to install @react-pdf/renderer");
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Installation failed: ${message}
+  Try manually: ${chalk3.cyan(installCmd)}`
+    };
+  }
+}
+async function ensureReactPdfRenderer(validation, cwd = process.cwd()) {
+  if (!validation.installed) {
+    const result = await promptAndInstallReactPdf(validation, cwd);
+    if (!result.success) {
+      console.error(chalk3.red(`
+  ${result.message}
+`));
+      return false;
+    }
+    return true;
+  }
+  if (!validation.valid) {
+    console.log(
+      chalk3.yellow(
+        `
+  \u26A0 ${validation.message}
+  ${chalk3.dim("\u2192")} You may encounter compatibility issues
+`
+      )
+    );
+  }
+  return true;
+}
+
+// src/utils/pre-flight.ts
+import chalk4 from "chalk";
+
+// src/utils/environment-validator.ts
+import fs6 from "fs";
+import path6 from "path";
+function validatePackageJson(cwd = process.cwd()) {
+  const pkgPath = path6.join(cwd, "package.json");
+  const exists = fs6.existsSync(pkgPath);
+  return {
+    valid: exists,
+    message: exists ? "package.json found" : "No package.json found in current directory",
+    fixCommand: exists ? void 0 : 'Run "npm init" or "pnpm init" to create a package.json'
+  };
+}
+function validateReactProject(cwd = process.cwd()) {
+  const pkgPath = path6.join(cwd, "package.json");
+  if (!fs6.existsSync(pkgPath)) {
+    return {
+      valid: false,
+      message: "Cannot validate React project without package.json"
+    };
+  }
+  try {
+    const pkg = readJsonFile(pkgPath);
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    const hasReact = "react" in deps;
+    return {
+      valid: hasReact,
+      message: hasReact ? "React is installed" : "This does not appear to be a React project",
+      fixCommand: hasReact ? void 0 : "Install React: npx create-vite@latest or npx create-react-app"
+    };
+  } catch {
+    return {
+      valid: false,
+      message: "Failed to read package.json"
+    };
+  }
+}
+function validatePdfxConfig(cwd = process.cwd()) {
+  const configPath = path6.join(cwd, "pdfx.json");
+  const exists = fs6.existsSync(configPath);
+  return {
+    valid: true,
+    // Not blocking
+    message: exists ? "pdfx.json already exists (will prompt to overwrite)" : "No existing pdfx.json"
+  };
+}
+function validateEnvironment(cwd = process.cwd()) {
+  return {
+    hasPackageJson: validatePackageJson(cwd),
+    isReactProject: validateReactProject(cwd),
+    hasPdfxConfig: validatePdfxConfig(cwd)
+  };
+}
+
+// src/utils/pre-flight.ts
+function runPreFlightChecks(cwd = process.cwd()) {
+  const environment = validateEnvironment(cwd);
+  const dependencies = validateDependencies(cwd);
+  const blockingErrors = [];
+  const warnings = [];
+  if (!environment.hasPackageJson.valid) {
+    blockingErrors.push(
+      `${environment.hasPackageJson.message}
+  ${chalk4.dim("\u2192")} ${environment.hasPackageJson.fixCommand}`
+    );
+  }
+  if (!environment.isReactProject.valid) {
+    blockingErrors.push(
+      `${environment.isReactProject.message}
+  ${chalk4.dim("\u2192")} ${environment.isReactProject.fixCommand}`
+    );
+  }
+  if (!dependencies.nodeJs.valid) {
+    blockingErrors.push(
+      `${dependencies.nodeJs.message}
+  ${chalk4.dim("\u2192")} Current: ${dependencies.nodeJs.currentVersion}, Required: ${dependencies.nodeJs.requiredVersion}
+  ${chalk4.dim("\u2192")} Visit https://nodejs.org to upgrade`
+    );
+  }
+  if (!dependencies.react.valid && dependencies.react.installed) {
+    warnings.push(
+      `${dependencies.react.message}
+  ${chalk4.dim("\u2192")} Current: ${dependencies.react.currentVersion}, Required: ${dependencies.react.requiredVersion}`
+    );
+  } else if (!dependencies.react.installed) {
+    blockingErrors.push(
+      `${dependencies.react.message}
+  ${chalk4.dim("\u2192")} This should have been caught by React project check`
+    );
+  }
+  if (dependencies.reactPdfRenderer.installed && !dependencies.reactPdfRenderer.valid) {
+    warnings.push(
+      `${dependencies.reactPdfRenderer.message}
+  ${chalk4.dim("\u2192")} Consider upgrading: npm install @react-pdf/renderer@latest`
+    );
+  }
+  if (dependencies.typescript && !dependencies.typescript.valid) {
+    warnings.push(
+      `${dependencies.typescript.message}
+  ${chalk4.dim("\u2192")} Install types: npm install -D @types/react-pdf`
+    );
+  }
+  return {
+    environment,
+    dependencies,
+    blockingErrors,
+    warnings,
+    canProceed: blockingErrors.length === 0
+  };
+}
+function displayPreFlightResults(result) {
+  console.log(chalk4.bold("\n  Pre-flight Checks:\n"));
+  if (result.blockingErrors.length > 0) {
+    console.log(chalk4.red("  \u2717 Blocking Issues:\n"));
+    for (const error of result.blockingErrors) {
+      console.log(chalk4.red(`    \u2022 ${error}
+`));
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk4.yellow("  \u26A0 Warnings:\n"));
+    for (const warning of result.warnings) {
+      console.log(chalk4.yellow(`    \u2022 ${warning}
+`));
+    }
+  }
+  if (result.blockingErrors.length === 0 && result.warnings.length === 0) {
+    console.log(chalk4.green("  \u2713 All checks passed!\n"));
+  }
+}
+
 // src/commands/init.ts
 async function init() {
-  console.log(chalk3.bold.cyan("\n  Welcome to the pdfx cli\n"));
-  const existingConfig = path4.join(process.cwd(), "pdfx.json");
-  if (fs4.existsSync(existingConfig)) {
-    const { overwrite } = await prompts2({
+  console.log(chalk5.bold.cyan("\n  Welcome to the pdfx cli\n"));
+  const preFlightResult = runPreFlightChecks();
+  displayPreFlightResults(preFlightResult);
+  if (!preFlightResult.canProceed) {
+    console.error(
+      chalk5.red("\n  Cannot proceed due to blocking issues. Please fix them and try again.\n")
+    );
+    process.exit(1);
+  }
+  const hasReactPdf = await ensureReactPdfRenderer(preFlightResult.dependencies.reactPdfRenderer);
+  if (!hasReactPdf) {
+    console.error(
+      chalk5.red("\n  @react-pdf/renderer is required. Please install it and try again.\n")
+    );
+    process.exit(1);
+  }
+  const existingConfig = path7.join(process.cwd(), "pdfx.json");
+  if (fs7.existsSync(existingConfig)) {
+    const { overwrite } = await prompts3({
       type: "confirm",
       name: "overwrite",
       message: "pdfx.json already exists. Overwrite?",
       initial: false
     });
     if (!overwrite) {
-      console.log(chalk3.yellow("Init cancelled \u2014 existing config preserved."));
+      console.log(chalk5.yellow("Init cancelled \u2014 existing config preserved."));
       return;
     }
   }
-  const answers = await prompts2(
+  const answers = await prompts3(
     [
       {
         type: "text",
@@ -5108,13 +5511,13 @@ async function init() {
     ],
     {
       onCancel: () => {
-        console.log(chalk3.yellow("\nSetup cancelled."));
+        console.log(chalk5.yellow("\nSetup cancelled."));
         process.exit(0);
       }
     }
   );
   if (!answers.componentDir || !answers.registry) {
-    console.error(chalk3.red("Missing required fields. Run pdfx init again."));
+    console.error(chalk5.red("Missing required fields. Run pdfx init again."));
     process.exit(1);
   }
   const config = {
@@ -5126,54 +5529,54 @@ async function init() {
   const validation = configSchema.safeParse(config);
   if (!validation.success) {
     const issues = validation.error.issues.map((i) => i.message).join(", ");
-    console.error(chalk3.red(`Invalid configuration: ${issues}`));
+    console.error(chalk5.red(`Invalid configuration: ${issues}`));
     process.exit(1);
   }
-  const spinner = ora3("Creating config and theme files...").start();
+  const spinner = ora4("Creating config and theme files...").start();
   try {
-    fs4.writeFileSync(path4.join(process.cwd(), "pdfx.json"), JSON.stringify(config, null, 2));
+    fs7.writeFileSync(path7.join(process.cwd(), "pdfx.json"), JSON.stringify(config, null, 2));
     const presetName = answers.themePreset || "professional";
     const preset = themePresets[presetName];
-    const themePath = path4.resolve(process.cwd(), config.theme);
-    ensureDir(path4.dirname(themePath));
-    fs4.writeFileSync(themePath, generateThemeFile(preset), "utf-8");
-    const contextPath = path4.join(path4.dirname(themePath), "pdfx-theme-context.tsx");
-    fs4.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
+    const themePath = path7.resolve(process.cwd(), config.theme);
+    ensureDir(path7.dirname(themePath));
+    fs7.writeFileSync(themePath, generateThemeFile(preset), "utf-8");
+    const contextPath = path7.join(path7.dirname(themePath), "pdfx-theme-context.tsx");
+    fs7.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
     spinner.succeed(`Created pdfx.json + ${config.theme} (${presetName} theme)`);
-    console.log(chalk3.green("\nSuccess! You can now run:"));
-    console.log(chalk3.cyan("  pdfx add heading"));
-    console.log(chalk3.dim(`
-  Components: ${path4.resolve(process.cwd(), answers.componentDir)}`));
-    console.log(chalk3.dim(`  Theme: ${path4.resolve(process.cwd(), config.theme)}
+    console.log(chalk5.green("\nSuccess! You can now run:"));
+    console.log(chalk5.cyan("  pdfx add heading"));
+    console.log(chalk5.dim(`
+  Components: ${path7.resolve(process.cwd(), answers.componentDir)}`));
+    console.log(chalk5.dim(`  Theme: ${path7.resolve(process.cwd(), config.theme)}
 `));
   } catch (error) {
     spinner.fail("Failed to create config");
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk3.dim(`  ${message}`));
+    console.error(chalk5.dim(`  ${message}`));
     process.exit(1);
   }
 }
 
 // src/commands/list.ts
-import path5 from "path";
-import chalk4 from "chalk";
-import ora4 from "ora";
+import path8 from "path";
+import chalk6 from "chalk";
+import ora5 from "ora";
 var FETCH_TIMEOUT_MS2 = 1e4;
 async function list() {
-  const configPath = path5.join(process.cwd(), "pdfx.json");
+  const configPath = path8.join(process.cwd(), "pdfx.json");
   if (!checkFileExists(configPath)) {
-    console.error(chalk4.red("Error: pdfx.json not found"));
-    console.log(chalk4.yellow("Run: pdfx init"));
+    console.error(chalk6.red("Error: pdfx.json not found"));
+    console.log(chalk6.yellow("Run: pdfx init"));
     process.exit(1);
   }
   const raw = readJsonFile(configPath);
   const configResult = configSchema.safeParse(raw);
   if (!configResult.success) {
-    console.error(chalk4.red("Invalid pdfx.json"));
+    console.error(chalk6.red("Invalid pdfx.json"));
     process.exit(1);
   }
   const config = configResult.data;
-  const spinner = ora4("Fetching component list...").start();
+  const spinner = ora5("Fetching component list...").start();
   try {
     let response;
     try {
@@ -5195,17 +5598,17 @@ async function list() {
       throw new RegistryError("Invalid registry format");
     }
     spinner.stop();
-    const targetDir = path5.resolve(process.cwd(), config.componentDir);
+    const targetDir = path8.resolve(process.cwd(), config.componentDir);
     const components = result.data.items.filter((item) => item.type === "registry:ui");
-    console.log(chalk4.bold(`
+    console.log(chalk6.bold(`
   Available Components (${components.length})
 `));
     for (const item of components) {
-      const componentSubDir = path5.join(targetDir, item.name);
+      const componentSubDir = path8.join(targetDir, item.name);
       const localPath = safePath(componentSubDir, `pdfx-${item.name}.tsx`);
       const installed = checkFileExists(localPath);
-      const status = installed ? chalk4.green("[installed]") : chalk4.dim("[not installed]");
-      console.log(`  ${chalk4.cyan(item.name.padEnd(20))} ${item.description}`);
+      const status = installed ? chalk6.green("[installed]") : chalk6.dim("[not installed]");
+      console.log(`  ${chalk6.cyan(item.name.padEnd(20))} ${item.description}`);
       console.log(`  ${"".padEnd(20)} ${status}`);
       console.log();
     }
@@ -5217,10 +5620,10 @@ async function list() {
 }
 
 // src/commands/template.ts
-import path6 from "path";
-import chalk5 from "chalk";
-import ora5 from "ora";
-import prompts3 from "prompts";
+import path9 from "path";
+import chalk7 from "chalk";
+import ora6 from "ora";
+import prompts4 from "prompts";
 function readConfig2(configPath) {
   const raw = readJsonFile(configPath);
   const result = configSchema.safeParse(raw);
@@ -5228,7 +5631,7 @@ function readConfig2(configPath) {
     const issues = result.error.issues.map((i) => i.message).join(", ");
     throw new ConfigError(
       `Invalid pdfx.json: ${issues}`,
-      `Fix the config or re-run ${chalk5.cyan("pdfx init")}`
+      `Fix the config or re-run ${chalk7.cyan("pdfx init")}`
     );
   }
   return result.data;
@@ -5295,7 +5698,7 @@ async function fetchComponent2(name, registryUrl) {
 }
 function resolveTemplateImports(content, templateName, config) {
   const cwd = process.cwd();
-  const templateSubdir = path6.resolve(
+  const templateSubdir = path9.resolve(
     cwd,
     config.templateDir ?? DEFAULTS.TEMPLATE_DIR,
     templateName
@@ -5303,26 +5706,26 @@ function resolveTemplateImports(content, templateName, config) {
   let result = content.replace(
     /from '\.\.\/\.\.\/components\/pdfx\/([a-z][a-z0-9-]*)\/pdfx-([a-z][a-z0-9-]*)'/g,
     (_match, componentName) => {
-      const absCompFile = path6.resolve(
+      const absCompFile = path9.resolve(
         cwd,
         config.componentDir,
         componentName,
         `pdfx-${componentName}`
       );
-      let rel = path6.relative(templateSubdir, absCompFile);
+      let rel = path9.relative(templateSubdir, absCompFile);
       if (!rel.startsWith(".")) rel = `./${rel}`;
       return `from '${rel}'`;
     }
   );
   if (config.theme) {
-    const absThemePath = path6.resolve(cwd, config.theme).replace(/\.tsx?$/, "");
-    let relTheme = path6.relative(templateSubdir, absThemePath);
+    const absThemePath = path9.resolve(cwd, config.theme).replace(/\.tsx?$/, "");
+    let relTheme = path9.relative(templateSubdir, absThemePath);
     if (!relTheme.startsWith(".")) relTheme = `./${relTheme}`;
-    const absContextPath = path6.join(
-      path6.dirname(path6.resolve(cwd, config.theme)),
+    const absContextPath = path9.join(
+      path9.dirname(path9.resolve(cwd, config.theme)),
       "pdfx-theme-context"
     );
-    let relContext = path6.relative(templateSubdir, absContextPath);
+    let relContext = path9.relative(templateSubdir, absContextPath);
     if (!relContext.startsWith(".")) relContext = `./${relContext}`;
     result = result.replace(/from '\.\.\/\.\.\/lib\/pdfx-theme'/g, `from '${relTheme}'`);
     result = result.replace(/from '\.\.\/\.\.\/lib\/pdfx-theme-context'/g, `from '${relContext}'`);
@@ -5331,10 +5734,10 @@ function resolveTemplateImports(content, templateName, config) {
 }
 async function resolveConflict(fileName, currentDecision) {
   if (currentDecision === "overwrite-all") return "overwrite-all";
-  const { action } = await prompts3({
+  const { action } = await prompts4({
     type: "select",
     name: "action",
-    message: `${chalk5.yellow(fileName)} already exists. What would you like to do?`,
+    message: `${chalk7.yellow(fileName)} already exists. What would you like to do?`,
     choices: [
       { title: "Skip", value: "skip", description: "Keep the existing file unchanged" },
       { title: "Overwrite", value: "overwrite", description: "Replace this file only" },
@@ -5355,14 +5758,14 @@ async function ensurePeerComponents(template, config, force) {
   if (!template.peerComponents || template.peerComponents.length === 0) {
     return { installedPeers, peerWarnings };
   }
-  const componentBaseDir = path6.resolve(process.cwd(), config.componentDir);
+  const componentBaseDir = path9.resolve(process.cwd(), config.componentDir);
   for (const componentName of template.peerComponents) {
-    const componentDir = path6.join(componentBaseDir, componentName);
-    const expectedMain = path6.join(componentDir, `pdfx-${componentName}.tsx`);
+    const componentDir = path9.join(componentBaseDir, componentName);
+    const expectedMain = path9.join(componentDir, `pdfx-${componentName}.tsx`);
     if (checkFileExists(componentDir)) {
       if (!checkFileExists(expectedMain)) {
         peerWarnings.push(
-          `${componentName}: directory exists but expected file missing (${path6.basename(expectedMain)})`
+          `${componentName}: directory exists but expected file missing (${path9.basename(expectedMain)})`
         );
       } else {
         peerWarnings.push(
@@ -5373,9 +5776,9 @@ async function ensurePeerComponents(template, config, force) {
     }
     const component = await fetchComponent2(componentName, config.registry);
     ensureDir(componentDir);
-    const componentRelDir = path6.join(config.componentDir, component.name);
+    const componentRelDir = path9.join(config.componentDir, component.name);
     for (const file of component.files) {
-      const fileName = path6.basename(file.path);
+      const fileName = path9.basename(file.path);
       const filePath = safePath(componentDir, fileName);
       let content = file.content;
       if (config.theme && (content.includes("pdfx-theme") || content.includes("pdfx-theme-context"))) {
@@ -5396,12 +5799,12 @@ async function ensurePeerComponents(template, config, force) {
 async function installTemplate(name, config, force) {
   const template = await fetchTemplate(name, config.registry);
   const peerResult = await ensurePeerComponents(template, config, force);
-  const templateBaseDir = path6.resolve(process.cwd(), config.templateDir ?? DEFAULTS.TEMPLATE_DIR);
-  const templateDir = path6.join(templateBaseDir, template.name);
+  const templateBaseDir = path9.resolve(process.cwd(), config.templateDir ?? DEFAULTS.TEMPLATE_DIR);
+  const templateDir = path9.join(templateBaseDir, template.name);
   ensureDir(templateDir);
   const filesToWrite = [];
   for (const file of template.files) {
-    const fileName = path6.basename(file.path);
+    const fileName = path9.basename(file.path);
     const filePath = safePath(templateDir, fileName);
     let content = file.content;
     if (/\.(tsx?|jsx?)$/.test(fileName) && content.includes("../../")) {
@@ -5414,7 +5817,7 @@ async function installTemplate(name, config, force) {
     const resolved = [];
     for (const file of filesToWrite) {
       if (checkFileExists(file.filePath)) {
-        const decision = await resolveConflict(path6.basename(file.filePath), globalDecision);
+        const decision = await resolveConflict(path9.basename(file.filePath), globalDecision);
         if (decision === "overwrite-all") {
           globalDecision = "overwrite-all";
         }
@@ -5427,7 +5830,7 @@ async function installTemplate(name, config, force) {
       if (!file.skip) {
         writeFile(file.filePath, file.content);
       } else {
-        console.log(chalk5.dim(`  skipped ${path6.basename(file.filePath)}`));
+        console.log(chalk7.dim(`  skipped ${path9.basename(file.filePath)}`));
       }
     }
   } else {
@@ -5436,37 +5839,37 @@ async function installTemplate(name, config, force) {
     }
   }
   if (template.peerComponents && template.peerComponents.length > 0) {
-    const componentBaseDir = path6.resolve(process.cwd(), config.componentDir);
+    const componentBaseDir = path9.resolve(process.cwd(), config.componentDir);
     const missing = [];
     for (const comp of template.peerComponents) {
-      const compDir = path6.join(componentBaseDir, comp);
+      const compDir = path9.join(componentBaseDir, comp);
       if (!checkFileExists(compDir)) {
         missing.push(comp);
       }
     }
     if (missing.length > 0) {
       console.log();
-      console.log(chalk5.yellow("  Missing peer components:"));
+      console.log(chalk7.yellow("  Missing peer components:"));
       for (const comp of missing) {
-        console.log(chalk5.dim(`    ${comp}  \u2192  run: ${chalk5.cyan(`pdfx add ${comp}`)}`));
+        console.log(chalk7.dim(`    ${comp}  \u2192  run: ${chalk7.cyan(`pdfx add ${comp}`)}`));
       }
     }
   }
   if (config.theme) {
-    const absThemePath = path6.resolve(process.cwd(), config.theme);
-    const contextPath = path6.join(path6.dirname(absThemePath), "pdfx-theme-context.tsx");
+    const absThemePath = path9.resolve(process.cwd(), config.theme);
+    const contextPath = path9.join(path9.dirname(absThemePath), "pdfx-theme-context.tsx");
     if (!checkFileExists(contextPath)) {
-      ensureDir(path6.dirname(contextPath));
+      ensureDir(path9.dirname(contextPath));
       writeFile(contextPath, generateThemeContextFile());
     }
   }
   return peerResult;
 }
 async function templateAdd(names, options = {}) {
-  const configPath = path6.join(process.cwd(), "pdfx.json");
+  const configPath = path9.join(process.cwd(), "pdfx.json");
   if (!checkFileExists(configPath)) {
-    console.error(chalk5.red("Error: pdfx.json not found"));
-    console.log(chalk5.yellow("Run: pdfx init"));
+    console.error(chalk7.red("Error: pdfx.json not found"));
+    console.log(chalk7.yellow("Run: pdfx init"));
     process.exit(1);
   }
   let config;
@@ -5474,11 +5877,11 @@ async function templateAdd(names, options = {}) {
     config = readConfig2(configPath);
   } catch (error) {
     if (error instanceof ConfigError) {
-      console.error(chalk5.red(error.message));
-      if (error.suggestion) console.log(chalk5.yellow(`  Hint: ${error.suggestion}`));
+      console.error(chalk7.red(error.message));
+      if (error.suggestion) console.log(chalk7.yellow(`  Hint: ${error.suggestion}`));
     } else {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk5.red(message));
+      console.error(chalk7.red(message));
     }
     process.exit(1);
   }
@@ -5487,24 +5890,24 @@ async function templateAdd(names, options = {}) {
   for (const templateName of names) {
     const nameResult = componentNameSchema.safeParse(templateName);
     if (!nameResult.success) {
-      console.error(chalk5.red(`Invalid template name: "${templateName}"`));
+      console.error(chalk7.red(`Invalid template name: "${templateName}"`));
       console.log(
-        chalk5.dim('  Names must be lowercase alphanumeric with hyphens (e.g., "invoice-classic")')
+        chalk7.dim('  Names must be lowercase alphanumeric with hyphens (e.g., "invoice-classic")')
       );
       failed.push(templateName);
       continue;
     }
-    const spinner = ora5(`Adding template ${templateName}...`).start();
+    const spinner = ora6(`Adding template ${templateName}...`).start();
     try {
       const result = await installTemplate(templateName, config, force);
-      spinner.succeed(`Added template ${chalk5.cyan(templateName)}`);
+      spinner.succeed(`Added template ${chalk7.cyan(templateName)}`);
       if (result.installedPeers.length > 0) {
         console.log(
-          chalk5.green(`  Installed required components: ${result.installedPeers.join(", ")}`)
+          chalk7.green(`  Installed required components: ${result.installedPeers.join(", ")}`)
         );
       }
       for (const warning of result.peerWarnings) {
-        console.log(chalk5.yellow(`  Warning: ${warning}`));
+        console.log(chalk7.yellow(`  Warning: ${warning}`));
       }
     } catch (error) {
       if (error instanceof ValidationError && error.message.includes("Cancelled")) {
@@ -5513,24 +5916,24 @@ async function templateAdd(names, options = {}) {
       } else if (error instanceof NetworkError || error instanceof RegistryError || error instanceof ValidationError) {
         spinner.fail(error.message);
         if (error.suggestion) {
-          console.log(chalk5.dim(`  Hint: ${error.suggestion}`));
+          console.log(chalk7.dim(`  Hint: ${error.suggestion}`));
         }
       } else {
         spinner.fail(`Failed to add template ${templateName}`);
         const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk5.dim(`  ${message}`));
+        console.error(chalk7.dim(`  ${message}`));
       }
       failed.push(templateName);
     }
   }
   console.log();
   if (failed.length > 0) {
-    console.log(chalk5.yellow(`Failed: ${failed.join(", ")}`));
+    console.log(chalk7.yellow(`Failed: ${failed.join(", ")}`));
   }
   if (failed.length < names.length) {
-    const resolvedDir = path6.resolve(process.cwd(), config.templateDir ?? DEFAULTS.TEMPLATE_DIR);
-    console.log(chalk5.green("Done!"));
-    console.log(chalk5.dim(`Templates installed to: ${resolvedDir}
+    const resolvedDir = path9.resolve(process.cwd(), config.templateDir ?? DEFAULTS.TEMPLATE_DIR);
+    console.log(chalk7.green("Done!"));
+    console.log(chalk7.dim(`Templates installed to: ${resolvedDir}
 `));
   }
   if (failed.length > 0) {
@@ -5538,20 +5941,20 @@ async function templateAdd(names, options = {}) {
   }
 }
 async function templateList() {
-  const configPath = path6.join(process.cwd(), "pdfx.json");
+  const configPath = path9.join(process.cwd(), "pdfx.json");
   if (!checkFileExists(configPath)) {
-    console.error(chalk5.red("Error: pdfx.json not found"));
-    console.log(chalk5.yellow("Run: pdfx init"));
+    console.error(chalk7.red("Error: pdfx.json not found"));
+    console.log(chalk7.yellow("Run: pdfx init"));
     process.exit(1);
   }
   const raw = readJsonFile(configPath);
   const configResult = configSchema.safeParse(raw);
   if (!configResult.success) {
-    console.error(chalk5.red("Invalid pdfx.json"));
+    console.error(chalk7.red("Invalid pdfx.json"));
     process.exit(1);
   }
   const config = configResult.data;
-  const spinner = ora5("Fetching template list...").start();
+  const spinner = ora6("Fetching template list...").start();
   try {
     let response;
     try {
@@ -5575,28 +5978,28 @@ async function templateList() {
     spinner.stop();
     const templates = result.data.items.filter((item) => item.type === "registry:template");
     if (templates.length === 0) {
-      console.log(chalk5.dim("\n  No templates available in the registry.\n"));
+      console.log(chalk7.dim("\n  No templates available in the registry.\n"));
       return;
     }
-    const templateBaseDir = path6.resolve(
+    const templateBaseDir = path9.resolve(
       process.cwd(),
       config.templateDir ?? DEFAULTS.TEMPLATE_DIR
     );
-    console.log(chalk5.bold(`
+    console.log(chalk7.bold(`
   Available Templates (${templates.length})
 `));
     for (const item of templates) {
-      const templateDir = path6.join(templateBaseDir, item.name);
+      const templateDir = path9.join(templateBaseDir, item.name);
       const installed = checkFileExists(templateDir);
-      const status = installed ? chalk5.green("[installed]") : chalk5.dim("[not installed]");
-      console.log(`  ${chalk5.cyan(item.name.padEnd(22))} ${item.description ?? ""}`);
+      const status = installed ? chalk7.green("[installed]") : chalk7.dim("[not installed]");
+      console.log(`  ${chalk7.cyan(item.name.padEnd(22))} ${item.description ?? ""}`);
       console.log(`  ${"".padEnd(22)} ${status}`);
       if (item.peerComponents && item.peerComponents.length > 0) {
-        console.log(chalk5.dim(`  ${"".padEnd(22)} requires: ${item.peerComponents.join(", ")}`));
+        console.log(chalk7.dim(`  ${"".padEnd(22)} requires: ${item.peerComponents.join(", ")}`));
       }
       console.log();
     }
-    console.log(chalk5.dim(`  Install with: ${chalk5.cyan("pdfx template add <template-name>")}
+    console.log(chalk7.dim(`  Install with: ${chalk7.cyan("pdfx template add <template-name>")}
 `));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -5606,15 +6009,15 @@ async function templateList() {
 }
 
 // src/commands/theme.ts
-import fs5 from "fs";
-import path7 from "path";
-import chalk6 from "chalk";
-import ora6 from "ora";
-import prompts4 from "prompts";
+import fs8 from "fs";
+import path10 from "path";
+import chalk8 from "chalk";
+import ora7 from "ora";
+import prompts5 from "prompts";
 import ts from "typescript";
 async function themeInit() {
-  console.log(chalk6.bold.cyan("\n  PDFx Theme Setup\n"));
-  const answers = await prompts4(
+  console.log(chalk8.bold.cyan("\n  PDFx Theme Setup\n"));
+  const answers = await prompts5(
     [
       {
         type: "select",
@@ -5648,47 +6051,47 @@ async function themeInit() {
     ],
     {
       onCancel: () => {
-        console.log(chalk6.yellow("\nTheme setup cancelled."));
+        console.log(chalk8.yellow("\nTheme setup cancelled."));
         process.exit(0);
       }
     }
   );
   if (!answers.preset || !answers.themePath) {
-    console.error(chalk6.red("Missing required fields."));
+    console.error(chalk8.red("Missing required fields."));
     process.exit(1);
   }
   const presetName = answers.preset;
   const themePath = answers.themePath;
   const preset = themePresets[presetName];
-  const spinner = ora6(`Scaffolding ${presetName} theme...`).start();
+  const spinner = ora7(`Scaffolding ${presetName} theme...`).start();
   try {
-    const absThemePath = path7.resolve(process.cwd(), themePath);
-    ensureDir(path7.dirname(absThemePath));
-    fs5.writeFileSync(absThemePath, generateThemeFile(preset), "utf-8");
-    const contextPath = path7.join(path7.dirname(absThemePath), "pdfx-theme-context.tsx");
-    fs5.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
+    const absThemePath = path10.resolve(process.cwd(), themePath);
+    ensureDir(path10.dirname(absThemePath));
+    fs8.writeFileSync(absThemePath, generateThemeFile(preset), "utf-8");
+    const contextPath = path10.join(path10.dirname(absThemePath), "pdfx-theme-context.tsx");
+    fs8.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
     spinner.succeed(`Created ${themePath} with ${presetName} theme`);
-    const configPath = path7.join(process.cwd(), "pdfx.json");
-    if (fs5.existsSync(configPath)) {
+    const configPath = path10.join(process.cwd(), "pdfx.json");
+    if (fs8.existsSync(configPath)) {
       try {
         const rawConfig = readJsonFile(configPath);
         const result = configSchema.safeParse(rawConfig);
         if (result.success) {
           const updatedConfig = { ...result.data, theme: themePath };
-          fs5.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2), "utf-8");
-          console.log(chalk6.green("  Updated pdfx.json with theme path"));
+          fs8.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2), "utf-8");
+          console.log(chalk8.green("  Updated pdfx.json with theme path"));
         }
       } catch {
-        console.log(chalk6.yellow('  Could not update pdfx.json \u2014 add "theme" field manually'));
+        console.log(chalk8.yellow('  Could not update pdfx.json \u2014 add "theme" field manually'));
       }
     }
-    console.log(chalk6.dim(`
+    console.log(chalk8.dim(`
   Edit ${themePath} to customize your theme.
 `));
   } catch (error) {
     spinner.fail("Failed to create theme file");
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk6.dim(`  ${message}`));
+    console.error(chalk8.dim(`  ${message}`));
     process.exit(1);
   }
 }
@@ -5696,54 +6099,54 @@ async function themeSwitch(presetName) {
   const validPresets = Object.keys(themePresets);
   if (!validPresets.includes(presetName)) {
     console.error(
-      chalk6.red(`Invalid preset: "${presetName}". Valid presets: ${validPresets.join(", ")}`)
+      chalk8.red(`Invalid preset: "${presetName}". Valid presets: ${validPresets.join(", ")}`)
     );
     process.exit(1);
   }
   const validatedPreset = presetName;
-  const configPath = path7.join(process.cwd(), "pdfx.json");
-  if (!fs5.existsSync(configPath)) {
-    console.error(chalk6.red('No pdfx.json found. Run "pdfx init" first.'));
+  const configPath = path10.join(process.cwd(), "pdfx.json");
+  if (!fs8.existsSync(configPath)) {
+    console.error(chalk8.red('No pdfx.json found. Run "pdfx init" first.'));
     process.exit(1);
   }
   const rawConfig = readJsonFile(configPath);
   const result = configSchema.safeParse(rawConfig);
   if (!result.success) {
-    console.error(chalk6.red("Invalid pdfx.json configuration."));
+    console.error(chalk8.red("Invalid pdfx.json configuration."));
     process.exit(1);
   }
   const config = result.data;
   if (!config.theme) {
     console.error(
-      chalk6.red('No theme path in pdfx.json. Run "pdfx theme init" to set up theming.')
+      chalk8.red('No theme path in pdfx.json. Run "pdfx theme init" to set up theming.')
     );
     process.exit(1);
   }
-  const answer = await prompts4({
+  const answer = await prompts5({
     type: "confirm",
     name: "confirm",
     message: `This will overwrite ${config.theme} with the ${validatedPreset} preset. Continue?`,
     initial: false
   });
   if (!answer.confirm) {
-    console.log(chalk6.yellow("Cancelled."));
+    console.log(chalk8.yellow("Cancelled."));
     return;
   }
-  const spinner = ora6(`Switching to ${validatedPreset} theme...`).start();
+  const spinner = ora7(`Switching to ${validatedPreset} theme...`).start();
   try {
     const preset = themePresets[validatedPreset];
-    const absThemePath = path7.resolve(process.cwd(), config.theme);
-    fs5.writeFileSync(absThemePath, generateThemeFile(preset), "utf-8");
-    const contextPath = path7.join(path7.dirname(absThemePath), "pdfx-theme-context.tsx");
-    if (!fs5.existsSync(contextPath)) {
-      ensureDir(path7.dirname(contextPath));
-      fs5.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
+    const absThemePath = path10.resolve(process.cwd(), config.theme);
+    fs8.writeFileSync(absThemePath, generateThemeFile(preset), "utf-8");
+    const contextPath = path10.join(path10.dirname(absThemePath), "pdfx-theme-context.tsx");
+    if (!fs8.existsSync(contextPath)) {
+      ensureDir(path10.dirname(contextPath));
+      fs8.writeFileSync(contextPath, generateThemeContextFile(), "utf-8");
     }
     spinner.succeed(`Switched to ${validatedPreset} theme`);
   } catch (error) {
     spinner.fail("Failed to switch theme");
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk6.dim(`  ${message}`));
+    console.error(chalk8.dim(`  ${message}`));
     process.exit(1);
   }
 }
@@ -5785,7 +6188,7 @@ function toPlainValue(node) {
   return void 0;
 }
 function parseThemeObject(themePath) {
-  const content = fs5.readFileSync(themePath, "utf-8");
+  const content = fs8.readFileSync(themePath, "utf-8");
   const sourceFile = ts.createSourceFile(
     themePath,
     content,
@@ -5811,29 +6214,29 @@ function parseThemeObject(themePath) {
   throw new Error("No exported `theme` object found.");
 }
 async function themeValidate() {
-  const configPath = path7.join(process.cwd(), "pdfx.json");
-  if (!fs5.existsSync(configPath)) {
-    console.error(chalk6.red('No pdfx.json found. Run "pdfx init" first.'));
+  const configPath = path10.join(process.cwd(), "pdfx.json");
+  if (!fs8.existsSync(configPath)) {
+    console.error(chalk8.red('No pdfx.json found. Run "pdfx init" first.'));
     process.exit(1);
   }
   const rawConfig = readJsonFile(configPath);
   const configResult = configSchema.safeParse(rawConfig);
   if (!configResult.success) {
-    console.error(chalk6.red("Invalid pdfx.json configuration."));
+    console.error(chalk8.red("Invalid pdfx.json configuration."));
     process.exit(1);
   }
   if (!configResult.data.theme) {
     console.error(
-      chalk6.red('No theme path in pdfx.json. Run "pdfx theme init" to set up theming.')
+      chalk8.red('No theme path in pdfx.json. Run "pdfx theme init" to set up theming.')
     );
     process.exit(1);
   }
-  const absThemePath = path7.resolve(process.cwd(), configResult.data.theme);
-  if (!fs5.existsSync(absThemePath)) {
-    console.error(chalk6.red(`Theme file not found: ${configResult.data.theme}`));
+  const absThemePath = path10.resolve(process.cwd(), configResult.data.theme);
+  if (!fs8.existsSync(absThemePath)) {
+    console.error(chalk8.red(`Theme file not found: ${configResult.data.theme}`));
     process.exit(1);
   }
-  const spinner = ora6("Validating theme file...").start();
+  const spinner = ora7("Validating theme file...").start();
   try {
     const parsedTheme = parseThemeObject(absThemePath);
     const result = themeSchema.safeParse(parsedTheme);
@@ -5843,13 +6246,13 @@ async function themeValidate() {
       process.exit(1);
     }
     spinner.succeed("Theme file is valid");
-    console.log(chalk6.dim(`
+    console.log(chalk8.dim(`
   Validated: ${configResult.data.theme}
 `));
   } catch (error) {
     spinner.fail("Failed to validate theme");
     const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk6.dim(`  ${message}`));
+    console.error(chalk8.dim(`  ${message}`));
     process.exit(1);
   }
 }