@xylabs/toolchain 7.10.0

package/dist/xy/lint/index.mjs

@@ -0,0 +1,3759 @@
+// 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/concurrency.ts
+import { AsyncLocalStorage } from "async_hooks";
+var outputStorage = new AsyncLocalStorage();
+var captureInstalled = false;
+function installOutputCapture() {
+  if (captureInstalled) return;
+  captureInstalled = true;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  function intercept(original) {
+    return function(chunk, ...args) {
+      const buffer = outputStorage.getStore();
+      if (buffer) {
+        buffer.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+        return true;
+      }
+      return original(chunk, ...args);
+    };
+  }
+  process.stdout.write = intercept(originalStdoutWrite);
+  process.stderr.write = intercept(originalStderrWrite);
+}
+async function runWithConcurrency(items, concurrency, fn) {
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const i = next++;
+      await fn(items[i]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+}
+
+// src/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/pm/registry.ts
+var implementations = /* @__PURE__ */ new Map();
+function getPackageManager(name) {
+  const pmName = name ?? detectPackageManager();
+  const pm = implementations.get(pmName);
+  if (!pm) {
+    throw new Error(
+      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
+    );
+  }
+  return pm;
+}
+
+// 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);
+  }
+};
+
+// src/lib/dependencies/workspaceCycles.ts
+import { readFileSync } from "fs";
+import PATH from "path";
+import chalk3 from "chalk";
+function detectWorkspaceCycles(workspaces) {
+  const workspaceNames = new Set(workspaces.map((ws) => ws.name));
+  const graph = /* @__PURE__ */ new Map();
+  for (const ws of workspaces) {
+    const pkgPath = PATH.join(ws.location, "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    const deps = pkg.dependencies ?? {};
+    const devDeps = pkg.devDependencies ?? {};
+    const edges = [];
+    for (const dep of Object.keys(deps)) {
+      if (workspaceNames.has(dep)) edges.push({ name: dep, type: "dep" });
+    }
+    for (const dep of Object.keys(devDeps)) {
+      if (workspaceNames.has(dep)) edges.push({ name: dep, type: "devDep" });
+    }
+    graph.set(ws.name, edges);
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  const cycles = [];
+  const path9 = [];
+  const onPath = /* @__PURE__ */ new Set();
+  for (const name of workspaceNames) color.set(name, WHITE);
+  function dfs(u, incomingEdgeType) {
+    color.set(u, GRAY);
+    onPath.add(u);
+    path9.push({ name: u, edgeType: incomingEdgeType });
+    for (const edge of graph.get(u) ?? []) {
+      const v = edge.name;
+      if (onPath.has(v)) {
+        const cycleEdges = [];
+        const startIdx = path9.findIndex((p) => p.name === v);
+        for (let i = startIdx; i < path9.length - 1; i++) {
+          const nextEdgeType = path9[i + 1].edgeType ?? "dep";
+          cycleEdges.push({
+            from: path9[i].name,
+            to: path9[i + 1].name,
+            type: nextEdgeType
+          });
+        }
+        cycleEdges.push({
+          from: u,
+          to: v,
+          type: edge.type
+        });
+        cycles.push(cycleEdges);
+      } else if (color.get(v) === WHITE) {
+        dfs(v, edge.type);
+      }
+    }
+    path9.pop();
+    onPath.delete(u);
+    color.set(u, BLACK);
+  }
+  for (const name of workspaceNames) {
+    if (color.get(name) === WHITE) dfs(name);
+  }
+  return cycles;
+}
+function printWorkspaceCycles(cycles) {
+  for (const cycle2 of cycles) {
+    console.error(chalk3.red("  Workspace dependency cycle:"));
+    for (const edge of cycle2) {
+      const edgeLabel = edge.type === "devDep" ? chalk3.yellow("devDep") : chalk3.cyan("dep");
+      console.error(`    ${chalk3.white(edge.from)} --(${edgeLabel})--> ${chalk3.white(edge.to)}`);
+    }
+  }
+}
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+
+// src/lib/loadConfig.ts
+import chalk4 from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+import deepmerge from "deepmerge";
+var config;
+var rootConfigPath;
+var workspaceConfigCache = /* @__PURE__ */ new Map();
+var deprecationWarned = /* @__PURE__ */ new Set();
+function createExplorer() {
+  return cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } });
+}
+var loadConfig = async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await createExplorer().search();
+    config = cosmicConfigResult?.config ?? {};
+    rootConfigPath = cosmicConfigResult?.filepath;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk4.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk4.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
+  }
+  return deepmerge(config, params ?? {});
+};
+async function loadWorkspaceConfig(workspaceDir) {
+  const cached = workspaceConfigCache.get(workspaceDir);
+  if (cached !== void 0) return cached;
+  const result = await createExplorer().search(workspaceDir);
+  if (!result || result.filepath === rootConfigPath) {
+    workspaceConfigCache.set(workspaceDir, {});
+    return {};
+  }
+  const wsConfig = result.config ?? {};
+  workspaceConfigCache.set(workspaceDir, wsConfig);
+  return wsConfig;
+}
+var DEPRECATED_COMMAND_FIELDS = /* @__PURE__ */ new Set(["deplint", "publint"]);
+function resolveCommandField(cfg, commandName, configPath) {
+  const commands = cfg.commands;
+  const fromCommands = commands?.[commandName];
+  const fromTopLevel = cfg[commandName];
+  if (fromCommands !== void 0 && typeof fromCommands === "object") {
+    return fromCommands;
+  }
+  if (fromTopLevel !== void 0 && typeof fromTopLevel === "object" && DEPRECATED_COMMAND_FIELDS.has(commandName)) {
+    const key = `${configPath ?? "unknown"}:${commandName}`;
+    if (!deprecationWarned.has(key)) {
+      deprecationWarned.add(key);
+      console.warn(chalk4.yellow(
+        `[xy] Deprecated: top-level "${commandName}" in ${configPath ?? "xy.config"} \u2014 move to "commands.${commandName}"`
+      ));
+    }
+    return fromTopLevel;
+  }
+  return {};
+}
+async function loadWorkspaceCommandConfig(workspaceDir, commandName) {
+  const root = await loadConfig();
+  const rootCmd = resolveCommandField(root, commandName, rootConfigPath);
+  const wsConfig = await loadWorkspaceConfig(workspaceDir);
+  const wsConfigPath = workspaceConfigCache.has(workspaceDir) ? workspaceDir : void 0;
+  const wsCmd = resolveCommandField(wsConfig, commandName, wsConfigPath);
+  return deepmerge(rootCmd, wsCmd);
+}
+
+// src/lib/packageName.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path from "path";
+function packageName() {
+  if (process.env.npm_package_name) {
+    return process.env.npm_package_name;
+  }
+  try {
+    const pkgPath = path.join(INIT_CWD(), "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/runInstall.ts
+import { spawnSync } from "child_process";
+import chalk5 from "chalk";
+function runInstall(cwd) {
+  const pm = detectPackageManager();
+  console.log(chalk5.gray(`Running ${pm} install...`));
+  const result = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk5.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk5.green("Dependencies installed"));
+  return true;
+}
+
+// src/lib/runSteps.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import chalk6 from "chalk";
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = packageName();
+    console.log(chalk6.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config2]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(chalk6.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !existsSync2(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = spawnSync2(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/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 pm = getPackageManager();
+  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
+  return runSteps(
+    `Cycle [${pkg}]`,
+    [pm.runInWorkspace(pkg, "package-cycle", verboseOptions)]
+  );
+};
+var cycleAll = async ({ verbose = false }) => {
+  const pkgName = packageName();
+  let exitCode = 0;
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  const workspaceCycles = detectWorkspaceCycles(workspaces);
+  if (workspaceCycles.length > 0) {
+    console.error(`${pkgName} workspace dependency graph has ${workspaceCycles.length} cycle(s):`);
+    printWorkspaceCycles(workspaceCycles);
+    exitCode = 1;
+  } else if (verbose) {
+    console.log(`${pkgName} workspace dependency graph has no cycles`);
+  }
+  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);
+  }
+  if (result.exitCode !== 0) {
+    exitCode = result.exitCode;
+  }
+  if (exitCode === 0) {
+    console.log(`${pkgName} \u2705 No dependency violations`);
+  } else {
+    console.error(`${pkgName} \u274C Dependency violations found`);
+  }
+  return exitCode;
+};
+
+// src/actions/deplint/deplint.ts
+import chalk18 from "chalk";
+
+// src/actions/deplint/packageJsonEditor.ts
+import fs2 from "fs";
+import chalk7 from "chalk";
+import sortPackageJson from "sort-package-json";
+
+// src/actions/deplint/getRequiredPeerDependencies.ts
+import fs from "fs";
+import path2 from "path";
+function findDepPackageJson(location, dep) {
+  let dir = location;
+  while (true) {
+    const candidate = path2.join(dir, "node_modules", dep, "package.json");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path2.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 = fs.readFileSync(depPkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      const peerDeps = pkg.peerDependencies;
+      if (peerDeps) {
+        for (const peer of Object.keys(peerDeps)) {
+          required.add(peer);
+        }
+      }
+    } catch {
+    }
+  }
+  return required;
+}
+
+// src/actions/deplint/packageJsonEditor.ts
+function readPackageJson(location) {
+  return JSON.parse(fs2.readFileSync(`${location}/package.json`, "utf8"));
+}
+function writePackageJson(location, pkg) {
+  const sorted = sortPackageJson(JSON.stringify(pkg, null, 2));
+  fs2.writeFileSync(`${location}/package.json`, `${sorted}
+`);
+}
+function moveDep(pkg, dep, from, to) {
+  const fromSection = pkg[from];
+  if (!fromSection?.[dep]) return;
+  const version = fromSection[dep];
+  delete fromSection[dep];
+  if (Object.keys(fromSection).length === 0) {
+    delete pkg[from];
+  }
+  const toSection = pkg[to] ?? {};
+  toSection[dep] = version;
+  pkg[to] = toSection;
+}
+function removeDep(pkg, dep, section) {
+  const sectionObj = pkg[section];
+  if (!sectionObj?.[dep]) return;
+  delete sectionObj[dep];
+  if (Object.keys(sectionObj).length === 0) {
+    delete pkg[section];
+  }
+}
+function addDep(pkg, dep, version, section) {
+  const sectionObj = pkg[section] ?? {};
+  sectionObj[dep] = version;
+  pkg[section] = sectionObj;
+}
+function resolveDepVersion(location, dep) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (depPkgPath) {
+    try {
+      const depPkg = JSON.parse(fs2.readFileSync(depPkgPath, "utf8"));
+      const version = depPkg.version;
+      if (version) return `~${version}`;
+    } catch {
+    }
+  }
+  return "*";
+}
+function resolveExpectedPeerVersion(location, dep, currentRange) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (depPkgPath) {
+    try {
+      const depPkg = JSON.parse(fs2.readFileSync(depPkgPath, "utf8"));
+      const version = depPkg.version;
+      if (version) {
+        const match = /^(\d+)\.(\d+)/.exec(version);
+        if (match) {
+          if (currentRange?.startsWith("^")) {
+            return `^${match[1]}`;
+          }
+          return `~${match[1]}.${match[2]}`;
+        }
+        return `~${version}`;
+      }
+    } catch {
+    }
+  }
+  return "*";
+}
+
+// src/actions/deplint/packageEditor.ts
+var DeplintPackageEditor = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+    this.pkg = readPackageJson(workspace.location);
+  }
+  workspace;
+  pkg;
+  applyFix(fix2) {
+    switch (fix2.action) {
+      case "add": {
+        addDep(this.pkg, fix2.dependency, fix2.version, fix2.section);
+        break;
+      }
+      case "move": {
+        moveDep(this.pkg, fix2.dependency, fix2.fromSection, fix2.toSection);
+        if (fix2.version !== void 0 && this.pkg[fix2.toSection]?.[fix2.dependency] !== void 0) {
+          this.pkg[fix2.toSection][fix2.dependency] = fix2.version;
+        }
+        break;
+      }
+      case "remove": {
+        removeDep(this.pkg, fix2.dependency, fix2.section);
+        break;
+      }
+      case "set-version": {
+        addDep(this.pkg, fix2.dependency, fix2.version, fix2.section);
+        break;
+      }
+    }
+    return {
+      dependency: fix2.dependency,
+      detail: fix2.detail,
+      workspace: this.workspace
+    };
+  }
+  save() {
+    writePackageJson(this.workspace.location, this.pkg);
+  }
+};
+
+// src/actions/deplint/fixer.ts
+function applyDeplintFixes(diagnostics) {
+  const editors = /* @__PURE__ */ new Map();
+  const applied = [];
+  for (const diagnostic2 of diagnostics) {
+    for (const fix2 of diagnostic2.fixes ?? []) {
+      const workspaceKey = diagnostic2.workspace.location;
+      let editor = editors.get(workspaceKey);
+      if (!editor) {
+        editor = new DeplintPackageEditor(diagnostic2.workspace);
+        editors.set(workspaceKey, editor);
+      }
+      applied.push(editor.applyFix(fix2));
+    }
+  }
+  for (const editor of editors.values()) {
+    editor.save();
+  }
+  return applied;
+}
+
+// src/actions/deplint/findFiles.ts
+import fs3 from "fs";
+
+// src/actions/deplint/findFilesByGlob.ts
+import { globSync } from "glob";
+function findFilesByGlob(cwd, pattern, ignore) {
+  return globSync(pattern, {
+    cwd,
+    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 = fs3.readFileSync(`${location}/package.json`, "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.workspaces ?? [];
+  } catch {
+    return [];
+  }
+}
+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 fs4 from "fs";
+import path3 from "path";
+function getDependenciesFromPackageJson(packageJsonPath) {
+  const packageJsonFullPath = path3.resolve(packageJsonPath);
+  const rawContent = fs4.readFileSync(packageJsonFullPath, "utf8");
+  const packageJson = JSON.parse(rawContent);
+  const depsRecord = packageJson.dependencies ?? {};
+  const devDepsRecord = packageJson.devDependencies ?? {};
+  const peerDepsRecord = packageJson.peerDependencies ?? {};
+  const dependencies = Object.keys(depsRecord);
+  const devDependencies = Object.keys(devDepsRecord);
+  const peerDependencies = Object.keys(peerDepsRecord);
+  const dependencyVersions = depsRecord;
+  const devDependencyVersions = devDepsRecord;
+  const peerDependencyVersions = peerDepsRecord;
+  return {
+    dependencies,
+    dependencyVersions,
+    devDependencies,
+    devDependencyVersions,
+    peerDependencies,
+    peerDependencyVersions
+  };
+}
+
+// src/actions/deplint/getExtendsFromTsconfigs.ts
+import fs5 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;
+  }
+  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 parseTypesField(value) {
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
+}
+function parseTsconfig(file) {
+  const content = fs5.readFileSync(file, "utf8");
+  const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
+  return JSON.parse(cleaned);
+}
+function getExtendsFromTsconfigs(location) {
+  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of tsconfigFiles) {
+    try {
+      const parsed = parseTsconfig(file);
+      const refs = parseExtendsField(parsed.extends);
+      for (const ref of refs) {
+        if (isExternalReference(ref)) {
+          packages.add(getBasePackageName(ref));
+        }
+      }
+    } catch {
+    }
+  }
+  return [...packages];
+}
+function getTypesFromTsconfigs(location) {
+  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of tsconfigFiles) {
+    try {
+      const parsed = parseTsconfig(file);
+      const compilerOptions = parsed.compilerOptions;
+      const refs = parseTypesField(compilerOptions?.types);
+      for (const ref of refs) {
+        packages.add(getBasePackageName(ref));
+      }
+    } catch {
+    }
+  }
+  return [...packages];
+}
+
+// src/actions/deplint/getExternalImportsFromFiles.ts
+import fs7 from "fs";
+
+// src/actions/deplint/getImportsFromFile.ts
+import fs6 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 ?? false;
+}
+function getImportsFromFile(filePath, importPaths, typeImportPaths) {
+  const sourceCode = fs6.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 shipsTsconfig(location) {
+  try {
+    const raw = fs7.readFileSync(`${location}/package.json`, "utf8");
+    const pkg = JSON.parse(raw);
+    const files = pkg.files;
+    return files?.some((f) => f === "tsconfig.json" || f.includes("tsconfig")) ?? false;
+  } catch {
+    return false;
+  }
+}
+function getExternalImportsFromFiles({
+  allFiles,
+  distFiles,
+  location,
+  tsconfigExtends = [],
+  tsconfigTypes = []
+}) {
+  const allImportPaths = {};
+  const distImportPaths = {};
+  const distTypeImportPaths = {};
+  for (const path9 of allFiles) getImportsFromFile(path9, allImportPaths, allImportPaths).flat();
+  const distTypeFiles = distFiles.filter(isDeclarationFile);
+  const distCodeFiles = distFiles.filter((file) => !isDeclarationFile(file));
+  for (const path9 of distCodeFiles) getImportsFromFile(path9, distImportPaths, distImportPaths).flat();
+  for (const path9 of distTypeFiles) getImportsFromFile(path9, 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));
+  const isDistTsconfig = shipsTsconfig(location);
+  for (const ext of tsconfigExtends) {
+    if (!externalAllImports.includes(ext)) externalAllImports.push(ext);
+    if (isDistTsconfig && !externalDistImports.includes(ext)) externalDistImports.push(ext);
+  }
+  for (const typ of tsconfigTypes) {
+    if (!externalAllImports.includes(typ)) externalAllImports.push(typ);
+  }
+  return {
+    allImportPaths,
+    allImports,
+    distImportPaths,
+    distImports,
+    externalAllImports,
+    externalDistImports,
+    externalDistTypeImports,
+    tsconfigExtends: [...tsconfigExtends]
+  };
+}
+
+// src/actions/deplint/checkPackage/getMismatchedPeerDevVersions.ts
+import chalk8 from "chalk";
+import semver from "semver";
+function findMismatchedPeerDevVersions({
+  peerDependencies,
+  peerDependencyVersions,
+  devDependencyVersions
+}, exclude) {
+  const mismatches = [];
+  for (const dep of peerDependencies) {
+    if (exclude?.has(dep)) continue;
+    const peerVersion = peerDependencyVersions[dep];
+    const devVersion = devDependencyVersions[dep];
+    const hasWorkspaceProtocol = devVersion?.startsWith("workspace:") || peerVersion?.startsWith("workspace:");
+    if (devVersion && peerVersion !== devVersion && !hasWorkspaceProtocol && !semver.subset(devVersion, peerVersion)) {
+      mismatches.push({
+        dep,
+        devVersion,
+        peerVersion
+      });
+    }
+  }
+  return mismatches;
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
+import fs8 from "fs";
+import { builtinModules } from "module";
+import chalk9 from "chalk";
+
+// src/actions/deplint/tsScriptsAliases.ts
+var VARIANT_MAP = {
+  "@xylabs/ts-scripts-yarn3": "@xylabs/ts-scripts-pnpm",
+  "@xylabs/ts-scripts-pnpm": "@xylabs/ts-scripts-yarn3",
+  "@xylabs/ts-scripts-react-yarn3": "@xylabs/ts-scripts-react-pnpm",
+  "@xylabs/ts-scripts-react-pnpm": "@xylabs/ts-scripts-react-yarn3"
+};
+function isSatisfiedByTsScriptsVariant(imp, allDeps) {
+  const variant = VARIANT_MAP[imp];
+  return variant !== void 0 && allDeps.includes(variant);
+}
+function isUsedViaTsScriptsVariant(dep, imports) {
+  const variant = VARIANT_MAP[dep];
+  return variant !== void 0 && imports.includes(variant);
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
+function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
+  return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
+}
+function isDistTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies) {
+  return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || devDependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp);
+}
+function shouldBePeerDependency(imp, location, currentPeers, distImports) {
+  if (currentPeers.length === 0) return false;
+  const depPkgPath = findDepPackageJson(location, imp);
+  if (!depPkgPath) return false;
+  try {
+    const pkg = JSON.parse(fs8.readFileSync(depPkgPath, "utf8"));
+    const importPeers = Object.keys(pkg.peerDependencies ?? {});
+    return importPeers.length > 0 && importPeers.every(
+      (peer) => currentPeers.includes(peer) && distImports.includes(peer)
+    );
+  } catch {
+    return false;
+  }
+}
+function findUnlistedDependencies(name, dependencies, devDependencies, peerDependencies, externalDistImports, externalDistTypeImports) {
+  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies];
+  const results = [];
+  for (const imp of externalDistImports) {
+    if (!isRuntimeImportListed(imp, name, dependencies, peerDependencies) && !isSatisfiedByTsScriptsVariant(imp, allDeps)) {
+      results.push({ imp, section: "dependencies" });
+    }
+  }
+  for (const imp of externalDistTypeImports) {
+    if (!isDistTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies) && !isSatisfiedByTsScriptsVariant(imp, allDeps)) {
+      results.push({ imp, section: "dependencies" });
+    }
+  }
+  return results;
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
+import { builtinModules as builtinModules2 } from "module";
+import chalk10 from "chalk";
+function findUnlistedDevDeps(name, dependencies, devDependencies, peerDependencies, externalAllImports, distImports, externalDistTypeImports) {
+  const results = [];
+  for (const imp of externalAllImports) {
+    if (!distImports.includes(imp) && !externalDistTypeImports.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) && !isSatisfiedByTsScriptsVariant(imp, [...dependencies, ...devDependencies, ...peerDependencies])) {
+      results.push(imp);
+    }
+  }
+  return results;
+}
+
+// src/actions/deplint/checkPackage/getUnnecessaryPeerDependencies.ts
+import fs10 from "fs";
+import chalk12 from "chalk";
+
+// src/actions/deplint/checkPackage/getUnsatisfiedPeerDependencies.ts
+import fs9 from "fs";
+import chalk11 from "chalk";
+import semver2 from "semver";
+import sortPackageJson2 from "sort-package-json";
+function readDepPackageJson(location, dep) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (!depPkgPath) return void 0;
+  try {
+    return JSON.parse(fs9.readFileSync(depPkgPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readPeerDeps(location, dep) {
+  const pkg = readDepPackageJson(location, dep);
+  if (!pkg) return [];
+  const peers = pkg.peerDependencies;
+  return Object.keys(peers ?? {});
+}
+function readPeerVersionRange(location, dep, peer) {
+  const pkg = readDepPackageJson(location, dep);
+  if (!pkg) return void 0;
+  const peers = pkg.peerDependencies;
+  return peers?.[peer];
+}
+function readInstalledVersion(location, dep) {
+  const pkg = readDepPackageJson(location, dep);
+  if (!pkg) return void 0;
+  return pkg.version;
+}
+function isPeerOptionalInAll(location, peer, sources) {
+  for (const source of sources) {
+    const pkg = readDepPackageJson(location, source.requiredBy);
+    if (!pkg) continue;
+    const meta = pkg.peerDependenciesMeta?.[peer];
+    if (!meta?.optional) return false;
+  }
+  return true;
+}
+var MAX_TRANSITIVE_DEPTH = 2;
+function collectPeerSources(location, dependencies, devDependencies) {
+  const peerSources = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  function addPeerSource(peer, source) {
+    const sources = peerSources.get(peer) ?? [];
+    sources.push(source);
+    peerSources.set(peer, sources);
+  }
+  function collectFromDeps(deps, isRuntime, chain) {
+    for (const dep of deps) {
+      const visitKey = `${dep}:${chain.join(">")}`;
+      if (visited.has(visitKey)) continue;
+      visited.add(visitKey);
+      for (const peer of readPeerDeps(location, dep)) {
+        addPeerSource(peer, {
+          chain: chain.length > 0 ? [...chain, dep] : void 0,
+          isRuntimeDep: isRuntime,
+          requiredBy: dep
+        });
+      }
+      if (chain.length < MAX_TRANSITIVE_DEPTH) {
+        const depPkg = readDepPackageJson(location, dep);
+        if (depPkg) {
+          const transitiveDeps = Object.keys(depPkg.dependencies ?? {});
+          collectFromDeps(transitiveDeps, isRuntime, [...chain, dep]);
+        }
+      }
+    }
+  }
+  collectFromDeps(dependencies, true, []);
+  const devOnly = devDependencies.filter((d) => !dependencies.includes(d));
+  collectFromDeps(devOnly, false, []);
+  return peerSources;
+}
+function getRequiredTransitivePeers(location, { dependencies, devDependencies }) {
+  const peerSources = collectPeerSources(location, dependencies, devDependencies);
+  return new Set(peerSources.keys());
+}
+function resolveVersionRange(location, sources, peer) {
+  for (const source of sources) {
+    const range = readPeerVersionRange(location, source.requiredBy, peer);
+    if (range) return range;
+  }
+  return "*";
+}
+function checkVersionSatisfaction(location, peer, requestedRange) {
+  const installedVersion = readInstalledVersion(location, peer);
+  if (!installedVersion) return { satisfied: true };
+  if (requestedRange === "*") return { installedVersion, satisfied: true };
+  if (requestedRange.startsWith("workspace:")) return { installedVersion, satisfied: true };
+  try {
+    const satisfied = semver2.satisfies(installedVersion, requestedRange, { includePrerelease: true });
+    return { installedVersion, satisfied };
+  } catch {
+    return { installedVersion, satisfied: true };
+  }
+}
+function findDeclaredPeerVersionMismatches(name, location, peerDependencies, peerDependencyVersions, exclude) {
+  const results = [];
+  for (const peer of peerDependencies) {
+    if (exclude?.has(peer) || peer === name) continue;
+    const declaredRange = peerDependencyVersions[peer];
+    if (!declaredRange || declaredRange === "*") continue;
+    const { installedVersion, satisfied } = checkVersionSatisfaction(location, peer, declaredRange);
+    if (!satisfied) {
+      results.push({
+        hasRuntimeSource: true,
+        installedVersion,
+        peer,
+        reason: "version-mismatch",
+        sources: [{ isRuntimeDep: true, requiredBy: name }],
+        versionRange: declaredRange
+      });
+    }
+  }
+  return results;
+}
+function findUnsatisfiedPeers({ name, location }, {
+  dependencies,
+  devDependencies,
+  peerDependencies,
+  peerDependencyVersions
+}, exclude) {
+  const peerSources = collectPeerSources(location, dependencies, devDependencies);
+  const depsSet = new Set(dependencies);
+  const devDepsSet = new Set(devDependencies);
+  const unsatisfied = [];
+  for (const [peer, sources] of peerSources) {
+    if (exclude?.has(peer) || peer === name) continue;
+    if (isPeerOptionalInAll(location, peer, sources)) continue;
+    const hasRuntimeSource = sources.some((s) => s.isRuntimeDep);
+    const isPresent = depsSet.has(peer) || devDepsSet.has(peer);
+    if (!isPresent) {
+      const versionRange2 = resolveVersionRange(location, sources, peer);
+      unsatisfied.push({
+        hasRuntimeSource,
+        peer,
+        reason: "missing",
+        sources,
+        versionRange: versionRange2
+      });
+      continue;
+    }
+    const versionRange = resolveVersionRange(location, sources, peer);
+    const { installedVersion, satisfied } = checkVersionSatisfaction(location, peer, versionRange);
+    if (!satisfied) {
+      unsatisfied.push({
+        hasRuntimeSource,
+        installedVersion,
+        peer,
+        reason: "version-mismatch",
+        sources,
+        versionRange
+      });
+    }
+  }
+  return [
+    ...unsatisfied,
+    ...findDeclaredPeerVersionMismatches(name, location, peerDependencies, peerDependencyVersions, exclude)
+  ];
+}
+function resolvePeerTargetSections(hasRuntimeSource, isTerminal) {
+  if (!hasRuntimeSource) return ["devDependencies"];
+  if (isTerminal) return ["dependencies"];
+  return ["peerDependencies", "devDependencies"];
+}
+
+// src/actions/deplint/checkPackage/getUnnecessaryPeerDependencies.ts
+function isPeerImportedInDist(dep, externalDistImports, externalDistTypeImports) {
+  const baseName = dep.replace(/^@types\//, "");
+  return externalDistImports.includes(dep) || externalDistImports.includes(baseName) || externalDistTypeImports.includes(dep) || externalDistTypeImports.includes(baseName);
+}
+function findUnrequestedPeerDeps(location, packageParams, { externalDistImports, externalDistTypeImports }, exclude) {
+  const requiredPeers = getRequiredTransitivePeers(location, packageParams);
+  const unrequested = [];
+  for (const dep of packageParams.peerDependencies) {
+    if (exclude?.has(dep)) continue;
+    if (packageParams.dependencies.includes(dep)) continue;
+    if (!isPeerImportedInDist(dep, externalDistImports, externalDistTypeImports)) continue;
+    if (!requiredPeers.has(dep)) {
+      unrequested.push(dep);
+    }
+  }
+  return unrequested;
+}
+function findRedundantPeerDeps({ peerDependencies, dependencies }, exclude) {
+  const depsSet = new Set(dependencies);
+  const redundant = [];
+  for (const dep of peerDependencies) {
+    if (exclude?.has(dep)) continue;
+    if (depsSet.has(dep)) {
+      redundant.push(dep);
+    }
+  }
+  return redundant;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDependencies.ts
+import chalk13 from "chalk";
+function isDepImported(dep, distImports, distTypeImports) {
+  const baseName = dep.replace(/^@types\//, "");
+  return distImports.includes(dep) || distImports.includes(baseName) || distTypeImports.includes(dep) || distTypeImports.includes(baseName);
+}
+function findUnusedDependencies(location, dependencies, devDependencies, externalDistImports, externalDistTypeImports, externalAllImports, exclude) {
+  const runtimeRequiredPeers = getRequiredPeerDependencies(location, dependencies);
+  const devRequiredPeers = getRequiredPeerDependencies(location, devDependencies);
+  const results = [];
+  for (const dep of dependencies) {
+    if (exclude?.has(dep)) continue;
+    if (runtimeRequiredPeers.has(dep)) continue;
+    const isImported = isDepImported(dep, externalDistImports, externalDistTypeImports);
+    if (isImported || isUsedViaTsScriptsVariant(dep, [...externalDistImports, ...externalDistTypeImports])) continue;
+    if (devRequiredPeers.has(dep)) {
+      results.push({
+        dep,
+        kind: "move-to-dev",
+        reason: "only needed as peer of devDependencies"
+      });
+    } else if (externalAllImports.includes(dep)) {
+      results.push({ dep, kind: "move-to-dev" });
+    } else {
+      results.push({ dep, kind: "remove" });
+    }
+  }
+  return results;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
+import chalk14 from "chalk";
+
+// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
+import fs12 from "fs";
+import path6 from "path";
+import ts2 from "typescript";
+
+// src/actions/deplint/getScriptReferencedPackages.ts
+import fs11 from "fs";
+import path5 from "path";
+function getBinNames(location, dep) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (!depPkgPath) return [];
+  try {
+    const raw = fs11.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 = path5.join(location, "package.json");
+  let scripts;
+  try {
+    const raw = fs11.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 = fs12.readFileSync(filePath, "utf8");
+  } catch {
+    return tokens;
+  }
+  const isMjsFile = filePath.endsWith(".mjs");
+  const sourceFile = ts2.createSourceFile(
+    path6.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 fs13 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 = fs13.readFileSync(file, "utf8");
+    return decoratorPattern.test(content);
+  } catch {
+    return false;
+  }
+});
+var hasDependencyRequiringTslib = ({ location, allDependencies }) => allDependencies.some((dep) => {
+  const pkgPath = findDepPackageJson(location, dep);
+  if (!pkgPath) return false;
+  try {
+    const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf8"));
+    const peers = pkg.peerDependencies;
+    return peers !== void 0 && "tslib" in peers;
+  } 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(fs13.readFileSync(pkgPath, "utf8"));
+      const transitiveDeps = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {})
+      ];
+      if (transitiveDeps.some((d) => importPlugins.has(d))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var hasVitest = ({ allDependencies }) => allDependencies.includes("vitest");
+var isYarnRepo = () => detectPackageManager() === "yarn";
+var isPnpmRepo = () => detectPackageManager() === "pnpm";
+var rules = [
+  {
+    package: "typescript",
+    isNeeded: hasTypescriptFiles
+  },
+  {
+    package: "eslint-import-resolver-typescript",
+    isNeeded: (context) => hasTypescriptFiles(context) && context.allDependencies.includes("eslint") && hasImportPlugin(context)
+  },
+  {
+    package: "tslib",
+    isNeeded: (context) => hasDecorators(context) || hasDependencyRequiringTslib(context)
+  },
+  {
+    package: "@vitest/coverage-v8",
+    isNeeded: hasVitest
+  },
+  {
+    package: "@xylabs/ts-scripts-yarn3",
+    isNeeded: isYarnRepo
+  },
+  {
+    package: "@xylabs/ts-scripts-react-yarn3",
+    isNeeded: isYarnRepo
+  },
+  {
+    package: "@xylabs/ts-scripts-pnpm",
+    isNeeded: isPnpmRepo
+  },
+  {
+    package: "@xylabs/ts-scripts-react-pnpm",
+    isNeeded: isPnpmRepo
+  }
+];
+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);
+  }
+  if (allImports.has(dep)) return true;
+  return isUsedViaTsScriptsVariant(dep, [...allImports]);
+}
+function findUnusedDevDeps(location, dependencies, devDependencies, 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);
+  const unused = [];
+  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)) {
+      unused.push(dep);
+    }
+  }
+  return unused;
+}
+
+// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
+import chalk15 from "chalk";
+function isPeerUsed(dep, externalDistImports, externalDistTypeImports) {
+  const baseName = dep.replace(/^@types\//, "");
+  return externalDistImports.includes(dep) || externalDistImports.includes(baseName) || externalDistTypeImports.includes(dep) || externalDistTypeImports.includes(baseName);
+}
+function findUnusedPeerDeps(peerDependencies, externalDistImports, externalDistTypeImports, exclude) {
+  const unused = [];
+  for (const dep of peerDependencies) {
+    if (exclude?.has(dep)) continue;
+    if (!isPeerUsed(dep, externalDistImports, externalDistTypeImports)) {
+      unused.push(dep);
+    }
+  }
+  return unused;
+}
+
+// src/actions/deplint/checkPackage/getWorkspaceVersionProblems.ts
+import chalk16 from "chalk";
+import semver3 from "semver";
+function checkSection(deps, versions, section, workspaceNames, problems) {
+  for (const dep of deps) {
+    if (!workspaceNames.has(dep)) continue;
+    const version = versions[dep];
+    if (version && !version.startsWith("workspace:")) {
+      problems.push({
+        dep,
+        section,
+        version
+      });
+    }
+  }
+}
+function findWorkspaceVersionProblems(packageParams, workspaceNames) {
+  const problems = [];
+  checkSection(packageParams.dependencies, packageParams.dependencyVersions, "dependencies", workspaceNames, problems);
+  checkSection(packageParams.devDependencies, packageParams.devDependencyVersions, "devDependencies", workspaceNames, problems);
+  return problems;
+}
+function findWorkspacePeerVersionProblems(packageParams, workspaceNames, location) {
+  const problems = [];
+  for (const dep of packageParams.peerDependencies) {
+    if (!workspaceNames.has(dep)) continue;
+    const declaredRange = packageParams.peerDependencyVersions[dep];
+    if (!declaredRange || declaredRange.startsWith("workspace:")) continue;
+    const resolved = resolveDepVersion(location, dep);
+    const actualVersion = resolved.startsWith("~") ? resolved.slice(1) : resolved;
+    if (actualVersion === "*") continue;
+    if (!semver3.satisfies(actualVersion, declaredRange)) {
+      problems.push({
+        actualVersion,
+        declaredRange,
+        dep
+      });
+    }
+  }
+  return problems;
+}
+
+// src/actions/deplint/rules.ts
+function diagnostic(context, id, message, dependency, evidence, fixes) {
+  return {
+    dependency,
+    evidence,
+    file: context.packageJsonPath,
+    fixes,
+    id,
+    message,
+    severity: "error",
+    workspace: context.workspace
+  };
+}
+function resolvedAddFix(context, dependency, section, detail) {
+  return {
+    action: "add",
+    dependency,
+    detail,
+    section,
+    version: resolveDepVersion(context.workspace.location, dependency)
+  };
+}
+var unlistedDependenciesRule = {
+  category: "dependencies",
+  id: "deplint.dependencies.unlisted",
+  evaluate(context) {
+    const findings = findUnlistedDependencies(
+      context.workspace.name,
+      context.packageParams.dependencies,
+      context.packageParams.devDependencies,
+      context.packageParams.peerDependencies,
+      context.sourceParams.externalDistImports,
+      context.sourceParams.externalDistTypeImports
+    );
+    return findings.map(({ imp, section }) => {
+      const isPeer = !context.isTerminalPackage && section === "dependencies" && !context.forceDeps.has(imp) && shouldBePeerDependency(imp, context.workspace.location, context.packageParams.peerDependencies, context.sourceParams.externalDistImports);
+      const fixes = isPeer ? ["peerDependencies", "devDependencies"].map(
+        (s) => resolvedAddFix(context, imp, s, `added to ${s}`)
+      ) : [resolvedAddFix(context, imp, section, `added to ${section}`)];
+      return diagnostic(
+        context,
+        "deplint.dependencies.unlisted",
+        `Missing dependency in package.json: ${imp}`,
+        imp,
+        context.sourceParams.distImportPaths[imp],
+        fixes
+      );
+    });
+  }
+};
+var unusedDependenciesRule = {
+  category: "dependencies",
+  id: "deplint.dependencies.unused",
+  evaluate(context) {
+    const findings = findUnusedDependencies(
+      context.workspace.location,
+      context.packageParams.dependencies,
+      context.packageParams.devDependencies,
+      context.sourceParams.externalDistImports,
+      context.sourceParams.externalDistTypeImports,
+      context.sourceParams.externalAllImports,
+      context.unusedDependencyExclude
+    );
+    return findings.map(({
+      dep,
+      kind,
+      reason
+    }) => diagnostic(
+      context,
+      "deplint.dependencies.unused",
+      kind === "move-to-dev" ? `dependency should be devDependency in package.json: ${dep}${reason ? ` (${reason})` : ""}` : `Unused dependency in package.json: ${dep}`,
+      dep,
+      void 0,
+      [kind === "move-to-dev" ? {
+        action: "move",
+        dependency: dep,
+        detail: "moved to devDependencies",
+        fromSection: "dependencies",
+        toSection: "devDependencies"
+      } : {
+        action: "remove",
+        dependency: dep,
+        detail: "removed from dependencies",
+        section: "dependencies"
+      }]
+    ));
+  }
+};
+var unlistedDevDependenciesRule = {
+  category: "devDependencies",
+  id: "deplint.devDependencies.unlisted",
+  evaluate(context) {
+    const findings = findUnlistedDevDeps(
+      context.workspace.name,
+      context.packageParams.dependencies,
+      context.packageParams.devDependencies,
+      context.packageParams.peerDependencies,
+      context.sourceParams.externalAllImports,
+      context.sourceParams.distImports,
+      context.sourceParams.externalDistTypeImports
+    );
+    return findings.map((imp) => diagnostic(
+      context,
+      "deplint.devDependencies.unlisted",
+      `Missing devDependency in package.json: ${imp}`,
+      imp,
+      context.sourceParams.allImportPaths[imp],
+      [resolvedAddFix(context, imp, "devDependencies", "added to devDependencies")]
+    ));
+  }
+};
+var unusedDevDependenciesRule = {
+  category: "devDependencies",
+  id: "deplint.devDependencies.unused",
+  evaluate(context) {
+    const findings = findUnusedDevDeps(
+      context.workspace.location,
+      context.packageParams.dependencies,
+      context.packageParams.devDependencies,
+      context.packageParams.peerDependencies,
+      context.sourceParams,
+      context.fileContext,
+      context.unusedDependencyExclude
+    );
+    return findings.map((dep) => diagnostic(
+      context,
+      "deplint.devDependencies.unused",
+      `Unused devDependency in package.json: ${dep}`,
+      dep,
+      void 0,
+      [{
+        action: "remove",
+        dependency: dep,
+        detail: "removed from devDependencies",
+        section: "devDependencies"
+      }]
+    ));
+  }
+};
+var redundantDevDependenciesRule = {
+  category: "devDependencies",
+  id: "deplint.devDependencies.redundant",
+  evaluate(context) {
+    const diagnostics = [];
+    for (const dep of context.packageParams.devDependencies) {
+      if (!context.packageParams.dependencies.includes(dep)) continue;
+      if (!context.isTerminalPackage && !context.forceDeps.has(dep) && shouldBePeerDependency(dep, context.workspace.location, context.packageParams.peerDependencies, context.sourceParams.externalDistImports)) {
+        continue;
+      }
+      diagnostics.push(diagnostic(
+        context,
+        "deplint.devDependencies.redundant",
+        `Redundant devDependency ${dep} \u2014 already listed in dependencies`,
+        dep,
+        void 0,
+        [{
+          action: "remove",
+          dependency: dep,
+          detail: "removed redundant devDependency (kept in dependencies)",
+          section: "devDependencies"
+        }]
+      ));
+    }
+    return diagnostics;
+  }
+};
+function generateVersionMismatchFixes(context, finding) {
+  const expectedVersion = resolveExpectedPeerVersion(
+    context.workspace.location,
+    finding.peer,
+    finding.versionRange
+  );
+  if (expectedVersion === "*") return [];
+  const fixes = [];
+  if (context.packageParams.peerDependencies.includes(finding.peer)) {
+    fixes.push({
+      action: "set-version",
+      dependency: finding.peer,
+      detail: `updated peerDependency version to match installed (${finding.installedVersion})`,
+      section: "peerDependencies",
+      version: expectedVersion
+    });
+  }
+  if (context.packageParams.devDependencies.includes(finding.peer)) {
+    const devVersion = context.packageParams.devDependencyVersions[finding.peer];
+    if (devVersion && !devVersion.startsWith("workspace:")) {
+      fixes.push({
+        action: "set-version",
+        dependency: finding.peer,
+        detail: `updated devDependency version to match installed (${finding.installedVersion})`,
+        section: "devDependencies",
+        version: expectedVersion
+      });
+    }
+  }
+  return fixes;
+}
+var unsatisfiedPeersRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.unsatisfied",
+  evaluate(context) {
+    const findings = findUnsatisfiedPeers(context.workspace, context.packageParams, context.exclude);
+    return findings.map((finding) => {
+      const requiredBy = finding.sources.map((source) => source.requiredBy).join(", ");
+      const chain = finding.sources.find((source) => source.chain && source.chain.length > 0)?.chain?.join(" -> ");
+      const evidence = chain ? [`via ${chain}`] : void 0;
+      const message = finding.reason === "version-mismatch" ? `Peer dependency version mismatch ${finding.peer} \u2014 installed ${finding.installedVersion ?? "unknown"} does not satisfy ${finding.versionRange} (required by ${requiredBy})` : finding.hasRuntimeSource ? `Unsatisfied peer dependency ${finding.peer} (required by ${requiredBy}) \u2014 must be in dependencies or peerDependencies` : `Unsatisfied peer dependency ${finding.peer} (required by devDependency ${requiredBy}) \u2014 must be in dependencies, devDependencies, or peerDependencies`;
+      const fixes = finding.reason === "missing" ? resolvePeerTargetSections(finding.hasRuntimeSource, context.isTerminalPackage).map((section) => ({
+        action: "add",
+        dependency: finding.peer,
+        detail: `added to ${section}`,
+        section,
+        version: finding.versionRange
+      })) : finding.reason === "version-mismatch" ? generateVersionMismatchFixes(context, finding) : void 0;
+      return diagnostic(
+        context,
+        "deplint.peerDependencies.unsatisfied",
+        message,
+        finding.peer,
+        evidence,
+        fixes
+      );
+    });
+  }
+};
+var unusedPeerDependenciesRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.unused",
+  evaluate(context) {
+    const findings = findUnusedPeerDeps(
+      context.packageParams.peerDependencies,
+      context.sourceParams.externalDistImports,
+      context.sourceParams.externalDistTypeImports,
+      context.unusedDependencyExclude
+    );
+    return findings.map((dep) => diagnostic(
+      context,
+      "deplint.peerDependencies.unused",
+      context.packageParams.dependencies.includes(dep) ? `Unused peerDependency [already a dependency] in package.json: ${dep}` : `Unused peerDependency in package.json: ${dep}`,
+      dep,
+      void 0,
+      [{
+        action: "remove",
+        dependency: dep,
+        detail: "removed from peerDependencies",
+        section: "peerDependencies"
+      }]
+    ));
+  }
+};
+var unrequestedPeerDependenciesRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.unrequested",
+  evaluate(context) {
+    if (!context.isTerminalPackage) return [];
+    const findings = findUnrequestedPeerDeps(
+      context.workspace.location,
+      context.packageParams,
+      context.sourceParams,
+      context.exclude
+    );
+    return findings.map((dep) => diagnostic(
+      context,
+      "deplint.peerDependencies.unrequested",
+      `Unnecessary peerDependency ${dep} \u2014 imported in dist but no dependency requires it as a peer; should be a dependency`,
+      dep,
+      void 0,
+      [{
+        action: "move",
+        dependency: dep,
+        detail: "moved from peerDependencies to dependencies",
+        fromSection: "peerDependencies",
+        toSection: "dependencies",
+        version: context.packageParams.peerDependencyVersions[dep] ?? "*"
+      }]
+    ));
+  }
+};
+var misplacedDependenciesRule = {
+  category: "dependencies",
+  id: "deplint.dependencies.misplaced",
+  evaluate(context) {
+    if (context.isTerminalPackage) return [];
+    const diagnostics = [];
+    for (const dep of context.packageParams.dependencies) {
+      if (context.forceDeps.has(dep)) continue;
+      if (context.forcePeers.has(dep) || shouldBePeerDependency(dep, context.workspace.location, context.packageParams.peerDependencies, context.sourceParams.externalDistImports)) {
+        const fixes = [{
+          action: "move",
+          dependency: dep,
+          detail: "moved from dependencies to peerDependencies",
+          fromSection: "dependencies",
+          toSection: "peerDependencies"
+        }];
+        if (!context.packageParams.devDependencies.includes(dep)) {
+          fixes.push(resolvedAddFix(context, dep, "devDependencies", "added to devDependencies"));
+        }
+        const reason = context.forcePeers.has(dep) ? 'configured as refType "peer"' : "it shares peers with existing peerDependencies";
+        diagnostics.push(diagnostic(
+          context,
+          "deplint.dependencies.misplaced",
+          `dependency ${dep} should be a peerDependency \u2014 ${reason}`,
+          dep,
+          void 0,
+          fixes
+        ));
+      }
+    }
+    return diagnostics;
+  }
+};
+var misplacedPeerDependenciesRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.misplaced",
+  evaluate(context) {
+    const diagnostics = [];
+    for (const dep of context.packageParams.peerDependencies) {
+      if (context.forceDeps.has(dep)) {
+        const fixes = [{
+          action: "move",
+          dependency: dep,
+          detail: "moved from peerDependencies to dependencies",
+          fromSection: "peerDependencies",
+          toSection: "dependencies",
+          version: context.packageParams.peerDependencyVersions[dep] ?? "*"
+        }];
+        diagnostics.push(diagnostic(
+          context,
+          "deplint.peerDependencies.misplaced",
+          `peerDependency ${dep} should be a dependency \u2014 configured as refType "dep"`,
+          dep,
+          void 0,
+          fixes
+        ));
+      }
+    }
+    return diagnostics;
+  }
+};
+var redundantPeerDependenciesRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.redundant",
+  evaluate(context) {
+    const findings = findRedundantPeerDeps(context.packageParams, context.exclude);
+    return findings.map((dep) => diagnostic(
+      context,
+      "deplint.peerDependencies.redundant",
+      `Redundant peerDependency ${dep} \u2014 already listed in dependencies`,
+      dep,
+      void 0,
+      [{
+        action: "remove",
+        dependency: dep,
+        detail: "removed redundant peerDependency (kept in dependencies)",
+        section: "peerDependencies"
+      }]
+    ));
+  }
+};
+var mismatchedPeerDevVersionsRule = {
+  category: "peerDependencies",
+  id: "deplint.peerDependencies.version-mismatch",
+  evaluate(context) {
+    const findings = findMismatchedPeerDevVersions(context.packageParams, context.exclude);
+    return findings.map(({
+      dep,
+      devVersion,
+      peerVersion
+    }) => diagnostic(
+      context,
+      "deplint.peerDependencies.version-mismatch",
+      `Peer/dev version mismatch ${dep} \u2014 peer: ${peerVersion}, dev: ${devVersion}`,
+      dep,
+      void 0,
+      [{
+        action: "set-version",
+        dependency: dep,
+        detail: "synced peerDependency to devDependency version",
+        section: "peerDependencies",
+        version: devVersion
+      }]
+    ));
+  }
+};
+var workspaceVersionProblemsRule = {
+  category: "peerDependencies",
+  id: "deplint.workspace.protocol",
+  evaluate(context) {
+    if (!context.workspaceNames) return [];
+    const protocolFindings = findWorkspaceVersionProblems(context.packageParams, context.workspaceNames);
+    const protocolDiagnostics = protocolFindings.map(({
+      dep,
+      section,
+      version
+    }) => diagnostic(
+      context,
+      "deplint.workspace.protocol",
+      `Workspace dependency ${dep} in ${section} should use workspace: protocol \u2014 found ${version}`,
+      dep,
+      void 0,
+      [{
+        action: "set-version",
+        dependency: dep,
+        detail: `set workspace:~ for ${section}`,
+        section,
+        version: "workspace:~"
+      }]
+    ));
+    const peerFindings = findWorkspacePeerVersionProblems(
+      context.packageParams,
+      context.workspaceNames,
+      context.workspace.location
+    );
+    const peerDiagnostics = peerFindings.map(({
+      dep,
+      actualVersion,
+      declaredRange
+    }) => {
+      const expectedRange = resolveExpectedPeerVersion(
+        context.workspace.location,
+        dep,
+        declaredRange
+      );
+      return diagnostic(
+        context,
+        "deplint.workspace.protocol",
+        `Workspace peerDependency ${dep} range ${declaredRange} does not satisfy workspace version ${actualVersion}`,
+        dep,
+        void 0,
+        expectedRange === "*" ? void 0 : [{
+          action: "set-version",
+          dependency: dep,
+          detail: "updated peerDependency to match workspace version",
+          section: "peerDependencies",
+          version: expectedRange
+        }]
+      );
+    });
+    return [...protocolDiagnostics, ...peerDiagnostics];
+  }
+};
+var deplintRules = [
+  unlistedDependenciesRule,
+  unusedDependenciesRule,
+  misplacedDependenciesRule,
+  unlistedDevDependenciesRule,
+  unusedDevDependenciesRule,
+  redundantDevDependenciesRule,
+  unsatisfiedPeersRule,
+  unusedPeerDependenciesRule,
+  unrequestedPeerDependenciesRule,
+  misplacedPeerDependenciesRule,
+  redundantPeerDependenciesRule,
+  mismatchedPeerDevVersionsRule,
+  workspaceVersionProblemsRule
+];
+
+// src/actions/deplint/snapshot.ts
+import fs14 from "fs";
+function isTerminalPackage(location) {
+  try {
+    const pkg = JSON.parse(fs14.readFileSync(`${location}/package.json`, "utf8"));
+    return pkg.private === true;
+  } catch {
+    return false;
+  }
+}
+function buildWorkspaceContext(workspace, exclude, workspaceNames, forceDeps, forcePeers) {
+  const { allFiles, distFiles } = findFiles(workspace.location);
+  const tsconfigExtends = getExtendsFromTsconfigs(workspace.location);
+  const tsconfigTypes = getTypesFromTsconfigs(workspace.location);
+  const sourceParams = getExternalImportsFromFiles({
+    allFiles,
+    distFiles,
+    location: workspace.location,
+    tsconfigExtends,
+    tsconfigTypes
+  });
+  const packageJsonPath = `${workspace.location}/package.json`;
+  const packageParams = getDependenciesFromPackageJson(packageJsonPath);
+  const requiredTransitivePeers = getRequiredTransitivePeers(workspace.location, packageParams);
+  return {
+    exclude,
+    fileContext: { allFiles, distFiles },
+    forceDeps: forceDeps ?? /* @__PURE__ */ new Set(),
+    forcePeers: forcePeers ?? /* @__PURE__ */ new Set(),
+    isTerminalPackage: isTerminalPackage(workspace.location),
+    packageJsonPath,
+    packageParams,
+    sourceParams,
+    unusedDependencyExclude: /* @__PURE__ */ new Set([...exclude ?? [], ...requiredTransitivePeers]),
+    workspace,
+    workspaceNames
+  };
+}
+
+// src/actions/deplint/engine.ts
+function resolveCheckFlags(deps = false, devDeps = false, peerDeps = false) {
+  const noneExplicit = !(deps || devDeps || peerDeps);
+  return {
+    checkDependencies: deps || noneExplicit,
+    checkDevDependencies: devDeps || noneExplicit,
+    checkPeerDependencies: peerDeps || noneExplicit
+  };
+}
+function shouldRunRule(category, ruleId, options) {
+  const flags = resolveCheckFlags(options.deps, options.devDeps, options.peerDeps);
+  if (ruleId === "deplint.peerDependencies.unsatisfied") {
+    return flags.checkDependencies || flags.checkDevDependencies || flags.checkPeerDependencies;
+  }
+  if (ruleId === "deplint.workspace.protocol") {
+    return flags.checkDependencies || flags.checkDevDependencies || flags.checkPeerDependencies;
+  }
+  if (category === "dependencies") return flags.checkDependencies;
+  if (category === "devDependencies") return flags.checkDevDependencies;
+  return flags.checkPeerDependencies;
+}
+async function evaluateWorkspaces(workspaces, options, workspaceNames) {
+  const diagnostics = [];
+  for (const workspace of workspaces) {
+    const wsConfig = await loadWorkspaceCommandConfig(workspace.location, "deplint");
+    const exclude = /* @__PURE__ */ new Set([
+      ...wsConfig.exclude ?? [],
+      ...options.cliExclude ?? []
+    ]);
+    const packageEntries = Object.entries(wsConfig.packages ?? {});
+    const forceDeps = new Set(
+      packageEntries.filter(([, cfg]) => cfg.refType === "dep").map(([name]) => name)
+    );
+    const forcePeers = new Set(
+      packageEntries.filter(([, cfg]) => cfg.refType === "peer").map(([name]) => name)
+    );
+    const context = buildWorkspaceContext(workspace, exclude, workspaceNames, forceDeps, forcePeers);
+    if (options.verbose) {
+      console.info(`Checking package: ${workspace.name} at ${workspace.location}`);
+      console.info(`All files: ${context.fileContext.allFiles.length}, Distribution files: ${context.fileContext.distFiles.length}`);
+    }
+    for (const rule of deplintRules) {
+      if (shouldRunRule(rule.category, rule.id, options)) {
+        diagnostics.push(...rule.evaluate(context));
+      }
+    }
+  }
+  return diagnostics;
+}
+async function runDeplint(workspaces, options, workspaceNames) {
+  let diagnostics = await evaluateWorkspaces(workspaces, options, workspaceNames);
+  const appliedFixes = [];
+  const MAX_FIX_PASSES = 5;
+  for (let pass = 0; options.fix && diagnostics.length > 0 && pass < MAX_FIX_PASSES; pass++) {
+    appliedFixes.push(...applyDeplintFixes(diagnostics));
+    diagnostics = await evaluateWorkspaces(workspaces, options, workspaceNames);
+  }
+  const errorCount = diagnostics.filter((diagnostic2) => diagnostic2.severity === "error").length;
+  const warningCount = diagnostics.filter((diagnostic2) => diagnostic2.severity === "warning").length;
+  return {
+    appliedFixes,
+    diagnostics,
+    summary: {
+      appliedFixes: appliedFixes.length,
+      errorCount,
+      warningCount,
+      workspacesChecked: workspaces.length
+    }
+  };
+}
+
+// src/actions/deplint/reporters.ts
+import chalk17 from "chalk";
+var humanDeplintReporter = {
+  render(result) {
+    for (const fix2 of result.appliedFixes) {
+      console.log(`[${chalk17.blue(fix2.workspace.name)}] Fixed: ${fix2.detail} ${chalk17.green(fix2.dependency)}`);
+    }
+    for (const diagnostic2 of result.diagnostics) {
+      console.log(`[${chalk17.blue(diagnostic2.workspace.name)}] ${diagnostic2.message}`);
+      for (const line of diagnostic2.evidence ?? []) {
+        console.log(`  ${line}`);
+      }
+      console.log(`  ${chalk17.yellow(diagnostic2.file)}
+`);
+    }
+    if (result.summary.errorCount > 0) {
+      console.warn(`Deplint: Found ${chalk17.red(result.summary.errorCount)} dependency problems. ${chalk17.red("\u2716")}`);
+      return;
+    }
+    console.info(`Deplint: Found no dependency problems. ${chalk17.green("\u2714")}`);
+  }
+};
+var jsonDeplintReporter = {
+  render(result) {
+    console.log(JSON.stringify(result, null, 2));
+  }
+};
+function getDeplintReporter(format) {
+  return format === "json" ? jsonDeplintReporter : humanDeplintReporter;
+}
+
+// src/actions/deplint/deplint.ts
+var deplint = async ({
+  pkg,
+  deps,
+  devDeps,
+  fix: fix2,
+  peerDeps,
+  verbose,
+  cliExclude,
+  format = "human"
+}) => {
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  const workspaceNames = pm.name === "pnpm" ? new Set(workspaces.map((ws) => ws.name)) : void 0;
+  if (pkg === void 0 && format === "human") {
+    console.info("Deplint Started...");
+  }
+  const targetWorkspace = pkg === void 0 ? void 0 : pm.findWorkspace(pkg);
+  const targetWorkspaces = pkg === void 0 ? workspaces : targetWorkspace ? [targetWorkspace] : [];
+  if (targetWorkspaces.length === 0) {
+    console.error(chalk18.red(`Workspace not found: ${pkg}`));
+    return 1;
+  }
+  const result = await runDeplint(targetWorkspaces, {
+    cliExclude,
+    deps,
+    devDeps,
+    fix: fix2,
+    peerDeps,
+    reporter: format,
+    verbose
+  }, workspaceNames);
+  getDeplintReporter(format).render(result);
+  if (fix2 && result.summary.appliedFixes > 0) {
+    runInstall();
+  }
+  return result.summary.errorCount > 0 ? 1 : 0;
+};
+
+// src/actions/package-lint-deps.ts
+import { readFileSync as readFileSync3, writeFileSync } from "fs";
+import PATH2 from "path";
+import chalk19 from "chalk";
+import semver4 from "semver";
+function readWorkspacePackageJson(cwd, location) {
+  const pkgPath = PATH2.resolve(cwd, location, "package.json");
+  try {
+    return JSON.parse(readFileSync3(pkgPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeWorkspacePackageJson(cwd, location, pkg) {
+  const pkgPath = PATH2.resolve(cwd, location, "package.json");
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function buildWorkspaceVersionMap(cwd, workspaces) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) map.set(name, version);
+  }
+  return map;
+}
+function expectedPeerRange(devDepVersion, targetVersion) {
+  const parsed = semver4.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  if (devDepVersion === "workspace:^") {
+    return `^${parsed.major}`;
+  }
+  return `~${parsed.major}.${parsed.minor}`;
+}
+function checkInternalPeerVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      if (version.startsWith("workspace:")) {
+        const expected2 = expectedPeerRange(devDeps?.[dep], targetVersion);
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} uses workspace: protocol \u2014 should be "${expected2}"`
+        );
+        continue;
+      }
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected && !semver4.satisfies(targetVersion, version)) {
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} is "${version}" \u2014 current version ${targetVersion} is not satisfied; expected "${expected}"`
+        );
+      }
+    }
+  }
+  return result;
+}
+function fixInternalPeerVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    let modified = false;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected) {
+        peerDeps[dep] = expected;
+        console.log(chalk19.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
+        modified = true;
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+
+// src/actions/lintNext.ts
+import path7 from "path";
+import chalk20 from "chalk";
+import { ESLint } from "eslint";
+var dumpMessages = (lintResults) => {
+  const colors = ["white", "yellow", "red"];
+  const severity = ["none", "warning", "error"];
+  for (const lintResult of lintResults) {
+    if (lintResult.messages.length > 0) {
+      console.log(chalk20.gray(`
+${lintResult.filePath}`));
+      for (const message of lintResult.messages) {
+        console.log(
+          chalk20.gray(`	${message.line}:${message.column}`),
+          chalk20[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk20.white(`	${message.message}`),
+          chalk20.gray(`	${message.ruleId}`)
+        );
+      }
+    }
+  }
+};
+async function lintOnePackage({
+  cache,
+  cwd,
+  fix: fix2,
+  verbose
+}) {
+  const engine = new ESLint({
+    cache,
+    cacheLocation: path7.join(cwd, ".eslintcache"),
+    cacheStrategy: "content",
+    cwd,
+    fix: fix2,
+    warnIgnored: false
+  });
+  const lintResults = await engine.lintFiles(".");
+  dumpMessages(lintResults);
+  if (fix2) {
+    await ESLint.outputFixes(lintResults);
+  }
+  const errors = lintResults.reduce((sum, r) => sum + r.errorCount, 0);
+  const warnings = lintResults.reduce((sum, r) => sum + r.warningCount, 0);
+  const files = lintResults.length;
+  if (verbose) {
+    const filesColor = files < 100 ? "green" : files < 1e3 ? "yellow" : "red";
+    console.log(chalk20.white(`  ${chalk20[filesColor](files)} files linted`));
+  }
+  return {
+    errors,
+    files,
+    warnings
+  };
+}
+async function lintNext({
+  cache = false,
+  fix: fix2 = false,
+  jobs,
+  pkg,
+  verbose = false
+}) {
+  const rootDir = INIT_CWD();
+  const pm = getPackageManager();
+  const allWorkspaces = pm.listWorkspaces();
+  const workspaces = pkg ? allWorkspaces.filter((ws) => ws.name === pkg) : allWorkspaces;
+  if (workspaces.length === 0) {
+    console.log(chalk20.red(pkg ? `Package "${pkg}" not found` : "No workspaces found"));
+    return 1;
+  }
+  const concurrency = jobs;
+  const label = fix2 ? "Fix" : "Lint";
+  installOutputCapture();
+  const results = Array.from(
+    { length: workspaces.length },
+    () => ({
+      errors: 0,
+      files: 0,
+      output: [],
+      pkg: "",
+      timeMs: 0,
+      warnings: 0
+    })
+  );
+  await runWithConcurrency(
+    workspaces.map((ws, i) => ({ i, ws })),
+    concurrency,
+    async ({ i, ws }) => {
+      const output = [];
+      await outputStorage.run(output, async () => {
+        const pkgStart = Date.now();
+        const absCwd = path7.resolve(rootDir, ws.location);
+        console.log(chalk20.green(`${label} [${ws.name}]`));
+        try {
+          const {
+            errors,
+            files,
+            warnings
+          } = await lintOnePackage({
+            cache,
+            cwd: absCwd,
+            fix: fix2,
+            verbose
+          });
+          const timeMs = Date.now() - pkgStart;
+          results[i] = {
+            errors,
+            files,
+            output,
+            pkg: ws.name,
+            timeMs,
+            warnings
+          };
+        } catch (ex) {
+          output.push(chalk20.red(`${label} failed for ${ws.name}: ${ex.message}
+`));
+          results[i] = {
+            errors: 1,
+            files: 0,
+            output,
+            pkg: ws.name,
+            timeMs: Date.now() - pkgStart,
+            warnings: 0
+          };
+        }
+      });
+    }
+  );
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalFiles = 0;
+  for (const result of results) {
+    for (const line of result.output) {
+      process.stdout.write(line);
+    }
+    totalErrors += result.errors;
+    totalWarnings += result.warnings;
+    totalFiles += result.files;
+  }
+  const errColor = totalErrors > 0 ? "red" : "green";
+  const warnColor = totalWarnings > 0 ? "yellow" : "green";
+  console.log(
+    chalk20[errColor](`${totalErrors} errors`) + chalk20.gray(", ") + chalk20[warnColor](`${totalWarnings} warnings`) + chalk20.gray(` across ${totalFiles} files in ${workspaces.length} packages`)
+  );
+  return totalErrors;
+}
+
+// src/actions/lint.ts
+var lintPackage = ({
+  pkg,
+  fix: fix2,
+  verbose
+}) => {
+  const pm = getPackageManager();
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [${pkg}]`, [
+    pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
+  ]);
+};
+var lint = ({
+  cache,
+  fix: fix2,
+  jobs,
+  next,
+  pkg,
+  verbose
+}) => {
+  if (next) {
+    return lintNext({
+      cache,
+      fix: fix2,
+      jobs,
+      pkg,
+      verbose
+    });
+  }
+  return pkg === void 0 ? lintAllPackages({ fix: fix2 }) : lintPackage({
+    pkg,
+    fix: fix2,
+    verbose
+  });
+};
+var lintAllPackages = ({ fix: fix2 = false } = {}) => {
+  const fixOptions = fix2 ? ["--fix"] : [];
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [All-Packages]`, [
+    ["eslint", ["--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
+  ]);
+};
+
+// src/actions/fix.ts
+var fix = (params) => {
+  return lint({ ...params, fix: true });
+};
+
+// src/actions/knip.ts
+var knip = () => {
+  return runSteps("Knip", [["knip", ["--dependencies", "--no-exit-code"]]]);
+};
+
+// src/actions/lint-init.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH3 from "path";
+import { createInterface } from "readline";
+import chalk21 from "chalk";
+import { globSync as globSync3 } from "glob";
+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 DISALLOWED_IMPORTS_XYLABS = [
+  "@xylabs/api",
+  "@xylabs/array",
+  "@xylabs/arraybuffer",
+  "@xylabs/assert",
+  "@xylabs/axios",
+  "@xylabs/base",
+  "@xylabs/bignumber",
+  "@xylabs/buffer",
+  "@xylabs/creatable",
+  "@xylabs/decimal-precision",
+  "@xylabs/delay",
+  "@xylabs/enum",
+  "@xylabs/error",
+  "@xylabs/eth-address",
+  "@xylabs/events",
+  "@xylabs/exists",
+  "@xylabs/forget",
+  "@xylabs/function-name",
+  "@xylabs/hex",
+  "@xylabs/log",
+  "@xylabs/logger",
+  "@xylabs/object",
+  "@xylabs/platform",
+  "@xylabs/profile",
+  "@xylabs/promise",
+  "@xylabs/retry",
+  "@xylabs/set",
+  "@xylabs/static-implements",
+  "@xylabs/storage",
+  "@xylabs/telemetry",
+  "@xylabs/telemetry-exporter",
+  "@xylabs/timer",
+  "@xylabs/typeof",
+  "@xylabs/url",
+  "@xylabs/zod"
+];
+var DISALLOWED_IMPORTS_XYO = [
+  "@xyo-network/core-payload-plugins",
+  "@xyo-network/manifest",
+  "@xyo-network/modules",
+  "@xyo-network/protocol",
+  "@xyo-network/sdk-utils",
+  "@xyo-network/shared",
+  "@xyo-network/manifest-model",
+  "@xyo-network/manifest-wrapper",
+  "@xyo-network/boundwitness",
+  "@xyo-network/core",
+  "@xyo-network/crypto",
+  "@xyo-network/payload",
+  "@xyo-network/api",
+  "@xyo-network/api-models",
+  "@xyo-network/dns",
+  "@xyo-network/metamask-connector",
+  "@xyo-network/module-factory-locator",
+  "@xyo-network/schema-payload-plugin",
+  "@xyo-network/archivist-memory",
+  "@xyo-network/id-payload-plugin",
+  "@xyo-network/wallet",
+  "@xyo-network/network",
+  "@xyo-network/payload-plugin",
+  "@xyo-network/payloadset-plugin",
+  "@xyo-network/quadkey",
+  "@xyo-network/schema-cache",
+  "@xyo-network/schema-name-validator",
+  "@xyo-network/witnesses"
+];
+function getRequiredDevDependencies(react) {
+  const configPkg = react ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  return {
+    [configPkg]: "workspace:^",
+    eslint: "^10.0.0"
+  };
+}
+function formatDisallowedArray(name, imports) {
+  const items = imports.map((i) => `  '${i}',`).join("\n");
+  return `const ${name} = [
+${items}
+]`;
+}
+function generateEslintConfig({
+  react,
+  useXyLabsBarrel,
+  useXyoBarrel
+}) {
+  const configPkg = react ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  const lines = [
+    "import type { Linter } from 'eslint'",
+    "",
+    `import { config as xylabsConfig } from '${configPkg}'`,
+    ""
+  ];
+  if (useXyLabsBarrel) {
+    lines.push(formatDisallowedArray("disallowedImportsXyLabs", DISALLOWED_IMPORTS_XYLABS), "");
+  }
+  if (useXyoBarrel) {
+    lines.push(formatDisallowedArray("disallowedImportsXyo", DISALLOWED_IMPORTS_XYO), "");
+  }
+  lines.push("const config: Linter.Config[] = [", "  { ignores: ['.yarn/**', 'build', '**/build/**', '**/dist/**', 'dist', 'node_modules/**', '**/node_modules/**', '**/*.md/**', '.claude/worktrees/*'] },", "  ...xylabsConfig,");
+  if (useXyLabsBarrel || useXyoBarrel) {
+    lines.push("  {", "    rules:", "    {", "      'no-restricted-imports': [", "        'warn',", "        {");
+    if (useXyLabsBarrel && useXyoBarrel) {
+      lines.push("          paths: [", "            ...disallowedImportsXyLabs,", "            ...disallowedImportsXyo,", "          ],");
+    } else if (useXyLabsBarrel) {
+      lines.push("          paths: [", "            ...disallowedImportsXyLabs,", "          ],");
+    } else {
+      lines.push("          paths: [", "            ...disallowedImportsXyo,", "          ],");
+    }
+    lines.push("        },", "      ],", "    },", "  },");
+  }
+  lines.push("]", "", "export default config", "");
+  return lines.join("\n");
+}
+function addDevDependencies(packageJsonPath, requiredDeps, verbose) {
+  const content = readFileSync4(packageJsonPath, "utf8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  let changed = false;
+  for (const [name, version] of Object.entries(requiredDeps)) {
+    if (!devDeps[name]) {
+      devDeps[name] = version;
+      changed = true;
+      if (verbose) console.log(chalk21.gray(`  Added ${name}@${version} to devDependencies`));
+    } else if (verbose) {
+      console.log(chalk21.gray(`  ${name} already in devDependencies`));
+    }
+  }
+  if (changed) {
+    const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
+    pkg.devDependencies = sorted;
+    writeFileSync2(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+    console.log(chalk21.green("Updated package.json devDependencies"));
+  } else {
+    console.log(chalk21.gray("package.json devDependencies already up to date"));
+  }
+  return changed;
+}
+function detectReactInMonorepo(cwd, verbose) {
+  const packageJsonPaths = globSync3("packages/**/package.json", {
+    cwd,
+    ignore: ["**/node_modules/**"]
+  });
+  for (const relPath of packageJsonPaths) {
+    const fullPath = PATH3.resolve(cwd, relPath);
+    try {
+      const content = readFileSync4(fullPath, "utf8");
+      const pkg = JSON.parse(content);
+      const deps = pkg.dependencies;
+      const peerDeps = pkg.peerDependencies;
+      if (deps?.react || peerDeps?.react) {
+        if (verbose) console.log(chalk21.gray(`  React detected in ${relPath}`));
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function findExistingConfig(configPath, legacyConfigPath) {
+  if (existsSync3(configPath)) return configPath;
+  if (existsSync3(legacyConfigPath)) return legacyConfigPath;
+  return void 0;
+}
+function removeLegacyConfig(legacyConfigPath) {
+  if (existsSync3(legacyConfigPath)) {
+    unlinkSync(legacyConfigPath);
+    console.log(chalk21.gray("Removed legacy eslint.config.mjs"));
+  }
+}
+function updateDependencies(packageJsonPath, react, cwd, verbose) {
+  if (!existsSync3(packageJsonPath)) {
+    console.log(chalk21.yellow("No package.json found \u2014 skipping dependency updates"));
+    return;
+  }
+  const changed = addDevDependencies(packageJsonPath, getRequiredDevDependencies(react), verbose);
+  if (changed) {
+    runInstall(cwd);
+  }
+}
+async function lintInit({ verbose } = {}) {
+  const cwd = INIT_CWD();
+  const configPath = PATH3.resolve(cwd, "eslint.config.ts");
+  const legacyConfigPath = PATH3.resolve(cwd, "eslint.config.mjs");
+  const existingPath = findExistingConfig(configPath, legacyConfigPath);
+  if (existingPath) {
+    const filename = PATH3.basename(existingPath);
+    const confirmed = await askConfirmation(
+      chalk21.yellow(`${filename} already exists. Replace it with eslint.config.ts? (y/N) `)
+    );
+    if (!confirmed) {
+      console.log(chalk21.gray(`Skipped \u2014 existing ${filename} preserved`));
+      return 0;
+    }
+  }
+  const react = detectReactInMonorepo(cwd, verbose);
+  if (react) {
+    console.log(chalk21.cyan("Detected React packages \u2014 using @xylabs/eslint-config-react-flat"));
+  } else if (verbose) {
+    console.log(chalk21.gray("  No React packages detected \u2014 using @xylabs/eslint-config-flat"));
+  }
+  const useXyLabsBarrel = await askConfirmation(
+    chalk21.cyan("Disallow @xylabs/sdk-js barrel imports? (y/N) ")
+  );
+  const useXyoBarrel = await askConfirmation(
+    chalk21.cyan("Disallow @xyo-network/sdk-js barrel imports? (y/N) ")
+  );
+  const config2 = generateEslintConfig({
+    react,
+    useXyLabsBarrel,
+    useXyoBarrel
+  });
+  writeFileSync2(configPath, config2, "utf8");
+  console.log(chalk21.green("Generated eslint.config.ts"));
+  removeLegacyConfig(legacyConfigPath);
+  updateDependencies(PATH3.resolve(cwd, "package.json"), react, cwd, verbose);
+  return 0;
+}
+
+// src/actions/lintlint.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import {
+  existsSync as existsSync4,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync3
+} from "fs";
+import PATH4 from "path";
+import chalk22 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;
+}
+function extractConfigBlocks(sharedModule) {
+  const config2 = sharedModule.config ?? sharedModule.default;
+  if (Array.isArray(config2)) return config2;
+  return [];
+}
+async function resolveSharedConfig(configDir, sharedPkg) {
+  try {
+    const sharedModule = await import(sharedPkg);
+    return extractConfigBlocks(sharedModule);
+  } catch {
+    const distPath = PATH4.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
+    try {
+      const sharedModule = await import(distPath);
+      return extractConfigBlocks(sharedModule);
+    } catch {
+      const neutralPath = PATH4.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
+      const sharedModule = await import(neutralPath);
+      return extractConfigBlocks(sharedModule);
+    }
+    return [];
+  }
+}
+async function loadSharedRules(configDir, sharedPkg, verbose) {
+  const sharedBlocks = await resolveSharedConfig(configDir, sharedPkg);
+  const sharedRules = mergeRulesFromBlocks(sharedBlocks);
+  if (verbose) {
+    console.log(chalk22.gray(`Shared config defines ${sharedRules.size} rules`));
+  }
+  if (sharedRules.size === 0) {
+    console.error(chalk22.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(chalk22.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(chalk22.yellow(`
+${redundant.length} redundant rule(s) (same as shared config \u2014 can be removed):`));
+    for (const { rule, local } of redundant) {
+      console.log(chalk22.yellow(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (overrides.length > 0) {
+    console.log(chalk22.cyan(`
+${overrides.length} rule override(s) (different from shared config):`));
+    for (const {
+      rule,
+      local,
+      shared
+    } of overrides) {
+      console.log(chalk22.cyan(`  ${rule}:`));
+      console.log(chalk22.gray(`    shared: ${formatRule(shared)}`));
+      console.log(chalk22.white(`    local:  ${formatRule(local)}`));
+    }
+  }
+  if (additions.length > 0 && verbose) {
+    console.log(chalk22.gray(`
+${additions.length} local addition(s) (not in shared config):`));
+    for (const { rule, local } of additions) {
+      console.log(chalk22.gray(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (redundant.length === 0 && overrides.length === 0) {
+    console.log(chalk22.green("No redundant or overridden rules found"));
+  }
+}
+function fixRedundantRules(eslintConfigPath, redundant) {
+  let updated = readFileSync5(eslintConfigPath, "utf8");
+  const original = updated;
+  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(/\{\s*rules\s*:\s*\{\s*\}\s*,?\s*\}\s*,?/g, "");
+  updated = updated.replaceAll(/\n{3,}/g, "\n\n");
+  if (updated !== original) {
+    writeFileSync3(eslintConfigPath, updated, "utf8");
+    console.log(chalk22.green(`
+Fixed: removed ${redundant.length} redundant rule(s)`));
+  }
+}
+function formatConfigFile(eslintConfigPath) {
+  spawnSync3("eslint", ["--fix", eslintConfigPath], { stdio: "inherit" });
+}
+function fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg) {
+  const updated = source.replaceAll(sharedPkg, expectedPkg);
+  writeFileSync3(eslintConfigPath, updated, "utf8");
+  console.log(chalk22.green(`Fixed: replaced ${sharedPkg} with ${expectedPkg}`));
+  const packageJsonPath = PATH4.resolve(configDir, "package.json");
+  if (!existsSync4(packageJsonPath)) return;
+  const content = readFileSync5(packageJsonPath, "utf8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  const oldVersion = devDeps[sharedPkg];
+  if (!oldVersion) return;
+  delete devDeps[sharedPkg];
+  devDeps[expectedPkg] = oldVersion;
+  const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
+  pkg.devDependencies = sorted;
+  writeFileSync3(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  console.log(chalk22.green(`Updated package.json: ${sharedPkg} \u2192 ${expectedPkg}`));
+  runInstall(configDir);
+}
+function checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, fix2, verbose) {
+  const hasReact = detectReactInMonorepo(configDir, verbose);
+  const expectedPkg = hasReact ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  if (sharedPkg === expectedPkg) return false;
+  console.log(chalk22.yellow(`
+Config mismatch: using ${sharedPkg} but ${hasReact ? "React packages detected" : "no React packages found"}`));
+  console.log(chalk22.yellow(`  Expected: ${expectedPkg}`));
+  if (fix2) {
+    fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg);
+  }
+  return true;
+}
+async function lintlint({ fix: fix2, verbose } = {}) {
+  const eslintConfigPath = await findUp(["eslint.config.ts", "eslint.config.mjs"]);
+  if (!eslintConfigPath) {
+    console.error(chalk22.red("No eslint.config.ts found"));
+    return 1;
+  }
+  const configDir = PATH4.dirname(eslintConfigPath);
+  if (verbose) {
+    console.log(chalk22.gray(`Found config: ${eslintConfigPath}`));
+  }
+  const source = readFileSync5(eslintConfigPath, "utf8");
+  const sharedPkg = detectSharedPackage(source);
+  if (!sharedPkg) {
+    console.log(chalk22.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
+    return 0;
+  }
+  if (verbose) {
+    console.log(chalk22.gray(`Shared package: ${sharedPkg}`));
+  }
+  const hasMismatch = checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, !!fix2, !!verbose);
+  const currentSource = hasMismatch && fix2 ? readFileSync5(eslintConfigPath, "utf8") : source;
+  const sharedRules = await loadSharedRules(configDir, sharedPkg, !!verbose);
+  if (!sharedRules) return 1;
+  const { explicit, resolved } = await loadLocalRules(eslintConfigPath, currentSource, !!verbose);
+  const results = compareRules(explicit, resolved, sharedRules);
+  reportResults(results, !!verbose);
+  if (results.redundant.length > 0 && fix2) {
+    fixRedundantRules(eslintConfigPath, results.redundant);
+  }
+  const didFix = fix2 && (hasMismatch || results.redundant.length > 0);
+  if (didFix) {
+    formatConfigFile(eslintConfigPath);
+  }
+  const hasUnfixedMismatch = hasMismatch && !fix2;
+  const hasUnfixedRedundant = results.redundant.length > 0 && !fix2;
+  return hasUnfixedMismatch || hasUnfixedRedundant ? 1 : 0;
+}
+
+// src/actions/package/compile/XyConfig.ts
+var ALL_PUBLINT_CHECKS = [
+  "files",
+  "importToDefault",
+  "main",
+  "module",
+  "peerDeps",
+  "publint",
+  "resolutions",
+  "rootSource",
+  "rootTypes",
+  "sideEffects",
+  "source",
+  "types"
+];
+var PUBLISH_ONLY_CHECKS = [
+  "files",
+  "importToDefault",
+  "main",
+  "module",
+  "publint",
+  "rootSource",
+  "rootTypes",
+  "sideEffects",
+  "source",
+  "types"
+];
+
+// src/actions/package/publint.ts
+import { promises as fs15 } from "fs";
+import path8 from "path";
+import chalk23 from "chalk";
+import { glob } from "glob";
+import sortPackageJson3 from "sort-package-json";
+var removeSourceFromExports = (exports) => {
+  let removed = false;
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "source") {
+      delete exports[key];
+      removed = true;
+    } else if (typeof value === "object" && value !== null && removeSourceFromExports(value)) removed = true;
+  }
+  return removed;
+};
+var hasSourceInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "source") return true;
+    if (typeof value === "object" && value !== null && hasSourceInExports(value)) return true;
+  }
+  return false;
+};
+var hasImportKeyInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "import" && typeof value === "string" && value.endsWith(".mjs")) return true;
+    if (typeof value === "object" && value !== null && hasImportKeyInExports(value)) return true;
+  }
+  return false;
+};
+var replaceImportWithDefault = (exports) => {
+  let modified = false;
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "import" && typeof value === "string" && value.endsWith(".mjs")) {
+      if (exports.default === void 0) {
+        exports.default = value;
+      }
+      delete exports.import;
+      if (exports.types === void 0) {
+        exports.types = value.replace(/\.mjs$/, ".d.ts");
+      }
+      modified = true;
+    } else if (typeof value === "object" && value !== null && replaceImportWithDefault(value)) modified = true;
+  }
+  return modified;
+};
+var hasTypesInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "types") return true;
+    if (typeof value === "object" && value !== null && hasTypesInExports(value)) return true;
+  }
+  return false;
+};
+function ensureExportsPath(value) {
+  if (value.startsWith("./") || value.startsWith("../")) return value;
+  return `./${value}`;
+}
+function emptyCustomResult() {
+  return {
+    errors: 0,
+    modified: false,
+    warnings: 0
+  };
+}
+function mergeResults(target, source) {
+  target.errors += source.errors;
+  target.warnings += source.warnings;
+  target.modified = target.modified || source.modified;
+}
+function checkFiles(pkg, fix2) {
+  const result = emptyCustomResult();
+  const files = pkg.files;
+  if (files === void 0) {
+    console.warn(chalk23.yellow('Publint [custom]: "files" field is missing'));
+    result.warnings++;
+  }
+  if (Array.isArray(files) && !files.includes("README.md")) {
+    files.push("README.md");
+    console.warn(chalk23.yellow('Publint [custom]: added "README.md" to "files"'));
+    result.modified = true;
+    result.warnings++;
+  }
+  if (Array.isArray(files) && files.includes("src")) {
+    if (fix2) {
+      pkg.files = files.filter((f) => f !== "src");
+      console.warn(chalk23.yellow('Publint [custom]: removed "src" from "files"'));
+      result.modified = true;
+    } else {
+      console.warn(chalk23.yellow('Publint [custom]: "src" should not be in "files" (use --fix to remove)'));
+    }
+    result.warnings++;
+  }
+  return result;
+}
+function checkExportsSource(pkg, fix2) {
+  const result = emptyCustomResult();
+  const exports = pkg.exports;
+  if (exports && typeof exports === "object" && hasSourceInExports(exports)) {
+    if (fix2) {
+      removeSourceFromExports(exports);
+      console.warn(chalk23.yellow('Publint [custom]: removed "source" entries from "exports"'));
+      result.modified = true;
+    } else {
+      console.warn(chalk23.yellow('Publint [custom]: "source" entries should not be in "exports" (use --fix to remove)'));
+    }
+    result.warnings++;
+  }
+  return result;
+}
+function migrateFieldToExports(pkg, field, exportKey, fix2) {
+  const result = emptyCustomResult();
+  if (pkg[field] === void 0) return result;
+  const fieldValue = pkg[field];
+  if (!fieldValue.endsWith(".js") && !fieldValue.endsWith(".mjs") && !fieldValue.endsWith(".cjs")) return result;
+  if (fix2) {
+    const exportValue = ensureExportsPath(fieldValue);
+    const exports = pkg.exports;
+    if (exports && typeof exports === "object") {
+      const dot = exports["."];
+      if (dot && typeof dot === "object" && !dot[exportKey]) {
+        dot[exportKey] = exportValue;
+        console.warn(chalk23.yellow(`Publint [custom]: migrated "${field}" to "exports['.'].${exportKey}" (${fieldValue})`));
+      }
+    } else if (!pkg.exports) {
+      pkg.exports = { ".": { [exportKey]: exportValue } };
+      console.warn(chalk23.yellow(`Publint [custom]: migrated "${field}" to "exports" (.\u2192${fieldValue})`));
+    }
+    delete pkg[field];
+    console.warn(chalk23.yellow(`Publint [custom]: removed deprecated "${field}" field`));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow(`Publint [custom]: "${field}" field is deprecated, use "exports" instead (use --fix to remove)`));
+  }
+  result.warnings++;
+  return result;
+}
+function checkSideEffects(pkg) {
+  const result = emptyCustomResult();
+  if (pkg.sideEffects !== false) {
+    console.warn(chalk23.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    result.warnings++;
+  }
+  return result;
+}
+function checkRootSource(pkg, fix2) {
+  const result = emptyCustomResult();
+  for (const field of ["source", "src"]) {
+    if (pkg[field] !== void 0) {
+      if (fix2) {
+        delete pkg[field];
+        console.warn(chalk23.yellow(`Publint [custom]: removed root-level "${field}" field`));
+        result.modified = true;
+      } else {
+        console.warn(chalk23.yellow(`Publint [custom]: root-level "${field}" field should not be in package.json (use --fix to remove)`));
+      }
+      result.warnings++;
+    }
+  }
+  return result;
+}
+function checkResolutions(pkg) {
+  const result = emptyCustomResult();
+  if (pkg.resolutions !== void 0) {
+    console.warn(chalk23.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk23.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    result.warnings++;
+  }
+  return result;
+}
+function checkImportToDefault(pkg, fix2) {
+  const result = emptyCustomResult();
+  const exports = pkg.exports;
+  if (!exports || typeof exports !== "object") return result;
+  if (!hasImportKeyInExports(exports)) return result;
+  if (fix2) {
+    replaceImportWithDefault(exports);
+    console.warn(chalk23.yellow('Publint [custom]: renamed "import" to "default" in "exports" and ensured "types" siblings'));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow('Publint [custom]: "import" entries in "exports" should use "default" instead (use --fix to rename)'));
+  }
+  result.warnings++;
+  return result;
+}
+function checkRootTypes(pkg, fix2) {
+  const result = emptyCustomResult();
+  if (pkg.types === void 0) return result;
+  const exports = pkg.exports;
+  if (!exports || typeof exports !== "object" || !hasTypesInExports(exports)) return result;
+  if (fix2) {
+    delete pkg.types;
+    console.warn(chalk23.yellow('Publint [custom]: removed redundant root "types" field (already defined in "exports")'));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow('Publint [custom]: root "types" field is redundant when "exports" defines types (use --fix to remove)'));
+  }
+  result.warnings++;
+  return result;
+}
+function customPubLint(pkg, fix2 = false, exclude = /* @__PURE__ */ new Set()) {
+  const result = emptyCustomResult();
+  if (!exclude.has("files")) mergeResults(result, checkFiles(pkg, fix2));
+  if (!exclude.has("source")) mergeResults(result, checkExportsSource(pkg, fix2));
+  if (!exclude.has("rootSource")) mergeResults(result, checkRootSource(pkg, fix2));
+  if (!exclude.has("main")) mergeResults(result, migrateFieldToExports(pkg, "main", "default", fix2));
+  if (!exclude.has("types")) mergeResults(result, migrateFieldToExports(pkg, "types", "types", fix2));
+  if (!exclude.has("module")) mergeResults(result, migrateFieldToExports(pkg, "module", "default", fix2));
+  if (!exclude.has("importToDefault")) mergeResults(result, checkImportToDefault(pkg, fix2));
+  if (!exclude.has("rootTypes")) mergeResults(result, checkRootTypes(pkg, fix2));
+  if (!exclude.has("sideEffects")) mergeResults(result, checkSideEffects(pkg));
+  if (!exclude.has("resolutions")) mergeResults(result, checkResolutions(pkg));
+  return [result.errors, result.warnings, result.modified];
+}
+var ALWAYS_INCLUDED_PATTERNS = [
+  "package.json",
+  "README",
+  "README.*",
+  "LICENCE",
+  "LICENCE.*",
+  "LICENSE",
+  "LICENSE.*",
+  "CHANGELOG",
+  "CHANGELOG.*"
+];
+async function resolvePackFiles(pkgDir, filesField) {
+  const patterns = [...ALWAYS_INCLUDED_PATTERNS];
+  if (filesField) {
+    for (const pattern of filesField) {
+      if (pattern.startsWith("!")) {
+        patterns.push(pattern);
+      } else {
+        patterns.push(pattern, `${pattern}/**`);
+      }
+    }
+  }
+  const matched = await glob(patterns, {
+    cwd: pkgDir,
+    nodir: true,
+    dot: false
+  });
+  const files = await Promise.all(
+    matched.map(async (rel) => {
+      const abs = path8.join(pkgDir, rel);
+      const data = await fs15.readFile(abs, "utf8").catch(() => "");
+      return { name: path8.join(pkgDir, rel), data };
+    })
+  );
+  return files;
+}
+async function runPublintLibrary(pkgDir, pkg, strict, pack) {
+  const { publint: publint2 } = await import("publint");
+  let packOption = false;
+  if (pack) {
+    const files = await resolvePackFiles(pkgDir, pkg.files);
+    packOption = { files };
+  }
+  const { messages } = await publint2({
+    level: "suggestion",
+    pack: packOption,
+    pkgDir,
+    strict
+  });
+  const { formatMessage } = await import("publint/utils");
+  for (const message of messages) {
+    switch (message.type) {
+      case "error": {
+        console.error(chalk23.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      case "warning": {
+        console.warn(chalk23.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      default: {
+        console.log(chalk23.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+    }
+  }
+  return {
+    errors: messages.filter((message) => message.type === "error").length,
+    total: messages.length
+  };
+}
+var packagePublint = async ({
+  exclude = /* @__PURE__ */ new Set(),
+  fix: fix2 = false,
+  pack = true,
+  pkgDir: pkgDirParam,
+  strict = true,
+  verbose: _verbose = false
+} = {}) => {
+  const pkgDir = pkgDirParam ?? INIT_CWD();
+  const sortedPkg = sortPackageJson3(await fs15.readFile(`${pkgDir}/package.json`, "utf8"));
+  await fs15.writeFile(`${pkgDir}/package.json`, sortedPkg);
+  const pkg = JSON.parse(await fs15.readFile(`${pkgDir}/package.json`, "utf8"));
+  const effectiveExclude = pkg.private ? /* @__PURE__ */ new Set([...exclude, ...PUBLISH_ONLY_CHECKS]) : exclude;
+  console.log(chalk23.green(`Publint: ${String(pkg.name)}${pkg.private ? chalk23.gray(" (private)") : ""}`));
+  console.log(chalk23.gray(pkgDir));
+  let libraryErrors = 0;
+  if (!effectiveExclude.has("publint")) {
+    const library = await runPublintLibrary(pkgDir, pkg, strict, pack);
+    libraryErrors = library.errors;
+  }
+  const [errorCount, _warningCount, modified] = customPubLint(pkg, fix2, effectiveExclude);
+  if (modified) {
+    const sorted = sortPackageJson3(JSON.stringify(pkg, null, 2));
+    await fs15.writeFile(`${pkgDir}/package.json`, sorted);
+  }
+  return libraryErrors + errorCount;
+};
+
+// src/actions/publint.ts
+import chalk24 from "chalk";
+function resolveExclude(publintConfig, cliExclude, cliInclude) {
+  const hasExclude = (publintConfig.exclude?.length ?? 0) > 0 || (cliExclude?.length ?? 0) > 0;
+  const hasInclude = (publintConfig.include?.length ?? 0) > 0 || (cliInclude?.length ?? 0) > 0;
+  if (hasExclude && hasInclude) {
+    console.error(chalk24.red("Publint: --include and --exclude cannot be used together"));
+    return void 0;
+  }
+  if (hasInclude) {
+    const include = /* @__PURE__ */ new Set([
+      ...publintConfig.include ?? [],
+      ...cliInclude ?? []
+    ]);
+    return new Set(ALL_PUBLINT_CHECKS.filter((c) => !include.has(c)));
+  }
+  return /* @__PURE__ */ new Set([
+    ...publintConfig.exclude ?? [],
+    ...cliExclude ?? []
+  ]);
+}
+function normalizePublintConfig(value) {
+  if (typeof value === "object") return value;
+  return {};
+}
+var publint = async ({
+  cliExclude,
+  cliInclude,
+  fix: fix2,
+  jobs,
+  pack,
+  verbose,
+  pkg
+}) => {
+  return pkg === void 0 ? await publintAll({
+    cliExclude,
+    cliInclude,
+    fix: fix2,
+    jobs,
+    pack,
+    verbose
+  }) : await publintSingle({
+    cliExclude,
+    cliInclude,
+    fix: fix2,
+    pack,
+    pkg,
+    verbose
+  });
+};
+function logPublintSummary(packages, errors, ms) {
+  const color = errors > 0 ? chalk24.red : chalk24.blue;
+  console.log(color(`Checked ${packages} package(s) in ${ms.toFixed(0)}ms with ${errors} issue(s) found.`));
+}
+var publintSingle = async ({
+  cliExclude,
+  cliInclude,
+  fix: fix2,
+  pack,
+  pkg,
+  verbose
+}) => {
+  const start = performance.now();
+  const pm = getPackageManager();
+  const workspace = pm.findWorkspace(pkg);
+  if (!workspace) {
+    console.error(chalk24.red(`Publint: workspace "${pkg}" not found`));
+    return 1;
+  }
+  const wsPublintConfig = normalizePublintConfig(
+    await loadWorkspaceCommandConfig(workspace.location, "publint")
+  );
+  const exclude = resolveExclude(wsPublintConfig, cliExclude, cliInclude);
+  if (!exclude) return 1;
+  const shouldPack = pack ?? wsPublintConfig.pack ?? true;
+  const errors = await packagePublint({
+    exclude,
+    fix: fix2,
+    pack: shouldPack,
+    pkgDir: workspace.location,
+    verbose
+  });
+  logPublintSummary(1, errors, performance.now() - start);
+  return errors;
+};
+var publintAll = async ({
+  cliExclude,
+  cliInclude,
+  fix: fix2,
+  jobs,
+  pack,
+  verbose
+}) => {
+  const start = performance.now();
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  const concurrency = jobs;
+  const results = Array.from({ length: workspaces.length }, () => ({ errors: 0, output: [] }));
+  installOutputCapture();
+  await runWithConcurrency(
+    workspaces.map((ws, i) => ({ i, ws })),
+    concurrency,
+    async ({ i, ws }) => {
+      const output = [];
+      await outputStorage.run(output, async () => {
+        try {
+          const wsPublintConfig = normalizePublintConfig(
+            await loadWorkspaceCommandConfig(ws.location, "publint")
+          );
+          const exclude = resolveExclude(wsPublintConfig, cliExclude, cliInclude) ?? /* @__PURE__ */ new Set();
+          const shouldPack = pack ?? wsPublintConfig.pack ?? true;
+          const errors = await packagePublint({
+            exclude,
+            fix: fix2,
+            pack: shouldPack,
+            pkgDir: ws.location,
+            verbose
+          });
+          results[i] = { errors, output };
+        } catch (ex) {
+          output.push(chalk24.red(`Publint failed for ${ws.name}: ${ex.message}
+`));
+          results[i] = { errors: 1, output };
+        }
+      });
+    }
+  );
+  let totalErrors = 0;
+  for (const { errors, output } of results) {
+    for (const line of output) {
+      process.stdout.write(line);
+    }
+    totalErrors += errors;
+  }
+  const allExclude = resolveExclude({}, cliExclude, cliInclude) ?? /* @__PURE__ */ new Set();
+  if (!allExclude.has("peerDeps")) {
+    const cwd = INIT_CWD();
+    const peerResult = checkInternalPeerVersions(cwd, workspaces);
+    if (peerResult.fixable.length > 0) {
+      if (fix2) {
+        fixInternalPeerVersions(cwd, workspaces);
+        runInstall();
+      } else {
+        for (const msg of peerResult.fixable) {
+          console.log(chalk24.red(`  \u2717 ${msg} (fixable)`));
+        }
+        totalErrors += peerResult.fixable.length;
+      }
+    }
+    totalErrors += peerResult.errors.length;
+  }
+  logPublintSummary(workspaces.length, totalErrors, performance.now() - start);
+  return totalErrors;
+};
+
+// src/actions/relint.ts
+var relintPackage = ({
+  pkg,
+  fix: fix2,
+  verbose
+}) => {
+  const pm = getPackageManager();
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [${pkg}]`, [
+    pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
+  ]);
+};
+var relint = ({
+  fix: fix2,
+  jobs,
+  next,
+  pkg,
+  verbose
+}) => {
+  if (next) {
+    return lintNext({
+      cache: false,
+      fix: fix2,
+      jobs,
+      pkg,
+      verbose
+    });
+  }
+  return pkg === void 0 ? relintAllPackages({ fix: fix2 }) : relintPackage({
+    pkg,
+    fix: fix2,
+    verbose
+  });
+};
+var relintAllPackages = ({ fix: fix2 = false } = {}) => {
+  const fixOptions = fix2 ? ["--fix"] : [];
+  return runSteps(`${fix2 ? "Fix" : "Lint"} [All-Packages]`, [
+    ["eslint", fixOptions]
+  ]);
+};
+
+// src/actions/sonar.ts
+var sonar = () => {
+  return runSteps("Sonar", [["eslint", ["-c", "sonar.eslintrc", "."]]]);
+};
+
+// src/xy/param.ts
+var packagePositionalParam = (yargs) => {
+  return yargs.positional("package", { describe: "Specific package to target", type: "string" });
+};
+
+// src/xy/lint/cycleCommand.ts
+var cycleCommand = {
+  command: "cycle [package]",
+  describe: "Cycle - Check for dependency cycles",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Cycle");
+    process.exitCode = await cycle({ jobs: argv.jobs, pkg: argv.package });
+  }
+};
+
+// src/xy/lint/deplintCommand.ts
+var deplintCommand = {
+  command: "deplint [package]",
+  describe: "Deplint - Run Deplint",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).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: true,
+      description: "Check peerDependencies",
+      type: "boolean"
+    }).option("exclude", {
+      alias: "e",
+      description: "Package names to exclude from unused checks (comma-separated or repeated)",
+      type: "array"
+    }).option("fix", {
+      alias: "f",
+      default: false,
+      description: "Fix unsatisfied peer dependencies by adding them to package.json",
+      type: "boolean"
+    }).option("format", {
+      choices: ["human", "json"],
+      default: "human",
+      description: "Output format",
+      type: "string"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Deplint");
+    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,
+      fix: !!argv.fix,
+      format: argv.format,
+      peerDeps: !!argv.peerDeps,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/fixCommand.ts
+import chalk25 from "chalk";
+var fixCommand = {
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).option("cache", {
+      alias: "c",
+      default: false,
+      description: "Use caching for performance",
+      type: "boolean"
+    }).option("next", {
+      alias: "n",
+      default: false,
+      description: "Fix per-package (lower memory, parallel)",
+      type: "boolean"
+    });
+  },
+  command: "fix [package]",
+  deprecated: 'Use "xy lint --fix" instead',
+  describe: "Fix - Run Eslint w/fix",
+  handler: async (argv) => {
+    console.warn(chalk25.yellow('Deprecated: use "xy lint --fix" instead of "xy fix"'));
+    if (argv.verbose) console.log("Fix");
+    process.exitCode = await fix({
+      cache: argv.cache,
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/knipCommand.ts
+import chalk26 from "chalk";
+var knipCommand = {
+  command: "knip",
+  describe: "Knip - Run Knip",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Knip");
+    const start = Date.now();
+    process.exitCode = knip();
+    console.log(chalk26.blue(`Knip finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/lint/index.ts
+import chalk27 from "chalk";
+
+// src/xy/lint/lint/initCommand.ts
+var initCommand = {
+  command: "init",
+  describe: "Generate eslint.config.ts and add ESLint dependencies",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Lint Init");
+    process.exitCode = await lintInit({ verbose: !!argv.verbose });
+  }
+};
+
+// src/xy/lint/lint/runCommand.ts
+var runCommand = {
+  aliases: ["$0"],
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).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"
+    }).option("next", {
+      alias: "n",
+      default: false,
+      description: "Lint per-package (lower memory, parallel)",
+      type: "boolean"
+    });
+  },
+  command: "run [package]",
+  describe: "Run ESLint",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Lint");
+    process.exitCode = argv.fix ? await fix({
+      cache: argv.cache,
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    }) : await lint({
+      cache: argv.cache,
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/lint/index.ts
+var lintCommand = {
+  builder: (yargs) => {
+    return yargs.command(runCommand).command(initCommand).option("init", {
+      default: false,
+      description: "Generate eslint.config.ts and add ESLint dependencies",
+      hidden: true,
+      type: "boolean"
+    });
+  },
+  command: "lint",
+  describe: "Lint - Run ESLint",
+  handler: async (argv) => {
+    if (argv.init) {
+      console.warn(chalk27.yellow('Deprecated: use "xy lint init" instead of "xy lint --init"'));
+      process.exitCode = await lintInit({ verbose: !!argv.verbose });
+    }
+  }
+};
+
+// src/xy/lint/lintlintCommand.ts
+var lintlintCommand = {
+  command: "lintlint",
+  describe: "Lint Lint - Check for redundant or overridden ESLint rules vs shared config",
+  builder: (yargs) => {
+    return yargs.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/lint/publintCommand.ts
+var publintCommand = {
+  command: "publint [package]",
+  describe: "Publint - Run Publint",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).option("fix", {
+      describe: 'Auto-fix issues (e.g. remove "src" from files, "source" from exports, root-level "source"/"src" fields)',
+      type: "boolean",
+      default: false
+    }).option("exclude", {
+      alias: "e",
+      description: "Checks to skip (comma-separated): publint, files, source, rootSource, main, types, module, sideEffects, resolutions, peerDeps",
+      type: "string"
+    }).option("include", {
+      description: "Only run these checks (comma-separated): publint, files, source, rootSource, main, types, module, sideEffects, resolutions, peerDeps",
+      type: "string"
+    }).option("pack", {
+      description: "Run pack before publint to verify published files (default: true)",
+      type: "boolean"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Publint");
+    const parseList = (raw) => raw?.split(",").map((v) => v.trim()).filter(Boolean);
+    process.exitCode = await publint({
+      cliExclude: parseList(argv.exclude),
+      cliInclude: parseList(argv.include),
+      fix: !!argv.fix,
+      jobs: argv.jobs,
+      pack: argv.pack,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/relintCommand.ts
+var relintCommand = {
+  command: "relint [package]",
+  describe: "Relint - Clean & Lint",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).option("next", {
+      alias: "n",
+      default: false,
+      description: "Relint per-package (lower memory, parallel)",
+      type: "boolean"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Relinting");
+    process.exitCode = await relint({
+      jobs: argv.jobs,
+      next: argv.next,
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/lint/sonarCommand.ts
+var sonarCommand = {
+  command: "sonar",
+  describe: "Sonar - Run Sonar Check",
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Sonar Check");
+    process.exitCode = sonar();
+  }
+};
+
+// 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(sonarCommand);
+};
+export {
+  xyLintCommands
+};
+//# sourceMappingURL=index.mjs.map