@xylabs/toolchain 7.10.0 → 7.10.1

package/dist/index.mjs

@@ -699,15 +699,111 @@ function printWorkspaceCycles(cycles) {
   }
 }
 
+// src/lib/deprecationMigrate.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync5,
+  writeFileSync
+} from "fs";
+import PATH4 from "path";
+import { createInterface } from "readline";
+import chalk5 from "chalk";
+function findProjectRoot() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+function askYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase().startsWith("y"));
+    });
+  });
+}
+function replaceInFile(filePath, oldStr, newStr) {
+  if (!existsSync2(filePath)) return false;
+  const content = readFileSync5(filePath, "utf8");
+  if (!content.includes(oldStr)) return false;
+  writeFileSync(filePath, content.replaceAll(oldStr, newStr), "utf8");
+  return true;
+}
+function migrateRootPackageJson(pkg, pkgPath, oldPackage, depField) {
+  const version = pkg[depField][oldPackage];
+  delete pkg[depField][oldPackage];
+  pkg[depField]["@xylabs/toolchain"] = version;
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  console.warn(chalk5.green(`  \u2713 Replaced ${oldPackage} \u2192 @xylabs/toolchain in ${depField}`));
+}
+function migrateWorkspacePackageJson(wsPkgPath, dir, oldPackage) {
+  if (!existsSync2(wsPkgPath)) return;
+  const wsPkg = JSON.parse(readFileSync5(wsPkgPath, "utf8"));
+  let changed = false;
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (wsPkg[field]?.[oldPackage]) {
+      const ver = wsPkg[field][oldPackage];
+      delete wsPkg[field][oldPackage];
+      wsPkg[field]["@xylabs/toolchain"] = ver;
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeFileSync(wsPkgPath, `${JSON.stringify(wsPkg, null, 2)}
+`, "utf8");
+    console.warn(chalk5.green(`  \u2713 Updated ${dir}/package.json`));
+  }
+}
+async function migrateWorkspaces(root, workspacesGlob, oldPackage) {
+  if (!Array.isArray(workspacesGlob)) return;
+  const { globSync: globSync5 } = await import("glob");
+  for (const pattern of workspacesGlob) {
+    const dirs = globSync5(pattern, { cwd: root });
+    for (const dir of dirs) {
+      if (replaceInFile(PATH4.join(root, dir, "xy.config.ts"), oldPackage, "@xylabs/toolchain")) {
+        console.warn(chalk5.green(`  \u2713 Updated ${dir}/xy.config.ts imports`));
+      }
+      migrateWorkspacePackageJson(PATH4.join(root, dir, "package.json"), dir, oldPackage);
+    }
+  }
+}
+function printManualInstructions(oldPackage) {
+  console.warn(chalk5.gray("  Skipped. To migrate manually:\n"));
+  console.warn(chalk5.gray(`    1. Replace "${oldPackage}" with "@xylabs/toolchain" in package.json`));
+  console.warn(chalk5.gray("    2. Update xy.config.ts imports"));
+  console.warn(chalk5.gray("    3. Run your package manager install\n"));
+}
+async function deprecationMigrate(oldPackage) {
+  const root = findProjectRoot();
+  const pkgPath = PATH4.join(root, "package.json");
+  if (!existsSync2(pkgPath)) return;
+  const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+  const depField = pkg.dependencies?.[oldPackage] ? "dependencies" : pkg.devDependencies?.[oldPackage] ? "devDependencies" : void 0;
+  if (!depField) return;
+  console.warn(chalk5.yellow(`
+\u26A0  ${oldPackage} is deprecated. Use @xylabs/toolchain instead.
+`));
+  const shouldMigrate = await askYesNo(chalk5.cyan("  Auto-migrate to @xylabs/toolchain? [y/N] "));
+  if (!shouldMigrate) {
+    printManualInstructions(oldPackage);
+    return;
+  }
+  migrateRootPackageJson(pkg, pkgPath, oldPackage, depField);
+  if (replaceInFile(PATH4.join(root, "xy.config.ts"), oldPackage, "@xylabs/toolchain")) {
+    console.warn(chalk5.green("  \u2713 Updated xy.config.ts imports"));
+  }
+  await migrateWorkspaces(root, pkg.workspaces, oldPackage);
+  console.warn(chalk5.yellow("\n  Run your package manager install to complete the migration.\n"));
+}
+
 // src/lib/file/constants.ts
 var WINDOWS_NEWLINE_REGEX = /\r\n/g;
 var CROSS_PLATFORM_NEWLINE = "\n";
 
 // src/lib/file/fileLines.ts
 import {
-  existsSync as existsSync2,
-  readFileSync as readFileSync5,
-  writeFileSync
+  existsSync as existsSync3,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync2
 } from "fs";
 
 // src/lib/string/empty.ts
@@ -721,18 +817,18 @@ var union = (a, b) => /* @__PURE__ */ new Set([...new Set(a), ...new Set(b)]);
 var defaultReadFileSyncOptions = { encoding: "utf8" };
 
 // src/lib/file/fileLines.ts
-var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync2(uri) ? readFileSync5(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
+var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync3(uri) ? readFileSync6(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
 var readNonEmptyLines = (uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty);
 var writeLines = (uri, lines, options = defaultReadFileSyncOptions) => {
-  const existing = existsSync2(uri) ? readFileSync5(uri, options) : void 0;
+  const existing = existsSync3(uri) ? readFileSync6(uri, options) : void 0;
   const desired = lines.join(CROSS_PLATFORM_NEWLINE);
-  if (existing !== desired) writeFileSync(uri, desired, options);
+  if (existing !== desired) writeFileSync2(uri, desired, options);
 };
 
 // src/lib/file/tryReadFileSync.ts
-import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
 var tryReadFileSync = (uri, options = defaultReadFileSyncOptions) => {
-  return existsSync3(uri) ? readFileSync6(uri, options) : void 0;
+  return existsSync4(uri) ? readFileSync7(uri, options) : void 0;
 };
 
 // src/lib/fillTemplate.ts
@@ -741,7 +837,7 @@ function fillTemplate(template, data) {
 }
 
 // src/lib/generateIgnoreFiles.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // src/lib/initCwd.ts
 function INIT_CWD() {
@@ -752,7 +848,7 @@ function INIT_CWD() {
 var localeCompare = (a, b) => a.localeCompare(b);
 var mergeEntries = (a, b) => [...union(a, b)].toSorted(localeCompare);
 var generateIgnoreFiles = (filename2, pkg) => {
-  console.log(chalk5.green(`Generate ${filename2} Files`));
+  console.log(chalk6.green(`Generate ${filename2} Files`));
   const cwd6 = INIT_CWD();
   const pm = getPackageManager();
   const singleWorkspace = pkg ? pm.findWorkspace(pkg) : void 0;
@@ -775,27 +871,27 @@ var generateIgnoreFiles = (filename2, pkg) => {
 
 // src/lib/generateReadmeFiles.ts
 import { execFile } from "child_process";
-import FS, { readFileSync as readFileSync7 } from "fs";
+import FS, { readFileSync as readFileSync8 } from "fs";
 import {
   mkdir,
   readFile,
   writeFile
 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import PATH4 from "path";
-import { createInterface } from "readline";
+import PATH5 from "path";
+import { createInterface as createInterface2 } from "readline";
 import { promisify } from "util";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 var execFileAsync = promisify(execFile);
 var require3 = createRequire2(import.meta.url);
-var packageRoot2 = PATH4.dirname(require3.resolve("@xylabs/ts-scripts-common/package.json"));
-var readmeTemplatesDir = PATH4.resolve(packageRoot2, "templates", "readme");
+var packageRoot2 = PATH5.dirname(require3.resolve("@xylabs/ts-scripts-common/package.json"));
+var readmeTemplatesDir = PATH5.resolve(packageRoot2, "templates", "readme");
 function fillReadmeTemplate(template, data) {
   const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
   return fillTemplate(template, additionalData);
 }
 async function generateTypedoc(packageLocation, entryPoints) {
-  const tempDir = PATH4.join(packageLocation, ".temp-typedoc");
+  const tempDir = PATH5.join(packageLocation, ".temp-typedoc");
   try {
     if (!FS.existsSync(tempDir)) {
       FS.mkdirSync(tempDir, { recursive: true });
@@ -803,7 +899,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
     const typedocConfig = {
       disableSources: true,
       entryPointStrategy: "expand",
-      entryPoints: entryPoints.map((ep) => PATH4.resolve(packageLocation, ep)),
+      entryPoints: entryPoints.map((ep) => PATH5.resolve(packageLocation, ep)),
       excludeExternals: true,
       excludeInternal: true,
       excludePrivate: true,
@@ -819,7 +915,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
       theme: "markdown",
       useCodeBlocks: true
     };
-    const typedocJsonPath = PATH4.join(tempDir, "typedoc.json");
+    const typedocJsonPath = PATH5.join(tempDir, "typedoc.json");
     FS.writeFileSync(typedocJsonPath, JSON.stringify(typedocConfig, null, 2));
     try {
       await execFileAsync("npx", ["typedoc", "--options", typedocJsonPath], { cwd: process.cwd() });
@@ -838,7 +934,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
 }
 function consolidateMarkdown(tempDir) {
   let consolidated = "## Reference\n\n";
-  const mainReadmePath = PATH4.join(tempDir, "README.md");
+  const mainReadmePath = PATH5.join(tempDir, "README.md");
   if (FS.existsSync(mainReadmePath)) {
     const mainContent = FS.readFileSync(mainReadmePath, "utf8").replace(/^---(.|\n)*?---\n/, "").replace(/^# .+\n/, "").replaceAll(/\]\((.+?)\.md\)/g, "](#$1)");
     consolidated += mainContent + "\n\n";
@@ -854,7 +950,7 @@ function processDirectory(dir, level = 0) {
     for (const item of items) {
       if (item.isDirectory()) continue;
       if (item.name === "README.md" || !item.name.endsWith(".md")) continue;
-      const fileContent = FS.readFileSync(PATH4.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
+      const fileContent = FS.readFileSync(PATH5.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
       const moduleName = item.name.replace(".md", "");
       content += `
 
@@ -870,14 +966,14 @@ ${indent}### <a id="${moduleName}"></a>${moduleName}
 
 ${indent}### ${item.name}
 `;
-      content += processDirectory(PATH4.join(dir, item.name), level + 1);
+      content += processDirectory(PATH5.join(dir, item.name), level + 1);
     }
   } catch {
   }
   return content;
 }
 function askConfirmation(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -885,8 +981,8 @@ function askConfirmation(question) {
     });
   });
 }
-var DEFAULT_README_TEMPLATE = readFileSync7(PATH4.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
-var DEFAULT_README_BODY = readFileSync7(PATH4.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
+var DEFAULT_README_TEMPLATE = readFileSync8(PATH5.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
+var DEFAULT_README_BODY = readFileSync8(PATH5.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
 function applyLogoConfig(template, logoUrl, logoLinkUrl) {
   let result = template;
   if (logoUrl) {
@@ -902,14 +998,14 @@ function applyLogoConfig(template, logoUrl, logoLinkUrl) {
 }
 function resolveTemplatePath(templatePath) {
   const cwd6 = INIT_CWD();
-  return templatePath ?? PATH4.join(cwd6, ".xy", "README.template.md");
+  return templatePath ?? PATH5.join(cwd6, ".xy", "README.template.md");
 }
 async function loadOrCreateTemplate(resolvedTemplatePath) {
   try {
     const template = await readFile(resolvedTemplatePath, "utf8");
     return { created: false, template };
   } catch {
-    console.log(chalk6.yellow(`Template not found: ${resolvedTemplatePath}`));
+    console.log(chalk7.yellow(`Template not found: ${resolvedTemplatePath}`));
     const shouldCreate = await askConfirmation("Would you like to create a stock template? (y/N) ");
     if (!shouldCreate) {
       throw new Error("Template creation declined");
@@ -920,16 +1016,16 @@ async function loadOrCreateTemplate(resolvedTemplatePath) {
   }
 }
 async function scaffoldTemplate(resolvedTemplatePath, template) {
-  const xyDir = PATH4.dirname(resolvedTemplatePath);
+  const xyDir = PATH5.dirname(resolvedTemplatePath);
   await mkdir(xyDir, { recursive: true });
   await writeFile(resolvedTemplatePath, template);
-  console.log(chalk6.green(`Created template: ${resolvedTemplatePath}`));
-  const bodyPath = PATH4.join(xyDir, "README.body.md");
+  console.log(chalk7.green(`Created template: ${resolvedTemplatePath}`));
+  const bodyPath = PATH5.join(xyDir, "README.body.md");
   await writeFile(bodyPath, DEFAULT_README_BODY);
-  console.log(chalk6.green(`Created body template: ${bodyPath}`));
+  console.log(chalk7.green(`Created body template: ${bodyPath}`));
 }
 async function resolveBody(location, defaultBody) {
-  const localBodyPath = PATH4.join(location, "README.body.md");
+  const localBodyPath = PATH5.join(location, "README.body.md");
   try {
     return await readFile(localBodyPath, "utf8");
   } catch {
@@ -938,7 +1034,7 @@ async function resolveBody(location, defaultBody) {
 }
 async function generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose, pm) {
   try {
-    const pkgJsonPath = PATH4.join(location, "package.json");
+    const pkgJsonPath = PATH5.join(location, "package.json");
     const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
     const body = await resolveBody(location, defaultBody);
     const typedocContent = typedoc ? await generateTypedoc(location, ["src/index*.ts"]) : "";
@@ -948,17 +1044,17 @@ async function generateReadmeForWorkspace(location, name, template, defaultBody,
       pm,
       typedoc: typedocContent
     });
-    await writeFile(PATH4.join(location, "README.md"), readmeContent);
-    if (verbose) console.log(chalk6.green(`  ${name}`));
+    await writeFile(PATH5.join(location, "README.md"), readmeContent);
+    if (verbose) console.log(chalk7.green(`  ${name}`));
     return true;
   } catch (ex) {
     const error = ex;
-    console.warn(chalk6.yellow(`  Skipped ${location}: ${error.message}`));
+    console.warn(chalk7.yellow(`  Skipped ${location}: ${error.message}`));
     return false;
   }
 }
 async function loadDefaultBody(resolvedTemplatePath) {
-  const xyBodyPath = PATH4.join(PATH4.dirname(resolvedTemplatePath), "README.body.md");
+  const xyBodyPath = PATH5.join(PATH5.dirname(resolvedTemplatePath), "README.body.md");
   try {
     return await readFile(xyBodyPath, "utf8");
   } catch {
@@ -984,7 +1080,7 @@ async function generateReadmeFiles({
   typedoc = false,
   verbose = false
 }) {
-  console.log(chalk6.green("Generate README Files"));
+  console.log(chalk7.green("Generate README Files"));
   const resolvedTemplatePath = resolveTemplatePath(templatePath);
   let template;
   let templateCreated;
@@ -995,7 +1091,7 @@ async function generateReadmeFiles({
   }
   template = applyLogoConfig(template, logoUrl, logoLinkUrl);
   if (templateCreated) {
-    console.log(chalk6.green("Generating README files for all packages..."));
+    console.log(chalk7.green("Generating README files for all packages..."));
   }
   const defaultBody = await loadDefaultBody(resolvedTemplatePath);
   const pmName = detectPackageManager();
@@ -1019,18 +1115,18 @@ async function generateReadmeFiles({
   );
   const failed = flushResults(results);
   const ms = performance.now() - start2;
-  console.log(chalk6.blue(`Generated ${workspaces.length} README(s) in ${ms.toFixed(0)}ms`));
+  console.log(chalk7.blue(`Generated ${workspaces.length} README(s) in ${ms.toFixed(0)}ms`));
   return failed ? 1 : 0;
 }
 
 // src/lib/gitignoreTemplate.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import PATH5 from "path";
+import PATH6 from "path";
 var require4 = createRequire3(import.meta.url);
-var packageRoot3 = PATH5.dirname(require4.resolve("@xylabs/ts-scripts-common/package.json"));
-var templatesDir2 = PATH5.resolve(packageRoot3, "templates", "gitignore");
-var gitignoreTemplate = () => readFileSync8(PATH5.resolve(templatesDir2, "template.gitignore"), "utf8");
+var packageRoot3 = PATH6.dirname(require4.resolve("@xylabs/ts-scripts-common/package.json"));
+var templatesDir2 = PATH6.resolve(packageRoot3, "templates", "gitignore");
+var gitignoreTemplate = () => readFileSync9(PATH6.resolve(templatesDir2, "template.gitignore"), "utf8");
 
 // src/lib/latestVersions.ts
 var latestVersions = {
@@ -1042,7 +1138,7 @@ var latestVersions = {
 };
 
 // src/lib/loadConfig.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { cosmiconfig } from "cosmiconfig";
 import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
 import deepmerge from "deepmerge";
@@ -1060,9 +1156,9 @@ var loadConfig = async (params) => {
     rootConfigPath = cosmicConfigResult?.filepath;
     const configFilePath = cosmicConfigResult?.filepath;
     if (configFilePath !== void 0) {
-      console.log(chalk7.green(`Loaded config from ${configFilePath}`));
+      console.log(chalk8.green(`Loaded config from ${configFilePath}`));
       if (config.verbose) {
-        console.log(chalk7.gray(`${JSON.stringify(config, null, 2)}`));
+        console.log(chalk8.gray(`${JSON.stringify(config, null, 2)}`));
       }
     }
   }
@@ -1092,7 +1188,7 @@ function resolveCommandField(cfg, commandName, configPath) {
     const key = `${configPath ?? "unknown"}:${commandName}`;
     if (!deprecationWarned.has(key)) {
       deprecationWarned.add(key);
-      console.warn(chalk7.yellow(
+      console.warn(chalk8.yellow(
         `[xy] Deprecated: top-level "${commandName}" in ${configPath ?? "xy.config"} \u2014 move to "commands.${commandName}"`
       ));
     }
@@ -1110,7 +1206,7 @@ async function loadWorkspaceCommandConfig(workspaceDir, commandName) {
 }
 
 // src/lib/packageName.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import path from "path";
 function packageName() {
   if (process.env.npm_package_name) {
@@ -1118,7 +1214,7 @@ function packageName() {
   }
   try {
     const pkgPath = path.join(INIT_CWD(), "package.json");
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
     return pkg.name;
   } catch {
     return void 0;
@@ -1126,29 +1222,29 @@ function packageName() {
 }
 
 // src/lib/parsedPackageJSON.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 var parsedPackageJSON = (path19) => {
   const pathToPackageJSON = path19 ?? process.env.npm_package_json ?? "";
-  const packageJSON = readFileSync10(pathToPackageJSON).toString();
+  const packageJSON = readFileSync11(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
 
 // src/lib/repoTemplates.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync12 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import PATH6 from "path";
+import PATH7 from "path";
 var require5 = createRequire4(import.meta.url);
-var packageRoot4 = PATH6.dirname(require5.resolve("@xylabs/ts-scripts-common/package.json"));
-var repoTemplatesDir = PATH6.resolve(packageRoot4, "templates", "repo");
+var packageRoot4 = PATH7.dirname(require5.resolve("@xylabs/ts-scripts-common/package.json"));
+var repoTemplatesDir = PATH7.resolve(packageRoot4, "templates", "repo");
 function collectFiles(dir, prefix) {
   const results = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      results.push(...collectFiles(PATH6.resolve(dir, entry.name), rel));
+      results.push(...collectFiles(PATH7.resolve(dir, entry.name), rel));
     } else {
       results.push({
-        content: readFileSync11(PATH6.resolve(dir, entry.name), "utf8"),
+        content: readFileSync12(PATH7.resolve(dir, entry.name), "utf8"),
         relativePath: rel
       });
     }
@@ -1156,7 +1252,7 @@ function collectFiles(dir, prefix) {
   return results;
 }
 function loadRepoTemplateFiles(template, section) {
-  const dir = PATH6.resolve(repoTemplatesDir, template, section);
+  const dir = PATH7.resolve(repoTemplatesDir, template, section);
   return collectFiles(dir, "");
 }
 function listRepoTemplates() {
@@ -1165,37 +1261,37 @@ function listRepoTemplates() {
 
 // src/lib/runInstall.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function runInstall(cwd6) {
   const pm = detectPackageManager();
-  console.log(chalk8.gray(`Running ${pm} install...`));
+  console.log(chalk9.gray(`Running ${pm} install...`));
   const result = spawnSync5(pm, ["install"], {
     cwd: cwd6,
     stdio: "inherit"
   });
   if (result.status !== 0) {
-    console.warn(chalk8.yellow(`${pm} install failed`));
+    console.warn(chalk9.yellow(`${pm} install failed`));
     return false;
   }
-  console.log(chalk8.green("Dependencies installed"));
+  console.log(chalk9.green("Dependencies installed"));
   return true;
 }
 
 // src/lib/runSteps.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import chalk9 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+import chalk10 from "chalk";
 var runSteps = (name, steps, exitOnFail = true, messages) => {
   return safeExit(() => {
     const pkgName = packageName();
-    console.log(chalk9.green(`${name} [${pkgName}]`));
+    console.log(chalk10.green(`${name} [${pkgName}]`));
     let totalStatus = 0;
     for (const [i, [command, args, config2]] of steps.entries()) {
       if (messages?.[i]) {
-        console.log(chalk9.gray(messages?.[i]));
+        console.log(chalk10.gray(messages?.[i]));
       }
       const argList = Array.isArray(args) ? args : args.split(" ");
-      if (command === "node" && !existsSync4(argList[0])) {
+      if (command === "node" && !existsSync5(argList[0])) {
         throw new Error(`File not found [${argList[0]}]`);
       }
       const status = spawnSync6(command, Array.isArray(args) ? args : args.split(" "), {
@@ -1214,16 +1310,16 @@ var runSteps = (name, steps, exitOnFail = true, messages) => {
 
 // src/lib/runStepsAsync.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import chalk10 from "chalk";
+import { existsSync as existsSync6 } from "fs";
+import chalk11 from "chalk";
 var runStepAsync = (name, step, exitOnFail = true, message) => {
   return new Promise((resolve) => {
     const [command, args, config2] = step;
     if (message) {
-      console.log(chalk10.gray(message));
+      console.log(chalk11.gray(message));
     }
     const argList = Array.isArray(args) ? args : args.split(" ");
-    if (command === "node" && !existsSync5(argList[0])) {
+    if (command === "node" && !existsSync6(argList[0])) {
       throw new Error(`File not found [${argList[0]}]`);
     }
     spawn(command, Array.isArray(args) ? args : args.split(" "), {
@@ -1234,8 +1330,8 @@ var runStepAsync = (name, step, exitOnFail = true, message) => {
     }).on("close", (code) => {
       if (code) {
         console.error(
-          chalk10.red(
-            `Command Exited With Non-Zero Result [${chalk10.gray(code)}] | ${chalk10.yellow(command)} ${chalk10.white(
+          chalk11.red(
+            `Command Exited With Non-Zero Result [${chalk11.gray(code)}] | ${chalk11.yellow(command)} ${chalk11.white(
               Array.isArray(args) ? args.join(" ") : args
             )}`
           )
@@ -1251,7 +1347,7 @@ var runStepAsync = (name, step, exitOnFail = true, message) => {
 var runStepsAsync = async (name, steps, exitOnFail = true, messages) => {
   return await safeExitAsync(async () => {
     const pkgName = packageName();
-    console.log(chalk10.green(`${name} [${pkgName}]`));
+    console.log(chalk11.green(`${name} [${pkgName}]`));
     let result = 0;
     for (const [i, step] of steps.entries()) {
       result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
@@ -1270,33 +1366,33 @@ var runXy = (command) => {
 };
 
 // src/lib/runXyWithWarning.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var runXyWithWarning = (command) => {
   const pm = getPackageManager();
   const commandString = `${pm.command} ${command}`;
   const commandXyString = `${pm.command} xy ${command}`;
-  console.warn(chalk11.yellow(`WARNING: [${chalk11.white(commandString)}] is deprecated for XY Labs Scripts.`));
-  console.warn(chalk11.gray(`Did you mean [${chalk11.magenta(commandXyString)}]?`));
+  console.warn(chalk12.yellow(`WARNING: [${chalk12.white(commandString)}] is deprecated for XY Labs Scripts.`));
+  console.warn(chalk12.gray(`Did you mean [${chalk12.magenta(commandXyString)}]?`));
   return 1;
 };
 
 // src/lib/tryRunLocalScript.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { readFileSync as readFileSync12 } from "fs";
-import PATH7 from "path";
-import chalk12 from "chalk";
+import { readFileSync as readFileSync13 } from "fs";
+import PATH8 from "path";
+import chalk13 from "chalk";
 function tryRunLocalScript(commandName) {
   if (process.env.XY_LOCAL_SCRIPT === "1") return void 0;
-  const rootPkgPath = PATH7.resolve(process.cwd(), "package.json");
+  const rootPkgPath = PATH8.resolve(process.cwd(), "package.json");
   let rootPkg;
   try {
-    rootPkg = JSON.parse(readFileSync12(rootPkgPath, "utf8"));
+    rootPkg = JSON.parse(readFileSync13(rootPkgPath, "utf8"));
   } catch {
     return void 0;
   }
   if (!rootPkg.scripts?.[commandName]) return void 0;
   const extraArgs = process.argv.slice(process.argv.indexOf(commandName) + 1);
-  console.log(chalk12.blue(`Delegating "${commandName}" to local script`));
+  console.log(chalk13.blue(`Delegating "${commandName}" to local script`));
   const pm = getPackageManager();
   const result = spawnSync7(pm.command, ["run", commandName, ...extraArgs], {
     cwd: process.cwd(),
@@ -1313,17 +1409,17 @@ function tryRunLocalScript(commandName) {
 }
 
 // src/lib/updo/applyUpdates.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync2 } from "fs";
-import PATH8 from "path";
-import chalk13 from "chalk";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync3 } from "fs";
+import PATH9 from "path";
+import chalk14 from "chalk";
 function applyUpdates(cwd6, workspaces, updates) {
   const updateMap = new Map(updates.map((u) => [u.name, u]));
   let modified = 0;
   for (const ws of workspaces) {
-    const pkgPath = PATH8.resolve(cwd6, ws.location, "package.json");
+    const pkgPath = PATH9.resolve(cwd6, ws.location, "package.json");
     let content;
     try {
-      content = readFileSync13(pkgPath, "utf8");
+      content = readFileSync14(pkgPath, "utf8");
     } catch {
       continue;
     }
@@ -1344,26 +1440,26 @@ function applyUpdates(cwd6, workspaces, updates) {
       }
     }
     if (changed) {
-      writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+      writeFileSync3(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
       modified++;
-      console.log(chalk13.gray(`  Updated ${ws.name}`));
+      console.log(chalk14.gray(`  Updated ${ws.name}`));
     }
   }
   return modified;
 }
 
 // src/lib/updo/collectWorkspaceDeps.ts
-import { readFileSync as readFileSync14 } from "fs";
-import PATH9 from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import PATH10 from "path";
 var DEP_FIELDS = ["dependencies", "devDependencies", "peerDependencies"];
 function collectWorkspaceDeps(cwd6, workspaces, workspaceNames) {
   const depMap = /* @__PURE__ */ new Map();
   for (const ws of workspaces) {
-    const pkgPath = PATH9.resolve(cwd6, ws.location, "package.json");
+    const pkgPath = PATH10.resolve(cwd6, ws.location, "package.json");
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+      pkg = JSON.parse(readFileSync15(pkgPath, "utf8"));
     } catch {
       continue;
     }
@@ -1445,51 +1541,51 @@ import {
   useRef,
   useState
 } from "@inquirer/core";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import semver from "semver";
 function versionColor(version, current) {
-  if (!version || !current) return chalk14.gray;
-  if (version === current) return chalk14.gray;
+  if (!version || !current) return chalk15.gray;
+  if (version === current) return chalk15.gray;
   const diff = semver.diff(current, version);
-  if (diff === "major" || diff === "premajor") return chalk14.red;
-  if (diff === "minor" || diff === "preminor") return chalk14.yellow;
-  return chalk14.green;
+  if (diff === "major" || diff === "premajor") return chalk15.red;
+  if (diff === "minor" || diff === "preminor") return chalk15.yellow;
+  return chalk15.green;
 }
 function pad(raw, colored, width) {
   return colored + " ".repeat(Math.max(0, width - raw.length));
 }
 function dot(selected) {
-  return selected ? chalk14.green("\u25CF") : chalk14.dim("\u25CB");
+  return selected ? chalk15.green("\u25CF") : chalk15.dim("\u25CB");
 }
 function renderHeader(w) {
   const header = [
     "  ",
-    chalk14.bold("Package".padEnd(w.name)),
-    chalk14.bold("Current".padEnd(w.current)),
-    chalk14.bold("  Wanted".padEnd(w.wanted + 2)),
-    chalk14.bold("  Latest".padEnd(w.latest + 2)),
-    chalk14.bold("  Next/RC".padEnd(w.next + 2))
+    chalk15.bold("Package".padEnd(w.name)),
+    chalk15.bold("Current".padEnd(w.current)),
+    chalk15.bold("  Wanted".padEnd(w.wanted + 2)),
+    chalk15.bold("  Latest".padEnd(w.latest + 2)),
+    chalk15.bold("  Next/RC".padEnd(w.next + 2))
   ].join("  ");
   const totalWidth = w.name + w.current + w.wanted + w.latest + w.next + 24;
   return `${header}
-${chalk14.gray("\u2500".repeat(totalWidth))}`;
+${chalk15.gray("\u2500".repeat(totalWidth))}`;
 }
 function renderRow(dep, selection, active, w) {
-  const pointer = active ? chalk14.cyan("\u276F") : " ";
+  const pointer = active ? chalk15.cyan("\u276F") : " ";
   const rawName = dep.name;
-  const name = active ? chalk14.white(rawName) : chalk14.gray(rawName);
+  const name = active ? chalk15.white(rawName) : chalk15.gray(rawName);
   const rawCurrent = dep.current ?? "-";
-  const current = chalk14.gray(rawCurrent);
+  const current = chalk15.gray(rawCurrent);
   const rawWanted = dep.wanted ?? "-";
-  const wantedColorFn = dep.wanted ? versionColor(dep.wanted, dep.current) : chalk14.gray;
+  const wantedColorFn = dep.wanted ? versionColor(dep.wanted, dep.current) : chalk15.gray;
   const wantedDot = dep.wanted ? dot(selection === 0) : " ";
   const wanted = `${wantedDot} ${pad(rawWanted, wantedColorFn(rawWanted), w.wanted)}`;
   const rawLatest = dep.latest ?? "-";
-  const latestColorFn = dep.latest ? versionColor(dep.latest, dep.current) : chalk14.gray;
+  const latestColorFn = dep.latest ? versionColor(dep.latest, dep.current) : chalk15.gray;
   const latestDot = dep.latest ? dot(selection === 1) : " ";
   const latest = `${latestDot} ${pad(rawLatest, latestColorFn(rawLatest), w.latest)}`;
   const rawNext = dep.next ?? "-";
-  const nextColorFn = dep.next ? versionColor(dep.next, dep.current) : chalk14.gray;
+  const nextColorFn = dep.next ? versionColor(dep.next, dep.current) : chalk15.gray;
   const nextDot = dep.next ? dot(selection === 2) : " ";
   const next = `${nextDot} ${pad(rawNext, nextColorFn(rawNext), w.next)}`;
   return `${pointer} ${pad(rawName, name, w.name)}  ${pad(rawCurrent, current, w.current)}  ${wanted}  ${latest}  ${next}`;
@@ -1540,8 +1636,8 @@ function renderPage(rows, cursor, selections, w, pageSize) {
     lines.push(renderRow(rows[i], selections[i], i === cursor, w));
   }
   if (total > pageSize) {
-    if (start2 > 0) lines.unshift(chalk14.dim("  \u2191 more"));
-    if (end < total) lines.push(chalk14.dim("  \u2193 more"));
+    if (start2 > 0) lines.unshift(chalk15.dim("  \u2191 more"));
+    if (end < total) lines.push(chalk15.dim("  \u2193 more"));
   }
   return lines.join("\n");
 }
@@ -1590,7 +1686,7 @@ var updoPrompt = createPrompt((config2, done) => {
   const header = renderHeader(w);
   const page = renderPage(rows, cursor, selections.current, w, 20);
   const selectedCount = selections.current.filter((s) => s >= 0).length;
-  const status = chalk14.gray(`  ${selectedCount} selected  \u2191/\u2193 navigate  space cycle version  enter confirm`);
+  const status = chalk15.gray(`  ${selectedCount} selected  \u2191/\u2193 navigate  space cycle version  enter confirm`);
   return `${header}
 ${page}
 ${status}`;
@@ -1598,11 +1694,11 @@ ${status}`;
 async function interactiveSelect(deps) {
   const updatable = deps.filter((d) => d.updateAvailable);
   if (updatable.length === 0) {
-    console.log(chalk14.green("\nAll packages are up to date!"));
+    console.log(chalk15.green("\nAll packages are up to date!"));
     return [];
   }
   if (!process.stdout.isTTY) {
-    console.log(chalk14.yellow("Non-interactive environment detected, skipping selection."));
+    console.log(chalk15.yellow("Non-interactive environment detected, skipping selection."));
     return [];
   }
   try {
@@ -1616,24 +1712,24 @@ async function interactiveSelect(deps) {
 }
 
 // src/lib/updo/renderTable.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import semver2 from "semver";
 function versionColor2(version, current) {
-  if (!version || !current) return chalk15.gray(version ?? "-");
-  if (version === current) return chalk15.gray(version);
+  if (!version || !current) return chalk16.gray(version ?? "-");
+  if (version === current) return chalk16.gray(version);
   const diff = semver2.diff(current, version);
-  if (diff === "major" || diff === "premajor") return chalk15.red(version);
-  if (diff === "minor" || diff === "preminor") return chalk15.yellow(version);
-  return chalk15.green(version);
+  if (diff === "major" || diff === "premajor") return chalk16.red(version);
+  if (diff === "minor" || diff === "preminor") return chalk16.yellow(version);
+  return chalk16.green(version);
 }
 var columns = [
   {
-    color: (_v, dep) => dep.updateAvailable ? chalk15.white(dep.name) : chalk15.gray(dep.name),
+    color: (_v, dep) => dep.updateAvailable ? chalk16.white(dep.name) : chalk16.gray(dep.name),
     header: "Package",
     value: (dep) => dep.name
   },
   {
-    color: (_v, dep) => chalk15.gray(dep.current ?? "-"),
+    color: (_v, dep) => chalk16.gray(dep.current ?? "-"),
     header: "Current",
     value: (dep) => dep.current ?? "-"
   },
@@ -1653,7 +1749,7 @@ var columns = [
     value: (dep) => dep.next ?? "-"
   },
   {
-    color: (_v, dep) => chalk15.gray(dep.depTypes.join(", ")),
+    color: (_v, dep) => chalk16.gray(dep.depTypes.join(", ")),
     header: "Type",
     value: (dep) => dep.depTypes.join(", ")
   }
@@ -1661,7 +1757,7 @@ var columns = [
 function renderTable(deps) {
   const updatable = deps.filter((d) => d.updateAvailable);
   if (updatable.length === 0) {
-    console.log(chalk15.green("\nAll packages are up to date!"));
+    console.log(chalk16.green("\nAll packages are up to date!"));
     return;
   }
   const widths = columns.map((col) => {
@@ -1671,14 +1767,14 @@ function renderTable(deps) {
     }
     return Math.max(col.header.length, maxData);
   });
-  const header = columns.map((col, i) => chalk15.bold(col.header.padEnd(widths[i]))).join("  ");
+  const header = columns.map((col, i) => chalk16.bold(col.header.padEnd(widths[i]))).join("  ");
   console.log(`
 ${header}`);
   let totalWidth = -2;
   for (const w of widths) {
     totalWidth += w + 2;
   }
-  console.log(chalk15.gray("\u2500".repeat(totalWidth)));
+  console.log(chalk16.gray("\u2500".repeat(totalWidth)));
   for (const dep of updatable) {
     const row = columns.map((col, i) => {
       const raw = col.value(dep);
@@ -1738,29 +1834,29 @@ function resolveVersions(deps, registry, installedVersions) {
 }
 
 // src/lib/updo/runUpdo.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 async function runUpdo(pm, _options = {}) {
   const cwd6 = INIT_CWD();
   const workspaces = pm.listWorkspaces();
   const workspaceNames = new Set(workspaces.map((ws) => ws.name));
-  console.log(chalk16.gray("Scanning workspace dependencies..."));
+  console.log(chalk17.gray("Scanning workspace dependencies..."));
   const declaredDeps = collectWorkspaceDeps(cwd6, workspaces, workspaceNames);
-  console.log(chalk16.gray(`  Found ${declaredDeps.size} unique dependencies across ${workspaces.length} workspaces`));
-  console.log(chalk16.gray("Fetching registry info..."));
+  console.log(chalk17.gray(`  Found ${declaredDeps.size} unique dependencies across ${workspaces.length} workspaces`));
+  console.log(chalk17.gray("Fetching registry info..."));
   const registryInfo = await fetchAllRegistryInfo([...declaredDeps.keys()]);
-  console.log(chalk16.gray("Reading installed versions..."));
+  console.log(chalk17.gray("Reading installed versions..."));
   const installedVersions = pm.listInstalledVersions();
   const resolved = resolveVersions(declaredDeps, registryInfo, installedVersions);
   const updates = await interactiveSelect(resolved);
   if (updates.length === 0) {
-    console.log(chalk16.gray("No updates selected."));
+    console.log(chalk17.gray("No updates selected."));
     return 0;
   }
-  console.log(chalk16.gray(`
+  console.log(chalk17.gray(`
 Applying ${updates.length} updates...`));
   const modified = applyUpdates(cwd6, workspaces, updates);
-  console.log(chalk16.gray(`  Modified ${modified} package.json files`));
-  console.log(chalk16.gray("Installing updated dependencies..."));
+  console.log(chalk17.gray(`  Modified ${modified} package.json files`));
+  console.log(chalk17.gray("Installing updated dependencies..."));
   return runSteps("Updo", [
     pm.install(),
     pm.dedupe()
@@ -1797,13 +1893,13 @@ var build = async ({
 
 // src/actions/claude-check.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   statSync as statSync2
 } from "fs";
-import PATH10 from "path";
-import chalk17 from "chalk";
+import PATH11 from "path";
+import chalk18 from "chalk";
 var checkCommands = (commandsDir) => {
   const pm = detectPackageManager();
   const rawTemplates = claudeCommandTemplates();
@@ -1814,15 +1910,15 @@ var checkCommands = (commandsDir) => {
   const missing = [];
   const outdated = [];
   for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH10.resolve(commandsDir, filename2);
-    if (!existsSync6(targetPath)) {
+    const targetPath = PATH11.resolve(commandsDir, filename2);
+    if (!existsSync7(targetPath)) {
       missing.push(filename2);
-    } else if (readFileSync15(targetPath, "utf8") !== content) {
+    } else if (readFileSync16(targetPath, "utf8") !== content) {
       outdated.push(filename2);
     }
   }
   const templateNames = new Set(Object.keys(templates));
-  const stale = existsSync6(commandsDir) ? readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  const stale = existsSync7(commandsDir) ? readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
   return {
     missing,
     outdated,
@@ -1839,15 +1935,15 @@ var checkRules = (rulesDir) => {
   const missing = [];
   const outdated = [];
   for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH10.resolve(rulesDir, filename2);
-    if (!existsSync6(targetPath)) {
+    const targetPath = PATH11.resolve(rulesDir, filename2);
+    if (!existsSync7(targetPath)) {
       missing.push(filename2);
-    } else if (readFileSync15(targetPath, "utf8") !== content) {
+    } else if (readFileSync16(targetPath, "utf8") !== content) {
       outdated.push(filename2);
     }
   }
   const templateNames = new Set(Object.keys(templates));
-  const stale = existsSync6(rulesDir) ? readdirSync3(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  const stale = existsSync7(rulesDir) ? readdirSync3(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
   return {
     missing,
     outdated,
@@ -1860,24 +1956,24 @@ var checkSkills = (skillsDir) => {
   const missing = [];
   const outdated = [];
   for (const [skillName, files] of Object.entries(rawTemplates)) {
-    const skillDir = PATH10.resolve(skillsDir, skillName);
-    if (!existsSync6(skillDir)) {
+    const skillDir = PATH11.resolve(skillsDir, skillName);
+    if (!existsSync7(skillDir)) {
       missing.push(skillName);
       continue;
     }
     for (const [filename2, rawContent] of Object.entries(files)) {
       const content = applyPackageManager(rawContent, pm);
-      const targetPath = PATH10.resolve(skillDir, filename2);
-      if (!existsSync6(targetPath)) {
+      const targetPath = PATH11.resolve(skillDir, filename2);
+      if (!existsSync7(targetPath)) {
         missing.push(`${skillName}/${filename2}`);
-      } else if (readFileSync15(targetPath, "utf8") !== content) {
+      } else if (readFileSync16(targetPath, "utf8") !== content) {
         outdated.push(`${skillName}/${filename2}`);
       }
     }
   }
   const templateNames = new Set(Object.keys(rawTemplates));
-  const stale = existsSync6(skillsDir) ? readdirSync3(skillsDir).filter(
-    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH10.resolve(skillsDir, f)).isDirectory() && !templateNames.has(f)
+  const stale = existsSync7(skillsDir) ? readdirSync3(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH11.resolve(skillsDir, f)).isDirectory() && !templateNames.has(f)
   ) : [];
   return {
     missing,
@@ -1888,81 +1984,81 @@ var checkSkills = (skillsDir) => {
 var logSection = (label, result) => {
   const issues = [...result.missing, ...result.outdated, ...result.stale];
   if (issues.length === 0) {
-    console.log(chalk17.green(`  \u2714 ${label}`));
+    console.log(chalk18.green(`  \u2714 ${label}`));
     return true;
   }
-  console.log(chalk17.red(`  \u2718 ${label}`));
+  console.log(chalk18.red(`  \u2718 ${label}`));
   for (const file of result.missing) {
-    console.log(chalk17.yellow(`      missing: ${file}`));
+    console.log(chalk18.yellow(`      missing: ${file}`));
   }
   for (const file of result.outdated) {
-    console.log(chalk17.yellow(`      outdated: ${file}`));
+    console.log(chalk18.yellow(`      outdated: ${file}`));
   }
   for (const file of result.stale) {
-    console.log(chalk17.yellow(`      stale: ${file}`));
+    console.log(chalk18.yellow(`      stale: ${file}`));
   }
   return false;
 };
 function claudeCheck() {
   const cwd6 = INIT_CWD();
-  const claudeDir = PATH10.resolve(cwd6, ".claude");
-  console.log(chalk17.bold("Claude configuration check:"));
+  const claudeDir = PATH11.resolve(cwd6, ".claude");
+  console.log(chalk18.bold("Claude configuration check:"));
   console.log();
-  const commandsResult = checkCommands(PATH10.resolve(claudeDir, "commands"));
-  const rulesResult = checkRules(PATH10.resolve(claudeDir, "rules"));
-  const skillsResult = checkSkills(PATH10.resolve(claudeDir, "skills"));
+  const commandsResult = checkCommands(PATH11.resolve(claudeDir, "commands"));
+  const rulesResult = checkRules(PATH11.resolve(claudeDir, "rules"));
+  const skillsResult = checkSkills(PATH11.resolve(claudeDir, "skills"));
   const commandsOk = logSection("commands", commandsResult);
   const rulesOk = logSection("rules", rulesResult);
   const skillsOk = logSection("skills", skillsResult);
   console.log();
   if (commandsOk && rulesOk && skillsOk) {
-    console.log(chalk17.green("All Claude configuration is up to date."));
+    console.log(chalk18.green("All Claude configuration is up to date."));
   } else {
-    console.log(chalk17.yellow("Run `xy claude init` to sync all configuration."));
+    console.log(chalk18.yellow("Run `xy claude init` to sync all configuration."));
   }
   return 0;
 }
 
 // src/actions/claude-clean.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   readdirSync as readdirSync4,
   rmSync,
   unlinkSync
 } from "fs";
-import PATH11 from "path";
-import chalk18 from "chalk";
+import PATH12 from "path";
+import chalk19 from "chalk";
 function removeFile(filePath, label) {
-  if (existsSync7(filePath)) {
+  if (existsSync8(filePath)) {
     unlinkSync(filePath);
-    console.log(chalk18.yellow(`  Removed ${label}`));
+    console.log(chalk19.yellow(`  Removed ${label}`));
     return true;
   }
   return false;
 }
 function removeDir(dirPath, label) {
-  if (existsSync7(dirPath)) {
+  if (existsSync8(dirPath)) {
     rmSync(dirPath, { recursive: true });
-    console.log(chalk18.yellow(`  Removed ${label}`));
+    console.log(chalk19.yellow(`  Removed ${label}`));
     return true;
   }
   return false;
 }
 function claudeClean() {
-  console.log(chalk18.green("Clean Claude configuration"));
+  console.log(chalk19.green("Clean Claude configuration"));
   const cwd6 = INIT_CWD();
   let removed = 0;
   const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
   for (const file of rootFiles) {
-    if (removeFile(PATH11.resolve(cwd6, file), file)) removed++;
+    if (removeFile(PATH12.resolve(cwd6, file), file)) removed++;
   }
-  if (removeDir(PATH11.resolve(cwd6, ".claude"), ".claude/")) removed++;
-  const packagesDir = PATH11.resolve(cwd6, "packages");
-  if (existsSync7(packagesDir)) {
+  if (removeDir(PATH12.resolve(cwd6, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH12.resolve(cwd6, "packages");
+  if (existsSync8(packagesDir)) {
     const findClaudeFiles = (dir, prefix) => {
       const entries = readdirSync4(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = PATH11.resolve(dir, entry.name);
+        const fullPath = PATH12.resolve(dir, entry.name);
         const label = `${prefix}${entry.name}`;
         if (entry.isFile() && (entry.name === "CLAUDE.md" || entry.name === "CLAUDE.local.md")) {
           if (removeFile(fullPath, label)) removed++;
@@ -1976,24 +2072,24 @@ function claudeClean() {
     findClaudeFiles(packagesDir, "packages/");
   }
   if (removed > 0) {
-    console.log(chalk18.green(`  Removed ${removed} item(s)`));
+    console.log(chalk19.green(`  Removed ${removed} item(s)`));
   } else {
-    console.log(chalk18.gray("  Nothing to clean"));
+    console.log(chalk19.gray("  Nothing to clean"));
   }
   return 0;
 }
 
 // src/actions/claude-commands.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import PATH12 from "path";
-import chalk19 from "chalk";
+import PATH13 from "path";
+import chalk20 from "chalk";
 var syncCommandFiles = (commandsDir) => {
   const pm = detectPackageManager();
   const rawTemplates = claudeCommandTemplates();
@@ -2005,10 +2101,10 @@ var syncCommandFiles = (commandsDir) => {
   let updated = 0;
   let created = 0;
   for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH12.resolve(commandsDir, filename2);
-    const existing = existsSync8(targetPath) ? readFileSync16(targetPath, "utf8") : void 0;
+    const targetPath = PATH13.resolve(commandsDir, filename2);
+    const existing = existsSync9(targetPath) ? readFileSync17(targetPath, "utf8") : void 0;
     if (existing === content) continue;
-    writeFileSync3(targetPath, content, "utf8");
+    writeFileSync4(targetPath, content, "utf8");
     if (existing) {
       updated++;
     } else {
@@ -2026,7 +2122,7 @@ var removeStaleCommands = (commandsDir, templateNames) => {
   let removed = 0;
   for (const file of existingCommands) {
     if (!templateNames.has(file)) {
-      unlinkSync2(PATH12.resolve(commandsDir, file));
+      unlinkSync2(PATH13.resolve(commandsDir, file));
       removed++;
     }
   }
@@ -2035,7 +2131,7 @@ var removeStaleCommands = (commandsDir, templateNames) => {
 var removeLegacyCommands = (commandsDir) => {
   const legacyFiles = readdirSync5(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
   for (const file of legacyFiles) {
-    unlinkSync2(PATH12.resolve(commandsDir, file));
+    unlinkSync2(PATH13.resolve(commandsDir, file));
   }
   return legacyFiles.length;
 };
@@ -2046,14 +2142,14 @@ var logCommandsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk19.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk20.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk19.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+    console.log(chalk20.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
   }
 };
 var claudeCommands = () => {
   const cwd6 = INIT_CWD();
-  const commandsDir = PATH12.resolve(cwd6, ".claude", "commands");
+  const commandsDir = PATH13.resolve(cwd6, ".claude", "commands");
   mkdirSync(commandsDir, { recursive: true });
   const legacy = removeLegacyCommands(commandsDir);
   const {
@@ -2069,15 +2165,15 @@ var claudeCommands = () => {
 // src/actions/claude-rules.ts
 import { spawnSync as spawnSync8 } from "child_process";
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import PATH13 from "path";
-import chalk20 from "chalk";
+import PATH14 from "path";
+import chalk21 from "chalk";
 var syncRuleFiles = (rulesDir) => {
   const pm = detectPackageManager();
   const rawTemplates = claudeMdRuleTemplates();
@@ -2089,10 +2185,10 @@ var syncRuleFiles = (rulesDir) => {
   let updated = 0;
   let created = 0;
   for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH13.resolve(rulesDir, filename2);
-    const existing = existsSync9(targetPath) ? readFileSync17(targetPath, "utf8") : void 0;
+    const targetPath = PATH14.resolve(rulesDir, filename2);
+    const existing = existsSync10(targetPath) ? readFileSync18(targetPath, "utf8") : void 0;
     if (existing === content) continue;
-    writeFileSync4(targetPath, content, "utf8");
+    writeFileSync5(targetPath, content, "utf8");
     if (existing) {
       updated++;
     } else {
@@ -2110,7 +2206,7 @@ var removeStaleRules = (rulesDir, templateNames) => {
   let removed = 0;
   for (const file of existingRules) {
     if (!templateNames.has(file)) {
-      unlinkSync3(PATH13.resolve(rulesDir, file));
+      unlinkSync3(PATH14.resolve(rulesDir, file));
       removed++;
     }
   }
@@ -2123,44 +2219,44 @@ var logRulesResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk20.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk21.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk20.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+    console.log(chalk21.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
   }
 };
 var ensureProjectClaudeMd = (cwd6, force) => {
-  const projectPath = PATH13.resolve(cwd6, "CLAUDE.md");
-  if (!existsSync9(projectPath) || force) {
-    if (force && existsSync9(projectPath)) {
-      console.log(chalk20.yellow("Regenerating CLAUDE.md"));
+  const projectPath = PATH14.resolve(cwd6, "CLAUDE.md");
+  if (!existsSync10(projectPath) || force) {
+    if (force && existsSync10(projectPath)) {
+      console.log(chalk21.yellow("Regenerating CLAUDE.md"));
     }
-    console.log(chalk20.green("Generating CLAUDE.md via claude /init..."));
+    console.log(chalk21.green("Generating CLAUDE.md via claude /init..."));
     const result = spawnSync8("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
       cwd: cwd6,
       shell: true,
       stdio: "inherit"
     });
     if (result.status !== 0) {
-      console.error(chalk20.red("claude /init failed \u2014 is Claude Code installed?"));
+      console.error(chalk21.red("claude /init failed \u2014 is Claude Code installed?"));
       return 1;
     }
   } else {
-    console.log(chalk20.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+    console.log(chalk21.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
   }
   return 0;
 };
 var ensureLocalClaudeMd = (cwd6) => {
-  const localPath = PATH13.resolve(cwd6, "CLAUDE.local.md");
-  if (existsSync9(localPath)) {
-    console.log(chalk20.gray("CLAUDE.local.md already exists (skipped)"));
+  const localPath = PATH14.resolve(cwd6, "CLAUDE.local.md");
+  if (existsSync10(localPath)) {
+    console.log(chalk21.gray("CLAUDE.local.md already exists (skipped)"));
   } else {
-    writeFileSync4(localPath, claudeMdLocalTemplate(), "utf8");
-    console.log(chalk20.green("Generated CLAUDE.local.md"));
+    writeFileSync5(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk21.green("Generated CLAUDE.local.md"));
   }
 };
 var claudeRules = ({ force } = {}) => {
   const cwd6 = INIT_CWD();
-  const rulesDir = PATH13.resolve(cwd6, ".claude", "rules");
+  const rulesDir = PATH14.resolve(cwd6, ".claude", "rules");
   mkdirSync2(rulesDir, { recursive: true });
   const {
     created,
@@ -2176,13 +2272,13 @@ var claudeRules = ({ force } = {}) => {
 
 // src/actions/claude-settings.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import PATH14 from "path";
-import { createInterface as createInterface2 } from "readline";
-import chalk21 from "chalk";
+import PATH15 from "path";
+import { createInterface as createInterface3 } from "readline";
+import chalk22 from "chalk";
 var DENY_LIST = [
   "Bash(git push --force *)",
   "Bash(git reset --hard *)",
@@ -2234,7 +2330,7 @@ function buildSettings(level) {
   };
 }
 function askConfirmation2(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -2244,37 +2340,37 @@ function askConfirmation2(question) {
 }
 async function claudeSettings({ level = "permissive" } = {}) {
   const cwd6 = INIT_CWD();
-  const claudeDir = PATH14.resolve(cwd6, ".claude");
-  const settingsPath = PATH14.resolve(claudeDir, "settings.local.json");
+  const claudeDir = PATH15.resolve(cwd6, ".claude");
+  const settingsPath = PATH15.resolve(claudeDir, "settings.local.json");
   mkdirSync3(claudeDir, { recursive: true });
-  if (existsSync10(settingsPath)) {
+  if (existsSync11(settingsPath)) {
     const confirmed = await askConfirmation2(
-      chalk21.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+      chalk22.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
     );
     if (!confirmed) {
-      console.log(chalk21.gray("Skipped \u2014 existing settings.local.json preserved"));
+      console.log(chalk22.gray("Skipped \u2014 existing settings.local.json preserved"));
       return 0;
     }
   }
   const settings = buildSettings(level);
-  writeFileSync5(settingsPath, `${JSON.stringify(settings, null, 2)}
+  writeFileSync6(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
-  console.log(chalk21.green(`Generated .claude/settings.local.json (${level})`));
+  console.log(chalk22.green(`Generated .claude/settings.local.json (${level})`));
   return 0;
 }
 
 // src/actions/claude-skills.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   rmSync as rmSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import PATH15 from "path";
-import chalk22 from "chalk";
+import PATH16 from "path";
+import chalk23 from "chalk";
 var syncSkillFiles = (skillsDir) => {
   const pm = detectPackageManager();
   const rawTemplates = claudeSkillTemplates();
@@ -2282,15 +2378,15 @@ var syncSkillFiles = (skillsDir) => {
   let updated = 0;
   let created = 0;
   for (const [skillName, files] of Object.entries(rawTemplates)) {
-    const skillDir = PATH15.resolve(skillsDir, skillName);
+    const skillDir = PATH16.resolve(skillsDir, skillName);
     mkdirSync4(skillDir, { recursive: true });
     for (const [filename2, rawContent] of Object.entries(files)) {
       const content = applyPackageManager(rawContent, pm);
-      const targetPath = PATH15.resolve(skillDir, filename2);
-      mkdirSync4(PATH15.dirname(targetPath), { recursive: true });
-      const existing = existsSync11(targetPath) ? readFileSync18(targetPath, "utf8") : void 0;
+      const targetPath = PATH16.resolve(skillDir, filename2);
+      mkdirSync4(PATH16.dirname(targetPath), { recursive: true });
+      const existing = existsSync12(targetPath) ? readFileSync19(targetPath, "utf8") : void 0;
       if (existing === content) continue;
-      writeFileSync6(targetPath, content, "utf8");
+      writeFileSync7(targetPath, content, "utf8");
       if (existing) {
         updated++;
       } else {
@@ -2306,12 +2402,12 @@ var syncSkillFiles = (skillsDir) => {
 };
 var removeStaleSkills = (skillsDir, templateNames) => {
   const existingSkills = readdirSync7(skillsDir).filter(
-    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync3(PATH15.resolve(skillsDir, f)).isDirectory()
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync3(PATH16.resolve(skillsDir, f)).isDirectory()
   );
   let removed = 0;
   for (const dir of existingSkills) {
     if (!templateNames.has(dir)) {
-      rmSync2(PATH15.resolve(skillsDir, dir), { recursive: true });
+      rmSync2(PATH16.resolve(skillsDir, dir), { recursive: true });
       removed++;
     }
   }
@@ -2324,14 +2420,14 @@ var logSkillsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk22.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+    console.log(chalk23.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
   } else {
-    console.log(chalk22.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+    console.log(chalk23.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
   }
 };
 var claudeSkills = () => {
   const cwd6 = INIT_CWD();
-  const skillsDir = PATH15.resolve(cwd6, ".claude", "skills");
+  const skillsDir = PATH16.resolve(cwd6, ".claude", "skills");
   mkdirSync4(skillsDir, { recursive: true });
   const {
     created,
@@ -2358,21 +2454,21 @@ var cleanAll = ({ verbose }) => {
 
 // src/actions/clean-docs.ts
 import path2 from "path";
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 var cleanDocs = () => {
   const pkgName = packageName();
-  console.log(chalk23.green(`Cleaning Docs [${pkgName}]`));
+  console.log(chalk24.green(`Cleaning Docs [${pkgName}]`));
   for (const { location } of getPackageManager().listWorkspaces()) deleteGlob(path2.join(location, "docs"));
   return 0;
 };
 
 // src/actions/clean-eslint.ts
 import path3 from "path";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 var cleanESLint = () => {
   const pkg = INIT_CWD();
   const pkgName = packageName();
-  console.log(chalk24.green(`Cleaning ESLint [${pkgName}]`));
+  console.log(chalk25.green(`Cleaning ESLint [${pkgName}]`));
   deleteGlob(path3.join(pkg, ".eslintcache"));
   return 0;
 };
@@ -2427,7 +2523,7 @@ var compileAll = ({
 
 // src/actions/copy-assets.ts
 import path4 from "path/posix";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 import cpy from "cpy";
 var copyPackageTargetAssets = async (target, name, location) => {
   try {
@@ -2450,7 +2546,7 @@ var copyPackageTargetAssets = async (target, name, location) => {
 };
 var copyTargetAssets = async (target, pkg) => {
   const workspaces = getPackageManager().listWorkspaces();
-  console.log(chalk25.green(`Copying Assets [${target.toUpperCase()}]`));
+  console.log(chalk26.green(`Copying Assets [${target.toUpperCase()}]`));
   const workspaceList = workspaces.filter(({ name }) => {
     return pkg === void 0 || name === pkg;
   });
@@ -2549,11 +2645,11 @@ var dead = () => {
 };
 
 // src/actions/deplint/deplint.ts
-import chalk37 from "chalk";
+import chalk38 from "chalk";
 
 // src/actions/deplint/packageJsonEditor.ts
 import fs3 from "fs";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import sortPackageJson from "sort-package-json";
 
 // src/actions/deplint/getRequiredPeerDependencies.ts
@@ -2974,7 +3070,7 @@ function getExternalImportsFromFiles({
 }
 
 // src/actions/deplint/checkPackage/getMismatchedPeerDevVersions.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 import semver4 from "semver";
 function findMismatchedPeerDevVersions({
   peerDependencies,
@@ -3001,7 +3097,7 @@ function findMismatchedPeerDevVersions({
 // src/actions/deplint/checkPackage/getUnlistedDependencies.ts
 import fs9 from "fs";
 import { builtinModules } from "module";
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 
 // src/actions/deplint/tsScriptsAliases.ts
 var VARIANT_MAP = {
@@ -3058,7 +3154,7 @@ function findUnlistedDependencies(name, dependencies, devDependencies, peerDepen
 
 // src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
 import { builtinModules as builtinModules2 } from "module";
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 function findUnlistedDevDeps(name, dependencies, devDependencies, peerDependencies, externalAllImports, distImports, externalDistTypeImports) {
   const results = [];
   for (const imp of externalAllImports) {
@@ -3071,11 +3167,11 @@ function findUnlistedDevDeps(name, dependencies, devDependencies, peerDependenci
 
 // src/actions/deplint/checkPackage/getUnnecessaryPeerDependencies.ts
 import fs11 from "fs";
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 
 // src/actions/deplint/checkPackage/getUnsatisfiedPeerDependencies.ts
 import fs10 from "fs";
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 import semver5 from "semver";
 import sortPackageJson2 from "sort-package-json";
 function readDepPackageJson(location, dep) {
@@ -3272,7 +3368,7 @@ function findRedundantPeerDeps({ peerDependencies, dependencies }, exclude) {
 }
 
 // src/actions/deplint/checkPackage/getUnusedDependencies.ts
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 function isDepImported(dep, distImports, distTypeImports) {
   const baseName = dep.replace(/^@types\//, "");
   return distImports.includes(dep) || distImports.includes(baseName) || distTypeImports.includes(dep) || distTypeImports.includes(baseName);
@@ -3302,7 +3398,7 @@ function findUnusedDependencies(location, dependencies, devDependencies, externa
 }
 
 // src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 
 // src/actions/deplint/getCliReferencedPackagesFromFiles.ts
 import fs13 from "fs";
@@ -3584,7 +3680,7 @@ function findUnusedDevDeps(location, dependencies, devDependencies, peerDependen
 }
 
 // src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 function isPeerUsed(dep, externalDistImports, externalDistTypeImports) {
   const baseName = dep.replace(/^@types\//, "");
   return externalDistImports.includes(dep) || externalDistImports.includes(baseName) || externalDistTypeImports.includes(dep) || externalDistTypeImports.includes(baseName);
@@ -3601,7 +3697,7 @@ function findUnusedPeerDeps(peerDependencies, externalDistImports, externalDistT
 }
 
 // src/actions/deplint/checkPackage/getWorkspaceVersionProblems.ts
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 import semver6 from "semver";
 function checkSection(deps, versions, section, workspaceNames, problems) {
   for (const dep of deps) {
@@ -4210,25 +4306,25 @@ async function runDeplint(workspaces, options, workspaceNames) {
 }
 
 // src/actions/deplint/reporters.ts
-import chalk36 from "chalk";
+import chalk37 from "chalk";
 var humanDeplintReporter = {
   render(result) {
     for (const fix2 of result.appliedFixes) {
-      console.log(`[${chalk36.blue(fix2.workspace.name)}] Fixed: ${fix2.detail} ${chalk36.green(fix2.dependency)}`);
+      console.log(`[${chalk37.blue(fix2.workspace.name)}] Fixed: ${fix2.detail} ${chalk37.green(fix2.dependency)}`);
     }
     for (const diagnostic2 of result.diagnostics) {
-      console.log(`[${chalk36.blue(diagnostic2.workspace.name)}] ${diagnostic2.message}`);
+      console.log(`[${chalk37.blue(diagnostic2.workspace.name)}] ${diagnostic2.message}`);
       for (const line of diagnostic2.evidence ?? []) {
         console.log(`  ${line}`);
       }
-      console.log(`  ${chalk36.yellow(diagnostic2.file)}
+      console.log(`  ${chalk37.yellow(diagnostic2.file)}
 `);
     }
     if (result.summary.errorCount > 0) {
-      console.warn(`Deplint: Found ${chalk36.red(result.summary.errorCount)} dependency problems. ${chalk36.red("\u2716")}`);
+      console.warn(`Deplint: Found ${chalk37.red(result.summary.errorCount)} dependency problems. ${chalk37.red("\u2716")}`);
       return;
     }
-    console.info(`Deplint: Found no dependency problems. ${chalk36.green("\u2714")}`);
+    console.info(`Deplint: Found no dependency problems. ${chalk37.green("\u2714")}`);
   }
 };
 var jsonDeplintReporter = {
@@ -4260,7 +4356,7 @@ var deplint = async ({
   const targetWorkspace = pkg === void 0 ? void 0 : pm.findWorkspace(pkg);
   const targetWorkspaces = pkg === void 0 ? workspaces : targetWorkspace ? [targetWorkspace] : [];
   if (targetWorkspaces.length === 0) {
-    console.error(chalk37.red(`Workspace not found: ${pkg}`));
+    console.error(chalk38.red(`Workspace not found: ${pkg}`));
     return 1;
   }
   const result = await runDeplint(targetWorkspaces, {
@@ -4280,24 +4376,24 @@ var deplint = async ({
 };
 
 // src/actions/deploy.ts
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 
 // src/actions/package-lint-deps.ts
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync7 } from "fs";
-import PATH16 from "path";
-import chalk38 from "chalk";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync8 } from "fs";
+import PATH17 from "path";
+import chalk39 from "chalk";
 import semver7 from "semver";
 function readWorkspacePackageJson(cwd6, location) {
-  const pkgPath = PATH16.resolve(cwd6, location, "package.json");
+  const pkgPath = PATH17.resolve(cwd6, location, "package.json");
   try {
-    return JSON.parse(readFileSync19(pkgPath, "utf8"));
+    return JSON.parse(readFileSync20(pkgPath, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writeWorkspacePackageJson(cwd6, location, pkg) {
-  const pkgPath = PATH16.resolve(cwd6, location, "package.json");
-  writeFileSync7(pkgPath, `${JSON.stringify(pkg, null, 2)}
+  const pkgPath = PATH17.resolve(cwd6, location, "package.json");
+  writeFileSync8(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
 }
 function buildWorkspaceVersionMap(cwd6, workspaces) {
@@ -4355,7 +4451,7 @@ function fixVersionConsistency(cwd6, rootPkg, writeRootPackageJson2, workspaces)
   if (rootPkg.version !== void 0) {
     delete rootPkg.version;
     writeRootPackageJson2(cwd6, rootPkg);
-    console.log(chalk38.green('  \u2714 Fixed: removed "version" from root package.json'));
+    console.log(chalk39.green('  \u2714 Fixed: removed "version" from root package.json'));
   }
   const versions = [];
   for (const { location } of workspaces) {
@@ -4376,7 +4472,7 @@ function fixVersionConsistency(cwd6, rootPkg, writeRootPackageJson2, workspaces)
     if (pkg.version !== highest) {
       pkg.version = highest;
       writeWorkspacePackageJson(cwd6, location, pkg);
-      console.log(chalk38.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
+      console.log(chalk39.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
     }
   }
 }
@@ -4431,7 +4527,7 @@ function fixInternalDepVersions(cwd6, workspaces) {
         const expected = expectedDepVersion(targetVersion);
         if (version !== expected) {
           deps[dep] = expected;
-          console.log(chalk38.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
+          console.log(chalk39.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
           modified = true;
         }
       }
@@ -4479,7 +4575,7 @@ function fixWorkspaceProtocol(cwd6, workspaces) {
         if (!workspaceNames.has(dep)) continue;
         if (!version.startsWith("workspace:")) {
           deps[dep] = "workspace:~";
-          console.log(chalk38.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
+          console.log(chalk39.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
           modified = true;
         }
       }
@@ -4537,7 +4633,7 @@ function fixInternalPeerVersions(cwd6, workspaces) {
       const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
       if (version !== expected) {
         peerDeps[dep] = expected;
-        console.log(chalk38.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
+        console.log(chalk39.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
         modified = true;
       }
     }
@@ -4564,7 +4660,7 @@ function syncInternalPeerVersions() {
       const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
       if (version !== expected) {
         peerDeps[dep] = expected;
-        console.log(chalk38.green(`Publish: updated ${name} peerDependencies.${dep} to "${expected}"`));
+        console.log(chalk39.green(`Publish: updated ${name} peerDependencies.${dep} to "${expected}"`));
         modified = true;
         updated++;
       }
@@ -4584,8 +4680,8 @@ function logMonorepoVersion() {
     if (!pkg) continue;
     const version = pkg.version;
     if (version) {
-      console.log(chalk38.green(`
-Deployed version: ${chalk38.bold(version)}`));
+      console.log(chalk39.green(`
+Deployed version: ${chalk39.bold(version)}`));
       return;
     }
   }
@@ -4596,7 +4692,7 @@ var privatePackageExcludeList = () => {
   const pm = getPackageManager();
   const possibleDeployablePackages = pm.listWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync20(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync21(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -4620,9 +4716,9 @@ function deploy(level = "patch") {
 }
 
 // src/actions/dupdeps.ts
-import chalk39 from "chalk";
+import chalk40 from "chalk";
 var dupdeps = () => {
-  console.log(chalk39.green("Checking all Dependencies for Duplicates"));
+  console.log(chalk40.green("Checking all Dependencies for Duplicates"));
   const pkg = parsedPackageJSON();
   const allDependencies = {
     ...pkg?.dependencies,
@@ -4640,21 +4736,21 @@ var eject = () => {
 
 // src/actions/lintNext.ts
 import path10 from "path";
-import chalk40 from "chalk";
+import chalk41 from "chalk";
 import { ESLint } from "eslint";
 var dumpMessages = (lintResults) => {
   const colors = ["white", "yellow", "red"];
   const severity = ["none", "warning", "error"];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk40.gray(`
+      console.log(chalk41.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
         console.log(
-          chalk40.gray(`	${message.line}:${message.column}`),
-          chalk40[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk40.white(`	${message.message}`),
-          chalk40.gray(`	${message.ruleId}`)
+          chalk41.gray(`	${message.line}:${message.column}`),
+          chalk41[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk41.white(`	${message.message}`),
+          chalk41.gray(`	${message.ruleId}`)
         );
       }
     }
@@ -4684,7 +4780,7 @@ async function lintOnePackage({
   const files = lintResults.length;
   if (verbose) {
     const filesColor = files < 100 ? "green" : files < 1e3 ? "yellow" : "red";
-    console.log(chalk40.white(`  ${chalk40[filesColor](files)} files linted`));
+    console.log(chalk41.white(`  ${chalk41[filesColor](files)} files linted`));
   }
   return {
     errors,
@@ -4704,7 +4800,7 @@ async function lintNext({
   const allWorkspaces = pm.listWorkspaces();
   const workspaces = pkg ? allWorkspaces.filter((ws) => ws.name === pkg) : allWorkspaces;
   if (workspaces.length === 0) {
-    console.log(chalk40.red(pkg ? `Package "${pkg}" not found` : "No workspaces found"));
+    console.log(chalk41.red(pkg ? `Package "${pkg}" not found` : "No workspaces found"));
     return 1;
   }
   const concurrency = jobs;
@@ -4729,7 +4825,7 @@ async function lintNext({
       await outputStorage.run(output, async () => {
         const pkgStart = Date.now();
         const absCwd = path10.resolve(rootDir, ws.location);
-        console.log(chalk40.green(`${label} [${ws.name}]`));
+        console.log(chalk41.green(`${label} [${ws.name}]`));
         try {
           const {
             errors,
@@ -4751,7 +4847,7 @@ async function lintNext({
             warnings
           };
         } catch (ex) {
-          output.push(chalk40.red(`${label} failed for ${ws.name}: ${ex.message}
+          output.push(chalk41.red(`${label} failed for ${ws.name}: ${ex.message}
 `));
           results[i] = {
             errors: 1,
@@ -4779,7 +4875,7 @@ async function lintNext({
   const errColor = totalErrors > 0 ? "red" : "green";
   const warnColor = totalWarnings > 0 ? "yellow" : "green";
   console.log(
-    chalk40[errColor](`${totalErrors} errors`) + chalk40.gray(", ") + chalk40[warnColor](`${totalWarnings} warnings`) + chalk40.gray(` across ${totalFiles} files in ${workspaces.length} packages`)
+    chalk41[errColor](`${totalErrors} errors`) + chalk41.gray(", ") + chalk41[warnColor](`${totalWarnings} warnings`) + chalk41.gray(` across ${totalFiles} files in ${workspaces.length} packages`)
   );
   return totalErrors;
 }
@@ -4851,7 +4947,7 @@ var genDocsAll = ({ incremental, jobs }) => {
 
 // src/actions/gitignore.ts
 import { unlinkSync as unlinkSync4 } from "fs";
-import chalk41 from "chalk";
+import chalk42 from "chalk";
 var COMMENT_PREFIX = "#";
 var isComment = (line) => line.startsWith(COMMENT_PREFIX);
 var isNegation = (line) => line.startsWith("!");
@@ -4908,7 +5004,7 @@ function removePackageGitignores(cwd6) {
     const filePath = `${cwd6}/${location}/.gitignore`;
     try {
       unlinkSync4(filePath);
-      console.log(chalk41.yellow(`  Removed ${location}/.gitignore`));
+      console.log(chalk42.yellow(`  Removed ${location}/.gitignore`));
       removed++;
     } catch {
     }
@@ -4917,7 +5013,7 @@ function removePackageGitignores(cwd6) {
 }
 var gitignoreGen = gitignore;
 function gitignore() {
-  console.log(chalk41.green("Generate .gitignore"));
+  console.log(chalk42.green("Generate .gitignore"));
   const cwd6 = INIT_CWD();
   const gitignorePath = `${cwd6}/.gitignore`;
   try {
@@ -4925,21 +5021,21 @@ function gitignore() {
     const existing = readNonEmptyLines(gitignorePath);
     const merged = mergeWithTemplate(existing, templateContent);
     writeLines(gitignorePath, merged);
-    console.log(chalk41.green("  Root .gitignore updated"));
+    console.log(chalk42.green("  Root .gitignore updated"));
     const removed = removePackageGitignores(cwd6);
     if (removed > 0) {
-      console.log(chalk41.green(`  Removed ${removed} package .gitignore file(s)`));
+      console.log(chalk42.green(`  Removed ${removed} package .gitignore file(s)`));
     }
     return 0;
   } catch (ex) {
     const error = ex;
-    console.error(chalk41.red(`Generate .gitignore failed: ${error.message}`));
+    console.error(chalk42.red(`Generate .gitignore failed: ${error.message}`));
     return 1;
   }
 }
 
 // src/actions/gitlint.ts
-import chalk42 from "chalk";
+import chalk43 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -4950,7 +5046,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk42.yellow(`Warning: ${message}`));
+    console.warn(chalk43.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -4970,13 +5066,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk42.green(`Passed: ${valid}`));
+    resultMessages.push(chalk43.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk42.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk43.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk42.red(` Errors: ${errors}`));
+    resultMessages.push(chalk43.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -4985,7 +5081,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync2 } from "child_process";
-import chalk43 from "chalk";
+import chalk44 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -4994,15 +5090,15 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync2("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk43.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk44.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync2("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk43.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk44.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync2("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk43.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk44.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
@@ -5013,7 +5109,7 @@ var knip = () => {
 };
 
 // src/actions/license.ts
-import chalk44 from "chalk";
+import chalk45 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = getPackageManager().listWorkspaces();
@@ -5038,18 +5134,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk44.green("License Checker"));
+  console.log(chalk45.green("License Checker"));
   return (await Promise.all(
     workspaceList.map(({ location, name }) => {
       return new Promise((resolve) => {
         init({ production: true, start: location }, (error, packages) => {
           if (error) {
-            console.error(chalk44.red(`License Checker [${name}] Error`));
-            console.error(chalk44.gray(error));
+            console.error(chalk45.red(`License Checker [${name}] Error`));
+            console.error(chalk45.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk44.green(`License Checker [${name}]`));
+            console.log(chalk45.green(`License Checker [${name}]`));
             let count = 0;
             for (const [name2, info] of Object.entries(packages)) {
               const licenses = Array.isArray(info.licenses) ? info.licenses : [info.licenses];
@@ -5065,7 +5161,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk44.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk45.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -5081,17 +5177,17 @@ var license = async (pkg) => {
 
 // src/actions/lint-init.ts
 import {
-  existsSync as existsSync12,
-  readFileSync as readFileSync21,
+  existsSync as existsSync13,
+  readFileSync as readFileSync22,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import PATH17 from "path";
-import { createInterface as createInterface3 } from "readline";
-import chalk45 from "chalk";
+import PATH18 from "path";
+import { createInterface as createInterface4 } from "readline";
+import chalk46 from "chalk";
 import { globSync as globSync3 } from "glob";
 function askConfirmation3(question) {
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -5213,7 +5309,7 @@ function generateEslintConfig({
   return lines.join("\n");
 }
 function addDevDependencies(packageJsonPath, requiredDeps, verbose) {
-  const content = readFileSync21(packageJsonPath, "utf8");
+  const content = readFileSync22(packageJsonPath, "utf8");
   const pkg = JSON.parse(content);
   const devDeps = pkg.devDependencies ?? {};
   let changed = false;
@@ -5221,19 +5317,19 @@ function addDevDependencies(packageJsonPath, requiredDeps, verbose) {
     if (!devDeps[name]) {
       devDeps[name] = version;
       changed = true;
-      if (verbose) console.log(chalk45.gray(`  Added ${name}@${version} to devDependencies`));
+      if (verbose) console.log(chalk46.gray(`  Added ${name}@${version} to devDependencies`));
     } else if (verbose) {
-      console.log(chalk45.gray(`  ${name} already in devDependencies`));
+      console.log(chalk46.gray(`  ${name} already in devDependencies`));
     }
   }
   if (changed) {
     const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
     pkg.devDependencies = sorted;
-    writeFileSync8(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+    writeFileSync9(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-    console.log(chalk45.green("Updated package.json devDependencies"));
+    console.log(chalk46.green("Updated package.json devDependencies"));
   } else {
-    console.log(chalk45.gray("package.json devDependencies already up to date"));
+    console.log(chalk46.gray("package.json devDependencies already up to date"));
   }
   return changed;
 }
@@ -5243,14 +5339,14 @@ function detectReactInMonorepo(cwd6, verbose) {
     ignore: ["**/node_modules/**"]
   });
   for (const relPath of packageJsonPaths) {
-    const fullPath = PATH17.resolve(cwd6, relPath);
+    const fullPath = PATH18.resolve(cwd6, relPath);
     try {
-      const content = readFileSync21(fullPath, "utf8");
+      const content = readFileSync22(fullPath, "utf8");
       const pkg = JSON.parse(content);
       const deps = pkg.dependencies;
       const peerDeps = pkg.peerDependencies;
       if (deps?.react || peerDeps?.react) {
-        if (verbose) console.log(chalk45.gray(`  React detected in ${relPath}`));
+        if (verbose) console.log(chalk46.gray(`  React detected in ${relPath}`));
         return true;
       }
     } catch {
@@ -5259,19 +5355,19 @@ function detectReactInMonorepo(cwd6, verbose) {
   return false;
 }
 function findExistingConfig(configPath, legacyConfigPath) {
-  if (existsSync12(configPath)) return configPath;
-  if (existsSync12(legacyConfigPath)) return legacyConfigPath;
+  if (existsSync13(configPath)) return configPath;
+  if (existsSync13(legacyConfigPath)) return legacyConfigPath;
   return void 0;
 }
 function removeLegacyConfig(legacyConfigPath) {
-  if (existsSync12(legacyConfigPath)) {
+  if (existsSync13(legacyConfigPath)) {
     unlinkSync5(legacyConfigPath);
-    console.log(chalk45.gray("Removed legacy eslint.config.mjs"));
+    console.log(chalk46.gray("Removed legacy eslint.config.mjs"));
   }
 }
 function updateDependencies(packageJsonPath, react, cwd6, verbose) {
-  if (!existsSync12(packageJsonPath)) {
-    console.log(chalk45.yellow("No package.json found \u2014 skipping dependency updates"));
+  if (!existsSync13(packageJsonPath)) {
+    console.log(chalk46.yellow("No package.json found \u2014 skipping dependency updates"));
     return;
   }
   const changed = addDevDependencies(packageJsonPath, getRequiredDevDependencies(react), verbose);
@@ -5281,52 +5377,52 @@ function updateDependencies(packageJsonPath, react, cwd6, verbose) {
 }
 async function lintInit({ verbose } = {}) {
   const cwd6 = INIT_CWD();
-  const configPath = PATH17.resolve(cwd6, "eslint.config.ts");
-  const legacyConfigPath = PATH17.resolve(cwd6, "eslint.config.mjs");
+  const configPath = PATH18.resolve(cwd6, "eslint.config.ts");
+  const legacyConfigPath = PATH18.resolve(cwd6, "eslint.config.mjs");
   const existingPath = findExistingConfig(configPath, legacyConfigPath);
   if (existingPath) {
-    const filename2 = PATH17.basename(existingPath);
+    const filename2 = PATH18.basename(existingPath);
     const confirmed = await askConfirmation3(
-      chalk45.yellow(`${filename2} already exists. Replace it with eslint.config.ts? (y/N) `)
+      chalk46.yellow(`${filename2} already exists. Replace it with eslint.config.ts? (y/N) `)
     );
     if (!confirmed) {
-      console.log(chalk45.gray(`Skipped \u2014 existing ${filename2} preserved`));
+      console.log(chalk46.gray(`Skipped \u2014 existing ${filename2} preserved`));
       return 0;
     }
   }
   const react = detectReactInMonorepo(cwd6, verbose);
   if (react) {
-    console.log(chalk45.cyan("Detected React packages \u2014 using @xylabs/eslint-config-react-flat"));
+    console.log(chalk46.cyan("Detected React packages \u2014 using @xylabs/eslint-config-react-flat"));
   } else if (verbose) {
-    console.log(chalk45.gray("  No React packages detected \u2014 using @xylabs/eslint-config-flat"));
+    console.log(chalk46.gray("  No React packages detected \u2014 using @xylabs/eslint-config-flat"));
   }
   const useXyLabsBarrel = await askConfirmation3(
-    chalk45.cyan("Disallow @xylabs/sdk-js barrel imports? (y/N) ")
+    chalk46.cyan("Disallow @xylabs/sdk-js barrel imports? (y/N) ")
   );
   const useXyoBarrel = await askConfirmation3(
-    chalk45.cyan("Disallow @xyo-network/sdk-js barrel imports? (y/N) ")
+    chalk46.cyan("Disallow @xyo-network/sdk-js barrel imports? (y/N) ")
   );
   const config2 = generateEslintConfig({
     react,
     useXyLabsBarrel,
     useXyoBarrel
   });
-  writeFileSync8(configPath, config2, "utf8");
-  console.log(chalk45.green("Generated eslint.config.ts"));
+  writeFileSync9(configPath, config2, "utf8");
+  console.log(chalk46.green("Generated eslint.config.ts"));
   removeLegacyConfig(legacyConfigPath);
-  updateDependencies(PATH17.resolve(cwd6, "package.json"), react, cwd6, verbose);
+  updateDependencies(PATH18.resolve(cwd6, "package.json"), react, cwd6, verbose);
   return 0;
 }
 
 // src/actions/lintlint.ts
 import { spawnSync as spawnSync9 } from "child_process";
 import {
-  existsSync as existsSync13,
-  readFileSync as readFileSync22,
-  writeFileSync as writeFileSync9
+  existsSync as existsSync14,
+  readFileSync as readFileSync23,
+  writeFileSync as writeFileSync10
 } from "fs";
-import PATH18 from "path";
-import chalk46 from "chalk";
+import PATH19 from "path";
+import chalk47 from "chalk";
 import { findUp } from "find-up";
 function parseRuleValue(value) {
   if (typeof value === "string") {
@@ -5405,12 +5501,12 @@ async function resolveSharedConfig(configDir, sharedPkg) {
     const sharedModule = await import(sharedPkg);
     return extractConfigBlocks(sharedModule);
   } catch {
-    const distPath = PATH18.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
+    const distPath = PATH19.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
     try {
       const sharedModule = await import(distPath);
       return extractConfigBlocks(sharedModule);
     } catch {
-      const neutralPath = PATH18.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
+      const neutralPath = PATH19.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
       const sharedModule = await import(neutralPath);
       return extractConfigBlocks(sharedModule);
     }
@@ -5421,10 +5517,10 @@ async function loadSharedRules(configDir, sharedPkg, verbose) {
   const sharedBlocks = await resolveSharedConfig(configDir, sharedPkg);
   const sharedRules = mergeRulesFromBlocks(sharedBlocks);
   if (verbose) {
-    console.log(chalk46.gray(`Shared config defines ${sharedRules.size} rules`));
+    console.log(chalk47.gray(`Shared config defines ${sharedRules.size} rules`));
   }
   if (sharedRules.size === 0) {
-    console.error(chalk46.red("Could not load rules from shared config. Is it installed and built?"));
+    console.error(chalk47.red("Could not load rules from shared config. Is it installed and built?"));
     return void 0;
   }
   return sharedRules;
@@ -5437,7 +5533,7 @@ async function loadLocalRules(eslintConfigPath, source, verbose) {
   const localRuleBlocks = extractLocalRuleBlocks(source);
   const explicit = extractRulesFromSourceBlocks(localRuleBlocks);
   if (verbose) {
-    console.log(chalk46.gray(`Local config has ${explicit.size} explicit rule setting(s)`));
+    console.log(chalk47.gray(`Local config has ${explicit.size} explicit rule setting(s)`));
   }
   return { explicit, resolved };
 }
@@ -5477,38 +5573,38 @@ function reportResults({
   redundant
 }, verbose) {
   if (redundant.length > 0) {
-    console.log(chalk46.yellow(`
+    console.log(chalk47.yellow(`
 ${redundant.length} redundant rule(s) (same as shared config \u2014 can be removed):`));
     for (const { rule, local } of redundant) {
-      console.log(chalk46.yellow(`  ${rule}: ${formatRule(local)}`));
+      console.log(chalk47.yellow(`  ${rule}: ${formatRule(local)}`));
     }
   }
   if (overrides.length > 0) {
-    console.log(chalk46.cyan(`
+    console.log(chalk47.cyan(`
 ${overrides.length} rule override(s) (different from shared config):`));
     for (const {
       rule,
       local,
       shared
     } of overrides) {
-      console.log(chalk46.cyan(`  ${rule}:`));
-      console.log(chalk46.gray(`    shared: ${formatRule(shared)}`));
-      console.log(chalk46.white(`    local:  ${formatRule(local)}`));
+      console.log(chalk47.cyan(`  ${rule}:`));
+      console.log(chalk47.gray(`    shared: ${formatRule(shared)}`));
+      console.log(chalk47.white(`    local:  ${formatRule(local)}`));
     }
   }
   if (additions.length > 0 && verbose) {
-    console.log(chalk46.gray(`
+    console.log(chalk47.gray(`
 ${additions.length} local addition(s) (not in shared config):`));
     for (const { rule, local } of additions) {
-      console.log(chalk46.gray(`  ${rule}: ${formatRule(local)}`));
+      console.log(chalk47.gray(`  ${rule}: ${formatRule(local)}`));
     }
   }
   if (redundant.length === 0 && overrides.length === 0) {
-    console.log(chalk46.green("No redundant or overridden rules found"));
+    console.log(chalk47.green("No redundant or overridden rules found"));
   }
 }
 function fixRedundantRules(eslintConfigPath, redundant) {
-  let updated = readFileSync22(eslintConfigPath, "utf8");
+  let updated = readFileSync23(eslintConfigPath, "utf8");
   const original = updated;
   for (const { rule } of redundant) {
     const escaped = rule.replaceAll("/", String.raw`\/`);
@@ -5518,8 +5614,8 @@ function fixRedundantRules(eslintConfigPath, redundant) {
   updated = updated.replaceAll(/\{\s*rules\s*:\s*\{\s*\}\s*,?\s*\}\s*,?/g, "");
   updated = updated.replaceAll(/\n{3,}/g, "\n\n");
   if (updated !== original) {
-    writeFileSync9(eslintConfigPath, updated, "utf8");
-    console.log(chalk46.green(`
+    writeFileSync10(eslintConfigPath, updated, "utf8");
+    console.log(chalk47.green(`
 Fixed: removed ${redundant.length} redundant rule(s)`));
   }
 }
@@ -5528,11 +5624,11 @@ function formatConfigFile(eslintConfigPath) {
 }
 function fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg) {
   const updated = source.replaceAll(sharedPkg, expectedPkg);
-  writeFileSync9(eslintConfigPath, updated, "utf8");
-  console.log(chalk46.green(`Fixed: replaced ${sharedPkg} with ${expectedPkg}`));
-  const packageJsonPath = PATH18.resolve(configDir, "package.json");
-  if (!existsSync13(packageJsonPath)) return;
-  const content = readFileSync22(packageJsonPath, "utf8");
+  writeFileSync10(eslintConfigPath, updated, "utf8");
+  console.log(chalk47.green(`Fixed: replaced ${sharedPkg} with ${expectedPkg}`));
+  const packageJsonPath = PATH19.resolve(configDir, "package.json");
+  if (!existsSync14(packageJsonPath)) return;
+  const content = readFileSync23(packageJsonPath, "utf8");
   const pkg = JSON.parse(content);
   const devDeps = pkg.devDependencies ?? {};
   const oldVersion = devDeps[sharedPkg];
@@ -5541,18 +5637,18 @@ function fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expec
   devDeps[expectedPkg] = oldVersion;
   const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
   pkg.devDependencies = sorted;
-  writeFileSync9(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+  writeFileSync10(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-  console.log(chalk46.green(`Updated package.json: ${sharedPkg} \u2192 ${expectedPkg}`));
+  console.log(chalk47.green(`Updated package.json: ${sharedPkg} \u2192 ${expectedPkg}`));
   runInstall(configDir);
 }
 function checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, fix2, verbose) {
   const hasReact = detectReactInMonorepo(configDir, verbose);
   const expectedPkg = hasReact ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
   if (sharedPkg === expectedPkg) return false;
-  console.log(chalk46.yellow(`
+  console.log(chalk47.yellow(`
 Config mismatch: using ${sharedPkg} but ${hasReact ? "React packages detected" : "no React packages found"}`));
-  console.log(chalk46.yellow(`  Expected: ${expectedPkg}`));
+  console.log(chalk47.yellow(`  Expected: ${expectedPkg}`));
   if (fix2) {
     fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg);
   }
@@ -5561,24 +5657,24 @@ Config mismatch: using ${sharedPkg} but ${hasReact ? "React packages detected" :
 async function lintlint({ fix: fix2, verbose } = {}) {
   const eslintConfigPath = await findUp(["eslint.config.ts", "eslint.config.mjs"]);
   if (!eslintConfigPath) {
-    console.error(chalk46.red("No eslint.config.ts found"));
+    console.error(chalk47.red("No eslint.config.ts found"));
     return 1;
   }
-  const configDir = PATH18.dirname(eslintConfigPath);
+  const configDir = PATH19.dirname(eslintConfigPath);
   if (verbose) {
-    console.log(chalk46.gray(`Found config: ${eslintConfigPath}`));
+    console.log(chalk47.gray(`Found config: ${eslintConfigPath}`));
   }
-  const source = readFileSync22(eslintConfigPath, "utf8");
+  const source = readFileSync23(eslintConfigPath, "utf8");
   const sharedPkg = detectSharedPackage(source);
   if (!sharedPkg) {
-    console.log(chalk46.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
+    console.log(chalk47.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
     return 0;
   }
   if (verbose) {
-    console.log(chalk46.gray(`Shared package: ${sharedPkg}`));
+    console.log(chalk47.gray(`Shared package: ${sharedPkg}`));
   }
   const hasMismatch = checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, !!fix2, !!verbose);
-  const currentSource = hasMismatch && fix2 ? readFileSync22(eslintConfigPath, "utf8") : source;
+  const currentSource = hasMismatch && fix2 ? readFileSync23(eslintConfigPath, "utf8") : source;
   const sharedRules = await loadSharedRules(configDir, sharedPkg, !!verbose);
   if (!sharedRules) return 1;
   const { explicit, resolved } = await loadLocalRules(eslintConfigPath, currentSource, !!verbose);
@@ -5603,7 +5699,7 @@ var npmignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
 // src/actions/orphan.ts
 import fs16 from "fs";
 import path11 from "path";
-import chalk47 from "chalk";
+import chalk48 from "chalk";
 import { glob as glob2 } from "glob";
 function isAncestorOfWorkspace(dir, workspaceLocations) {
   const dirWithSep = dir.endsWith(path11.sep) ? dir : dir + path11.sep;
@@ -5630,7 +5726,7 @@ function findOrphans(cwd6, verbose) {
     if (workspaceLocations.has(parentAbs)) continue;
     if (fs16.existsSync(path11.join(parentAbs, "package.json"))) continue;
     if (verbose) {
-      console.log(chalk47.gray(`  Found orphan: ${parentRel}`));
+      console.log(chalk48.gray(`  Found orphan: ${parentRel}`));
     }
     let topOrphan = parentRel;
     let current = path11.dirname(parentRel);
@@ -5648,45 +5744,45 @@ function findOrphans(cwd6, verbose) {
 }
 function orphanList({ verbose } = {}) {
   const cwd6 = INIT_CWD();
-  console.log(chalk47.green("Orphan List"));
+  console.log(chalk48.green("Orphan List"));
   const orphans = findOrphans(cwd6, verbose);
   if (orphans.length === 0) {
-    console.log(chalk47.green("  No orphaned directories found"));
+    console.log(chalk48.green("  No orphaned directories found"));
     return 0;
   }
   for (const orphan of orphans) {
-    console.log(chalk47.yellow(`  ${orphan}`));
+    console.log(chalk48.yellow(`  ${orphan}`));
   }
-  console.log(chalk47.yellow(`
+  console.log(chalk48.yellow(`
   Found ${orphans.length} orphaned director${orphans.length === 1 ? "y" : "ies"}`));
   return 1;
 }
 function orphanClean({ verbose } = {}) {
   const cwd6 = INIT_CWD();
-  console.log(chalk47.green("Orphan Clean"));
+  console.log(chalk48.green("Orphan Clean"));
   const orphans = findOrphans(cwd6, verbose);
   if (orphans.length === 0) {
-    console.log(chalk47.green("  No orphaned directories found"));
+    console.log(chalk48.green("  No orphaned directories found"));
     return 0;
   }
   for (const orphan of orphans) {
     const absPath = path11.resolve(cwd6, orphan);
     fs16.rmSync(absPath, { force: true, recursive: true });
-    console.log(chalk47.yellow(`  Removed ${orphan}`));
+    console.log(chalk48.yellow(`  Removed ${orphan}`));
   }
-  console.log(chalk47.green(`
+  console.log(chalk48.green(`
   Cleaned ${orphans.length} orphaned director${orphans.length === 1 ? "y" : "ies"}`));
   return 0;
 }
 
 // src/actions/package/clean-outputs.ts
 import path12 from "path";
-import chalk48 from "chalk";
+import chalk49 from "chalk";
 var packageCleanOutputs = () => {
   const pkg = INIT_CWD();
   const pkgName = packageName();
   const folders = [path12.join(pkg, "dist"), path12.join(pkg, "build"), path12.join(pkg, "docs")];
-  console.log(chalk48.green(`Cleaning Outputs [${pkgName}]`));
+  console.log(chalk49.green(`Cleaning Outputs [${pkgName}]`));
   for (const folder of folders) {
     deleteGlob(folder);
   }
@@ -5695,11 +5791,11 @@ var packageCleanOutputs = () => {
 
 // src/actions/package/clean-typescript.ts
 import path13 from "path";
-import chalk49 from "chalk";
+import chalk50 from "chalk";
 var packageCleanTypescript = () => {
   const pkg = INIT_CWD();
   const pkgName = packageName();
-  console.log(chalk49.green(`Cleaning Typescript [${pkgName}]`));
+  console.log(chalk50.green(`Cleaning Typescript [${pkgName}]`));
   const files = [path13.join(pkg, "*.tsbuildinfo"), path13.join(pkg, ".tsconfig.*"), path13.join(pkg, ".eslintcache")];
   for (const file of files) {
     deleteGlob(file);
@@ -5714,26 +5810,26 @@ var packageClean = () => {
 
 // src/actions/package/compile/compile.ts
 import { cwd as cwd4 } from "process";
-import chalk54 from "chalk";
+import chalk55 from "chalk";
 
 // src/actions/package/compile/packageCompileTsup.ts
-import chalk53 from "chalk";
+import chalk54 from "chalk";
 import { build as build2, defineConfig } from "tsup";
 
 // src/actions/package/compile/inputs.ts
-import chalk50 from "chalk";
+import chalk51 from "chalk";
 import { glob as glob3 } from "glob";
 var getAllInputs = (srcDir, verbose = false) => {
   return [...glob3.sync(`${srcDir}/**/*.ts`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk50.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk51.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   }), ...glob3.sync(`${srcDir}/**/*.tsx`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk50.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk51.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   })];
@@ -5796,7 +5892,7 @@ function deepMergeObjects(objects) {
 
 // src/actions/package/compile/packageCompileTsc.ts
 import { cwd as cwd2 } from "process";
-import chalk51 from "chalk";
+import chalk52 from "chalk";
 import { createProgramFromConfig } from "tsc-prog";
 import ts3, {
   DiagnosticCategory,
@@ -5818,7 +5914,7 @@ var getCompilerOptions = (options = {}, fileName = "tsconfig.json") => {
 var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
   const pkg = cwd2();
   if (verbose) {
-    console.log(chalk51.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk52.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   const configFilePath = ts3.findConfigFile(
     pkg,
@@ -5840,10 +5936,10 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     emitDeclarationOnly: true,
     noEmit: false
   };
-  console.log(chalk51.cyan(`Validating Files: ${entries.length}`));
+  console.log(chalk52.cyan(`Validating Files: ${entries.length}`));
   if (verbose) {
     for (const entry of entries) {
-      console.log(chalk51.grey(`Validating: ${entry}`));
+      console.log(chalk52.grey(`Validating: ${entry}`));
     }
   }
   try {
@@ -5879,7 +5975,7 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     return 0;
   } finally {
     if (verbose) {
-      console.log(chalk51.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+      console.log(chalk52.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
     }
   }
 };
@@ -5887,7 +5983,7 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
 // src/actions/package/compile/packageCompileTscTypes.ts
 import path14 from "path";
 import { cwd as cwd3 } from "process";
-import chalk52 from "chalk";
+import chalk53 from "chalk";
 import { rollup } from "rollup";
 import dts from "rollup-plugin-dts";
 import nodeExternals from "rollup-plugin-node-externals";
@@ -5912,8 +6008,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
         if (ignoredWarningCodes.has(warning.code ?? "")) {
           return;
         }
-        console.warn(chalk52.yellow(`[${warning.code}] ${warning.message}`));
-        console.warn(chalk52.gray(inputPath));
+        console.warn(chalk53.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk53.gray(inputPath));
         warn(warning);
       }
     });
@@ -5923,8 +6019,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
     });
   } catch (ex) {
     const error = ex;
-    console.warn(chalk52.red(error));
-    console.warn(chalk52.gray(inputPath));
+    console.warn(chalk53.red(error));
+    console.warn(chalk53.gray(inputPath));
   }
   if (verbose) {
     console.log(`Bundled declarations written to ${outputPath}`);
@@ -5932,7 +6028,7 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
 }
 var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build", verbose = false) => {
   if (verbose) {
-    console.log(chalk52.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk53.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
     console.log(`Entries: ${entries.join(", ")}`);
   }
   const pkg = cwd3();
@@ -5956,7 +6052,7 @@ var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build",
     await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, { compilerOptions }, verbose);
   }));
   if (verbose) {
-    console.log(chalk52.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk53.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   return 0;
 };
@@ -5968,15 +6064,15 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
   }
   if (entries.length === 0) {
-    console.warn(chalk53.yellow(`No entries found in ${srcDir} to compile`));
+    console.warn(chalk54.yellow(`No entries found in ${srcDir} to compile`));
     return 0;
   }
   if (verbose) {
-    console.log(chalk53.gray(`buildDir [${buildDir}]`));
+    console.log(chalk54.gray(`buildDir [${buildDir}]`));
   }
   const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
   if (validationResult !== 0) {
-    console.error(chalk53.red(`Compile:Validation had ${validationResult} errors`));
+    console.error(chalk54.red(`Compile:Validation had ${validationResult} errors`));
     return validationResult;
   }
   const optionsParams = tsupOptions([{
@@ -6001,12 +6097,12 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     })
   )).flat();
   if (verbose) {
-    console.log(chalk53.cyan(`TSUP:build:start [${srcDir}]`));
-    console.log(chalk53.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
+    console.log(chalk54.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk54.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
   }
   await Promise.all(optionsList.map((options2) => build2(options2)));
   if (verbose) {
-    console.log(chalk53.cyan(`TSUP:build:stop [${srcDir}]`));
+    console.log(chalk54.cyan(`TSUP:build:stop [${srcDir}]`));
   }
   if (bundleTypes) {
     await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
@@ -6117,7 +6213,7 @@ var packageCompileTsup = async (config2) => {
 // src/actions/package/compile/compile.ts
 var packageCompile = async (inConfig = {}) => {
   const pkg = cwd4();
-  console.log(chalk54.green(`Compiling ${pkg}`));
+  console.log(chalk55.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
   return await packageCompileTsup(config2);
 };
@@ -6152,7 +6248,7 @@ var PUBLISH_ONLY_CHECKS = [
 
 // src/actions/package/copy-assets.ts
 import path15 from "path/posix";
-import chalk55 from "chalk";
+import chalk56 from "chalk";
 import cpy2 from "cpy";
 var copyTargetAssets2 = async (target, name, location) => {
   try {
@@ -6165,7 +6261,7 @@ var copyTargetAssets2 = async (target, name, location) => {
       }
     );
     if (values.length > 0) {
-      console.log(chalk55.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+      console.log(chalk56.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
     }
     for (const value of values) {
       console.log(`${value.split("/").pop()} => ./dist/${target}`);
@@ -6230,9 +6326,9 @@ var packageCycle = async () => {
 };
 
 // src/actions/package/gen-docs.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import path16 from "path";
-import chalk56 from "chalk";
+import chalk57 from "chalk";
 import {
   Application,
   ArgumentsReader,
@@ -6250,7 +6346,7 @@ var ExitCodes = {
 };
 var packageGenDocs = async () => {
   const pkg = INIT_CWD();
-  if (pkg !== void 0 && !existsSync14(path16.join(pkg, "typedoc.json"))) {
+  if (pkg !== void 0 && !existsSync15(path16.join(pkg, "typedoc.json"))) {
     return;
   }
   const app = await Application.bootstrap({
@@ -6336,7 +6432,7 @@ var runTypeDoc = async (app) => {
       return ExitCodes.OutputError;
     }
   }
-  console.log(chalk56.green(`${pkgName} - Ok`));
+  console.log(chalk57.green(`${pkgName} - Ok`));
   return ExitCodes.Ok;
 };
 
@@ -6345,7 +6441,7 @@ import { readdirSync as readdirSync8 } from "fs";
 import path17 from "path";
 import { cwd as cwd5 } from "process";
 import { pathToFileURL } from "url";
-import chalk57 from "chalk";
+import chalk58 from "chalk";
 import { ESLint as ESLint2 } from "eslint";
 import { findUp as findUp2 } from "find-up";
 import picomatch from "picomatch";
@@ -6354,14 +6450,14 @@ var dumpMessages2 = (lintResults) => {
   const severity = ["none", "warning", "error"];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk57.gray(`
+      console.log(chalk58.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
         console.log(
-          chalk57.gray(`	${message.line}:${message.column}`),
-          chalk57[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk57.white(`	${message.message}`),
-          chalk57.gray(`	${message.ruleId}`)
+          chalk58.gray(`	${message.line}:${message.column}`),
+          chalk58[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk58.white(`	${message.message}`),
+          chalk58.gray(`	${message.ruleId}`)
         );
       }
     }
@@ -6399,10 +6495,10 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
     cache
   });
   const files = getFiles(cwd5(), ignoreFolders);
-  console.log(chalk57.green(`Linting ${pkg} [files = ${files.length}]`));
+  console.log(chalk58.green(`Linting ${pkg} [files = ${files.length}]`));
   if (verbose) {
     for (const file of files) {
-      console.log(chalk57.gray(`	${file}`));
+      console.log(chalk58.gray(`	${file}`));
     }
   }
   const lintResults = await engine.lintFiles(files);
@@ -6413,14 +6509,14 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
   const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
   const lintTime = Date.now() - start2;
   const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk57.white(`Linted ${chalk57[filesCountColor](files.length)} files in ${chalk57[lintTimeColor](lintTime)}ms`));
+  console.log(chalk58.white(`Linted ${chalk58[filesCountColor](files.length)} files in ${chalk58[lintTimeColor](lintTime)}ms`));
   return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
 };
 
 // src/actions/package/publint.ts
 import { promises as fs17 } from "fs";
 import path18 from "path";
-import chalk58 from "chalk";
+import chalk59 from "chalk";
 import { glob as glob4 } from "glob";
 import sortPackageJson3 from "sort-package-json";
 var removeSourceFromExports = (exports) => {
@@ -6490,22 +6586,22 @@ function checkFiles(pkg, fix2) {
   const result = emptyCustomResult();
   const files = pkg.files;
   if (files === void 0) {
-    console.warn(chalk58.yellow('Publint [custom]: "files" field is missing'));
+    console.warn(chalk59.yellow('Publint [custom]: "files" field is missing'));
     result.warnings++;
   }
   if (Array.isArray(files) && !files.includes("README.md")) {
     files.push("README.md");
-    console.warn(chalk58.yellow('Publint [custom]: added "README.md" to "files"'));
+    console.warn(chalk59.yellow('Publint [custom]: added "README.md" to "files"'));
     result.modified = true;
     result.warnings++;
   }
   if (Array.isArray(files) && files.includes("src")) {
     if (fix2) {
       pkg.files = files.filter((f) => f !== "src");
-      console.warn(chalk58.yellow('Publint [custom]: removed "src" from "files"'));
+      console.warn(chalk59.yellow('Publint [custom]: removed "src" from "files"'));
       result.modified = true;
     } else {
-      console.warn(chalk58.yellow('Publint [custom]: "src" should not be in "files" (use --fix to remove)'));
+      console.warn(chalk59.yellow('Publint [custom]: "src" should not be in "files" (use --fix to remove)'));
     }
     result.warnings++;
   }
@@ -6517,10 +6613,10 @@ function checkExportsSource(pkg, fix2) {
   if (exports && typeof exports === "object" && hasSourceInExports(exports)) {
     if (fix2) {
       removeSourceFromExports(exports);
-      console.warn(chalk58.yellow('Publint [custom]: removed "source" entries from "exports"'));
+      console.warn(chalk59.yellow('Publint [custom]: removed "source" entries from "exports"'));
       result.modified = true;
     } else {
-      console.warn(chalk58.yellow('Publint [custom]: "source" entries should not be in "exports" (use --fix to remove)'));
+      console.warn(chalk59.yellow('Publint [custom]: "source" entries should not be in "exports" (use --fix to remove)'));
     }
     result.warnings++;
   }
@@ -6538,17 +6634,17 @@ function migrateFieldToExports(pkg, field, exportKey, fix2) {
       const dot2 = exports["."];
       if (dot2 && typeof dot2 === "object" && !dot2[exportKey]) {
         dot2[exportKey] = exportValue;
-        console.warn(chalk58.yellow(`Publint [custom]: migrated "${field}" to "exports['.'].${exportKey}" (${fieldValue})`));
+        console.warn(chalk59.yellow(`Publint [custom]: migrated "${field}" to "exports['.'].${exportKey}" (${fieldValue})`));
       }
     } else if (!pkg.exports) {
       pkg.exports = { ".": { [exportKey]: exportValue } };
-      console.warn(chalk58.yellow(`Publint [custom]: migrated "${field}" to "exports" (.\u2192${fieldValue})`));
+      console.warn(chalk59.yellow(`Publint [custom]: migrated "${field}" to "exports" (.\u2192${fieldValue})`));
     }
     delete pkg[field];
-    console.warn(chalk58.yellow(`Publint [custom]: removed deprecated "${field}" field`));
+    console.warn(chalk59.yellow(`Publint [custom]: removed deprecated "${field}" field`));
     result.modified = true;
   } else {
-    console.warn(chalk58.yellow(`Publint [custom]: "${field}" field is deprecated, use "exports" instead (use --fix to remove)`));
+    console.warn(chalk59.yellow(`Publint [custom]: "${field}" field is deprecated, use "exports" instead (use --fix to remove)`));
   }
   result.warnings++;
   return result;
@@ -6556,7 +6652,7 @@ function migrateFieldToExports(pkg, field, exportKey, fix2) {
 function checkSideEffects(pkg) {
   const result = emptyCustomResult();
   if (pkg.sideEffects !== false) {
-    console.warn(chalk58.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    console.warn(chalk59.yellow('Publint [custom]: "sideEffects" field should be set to false'));
     result.warnings++;
   }
   return result;
@@ -6567,10 +6663,10 @@ function checkRootSource(pkg, fix2) {
     if (pkg[field] !== void 0) {
       if (fix2) {
         delete pkg[field];
-        console.warn(chalk58.yellow(`Publint [custom]: removed root-level "${field}" field`));
+        console.warn(chalk59.yellow(`Publint [custom]: removed root-level "${field}" field`));
         result.modified = true;
       } else {
-        console.warn(chalk58.yellow(`Publint [custom]: root-level "${field}" field should not be in package.json (use --fix to remove)`));
+        console.warn(chalk59.yellow(`Publint [custom]: root-level "${field}" field should not be in package.json (use --fix to remove)`));
       }
       result.warnings++;
     }
@@ -6580,8 +6676,8 @@ function checkRootSource(pkg, fix2) {
 function checkResolutions(pkg) {
   const result = emptyCustomResult();
   if (pkg.resolutions !== void 0) {
-    console.warn(chalk58.yellow('Publint [custom]: "resolutions" in use'));
-    console.warn(chalk58.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    console.warn(chalk59.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk59.gray(JSON.stringify(pkg.resolutions, null, 2)));
     result.warnings++;
   }
   return result;
@@ -6593,10 +6689,10 @@ function checkImportToDefault(pkg, fix2) {
   if (!hasImportKeyInExports(exports)) return result;
   if (fix2) {
     replaceImportWithDefault(exports);
-    console.warn(chalk58.yellow('Publint [custom]: renamed "import" to "default" in "exports" and ensured "types" siblings'));
+    console.warn(chalk59.yellow('Publint [custom]: renamed "import" to "default" in "exports" and ensured "types" siblings'));
     result.modified = true;
   } else {
-    console.warn(chalk58.yellow('Publint [custom]: "import" entries in "exports" should use "default" instead (use --fix to rename)'));
+    console.warn(chalk59.yellow('Publint [custom]: "import" entries in "exports" should use "default" instead (use --fix to rename)'));
   }
   result.warnings++;
   return result;
@@ -6608,10 +6704,10 @@ function checkRootTypes(pkg, fix2) {
   if (!exports || typeof exports !== "object" || !hasTypesInExports(exports)) return result;
   if (fix2) {
     delete pkg.types;
-    console.warn(chalk58.yellow('Publint [custom]: removed redundant root "types" field (already defined in "exports")'));
+    console.warn(chalk59.yellow('Publint [custom]: removed redundant root "types" field (already defined in "exports")'));
     result.modified = true;
   } else {
-    console.warn(chalk58.yellow('Publint [custom]: root "types" field is redundant when "exports" defines types (use --fix to remove)'));
+    console.warn(chalk59.yellow('Publint [custom]: root "types" field is redundant when "exports" defines types (use --fix to remove)'));
   }
   result.warnings++;
   return result;
@@ -6683,15 +6779,15 @@ async function runPublintLibrary(pkgDir, pkg, strict, pack) {
   for (const message of messages) {
     switch (message.type) {
       case "error": {
-        console.error(chalk58.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.error(chalk59.red(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       case "warning": {
-        console.warn(chalk58.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.warn(chalk59.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       default: {
-        console.log(chalk58.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.log(chalk59.white(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
     }
@@ -6714,8 +6810,8 @@ var packagePublint = async ({
   await fs17.writeFile(`${pkgDir}/package.json`, sortedPkg);
   const pkg = JSON.parse(await fs17.readFile(`${pkgDir}/package.json`, "utf8"));
   const effectiveExclude = pkg.private ? /* @__PURE__ */ new Set([...exclude, ...PUBLISH_ONLY_CHECKS]) : exclude;
-  console.log(chalk58.green(`Publint: ${String(pkg.name)}${pkg.private ? chalk58.gray(" (private)") : ""}`));
-  console.log(chalk58.gray(pkgDir));
+  console.log(chalk59.green(`Publint: ${String(pkg.name)}${pkg.private ? chalk59.gray(" (private)") : ""}`));
+  console.log(chalk59.gray(pkgDir));
   let libraryErrors = 0;
   if (!effectiveExclude.has("publint")) {
     const library = await runPublintLibrary(pkgDir, pkg, strict, pack);
@@ -6736,12 +6832,12 @@ var packageRecompile = async () => {
 
 // src/actions/package-lint.ts
 import {
-  existsSync as existsSync15,
-  readFileSync as readFileSync23,
-  writeFileSync as writeFileSync10
+  existsSync as existsSync16,
+  readFileSync as readFileSync24,
+  writeFileSync as writeFileSync11
 } from "fs";
-import PATH19 from "path";
-import chalk59 from "chalk";
+import PATH20 from "path";
+import chalk60 from "chalk";
 import picomatch2 from "picomatch";
 import semver8 from "semver";
 function emptyResult() {
@@ -6752,18 +6848,18 @@ function emptyResult() {
   };
 }
 function readRootPackageJson(cwd6) {
-  const raw = readFileSync23(PATH19.resolve(cwd6, "package.json"), "utf8");
+  const raw = readFileSync24(PATH20.resolve(cwd6, "package.json"), "utf8");
   return JSON.parse(raw);
 }
 function writeRootPackageJson(cwd6, pkg) {
-  const path19 = PATH19.resolve(cwd6, "package.json");
-  writeFileSync10(path19, `${JSON.stringify(pkg, null, 2)}
+  const path19 = PATH20.resolve(cwd6, "package.json");
+  writeFileSync11(path19, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
 }
 function readPnpmWorkspaceGlobs(cwd6) {
-  const wsPath = PATH19.resolve(cwd6, "pnpm-workspace.yaml");
-  if (!existsSync15(wsPath)) return void 0;
-  const raw = readFileSync23(wsPath, "utf8");
+  const wsPath = PATH20.resolve(cwd6, "pnpm-workspace.yaml");
+  if (!existsSync16(wsPath)) return void 0;
+  const raw = readFileSync24(wsPath, "utf8");
   const globs = [];
   let inPackages = false;
   for (const line of raw.split("\n")) {
@@ -6807,7 +6903,7 @@ function checkRootPrivate(pkg) {
 function fixRootPrivate(cwd6, pkg) {
   pkg.private = true;
   writeRootPackageJson(cwd6, pkg);
-  console.log(chalk59.green('  \u2714 Fixed: set "private": true in root package.json'));
+  console.log(chalk60.green('  \u2714 Fixed: set "private": true in root package.json'));
 }
 function checkNoPublishConfigOnPrivate(pkg) {
   const result = emptyResult();
@@ -6819,15 +6915,15 @@ function checkNoPublishConfigOnPrivate(pkg) {
 function fixNoPublishConfigOnPrivate(cwd6, pkg) {
   delete pkg.publishConfig;
   writeRootPackageJson(cwd6, pkg);
-  console.log(chalk59.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+  console.log(chalk60.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
 }
 function checkNoPackageManagerInWorkspaces(cwd6, workspaces) {
   const result = emptyResult();
   for (const { location, name } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const raw = readFileSync23(pkgPath, "utf8");
+      const raw = readFileSync24(pkgPath, "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.packageManager) {
         result.fixable.push(`${name} (${location}) has a packageManager field \u2014 only the root should define this`);
@@ -6840,15 +6936,15 @@ function checkNoPackageManagerInWorkspaces(cwd6, workspaces) {
 function fixNoPackageManagerInWorkspaces(cwd6, _pkg, workspaces) {
   for (const { location } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const raw = readFileSync23(pkgPath, "utf8");
+      const raw = readFileSync24(pkgPath, "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.packageManager) {
         delete pkg.packageManager;
-        writeFileSync10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+        writeFileSync11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk59.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
+        console.log(chalk60.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
       }
     } catch {
     }
@@ -6858,9 +6954,9 @@ function checkWorkspacesFieldPlacement(cwd6, pm, workspaces) {
   const result = emptyResult();
   for (const { location, name } of workspaces) {
     if (pm === "pnpm" ? true : location !== ".") {
-      const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+      const pkgPath = PATH20.resolve(cwd6, location, "package.json");
       try {
-        const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
         if (pkg.workspaces) {
           const label = location === "." ? "Root" : `${name} (${location})`;
           const reason = pm === "pnpm" ? "pnpm uses pnpm-workspace.yaml instead" : "only the root should define workspaces";
@@ -6875,15 +6971,15 @@ function checkWorkspacesFieldPlacement(cwd6, pm, workspaces) {
 function fixWorkspacesFieldPlacement(cwd6, pm, workspaces) {
   for (const { location } of workspaces) {
     if (pm === "pnpm" ? true : location !== ".") {
-      const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+      const pkgPath = PATH20.resolve(cwd6, location, "package.json");
       try {
-        const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
         if (pkg.workspaces) {
           delete pkg.workspaces;
-          writeFileSync10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+          writeFileSync11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
           const label = location === "." ? "root" : location;
-          console.log(chalk59.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
+          console.log(chalk60.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
         }
       } catch {
       }
@@ -6913,22 +7009,22 @@ function logResults(label, result, fix2) {
   let errors = 0;
   let fixed = 0;
   for (const error of result.errors) {
-    console.log(chalk59.red(`  \u2717 ${error}`));
+    console.log(chalk60.red(`  \u2717 ${error}`));
     errors++;
   }
   for (const fixable of result.fixable) {
     if (fix2) {
       fixed++;
     } else {
-      console.log(chalk59.red(`  \u2717 ${fixable} (fixable)`));
+      console.log(chalk60.red(`  \u2717 ${fixable} (fixable)`));
       errors++;
     }
   }
   for (const warning of result.warnings) {
-    console.log(chalk59.yellow(`  \u26A0 ${warning}`));
+    console.log(chalk60.yellow(`  \u26A0 ${warning}`));
   }
   if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
-    console.log(chalk59.green(`  \u2713 ${label}`));
+    console.log(chalk60.green(`  \u2713 ${label}`));
   }
   return { errors, fixed };
 }
@@ -6950,9 +7046,9 @@ function checkVoltaOnlyInRoot(cwd6, workspaces) {
   const result = emptyResult();
   for (const { location, name } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
       if (pkg.volta) {
         result.fixable.push(`${name} (${location}) has a volta field \u2014 only the root should define this`);
       }
@@ -6964,15 +7060,15 @@ function checkVoltaOnlyInRoot(cwd6, workspaces) {
 function fixVoltaOnlyInRoot(cwd6, _pkg, workspaces) {
   for (const { location } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const raw = readFileSync23(pkgPath, "utf8");
+      const raw = readFileSync24(pkgPath, "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.volta) {
         delete pkg.volta;
-        writeFileSync10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+        writeFileSync11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk59.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
+        console.log(chalk60.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
       }
     } catch {
     }
@@ -6983,15 +7079,15 @@ function isTerminalPackage2(pkg) {
 }
 function checkEnginesOnlyInNonTerminal(cwd6, workspaces) {
   const result = emptyResult();
-  const rootPkg = JSON.parse(readFileSync23(PATH19.resolve(cwd6, "package.json"), "utf8"));
+  const rootPkg = JSON.parse(readFileSync24(PATH20.resolve(cwd6, "package.json"), "utf8"));
   if (rootPkg.engines) {
     result.fixable.push("Root package.json has engines \u2014 terminal packages should not declare engines (use volta instead)");
   }
   for (const { location, name } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
       if (isTerminalPackage2(pkg) && pkg.engines) {
         result.fixable.push(`${name} (${location}) is terminal (private) but has engines \u2014 terminal packages should not declare engines`);
       }
@@ -7004,33 +7100,33 @@ function checkEnginesOnlyInNonTerminal(cwd6, workspaces) {
   return result;
 }
 function fixEnginesOnlyInNonTerminal(cwd6, _pkg, workspaces) {
-  const rootPath = PATH19.resolve(cwd6, "package.json");
-  const rootRaw = readFileSync23(rootPath, "utf8");
+  const rootPath = PATH20.resolve(cwd6, "package.json");
+  const rootRaw = readFileSync24(rootPath, "utf8");
   const rootPkg = JSON.parse(rootRaw);
   if (rootPkg.engines) {
     delete rootPkg.engines;
-    writeFileSync10(rootPath, `${JSON.stringify(rootPkg, null, 2)}
+    writeFileSync11(rootPath, `${JSON.stringify(rootPkg, null, 2)}
 `, "utf8");
-    console.log(chalk59.green("  \u2714 Fixed: removed engines from root package.json"));
+    console.log(chalk60.green("  \u2714 Fixed: removed engines from root package.json"));
   }
   const enginesTemplate = resolveEnginesTemplate(cwd6, workspaces);
   for (const { location } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = PATH20.resolve(cwd6, location, "package.json");
     try {
-      const raw = readFileSync23(pkgPath, "utf8");
+      const raw = readFileSync24(pkgPath, "utf8");
       const pkg = JSON.parse(raw);
       if (isTerminalPackage2(pkg) && pkg.engines) {
         delete pkg.engines;
-        writeFileSync10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+        writeFileSync11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk59.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
+        console.log(chalk60.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
       }
       if (!isTerminalPackage2(pkg) && !pkg.engines && enginesTemplate) {
         pkg.engines = enginesTemplate;
-        writeFileSync10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+        writeFileSync11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk59.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
+        console.log(chalk60.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
       }
     } catch {
     }
@@ -7040,7 +7136,7 @@ function resolveEnginesTemplate(cwd6, workspaces) {
   for (const { location } of workspaces) {
     if (location === ".") continue;
     try {
-      const pkg = JSON.parse(readFileSync23(PATH19.resolve(cwd6, location, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync24(PATH20.resolve(cwd6, location, "package.json"), "utf8"));
       if (!isTerminalPackage2(pkg) && pkg.engines) {
         return pkg.engines;
       }
@@ -7058,9 +7154,9 @@ function checkVersionsIncludeLts(cwd6, workspaces) {
     yarn: latestVersions.yarn
   };
   for (const { location, name } of workspaces) {
-    const pkgPath = location === "." ? PATH19.resolve(cwd6, "package.json") : PATH19.resolve(cwd6, location, "package.json");
+    const pkgPath = location === "." ? PATH20.resolve(cwd6, "package.json") : PATH20.resolve(cwd6, location, "package.json");
     try {
-      const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
       const label = location === "." ? "root" : `${name} (${location})`;
       const engines = pkg.engines;
       if (engines) {
@@ -7091,14 +7187,14 @@ function checkVersionsIncludeLts(cwd6, workspaces) {
 }
 function logSummary(errors, fixed) {
   if (fixed > 0) {
-    console.log(chalk59.green(`
+    console.log(chalk60.green(`
   Fixed ${fixed} issue(s)`));
   }
   if (errors > 0) {
-    console.log(chalk59.red(`
+    console.log(chalk60.red(`
   ${errors} error(s) found`));
   } else if (fixed === 0) {
-    console.log(chalk59.green("\n  All checks passed"));
+    console.log(chalk60.green("\n  All checks passed"));
   }
 }
 function packageLintMonorepo(fix2 = false) {
@@ -7107,14 +7203,14 @@ function packageLintMonorepo(fix2 = false) {
   try {
     pkg = readRootPackageJson(cwd6);
   } catch {
-    console.error(chalk59.red("Could not read package.json"));
+    console.error(chalk60.red("Could not read package.json"));
     return 1;
   }
   if (!isMonorepo(pkg, cwd6)) {
-    console.log(chalk59.gray("Not a monorepo \u2014 skipping repo lint checks"));
+    console.log(chalk60.gray("Not a monorepo \u2014 skipping repo lint checks"));
     return 0;
   }
-  console.log(chalk59.green("Repo Lint"));
+  console.log(chalk60.green("Repo Lint"));
   const pm = detectPackageManager();
   const workspaces = getPackageManager().listWorkspaces();
   const internalDepCheck = pm === "pnpm" ? {
@@ -7188,34 +7284,34 @@ function packageLintMonorepo(fix2 = false) {
 
 // src/actions/packman/clean.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
-import PATH24 from "path";
-import chalk65 from "chalk";
+import PATH25 from "path";
+import chalk66 from "chalk";
 
 // src/actions/packman/convert.ts
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   statSync as statSync4
 } from "fs";
-import PATH23 from "path";
-import chalk64 from "chalk";
+import PATH24 from "path";
+import chalk65 from "chalk";
 
 // src/actions/packman/convertToPnpm.ts
 import { spawnSync as spawnSync10 } from "child_process";
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync27,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "fs";
-import PATH21 from "path";
-import chalk62 from "chalk";
+import PATH22 from "path";
+import chalk63 from "chalk";
 
 // src/actions/packman/rewriteScripts.ts
 function rewriteYarnToPnpm(script) {
@@ -7267,11 +7363,11 @@ function rewriteScriptsInPackageJson(pkg, direction) {
 
 // src/actions/packman/rewriteSourceImports.ts
 import {
-  existsSync as existsSync16,
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync11
+  existsSync as existsSync17,
+  readFileSync as readFileSync25,
+  writeFileSync as writeFileSync12
 } from "fs";
-import chalk60 from "chalk";
+import chalk61 from "chalk";
 import { globSync as globSync4 } from "glob";
 var IMPORT_SWAP_MAP = {
   "yarn-to-pnpm": [
@@ -7306,30 +7402,30 @@ function rewriteSourceImports(cwd6, direction) {
   });
   let count = 0;
   for (const file of files) {
-    if (!existsSync16(file)) continue;
-    const original = readFileSync24(file, "utf8");
+    if (!existsSync17(file)) continue;
+    const original = readFileSync25(file, "utf8");
     let content = original;
     for (const [from, to] of swaps) {
       content = content.replaceAll(from, to);
     }
     if (content !== original) {
-      writeFileSync11(file, content, "utf8");
+      writeFileSync12(file, content, "utf8");
       count++;
     }
   }
   if (count > 0) {
-    console.log(chalk60.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
+    console.log(chalk61.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
   }
 }
 
 // src/actions/packman/swapTsScriptsDependency.ts
 import {
-  existsSync as existsSync17,
-  readFileSync as readFileSync25,
-  writeFileSync as writeFileSync12
+  existsSync as existsSync18,
+  readFileSync as readFileSync26,
+  writeFileSync as writeFileSync13
 } from "fs";
-import PATH20 from "path";
-import chalk61 from "chalk";
+import PATH21 from "path";
+import chalk62 from "chalk";
 var SWAP_MAP = {
   "yarn-to-pnpm": [
     ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"]
@@ -7339,8 +7435,8 @@ var SWAP_MAP = {
   ]
 };
 function swapInPackageJson(pkgPath, direction) {
-  if (!existsSync17(pkgPath)) return false;
-  const raw = readFileSync25(pkgPath, "utf8");
+  if (!existsSync18(pkgPath)) return false;
+  const raw = readFileSync26(pkgPath, "utf8");
   const pkg = JSON.parse(raw);
   let changed = false;
   for (const depField of ["dependencies", "devDependencies"]) {
@@ -7355,24 +7451,24 @@ function swapInPackageJson(pkgPath, direction) {
     }
   }
   if (changed) {
-    writeFileSync12(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    writeFileSync13(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
   }
   return changed;
 }
 function swapTsScriptsDependency(cwd6, workspacePackageJsonPaths, direction) {
   let count = 0;
-  if (swapInPackageJson(PATH20.join(cwd6, "package.json"), direction)) {
+  if (swapInPackageJson(PATH21.join(cwd6, "package.json"), direction)) {
     count++;
   }
   for (const pkgPath of workspacePackageJsonPaths) {
-    const fullPath = PATH20.resolve(cwd6, pkgPath, "package.json");
+    const fullPath = PATH21.resolve(cwd6, pkgPath, "package.json");
     if (swapInPackageJson(fullPath, direction)) {
       count++;
     }
   }
   if (count > 0) {
     const target = direction === "yarn-to-pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
-    console.log(chalk61.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
+    console.log(chalk62.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
   }
 }
 
@@ -7383,13 +7479,13 @@ function createPnpmWorkspaceYaml(cwd6, workspacePatterns) {
   for (const pattern of workspacePatterns) {
     lines.push(`  - '${pattern}'`);
   }
-  writeFileSync13(PATH21.join(cwd6, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
-  console.log(chalk62.green("  Created pnpm-workspace.yaml"));
+  writeFileSync14(PATH22.join(cwd6, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
+  console.log(chalk63.green("  Created pnpm-workspace.yaml"));
 }
 function readPnpmWorkspacePatterns(cwd6) {
-  const wsPath = PATH21.join(cwd6, "pnpm-workspace.yaml");
-  if (!existsSync18(wsPath)) return [];
-  const content = readFileSync26(wsPath, "utf8");
+  const wsPath = PATH22.join(cwd6, "pnpm-workspace.yaml");
+  if (!existsSync19(wsPath)) return [];
+  const content = readFileSync27(wsPath, "utf8");
   const patterns = [];
   const lines = content.split("\n");
   let inPackages = false;
@@ -7408,20 +7504,20 @@ function readPnpmWorkspacePatterns(cwd6) {
   return patterns;
 }
 function updateRootPackageJson(cwd6) {
-  const pkgPath = PATH21.join(cwd6, "package.json");
-  const pkg = JSON.parse(readFileSync26(pkgPath, "utf8"));
+  const pkgPath = PATH22.join(cwd6, "package.json");
+  const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
   const workspacePatterns = pkg.workspaces ?? readPnpmWorkspacePatterns(cwd6);
   delete pkg.workspaces;
   pkg.packageManager = `pnpm@${PNPM_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
-  writeFileSync13(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk62.green("  Updated root package.json"));
+  writeFileSync14(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk63.green("  Updated root package.json"));
   return workspacePatterns;
 }
 function updateGitignore(cwd6) {
-  const gitignorePath = PATH21.join(cwd6, ".gitignore");
-  if (!existsSync18(gitignorePath)) return;
-  let content = readFileSync26(gitignorePath, "utf8");
+  const gitignorePath = PATH22.join(cwd6, ".gitignore");
+  if (!existsSync19(gitignorePath)) return;
+  let content = readFileSync27(gitignorePath, "utf8");
   const yarnLines = [
     ".pnp.*",
     ".pnp",
@@ -7436,53 +7532,53 @@ function updateGitignore(cwd6) {
     content = content.replaceAll(new RegExp(String.raw`^${line.replaceAll(".", String.raw`\.`).replaceAll("*", String.raw`\*`).replaceAll("!", String.raw`\!`)}\s*$`, "gm"), "");
   }
   content = content.replaceAll(/\n{3,}/g, "\n\n");
-  writeFileSync13(gitignorePath, content, "utf8");
-  console.log(chalk62.green("  Updated .gitignore"));
+  writeFileSync14(gitignorePath, content, "utf8");
+  console.log(chalk63.green("  Updated .gitignore"));
 }
 function deleteYarnArtifacts(cwd6) {
-  const yarnLock = PATH21.join(cwd6, "yarn.lock");
-  const yarnrc = PATH21.join(cwd6, ".yarnrc.yml");
-  const yarnDir = PATH21.join(cwd6, ".yarn");
-  if (existsSync18(yarnLock)) {
+  const yarnLock = PATH22.join(cwd6, "yarn.lock");
+  const yarnrc = PATH22.join(cwd6, ".yarnrc.yml");
+  const yarnDir = PATH22.join(cwd6, ".yarn");
+  if (existsSync19(yarnLock)) {
     rmSync3(yarnLock);
-    console.log(chalk62.gray("  Deleted yarn.lock"));
+    console.log(chalk63.gray("  Deleted yarn.lock"));
   }
-  if (existsSync18(yarnrc)) {
+  if (existsSync19(yarnrc)) {
     rmSync3(yarnrc);
-    console.log(chalk62.gray("  Deleted .yarnrc.yml"));
+    console.log(chalk63.gray("  Deleted .yarnrc.yml"));
   }
-  if (existsSync18(yarnDir)) {
+  if (existsSync19(yarnDir)) {
     rmSync3(yarnDir, { force: true, recursive: true });
-    console.log(chalk62.gray("  Deleted .yarn/"));
+    console.log(chalk63.gray("  Deleted .yarn/"));
   }
 }
 function createNpmrc(cwd6) {
-  const npmrcPath = PATH21.join(cwd6, ".npmrc");
-  if (existsSync18(npmrcPath)) return;
-  mkdirSync5(PATH21.dirname(npmrcPath), { recursive: true });
-  writeFileSync13(npmrcPath, "", "utf8");
-  console.log(chalk62.green("  Created .npmrc"));
+  const npmrcPath = PATH22.join(cwd6, ".npmrc");
+  if (existsSync19(npmrcPath)) return;
+  mkdirSync5(PATH22.dirname(npmrcPath), { recursive: true });
+  writeFileSync14(npmrcPath, "", "utf8");
+  console.log(chalk63.green("  Created .npmrc"));
 }
 function convertToPnpm(cwd6, workspacePackageJsonPaths) {
-  console.log(chalk62.blue("\nConverting to pnpm...\n"));
+  console.log(chalk63.blue("\nConverting to pnpm...\n"));
   const workspacePatterns = updateRootPackageJson(cwd6);
   createPnpmWorkspaceYaml(cwd6, workspacePatterns);
   for (const pkgPath of workspacePackageJsonPaths) {
-    const fullPath = PATH21.resolve(cwd6, pkgPath, "package.json");
-    if (!existsSync18(fullPath)) continue;
-    const pkg = JSON.parse(readFileSync26(fullPath, "utf8"));
+    const fullPath = PATH22.resolve(cwd6, pkgPath, "package.json");
+    if (!existsSync19(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync27(fullPath, "utf8"));
     const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
     if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
-      writeFileSync13(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+      writeFileSync14(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk62.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk63.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore(cwd6);
   createNpmrc(cwd6);
   swapTsScriptsDependency(cwd6, workspacePackageJsonPaths, "yarn-to-pnpm");
   rewriteSourceImports(cwd6, "yarn-to-pnpm");
   deleteYarnArtifacts(cwd6);
-  console.log(chalk62.blue("\nRunning pnpm install..."));
+  console.log(chalk63.blue("\nRunning pnpm install..."));
   const install = spawnSync10("pnpm", ["install"], {
     cwd: cwd6,
     encoding: "utf8",
@@ -7490,23 +7586,23 @@ function convertToPnpm(cwd6, workspacePackageJsonPaths) {
     stdio: "inherit"
   });
   if (install.status !== 0) {
-    console.error(chalk62.red("pnpm install failed"));
+    console.error(chalk63.red("pnpm install failed"));
     return 1;
   }
-  console.log(chalk62.blue("\nConversion complete.\n"));
+  console.log(chalk63.blue("\nConversion complete.\n"));
   return 0;
 }
 
 // src/actions/packman/convertToYarn.ts
 import { spawnSync as spawnSync11 } from "child_process";
 import {
-  existsSync as existsSync19,
-  readFileSync as readFileSync27,
+  existsSync as existsSync20,
+  readFileSync as readFileSync28,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
-import PATH22 from "path";
-import chalk63 from "chalk";
+import PATH23 from "path";
+import chalk64 from "chalk";
 var YARN_VERSION = "4.13.0";
 var YARNRC_TEMPLATE = `compressionLevel: mixed
 
@@ -7528,9 +7624,9 @@ var YARN_GITIGNORE_ENTRIES = `
 !.yarn/versions
 `;
 function readPnpmWorkspacePatterns2(cwd6) {
-  const wsPath = PATH22.join(cwd6, "pnpm-workspace.yaml");
-  if (!existsSync19(wsPath)) return [];
-  const content = readFileSync27(wsPath, "utf8");
+  const wsPath = PATH23.join(cwd6, "pnpm-workspace.yaml");
+  if (!existsSync20(wsPath)) return [];
+  const content = readFileSync28(wsPath, "utf8");
   const patterns = [];
   const lines = content.split("\n");
   let inPackages = false;
@@ -7549,83 +7645,83 @@ function readPnpmWorkspacePatterns2(cwd6) {
   return patterns;
 }
 function updateRootPackageJson2(cwd6, workspacePatterns) {
-  const pkgPath = PATH22.join(cwd6, "package.json");
-  const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
+  const pkgPath = PATH23.join(cwd6, "package.json");
+  const pkg = JSON.parse(readFileSync28(pkgPath, "utf8"));
   pkg.workspaces = workspacePatterns;
   pkg.packageManager = `yarn@${YARN_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
-  writeFileSync14(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk63.green("  Updated root package.json"));
+  writeFileSync15(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk64.green("  Updated root package.json"));
 }
 function updateGitignore2(cwd6) {
-  const gitignorePath = PATH22.join(cwd6, ".gitignore");
-  let content = existsSync19(gitignorePath) ? readFileSync27(gitignorePath, "utf8") : "";
+  const gitignorePath = PATH23.join(cwd6, ".gitignore");
+  let content = existsSync20(gitignorePath) ? readFileSync28(gitignorePath, "utf8") : "";
   if (!content.includes(".yarn/*")) {
     content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
   }
-  writeFileSync14(gitignorePath, content, "utf8");
-  console.log(chalk63.green("  Updated .gitignore"));
+  writeFileSync15(gitignorePath, content, "utf8");
+  console.log(chalk64.green("  Updated .gitignore"));
 }
 function deletePnpmArtifacts(cwd6) {
-  const lockfile = PATH22.join(cwd6, "pnpm-lock.yaml");
-  const workspaceYaml = PATH22.join(cwd6, "pnpm-workspace.yaml");
-  const npmrc = PATH22.join(cwd6, ".npmrc");
-  if (existsSync19(lockfile)) {
+  const lockfile = PATH23.join(cwd6, "pnpm-lock.yaml");
+  const workspaceYaml = PATH23.join(cwd6, "pnpm-workspace.yaml");
+  const npmrc = PATH23.join(cwd6, ".npmrc");
+  if (existsSync20(lockfile)) {
     rmSync4(lockfile);
-    console.log(chalk63.gray("  Deleted pnpm-lock.yaml"));
+    console.log(chalk64.gray("  Deleted pnpm-lock.yaml"));
   }
-  if (existsSync19(workspaceYaml)) {
+  if (existsSync20(workspaceYaml)) {
     rmSync4(workspaceYaml);
-    console.log(chalk63.gray("  Deleted pnpm-workspace.yaml"));
+    console.log(chalk64.gray("  Deleted pnpm-workspace.yaml"));
   }
-  if (existsSync19(npmrc)) {
-    const content = readFileSync27(npmrc, "utf8");
+  if (existsSync20(npmrc)) {
+    const content = readFileSync28(npmrc, "utf8");
     if (content.trim() === "" || content.includes("shamefully-hoist") || content.includes("node-linker")) {
       rmSync4(npmrc);
-      console.log(chalk63.gray("  Deleted .npmrc"));
+      console.log(chalk64.gray("  Deleted .npmrc"));
     }
   }
 }
 function createYarnrc(cwd6) {
-  const yarnrcPath = PATH22.join(cwd6, ".yarnrc.yml");
-  if (existsSync19(yarnrcPath)) return;
-  writeFileSync14(yarnrcPath, YARNRC_TEMPLATE, "utf8");
-  console.log(chalk63.green("  Created .yarnrc.yml"));
+  const yarnrcPath = PATH23.join(cwd6, ".yarnrc.yml");
+  if (existsSync20(yarnrcPath)) return;
+  writeFileSync15(yarnrcPath, YARNRC_TEMPLATE, "utf8");
+  console.log(chalk64.green("  Created .yarnrc.yml"));
 }
 function readWorkspacePatternsFromPackageJson(cwd6) {
-  const pkgPath = PATH22.join(cwd6, "package.json");
-  if (!existsSync19(pkgPath)) return [];
-  const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
+  const pkgPath = PATH23.join(cwd6, "package.json");
+  if (!existsSync20(pkgPath)) return [];
+  const pkg = JSON.parse(readFileSync28(pkgPath, "utf8"));
   return pkg.workspaces ?? [];
 }
 function convertToYarn(cwd6, workspacePackageJsonPaths) {
-  console.log(chalk63.blue("\nConverting to yarn...\n"));
+  console.log(chalk64.blue("\nConverting to yarn...\n"));
   const workspacePatterns = readPnpmWorkspacePatterns2(cwd6);
   if (workspacePatterns.length === 0) {
     const fromPkg = readWorkspacePatternsFromPackageJson(cwd6);
     if (fromPkg.length > 0) {
       workspacePatterns.push(...fromPkg);
     } else {
-      console.warn(chalk63.yellow("  No workspace patterns found"));
+      console.warn(chalk64.yellow("  No workspace patterns found"));
     }
   }
   updateRootPackageJson2(cwd6, workspacePatterns);
   for (const pkgPath of workspacePackageJsonPaths) {
-    const fullPath = PATH22.resolve(cwd6, pkgPath, "package.json");
-    if (!existsSync19(fullPath)) continue;
-    const pkg = JSON.parse(readFileSync27(fullPath, "utf8"));
+    const fullPath = PATH23.resolve(cwd6, pkgPath, "package.json");
+    if (!existsSync20(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync28(fullPath, "utf8"));
     const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
     if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
-      writeFileSync14(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+      writeFileSync15(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk63.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk64.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore2(cwd6);
   createYarnrc(cwd6);
   swapTsScriptsDependency(cwd6, workspacePackageJsonPaths, "pnpm-to-yarn");
   rewriteSourceImports(cwd6, "pnpm-to-yarn");
   deletePnpmArtifacts(cwd6);
-  console.log(chalk63.blue("\nRunning yarn install..."));
+  console.log(chalk64.blue("\nRunning yarn install..."));
   const install = spawnSync11("yarn", ["install"], {
     cwd: cwd6,
     encoding: "utf8",
@@ -7633,31 +7729,31 @@ function convertToYarn(cwd6, workspacePackageJsonPaths) {
     stdio: "inherit"
   });
   if (install.status !== 0) {
-    console.error(chalk63.red("yarn install failed"));
+    console.error(chalk64.red("yarn install failed"));
     return 1;
   }
-  console.log(chalk63.blue("\nConversion complete.\n"));
+  console.log(chalk64.blue("\nConversion complete.\n"));
   return 0;
 }
 
 // src/actions/packman/convert.ts
 function detectCurrentPM(cwd6) {
-  if (existsSync20(PATH23.join(cwd6, "pnpm-lock.yaml")) || existsSync20(PATH23.join(cwd6, "pnpm-workspace.yaml"))) {
+  if (existsSync21(PATH24.join(cwd6, "pnpm-lock.yaml")) || existsSync21(PATH24.join(cwd6, "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync20(PATH23.join(cwd6, "yarn.lock")) || existsSync20(PATH23.join(cwd6, ".yarnrc.yml"))) {
+  if (existsSync21(PATH24.join(cwd6, "yarn.lock")) || existsSync21(PATH24.join(cwd6, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "unknown";
 }
 function findWorkspacePackagePaths(cwd6) {
-  const pkgPath = PATH23.join(cwd6, "package.json");
-  const pkg = JSON.parse(readFileSync28(pkgPath, "utf8"));
+  const pkgPath = PATH24.join(cwd6, "package.json");
+  const pkg = JSON.parse(readFileSync29(pkgPath, "utf8"));
   const patterns = pkg.workspaces ?? [];
   if (patterns.length === 0) {
-    const wsPath = PATH23.join(cwd6, "pnpm-workspace.yaml");
-    if (existsSync20(wsPath)) {
-      const content = readFileSync28(wsPath, "utf8");
+    const wsPath = PATH24.join(cwd6, "pnpm-workspace.yaml");
+    if (existsSync21(wsPath)) {
+      const content = readFileSync29(wsPath, "utf8");
       const lines = content.split("\n");
       let inPackages = false;
       for (const line of lines) {
@@ -7687,15 +7783,15 @@ function resolveWorkspaceGlob(cwd6, pattern) {
 }
 function walkGlob(basePath, parts, currentPath) {
   if (parts.length === 0) {
-    const fullPath = PATH23.join(basePath, currentPath);
-    if (existsSync20(PATH23.join(fullPath, "package.json"))) {
+    const fullPath = PATH24.join(basePath, currentPath);
+    if (existsSync21(PATH24.join(fullPath, "package.json"))) {
       return [currentPath];
     }
     return [];
   }
   const [part, ...rest] = parts;
-  const dirPath = PATH23.join(basePath, currentPath);
-  if (!existsSync20(dirPath) || !statSync4(dirPath).isDirectory()) {
+  const dirPath = PATH24.join(basePath, currentPath);
+  if (!existsSync21(dirPath) || !statSync4(dirPath).isDirectory()) {
     return [];
   }
   if (part === "*" || part === "**") {
@@ -7723,38 +7819,38 @@ function walkGlob(basePath, parts, currentPath) {
 function convert({ target, verbose }) {
   const validTargets = ["pnpm", "yarn"];
   if (!validTargets.includes(target)) {
-    console.error(chalk64.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
+    console.error(chalk65.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
     return 1;
   }
   const cwd6 = process.cwd();
   const currentPM = detectCurrentPM(cwd6);
   if (verbose) {
-    console.log(chalk64.gray(`Current package manager: ${currentPM}`));
-    console.log(chalk64.gray(`Target package manager: ${target}`));
+    console.log(chalk65.gray(`Current package manager: ${currentPM}`));
+    console.log(chalk65.gray(`Target package manager: ${target}`));
   }
   if (currentPM === target) {
-    console.log(chalk64.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
+    console.log(chalk65.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
   }
   if (currentPM === "unknown") {
-    console.error(chalk64.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    console.error(chalk65.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
     return 1;
   }
   const workspacePaths = findWorkspacePackagePaths(cwd6);
   if (verbose) {
-    console.log(chalk64.gray(`Found ${workspacePaths.length} workspace packages`));
+    console.log(chalk65.gray(`Found ${workspacePaths.length} workspace packages`));
   }
   const result = target === "pnpm" ? convertToPnpm(cwd6, workspacePaths) : convertToYarn(cwd6, workspacePaths);
   if (result !== 0) return result;
-  console.log(chalk64.green("\nRunning repo lint --fix..."));
+  console.log(chalk65.green("\nRunning repo lint --fix..."));
   packageLintMonorepo(true);
   return result;
 }
 
 // src/actions/packman/clean.ts
 function removeNodeModules(dir, verbose) {
-  const nmPath = PATH24.join(dir, "node_modules");
-  if (existsSync21(nmPath)) {
-    if (verbose) console.log(chalk65.gray(`Removing ${nmPath}`));
+  const nmPath = PATH25.join(dir, "node_modules");
+  if (existsSync22(nmPath)) {
+    if (verbose) console.log(chalk66.gray(`Removing ${nmPath}`));
     rmSync5(nmPath, { force: true, recursive: true });
     return true;
   }
@@ -7764,73 +7860,73 @@ function packmanClean({ verbose }) {
   const cwd6 = process.cwd();
   const pm = detectCurrentPM(cwd6);
   if (pm === "unknown") {
-    console.error(chalk65.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    console.error(chalk66.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
     return 1;
   }
-  console.log(chalk65.blue(`Detected package manager: ${pm}`));
+  console.log(chalk66.blue(`Detected package manager: ${pm}`));
   let removedCount = 0;
   if (removeNodeModules(cwd6, verbose)) removedCount++;
   const workspacePaths = findWorkspacePackagePaths(cwd6);
   for (const wsPath of workspacePaths) {
-    const fullPath = PATH24.join(cwd6, wsPath);
+    const fullPath = PATH25.join(cwd6, wsPath);
     if (removeNodeModules(fullPath, verbose)) removedCount++;
   }
-  console.log(chalk65.green(`Removed ${removedCount} node_modules folder${removedCount === 1 ? "" : "s"}`));
+  console.log(chalk66.green(`Removed ${removedCount} node_modules folder${removedCount === 1 ? "" : "s"}`));
   if (pm === "yarn") {
-    const lockPath = PATH24.join(cwd6, "yarn.lock");
-    if (existsSync21(lockPath)) {
-      writeFileSync15(lockPath, "");
-      console.log(chalk65.green("Truncated yarn.lock"));
+    const lockPath = PATH25.join(cwd6, "yarn.lock");
+    if (existsSync22(lockPath)) {
+      writeFileSync16(lockPath, "");
+      console.log(chalk66.green("Truncated yarn.lock"));
     }
   } else if (pm === "pnpm") {
-    const lockPath = PATH24.join(cwd6, "pnpm-lock.yaml");
-    if (existsSync21(lockPath)) {
+    const lockPath = PATH25.join(cwd6, "pnpm-lock.yaml");
+    if (existsSync22(lockPath)) {
       rmSync5(lockPath);
-      console.log(chalk65.green("Deleted pnpm-lock.yaml"));
+      console.log(chalk66.green("Deleted pnpm-lock.yaml"));
     }
   }
-  console.log(chalk65.green("Ready for a clean install"));
+  console.log(chalk66.green("Ready for a clean install"));
   return 0;
 }
 
 // src/actions/packman/lint.ts
 import {
-  existsSync as existsSync22,
-  readFileSync as readFileSync29,
-  writeFileSync as writeFileSync16
+  existsSync as existsSync23,
+  readFileSync as readFileSync30,
+  writeFileSync as writeFileSync17
 } from "fs";
-import PATH25 from "path";
-import chalk66 from "chalk";
+import PATH26 from "path";
+import chalk67 from "chalk";
 function checkEnableScripts(cwd6, verbose, silent) {
-  const yarnrcPath = PATH25.join(cwd6, ".yarnrc.yml");
-  if (!existsSync22(yarnrcPath)) {
-    if (verbose) console.log(chalk66.gray("  No .yarnrc.yml found, skipping enableScripts check"));
+  const yarnrcPath = PATH26.join(cwd6, ".yarnrc.yml");
+  if (!existsSync23(yarnrcPath)) {
+    if (verbose) console.log(chalk67.gray("  No .yarnrc.yml found, skipping enableScripts check"));
     return true;
   }
-  const content = readFileSync29(yarnrcPath, "utf8");
+  const content = readFileSync30(yarnrcPath, "utf8");
   const lines = content.split("\n");
   for (const line of lines) {
     const trimmed = line.trim();
     if (/^enableScripts\s*:/.test(trimmed)) {
       const value = trimmed.replace(/^enableScripts\s*:\s*/, "").trim();
       if (value === "false") {
-        if (verbose) console.log(chalk66.green("  enableScripts is correctly set to false"));
+        if (verbose) console.log(chalk67.green("  enableScripts is correctly set to false"));
         return true;
       }
-      if (!silent) console.log(chalk66.red("  enableScripts is set to", value, "(expected false)"));
+      if (!silent) console.log(chalk67.red("  enableScripts is set to", value, "(expected false)"));
       return false;
     }
   }
-  if (!silent) console.log(chalk66.red("  enableScripts is not set in .yarnrc.yml (expected false)"));
+  if (!silent) console.log(chalk67.red("  enableScripts is not set in .yarnrc.yml (expected false)"));
   return false;
 }
 function fixEnableScripts(cwd6, verbose) {
-  const yarnrcPath = PATH25.join(cwd6, ".yarnrc.yml");
-  if (!existsSync22(yarnrcPath)) {
-    if (verbose) console.log(chalk66.gray("  No .yarnrc.yml found, skipping enableScripts fix"));
+  const yarnrcPath = PATH26.join(cwd6, ".yarnrc.yml");
+  if (!existsSync23(yarnrcPath)) {
+    if (verbose) console.log(chalk67.gray("  No .yarnrc.yml found, skipping enableScripts fix"));
     return true;
   }
-  const content = readFileSync29(yarnrcPath, "utf8");
+  const content = readFileSync30(yarnrcPath, "utf8");
   const lines = content.split("\n");
   let found = false;
   const newLines = lines.map((line) => {
@@ -7859,8 +7955,8 @@ function fixEnableScripts(cwd6, verbose) {
       }
     }
   }
-  writeFileSync16(yarnrcPath, newLines.join("\n"), "utf8");
-  console.log(chalk66.green("  Fixed: enableScripts set to false"));
+  writeFileSync17(yarnrcPath, newLines.join("\n"), "utf8");
+  console.log(chalk67.green("  Fixed: enableScripts set to false"));
   return true;
 }
 var checks = [
@@ -7874,7 +7970,7 @@ function packmanLint({ fix: fix2, verbose } = {}) {
   const cwd6 = process.cwd();
   let failures = 0;
   for (const check of checks) {
-    if (verbose) console.log(chalk66.gray(`Checking: ${check.name}`));
+    if (verbose) console.log(chalk67.gray(`Checking: ${check.name}`));
     const passed = check.check(cwd6, verbose, fix2);
     if (!passed) {
       if (fix2) {
@@ -7888,24 +7984,24 @@ function packmanLint({ fix: fix2, verbose } = {}) {
     }
   }
   if (failures > 0) {
-    console.log(chalk66.red(`
+    console.log(chalk67.red(`
 packman lint: ${failures} check(s) failed`));
     if (!fix2) {
-      console.log(chalk66.yellow("Run with --fix to auto-fix issues"));
+      console.log(chalk67.yellow("Run with --fix to auto-fix issues"));
     }
   } else {
-    console.log(chalk66.green("\npackman lint: all checks passed"));
+    console.log(chalk67.green("\npackman lint: all checks passed"));
   }
   return failures > 0 ? 1 : 0;
 }
 
 // src/actions/publint.ts
-import chalk67 from "chalk";
+import chalk68 from "chalk";
 function resolveExclude(publintConfig, cliExclude, cliInclude) {
   const hasExclude = (publintConfig.exclude?.length ?? 0) > 0 || (cliExclude?.length ?? 0) > 0;
   const hasInclude = (publintConfig.include?.length ?? 0) > 0 || (cliInclude?.length ?? 0) > 0;
   if (hasExclude && hasInclude) {
-    console.error(chalk67.red("Publint: --include and --exclude cannot be used together"));
+    console.error(chalk68.red("Publint: --include and --exclude cannot be used together"));
     return void 0;
   }
   if (hasInclude) {
@@ -7956,7 +8052,7 @@ var publint = async ({
   });
 };
 function logPublintSummary(packages, errors, ms) {
-  const color = errors > 0 ? chalk67.red : chalk67.blue;
+  const color = errors > 0 ? chalk68.red : chalk68.blue;
   console.log(color(`Checked ${packages} package(s) in ${ms.toFixed(0)}ms with ${errors} issue(s) found.`));
 }
 var publintSingle = async ({
@@ -7971,7 +8067,7 @@ var publintSingle = async ({
   const pm = getPackageManager();
   const workspace = pm.findWorkspace(pkg);
   if (!workspace) {
-    console.error(chalk67.red(`Publint: workspace "${pkg}" not found`));
+    console.error(chalk68.red(`Publint: workspace "${pkg}" not found`));
     return 1;
   }
   const wsPublintConfig = normalizePublintConfig(
@@ -8025,7 +8121,7 @@ var publintAll = async ({
           });
           results[i] = { errors, output };
         } catch (ex) {
-          output.push(chalk67.red(`Publint failed for ${ws.name}: ${ex.message}
+          output.push(chalk68.red(`Publint failed for ${ws.name}: ${ex.message}
 `));
           results[i] = { errors: 1, output };
         }
@@ -8049,7 +8145,7 @@ var publintAll = async ({
         runInstall();
       } else {
         for (const msg of peerResult.fixable) {
-          console.log(chalk67.red(`  \u2717 ${msg} (fixable)`));
+          console.log(chalk68.red(`  \u2717 ${msg} (fixable)`));
         }
         totalErrors += peerResult.fixable.length;
       }
@@ -8103,25 +8199,25 @@ async function readmeInit({ templatePath }) {
 }
 
 // src/actions/readme-lint.ts
-import { existsSync as existsSync23, readFileSync as readFileSync30 } from "fs";
-import PATH26 from "path";
-import chalk68 from "chalk";
+import { existsSync as existsSync24, readFileSync as readFileSync31 } from "fs";
+import PATH27 from "path";
+import chalk69 from "chalk";
 function lintTemplate(cwd6) {
   const result = { errors: [], warnings: [] };
   const templatePath = resolveTemplatePath();
-  if (!existsSync23(templatePath)) {
+  if (!existsSync24(templatePath)) {
     result.errors.push('Missing .xy/README.template.md (run "xy readme init" to create)');
     return result;
   }
-  const template = readFileSync30(templatePath, "utf8");
+  const template = readFileSync31(templatePath, "utf8");
   if (!template.includes("{{body}}")) {
     result.warnings.push(".xy/README.template.md does not contain a {{body}} placeholder");
   }
   if (!template.includes("{{description}}")) {
     result.warnings.push(".xy/README.template.md does not contain a {{description}} placeholder");
   }
-  const bodyPath = PATH26.join(cwd6, ".xy", "README.body.md");
-  if (!existsSync23(bodyPath)) {
+  const bodyPath = PATH27.join(cwd6, ".xy", "README.body.md");
+  if (!existsSync24(bodyPath)) {
     result.errors.push('Missing .xy/README.body.md (run "xy readme init" to create)');
   }
   return result;
@@ -8129,8 +8225,8 @@ function lintTemplate(cwd6) {
 function lintLogoConfig(cwd6, config2) {
   const result = { errors: [], warnings: [] };
   const templatePath = resolveTemplatePath();
-  if (existsSync23(templatePath)) {
-    const template = readFileSync30(templatePath, "utf8");
+  if (existsSync24(templatePath)) {
+    const template = readFileSync31(templatePath, "utf8");
     const logoRef = /\[logo]: (.+)/.exec(template);
     if (logoRef?.[1].includes("example.com")) {
       result.warnings.push(".xy/README.template.md still has the example.com logo placeholder \u2014 update it or set readme.logoUrl in xy.config.ts");
@@ -8149,15 +8245,15 @@ function lintPackages(cwd6) {
   const workspaces = pm.listWorkspaces();
   for (const { location, name } of workspaces) {
     if (location === ".") continue;
-    const pkgPath = PATH26.join(cwd6, location, "package.json");
+    const pkgPath = PATH27.join(cwd6, location, "package.json");
     try {
-      const pkg = JSON.parse(readFileSync30(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync31(pkgPath, "utf8"));
       if (pkg.private) continue;
       if (!pkg.description) {
         result.warnings.push(`${name} is missing a "description" in package.json`);
       }
-      const readmePath = PATH26.join(cwd6, location, "README.md");
-      if (!existsSync23(readmePath)) {
+      const readmePath = PATH27.join(cwd6, location, "README.md");
+      if (!existsSync24(readmePath)) {
         result.errors.push(`${name} is missing README.md`);
       }
     } catch {
@@ -8167,7 +8263,7 @@ function lintPackages(cwd6) {
 }
 function readmeLint({ config: config2, verbose }) {
   const cwd6 = INIT_CWD();
-  console.log(chalk68.green("Readme Lint"));
+  console.log(chalk69.green("Readme Lint"));
   const checks2 = [
     lintTemplate(cwd6),
     lintLogoConfig(cwd6, config2),
@@ -8177,19 +8273,19 @@ function readmeLint({ config: config2, verbose }) {
   let warningCount = 0;
   for (const { errors, warnings } of checks2) {
     for (const error of errors) {
-      console.log(chalk68.red(`  \u2717 ${error}`));
+      console.log(chalk69.red(`  \u2717 ${error}`));
       errorCount++;
     }
     for (const warning of warnings) {
-      console.log(chalk68.yellow(`  \u26A0 ${warning}`));
+      console.log(chalk69.yellow(`  \u26A0 ${warning}`));
       warningCount++;
     }
   }
   if (errorCount === 0 && warningCount === 0) {
-    console.log(chalk68.green("  All checks passed"));
+    console.log(chalk69.green("  All checks passed"));
   } else {
     if (verbose) {
-      console.log(chalk68.gray(`  ${errorCount} error(s), ${warningCount} warning(s)`));
+      console.log(chalk69.gray(`  ${errorCount} error(s), ${warningCount} warning(s)`));
     }
   }
   return errorCount > 0 ? 1 : 0;
@@ -8298,18 +8394,18 @@ var relintAllPackages = ({ fix: fix2 = false } = {}) => {
 // src/actions/repo-init.ts
 import { spawnSync as spawnSync12 } from "child_process";
 import {
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync31,
-  writeFileSync as writeFileSync17
+  readFileSync as readFileSync32,
+  writeFileSync as writeFileSync18
 } from "fs";
 import { createRequire as createRequire5 } from "module";
-import PATH27 from "path";
-import { createInterface as createInterface4 } from "readline";
-import chalk69 from "chalk";
+import PATH28 from "path";
+import { createInterface as createInterface5 } from "readline";
+import chalk70 from "chalk";
 function askQuestion(question) {
-  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -8320,7 +8416,7 @@ function askQuestion(question) {
 function getConfigVersion() {
   const require6 = createRequire5(import.meta.url);
   const pkgPath = require6.resolve("@xylabs/ts-scripts-common/package.json");
-  const pkg = JSON.parse(readFileSync31(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync32(pkgPath, "utf8"));
   return pkg.version.replace(/\.\d+$/, "");
 }
 function mapOutputPath(relativePath, variables) {
@@ -8370,10 +8466,10 @@ function buildVariables(params) {
   };
 }
 function ensureEmptyDir(projectDir, name) {
-  if (existsSync24(projectDir)) {
+  if (existsSync25(projectDir)) {
     const entries = readdirSync10(projectDir);
     if (entries.length > 0) {
-      console.error(chalk69.red(`Directory '${name}' already exists and is not empty`));
+      console.error(chalk70.red(`Directory '${name}' already exists and is not empty`));
       return false;
     }
   }
@@ -8389,37 +8485,37 @@ function scaffoldFiles(templateName, layer, outputDir, pm, variables, verbose) {
     let outputPath = mapOutputPath(file.relativePath, variables);
     if (!outputPath) continue;
     if (layer === "root") outputPath = mapBuildWorkflowName(outputPath);
-    const fullPath = PATH27.resolve(outputDir, outputPath);
-    mkdirSync6(PATH27.dirname(fullPath), { recursive: true });
-    writeFileSync17(fullPath, content);
+    const fullPath = PATH28.resolve(outputDir, outputPath);
+    mkdirSync6(PATH28.dirname(fullPath), { recursive: true });
+    writeFileSync18(fullPath, content);
     count++;
-    if (verbose) console.log(chalk69.gray(`  ${layer === "root" ? outputPath : `packages/${variables.packageName}/${outputPath}`}`));
+    if (verbose) console.log(chalk70.gray(`  ${layer === "root" ? outputPath : `packages/${variables.packageName}/${outputPath}`}`));
   }
   return count;
 }
 function initGitRepo(projectDir, verbose) {
-  if (verbose) console.log(chalk69.gray("Initializing git repository..."));
+  if (verbose) console.log(chalk70.gray("Initializing git repository..."));
   const result = spawnSync12("git", ["init", "-b", "main"], {
     cwd: projectDir,
     stdio: verbose ? "inherit" : "pipe"
   });
   if (result.status === 0) {
-    console.log(chalk69.green("Initialized git repository"));
+    console.log(chalk70.green("Initialized git repository"));
   } else {
-    console.warn(chalk69.yellow("git init failed, skipping"));
+    console.warn(chalk70.yellow("git init failed, skipping"));
   }
 }
 function installDependencies(projectDir, pm) {
-  console.log(chalk69.gray(`Running ${pm} install...`));
+  console.log(chalk70.gray(`Running ${pm} install...`));
   const result = spawnSync12(pm, ["install"], {
     cwd: projectDir,
     stdio: "inherit"
   });
   if (result.status !== 0) {
-    console.warn(chalk69.yellow(`${pm} install failed`));
+    console.warn(chalk70.yellow(`${pm} install failed`));
     return false;
   }
-  console.log(chalk69.green("Dependencies installed"));
+  console.log(chalk70.green("Dependencies installed"));
   return true;
 }
 async function repoInit(params) {
@@ -8434,13 +8530,13 @@ async function repoInit(params) {
   } = params;
   let name = params.name;
   if (!name) {
-    name = await askQuestion(chalk69.cyan("Project name: "));
+    name = await askQuestion(chalk70.cyan("Project name: "));
     if (!name) {
-      console.error(chalk69.red("Project name is required"));
+      console.error(chalk70.red("Project name is required"));
       return 1;
     }
   }
-  const projectName = PATH27.basename(name);
+  const projectName = PATH28.basename(name);
   const packageName2 = params.packageName ?? projectName;
   const githubOrg = params.githubOrg ?? scope.replace(/^@/, "");
   const variables = buildVariables({
@@ -8452,26 +8548,26 @@ async function repoInit(params) {
     scope
   });
   if (verbose) {
-    console.log(chalk69.gray("Template variables:"));
+    console.log(chalk70.gray("Template variables:"));
     for (const [key, value] of Object.entries(variables)) {
-      console.log(chalk69.gray(`  ${key}: ${value}`));
+      console.log(chalk70.gray(`  ${key}: ${value}`));
     }
   }
-  const projectDir = PATH27.resolve(process.cwd(), name);
+  const projectDir = PATH28.resolve(process.cwd(), name);
   if (!ensureEmptyDir(projectDir, name)) return 1;
   const rootCount = scaffoldFiles(template, "root", projectDir, pm, variables, verbose);
-  const pkgDir = PATH27.resolve(projectDir, "packages", packageName2);
+  const pkgDir = PATH28.resolve(projectDir, "packages", packageName2);
   const pkgCount = scaffoldFiles(template, "package", pkgDir, pm, variables, verbose);
-  console.log(chalk69.green(`Scaffolded ${rootCount + pkgCount} files into ${name}/`));
+  console.log(chalk70.green(`Scaffolded ${rootCount + pkgCount} files into ${name}/`));
   if (!skipGit) initGitRepo(projectDir, verbose);
   if (!skipInstall && !installDependencies(projectDir, pm)) return 1;
   console.log("");
-  console.log(chalk69.cyan(`Project ${name} created successfully!`));
+  console.log(chalk70.cyan(`Project ${name} created successfully!`));
   console.log("");
-  console.log(chalk69.gray("Next steps:"));
-  console.log(chalk69.gray(`  cd ${name}`));
-  if (skipInstall) console.log(chalk69.gray(`  ${pm} install`));
-  console.log(chalk69.gray(`  ${pm} xy build`));
+  console.log(chalk70.gray("Next steps:"));
+  console.log(chalk70.gray(`  cd ${name}`));
+  if (skipInstall) console.log(chalk70.gray(`  ${pm} install`));
+  console.log(chalk70.gray(`  ${pm} xy build`));
   return 0;
 }
 
@@ -8508,10 +8604,10 @@ var start = () => {
 };
 
 // src/actions/statics.ts
-import chalk70 from "chalk";
+import chalk71 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk70.green("Check Required Static Dependencies"));
+  console.log(chalk71.green("Check Required Static Dependencies"));
   const pkg = parsedPackageJSON();
   const xy2 = pkg?.xy;
   const deps = xy2?.deps;
@@ -8690,7 +8786,7 @@ var xyBuildCommands = (args) => {
 };
 
 // src/xy/common/checkCommand.ts
-import chalk71 from "chalk";
+import chalk72 from "chalk";
 var checkCommand = {
   command: "check",
   describe: "Check - Run gitlint, publint, repo lint, lintlint, and readme lint",
@@ -8707,25 +8803,25 @@ var checkCommand = {
     const jobs = argv.jobs;
     let errors = 0;
     if (verbose) console.log("Check");
-    console.log(chalk71.blue("\n\u2014 gitlint \u2014"));
+    console.log(chalk72.blue("\n\u2014 gitlint \u2014"));
     errors += fix2 ? gitlintFix() : gitlint();
-    console.log(chalk71.blue("\n\u2014 publint \u2014"));
+    console.log(chalk72.blue("\n\u2014 publint \u2014"));
     errors += await publint({
       fix: fix2,
       jobs,
       verbose
     });
-    console.log(chalk71.blue("\n\u2014 repo lint \u2014"));
+    console.log(chalk72.blue("\n\u2014 repo lint \u2014"));
     errors += packageLintMonorepo(fix2);
-    console.log(chalk71.blue("\n\u2014 lintlint \u2014"));
+    console.log(chalk72.blue("\n\u2014 lintlint \u2014"));
     errors += await lintlint({ fix: fix2, verbose });
-    console.log(chalk71.blue("\n\u2014 readme lint \u2014"));
+    console.log(chalk72.blue("\n\u2014 readme lint \u2014"));
     const config2 = await loadConfig();
     errors += readmeLint({ config: config2, verbose });
     if (errors > 0) {
-      console.log(chalk71.red(`${errors} issue(s) found`));
+      console.log(chalk72.red(`${errors} issue(s) found`));
     } else {
-      console.log(chalk71.green("All checks passed"));
+      console.log(chalk72.green("All checks passed"));
     }
     process.exitCode = errors > 0 ? 1 : 0;
   }
@@ -9391,7 +9487,7 @@ var deplintCommand = {
 };
 
 // src/xy/lint/fixCommand.ts
-import chalk72 from "chalk";
+import chalk73 from "chalk";
 var fixCommand = {
   builder: (yargs2) => {
     return packagePositionalParam(yargs2).option("cache", {
@@ -9410,7 +9506,7 @@ var fixCommand = {
   deprecated: 'Use "xy lint --fix" instead',
   describe: "Fix - Run Eslint w/fix",
   handler: async (argv) => {
-    console.warn(chalk72.yellow('Deprecated: use "xy lint --fix" instead of "xy fix"'));
+    console.warn(chalk73.yellow('Deprecated: use "xy lint --fix" instead of "xy fix"'));
     if (argv.verbose) console.log("Fix");
     process.exitCode = await fix({
       cache: argv.cache,
@@ -9423,7 +9519,7 @@ var fixCommand = {
 };
 
 // src/xy/lint/knipCommand.ts
-import chalk73 from "chalk";
+import chalk74 from "chalk";
 var knipCommand = {
   command: "knip",
   describe: "Knip - Run Knip",
@@ -9434,12 +9530,12 @@ var knipCommand = {
     if (argv.verbose) console.log("Knip");
     const start2 = Date.now();
     process.exitCode = knip();
-    console.log(chalk73.blue(`Knip finished in ${Date.now() - start2}ms`));
+    console.log(chalk74.blue(`Knip finished in ${Date.now() - start2}ms`));
   }
 };
 
 // src/xy/lint/lint/index.ts
-import chalk74 from "chalk";
+import chalk75 from "chalk";
 
 // src/xy/lint/lint/initCommand.ts
 var initCommand4 = {
@@ -9506,7 +9602,7 @@ var lintCommand4 = {
   describe: "Lint - Run ESLint",
   handler: async (argv) => {
     if (argv.init) {
-      console.warn(chalk74.yellow('Deprecated: use "xy lint init" instead of "xy lint --init"'));
+      console.warn(chalk75.yellow('Deprecated: use "xy lint init" instead of "xy lint --init"'));
       process.exitCode = await lintInit({ verbose: !!argv.verbose });
     }
   }
@@ -9655,11 +9751,11 @@ var xyReactCommands = (args) => {
 };
 
 // src/xy/xy.ts
-import chalk76 from "chalk";
+import chalk77 from "chalk";
 
 // src/xy/xyParseOptions.ts
 import { availableParallelism } from "os";
-import chalk75 from "chalk";
+import chalk76 from "chalk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 function formatDuration(ms) {
@@ -9684,14 +9780,14 @@ var xyParseOptions = () => {
       timerRegistered = true;
       const commandName = argv._[0];
       const jobs = argv.jobs;
-      const label = commandName ? ` [${chalk75.white(commandName)}]` : "";
+      const label = commandName ? ` [${chalk76.white(commandName)}]` : "";
       console.log(
-        chalk75.blue("\u2B21 XY") + label + chalk75.gray(` [threads: ${jobs}]`)
+        chalk76.blue("\u2B21 XY") + label + chalk76.gray(` [threads: ${jobs}]`)
       );
       const start2 = Date.now();
       process.on("exit", () => {
-        const exitLabel = commandName ? ` [${chalk75.white(commandName)}]` : "";
-        console.log(chalk75.blue(`Finished${exitLabel} in ${formatDuration(Date.now() - start2)}`));
+        const exitLabel = commandName ? ` [${chalk76.white(commandName)}]` : "";
+        console.log(chalk76.blue(`Finished${exitLabel} in ${formatDuration(Date.now() - start2)}`));
       });
     }
   }, true).option("jobs", {
@@ -9760,8 +9856,8 @@ var xyBase = async (plugins) => {
   let args = xyBuildCommands(xyCommonCommands(xyLintCommands(options)));
   if (plugins) args = plugins(args);
   return await args.demandCommand(1).command("*", "", () => {
-    console.error(chalk76.yellow(`Command not found [${chalk76.magenta(process.argv[2])}]`));
-    console.log(chalk76.gray("Try 'xy --help' for list of commands"));
+    console.error(chalk77.yellow(`Command not found [${chalk77.magenta(process.argv[2])}]`));
+    console.log(chalk77.gray("Try 'xy --help' for list of commands"));
   }).version().help().argv;
 };
 var xy = async () => {
@@ -9838,6 +9934,7 @@ export {
   deplint,
   deplintRules,
   deploy,
+  deprecationMigrate,
   detectCurrentPM,
   detectDuplicateDependencies,
   detectPackageManager,