@xylabs/ts-scripts-yarn3 7.4.28 → 7.5.1

package/dist/index.mjs

@@ -1,345 +1,5 @@
-// src/actions/build.ts
-import chalk11 from "chalk";
-
-// src/lib/checkResult.ts
-import chalk from "chalk";
-var checkResult = (name, result, level = "error", exitOnFail = false) => {
-  if (result) {
-    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
-    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
-    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
-    if (exitOnFail) {
-      process.exit(result);
-    }
-  }
-};
-
-// src/lib/claudeMdTemplate.ts
-import {
-  readdirSync,
-  readFileSync,
-  statSync
-} from "fs";
-import { createRequire } from "module";
-import PATH from "path";
-var require2 = createRequire(import.meta.url);
-var packageRoot = PATH.dirname(require2.resolve("@xylabs/ts-scripts-yarn3/package.json"));
-var templatesDir = PATH.resolve(packageRoot, "templates", "claude");
-var XYLABS_RULES_PREFIX = "xylabs-";
-var XYLABS_COMMANDS_PREFIX = "xy-";
-var LEGACY_COMMANDS_PREFIX = "xylabs-";
-var XYLABS_SKILLS_PREFIX = "xylabs-";
-var claudeMdRuleTemplates = () => {
-  const rulesDir = PATH.resolve(templatesDir, "rules");
-  const files = readdirSync(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
-  const result = {};
-  for (const file of files) {
-    result[file] = readFileSync(PATH.resolve(rulesDir, file), "utf8");
-  }
-  return result;
-};
-var claudeCommandTemplates = () => {
-  const commandsDir = PATH.resolve(templatesDir, "commands");
-  const files = readdirSync(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
-  const result = {};
-  for (const file of files) {
-    result[file] = readFileSync(PATH.resolve(commandsDir, file), "utf8");
-  }
-  return result;
-};
-var claudeSkillTemplates = () => {
-  const skillsDir = PATH.resolve(templatesDir, "skills");
-  const dirs = readdirSync(skillsDir).filter(
-    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync(PATH.resolve(skillsDir, f)).isDirectory()
-  );
-  const result = {};
-  for (const dir of dirs) {
-    const dirPath = PATH.resolve(skillsDir, dir);
-    const files = readdirSync(dirPath, { recursive: true, encoding: "utf8" });
-    result[dir] = {};
-    for (const file of files) {
-      if (statSync(PATH.resolve(dirPath, file)).isFile()) {
-        result[dir][file] = readFileSync(PATH.resolve(dirPath, file), "utf8");
-      }
-    }
-  }
-  return result;
-};
-var claudeMdProjectTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-project.md"), "utf8");
-var claudeMdLocalTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-local.md"), "utf8");
-
-// src/lib/createBuildConfig.ts
-import { readFileSync as readFileSync2 } from "fs";
-
-// src/lib/defaultBuildConfig.ts
-var defaultBuildConfig = {
-  compilerOptions: {
-    rootDir: "src",
-    rootDirs: ["package.json"]
-  },
-  exclude: [
-    "**/build",
-    "**/dist",
-    "**/node_modules",
-    "**/*.spec.*",
-    "**/*.spec",
-    "**/*.stories.*",
-    "**/*.example.*",
-    "**/spec/*",
-    "**/stories/*"
-  ],
-  include: ["src"]
-};
-
-// src/lib/createBuildConfig.ts
-var getGeneralTypescriptConfig = (location) => {
-  let generalConfig;
-  try {
-    generalConfig = readFileSync2(`${location}/tsconfig.json`, { encoding: "utf8" });
-  } catch {
-    return false;
-  }
-  return JSON.parse(generalConfig);
-};
-var createBuildConfig = (location, module, target, outDirSuffix) => {
-  const generalConfigObject = getGeneralTypescriptConfig(location);
-  if (generalConfigObject === false) {
-    return void 0;
-  }
-  return {
-    ...generalConfigObject,
-    compilerOptions: {
-      ...defaultBuildConfig.compilerOptions,
-      ...generalConfigObject.compilerOptions,
-      module,
-      outDir: `./${generalConfigObject.compilerOptions?.outDir ?? "dist"}/${outDirSuffix}`,
-      target
-    },
-    exclude: [...generalConfigObject.exclude ?? [], ...defaultBuildConfig.exclude],
-    include: [...generalConfigObject.include ?? [], ...defaultBuildConfig.include]
-  };
-};
-
-// src/lib/deleteGlob.ts
-import fs from "fs";
-import { glob } from "glob";
-var deleteGlob = (globPath) => {
-  const files = glob.sync(globPath);
-  for (const file of files) {
-    fs.rmSync(file, { recursive: true, force: true });
-  }
-};
-
-// src/lib/dependencies/detectDuplicateDependencies.ts
-import { execSync } from "child_process";
-
-// src/lib/processEx.ts
-import chalk2 from "chalk";
-
-// src/lib/withError.ts
-var withError = (ex, closure, predicate = (ex2) => !!ex2.name && !!ex2.message) => {
-  return predicate(ex) ? closure(ex) : void 0;
-};
-
-// src/lib/withErrnoException.ts
-var withErrnoException = (ex, closure) => {
-  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
-};
-
-// src/lib/processEx.ts
-var processEx = (ex) => {
-  const error = typeof ex === "string" ? new Error(ex) : ex;
-  const exitCode = withErrnoException(error, (error2) => {
-    if (error2.code === "ENOENT") {
-      console.error(chalk2.red(`'${error2.path}' not found.`));
-    } else {
-      console.error(chalk2.red(`Errno: ${error2.code}`));
-    }
-    return error2.errno ?? -1;
-  }) ?? withError(error, (error2) => {
-    console.error(chalk2.red(`${error2.name}: ${error2.message}`));
-    return -1;
-  }) ?? (() => {
-    console.error(chalk2.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
-    return -1;
-  })();
-  process.exit(process.exitCode ?? exitCode);
-};
-
-// src/lib/safeExit.ts
-var safeExit = (func, exitOnFail = true) => {
-  try {
-    const result = func();
-    if (result && exitOnFail) {
-      process.exit(result);
-    }
-    return result;
-  } catch (ex) {
-    return processEx(ex);
-  }
-};
-var safeExitAsync = async (func, exitOnFail = true) => {
-  try {
-    const result = await func();
-    if (result && exitOnFail) {
-      process.exit(result);
-    }
-    return result;
-  } catch (ex) {
-    return processEx(ex);
-  }
-};
-
-// src/lib/dependencies/DuplicateDetector.ts
-import { EOL } from "os";
-import chalk3 from "chalk";
-
-// src/lib/jsonFormatters.ts
-var multiLineToJSONArray = (output) => {
-  const withCommas = output.replaceAll("\r\n", "").replaceAll("\n", ",");
-  const cleanCollection = withCommas.slice(0, Math.max(0, withCommas.length - 1));
-  const collection = `[${cleanCollection}]`;
-  return JSON.parse(collection);
-};
-
-// src/lib/dependencies/DuplicateDetector.ts
-var trimVirtualMeta = (value) => {
-  const virtualParts = value.split("virtual:");
-  if (virtualParts.length > 1) {
-    const hashParts = virtualParts[1].split("#");
-    return virtualParts[0] + hashParts[1];
-  } else {
-    return value;
-  }
-};
-var trimObjectDependencyVirtualMeta = (obj) => {
-  const resultObj = {};
-  for (const [key, value] of Object.entries(obj)) {
-    resultObj[trimVirtualMeta(key)] = {
-      descriptor: trimVirtualMeta(value.descriptor),
-      locator: trimVirtualMeta(value.locator)
-    };
-  }
-  return resultObj;
-};
-var trimDependencyVirtualMeta = (dependencies) => {
-  return dependencies.map((dependency) => {
-    return { children: trimObjectDependencyVirtualMeta(dependency.children), value: trimVirtualMeta(dependency.value) };
-  });
-};
-var DuplicateDetector = class {
-  dependency;
-  dependencyEntries;
-  constructor(output, dependency) {
-    this.dependency = dependency;
-    this.dependencyEntries = trimDependencyVirtualMeta(multiLineToJSONArray(output));
-  }
-  detect() {
-    const result = this.dependencyEntries.reduce(this.detectReducer, this.resultsFactory(this.dependency));
-    if (result.duplicateVersions.length > 0) {
-      console.log(chalk3.yellow(`${EOL}Duplicates found for: ${this.dependency}`));
-      const duplicateVersions = result.duplicateVersions.toString().replaceAll(",", `${EOL}  `);
-      console.log(chalk3.grey(`  ${duplicateVersions}`, EOL));
-      return 1;
-    } else {
-      console.log(`${this.dependency} - OK`);
-      return 0;
-    }
-  }
-  detectReducer(acc, entry) {
-    const version = Object.entries(entry.children).map(([k]) => k)[0];
-    if (!acc.currentVersion) {
-      acc.currentVersion = version;
-      return acc;
-    }
-    if (acc.currentVersion && acc.currentVersion !== version && !version.includes("@virtual:")) {
-      if (acc.duplicateVersions.length === 0) {
-        acc.duplicateVersions.push(acc.currentVersion);
-      }
-      acc.duplicateVersions.push(version);
-      acc.duplicateVersions = [...new Set(acc.duplicateVersions)];
-    }
-    return acc;
-  }
-  resultsFactory = (dependency) => ({
-    currentVersion: void 0,
-    dependency,
-    duplicateVersions: []
-  });
-};
-
-// src/lib/dependencies/detectDuplicateDependencies.ts
-var detectDuplicateDependencies = (depsFromPackageJSON, DefaultDependencies2) => {
-  let exitCode = 0;
-  const dependencies = depsFromPackageJSON?.length ? depsFromPackageJSON : DefaultDependencies2;
-  return safeExit(() => {
-    if (dependencies) {
-      for (const dependency of dependencies) {
-        let output;
-        try {
-          const cmd = `yarn why ${dependency} --json`;
-          output = execSync(cmd).toString();
-        } catch (e) {
-          console.error(`Error running yarn why: ${e}`);
-          exitCode = 1;
-          continue;
-        }
-        if (output) {
-          exitCode = new DuplicateDetector(output, dependency).detect();
-        } else {
-          console.log(`${dependency} - N/A`);
-          if (depsFromPackageJSON) {
-            exitCode = 1;
-            console.log(`\u{1F6A8} Library ${dependency} was requested in package.json but not found`);
-          }
-        }
-      }
-      return exitCode;
-    } else {
-      console.log("\u{1F6A8} No dependencies where passed");
-      return exitCode;
-    }
-  });
-};
-
-// src/lib/file/constants.ts
-var WINDOWS_NEWLINE_REGEX = /\r\n/g;
-var CROSS_PLATFORM_NEWLINE = "\n";
-
-// src/lib/file/fileLines.ts
-import {
-  existsSync,
-  readFileSync as readFileSync3,
-  writeFileSync
-} from "fs";
-
-// src/lib/string/empty.ts
-var empty = (value) => value?.trim().length === 0;
-var notEmpty = (value) => !empty(value);
-
-// src/lib/string/union.ts
-var union = (a, b) => /* @__PURE__ */ new Set([...new Set(a), ...new Set(b)]);
-
-// src/lib/file/ReadFileSyncOptions.ts
-var defaultReadFileSyncOptions = { encoding: "utf8" };
-
-// src/lib/file/fileLines.ts
-var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync(uri) ? readFileSync3(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 = existsSync(uri) ? readFileSync3(uri, options) : void 0;
-  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
-  if (existing !== desired) writeFileSync(uri, desired, options);
-};
-
-// src/lib/file/tryReadFileSync.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
-var tryReadFileSync = (uri, options = defaultReadFileSyncOptions) => {
-  return existsSync2(uri) ? readFileSync4(uri, options) : void 0;
-};
-
-// src/lib/generateIgnoreFiles.ts
-import chalk4 from "chalk";
+// src/index.ts
+import { registerPackageManager } from "@xylabs/ts-scripts-common";
 
 // src/lib/yarn/isYarnVersionOrGreater.ts
 import { spawnSync } from "child_process";
@@ -375,4014 +35,247 @@ var yarnWorkspace = (pkg) => {
   return workspace;
 };
 
-// src/lib/yarn/yarnInitCwd.ts
-var INIT_CWD = () => {
-  if (!process.env.INIT_CWD) console.error("Missing INIT_CWD");
-  return process.env.INIT_CWD;
-};
-
-// src/lib/generateIgnoreFiles.ts
-var localeCompare = (a, b) => a.localeCompare(b);
-var mergeEntries = (a, b) => [...union(a, b)].toSorted(localeCompare);
-var generateIgnoreFiles = (filename2, pkg) => {
-  console.log(chalk4.green(`Generate ${filename2} Files`));
-  const cwd5 = INIT_CWD() ?? ".";
-  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
-  const readEntries = (location) => readNonEmptyLines(`${location}/${filename2}`);
-  const writeEntries = (location, entries) => writeLines(`${location}/${filename2}`, entries);
-  const results = workspaces.map(({ location, name }) => {
-    try {
-      writeEntries(location, mergeEntries(readEntries(cwd5), readEntries(location)));
-      return 0;
-    } catch (ex) {
-      const error = ex;
-      console.error(`Generate ${filename2} Files [${name}] [${error.message}]`);
-      return 1;
-    }
-  });
-  const succeeded = results.every((result) => result === 0);
-  return succeeded ? 0 : 1;
-};
-
-// src/lib/generateReadmeFiles.ts
-import { execSync as execSync2 } from "child_process";
-import FS, { readFileSync as readFileSync5 } from "fs";
-import {
-  mkdir,
-  readFile,
-  writeFile
-} from "fs/promises";
-import { createRequire as createRequire2 } from "module";
-import PATH2 from "path";
-import { createInterface } from "readline";
-import chalk5 from "chalk";
-var require3 = createRequire2(import.meta.url);
-var packageRoot2 = PATH2.dirname(require3.resolve("@xylabs/ts-scripts-yarn3/package.json"));
-var readmeTemplatesDir = PATH2.resolve(packageRoot2, "templates", "readme");
-function fillTemplate(template, data) {
-  const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
-  return template.replaceAll(/\{\{(.*?)\}\}/g, (_, key) => additionalData[key.trim()] ?? "");
-}
-function generateTypedoc(packageLocation, entryPoints) {
-  const tempDir = PATH2.join(packageLocation, ".temp-typedoc");
-  try {
-    if (!FS.existsSync(tempDir)) {
-      FS.mkdirSync(tempDir, { recursive: true });
-    }
-    const typedocConfig = {
-      disableSources: true,
-      entryPointStrategy: "expand",
-      entryPoints: entryPoints.map((ep) => PATH2.resolve(packageLocation, ep)),
-      excludeExternals: true,
-      excludeInternal: true,
-      excludePrivate: true,
-      githubPages: false,
-      hideBreadcrumbs: true,
-      hideGenerator: true,
-      hidePageTitle: true,
-      out: tempDir,
-      plugin: ["typedoc-plugin-markdown"],
-      readme: "none",
-      skipErrorChecking: true,
-      sort: ["source-order"],
-      theme: "markdown",
-      useCodeBlocks: true
-    };
-    const typedocJsonPath = PATH2.join(tempDir, "typedoc.json");
-    FS.writeFileSync(typedocJsonPath, JSON.stringify(typedocConfig, null, 2));
-    try {
-      execSync2(`npx typedoc --options ${typedocJsonPath}`, {
-        cwd: process.cwd(),
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch {
-      return "";
-    }
-    return consolidateMarkdown(tempDir);
-  } catch {
-    return "";
-  } finally {
+// src/pm/yarnPackageManager.ts
+var YarnPackageManager = class {
+  command = "yarn";
+  lockfile = "yarn.lock";
+  name = "yarn";
+  dedupe() {
+    return ["yarn", ["dedupe"]];
+  }
+  findWorkspace(name) {
     try {
-      FS.rmSync(tempDir, { force: true, recursive: true });
+      return yarnWorkspace(name);
     } catch {
+      return void 0;
     }
   }
-}
-function consolidateMarkdown(tempDir) {
-  let consolidated = "## Reference\n\n";
-  const mainReadmePath = PATH2.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";
-  }
-  consolidated += processDirectory(tempDir);
-  return consolidated.replaceAll(/\n\n\n+/g, "\n\n").replaceAll(/^#### /gm, "### ").replaceAll(/^##### /gm, "#### ").replaceAll(/^###### /gm, "##### ");
-}
-function processDirectory(dir, level = 0) {
-  const indent = "  ".repeat(level);
-  let content = "";
-  try {
-    const items = FS.readdirSync(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (item.isDirectory()) continue;
-      if (item.name === "README.md" || !item.name.endsWith(".md")) continue;
-      const fileContent = FS.readFileSync(PATH2.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
-      const moduleName = item.name.replace(".md", "");
-      content += `
-
-${indent}### <a id="${moduleName}"></a>${moduleName}
-
-`;
-      content += fileContent.replace(/^# .+\n/, "").replaceAll(/\]\((.+?)\.md\)/g, "](#$1)");
-    }
-    for (const item of items) {
-      if (!item.isDirectory()) continue;
-      if (item.name === "spec" || item.name.includes(".spec")) continue;
-      content += `
-
-${indent}### ${item.name}
-`;
-      content += processDirectory(PATH2.join(dir, item.name), level + 1);
-    }
-  } catch {
-  }
-  return content;
-}
-function askConfirmation(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-    });
-  });
-}
-var DEFAULT_README_TEMPLATE = readFileSync5(PATH2.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
-var DEFAULT_README_BODY = readFileSync5(PATH2.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
-function applyLogoConfig(template, logoUrl, logoLinkUrl) {
-  let result = template;
-  if (logoUrl) {
-    result = result.replace(/\[logo]: .+/, `[logo]: ${logoUrl}`);
-    if (logoLinkUrl) {
-      result = result.replace(/\[!\[logo]\[]][^)]*\)/, `[![logo][]](${logoLinkUrl})`);
-    }
-  } else {
-    result = result.replace(/\[!\[logo]\[]][^\n]*\n*/, "");
-    result = result.replace(/\[logo]: [^\n]*\n?/, "");
-  }
-  return result;
-}
-function resolveTemplatePath(templatePath) {
-  const cwd5 = INIT_CWD() ?? ".";
-  return templatePath ?? PATH2.join(cwd5, ".xy", "README.template.md");
-}
-async function loadOrCreateTemplate(resolvedTemplatePath) {
-  try {
-    const template = await readFile(resolvedTemplatePath, "utf8");
-    return { created: false, template };
-  } catch {
-    console.log(chalk5.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");
-    }
-    const template = DEFAULT_README_TEMPLATE;
-    await scaffoldTemplate(resolvedTemplatePath, template);
-    return { created: true, template };
-  }
-}
-async function scaffoldTemplate(resolvedTemplatePath, template) {
-  const xyDir = PATH2.dirname(resolvedTemplatePath);
-  await mkdir(xyDir, { recursive: true });
-  await writeFile(resolvedTemplatePath, template);
-  console.log(chalk5.green(`Created template: ${resolvedTemplatePath}`));
-  const bodyPath = PATH2.join(xyDir, "README.body.md");
-  await writeFile(bodyPath, DEFAULT_README_BODY);
-  console.log(chalk5.green(`Created body template: ${bodyPath}`));
-}
-async function resolveBody(location, defaultBody) {
-  const localBodyPath = PATH2.join(location, "README.body.md");
-  try {
-    return await readFile(localBodyPath, "utf8");
-  } catch {
-    return defaultBody;
-  }
-}
-async function generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose) {
-  try {
-    const pkgJsonPath = PATH2.join(location, "package.json");
-    const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
-    const body = await resolveBody(location, defaultBody);
-    const typedocContent = typedoc ? generateTypedoc(location, ["src/index*.ts"]) : "";
-    const readmeContent = fillTemplate(template, {
-      ...pkgJson,
-      body,
-      typedoc: typedocContent
-    });
-    await writeFile(PATH2.join(location, "README.md"), readmeContent);
-    if (verbose) console.log(chalk5.green(`  ${name}`));
-    return true;
-  } catch (ex) {
-    const error = ex;
-    console.warn(chalk5.yellow(`  Skipped ${location}: ${error.message}`));
-    return false;
-  }
-}
-async function generateReadmeFiles({
-  logoLinkUrl,
-  logoUrl,
-  pkg,
-  templatePath,
-  typedoc = false,
-  verbose = false
-}) {
-  console.log(chalk5.green("Generate README Files"));
-  const resolvedTemplatePath = resolveTemplatePath(templatePath);
-  let template;
-  let templateCreated;
-  try {
-    ({ template, created: templateCreated } = await loadOrCreateTemplate(resolvedTemplatePath));
-  } catch {
-    return 1;
-  }
-  template = applyLogoConfig(template, logoUrl, logoLinkUrl);
-  if (templateCreated) {
-    console.log(chalk5.green("Generating README files for all packages..."));
-  }
-  const xyDir = PATH2.dirname(resolvedTemplatePath);
-  const xyBodyPath = PATH2.join(xyDir, "README.body.md");
-  let defaultBody;
-  try {
-    defaultBody = await readFile(xyBodyPath, "utf8");
-  } catch {
-    defaultBody = DEFAULT_README_BODY;
-  }
-  const workspaces = pkg && !templateCreated ? [yarnWorkspace(pkg)] : yarnWorkspaces();
-  let failed = false;
-  for (const { location, name } of workspaces) {
-    const success = await generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose);
-    if (!success) failed = true;
-  }
-  return failed ? 1 : 0;
-}
-
-// src/lib/gitignoreTemplate.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { createRequire as createRequire3 } from "module";
-import PATH3 from "path";
-var require4 = createRequire3(import.meta.url);
-var packageRoot3 = PATH3.dirname(require4.resolve("@xylabs/ts-scripts-yarn3/package.json"));
-var templatesDir2 = PATH3.resolve(packageRoot3, "templates", "gitignore");
-var gitignoreTemplate = () => readFileSync6(PATH3.resolve(templatesDir2, "template.gitignore"), "utf8");
-
-// src/lib/loadConfig.ts
-import chalk6 from "chalk";
-import { cosmiconfig } from "cosmiconfig";
-import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
-import deepmerge from "deepmerge";
-var config;
-var loadConfig = async (params) => {
-  if (config === void 0) {
-    const cosmicConfigResult = await cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } }).search();
-    config = cosmicConfigResult?.config;
-    const configFilePath = cosmicConfigResult?.filepath;
-    if (configFilePath !== void 0) {
-      console.log(chalk6.green(`Loaded config from ${configFilePath}`));
-      if (config.verbose) {
-        console.log(chalk6.gray(`${JSON.stringify(config, null, 2)}`));
-      }
-    }
-  }
-  return deepmerge(config, params ?? {});
-};
-
-// src/lib/parsedPackageJSON.ts
-import { readFileSync as readFileSync7 } from "fs";
-var parsedPackageJSON = (path14) => {
-  const pathToPackageJSON = path14 ?? process.env.npm_package_json ?? "";
-  const packageJSON = readFileSync7(pathToPackageJSON).toString();
-  return JSON.parse(packageJSON);
-};
-
-// src/lib/runSteps.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import chalk7 from "chalk";
-var runSteps = (name, steps, exitOnFail = true, messages) => {
-  return safeExit(() => {
-    const pkgName = process.env.npm_package_name;
-    console.log(chalk7.green(`${name} [${pkgName}]`));
-    let totalStatus = 0;
-    for (const [i, [command, args, config2]] of steps.entries()) {
-      if (messages?.[i]) {
-        console.log(chalk7.gray(messages?.[i]));
-      }
-      const argList = Array.isArray(args) ? args : args.split(" ");
-      if (command === "node" && !existsSync3(argList[0])) {
-        throw new Error(`File not found [${argList[0]}]`);
-      }
-      const status = spawnSync3(command, Array.isArray(args) ? args : args.split(" "), {
-        ...config2,
-        encoding: "utf8",
-        env: { FORCE_COLOR: "3", ...process.env },
-        shell: true,
-        stdio: "inherit"
-      }).status ?? 0;
-      checkResult(name, status, "error", exitOnFail);
-      totalStatus += status ?? 0;
-    }
-    return totalStatus;
-  }, !!exitOnFail);
-};
-
-// src/lib/runStepsAsync.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import chalk8 from "chalk";
-var runStepAsync = (name, step, exitOnFail = true, message) => {
-  return new Promise((resolve) => {
-    const [command, args, config2] = step;
-    if (message) {
-      console.log(chalk8.gray(message));
-    }
-    const argList = Array.isArray(args) ? args : args.split(" ");
-    if (command === "node" && !existsSync4(argList[0])) {
-      throw new Error(`File not found [${argList[0]}]`);
-    }
-    spawn(command, Array.isArray(args) ? args : args.split(" "), {
-      ...config2,
-      env: { FORCE_COLOR: "3", ...process.env },
-      shell: true,
-      stdio: "inherit"
-    }).on("close", (code) => {
-      if (code) {
-        console.error(
-          chalk8.red(
-            `Command Exited With Non-Zero Result [${chalk8.gray(code)}] | ${chalk8.yellow(command)} ${chalk8.white(
-              Array.isArray(args) ? args.join(" ") : args
-            )}`
-          )
-        );
-        checkResult(name, code, "error", exitOnFail);
-        resolve(code);
-      } else {
-        resolve(0);
-      }
-    });
-  });
-};
-var runStepsAsync = async (name, steps, exitOnFail = true, messages) => {
-  return await safeExitAsync(async () => {
-    const pkgName = process.env.npm_package_name;
-    console.log(chalk8.green(`${name} [${pkgName}]`));
-    let result = 0;
-    for (const [i, step] of steps.entries()) {
-      result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
-    }
-    return result;
-  });
-};
-
-// src/lib/runXy.ts
-var runXy = (command) => {
-  return runSteps(
-    `XY [${command}]`,
-    [["yarn", ["xy", command, ...process.argv.filter((value, index) => index > 1 ? value : void 0)]]]
-  );
-};
-
-// src/lib/runXyWithWarning.ts
-import chalk9 from "chalk";
-var runXyWithWarning = (command) => {
-  const commandString = `yarn ${command}`;
-  const commandXyString = `yarn xy ${command}`;
-  console.warn(chalk9.yellow(`WARNING: [${chalk9.white(commandString)}] is deprecated for XY Labs Scripts.`));
-  console.warn(chalk9.gray(`Did you mean [${chalk9.magenta(commandXyString)}]?`));
-  return 1;
-};
-
-// src/lib/tryRunLocalScript.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
-import PATH4 from "path";
-import chalk10 from "chalk";
-function tryRunLocalScript(commandName) {
-  if (process.env.XY_LOCAL_SCRIPT === "1") return void 0;
-  const rootPkgPath = PATH4.resolve(process.cwd(), "package.json");
-  let rootPkg;
-  try {
-    rootPkg = JSON.parse(readFileSync8(rootPkgPath, "utf8"));
-  } catch {
-    return void 0;
-  }
-  if (!rootPkg.scripts?.[commandName]) return void 0;
-  console.log(chalk10.blue(`Delegating "${commandName}" to local script`));
-  const result = spawnSync4("yarn", ["run", commandName], {
-    cwd: process.cwd(),
-    encoding: "utf8",
-    env: {
-      FORCE_COLOR: "3",
-      ...process.env,
-      XY_LOCAL_SCRIPT: "1"
-    },
-    shell: true,
-    stdio: "inherit"
-  });
-  return result.status ?? 1;
-}
-
-// src/actions/build.ts
-var build = async ({
-  incremental,
-  jobs,
-  target,
-  verbose,
-  pkg
-}) => {
-  const start = Date.now();
-  const pkgOptions = pkg === void 0 ? [] : [pkg];
-  const incrementalOptions = incremental ? ["-i"] : [];
-  const verboseOptions = verbose ? ["-v"] : [];
-  const targetOptions = target === void 0 ? [] : ["-t", target];
-  const jobsOptions = jobs === void 0 ? [] : ["-j", `${jobs}`];
-  if (jobs !== void 0) {
-    console.log(chalk11.blue(`Jobs set to [${jobs}]`));
-  }
-  const result = await runStepsAsync(`Build${incremental ? "-Incremental" : ""} [${pkg ?? "All"}]`, [
-    ["yarn", ["xy", "compile", ...pkgOptions, ...targetOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions, "--types", "tsup"]],
-    ["yarn", ["xy", "publint", ...pkgOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]],
-    ["yarn", ["xy", "deplint", ...pkgOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]],
-    ["yarn", ["xy", "lint", ...pkgOptions, ...verboseOptions, ...incrementalOptions]]
-  ]);
-  console.log(`${chalk11.gray("Built in")} [${chalk11.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk11.gray("seconds")}`);
-  return result;
-};
-
-// src/actions/claude-clean.ts
-import {
-  existsSync as existsSync5,
-  readdirSync as readdirSync2,
-  rmSync,
-  unlinkSync
-} from "fs";
-import PATH5 from "path";
-import chalk12 from "chalk";
-function removeFile(filePath, label) {
-  if (existsSync5(filePath)) {
-    unlinkSync(filePath);
-    console.log(chalk12.yellow(`  Removed ${label}`));
-    return true;
-  }
-  return false;
-}
-function removeDir(dirPath, label) {
-  if (existsSync5(dirPath)) {
-    rmSync(dirPath, { recursive: true });
-    console.log(chalk12.yellow(`  Removed ${label}`));
-    return true;
-  }
-  return false;
-}
-function claudeClean() {
-  console.log(chalk12.green("Clean Claude configuration"));
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  let removed = 0;
-  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
-  for (const file of rootFiles) {
-    if (removeFile(PATH5.resolve(cwd5, file), file)) removed++;
-  }
-  if (removeDir(PATH5.resolve(cwd5, ".claude"), ".claude/")) removed++;
-  const packagesDir = PATH5.resolve(cwd5, "packages");
-  if (existsSync5(packagesDir)) {
-    const findClaudeFiles = (dir, prefix) => {
-      const entries = readdirSync2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = PATH5.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++;
-        } else if (entry.isDirectory() && entry.name === ".claude") {
-          if (removeDir(fullPath, `${label}/`)) removed++;
-        } else if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-          findClaudeFiles(fullPath, `${label}/`);
-        }
-      }
-    };
-    findClaudeFiles(packagesDir, "packages/");
-  }
-  if (removed > 0) {
-    console.log(chalk12.green(`  Removed ${removed} item(s)`));
-  } else {
-    console.log(chalk12.gray("  Nothing to clean"));
-  }
-  return 0;
-}
-
-// src/actions/claude-commands.ts
-import {
-  existsSync as existsSync6,
-  mkdirSync,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync9,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
-} from "fs";
-import PATH6 from "path";
-import chalk13 from "chalk";
-var syncCommandFiles = (commandsDir) => {
-  const templates = claudeCommandTemplates();
-  const templateNames = new Set(Object.keys(templates));
-  let updated = 0;
-  let created = 0;
-  for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH6.resolve(commandsDir, filename2);
-    const existing = existsSync6(targetPath) ? readFileSync9(targetPath, "utf8") : void 0;
-    if (existing === content) continue;
-    writeFileSync2(targetPath, content, "utf8");
-    if (existing) {
-      updated++;
-    } else {
-      created++;
-    }
-  }
-  return {
-    created,
-    templateNames,
-    updated
-  };
-};
-var removeStaleCommands = (commandsDir, templateNames) => {
-  const existingCommands = readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
-  let removed = 0;
-  for (const file of existingCommands) {
-    if (!templateNames.has(file)) {
-      unlinkSync2(PATH6.resolve(commandsDir, file));
-      removed++;
-    }
-  }
-  return removed;
-};
-var removeLegacyCommands = (commandsDir) => {
-  const legacyFiles = readdirSync3(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
-  for (const file of legacyFiles) {
-    unlinkSync2(PATH6.resolve(commandsDir, file));
-  }
-  return legacyFiles.length;
-};
-var logCommandsResult = (created, updated, removed) => {
-  if (created || updated || removed) {
-    const parts = [
-      created ? `${created} created` : "",
-      updated ? `${updated} updated` : "",
-      removed ? `${removed} removed` : ""
-    ].filter(Boolean);
-    console.log(chalk13.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
-  } else {
-    console.log(chalk13.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
-  }
-};
-var claudeCommands = () => {
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  const commandsDir = PATH6.resolve(cwd5, ".claude", "commands");
-  mkdirSync(commandsDir, { recursive: true });
-  const legacy = removeLegacyCommands(commandsDir);
-  const {
-    created,
-    templateNames,
-    updated
-  } = syncCommandFiles(commandsDir);
-  const removed = removeStaleCommands(commandsDir, templateNames);
-  logCommandsResult(created, updated, removed + legacy);
-  return 0;
-};
-
-// src/actions/claude-rules.ts
-import { spawnSync as spawnSync5 } from "child_process";
-import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync2,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync10,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync3
-} from "fs";
-import PATH7 from "path";
-import chalk14 from "chalk";
-var syncRuleFiles = (rulesDir) => {
-  const templates = claudeMdRuleTemplates();
-  const templateNames = new Set(Object.keys(templates));
-  let updated = 0;
-  let created = 0;
-  for (const [filename2, content] of Object.entries(templates)) {
-    const targetPath = PATH7.resolve(rulesDir, filename2);
-    const existing = existsSync7(targetPath) ? readFileSync10(targetPath, "utf8") : void 0;
-    if (existing === content) continue;
-    writeFileSync3(targetPath, content, "utf8");
-    if (existing) {
-      updated++;
-    } else {
-      created++;
-    }
-  }
-  return {
-    created,
-    templateNames,
-    updated
-  };
-};
-var removeStaleRules = (rulesDir, templateNames) => {
-  const existingRules = readdirSync4(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
-  let removed = 0;
-  for (const file of existingRules) {
-    if (!templateNames.has(file)) {
-      unlinkSync3(PATH7.resolve(rulesDir, file));
-      removed++;
-    }
-  }
-  return removed;
-};
-var logRulesResult = (created, updated, removed) => {
-  if (created || updated || removed) {
-    const parts = [
-      created ? `${created} created` : "",
-      updated ? `${updated} updated` : "",
-      removed ? `${removed} removed` : ""
-    ].filter(Boolean);
-    console.log(chalk14.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
-  } else {
-    console.log(chalk14.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
-  }
-};
-var ensureProjectClaudeMd = (cwd5, force) => {
-  const projectPath = PATH7.resolve(cwd5, "CLAUDE.md");
-  if (!existsSync7(projectPath) || force) {
-    if (force && existsSync7(projectPath)) {
-      console.log(chalk14.yellow("Regenerating CLAUDE.md"));
-    }
-    console.log(chalk14.green("Generating CLAUDE.md via claude /init..."));
-    const result = spawnSync5("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
-      cwd: cwd5,
-      shell: true,
-      stdio: "inherit"
-    });
-    if (result.status !== 0) {
-      console.error(chalk14.red("claude /init failed \u2014 is Claude Code installed?"));
-      return 1;
-    }
-  } else {
-    console.log(chalk14.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
-  }
-  return 0;
-};
-var ensureLocalClaudeMd = (cwd5) => {
-  const localPath = PATH7.resolve(cwd5, "CLAUDE.local.md");
-  if (existsSync7(localPath)) {
-    console.log(chalk14.gray("CLAUDE.local.md already exists (skipped)"));
-  } else {
-    writeFileSync3(localPath, claudeMdLocalTemplate(), "utf8");
-    console.log(chalk14.green("Generated CLAUDE.local.md"));
-  }
-};
-var claudeRules = ({ force } = {}) => {
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  const rulesDir = PATH7.resolve(cwd5, ".claude", "rules");
-  mkdirSync2(rulesDir, { recursive: true });
-  const {
-    created,
-    templateNames,
-    updated
-  } = syncRuleFiles(rulesDir);
-  const removed = removeStaleRules(rulesDir, templateNames);
-  logRulesResult(created, updated, removed);
-  const claudeMdResult = ensureProjectClaudeMd(cwd5, force);
-  ensureLocalClaudeMd(cwd5);
-  return claudeMdResult ?? 0;
-};
-
-// src/actions/claude-settings.ts
-import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync4
-} from "fs";
-import PATH8 from "path";
-import { createInterface as createInterface2 } from "readline";
-import chalk15 from "chalk";
-var DEFAULT_SETTINGS = {
-  permissions: {
-    allow: [
-      "Bash(git *)",
-      "Bash(yarn *)",
-      "Bash(npx *)",
-      "Bash(node *)",
-      "Bash(ls *)",
-      "Bash(mkdir *)",
-      "Bash(cp *)",
-      "Bash(mv *)",
-      "Bash(rm *)",
-      "Bash(cat *)",
-      "Bash(head *)",
-      "Bash(tail *)",
-      "Bash(echo *)",
-      "Bash(pwd)",
-      "Bash(which *)",
-      "Bash(grep *)",
-      "Bash(find *)",
-      "Bash(npm view *)",
-      "Bash(gh *)",
-      "Read",
-      "Edit",
-      "Write",
-      "Glob",
-      "Grep",
-      "Skill"
-    ],
-    deny: [
-      "Bash(git push --force *)",
-      "Bash(git reset --hard *)",
-      "Bash(rm -rf /*)"
-    ]
-  }
-};
-function askConfirmation2(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-    });
-  });
-}
-async function claudeSettings() {
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  const claudeDir = PATH8.resolve(cwd5, ".claude");
-  const settingsPath = PATH8.resolve(claudeDir, "settings.local.json");
-  mkdirSync3(claudeDir, { recursive: true });
-  if (existsSync8(settingsPath)) {
-    const confirmed = await askConfirmation2(
-      chalk15.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
-    );
-    if (!confirmed) {
-      console.log(chalk15.gray("Skipped \u2014 existing settings.local.json preserved"));
-      return 0;
-    }
-  }
-  writeFileSync4(settingsPath, `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}
-`, "utf8");
-  console.log(chalk15.green("Generated .claude/settings.local.json"));
-  return 0;
-}
-
-// src/actions/claude-skills.ts
-import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync11,
-  rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync5
-} from "fs";
-import PATH9 from "path";
-import chalk16 from "chalk";
-var syncSkillFiles = (skillsDir) => {
-  const templates = claudeSkillTemplates();
-  const templateNames = new Set(Object.keys(templates));
-  let updated = 0;
-  let created = 0;
-  for (const [skillName, files] of Object.entries(templates)) {
-    const skillDir = PATH9.resolve(skillsDir, skillName);
-    mkdirSync4(skillDir, { recursive: true });
-    for (const [filename2, content] of Object.entries(files)) {
-      const targetPath = PATH9.resolve(skillDir, filename2);
-      mkdirSync4(PATH9.dirname(targetPath), { recursive: true });
-      const existing = existsSync9(targetPath) ? readFileSync11(targetPath, "utf8") : void 0;
-      if (existing === content) continue;
-      writeFileSync5(targetPath, content, "utf8");
-      if (existing) {
-        updated++;
-      } else {
-        created++;
-      }
-    }
-  }
-  return {
-    created,
-    templateNames,
-    updated
-  };
-};
-var removeStaleSkills = (skillsDir, templateNames) => {
-  const existingSkills = readdirSync5(skillsDir).filter(
-    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH9.resolve(skillsDir, f)).isDirectory()
-  );
-  let removed = 0;
-  for (const dir of existingSkills) {
-    if (!templateNames.has(dir)) {
-      rmSync2(PATH9.resolve(skillsDir, dir), { recursive: true });
-      removed++;
-    }
-  }
-  return removed;
-};
-var logSkillsResult = (created, updated, removed) => {
-  if (created || updated || removed) {
-    const parts = [
-      created ? `${created} created` : "",
-      updated ? `${updated} updated` : "",
-      removed ? `${removed} removed` : ""
-    ].filter(Boolean);
-    console.log(chalk16.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
-  } else {
-    console.log(chalk16.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
-  }
-};
-var claudeSkills = () => {
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  const skillsDir = PATH9.resolve(cwd5, ".claude", "skills");
-  mkdirSync4(skillsDir, { recursive: true });
-  const {
-    created,
-    templateNames,
-    updated
-  } = syncSkillFiles(skillsDir);
-  const removed = removeStaleSkills(skillsDir, templateNames);
-  logSkillsResult(created, updated, removed);
-  return 0;
-};
-
-// src/actions/clean.ts
-var clean = async ({ verbose, pkg }) => {
-  return pkg ? await cleanPackage({ pkg, verbose }) : cleanAll({ verbose });
-};
-var cleanPackage = ({ pkg }) => {
-  return runStepsAsync(`Clean [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-clean"]]]);
-};
-var cleanAll = ({ verbose }) => {
-  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
-  return runStepsAsync("Clean", [["yarn", ["workspaces foreach", "-pA", "--jobs 64", ...verboseOptions, "run", "package-clean"]]]);
-};
-
-// src/actions/clean-docs.ts
-import path from "path";
-import chalk17 from "chalk";
-var cleanDocs = () => {
-  const pkgName = process.env.npm_package_name;
-  console.log(chalk17.green(`Cleaning Docs [${pkgName}]`));
-  for (const { location } of yarnWorkspaces()) deleteGlob(path.join(location, "docs"));
-  return 0;
-};
-
-// src/actions/compile.ts
-import chalk18 from "chalk";
-var compile = ({
-  verbose,
-  target,
-  pkg,
-  incremental,
-  publint: publint2,
-  jobs
-}) => {
-  return pkg ? compilePackage({
-    pkg,
-    publint: publint2,
-    target,
-    verbose
-  }) : compileAll({
-    incremental,
-    publint: publint2,
-    target,
-    verbose,
-    jobs
-  });
-};
-var compilePackage = ({ target, pkg }) => {
-  const targetOptions = target ? ["-t", target] : [];
-  return runSteps(
-    `Compile [${pkg}]`,
-    [["yarn", ["workspace", pkg, "run", "package-compile", ...targetOptions]]]
-  );
-};
-var compileAll = ({
-  jobs,
-  verbose,
-  target,
-  incremental
-}) => {
-  const start = Date.now();
-  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
-  const targetOptions = target ? ["-t", target] : [];
-  const incrementalOptions = incremental ? ["--since", "-Ap", "--topological-dev"] : ["--parallel", "-Ap", "--topological-dev"];
-  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
-  if (jobs) {
-    console.log(chalk18.blue(`Jobs set to [${jobs}]`));
-  }
-  const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
-    ["yarn", [
+  foreachWorkspace(script, args = [], options) {
+    const jobsOptions = options?.jobs ? ["-j", `${options.jobs}`] : [];
+    const verboseOptions = options?.verbose ? ["--verbose"] : ["--no-verbose"];
+    const incrementalOptions = options?.incremental ? ["--since", "-Ap", "--topological-dev"] : ["--parallel", "-Ap", "--topological-dev"];
+    return ["yarn", [
       "workspaces",
       "foreach",
       ...incrementalOptions,
       ...jobsOptions,
       ...verboseOptions,
       "run",
-      "package-compile",
-      ...targetOptions
-    ]]
-  ]);
-  console.log(`${chalk18.gray("Compiled in")} [${chalk18.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk18.gray("seconds")}`);
-  return result;
-};
-
-// src/actions/copy-assets.ts
-import path2 from "path/posix";
-import chalk19 from "chalk";
-import cpy from "cpy";
-var copyPackageTargetAssets = async (target, name, location) => {
-  try {
-    const values = await cpy(
-      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
-      `../dist/${target}`,
-      {
-        cwd: path2.join(process.cwd(), location, "src"),
-        flat: false
-      }
-    );
-    for (const value of values) {
-      console.log(`${value.split("/").pop()} => ./dist/${target}`);
-    }
-    return 0;
-  } catch (reason) {
-    console.log(`Copy Failed: ${name}: ${reason}`);
-    return 1;
+      script,
+      ...args
+    ]];
   }
-};
-var copyTargetAssets = async (target, pkg) => {
-  const workspaces = yarnWorkspaces();
-  console.log(chalk19.green(`Copying Assets [${target.toUpperCase()}]`));
-  const workspaceList = workspaces.filter(({ name }) => {
-    return pkg === void 0 || name === pkg;
-  });
-  if (workspaceList.length === 0) {
-    console.error(`Package not found [${pkg}]`);
-  } else {
-    const results = await Promise.all(
-      workspaceList.map(async (workspace) => {
-        const { location, name } = workspace;
-        return await copyPackageTargetAssets(target, name, location);
-      })
-    );
-    return results.reduce((prev, result) => prev || result, 0);
+  install() {
+    return ["yarn", ["install"]];
   }
-  return 0;
-};
-var copyAssets = async ({ target, pkg }) => {
-  switch (target) {
-    case "esm": {
-      return await copyTargetAssets("esm", pkg);
-    }
-    case "cjs": {
-      return await copyTargetAssets("cjs", pkg);
-    }
-    default: {
-      return await copyTargetAssets("esm", pkg) || await copyTargetAssets("cjs", pkg);
-    }
+  listWorkspaces() {
+    return yarnWorkspaces();
   }
-};
-
-// src/actions/cycle.ts
-import { cruise } from "dependency-cruiser";
-var cycle = async ({ verbose, pkg } = {}) => {
-  return pkg ? cyclePackage({ pkg, verbose }) : await cycleAll({ verbose });
-};
-var cyclePackage = ({ pkg, verbose }) => {
-  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
-  return runSteps(
-    `Cycle [${pkg}]`,
-    [["yarn", ["workspace", pkg, "run", "package-cycle", ...verboseOptions]]]
-  );
-};
-var cycleAll = async ({ verbose = false }) => {
-  const pkgName = process.env.npm_package_name;
-  const cruiseOptions = {
-    ruleSet: {
-      forbidden: [
-        {
-          name: "no-circular",
-          severity: "error",
-          comment: "This dependency creates a circular reference",
-          from: {},
-          to: { circular: true }
-        }
-      ]
-    },
-    exclude: "node_modules|packages/.*/packages",
-    validate: true,
-    doNotFollow: { path: "node_modules|packages/.*/packages" },
-    tsPreCompilationDeps: false,
-    combinedDependencies: true,
-    outputType: verbose ? "text" : "err"
-  };
-  const target = "**/packages/*/src";
-  console.log(`Checking for circular dependencies in ${target}...`);
-  const result = await cruise([target], cruiseOptions);
-  if (result.output) {
-    console.log(result.output);
+  outdated() {
+    return ["yarn", ["outdated"]];
   }
-  if (result.exitCode === 0) {
-    console.log(`${pkgName} \u2705 No dependency violations`);
-  } else {
-    console.error(`${pkgName} \u274C Dependency violations found`);
+  runInWorkspace(pkg, script, args = []) {
+    return ["yarn", ["workspace", pkg, "run", script, ...args]];
   }
-  return result.exitCode;
-};
-
-// src/actions/dead.ts
-var dead = () => {
-  return runSteps("Dead", [["yarn", ["ts-prune", "-p", "tsconfig.json"]]]);
-};
-
-// src/actions/deplint/deplint.ts
-import chalk25 from "chalk";
-
-// src/actions/deplint/findFiles.ts
-import fs2 from "fs";
-
-// src/actions/deplint/findFilesByGlob.ts
-import { globSync } from "glob";
-function findFilesByGlob(cwd5, pattern, ignore) {
-  return globSync(pattern, {
-    cwd: cwd5,
-    absolute: true,
-    ignore,
-    nodir: true
-  });
-}
-
-// src/actions/deplint/findFiles.ts
-var codeExtensions = "*.{ts,tsx,mts,cts,js,mjs,cjs}";
-function getWorkspaceIgnores(location) {
-  try {
-    const raw = fs2.readFileSync(`${location}/package.json`, "utf8");
-    const pkg = JSON.parse(raw);
-    return pkg.workspaces ?? [];
-  } catch {
-    return [];
+  runXy(args) {
+    return ["yarn", ["xy", ...args]];
   }
-}
-function findFiles(location) {
-  const workspaceIgnores = getWorkspaceIgnores(location).map((w) => `${w}/**`);
-  const ignore = ["**/node_modules/**", "dist/**", ...workspaceIgnores];
-  const allFiles = findFilesByGlob(location, `./**/${codeExtensions}`, ignore);
-  const distFiles = [
-    ...findFilesByGlob(location, "./dist/**/*.d.ts"),
-    ...findFilesByGlob(location, `./dist/**/${codeExtensions}`)
-  ];
-  return { allFiles, distFiles };
-}
-
-// src/actions/deplint/getDependenciesFromPackageJson.ts
-import fs3 from "fs";
-import path3 from "path";
-function getDependenciesFromPackageJson(packageJsonPath) {
-  const packageJsonFullPath = path3.resolve(packageJsonPath);
-  const rawContent = fs3.readFileSync(packageJsonFullPath, "utf8");
-  const packageJson = JSON.parse(rawContent);
-  const dependencies = packageJson.dependencies ? Object.keys(packageJson.dependencies) : [];
-  const devDependencies = packageJson.devDependencies ? Object.keys(packageJson.devDependencies) : [];
-  const peerDependencies = packageJson.peerDependencies ? Object.keys(packageJson.peerDependencies) : [];
-  return {
-    dependencies,
-    devDependencies,
-    peerDependencies
-  };
-}
-
-// src/actions/deplint/getExtendsFromTsconfigs.ts
-import fs4 from "fs";
-import { globSync as globSync2 } from "glob";
-
-// src/actions/deplint/getBasePackageName.ts
-function getBasePackageName(importName) {
-  const importNameScrubbed = importName.replaceAll('"', "").trim();
-  if (importNameScrubbed.startsWith("@")) {
-    const parts = importNameScrubbed.split("/");
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : importNameScrubbed;
+  versionApply() {
+    return ["yarn", ["version", "apply", "--all"]];
   }
-  return importNameScrubbed.split("/")[0];
-}
-
-// src/actions/deplint/getExtendsFromTsconfigs.ts
-var isExternalReference = (ref) => !ref.startsWith(".") && !ref.startsWith("/");
-function parseExtendsField(value) {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
-  return [];
-}
-function getExtendsFromTsconfigs(location) {
-  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
-  const packages = /* @__PURE__ */ new Set();
-  for (const file of tsconfigFiles) {
-    try {
-      const content = fs4.readFileSync(file, "utf8");
-      const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
-      const parsed = JSON.parse(cleaned);
-      const refs = parseExtendsField(parsed.extends);
-      for (const ref of refs) {
-        if (isExternalReference(ref)) {
-          packages.add(getBasePackageName(ref));
-        }
-      }
-    } catch {
-    }
-  }
-  return [...packages];
-}
-
-// src/actions/deplint/getImportsFromFile.ts
-import fs5 from "fs";
-import path4 from "path";
-import ts from "typescript";
-function isTypeOnlyImportClause(clause) {
-  if (clause === void 0) {
-    return false;
-  }
-  if ("phaseModifier" in clause) {
-    const mod = clause.phaseModifier;
-    const kind = typeof mod === "number" ? mod : mod?.kind;
-    return kind === ts.SyntaxKind.TypeKeyword;
-  }
-  return clause.isTypeOnly;
-}
-function getImportsFromFile(filePath, importPaths, typeImportPaths) {
-  const sourceCode = fs5.readFileSync(filePath, "utf8");
-  const isMjsFile = filePath.endsWith(".mjs");
-  const sourceFile = ts.createSourceFile(
-    path4.basename(filePath),
-    sourceCode,
-    ts.ScriptTarget.Latest,
-    true,
-    isMjsFile ? ts.ScriptKind.JS : void 0
-  );
-  const imports = [];
-  const typeImports = [];
-  const isDeclarationFile2 = filePath.endsWith(".d.ts");
-  function visit(node) {
-    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier?.getFullText();
-      const isTypeImport = ts.isImportDeclaration(node) ? isTypeOnlyImportClause(node.importClause) : false;
-      if (typeof moduleSpecifier === "string") {
-        const trimmed = moduleSpecifier.replaceAll("'", "").replaceAll('"', "").trim();
-        if (isTypeImport || isDeclarationFile2) {
-          typeImports.push(trimmed);
-        } else {
-          imports.push(trimmed);
-        }
-      }
-    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const [arg] = node.arguments;
-      if (ts.isStringLiteral(arg)) {
-        imports.push(arg.text);
-      }
-    } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
-      imports.push(node.arguments[0].text);
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  for (const ref of sourceFile.typeReferenceDirectives) {
-    typeImports.push(ref.fileName);
-  }
-  const importsStartsWithExcludes = [".", "#", "node:"];
-  const isValidImport = (imp) => !importsStartsWithExcludes.some((exc) => imp.startsWith(exc)) && !imp.includes("*") && !imp.includes("!");
-  const cleanedImports = imports.filter(isValidImport).map(getBasePackageName);
-  const cleanedTypeImports = typeImports.filter(isValidImport).map(getBasePackageName);
-  for (const imp of cleanedImports) {
-    importPaths[imp] = importPaths[imp] ?? [];
-    importPaths[imp].push(filePath);
-  }
-  for (const imp of cleanedTypeImports) {
-    typeImportPaths[imp] = typeImportPaths[imp] ?? [];
-    typeImportPaths[imp].push(filePath);
-  }
-  return [cleanedImports, cleanedTypeImports];
-}
-
-// src/actions/deplint/getExternalImportsFromFiles.ts
-var internalImportPrefixes = [".", "#", "node:"];
-var removeInternalImports = (imports) => {
-  return imports.filter((imp) => !internalImportPrefixes.some((prefix) => imp.startsWith(prefix)));
-};
-var isDeclarationFile = (file) => file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts");
-function getExternalImportsFromFiles({
-  allFiles,
-  distFiles,
-  tsconfigExtends = []
-}) {
-  const allImportPaths = {};
-  const distImportPaths = {};
-  const distTypeImportPaths = {};
-  for (const path14 of allFiles) getImportsFromFile(path14, allImportPaths, allImportPaths).flat();
-  const distTypeFiles = distFiles.filter(isDeclarationFile);
-  const distCodeFiles = distFiles.filter((file) => !isDeclarationFile(file));
-  for (const path14 of distCodeFiles) getImportsFromFile(path14, distImportPaths, distImportPaths).flat();
-  for (const path14 of distTypeFiles) getImportsFromFile(path14, distTypeImportPaths, distTypeImportPaths).flat();
-  const allImports = Object.keys(allImportPaths);
-  const distImports = Object.keys(distImportPaths);
-  const externalAllImports = removeInternalImports(allImports);
-  const externalDistImports = removeInternalImports(distImports);
-  const externalDistTypeImports = removeInternalImports(Object.keys(distTypeImportPaths));
-  for (const ext of tsconfigExtends) {
-    if (!externalAllImports.includes(ext)) externalAllImports.push(ext);
-  }
-  return {
-    allImportPaths,
-    allImports,
-    distImportPaths,
-    distImports,
-    externalAllImports,
-    externalDistImports,
-    externalDistTypeImports
-  };
-}
-
-// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
-import { builtinModules } from "module";
-import chalk20 from "chalk";
-function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
-  return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
-}
-function isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies) {
-  return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || devDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp);
-}
-function logMissing(name, imp, importPaths) {
-  console.log(`[${chalk20.blue(name)}] Missing dependency in package.json: ${chalk20.red(imp)}`);
-  if (importPaths[imp]) {
-    console.log(`  ${importPaths[imp].join("\n ")}`);
-  }
-}
-function getUnlistedDependencies({ name, location }, {
-  dependencies,
-  devDependencies,
-  peerDependencies
-}, {
-  externalDistImports,
-  externalDistTypeImports,
-  distImportPaths
-}) {
-  let unlistedDependencies = 0;
-  for (const imp of externalDistImports) {
-    if (!isRuntimeImportListed(imp, name, dependencies, peerDependencies)) {
-      unlistedDependencies++;
-      logMissing(name, imp, distImportPaths);
-    }
-  }
-  for (const imp of externalDistTypeImports) {
-    if (!isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies)) {
-      unlistedDependencies++;
-      logMissing(name, imp, distImportPaths);
-    }
-  }
-  if (unlistedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk20.yellow(packageLocation)}
-`);
-  }
-  return unlistedDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
-import { builtinModules as builtinModules2 } from "module";
-import chalk21 from "chalk";
-function getUnlistedDevDependencies({ name, location }, {
-  devDependencies,
-  dependencies,
-  peerDependencies
-}, {
-  allImportPaths,
-  externalAllImports,
-  distImports
-}) {
-  let unlistedDevDependencies = 0;
-  for (const imp of externalAllImports) {
-    if (!distImports.includes(imp) && imp !== name && !dependencies.includes(imp) && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`) && !builtinModules2.includes(imp)) {
-      unlistedDevDependencies++;
-      console.log(`[${chalk21.blue(name)}] Missing devDependency in package.json: ${chalk21.red(imp)}`);
-      if (allImportPaths[imp]) {
-        console.log(`  ${allImportPaths[imp].join("\n ")}`);
-      }
-    }
-  }
-  if (unlistedDevDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk21.yellow(packageLocation)}
-`);
-  }
-  return unlistedDevDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDependencies.ts
-import chalk22 from "chalk";
-function getUnusedDependencies({ name, location }, { dependencies }, {
-  externalDistImports,
-  externalDistTypeImports,
-  externalAllImports
-}, exclude) {
-  let unusedDependencies = 0;
-  for (const dep of dependencies) {
-    if (exclude?.has(dep)) continue;
-    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
-      unusedDependencies++;
-      if (externalAllImports.includes(dep)) {
-        console.log(`[${chalk22.blue(name)}] dependency should be devDependency in package.json: ${chalk22.red(dep)}`);
-      } else {
-        console.log(`[${chalk22.blue(name)}] Unused dependency in package.json: ${chalk22.red(dep)}`);
-      }
-    }
-  }
-  if (unusedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk22.yellow(packageLocation)}
-`);
-  }
-  return unusedDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-import chalk23 from "chalk";
-
-// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
-import fs8 from "fs";
-import path7 from "path";
-import ts2 from "typescript";
-
-// src/actions/deplint/getScriptReferencedPackages.ts
-import fs7 from "fs";
-import path6 from "path";
-
-// src/actions/deplint/getRequiredPeerDependencies.ts
-import fs6 from "fs";
-import path5 from "path";
-function findDepPackageJson(location, dep) {
-  let dir = location;
-  while (true) {
-    const candidate = path5.join(dir, "node_modules", dep, "package.json");
-    if (fs6.existsSync(candidate)) return candidate;
-    const parent = path5.dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function getRequiredPeerDependencies(location, allDeps) {
-  const required = /* @__PURE__ */ new Set();
-  for (const dep of allDeps) {
-    const depPkgPath = findDepPackageJson(location, dep);
-    if (!depPkgPath) continue;
-    try {
-      const raw = fs6.readFileSync(depPkgPath, "utf8");
-      const pkg = JSON.parse(raw);
-      if (pkg.peerDependencies) {
-        for (const peer of Object.keys(pkg.peerDependencies)) {
-          required.add(peer);
-        }
-      }
-    } catch {
-    }
-  }
-  return required;
-}
-
-// src/actions/deplint/getScriptReferencedPackages.ts
-function getBinNames(location, dep) {
-  const depPkgPath = findDepPackageJson(location, dep);
-  if (!depPkgPath) return [];
-  try {
-    const raw = fs7.readFileSync(depPkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    if (!pkg.bin) return [];
-    if (typeof pkg.bin === "string") return [pkg.name?.split("/").pop() ?? dep];
-    return Object.keys(pkg.bin);
-  } catch {
-    return [];
-  }
-}
-function tokenizeScript(script) {
-  return script.split(/[&|;$()"`\s]+/).map((t) => t.trim()).filter(Boolean);
-}
-function getScriptReferencedPackages(location, allDeps) {
-  const pkgPath = path6.join(location, "package.json");
-  let scripts = {};
-  try {
-    const raw = fs7.readFileSync(pkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    scripts = pkg.scripts ?? {};
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-  const scriptText = Object.values(scripts).join(" ");
-  const tokens = new Set(tokenizeScript(scriptText));
-  const binToPackage = /* @__PURE__ */ new Map();
-  for (const dep of allDeps) {
-    const bins = getBinNames(location, dep);
-    for (const bin of bins) {
-      binToPackage.set(bin, dep);
-    }
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  for (const token of tokens) {
-    const baseName = getBasePackageName(token);
-    if (allDeps.includes(baseName)) {
-      referenced.add(baseName);
-    }
-    const pkg = binToPackage.get(token);
-    if (pkg) {
-      referenced.add(pkg);
-    }
-  }
-  return referenced;
-}
-
-// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
-var shellCommandFunctions = /* @__PURE__ */ new Set(["execSync", "exec"]);
-var directExecFunctions = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync"]);
-var allExecFunctions = /* @__PURE__ */ new Set([...shellCommandFunctions, ...directExecFunctions]);
-function getCommandTokensFromFile(filePath) {
-  const tokens = /* @__PURE__ */ new Set();
-  let sourceCode;
-  try {
-    sourceCode = fs8.readFileSync(filePath, "utf8");
-  } catch {
-    return tokens;
-  }
-  const isMjsFile = filePath.endsWith(".mjs");
-  const sourceFile = ts2.createSourceFile(
-    path7.basename(filePath),
-    sourceCode,
-    ts2.ScriptTarget.Latest,
-    true,
-    isMjsFile ? ts2.ScriptKind.JS : void 0
-  );
-  function visit(node) {
-    if (ts2.isCallExpression(node) && node.arguments.length > 0) {
-      const fnName = getFunctionName(node.expression);
-      if (fnName && allExecFunctions.has(fnName)) {
-        const firstArg = node.arguments[0];
-        if (ts2.isStringLiteral(firstArg) || ts2.isNoSubstitutionTemplateLiteral(firstArg)) {
-          const value = firstArg.text;
-          if (shellCommandFunctions.has(fnName)) {
-            for (const token of tokenizeScript(value)) {
-              tokens.add(token);
-            }
-          } else {
-            tokens.add(value);
-          }
-        } else if (ts2.isTemplateExpression(firstArg)) {
-          const head = firstArg.head.text;
-          if (head) {
-            for (const token of tokenizeScript(head)) {
-              tokens.add(token);
-            }
-          }
-        }
-      }
-    }
-    ts2.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return tokens;
-}
-function getFunctionName(expr) {
-  if (ts2.isIdentifier(expr)) {
-    return expr.text;
-  }
-  if (ts2.isPropertyAccessExpression(expr) && ts2.isIdentifier(expr.name)) {
-    return expr.name.text;
-  }
-  return void 0;
-}
-function getCliReferencedPackagesFromFiles(allFiles, location, allDeps) {
-  const allTokens = /* @__PURE__ */ new Set();
-  for (const file of allFiles) {
-    for (const token of getCommandTokensFromFile(file)) {
-      allTokens.add(token);
-    }
-  }
-  if (allTokens.size === 0) return /* @__PURE__ */ new Set();
-  const binToPackage = /* @__PURE__ */ new Map();
-  for (const dep of allDeps) {
-    for (const bin of getBinNames(location, dep)) {
-      binToPackage.set(bin, dep);
-    }
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  for (const token of allTokens) {
-    const baseName = getBasePackageName(token);
-    if (allDeps.includes(baseName)) {
-      referenced.add(baseName);
-    }
-    const pkg = binToPackage.get(token);
-    if (pkg) {
-      referenced.add(pkg);
-    }
-  }
-  return referenced;
-}
-
-// src/actions/deplint/implicitDevDependencies.ts
-import fs9 from "fs";
-var hasFileWithExtension = (files, extensions) => files.some((f) => extensions.some((ext) => f.endsWith(ext)));
-var tsExtensions = [".ts", ".tsx", ".mts", ".cts"];
-var hasTypescriptFiles = ({ allFiles }) => hasFileWithExtension(allFiles, tsExtensions);
-var decoratorPattern = /^\s*@[a-zA-Z]\w*/m;
-var hasDecorators = ({ allFiles }) => allFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
-  try {
-    const content = fs9.readFileSync(file, "utf8");
-    return decoratorPattern.test(content);
-  } catch {
-    return false;
-  }
-});
-var importPlugins = /* @__PURE__ */ new Set(["eslint-plugin-import-x", "eslint-plugin-import"]);
-function hasImportPlugin({ location, allDependencies }) {
-  if (allDependencies.some((d) => importPlugins.has(d))) return true;
-  for (const dep of allDependencies) {
-    const pkgPath = findDepPackageJson(location, dep);
-    if (!pkgPath) continue;
-    try {
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
-      const transitiveDeps = [
-        ...Object.keys(pkg.dependencies ?? {}),
-        ...Object.keys(pkg.peerDependencies ?? {})
+  versionBump(type) {
+    if (type === "prerelease") {
+      return [
+        ["yarn", "workspaces foreach --all version patch --deferred --prerelease"]
       ];
-      if (transitiveDeps.some((d) => importPlugins.has(d))) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-var hasVitest = ({ allDependencies }) => allDependencies.includes("vitest");
-var rules = [
-  {
-    package: "typescript",
-    isNeeded: hasTypescriptFiles
-  },
-  {
-    package: "eslint-import-resolver-typescript",
-    isNeeded: (context) => hasTypescriptFiles(context) && context.allDependencies.includes("eslint") && hasImportPlugin(context)
-  },
-  {
-    package: "tslib",
-    isNeeded: hasDecorators
-  },
-  {
-    package: "@vitest/coverage-v8",
-    isNeeded: hasVitest
-  }
-];
-function getImplicitDevDependencies(context) {
-  const implicit = /* @__PURE__ */ new Set();
-  for (const rule of rules) {
-    if (rule.isNeeded(context)) {
-      implicit.add(rule.package);
-    }
-  }
-  return implicit;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-var allExternalImports = ({
-  externalAllImports,
-  externalDistImports,
-  externalDistTypeImports
-}) => {
-  return /* @__PURE__ */ new Set([
-    ...externalAllImports,
-    ...externalDistImports,
-    ...externalDistTypeImports
-  ]);
-};
-function isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs) {
-  if (implicitDeps.has(dep)) return true;
-  if (requiredPeers.has(dep)) return true;
-  if (scriptRefs.has(dep)) return true;
-  if (cliRefs.has(dep)) return true;
-  if (dep.startsWith("@types/")) {
-    const baseName = dep.replace(/^@types\//, "");
-    return allImports.has(baseName) || allImports.has(dep) || implicitDeps.has(baseName);
-  }
-  return allImports.has(dep);
-}
-function getUnusedDevDependencies({ name, location }, {
-  devDependencies,
-  dependencies,
-  peerDependencies
-}, sourceParams, fileContext, exclude) {
-  const allImports = allExternalImports(sourceParams);
-  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies];
-  const implicitDeps = getImplicitDevDependencies({
-    ...fileContext,
-    allDependencies: allDeps,
-    location
-  });
-  const requiredPeers = getRequiredPeerDependencies(location, allDeps);
-  const scriptRefs = getScriptReferencedPackages(location, allDeps);
-  const cliRefs = getCliReferencedPackagesFromFiles(fileContext.allFiles, location, allDeps);
-  let unusedDevDependencies = 0;
-  for (const dep of devDependencies) {
-    if (exclude?.has(dep)) continue;
-    if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
-    if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs)) {
-      unusedDevDependencies++;
-      console.log(`[${chalk23.blue(name)}] Unused devDependency in package.json: ${chalk23.red(dep)}`);
-    }
-  }
-  if (unusedDevDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk23.yellow(packageLocation)}
-`);
-  }
-  return unusedDevDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
-import chalk24 from "chalk";
-function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }, exclude) {
-  let unusedDependencies = 0;
-  for (const dep of peerDependencies) {
-    if (exclude?.has(dep)) continue;
-    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
-      unusedDependencies++;
-      if (dependencies.includes(dep)) {
-        console.log(`[${chalk24.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk24.red(dep)}`);
-      } else {
-        console.log(`[${chalk24.blue(name)}] Unused peerDependency in package.json: ${chalk24.red(dep)}`);
-      }
-    }
-  }
-  if (unusedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk24.yellow(packageLocation)}
-`);
-  }
-  return unusedDependencies;
-}
-
-// src/actions/deplint/checkPackage/checkPackage.ts
-function logVerbose(name, location, allFiles, distFiles, tsconfigExtends) {
-  console.info(`Checking package: ${name} at ${location}`);
-  console.info(`All files: ${allFiles.length}, Distribution files: ${distFiles.length}`);
-  for (const file of allFiles) {
-    console.info(`File: ${file}`);
-  }
-  for (const file of distFiles) {
-    console.info(`Distribution file: ${file}`);
-  }
-  for (const ext of tsconfigExtends) {
-    console.info(`Tsconfig extends: ${ext}`);
-  }
-}
-function checkPackage({
-  name,
-  location,
-  deps = false,
-  devDeps = false,
-  exclude,
-  peerDeps = false,
-  verbose = false
-}) {
-  const { allFiles, distFiles } = findFiles(location);
-  const tsconfigExtends = getExtendsFromTsconfigs(location);
-  if (verbose) {
-    logVerbose(name, location, allFiles, distFiles, tsconfigExtends);
-  }
-  const checkDeps = deps || !(deps || devDeps || peerDeps);
-  const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
-  const checkPeerDeps = peerDeps;
-  const sourceParams = getExternalImportsFromFiles({
-    allFiles,
-    distFiles,
-    tsconfigExtends
-  });
-  const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
-  const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
-  const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const fileContext = { allFiles, distFiles };
-  const unusedDevDependencies = checkDevDeps ? getUnusedDevDependencies({ name, location }, packageParams, sourceParams, fileContext, exclude) : 0;
-  const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
-  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedDevDependencies + unusedPeerDependencies;
-  return totalErrors;
-}
-
-// src/actions/deplint/deplint.ts
-var deplint = async ({
-  pkg,
-  deps,
-  devDeps,
-  peerDeps,
-  verbose,
-  cliExclude
-}) => {
-  const config2 = await loadConfig();
-  const exclude = /* @__PURE__ */ new Set([
-    ...config2.deplint?.exclude ?? [],
-    ...cliExclude ?? []
-  ]);
-  let totalErrors = 0;
-  if (pkg === void 0) {
-    const workspaces = yarnWorkspaces();
-    console.info("Deplint Started...");
-    for (const workspace of workspaces) {
-      totalErrors += checkPackage({
-        ...workspace,
-        deps,
-        devDeps,
-        exclude,
-        peerDeps,
-        verbose
-      });
-    }
-  } else {
-    const { location, name } = yarnWorkspace(pkg);
-    console.info(`Running Deplint for ${name}`);
-    totalErrors += checkPackage({
-      name,
-      location,
-      devDeps,
-      deps,
-      exclude,
-      peerDeps,
-      verbose
-    });
-  }
-  if (totalErrors > 0) {
-    console.warn(`Deplint: Found ${chalk25.red(totalErrors)} dependency problems. ${chalk25.red("\u2716")}`);
-  } else {
-    console.info(`Deplint: Found no dependency problems. ${chalk25.green("\u2714")}`);
-  }
-  return 0;
-};
-
-// src/actions/deploy.ts
-import { readFileSync as readFileSync12 } from "fs";
-var privatePackageExcludeList = () => {
-  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
-    workspace,
-    JSON.parse(readFileSync12(`${workspace.location}/package.json`, { encoding: "utf8" }))
-  ]);
-  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
-  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
-  return excludeList;
-};
-var deploy = () => {
-  const excludeList = privatePackageExcludeList();
-  if (excludeList.length > 0) {
-    console.log("Excluding private packages from deployment:", excludeList);
-  }
-  return runSteps("Deploy [Patch]", [
-    ["yarn", "workspaces foreach --all version patch --deferred"],
-    ["yarn", "xy clean"],
-    ["yarn", "xy build"],
-    ["yarn", "version apply --all"]
-  ]);
-};
-
-// src/actions/deploy-major.ts
-import { readFileSync as readFileSync13 } from "fs";
-var privatePackageExcludeList2 = () => {
-  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
-    workspace,
-    JSON.parse(readFileSync13(`${workspace.location}/package.json`, { encoding: "utf8" }))
-  ]);
-  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
-  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
-  return excludeList;
-};
-var deployMajor = () => {
-  const excludeList = privatePackageExcludeList2();
-  if (excludeList.length > 0) {
-    console.log("Excluding private packages from deployment:", excludeList);
-  }
-  return runSteps("Deploy [Major]", [
-    ["yarn", "workspaces foreach --all version major --deferred"],
-    ["yarn", "xy clean"],
-    ["yarn", "xy build"],
-    ["yarn", "version apply --all"]
-  ]);
-};
-
-// src/actions/deploy-minor.ts
-import { readFileSync as readFileSync14 } from "fs";
-var privatePackageExcludeList3 = () => {
-  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
-    workspace,
-    JSON.parse(readFileSync14(`${workspace.location}/package.json`, { encoding: "utf8" }))
-  ]);
-  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
-  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
-  return excludeList;
-};
-var deployMinor = () => {
-  const excludeList = privatePackageExcludeList3();
-  if (excludeList.length > 0) {
-    console.log("Excluding private packages from deployment:", excludeList);
-  }
-  return runSteps("Deploy [Minor]", [
-    ["yarn", "workspaces foreach --all version minor --deferred"],
-    ["yarn", "xy clean"],
-    ["yarn", "xy build"],
-    ["yarn", "version apply --all"]
-  ]);
-};
-
-// src/actions/deploy-next.ts
-import { readFileSync as readFileSync15 } from "fs";
-var privatePackageExcludeList4 = () => {
-  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
-    workspace,
-    JSON.parse(readFileSync15(`${workspace.location}/package.json`, { encoding: "utf8" }))
-  ]);
-  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
-  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
-  return excludeList;
-};
-var deployNext = () => {
-  const excludeList = privatePackageExcludeList4();
-  if (excludeList.length > 0) {
-    console.log("Excluding private packages from deployment:", excludeList);
-  }
-  return runSteps("Deploy [Next]", [
-    ["yarn", "workspaces foreach --all version minor --deferred"],
-    ["yarn", "xy clean"],
-    ["yarn", "xy build"],
-    ["yarn", "version apply --all --prerelease"]
-  ]);
-};
-
-// src/actions/dupdeps.ts
-import chalk26 from "chalk";
-var dupdeps = () => {
-  console.log(chalk26.green("Checking all Dependencies for Duplicates"));
-  const pkg = parsedPackageJSON();
-  const allDependencies = { ...pkg?.dependencies, ...pkg?.devDependencies };
-  const dependencies = Object.keys(allDependencies);
-  return detectDuplicateDependencies(dependencies);
-};
-
-// src/actions/lint.ts
-import chalk27 from "chalk";
-var lintPackage = ({
-  pkg,
-  fix: fix2,
-  verbose
-}) => {
-  console.log(chalk27.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
-  const start = Date.now();
-  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
-    ["yarn", [
-      "workspace",
-      pkg,
-      "run",
-      fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
-    ]]
-  ]);
-  console.log(chalk27.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk27.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk27.gray("seconds")}`));
-  return result;
-};
-var lint = ({
-  pkg,
-  verbose,
-  incremental,
-  fix: fix2
-} = {}) => {
-  return pkg === void 0 ? lintAllPackages({
-    verbose,
-    incremental,
-    fix: fix2
-  }) : lintPackage({
-    pkg,
-    fix: fix2,
-    verbose
-  });
-};
-var lintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk27.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
-  const start = Date.now();
-  const fixOptions = fix2 ? ["--fix"] : [];
-  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
-    ["yarn", ["eslint", "--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
-  ]);
-  console.log(chalk27.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk27.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk27.gray("seconds")}`));
-  return result;
-};
-
-// src/actions/fix.ts
-var fix = (params) => {
-  return lint({ ...params, fix: true });
-};
-
-// src/actions/gen-docs.ts
-var genDocs = ({ pkg, incremental }) => {
-  return pkg ? genDocsPackage({ pkg }) : genDocsAll({ incremental });
-};
-var genDocsPackage = ({ pkg }) => {
-  const steps = [["yarn", ["workspace", pkg, "run", "package-gen-docs"]]];
-  return runSteps(`GenDocs [${pkg}]`, [...steps]);
-};
-var genDocsAll = ({ incremental }) => {
-  const incrementalOptions = incremental ? ["--since", "-pA"] : ["-pA"];
-  const steps = [["yarn", ["workspaces", "foreach", ...incrementalOptions, "run", "package-gen-docs"]]];
-  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [...steps]);
-};
-
-// src/actions/gitignore.ts
-import { unlinkSync as unlinkSync4 } from "fs";
-import chalk28 from "chalk";
-var COMMENT_PREFIX = "#";
-var isComment = (line) => line.startsWith(COMMENT_PREFIX);
-var isNegation = (line) => line.startsWith("!");
-function parseTemplateSections(lines) {
-  const sections = [];
-  let current = [];
-  for (const line of lines) {
-    if (isComment(line)) {
-      if (current.length > 0) {
-        sections.push(current);
-      }
-      current = [line];
-    } else {
-      current.push(line);
-    }
-  }
-  if (current.length > 0) {
-    sections.push(current);
-  }
-  return sections;
-}
-function mergeWithTemplate(existing, templateContent) {
-  const templateLines = templateContent.split("\n").filter((line) => line.trim().length > 0);
-  const sections = parseTemplateSections(templateLines);
-  const existingEntries = new Set(existing.filter((line) => !isComment(line)));
-  const templateEntries = new Set(templateLines.filter((line) => !isComment(line)));
-  const customEntries = [...existingEntries].filter((entry) => !templateEntries.has(entry));
-  const result = [];
-  for (const section of sections) {
-    for (const line of section) {
-      result.push(line);
-    }
-    result.push("");
-  }
-  if (customEntries.length > 0) {
-    result.push("# Custom");
-    const sorted = [...union(customEntries, [])].toSorted((a, b) => {
-      if (isNegation(a) && !isNegation(b)) return 1;
-      if (!isNegation(a) && isNegation(b)) return -1;
-      return a.localeCompare(b);
-    });
-    for (const entry of sorted) {
-      result.push(entry);
-    }
-    result.push("");
-  }
-  return result;
-}
-function removePackageGitignores(cwd5) {
-  let removed = 0;
-  const workspaces = yarnWorkspaces();
-  for (const { location } of workspaces) {
-    if (location === ".") continue;
-    const filePath = `${cwd5}/${location}/.gitignore`;
-    try {
-      unlinkSync4(filePath);
-      console.log(chalk28.yellow(`  Removed ${location}/.gitignore`));
-      removed++;
-    } catch {
-    }
-  }
-  return removed;
-}
-var gitignoreGen = gitignore;
-function gitignore() {
-  console.log(chalk28.green("Generate .gitignore"));
-  const cwd5 = INIT_CWD() ?? ".";
-  const gitignorePath = `${cwd5}/.gitignore`;
-  try {
-    const templateContent = gitignoreTemplate();
-    const existing = readNonEmptyLines(gitignorePath);
-    const merged = mergeWithTemplate(existing, templateContent);
-    writeLines(gitignorePath, merged);
-    console.log(chalk28.green("  Root .gitignore updated"));
-    const removed = removePackageGitignores(cwd5);
-    if (removed > 0) {
-      console.log(chalk28.green(`  Removed ${removed} package .gitignore file(s)`));
-    }
-    return 0;
-  } catch (ex) {
-    const error = ex;
-    console.error(chalk28.red(`Generate .gitignore failed: ${error.message}`));
-    return 1;
-  }
-}
-
-// src/actions/gitlint.ts
-import chalk29 from "chalk";
-import ParseGitConfig from "parse-git-config";
-var gitlint = () => {
-  console.log(`
-Gitlint Start [${process.cwd()}]
-`);
-  let valid = 0;
-  let warnings = 0;
-  const errors = 0;
-  const gitConfig = ParseGitConfig.sync();
-  const warn = (message) => {
-    console.warn(chalk29.yellow(`Warning: ${message}`));
-    warnings++;
-  };
-  if (gitConfig.core.ignorecase) {
-    warn("Please set core.ignorecase to FALSE in .git/config file [run yarn gitlint-fix]");
-  } else {
-    valid++;
-  }
-  if (gitConfig.core.autocrlf === false) {
-    valid++;
-  } else {
-    warn("Please set core.autocrlf to FALSE in .git/config file [run yarn gitlint-fix]");
-  }
-  if (gitConfig.core.eol === "lf") {
-    valid++;
-  } else {
-    warn('Please set core.eol to "lf" in .git/config file [run yarn gitlint-fix]');
-  }
-  const resultMessages = [];
-  if (valid > 0) {
-    resultMessages.push(chalk29.green(`Passed: ${valid}`));
-  }
-  if (warnings > 0) {
-    resultMessages.push(chalk29.yellow(`Warnings: ${warnings}`));
-  }
-  if (errors > 0) {
-    resultMessages.push(chalk29.red(` Errors: ${errors}`));
-  }
-  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
-`);
-  return warnings + errors === 0 ? 1 : 0;
-};
-
-// src/actions/gitlint-fix.ts
-import { execSync as execSync3 } from "child_process";
-import chalk30 from "chalk";
-import ParseGitConfig2 from "parse-git-config";
-var gitlintFix = () => {
-  console.log(`
-Gitlint Fix Start [${process.cwd()}]
-`);
-  const gitConfig = ParseGitConfig2.sync();
-  if (gitConfig.core.ignorecase) {
-    execSync3("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk30.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
-  }
-  if (gitConfig.core.autocrlf !== false) {
-    execSync3("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk30.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
-  }
-  if (gitConfig.core.eol !== "lf") {
-    execSync3("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk30.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
-  }
-  return 1;
-};
-
-// src/actions/knip.ts
-var knip = () => {
-  return runSteps("Knip", [["yarn", ["knip", "--dependencies", "--no-exit-code"]]]);
-};
-
-// src/actions/license.ts
-import chalk31 from "chalk";
-import { init } from "license-checker";
-var license = async (pkg) => {
-  const workspaces = yarnWorkspaces();
-  const workspaceList = workspaces.filter(({ name }) => {
-    return pkg === void 0 || name === pkg;
-  });
-  const exclude = /* @__PURE__ */ new Set([
-    "MIT",
-    "MIT*",
-    "ISC",
-    "Apache-2.0",
-    "BSD",
-    "BSD*",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "CC-BY-4.0",
-    "Unlicense",
-    "CC-BY-3.0",
-    "CC0-1.0",
-    "LGPL-3.0-only",
-    "LGPL-3.0",
-    "LGPL-3.0-or-later",
-    "Python-2.0"
-  ]);
-  console.log(chalk31.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(chalk31.red(`License Checker [${name}] Error`));
-            console.error(chalk31.gray(error));
-            console.log("\n");
-            resolve(1);
-          } else {
-            console.log(chalk31.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];
-              for (let license2 of licenses) {
-                if (license2) {
-                  const processedLicense = license2[0] === "(" && license2.at(-1) === ")" ? license2.slice(1, -2) : license2;
-                  const orLicenses = processedLicense.split(" OR ");
-                  let orLicenseFound = false;
-                  for (const orLicense of orLicenses) {
-                    if (exclude.has(orLicense)) {
-                      orLicenseFound = true;
-                    }
-                  }
-                  if (!orLicenseFound) {
-                    count++;
-                    console.warn(chalk31.yellow(`${name2}: Package License not allowed [${license2}]`));
-                  }
-                }
-              }
-            }
-            console.log("\n");
-            resolve(count);
-          }
-        });
-      });
-    })
-  )).reduce((prev, value) => prev || value, 0);
-};
-
-// src/actions/lintlint.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
-import PATH10 from "path";
-import chalk32 from "chalk";
-import { findUp } from "find-up";
-function parseRuleValue(value) {
-  if (typeof value === "string") {
-    return { level: value };
-  }
-  if (typeof value === "number") {
-    return { level: String(value) };
-  }
-  if (Array.isArray(value) && value.length > 0) {
-    return {
-      level: String(value[0]),
-      options: value.length > 1 ? value.slice(1) : void 0
-    };
-  }
-  return void 0;
-}
-function normalizeLevel(level) {
-  if (level === "0" || level === "off") return "off";
-  if (level === "1" || level === "warn") return "warn";
-  if (level === "2" || level === "error") return "error";
-  return level;
-}
-function rulesMatch(a, b) {
-  if (normalizeLevel(a.level) !== normalizeLevel(b.level)) return false;
-  return JSON.stringify(a.options) === JSON.stringify(b.options);
-}
-function formatRule(entry) {
-  if (entry.options) {
-    return JSON.stringify([entry.level, ...entry.options]);
-  }
-  return JSON.stringify([entry.level]);
-}
-function mergeRulesFromBlocks(blocks) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    if (!block.rules) continue;
-    for (const [name, value] of Object.entries(block.rules)) {
-      const parsed = parseRuleValue(value);
-      if (parsed) merged.set(name, parsed);
-    }
-  }
-  return merged;
-}
-function detectSharedPackage(source) {
-  if (source.includes("@xylabs/eslint-config-react-flat")) return "@xylabs/eslint-config-react-flat";
-  if (source.includes("@xylabs/eslint-config-flat")) return "@xylabs/eslint-config-flat";
-  return void 0;
-}
-function extractLocalRuleBlocks(source) {
-  const blocks = [];
-  const ruleBlockRegex = /\{\s*(?:files\s*:\s*\[.*?\]\s*,\s*)?rules\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
-  let match;
-  while ((match = ruleBlockRegex.exec(source)) !== null) {
-    blocks.push(match[1]);
-  }
-  return blocks;
-}
-function extractRulesFromSourceBlocks(blocks) {
-  const rules2 = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const ruleRegex = /['"]([^'"]+)['"]\s*:\s*(\[[\s\S]*?\](?=\s*,|\s*$))/gm;
-    let match;
-    while ((match = ruleRegex.exec(block)) !== null) {
-      rules2.set(match[1], match[2]);
-    }
-  }
-  return rules2;
-}
-async function resolveSharedConfig(configDir, sharedPkg) {
-  try {
-    const sharedModule = await import(sharedPkg);
-    const config2 = sharedModule.config ?? sharedModule.default;
-    if (Array.isArray(config2)) return config2;
-    return [];
-  } catch {
-    const distPath = PATH10.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
-    try {
-      const sharedModule = await import(distPath);
-      const config2 = sharedModule.config ?? sharedModule.default;
-      if (Array.isArray(config2)) return config2;
-    } catch {
-      const neutralPath = PATH10.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
-      const sharedModule = await import(neutralPath);
-      const config2 = sharedModule.config ?? sharedModule.default;
-      if (Array.isArray(config2)) return config2;
-    }
-    return [];
-  }
-}
-async function loadSharedRules(configDir, sharedPkg, verbose) {
-  const sharedBlocks = await resolveSharedConfig(configDir, sharedPkg);
-  const sharedRules = mergeRulesFromBlocks(sharedBlocks);
-  if (verbose) {
-    console.log(chalk32.gray(`Shared config defines ${sharedRules.size} rules`));
-  }
-  if (sharedRules.size === 0) {
-    console.error(chalk32.red("Could not load rules from shared config. Is it installed and built?"));
-    return void 0;
-  }
-  return sharedRules;
-}
-async function loadLocalRules(eslintConfigPath, source, verbose) {
-  const localModule = await import(eslintConfigPath);
-  const localConfig = localModule.default ?? localModule;
-  const localBlocks = Array.isArray(localConfig) ? localConfig : [localConfig];
-  const resolved = mergeRulesFromBlocks(localBlocks);
-  const localRuleBlocks = extractLocalRuleBlocks(source);
-  const explicit = extractRulesFromSourceBlocks(localRuleBlocks);
-  if (verbose) {
-    console.log(chalk32.gray(`Local config has ${explicit.size} explicit rule setting(s)`));
-  }
-  return { explicit, resolved };
-}
-function compareRules(explicitRuleNames, allResolvedRules, sharedRules) {
-  const redundant = [];
-  const overrides = [];
-  const additions = [];
-  for (const ruleName of explicitRuleNames.keys()) {
-    const resolvedEntry = allResolvedRules.get(ruleName);
-    const sharedEntry = sharedRules.get(ruleName);
-    if (!resolvedEntry) continue;
-    if (!sharedEntry) {
-      additions.push({ local: resolvedEntry, rule: ruleName });
-    } else if (rulesMatch(resolvedEntry, sharedEntry)) {
-      redundant.push({
-        local: resolvedEntry,
-        rule: ruleName,
-        shared: sharedEntry
-      });
-    } else {
-      overrides.push({
-        local: resolvedEntry,
-        rule: ruleName,
-        shared: sharedEntry
-      });
-    }
-  }
-  return {
-    additions,
-    overrides,
-    redundant
-  };
-}
-function reportResults({
-  additions,
-  overrides,
-  redundant
-}, verbose) {
-  if (redundant.length > 0) {
-    console.log(chalk32.yellow(`
-${redundant.length} redundant rule(s) (same as shared config \u2014 can be removed):`));
-    for (const { rule, local } of redundant) {
-      console.log(chalk32.yellow(`  ${rule}: ${formatRule(local)}`));
-    }
-  }
-  if (overrides.length > 0) {
-    console.log(chalk32.cyan(`
-${overrides.length} rule override(s) (different from shared config):`));
-    for (const {
-      rule,
-      local,
-      shared
-    } of overrides) {
-      console.log(chalk32.cyan(`  ${rule}:`));
-      console.log(chalk32.gray(`    shared: ${formatRule(shared)}`));
-      console.log(chalk32.white(`    local:  ${formatRule(local)}`));
     }
-  }
-  if (additions.length > 0 && verbose) {
-    console.log(chalk32.gray(`
-${additions.length} local addition(s) (not in shared config):`));
-    for (const { rule, local } of additions) {
-      console.log(chalk32.gray(`  ${rule}: ${formatRule(local)}`));
-    }
-  }
-  if (redundant.length === 0 && overrides.length === 0) {
-    console.log(chalk32.green("No redundant or overridden rules found"));
-  }
-}
-function fixRedundantRules(eslintConfigPath, source, redundant) {
-  let updated = source;
-  for (const { rule } of redundant) {
-    const escaped = rule.replaceAll("/", String.raw`\/`);
-    const pattern = new RegExp(String.raw`[ \t]*['"]${escaped}['"]\s*:\s*\[[^\]]*\],?[ \t]*\n?`, "g");
-    updated = updated.replace(pattern, "");
-  }
-  updated = updated.replaceAll(/\n{3,}/g, "\n\n");
-  if (updated !== source) {
-    writeFileSync6(eslintConfigPath, updated, "utf8");
-    console.log(chalk32.green(`
-Fixed: removed ${redundant.length} redundant rule(s)`));
-  }
-}
-async function lintlint({ fix: fix2, verbose } = {}) {
-  const eslintConfigPath = await findUp("eslint.config.mjs");
-  if (!eslintConfigPath) {
-    console.error(chalk32.red("No eslint.config.mjs found"));
-    return 1;
-  }
-  const configDir = PATH10.dirname(eslintConfigPath);
-  if (verbose) {
-    console.log(chalk32.gray(`Found config: ${eslintConfigPath}`));
-  }
-  const source = readFileSync16(eslintConfigPath, "utf8");
-  const sharedPkg = detectSharedPackage(source);
-  if (!sharedPkg) {
-    console.log(chalk32.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
-    return 0;
-  }
-  if (verbose) {
-    console.log(chalk32.gray(`Shared package: ${sharedPkg}`));
-  }
-  const sharedRules = await loadSharedRules(configDir, sharedPkg, !!verbose);
-  if (!sharedRules) return 1;
-  const { explicit, resolved } = await loadLocalRules(eslintConfigPath, source, !!verbose);
-  const results = compareRules(explicit, resolved, sharedRules);
-  reportResults(results, !!verbose);
-  if (results.redundant.length > 0 && fix2) {
-    fixRedundantRules(eslintConfigPath, source, results.redundant);
-  }
-  return results.redundant.length > 0 && !fix2 ? 1 : 0;
-}
-
-// src/actions/npmignore-gen.ts
-var filename = ".npmignore";
-var npmignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
-
-// src/actions/package/clean-outputs.ts
-import path8 from "path";
-import chalk33 from "chalk";
-var packageCleanOutputs = () => {
-  const pkg = process.env.INIT_CWD ?? ".";
-  const pkgName = process.env.npm_package_name;
-  const folders = [path8.join(pkg, "dist"), path8.join(pkg, "build"), path8.join(pkg, "docs")];
-  console.log(chalk33.green(`Cleaning Outputs [${pkgName}]`));
-  for (let folder of folders) {
-    deleteGlob(folder);
-  }
-  return 0;
-};
-
-// src/actions/package/clean-typescript.ts
-import path9 from "path";
-import chalk34 from "chalk";
-var packageCleanTypescript = () => {
-  const pkg = process.env.INIT_CWD ?? ".";
-  const pkgName = process.env.npm_package_name;
-  console.log(chalk34.green(`Cleaning Typescript [${pkgName}]`));
-  const files = [path9.join(pkg, "*.tsbuildinfo"), path9.join(pkg, ".tsconfig.*"), path9.join(pkg, ".eslintcache")];
-  for (let file of files) {
-    deleteGlob(file);
-  }
-  return 0;
-};
-
-// src/actions/package/clean.ts
-var packageClean = async () => {
-  return (await Promise.all([packageCleanOutputs(), packageCleanTypescript()])).reduce((prev, value) => prev + value, 0);
-};
-
-// src/actions/package/compile/compile.ts
-import chalk39 from "chalk";
-
-// src/actions/package/compile/packageCompileTsup.ts
-import chalk38 from "chalk";
-import { build as build2, defineConfig } from "tsup";
-
-// src/actions/package/compile/inputs.ts
-import chalk35 from "chalk";
-import { glob as glob2 } from "glob";
-var getAllInputs = (srcDir, verbose = false) => {
-  return [...glob2.sync(`${srcDir}/**/*.ts`, { posix: true }).map((file) => {
-    const result = file.slice(Math.max(0, srcDir.length + 1));
-    if (verbose) {
-      console.log(chalk35.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
-    }
-    return result;
-  }), ...glob2.sync(`${srcDir}/**/*.tsx`, { posix: true }).map((file) => {
-    const result = file.slice(Math.max(0, srcDir.length + 1));
-    if (verbose) {
-      console.log(chalk35.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
-    }
-    return result;
-  })];
-};
-
-// src/actions/package/compile/buildEntries.ts
-var isSpecOrStory = (entry) => {
-  return entry.includes(".spec.") || entry.includes(".stories.") || entry.startsWith("spec/") || entry.includes("/spec/") || entry.startsWith("stories/") || entry.includes("/stories/") || entry === "spec.ts" || entry.endsWith("/spec.ts") || entry === "stories.ts" || entry.endsWith("/stories.ts");
-};
-var buildEntries = (srcDir, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
-  let entries = [];
-  switch (entryMode) {
-    case "platform": {
-      entries = ["index-node.ts", "index-browser.ts"];
-      break;
-    }
-    case "all": {
-      entries = (excludeSpecAndStories ? getAllInputs(srcDir).filter((entry) => !isSpecOrStory(entry)) : getAllInputs(srcDir)).filter((entry) => !entry.endsWith(".d.ts"));
-      break;
-    }
-    case "custom": {
-      entries = [];
-      break;
-    }
-    default: {
-      entries = ["index.ts"];
-      break;
-    }
-  }
-  if (typeof options !== "boolean" && Array.isArray(options?.entry)) {
-    entries.push(...options.entry);
-  }
-  if (verbose) console.log(`buildEntries [${entryMode}] ${entries.length}`);
-  return entries;
-};
-
-// src/actions/package/compile/deepMerge.ts
-function deepMerge(target, source) {
-  if (!source || typeof source !== "object") return target;
-  for (const key of Object.keys(source)) {
-    if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
-      if (!target[key] || typeof target[key] !== "object") {
-        target[key] = {};
-      }
-      deepMerge(target[key], source[key]);
-    } else {
-      target[key] = source[key];
-    }
-  }
-  return target;
-}
-function deepMergeObjects(objects) {
-  const result = {};
-  for (const obj of objects) {
-    deepMerge(result, obj);
-  }
-  return result;
-}
-
-// src/actions/package/compile/packageCompileTsc.ts
-import { cwd as cwd2 } from "process";
-import chalk36 from "chalk";
-import { createProgramFromConfig } from "tsc-prog";
-import ts3, {
-  DiagnosticCategory,
-  formatDiagnosticsWithColorAndContext,
-  getPreEmitDiagnostics,
-  sys
-} from "typescript";
-
-// src/actions/package/compile/getCompilerOptions.ts
-import { cwd } from "process";
-import deepmerge2 from "deepmerge";
-import { getTsconfig } from "get-tsconfig";
-var getCompilerOptions = (options = {}, fileName = "tsconfig.json") => {
-  const resolvedTsConfigCompilerOptions = getTsconfig(cwd(), fileName)?.config?.compilerOptions ?? {};
-  return deepmerge2(resolvedTsConfigCompilerOptions, options);
-};
-
-// src/actions/package/compile/packageCompileTsc.ts
-var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
-  const pkg = process.env.INIT_CWD ?? cwd2();
-  if (verbose) {
-    console.log(chalk36.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
-  }
-  const configFilePath = ts3.findConfigFile(
-    "./",
-    // search path
-    ts3.sys.fileExists,
-    "tsconfig.json"
-  );
-  if (configFilePath === void 0) {
-    throw new Error("Could not find tsconfig.json");
-  }
-  const compilerOptions = {
-    ...getCompilerOptions({
-      removeComments: false,
-      skipDefaultLibCheck: true,
-      skipLibCheck: true,
-      sourceMap: false
-    }),
-    ...compilerOptionsParam,
-    outDir: `${outDir}/${platform}`,
-    emitDeclarationOnly: true,
-    noEmit: false
-  };
-  console.log(chalk36.cyan(`Validating Files: ${entries.length}`));
-  if (verbose) {
-    for (const entry of entries) {
-      console.log(chalk36.grey(`Validating: ${entry}`));
-    }
-  }
-  try {
-    if (entries.length > 0) {
-      const program = createProgramFromConfig({
-        configFilePath,
-        basePath: pkg ?? cwd2(),
-        compilerOptions,
-        files: entries.map((entry) => `${srcDir}/${entry}`),
-        include: [`${srcDir}/**/*.*`]
-      });
-      const diagnostics = getPreEmitDiagnostics(program);
-      if (diagnostics.length > 0) {
-        const formattedDiagnostics = formatDiagnosticsWithColorAndContext(
-          diagnostics,
-          {
-            getCanonicalFileName: (fileName) => fileName,
-            getCurrentDirectory: () => srcDir,
-            getNewLine: () => sys.newLine
-          }
-        );
-        console.error(formattedDiagnostics);
-      }
-      const nonEmitPatterns = [".stories.", "/stories/", "/stories.", ".spec.", "/spec/", "/spec.", ".example."];
-      program.emit(void 0, (fileName, text, writeByteOrderMark) => {
-        if (nonEmitPatterns.some((pattern) => fileName.includes(pattern))) {
-          return;
-        }
-        ts3.sys.writeFile(fileName, text, writeByteOrderMark);
-      });
-      return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0);
-    }
-    return 0;
-  } finally {
-    if (verbose) {
-      console.log(chalk36.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
-    }
-  }
-};
-
-// src/actions/package/compile/packageCompileTscTypes.ts
-import path10 from "path";
-import { cwd as cwd3 } from "process";
-import chalk37 from "chalk";
-import { rollup } from "rollup";
-import dts from "rollup-plugin-dts";
-import nodeExternals from "rollup-plugin-node-externals";
-var ignoredWarningCodes = /* @__PURE__ */ new Set(["EMPTY_BUNDLE", "UNRESOLVED_IMPORT"]);
-async function bundleDts(inputPath, outputPath, platform, options, verbose = false) {
-  const pkg = process.env.INIT_CWD ?? cwd3();
-  const tsconfigPath = path10.resolve(pkg, "tsconfig.json");
-  const nodePlugIns = platform === "node" ? [nodeExternals()] : [];
-  try {
-    const bundle = await rollup({
-      input: inputPath,
-      plugins: [dts({
-        ...options,
-        tsconfig: tsconfigPath,
-        compilerOptions: {
-          emitDeclarationOnly: true,
-          noEmit: false,
-          declarationMap: true
-        }
-      }), ...nodePlugIns],
-      onwarn(warning, warn) {
-        if (ignoredWarningCodes.has(warning.code ?? "")) {
-          return;
-        }
-        console.warn(chalk37.yellow(`[${warning.code}] ${warning.message}`));
-        console.warn(chalk37.gray(inputPath));
-        warn(warning);
-      }
-    });
-    await bundle.write({
-      file: outputPath,
-      format: "es"
-    });
-  } catch (ex) {
-    const error = ex;
-    console.warn(chalk37.red(error));
-    console.warn(chalk37.gray(inputPath));
-  }
-  if (verbose) {
-    console.log(`Bundled declarations written to ${outputPath}`);
-  }
-}
-var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build", verbose = false) => {
-  if (verbose) {
-    console.log(chalk37.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
-    console.log(`Entries: ${entries.join(", ")}`);
-  }
-  const pkg = process.env.INIT_CWD ?? cwd3();
-  const srcRoot = `${pkg}/${srcDir}/${platform}`;
-  const entryNameToTypeName = (entry) => {
-    const splitEntryName = entry.split(".");
-    const newEntryExtension = "d." + splitEntryName.at(-1);
-    return [...splitEntryName.slice(0, -1), newEntryExtension].join(".");
-  };
-  const compilerOptions = getCompilerOptions({
-    removeComments: false,
-    skipDefaultLibCheck: true,
-    skipLibCheck: true,
-    declarationMap: true,
-    emitDeclarationOnly: true,
-    noEmit: true
-  });
-  const entryNames = entries.map((entry) => entry.split(`${srcDir}/`).at(-1) ?? entry);
-  await Promise.all(entryNames.map(async (entryName) => {
-    const entryTypeName = entryNameToTypeName(entryName);
-    await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, { compilerOptions }, verbose);
-  }));
-  if (verbose) {
-    console.log(chalk37.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
-  }
-  return 0;
-};
-
-// src/actions/package/compile/packageCompileTsup.ts
-var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = false, verbose) => {
-  const outDir = options?.outDir ?? "dist";
-  if (verbose) {
-    console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
-  }
-  if (entries.length === 0) {
-    console.warn(chalk38.yellow(`No entries found in ${srcDir} to compile`));
-    return 0;
-  }
-  if (verbose) {
-    console.log(chalk38.gray(`buildDir [${buildDir}]`));
-  }
-  const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
-  if (validationResult !== 0) {
-    console.error(chalk38.red(`Compile:Validation had ${validationResult} errors`));
-    return validationResult;
-  }
-  const optionsParams = tsupOptions([{
-    bundle: true,
-    cjsInterop: true,
-    clean: false,
-    dts: false,
-    format: ["esm"],
-    outDir,
-    silent: true,
-    sourcemap: true,
-    splitting: false,
-    tsconfig: "tsconfig.json",
-    ...options,
-    entry: entries.map((entry) => `${srcDir}/${entry}`)
-  }]);
-  const optionsResult = defineConfig(optionsParams);
-  const optionsList = (await Promise.all(
-    (Array.isArray(optionsResult) ? optionsResult : [optionsResult]).flatMap(async (options2) => {
-      const result = typeof options2 === "function" ? await options2({}) : [options2];
-      return Array.isArray(result) ? result : [result];
-    })
-  )).flat();
-  if (verbose) {
-    console.log(chalk38.cyan(`TSUP:build:start [${srcDir}]`));
-    console.log(chalk38.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
-  }
-  await Promise.all(optionsList.map((options2) => build2(options2)));
-  if (verbose) {
-    console.log(chalk38.cyan(`TSUP:build:stop [${srcDir}]`));
-  }
-  if (bundleTypes) {
-    await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
-  }
-  return 0;
-};
-var tsupOptions = (options = []) => {
-  const standardLoaders = {
-    ".gif": "copy",
-    ".html": "copy",
-    ".jpg": "copy",
-    ".json": "json",
-    ".png": "copy",
-    ".svg": "text",
-    ".webp": "copy"
-  };
-  const standardOptions = {
-    bundle: true,
-    format: ["esm"],
-    loader: standardLoaders,
-    outExtension: ({ format }) => format === "esm" ? { js: ".mjs" } : { js: ".cjs" },
-    skipNodeModulesBundle: true,
-    sourcemap: true,
-    target: "esnext"
-  };
-  return deepMergeObjects([standardOptions, ...options]);
-};
-var packageCompileTsup = async (config2) => {
-  const compile2 = config2?.compile;
-  const verbose = config2?.verbose ?? false;
-  const outDirAsBuildDir = compile2?.outDirAsBuildDir ?? true;
-  const bundleTypes = compile2?.bundleTypes ?? false;
-  if (verbose) {
-    console.log("Compiling with TSUP");
-  }
-  const compileForNode = compile2?.node ?? { src: {} };
-  const compileForBrowser = compile2?.browser ?? { src: {} };
-  const compileForNeutral = compile2?.neutral ?? { src: {} };
-  return (await Promise.all(
-    Object.entries(compileForNode).map(async ([srcDir, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile2?.node?.esbuildOptions === "object" ? compile2?.node?.esbuildOptions : {};
-      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
-      const platform = "node";
-      const rootOutDir = optionsObject.outDir ?? "dist";
-      const outDir = rootOutDir + "/" + platform;
-      return typeof srcDir === "string" ? await compileFolder(
-        srcDir,
-        entry,
-        outDirAsBuildDir ? rootOutDir : "build",
-        tsupOptions([
-          inEsBuildOptions,
-          compile2?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "node", outDir }
-        ]),
-        bundleTypes,
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForBrowser).map(async ([srcDir, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile2?.browser?.esbuildOptions === "object" ? compile2?.browser?.esbuildOptions : {};
-      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
-      const platform = "browser";
-      const rootOutDir = optionsObject.outDir ?? "dist";
-      const outDir = rootOutDir + "/" + platform;
-      return typeof srcDir === "string" ? await compileFolder(
-        srcDir,
-        entry,
-        outDirAsBuildDir ? rootOutDir : "build",
-        tsupOptions([
-          inEsBuildOptions,
-          compile2?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "browser", outDir }
-        ]),
-        bundleTypes,
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
-    Object.entries(compileForNeutral).map(async ([srcDir, options]) => {
-      const optionsObject = typeof options === "object" ? options : {};
-      const inEsBuildOptions = typeof compile2?.neutral?.esbuildOptions === "object" ? compile2?.neutral?.esbuildOptions : {};
-      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
-      const platform = "neutral";
-      const rootOutDir = optionsObject.outDir ?? "dist";
-      const outDir = rootOutDir + "/" + platform;
-      return typeof srcDir === "string" ? await compileFolder(
-        srcDir,
-        entry,
-        outDirAsBuildDir ? rootOutDir : "build",
-        tsupOptions([
-          inEsBuildOptions,
-          compile2?.tsup?.options ?? {},
-          typeof options === "object" ? options : {},
-          { platform: "neutral", outDir }
-        ]),
-        bundleTypes,
-        verbose
-      ) : 0;
-    })
-  )).reduce((prev, value) => prev + value, 0) + 0;
-};
-
-// src/actions/package/compile/compile.ts
-var packageCompile = async (inConfig = {}) => {
-  const pkg = process.env.INIT_CWD;
-  console.log(chalk39.green(`Compiling ${pkg}`));
-  const config2 = await loadConfig(inConfig);
-  return await packageCompileTsup(config2);
-};
-
-// src/actions/package/copy-assets.ts
-import path11 from "path/posix";
-import chalk40 from "chalk";
-import cpy2 from "cpy";
-var copyTargetAssets2 = async (target, name, location) => {
-  try {
-    const values = await cpy2(
-      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
-      `../dist/${target}`,
-      {
-        cwd: path11.join(location, "src"),
-        flat: false
-      }
-    );
-    if (values.length > 0) {
-      console.log(chalk40.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
-    }
-    for (const value of values) {
-      console.log(`${value.split("/").pop()} => ./dist/${target}`);
-    }
-    return 0;
-  } catch (ex) {
-    const error = ex;
-    console.log(`Copy Assets Failed: ${name}: ${error.message}`);
-    return 1;
-  }
-};
-var packageCopyAssets = async ({ target }) => {
-  const pkg = process.env.INIT_CWD ?? "./";
-  const pkgName = process.env.npm_package_name ?? "Unknown";
-  switch (target) {
-    case "esm": {
-      return await copyTargetAssets2("esm", pkgName, pkg);
-    }
-    case "cjs": {
-      return await copyTargetAssets2("cjs", pkgName, pkg);
-    }
-    default: {
-      return await copyTargetAssets2("esm", pkgName, pkg) || await copyTargetAssets2("cjs", pkgName, pkg);
-    }
-  }
-};
-
-// src/actions/package/cycle.ts
-import { cruise as cruise2 } from "dependency-cruiser";
-var packageCycle = async () => {
-  const pkg = process.env.INIT_CWD;
-  const pkgName = process.env.npm_package_name;
-  const cruiseOptions = {
-    ruleSet: {
-      forbidden: [
-        {
-          name: "no-circular",
-          severity: "error",
-          comment: "This dependency creates a circular reference",
-          from: {},
-          to: { circular: true }
-        }
-      ]
-    },
-    exclude: "node_modules|packages/.*/packages",
-    validate: true,
-    doNotFollow: { path: "node_modules|packages/.*/packages" },
-    tsPreCompilationDeps: false,
-    combinedDependencies: true,
-    outputType: "err"
-  };
-  const target = `${pkg}/src`;
-  console.log(`Checking for circular dependencies in ${target}...`);
-  const result = await cruise2([target], cruiseOptions);
-  console.log(result.output);
-  if (result.exitCode === 0) {
-    console.log(`${pkgName} \u2705 No dependency violations`);
-  } else {
-    console.error(`${pkgName} \u274C Dependency violations found`);
-  }
-  return result.exitCode;
-};
-
-// src/actions/package/gen-docs.ts
-import { existsSync as existsSync10 } from "fs";
-import path12 from "path";
-import chalk41 from "chalk";
-import {
-  Application,
-  ArgumentsReader,
-  TSConfigReader,
-  TypeDocReader
-} from "typedoc";
-var ExitCodes = {
-  CompileError: 3,
-  ExceptionThrown: 6,
-  NoEntryPoints: 2,
-  Ok: 0,
-  OptionError: 1,
-  OutputError: 5,
-  ValidationError: 4
-};
-var packageGenDocs = async () => {
-  const pkg = process.env.INIT_CWD;
-  if (pkg !== void 0 && !existsSync10(path12.join(pkg, "typedoc.json"))) {
-    return;
-  }
-  const app = await Application.bootstrap({
-    entryPointStrategy: "merge",
-    entryPoints: [`${pkg}/src/**/*.ts`, `${pkg}/packages/*/dist/docs.json`],
-    excludeExternals: true,
-    json: `${pkg}/dist/docs.json`,
-    logLevel: "Error",
-    tsconfig: `${pkg}/tsconfig.json`
-  });
-  app.options.addReader(new ArgumentsReader(0));
-  app.options.addReader(new TypeDocReader());
-  app.options.addReader(new TSConfigReader());
-  app.options.addReader(new ArgumentsReader(300));
-  return await runTypeDoc(app);
-};
-var runTypeDoc = async (app) => {
-  const pkgName = process.env.npm_package_name;
-  if (app.options.getValue("version")) {
-    console.log(app.toString());
-    return ExitCodes.Ok;
-  }
-  if (app.options.getValue("showConfig")) {
-    console.log(app.options.getRawValues());
-    return ExitCodes.Ok;
-  }
-  if (app.logger.hasErrors()) {
-    return ExitCodes.OptionError;
-  }
-  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
-    return ExitCodes.OptionError;
-  }
-  if (app.options.getValue("entryPoints").length === 0) {
-    app.logger.error("No entry points provided");
-    return ExitCodes.NoEntryPoints;
-  }
-  if (app.options.getValue("watch")) {
-    await app.convertAndWatch(async (project2) => {
-      const out = app.options.getValue("out");
-      if (out) {
-        await app.generateDocs(project2, out);
-      }
-      const json = app.options.getValue("json");
-      if (json) {
-        await app.generateJson(project2, json);
-      }
-      if (!out && !json) {
-        await app.generateDocs(project2, "./docs");
-      }
-    });
-    return ExitCodes.Ok;
-  }
-  const project = await app.convert();
-  if (!project) {
-    return ExitCodes.CompileError;
-  }
-  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
-    return ExitCodes.CompileError;
-  }
-  app.validate(project);
-  if (app.logger.hasErrors()) {
-    return ExitCodes.ValidationError;
-  }
-  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
-    return ExitCodes.ValidationError;
-  }
-  if (app.options.getValue("emit") !== "none") {
-    const out = app.options.getValue("out");
-    if (out) {
-      await app.generateDocs(project, out);
-    }
-    const json = app.options.getValue("json");
-    if (json) {
-      await app.generateJson(project, json);
-    }
-    if (!out && !json) {
-      await app.generateDocs(project, "./docs");
-    }
-    if (app.logger.hasErrors()) {
-      return ExitCodes.OutputError;
-    }
-    if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
-      return ExitCodes.OutputError;
-    }
-  }
-  console.log(chalk41.green(`${pkgName} - Ok`));
-  return ExitCodes.Ok;
-};
-
-// src/actions/package/lint.ts
-import { readdirSync as readdirSync6 } from "fs";
-import path13 from "path";
-import { cwd as cwd4 } from "process";
-import { pathToFileURL } from "url";
-import chalk42 from "chalk";
-import { ESLint } from "eslint";
-import { findUp as findUp2 } from "find-up";
-import picomatch from "picomatch";
-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(chalk42.gray(`
-${lintResult.filePath}`));
-      for (const message of lintResult.messages) {
-        console.log(
-          chalk42.gray(`	${message.line}:${message.column}`),
-          chalk42[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk42.white(`	${message.message}`),
-          chalk42.gray(`	${message.ruleId}`)
-        );
-      }
-    }
-  }
-};
-async function getRootESLintConfig() {
-  const configPath = await findUp2("eslint.config.mjs");
-  if (configPath === void 0) {
-    throw new Error("eslint.config.mjs not found in the monorepo");
-  }
-  return pathToFileURL(configPath);
-}
-function getFiles(dir, ignoreFolders) {
-  const currentDirectory = cwd4();
-  const subDirectory = dir.split(currentDirectory)[1]?.split("/")[1];
-  if (ignoreFolders.includes(subDirectory)) return [];
-  return readdirSync6(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const res = path13.resolve(dir, dirent.name);
-    const relativePath = subDirectory === void 0 ? dirent.name : `${subDirectory}/${dirent.name}`;
-    const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
-    if (ignoreMatchers.some((isMatch) => isMatch(relativePath))) return [];
-    return dirent.isDirectory() ? getFiles(res, ignoreFolders) : [res];
-  });
-}
-var packageLint = async (fix2 = false, verbose = false, cache = true) => {
-  const pkg = process.env.INIT_CWD;
-  const configPath = await getRootESLintConfig();
-  const { default: eslintConfig } = await import(configPath.href);
-  const start = Date.now();
-  const ignoreFolders = ["node_modules", "dist", "packages", ".git", "build", ".yarn", ".vscode", ".github"];
-  const engine = new ESLint({
-    baseConfig: [...eslintConfig],
-    fix: fix2,
-    warnIgnored: false,
-    cache
-  });
-  const files = getFiles(cwd4(), ignoreFolders);
-  console.log(chalk42.green(`Linting ${pkg} [files = ${files.length}]`));
-  if (verbose) {
-    for (const file of files) {
-      console.log(chalk42.gray(`	${file}`));
-    }
-  }
-  const lintResults = await engine.lintFiles(files);
-  dumpMessages(lintResults);
-  if (fix2) {
-    await ESLint.outputFixes(lintResults);
-  }
-  const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
-  const lintTime = Date.now() - start;
-  const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk42.white(`Linted ${chalk42[filesCountColor](files.length)} files in ${chalk42[lintTimeColor](lintTime)}ms`));
-  return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
-};
-
-// src/actions/package/publint.ts
-import { promises as fs10 } from "fs";
-import chalk43 from "chalk";
-import sortPackageJson from "sort-package-json";
-var customPubLint = (pkg) => {
-  let errorCount = 0;
-  let warningCount = 0;
-  if (pkg.files === void 0) {
-    console.warn(chalk43.yellow('Publint [custom]: "files" field is missing'));
-    warningCount++;
-  }
-  if (pkg.main !== void 0) {
-    console.warn(chalk43.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
-    warningCount++;
-  }
-  if (pkg.sideEffects !== false) {
-    console.warn(chalk43.yellow('Publint [custom]: "sideEffects" field should be set to false'));
-    warningCount++;
-  }
-  if (pkg.resolutions !== void 0) {
-    console.warn(chalk43.yellow('Publint [custom]: "resolutions" in use'));
-    console.warn(chalk43.gray(JSON.stringify(pkg.resolutions, null, 2)));
-    warningCount++;
-  }
-  return [errorCount, warningCount];
-};
-var packagePublint = async ({ strict = true, verbose = false } = {}) => {
-  const pkgDir = process.env.INIT_CWD;
-  const sortedPkg = sortPackageJson(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
-  await fs10.writeFile(`${pkgDir}/package.json`, sortedPkg);
-  const pkg = JSON.parse(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
-  console.log(chalk43.green(`Publint: ${pkg.name}`));
-  console.log(chalk43.gray(pkgDir));
-  const { publint: publint2 } = await import("publint");
-  const { messages } = await publint2({
-    level: "suggestion",
-    pkgDir,
-    strict
-  });
-  const { formatMessage } = await import("publint/utils");
-  for (const message of messages) {
-    switch (message.type) {
-      case "error": {
-        console.error(chalk43.red(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-      case "warning": {
-        console.warn(chalk43.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-      default: {
-        console.log(chalk43.white(`[${message.code}] ${formatMessage(message, pkg)}`));
-        break;
-      }
-    }
-  }
-  const [errorCount, warningCount] = customPubLint(pkg);
-  if (verbose) {
-    console.log(chalk43.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
-  }
-  return messages.filter((message) => message.type === "error").length + errorCount;
-};
-
-// src/actions/package/recompile.ts
-var packageRecompile = async () => {
-  return await packageClean() || await packageCompile();
-};
-
-// src/actions/package-lint.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "fs";
-import PATH11 from "path";
-import chalk44 from "chalk";
-import picomatch2 from "picomatch";
-function emptyResult() {
-  return {
-    errors: [],
-    fixable: [],
-    warnings: []
-  };
-}
-function readRootPackageJson(cwd5) {
-  const raw = readFileSync17(PATH11.resolve(cwd5, "package.json"), "utf8");
-  return JSON.parse(raw);
-}
-function writeRootPackageJson(cwd5, pkg) {
-  const path14 = PATH11.resolve(cwd5, "package.json");
-  writeFileSync7(path14, `${JSON.stringify(pkg, null, 2)}
-`, "utf8");
-}
-function isMonorepo(pkg) {
-  const workspaces = pkg.workspaces;
-  return Array.isArray(workspaces) && workspaces.length > 0;
-}
-function checkPackagesFolder(workspaces) {
-  const result = emptyResult();
-  for (const { location, name } of workspaces) {
-    if (location === ".") continue;
-    if (!location.startsWith("packages/") && !location.startsWith("packages\\")) {
-      result.errors.push(`${name} (${location}) is not inside a packages/ folder`);
-    }
-  }
-  return result;
-}
-function checkRootPrivate(pkg) {
-  const result = emptyResult();
-  if (!pkg.private) {
-    result.fixable.push("Root package.json must be private to prevent accidental publishing");
-  }
-  return result;
-}
-function fixRootPrivate(cwd5, pkg) {
-  pkg.private = true;
-  writeRootPackageJson(cwd5, pkg);
-  console.log(chalk44.green('  \u2714 Fixed: set "private": true in root package.json'));
-}
-function checkNoPublishConfigOnPrivate(pkg) {
-  const result = emptyResult();
-  if (pkg.private && pkg.publishConfig) {
-    result.fixable.push("Root package.json has publishConfig but is private \u2014 publishConfig is unnecessary");
-  }
-  return result;
-}
-function fixNoPublishConfigOnPrivate(cwd5, pkg) {
-  delete pkg.publishConfig;
-  writeRootPackageJson(cwd5, pkg);
-  console.log(chalk44.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
-}
-function checkDiscoverable(pkg, workspaces) {
-  const result = emptyResult();
-  const globs = pkg.workspaces;
-  const matchers = globs.map((glob3) => picomatch2(glob3));
-  const isMatch = (location) => matchers.some((m) => m(location));
-  for (const { location, name } of workspaces) {
-    if (location === ".") continue;
-    if (!isMatch(location)) {
-      result.errors.push(`${name} (${location}) is not matched by any workspace glob in package.json`);
-    }
-  }
-  return result;
-}
-function logResults(label, result, fix2) {
-  let errors = 0;
-  let fixed = 0;
-  for (const error of result.errors) {
-    console.log(chalk44.red(`  \u2717 ${error}`));
-    errors++;
-  }
-  for (const fixable of result.fixable) {
-    if (fix2) {
-      fixed++;
-    } else {
-      console.log(chalk44.red(`  \u2717 ${fixable} (fixable)`));
-      errors++;
-    }
-  }
-  for (const warning of result.warnings) {
-    console.log(chalk44.yellow(`  \u26A0 ${warning}`));
-  }
-  if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
-    console.log(chalk44.green(`  \u2713 ${label}`));
-  }
-  return { errors, fixed };
-}
-function runChecks(entries, cwd5, pkg, fix2) {
-  let totalErrors = 0;
-  let totalFixed = 0;
-  for (const entry of entries) {
-    const result = entry.check();
-    const log = logResults(entry.label, result, fix2);
-    if (fix2 && entry.fix && result.fixable.length > 0) {
-      entry.fix(cwd5, pkg);
-    }
-    totalErrors += log.errors;
-    totalFixed += log.fixed;
-  }
-  return { errors: totalErrors, fixed: totalFixed };
-}
-function logSummary(errors, fixed) {
-  if (fixed > 0) {
-    console.log(chalk44.green(`
-  Fixed ${fixed} issue(s)`));
-  }
-  if (errors > 0) {
-    console.log(chalk44.red(`
-  ${errors} error(s) found`));
-  } else if (fixed === 0) {
-    console.log(chalk44.green("\n  All checks passed"));
-  }
-}
-function packageLintMonorepo(fix2 = false) {
-  const cwd5 = INIT_CWD() ?? process.cwd();
-  let pkg;
-  try {
-    pkg = readRootPackageJson(cwd5);
-  } catch {
-    console.error(chalk44.red("Could not read package.json"));
-    return 1;
-  }
-  if (!isMonorepo(pkg)) {
-    console.log(chalk44.gray("Not a monorepo \u2014 skipping package-lint checks"));
-    return 0;
-  }
-  console.log(chalk44.green("Package Lint"));
-  const workspaces = yarnWorkspaces();
-  const checks = [
-    {
-      check: () => checkRootPrivate(pkg),
-      fix: fixRootPrivate,
-      label: "Root package is private"
-    },
-    {
-      check: () => checkNoPublishConfigOnPrivate(pkg),
-      fix: fixNoPublishConfigOnPrivate,
-      label: "No publishConfig on private root"
-    },
-    { check: () => checkPackagesFolder(workspaces), label: "All packages are in packages/ folder" },
-    { check: () => checkDiscoverable(pkg, workspaces), label: "All packages are discoverable from workspace globs" }
-  ];
-  const { errors, fixed } = runChecks(checks, cwd5, pkg, fix2);
-  logSummary(errors, fixed);
-  return errors > 0 ? 1 : 0;
-}
-
-// src/actions/publint.ts
-var publint = async ({ verbose, pkg }) => {
-  return pkg === void 0 ? publintAll({ verbose }) : await publintPackage({ pkg, verbose });
-};
-var publintPackage = ({ pkg }) => {
-  return runStepsAsync(`Publint [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-publint"]]]);
-};
-var publintAll = ({ verbose }) => {
-  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
-  return runSteps("Publint", [["yarn", ["workspaces", "foreach", "-pA", ...verboseOptions, "run", "package-publint"]]]);
-};
-
-// src/actions/publish.ts
-var publish = () => {
-  return runSteps("Publish", [["npm", ["publish", "--workspaces"]]]);
-};
-
-// src/actions/readme-gen.ts
-async function readmeGen({
-  pkg,
-  templatePath,
-  typedoc,
-  verbose
-}) {
-  const config2 = await loadConfig();
-  return await generateReadmeFiles({
-    logoLinkUrl: config2.readme?.logoLinkUrl,
-    logoUrl: config2.readme?.logoUrl,
-    pkg,
-    templatePath,
-    typedoc,
-    verbose
-  });
-}
-
-// src/actions/readme-init.ts
-async function readmeInit({ templatePath }) {
-  const config2 = await loadConfig();
-  const template = applyLogoConfig(DEFAULT_README_TEMPLATE, config2.readme?.logoUrl, config2.readme?.logoLinkUrl);
-  const resolvedTemplatePath = resolveTemplatePath(templatePath);
-  await scaffoldTemplate(resolvedTemplatePath, template);
-  return 0;
-}
-
-// src/actions/rebuild.ts
-var rebuild = ({ target }) => {
-  return runSteps("Rebuild", [
-    ["yarn", "xy clean"],
-    ["yarn", target ? `xy build -t ${target}` : "xy build"]
-  ]);
-};
-
-// src/actions/recompile.ts
-import chalk45 from "chalk";
-var recompile = async ({
-  verbose,
-  target,
-  pkg,
-  incremental
-}) => {
-  return pkg ? await recompilePackage({
-    pkg,
-    target,
-    verbose
-  }) : await recompileAll({
-    incremental,
-    target,
-    verbose
-  });
-};
-var recompilePackage = ({ target, pkg }) => {
-  const targetOptions = target ? ["-t", target] : [];
-  return runStepsAsync(
-    `Recompile [${pkg}]`,
-    [["yarn", ["workspace", pkg, "run", "package-recompile", ...targetOptions]]]
-  );
-};
-var recompileAll = async ({
-  jobs,
-  verbose,
-  target,
-  incremental
-}) => {
-  const start = Date.now();
-  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
-  const targetOptions = target ? ["-t", target] : [];
-  const incrementalOptions = incremental ? ["--since", "-Apt", "--topological-dev"] : ["--parallel", "-Apt", "--topological-dev"];
-  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
-  if (jobs) {
-    console.log(chalk45.blue(`Jobs set to [${jobs}]`));
-  }
-  const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
-    [
-      "yarn",
-      [
-        "workspaces",
-        "foreach",
-        ...incrementalOptions,
-        ...jobsOptions,
-        ...verboseOptions,
-        "run",
-        "package-clean",
-        ...targetOptions
-      ]
-    ],
-    [
-      "yarn",
-      [
-        "workspaces",
-        "foreach",
-        ...incrementalOptions,
-        ...jobsOptions,
-        ...verboseOptions,
-        "run",
-        "package-compile",
-        ...targetOptions
-      ]
-    ]
-  ]);
-  console.log(
-    `${chalk45.gray("Recompiled in")} [${chalk45.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk45.gray("seconds")}`
-  );
-  return result;
-};
-
-// src/actions/reinstall.ts
-import {
-  closeSync,
-  openSync,
-  rmSync as rmSync3
-} from "fs";
-var reinstall = () => {
-  console.log("Reinstall [Clear Lock File]");
-  closeSync(openSync("./yarn.lock", "w"));
-  console.log("Reinstall [Clear Node Modules]");
-  const workspaces = yarnWorkspaces();
-  const result = workspaces.map(({ location, name }) => {
-    const dist = `${location}/node_modules`;
-    try {
-      rmSync3(dist, { force: true, recursive: true });
-      return 0;
-    } catch (ex) {
-      const error = ex;
-      console.error(`Reinstall [Clear Node Modules] Failed [${name}, ${error.message}]`);
-      return 1;
-    }
-  }).reduce((prev, result2) => prev || result2, 0);
-  return result || runSteps("Reinstall", [["yarn", "install --network-timeout 10000"]]);
-};
-
-// src/actions/relint.ts
-import chalk46 from "chalk";
-var relintPackage = ({
-  pkg,
-  fix: fix2,
-  verbose
-}) => {
-  console.log(chalk46.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
-  const start = Date.now();
-  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
-    ["yarn", [
-      "workspace",
-      pkg,
-      "run",
-      fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
-    ]]
-  ]);
-  console.log(chalk46.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk46.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk46.gray("seconds")}`));
-  return result;
-};
-var relint = ({
-  pkg,
-  verbose,
-  incremental,
-  fix: fix2
-} = {}) => {
-  return pkg === void 0 ? relintAllPackages({
-    verbose,
-    incremental,
-    fix: fix2
-  }) : relintPackage({
-    pkg,
-    fix: fix2,
-    verbose
-  });
-};
-var relintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk46.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
-  const start = Date.now();
-  const fixOptions = fix2 ? ["--fix"] : [];
-  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
-    ["yarn", ["eslint", ...fixOptions]]
-  ]);
-  console.log(chalk46.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk46.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk46.gray("seconds")}`));
-  return result;
-};
-
-// src/actions/retest.ts
-function isWorkspace(target) {
-  return yarnWorkspaces().some((ws) => ws.name === target);
-}
-var retest = ({ target } = {}) => {
-  if (target && isWorkspace(target)) {
-    return runSteps(`Re-Test [${target}]`, [
-      ["yarn", ["workspace", target, "run", "vitest", "--clearCache"]],
-      ["yarn", ["workspace", target, "run", "vitest", "."]]
-    ]);
-  }
-  const path14 = target ?? ".";
-  return runSteps("Re-Test", [
-    ["yarn", ["vitest", "--clearCache"]],
-    ["yarn", ["vitest", path14]]
-  ]);
-};
-
-// src/actions/sonar.ts
-var sonar = () => {
-  return runSteps("Sonar", [["yarn", ["eslint", "-c", "sonar.eslintrc", "."]]]);
-};
-
-// src/actions/statics.ts
-import chalk47 from "chalk";
-var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
-var statics = () => {
-  console.log(chalk47.green("Check Required Static Dependencies"));
-  const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
-  return detectDuplicateDependencies(statics2, DefaultDependencies);
-};
-
-// src/actions/test.ts
-function isWorkspace2(target) {
-  return yarnWorkspaces().some((ws) => ws.name === target);
-}
-var test = ({ target } = {}) => {
-  if (target && isWorkspace2(target)) {
-    return runSteps(`Test [${target}]`, [["yarn", ["workspace", target, "run", "vitest", "."]]]);
-  }
-  const path14 = target ?? ".";
-  return runSteps("Test", [["yarn", ["vitest", path14]]]);
-};
-
-// src/actions/up.ts
-var up = () => {
-  return runSteps("Up", [["yarn", "outdated"]]);
-};
-
-// src/actions/updo.ts
-var updo = () => {
-  return runSteps("Updo", [
-    ["yarn", "install"],
-    ["yarn", "upgrade-interactive"],
-    ["yarn", "dedupe"]
-  ]);
-};
-
-// src/actions/upplug.ts
-var updateYarnPlugins = () => {
-  return runSteps("Update Yarn Plugins", [
-    ["yarn", ["plugin", "import", "https://mskelton.dev/yarn-outdated/v3"]],
-    ["yarn", ["plugin", "import", "version"]],
-    ["yarn", ["plugin", "import", "interactive-tools"]],
-    ["yarn", ["plugin", "import", "workspace-tools"]]
-  ]);
-};
-
-// src/actions/upyarn.ts
-var updateYarnVersion = () => {
-  return runSteps("Update Yarn Version", [["yarn", ["set", "version", "latest"]]]);
-};
-
-// src/actions/yarn3only.ts
-var yarn3Only = () => {
-  const [valid, version] = isYarnVersionOrGreater(3);
-  if (!valid) {
-    processEx(`Invalid Yarn version [${version}]`);
-  }
-  return 0;
-};
-
-// src/loadPackageConfig.ts
-import { readFile as readFile2 } from "fs/promises";
-var loadPackageConfig = async () => {
-  const pkg = process.env.INIT_CWD;
-  const pkgConfig = await readFile2(`${pkg}/package.json`, { encoding: "utf8" });
-  return JSON.parse(pkgConfig);
-};
-
-// src/xy/build/buildCommand.ts
-var buildCommand = {
-  command: "build [package]",
-  describe: "Build - Compile & Lint",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to build" });
-  },
-  handler: async (argv) => {
-    if (argv.verbose) {
-      console.log(`Building: ${argv.package ?? "all"}`);
-    }
-    process.exitCode = await build({
-      incremental: !!argv.incremental,
-      jobs: argv.jobs,
-      pkg: argv.package,
-      target: argv.target,
-      verbose: !!argv.verbose
-    });
-  }
-};
-
-// src/xy/build/compileCommand.ts
-var compileCommand = {
-  command: "compile [package]",
-  describe: "Compile with Typescript & Copy Images",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to compile" });
-  },
-  handler: (argv) => {
-    if (argv.verbose) {
-      console.log(`Compiling: ${argv.package ?? "all"}`);
-    }
-    process.exitCode = compile({
-      incremental: !!argv.incremental,
-      jobs: argv.jobs,
-      pkg: argv.package,
-      target: argv.target,
-      verbose: !!argv.verbose
-    });
-  }
-};
-
-// src/xy/build/compileOnlyCommand.ts
-var compileOnlyCommand = {
-  command: "compile-only [package]",
-  describe: "Compile with Typescript & Copy Images (No Publint)",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to compile" });
-  },
-  handler: (argv) => {
-    if (argv.verbose) {
-      console.log(`Compiling: ${argv.package ?? "all"}`);
-    }
-    process.exitCode = compile({
-      incremental: !!argv.incremental,
-      jobs: argv.jobs,
-      pkg: argv.package,
-      publint: false,
-      target: argv.target,
-      verbose: !!argv.verbose
-    });
-  }
-};
-
-// src/xy/build/copyAssetsCommand.ts
-var copyAssetsCommand = {
-  command: "copy-assets [package]",
-  describe: "Copy Assets - Copy the assets from src to dist",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to copy assets" });
-  },
-  handler: async (argv) => {
-    if (argv.verbose) console.log(`Copying Assets: ${argv.package ?? "all"}`);
-    process.exitCode = await copyAssets({ target: argv.target });
-  }
-};
-
-// src/xy/build/rebuildCommand.ts
-var rebuildCommand = {
-  command: "rebuild [package]",
-  describe: "Rebuild - Clean, Compile & Lint",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to rebuild" });
-  },
-  handler: (argv) => {
-    if (argv.verbose) console.log(`Rebuilding: ${argv.package ?? "all"}`);
-    process.exitCode = rebuild({ target: argv.target });
-  }
-};
-
-// src/xy/build/recompileCommand.ts
-var recompileCommand = {
-  command: "recompile [package]",
-  describe: "Re-compile with Typescript & Copy Images",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to re-compile" });
-  },
-  handler: async (argv) => {
-    if (argv.verbose) {
-      console.log(`Re-compiling: ${argv.package ?? "all"}`);
-    }
-    process.exitCode = await recompile({
-      incremental: !!argv.incremental,
-      jobs: argv.jobs,
-      pkg: argv.package,
-      target: argv.target,
-      verbose: !!argv.verbose
-    });
-  }
-};
-
-// src/xy/build/index.ts
-var xyBuildCommands = (args) => {
-  return args.command(buildCommand).command(compileCommand).command(compileOnlyCommand).command(recompileCommand).command(rebuildCommand).command(copyAssetsCommand);
-};
-
-// src/xy/common/claude/cleanCommand.ts
-var cleanCommand = {
-  command: "clean",
-  describe: "Remove all Claude configuration files from the repo",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Claude Clean");
-    process.exitCode = claudeClean();
-  }
-};
-
-// src/xy/common/claude/commandsCommand.ts
-var commandsCommand = {
-  command: "commands",
-  describe: "Sync XY Labs standard Claude slash commands to .claude/commands/",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Claude Commands");
-    process.exitCode = claudeCommands();
-  }
-};
-
-// src/xy/common/claude/initCommand.ts
-var initCommand = {
-  builder: (yargs2) => {
-    return yargs2.option("force", {
-      alias: "f",
-      default: false,
-      description: "Overwrite existing CLAUDE.md",
-      type: "boolean"
-    });
-  },
-  command: "init",
-  describe: "Initialize all Claude configuration (commands, rules, settings)",
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Claude Init");
-    const commandsResult = claudeCommands();
-    const rulesResult = claudeRules({ force: argv.force });
-    const settingsResult = await claudeSettings();
-    process.exitCode = commandsResult || rulesResult || settingsResult;
-  }
-};
-
-// src/xy/common/claude/rulesCommand.ts
-var rulesCommand = {
-  builder: (yargs2) => {
-    return yargs2.option("force", {
-      alias: "f",
-      default: false,
-      description: "Overwrite existing CLAUDE.md",
-      type: "boolean"
-    });
-  },
-  command: "rules",
-  describe: "Sync XY Labs standard Claude rules to .claude/rules/",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Claude Rules");
-    process.exitCode = claudeRules({ force: argv.force });
-  }
-};
-
-// src/xy/common/claude/settingsCommand.ts
-var settingsCommand = {
-  command: "settings",
-  describe: "Initialize .claude/settings.local.json with XY Labs defaults",
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Claude Settings");
-    process.exitCode = await claudeSettings();
-  }
-};
-
-// src/xy/common/claude/skillsCommand.ts
-var skillsCommand = {
-  builder: (yargs2) => yargs2,
-  command: "skills",
-  describe: "Sync XY Labs standard Claude skills to .claude/skills/",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Claude Skills");
-    process.exitCode = claudeSkills();
-  }
-};
-
-// src/xy/common/claude/index.ts
-var claudeCommand = {
-  builder: (yargs2) => {
-    return yargs2.command(cleanCommand).command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(skillsCommand).demandCommand(1, "Please specify a claude subcommand");
-  },
-  command: "claude",
-  describe: "Claude - Claude Code configuration utilities",
-  handler: () => {
-  }
-};
-
-// src/xy/common/cleanDocsCommand.ts
-var cleanDocsCommand = {
-  command: "clean-docs",
-  describe: "CleanDocs - Clean TypeDocs",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Cleaning TypeDocs: all");
-    process.exitCode = cleanDocs();
+    return [
+      ["yarn", `workspaces foreach --all version ${type} --deferred`]
+    ];
   }
 };
 
-// src/xy/param.ts
-var packagePositionalParam = (yargs2) => {
-  return yargs2.positional("package", { describe: "Specific package to target", type: "string" });
+// src/actions/deploy.ts
+import { readFileSync } from "fs";
+import { runSteps } from "@xylabs/ts-scripts-common";
+var privatePackageExcludeList = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
 };
-
-// src/xy/common/deadCommand.ts
-var deadCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  command: "dead [package]",
-  describe: "Dead - Check for dead code",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Dead");
-    process.exitCode = dead();
+var deploy = () => {
+  const excludeList = privatePackageExcludeList();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
   }
+  return runSteps("Deploy [Patch]", [
+    ["yarn", "workspaces foreach --all version patch --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "version apply --all"]
+  ]);
 };
 
-// src/xy/common/genDocsCommand.ts
-var genDocsCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  command: "gen-docs [package]",
-  describe: "GenDocs - Generate TypeDocs",
-  handler: (argv) => {
-    if (argv.verbose) console.log(`Generating TypeDocs: ${argv.package ?? "all"}`);
-    process.exitCode = genDocs({ incremental: !!argv.incremental, pkg: argv.package });
-  }
+// src/actions/deploy-major.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { runSteps as runSteps2 } from "@xylabs/ts-scripts-common";
+var privatePackageExcludeList2 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync2(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
 };
-
-// src/xy/common/gitignoreCommand.ts
-var gitignoreCommand = {
-  command: "gitignore",
-  describe: "GitIgnore - Generate root .gitignore and remove package .gitignore files",
-  handler: (argv) => {
-    if (argv.verbose) console.log("GitIgnore");
-    process.exitCode = gitignore();
+var deployMajor = () => {
+  const excludeList = privatePackageExcludeList2();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
   }
+  return runSteps2("Deploy [Major]", [
+    ["yarn", "workspaces foreach --all version major --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "version apply --all"]
+  ]);
 };
 
-// src/xy/common/gitlintCommand.ts
-var gitlintCommand = {
-  command: "gitlint [package]",
-  describe: "Gitlint - Lint your git config",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Gitlint");
-    process.exitCode = argv.fix ? gitlintFix() : gitlint();
-  }
+// src/actions/deploy-minor.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { runSteps as runSteps3 } from "@xylabs/ts-scripts-common";
+var privatePackageExcludeList3 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync3(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
 };
-
-// src/xy/common/licenseCommand.ts
-var licenseCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  command: "license [package]",
-  describe: "License - Check licenses of dependencies",
-  handler: async (argv) => {
-    if (argv.verbose) console.log(`License: ${argv.package ?? "all"}`);
-    process.exitCode = await license();
+var deployMinor = () => {
+  const excludeList = privatePackageExcludeList3();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
   }
+  return runSteps3("Deploy [Minor]", [
+    ["yarn", "workspaces foreach --all version minor --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "version apply --all"]
+  ]);
 };
 
-// src/xy/common/npmignoreGenCommand.ts
-var npmignoreGenCommand = {
-  command: "npmignore-gen",
-  describe: "NpmIgnore Gen - Generate .npmignore files",
-  handler: (argv) => {
-    if (argv.verbose) console.log("NpmIgnore Gen");
-    process.exitCode = npmignoreGen();
-  }
+// src/actions/deploy-next.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { runSteps as runSteps4 } from "@xylabs/ts-scripts-common";
+var privatePackageExcludeList4 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync4(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
 };
-
-// src/xy/common/readme/genCommand.ts
-var genCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2).option("template", {
-      alias: "t",
-      description: "Path to README.template.md",
-      type: "string"
-    }).option("typedoc", {
-      default: false,
-      description: "Generate TypeDoc reference sections",
-      type: "boolean"
-    });
-  },
-  aliases: ["$0"],
-  command: "gen [package]",
-  describe: "Generate README.md files from template",
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Readme Gen");
-    process.exitCode = await readmeGen({
-      pkg: argv.package,
-      templatePath: argv.template,
-      typedoc: argv.typedoc,
-      verbose: !!argv.verbose
-    });
+var deployNext = () => {
+  const excludeList = privatePackageExcludeList4();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
   }
+  return runSteps4("Deploy [Next]", [
+    ["yarn", "workspaces foreach --all version minor --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "version apply --all --prerelease"]
+  ]);
 };
 
-// src/xy/common/readme/initCommand.ts
-var initCommand2 = {
-  builder: (yargs2) => {
-    return yargs2.option("template", {
-      alias: "t",
-      description: "Path to README.template.md",
-      type: "string"
-    });
-  },
-  command: "init",
-  describe: "Initialize README template and logo files",
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Readme Init");
-    process.exitCode = await readmeInit({
-      templatePath: argv.template,
-      verbose: !!argv.verbose
-    });
-  }
+// src/actions/publish.ts
+import { runSteps as runSteps5 } from "@xylabs/ts-scripts-common";
+var publish = () => {
+  return runSteps5("Publish", [["npm", ["publish", "--workspaces"]]]);
 };
 
-// src/xy/common/readme/index.ts
-var readmeCommand = {
-  builder: (yargs2) => {
-    return yargs2.command(genCommand).command(initCommand2);
-  },
-  command: "readme",
-  describe: "Readme - README file utilities",
-  handler: () => {
-  }
+// src/actions/reinstall.ts
+import {
+  closeSync,
+  openSync,
+  rmSync
+} from "fs";
+import { runSteps as runSteps6 } from "@xylabs/ts-scripts-common";
+var reinstall = () => {
+  console.log("Reinstall [Clear Lock File]");
+  closeSync(openSync("./yarn.lock", "w"));
+  console.log("Reinstall [Clear Node Modules]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/node_modules`;
+    try {
+      rmSync(dist, { force: true, recursive: true });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Reinstall [Clear Node Modules] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || runSteps6("Reinstall", [["yarn", "install --network-timeout 10000"]]);
 };
 
-// src/xy/common/retestCommand.ts
-var retestCommand = {
-  command: "retest [target]",
-  describe: "Re-Test - Run Vitest Tests with cleaned cache",
-  builder: (yargs2) => {
-    return yargs2.positional("target", { describe: "Package name or file/folder path to test" });
-  },
-  handler: (argv) => {
-    if (argv.verbose) console.log(`Re-Testing: ${argv.target ?? "all"}`);
-    process.exitCode = retest({ target: argv.target });
-  }
+// src/actions/up.ts
+import { runSteps as runSteps7 } from "@xylabs/ts-scripts-common";
+var up = () => {
+  return runSteps7("Up", [["yarn", "outdated"]]);
 };
 
-// src/xy/common/testCommand.ts
-var testCommand = {
-  command: "test [target]",
-  describe: "Test - Run Vitest Tests",
-  builder: (yargs2) => {
-    return yargs2.positional("target", { describe: "Package name or file/folder path to test" });
-  },
-  handler: (argv) => {
-    if (argv.verbose) console.log(`Testing: ${argv.target ?? "all"}`);
-    process.exitCode = test({ target: argv.target });
-  }
+// src/actions/updo.ts
+import { runSteps as runSteps8 } from "@xylabs/ts-scripts-common";
+var updo = () => {
+  return runSteps8("Updo", [
+    ["yarn", "install"],
+    ["yarn", "upgrade-interactive"],
+    ["yarn", "dedupe"]
+  ]);
 };
 
-// src/xy/common/upplugCommand.ts
-var upplugCommand = {
-  command: "upplug",
-  describe: "UpPlug - Update Yarn Plugins",
-  handler: (argv) => {
-    if (argv.verbose) console.log("UpPlug");
-    process.exitCode = updateYarnPlugins();
-  }
+// src/actions/upplug.ts
+import { runSteps as runSteps9 } from "@xylabs/ts-scripts-common";
+var updateYarnPlugins = () => {
+  return runSteps9("Update Yarn Plugins", [
+    ["yarn", ["plugin", "import", "https://mskelton.dev/yarn-outdated/v3"]],
+    ["yarn", ["plugin", "import", "version"]],
+    ["yarn", ["plugin", "import", "interactive-tools"]],
+    ["yarn", ["plugin", "import", "workspace-tools"]]
+  ]);
 };
 
-// src/xy/common/upyarnCommand.ts
-var upyarnCommand = {
-  command: "upyarn",
-  describe: "UpYarn - Update Yarn Version",
-  handler: (argv) => {
-    if (argv.verbose) console.log("UpYarn");
-    process.exitCode = updateYarnVersion();
-  }
+// src/actions/upyarn.ts
+import { runSteps as runSteps10 } from "@xylabs/ts-scripts-common";
+var updateYarnVersion = () => {
+  return runSteps10("Update Yarn Version", [["yarn", ["set", "version", "latest"]]]);
 };
 
-// src/xy/common/yarn3OnlyCommand.ts
-var yarn3OnlyCommand = {
-  command: "yarn3only",
-  describe: "Yarn3Only - Check if using Yarn v3",
-  handler: (argv) => {
-    if (argv.verbose) console.log("Yarn 3 Check");
-    process.exitCode = yarn3Only();
+// src/actions/yarn3only.ts
+import { processEx } from "@xylabs/ts-scripts-common";
+var yarn3Only = () => {
+  const [valid, version] = isYarnVersionOrGreater(3);
+  if (!valid) {
+    processEx(`Invalid Yarn version [${version}]`);
   }
+  return 0;
 };
 
-// src/xy/common/index.ts
-var xyCommonCommands = (args) => {
-  return args.command(claudeCommand).command(licenseCommand).command(deadCommand).command(genDocsCommand).command(cleanDocsCommand).command(gitlintCommand).command(gitignoreCommand).command(npmignoreGenCommand).command(readmeCommand).command(retestCommand).command(testCommand).command(upplugCommand).command(upyarnCommand).command(yarn3OnlyCommand);
-};
+// src/actions/index.ts
+import {
+  clean,
+  dupdeps,
+  statics
+} from "@xylabs/ts-scripts-common";
 
 // src/xy/deploy/deployCommand.ts
 var deployCommand = {
@@ -4440,11 +333,11 @@ var xyDeployCommands = (args) => {
 };
 
 // src/xy/install/cleanCommand.ts
-var cleanCommand2 = {
+var cleanCommand = {
   command: "clean [package]",
   describe: "Clean",
-  builder: (yargs2) => {
-    return yargs2.positional("package", { describe: "Specific package to clean" });
+  builder: (yargs) => {
+    return yargs.positional("package", { describe: "Specific package to clean" });
   },
   handler: async (argv) => {
     if (argv.verbose) {
@@ -4509,403 +402,75 @@ var updoCommand = {
 
 // src/xy/install/index.ts
 var xyInstallCommands = (args) => {
-  return args.command(cleanCommand2).command(reinstallCommand).command(upCommand).command(updoCommand).command(staticsCommand).command(dupdepsCommand);
-};
-
-// src/xy/lint/cycleCommand.ts
-import chalk48 from "chalk";
-var cycleCommand = {
-  command: "cycle [package]",
-  describe: "Cycle - Check for dependency cycles",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  handler: async (argv) => {
-    const start = Date.now();
-    if (argv.verbose) console.log("Cycle");
-    process.exitCode = await cycle({ pkg: argv.package });
-    console.log(chalk48.blue(`Finished in ${Date.now() - start}ms`));
-  }
-};
-
-// src/xy/lint/deplintCommand.ts
-import chalk49 from "chalk";
-var deplintCommand = {
-  command: "deplint [package]",
-  describe: "Deplint - Run Deplint",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2).option("deps", {
-      alias: "d",
-      default: false,
-      description: "Check dependencies",
-      type: "boolean"
-    }).option("devDeps", {
-      alias: "v",
-      default: false,
-      description: "Check devDependencies",
-      type: "boolean"
-    }).option("peerDeps", {
-      alias: "p",
-      default: false,
-      description: "Check peerDependencies",
-      type: "boolean"
-    }).option("exclude", {
-      alias: "e",
-      description: "Package names to exclude from unused checks (comma-separated or repeated)",
-      type: "array"
-    });
-  },
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Deplint");
-    const start = Date.now();
-    const cliExclude = argv.exclude?.flatMap((v) => String(v).split(",")).map((v) => v.trim()).filter(Boolean);
-    process.exitCode = await deplint({
-      cliExclude,
-      pkg: argv.package,
-      deps: !!argv.deps,
-      devDeps: !!argv.devDeps,
-      peerDeps: !!argv.peerDeps,
-      verbose: !!argv.verbose
-    });
-    console.log(chalk49.blue(`Finished in ${Date.now() - start}ms`));
-  }
-};
-
-// src/xy/lint/fixCommand.ts
-import chalk50 from "chalk";
-var fixCommand = {
-  command: "fix [package]",
-  describe: "Fix - Run Eslint w/fix",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  handler: (argv) => {
-    const start = Date.now();
-    if (argv.verbose) console.log("Fix");
-    process.exitCode = fix();
-    console.log(chalk50.blue(`Finished in ${Date.now() - start}ms`));
-  }
-};
-
-// src/xy/lint/knipCommand.ts
-import chalk51 from "chalk";
-var knipCommand = {
-  command: "knip",
-  describe: "Knip - Run Knip",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  handler: (argv) => {
-    if (argv.verbose) console.log("Knip");
-    const start = Date.now();
-    process.exitCode = knip();
-    console.log(chalk51.blue(`Knip finished in ${Date.now() - start}ms`));
-  }
-};
-
-// src/xy/lint/lintCommand.ts
-import chalk52 from "chalk";
-var lintCommand = {
-  command: "lint [package]",
-  describe: "Lint - Run Eslint",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2).option("fix", {
-      alias: "f",
-      default: false,
-      description: "Fix fixable issues",
-      type: "boolean"
-    }).option("cache", {
-      alias: "c",
-      default: false,
-      description: "Use caching for performance",
-      type: "boolean"
-    });
-  },
-  handler: (argv) => {
-    if (argv.verbose) console.log("Lint");
-    const start = Date.now();
-    process.exitCode = argv.fix ? fix({
-      pkg: argv.package,
-      cache: argv.cache,
-      verbose: !!argv.verbose
-    }) : lint({
-      pkg: argv.package,
-      cache: argv.cache,
-      verbose: !!argv.verbose
-    });
-    console.log(chalk52.blue(`Finished in ${Date.now() - start}ms`));
-  }
+  return args.command(cleanCommand).command(reinstallCommand).command(upCommand).command(updoCommand).command(staticsCommand).command(dupdepsCommand);
 };
 
-// src/xy/lint/lintlintCommand.ts
-var lintlintCommand = {
-  command: "lintlint",
-  describe: "Lint Lint - Check for redundant or overridden ESLint rules vs shared config",
-  builder: (yargs2) => {
-    return yargs2.option("fix", {
-      default: false,
-      description: "Remove redundant rules from local config",
-      type: "boolean"
-    });
-  },
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Lint Lint");
-    process.exitCode = await lintlint({
-      fix: argv.fix,
-      verbose: !!argv.verbose
-    });
-  }
-};
+// src/xy/xy.ts
+import { xyBase } from "@xylabs/ts-scripts-common";
 
-// src/xy/lint/packageLintCommand.ts
-var packageLintCommand = {
-  builder: (yargs2) => {
-    return yargs2.option("fix", {
-      default: false,
-      description: "Auto-fix fixable issues",
-      type: "boolean"
-    });
-  },
-  command: "package-lint",
-  describe: "Package Lint - Check monorepo package structure",
+// src/xy/common/upplugCommand.ts
+var upplugCommand = {
+  command: "upplug",
+  describe: "UpPlug - Update Yarn Plugins",
   handler: (argv) => {
-    if (argv.verbose) console.log("Package Lint");
-    process.exitCode = packageLintMonorepo(!!argv.fix);
-  }
-};
-
-// src/xy/lint/publintCommand.ts
-import chalk53 from "chalk";
-var publintCommand = {
-  command: "publint [package]",
-  describe: "Publint - Run Publint",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
-  handler: async (argv) => {
-    if (argv.verbose) console.log("Publint");
-    const start = Date.now();
-    process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
-    console.log(chalk53.blue(`Finished in ${Date.now() - start}ms`));
+    if (argv.verbose) console.log("UpPlug");
+    process.exitCode = updateYarnPlugins();
   }
 };
 
-// src/xy/lint/relintCommand.ts
-import chalk54 from "chalk";
-var relintCommand = {
-  command: "relint [package]",
-  describe: "Relint - Clean & Lint",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
+// src/xy/common/upyarnCommand.ts
+var upyarnCommand = {
+  command: "upyarn",
+  describe: "UpYarn - Update Yarn Version",
   handler: (argv) => {
-    if (argv.verbose) console.log("Relinting");
-    const start = Date.now();
-    process.exitCode = relint();
-    console.log(chalk54.blue(`Finished in ${Date.now() - start}ms`));
+    if (argv.verbose) console.log("UpYarn");
+    process.exitCode = updateYarnVersion();
   }
 };
 
-// src/xy/lint/sonarCommand.ts
-import chalk55 from "chalk";
-var sonarCommand = {
-  command: "sonar",
-  describe: "Sonar - Run Sonar Check",
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
+// src/xy/common/yarn3OnlyCommand.ts
+var yarn3OnlyCommand = {
+  command: "yarn3only",
+  describe: "Yarn3Only - Check if using Yarn v3",
   handler: (argv) => {
-    const start = Date.now();
-    if (argv.verbose) console.log("Sonar Check");
-    process.exitCode = sonar();
-    console.log(chalk55.blue(`Finished in ${Date.now() - start}ms`));
+    if (argv.verbose) console.log("Yarn 3 Check");
+    process.exitCode = yarn3Only();
   }
 };
 
-// src/xy/lint/index.ts
-var xyLintCommands = (args) => {
-  return args.command(cycleCommand).command(lintCommand).command(lintlintCommand).command(deplintCommand).command(fixCommand).command(relintCommand).command(publintCommand).command(knipCommand).command(packageLintCommand).command(sonarCommand);
-};
-
-// src/xy/xy.ts
-import chalk56 from "chalk";
-
-// src/xy/xyParseOptions.ts
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-var xyParseOptions = () => {
-  return yargs(hideBin(process.argv)).scriptName("yarn xy").middleware((argv) => {
-    const commandName = argv._[0];
-    if (commandName && argv._.length <= 1) {
-      const result = tryRunLocalScript(commandName);
-      if (result !== void 0) {
-        process.exit(result);
-      }
-    }
-  }, true).option("jobs", {
-    alias: "j",
-    default: void 0,
-    description: "Max parallel jobs",
-    type: "number"
-  }).option("verbose", {
-    alias: "v",
-    default: false,
-    description: "Run with verbose logging",
-    type: "boolean"
-  }).option("incremental", {
-    alias: "i",
-    default: false,
-    description: "Attempt to perform the action only on changed packages",
-    type: "boolean"
-  }).option("profile", {
-    alias: "p",
-    default: false,
-    description: "Profile action",
-    type: "boolean"
-  });
+// src/xy/yarnCommands.ts
+var xyYarnCommands = (args) => {
+  return args.command(upplugCommand).command(upyarnCommand).command(yarn3OnlyCommand);
 };
 
 // src/xy/xy.ts
 var xy = async () => {
-  const options = xyParseOptions();
-  return await xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
-    console.error(chalk56.yellow(`Command not found [${chalk56.magenta(process.argv[2])}]`));
-    console.log(chalk56.gray("Try 'yarn xy --help' for list of commands"));
-  }).version().help().argv;
+  return await xyBase((args) => xyYarnCommands(xyInstallCommands(xyDeployCommands(args))));
 };
+
+// src/index.ts
+export * from "@xylabs/ts-scripts-common";
+registerPackageManager(new YarnPackageManager());
 export {
-  CROSS_PLATFORM_NEWLINE,
-  DEFAULT_README_BODY,
-  DEFAULT_README_TEMPLATE,
-  DuplicateDetector,
-  INIT_CWD,
-  LEGACY_COMMANDS_PREFIX,
-  WINDOWS_NEWLINE_REGEX,
-  XYLABS_COMMANDS_PREFIX,
-  XYLABS_RULES_PREFIX,
-  XYLABS_SKILLS_PREFIX,
-  applyLogoConfig,
-  build,
-  checkResult,
-  claudeClean,
-  claudeCommandTemplates,
-  claudeCommands,
-  claudeMdLocalTemplate,
-  claudeMdProjectTemplate,
-  claudeMdRuleTemplates,
-  claudeRules,
-  claudeSettings,
-  claudeSkillTemplates,
-  claudeSkills,
+  YarnPackageManager,
   clean,
-  cleanAll,
-  cleanDocs,
-  cleanPackage,
-  compile,
-  compileAll,
-  compilePackage,
-  copyAssets,
-  createBuildConfig,
-  cycle,
-  cycleAll,
-  cyclePackage,
-  dead,
-  defaultBuildConfig,
-  defaultReadFileSyncOptions,
-  deleteGlob,
-  deplint,
   deploy,
   deployMajor,
   deployMinor,
   deployNext,
-  detectDuplicateDependencies,
   dupdeps,
-  empty,
-  fix,
-  genDocs,
-  genDocsAll,
-  genDocsPackage,
-  generateIgnoreFiles,
-  generateReadmeFiles,
-  gitignore,
-  gitignoreGen,
-  gitignoreTemplate,
-  gitlint,
-  gitlintFix,
   isYarnVersionOrGreater,
-  knip,
-  license,
-  lint,
-  lintAllPackages,
-  lintPackage,
-  lintlint,
-  loadConfig,
-  loadPackageConfig,
-  multiLineToJSONArray,
-  notEmpty,
-  npmignoreGen,
-  packageClean,
-  packageCleanOutputs,
-  packageCleanTypescript,
-  packageCompile,
-  packageCompileTsc,
-  packageCompileTsup,
-  packageCopyAssets,
-  packageCycle,
-  packageGenDocs,
-  packageLint,
-  packageLintMonorepo,
-  packagePublint,
-  packageRecompile,
-  parsedPackageJSON,
-  processEx,
-  publint,
-  publintAll,
-  publintPackage,
   publish,
-  readLines,
-  readNonEmptyLines,
-  readmeGen,
-  readmeInit,
-  rebuild,
-  recompile,
-  recompileAll,
-  recompilePackage,
   reinstall,
-  relint,
-  relintAllPackages,
-  relintPackage,
-  resolveTemplatePath,
-  retest,
-  runStepAsync,
-  runSteps,
-  runStepsAsync,
-  runXy,
-  runXyWithWarning,
-  safeExit,
-  safeExitAsync,
-  scaffoldTemplate,
-  sonar,
   statics,
-  test,
-  tryReadFileSync,
-  tryRunLocalScript,
-  tsupOptions,
-  union,
   up,
   updateYarnPlugins,
   updateYarnVersion,
   updo,
-  withErrnoException,
-  withError,
-  writeLines,
   xy,
-  xyBuildCommands,
-  xyCommonCommands,
   xyDeployCommands,
   xyInstallCommands,
-  xyLintCommands,
-  xyParseOptions,
+  xyYarnCommands,
   yarn3Only,
   yarnWorkspace,
   yarnWorkspaces