@blzsky/variant 0.2.1 → 0.3.0-canary.1

package/dist/{chunk-FZEXZBXB.js → chunk-JEJRXPCU.js}

@@ -1,13 +1,13 @@
 import {
   resolveCommit
-} from "./chunk-6BXSZPHC.js";
+} from "./chunk-OON6O4S5.js";
 import {
   collectExportedSurface,
   significantText
-} from "./chunk-RC23JQKI.js";
+} from "./chunk-WULBOSG5.js";
 import {
   GitRefError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-C3NZIFW6.js";
 
 // src/core/vcs/base-ref.ts
 async function assertBaseRef(cwd, ref) {
@@ -25,18 +25,22 @@ function createClassifier() {
       const tsm2 = await import("ts-morph");
       return {
         tsm: tsm2,
-        project: new tsm2.Project({ useInMemoryFileSystem: true })
+        project: new tsm2.Project({
+          useInMemoryFileSystem: true,
+          compilerOptions: { allowJs: true }
+        })
       };
     })();
     const { tsm, project } = await host;
     const id = nextId++;
+    const ext = sourceExtension(input.filePath);
     const beforeFile = project.createSourceFile(
-      `__before_${id}.ts`,
+      `__before_${id}${ext}`,
       input.before,
       { overwrite: true }
     );
     const afterFile = project.createSourceFile(
-      `__after_${id}.ts`,
+      `__after_${id}${ext}`,
       input.after,
       { overwrite: true }
     );
@@ -76,15 +80,23 @@ function compareSurfaces(input, beforeFile, afterFile, tsm) {
     if (!afterApi.symbols.has(name)) removed.push(name);
   }
   const surfaceChanged = added.length > 0 || removed.length > 0 || changed.some((c) => c.kind !== "body");
+  const parseNotes = [
+    ...hasParseErrors(beforeFile) ? ["base"] : [],
+    ...hasParseErrors(afterFile) ? ["working-tree"] : []
+  ].map(
+    (side) => `the ${side} version does not parse; classified as breaking without trusting the comparison`
+  );
   let classification;
-  if (surfaceChanged) {
+  if (surfaceChanged || parseNotes.length > 0) {
     classification = "breaking";
   } else if (changed.length > 0 || significantText(input.before, tsm) !== significantText(input.after, tsm)) {
     classification = "internal";
   } else {
     classification = "non-impacting";
   }
-  const confidenceNotes = [.../* @__PURE__ */ new Set([...beforeApi.notes, ...afterApi.notes])];
+  const confidenceNotes = [
+    .../* @__PURE__ */ new Set([...parseNotes, ...beforeApi.notes, ...afterApi.notes])
+  ];
   const confidence = Math.max(
     0.3,
     Math.round((1 - confidenceNotes.length * 0.15) * 100) / 100
@@ -94,9 +106,29 @@ function compareSurfaces(input, beforeFile, afterFile, tsm) {
     classification,
     exportedSymbols: { added, removed, changed },
     confidence,
-    confidenceNotes
+    confidenceNotes,
+    syntaxErrors: parseNotes.length > 0
   };
 }
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+function sourceExtension(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  const ext = dot === -1 ? "" : filePath.slice(dot);
+  return SOURCE_EXTENSIONS.has(ext) ? ext : ".ts";
+}
+function hasParseErrors(file) {
+  const { parseDiagnostics } = file.compilerNode;
+  return (parseDiagnostics?.length ?? 0) > 0;
+}
 
 export {
   createClassifier,

package/dist/chunk-LUTP2TVU.js

@@ -0,0 +1,94 @@
+import {
+  deriveVerdict,
+  traceTestImpact
+} from "./chunk-BNACT47L.js";
+import {
+  assertBaseRef
+} from "./chunk-JEJRXPCU.js";
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  appendImpactPrediction,
+  defaultHistoryDir
+} from "./chunk-34VGKPEM.js";
+import {
+  changeBaseDeps,
+  resolveChangeBase
+} from "./chunk-O6FCFZDF.js";
+import {
+  readHeadSha
+} from "./chunk-OON6O4S5.js";
+import {
+  GitRefError,
+  NoTestFilesError
+} from "./chunk-C3NZIFW6.js";
+
+// src/core/impact/predict.ts
+var DEFAULT_IMPACT_BASE_REF = "HEAD~1";
+async function analyzeImpact(cwd, options = {}) {
+  const base = options.changedFiles === void 0 ? await resolveChangeBase(
+    options.base,
+    options.changeBaseDeps ?? changeBaseDeps(cwd)
+  ) : {
+    ref: options.base ?? DEFAULT_IMPACT_BASE_REF,
+    source: options.base === void 0 ? "previous-commit" : "flag",
+    label: options.base ?? "previous commit"
+  };
+  const baseRef = base.ref;
+  if (options.changedFiles === void 0) await assertBaseRef(cwd, baseRef);
+  const packageGraph = await loadPackageGraph(cwd).catch(() => void 0);
+  const result = await traceTestImpact(cwd, {
+    baseRef,
+    ...packageGraph !== void 0 && { packageGraph },
+    ...options.changedFiles !== void 0 && {
+      changedFiles: options.changedFiles
+    },
+    ...options.readBefore !== void 0 && { readBefore: options.readBefore }
+  });
+  if (result === null) {
+    throw new GitRefError(
+      `Could not list the files changed since "${baseRef}"`
+    );
+  }
+  return { base, result, packageGraph };
+}
+async function predictImpact(cwd, options = {}) {
+  const { base, result, packageGraph } = await analyzeImpact(cwd, options);
+  const baseRef = base.ref;
+  if (result.tests.totalTests === 0) throw new NoTestFilesError();
+  const verdict = deriveVerdict(
+    result.radius.changed.map((change) => change.classification),
+    { forceBuild: result.tests.selectAll }
+  );
+  const headSha = options.headSha !== void 0 ? options.headSha : base.headSha ?? await readHeadSha(cwd);
+  const historyLogged = await appendImpactPrediction(defaultHistoryDir(cwd), {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    baseRef,
+    headSha,
+    changedFiles: result.radius.changed.map((change) => change.filePath),
+    affectedFiles: result.radius.affectedFiles.length,
+    affectedPackages: result.radius.affectedPackages,
+    affectedTests: result.tests.affectedTests,
+    totalTests: result.tests.totalTests,
+    selectAll: result.tests.selectAll,
+    verdict,
+    confidence: result.tests.confidence,
+    notes: [...result.radius.notes, ...result.tests.notes]
+  });
+  return {
+    baseRef,
+    baseSource: base.source,
+    baseLabel: base.label,
+    headSha,
+    result,
+    verdict,
+    packagesFound: packageGraph?.packages.length ?? 0,
+    historyLogged
+  };
+}
+
+export {
+  analyzeImpact,
+  predictImpact
+};

package/dist/{chunk-7OPTWU6E.js → chunk-MKUYZIXF.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-3E5LBU3O.js";
 import {
   listChangedFiles
-} from "./chunk-6BXSZPHC.js";
+} from "./chunk-OON6O4S5.js";
 
 // src/core/cache/git-diff.ts
 import path from "path";

package/dist/chunk-MNYKLWRC.js

@@ -0,0 +1,377 @@
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  defaultBranchRef
+} from "./chunk-OON6O4S5.js";
+
+// src/core/setup/discover.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+
+// src/core/setup/workflow.ts
+var TEST_COMMAND = /\b(?:vitest|jest)\b|\b(?:npm|pnpm|yarn|bun)(?:\s+run)?\s+test\b|\bturbo(?:\s+run)?\s+test\b|\bnx\s+(?:run-many|affected|test)\b/;
+function runsTests(workflow) {
+  return workflow.split("\n").some((line) => !line.trim().startsWith("#") && TEST_COMMAND.test(line));
+}
+var CHECKOUT = /^(\s*)(-\s+)?uses:\s*actions\/checkout@\S+\s*$/;
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function withFullHistory(workflow) {
+  const lines = workflow.split("\n");
+  const out = [];
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    out.push(line);
+    const match = CHECKOUT.exec(line);
+    if (match === null) continue;
+    const keyIndent = (match[1]?.length ?? 0) + (match[2]?.length ?? 0);
+    const pad = " ".repeat(keyIndent);
+    let end = i + 1;
+    while (end < lines.length) {
+      const next = lines[end] ?? "";
+      if (next.trim() !== "" && indentOf(next) < keyIndent) break;
+      if (next.trim().startsWith("- ") && indentOf(next) < keyIndent) break;
+      end++;
+    }
+    const step = lines.slice(i + 1, end);
+    const withAt = step.findIndex(
+      (l) => indentOf(l) === keyIndent && /^with:\s*$/.test(l.trim())
+    );
+    if (withAt === -1) {
+      out.push(`${pad}with:`, `${pad}  fetch-depth: 0`);
+      changed = true;
+      continue;
+    }
+    const depthAt = step.findIndex(
+      (l, index) => index > withAt && indentOf(l) > keyIndent && /^fetch-depth:/.test(l.trim())
+    );
+    for (let j = 0; j < step.length; j++) {
+      const stepLine = step[j] ?? "";
+      if (j === depthAt) {
+        const fixed = stepLine.replace(/fetch-depth:.*$/, "fetch-depth: 0");
+        if (fixed !== stepLine) changed = true;
+        out.push(fixed);
+        continue;
+      }
+      out.push(stepLine);
+      if (j === withAt && depthAt === -1) {
+        out.push(`${pad}  fetch-depth: 0`);
+        changed = true;
+      }
+    }
+    i = end - 1;
+  }
+  return changed ? out.join("\n") : null;
+}
+var ACTIONS = [
+  "actions/checkout",
+  "actions/setup-node",
+  "actions/github-script",
+  "pnpm/action-setup",
+  "oven-sh/setup-bun"
+];
+function workflowStyle(workflow) {
+  const actions = {};
+  let node;
+  let bun;
+  for (const raw of workflow.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("#")) continue;
+    const uses = /^(?:-\s+)?uses:\s*(\S+)@(\S+)/.exec(line);
+    if (uses !== null) {
+      const [, action, version] = uses;
+      if (action !== void 0 && ACTIONS.includes(action)) {
+        actions[action] ??= `${action}@${version}`;
+      }
+      continue;
+    }
+    if (line.includes("${{")) continue;
+    if (/^node-version(?:-file)?:\s*\S/.test(line)) node ??= line;
+    if (/^bun-version(?:-file)?:\s*\S/.test(line)) bun ??= line;
+  }
+  return {
+    actions,
+    ...node !== void 0 && { node },
+    ...bun !== void 0 && { bun }
+  };
+}
+var DEFAULT_ACTIONS = {
+  "actions/checkout": "actions/checkout@v7",
+  "actions/setup-node": "actions/setup-node@v7",
+  "actions/github-script": "actions/github-script@v9",
+  "pnpm/action-setup": "pnpm/action-setup@v4",
+  "oven-sh/setup-bun": "oven-sh/setup-bun@v2"
+};
+var INSTALL = {
+  npm: "npm ci",
+  pnpm: "pnpm install --frozen-lockfile",
+  yarn: "yarn install --frozen-lockfile",
+  bun: "bun install --frozen-lockfile"
+};
+var EXEC = {
+  npm: "npx --no -- variant",
+  pnpm: "pnpm exec variant",
+  yarn: "yarn variant",
+  bun: "bun run variant"
+};
+var NODE_CACHE = {
+  npm: "npm",
+  pnpm: "pnpm",
+  yarn: "yarn"
+};
+function pullRequestWorkflow(packageManager, style = { actions: {} }) {
+  const cache = NODE_CACHE[packageManager];
+  const action = (name) => style.actions[name] ?? DEFAULT_ACTIONS[name] ?? name;
+  const setup = packageManager === "pnpm" ? [`      - uses: ${action("pnpm/action-setup")}`, ""] : packageManager === "bun" ? [
+    `      - uses: ${action("oven-sh/setup-bun")}`,
+    ...style.bun === void 0 ? [] : ["        with:", `          ${style.bun}`],
+    ""
+  ] : [];
+  return [
+    "# Written by `variant init`. It keeps one comment on each pull request",
+    "# saying what the change affects. It is yours to edit.",
+    "",
+    "name: variant",
+    "",
+    "on:",
+    "  pull_request:",
+    "",
+    "permissions:",
+    "  contents: read",
+    "  pull-requests: write",
+    "",
+    "# A newer push makes the report for an older one pointless.",
+    "concurrency:",
+    // Split so the linter does not take a workflow expression for a
+    // template placeholder someone forgot the backticks on.
+    `  group: variant-$${"{{ github.event.pull_request.number }}"}`,
+    "  cancel-in-progress: true",
+    "",
+    "jobs:",
+    "  report:",
+    "    runs-on: ubuntu-latest",
+    "    timeout-minutes: 10",
+    "    steps:",
+    `      - uses: ${action("actions/checkout")}`,
+    "        with:",
+    "          # variant compares against the commit the branch started from.",
+    "          fetch-depth: 0",
+    "",
+    ...setup,
+    `      - uses: ${action("actions/setup-node")}`,
+    "        with:",
+    `          ${style.node ?? "node-version: 22"}`,
+    ...cache === void 0 ? [] : [`          cache: ${cache}`],
+    "",
+    `      - run: ${INSTALL[packageManager]}`,
+    "",
+    "      - name: Describe the pull request",
+    `        run: ${EXEC[packageManager]} pr report --markdown --output pr-report.md`,
+    "",
+    "      - name: Post or update the comment",
+    "        # Pull requests from forks get a read-only token and cannot comment.",
+    "        if: github.event.pull_request.head.repo.full_name == github.repository",
+    `        uses: ${action("actions/github-script")}`,
+    "        with:",
+    "          script: |",
+    '            const fs = require("node:fs");',
+    '            const body = fs.readFileSync("pr-report.md", "utf8");',
+    "            // The first line of every report; it marks the comment to update.",
+    '            const marker = "## Variant PR Report";',
+    "            const { owner, repo } = context.repo;",
+    "            const issue_number = context.issue.number;",
+    "            const comments = await github.paginate(github.rest.issues.listComments, {",
+    "              owner,",
+    "              repo,",
+    "              issue_number,",
+    "            });",
+    "            const existing = comments.find(",
+    "              (comment) =>",
+    '                comment.user?.login === "github-actions[bot]" &&',
+    "                comment.body?.startsWith(marker),",
+    "            );",
+    "            if (existing) {",
+    "              await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body });",
+    "            } else {",
+    "              await github.rest.issues.createComment({ owner, repo, issue_number, body });",
+    "            }",
+    ""
+  ].join("\n");
+}
+
+// src/core/setup/discover.ts
+var LOCKFILES = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"],
+  ["npm-shrinkwrap.json", "npm"]
+];
+var IGNORE = ["**/node_modules/**", "**/dist/**", ".git/**", ".variant/**"];
+async function readText(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readManifest(cwd) {
+  const raw = await readText(path.join(cwd, "package.json"));
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+async function managerIn(dir) {
+  for (const [lockfile, name2] of LOCKFILES) {
+    if (await readText(path.join(dir, lockfile)) !== null) return name2;
+  }
+  const declared = (await readManifest(dir))?.packageManager;
+  const name = typeof declared === "string" ? declared.split("@")[0] : void 0;
+  return name !== void 0 && MANAGERS.has(name) ? name : null;
+}
+async function detectPackageManager(cwd) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const found = await managerIn(dir);
+    if (found !== null) return found;
+    const parent = path.dirname(dir);
+    const atRoot = await access(path.join(dir, ".git")).then(
+      () => true,
+      () => false
+    );
+    if (parent === dir || atRoot) return null;
+    dir = parent;
+  }
+}
+async function packageManagerOf(cwd) {
+  return detectPackageManager(cwd);
+}
+var CONFIG_FLAG = /(?:--config|-c)(?:=|\s+)(\S+)/;
+function vitestRuns(manifest) {
+  const configs = [];
+  let plain = false;
+  for (const script of Object.values(manifest?.scripts ?? {})) {
+    if (typeof script !== "string") continue;
+    for (const command of script.split(/&&|\|\||;/)) {
+      if (!/\bvitest\b/.test(command)) continue;
+      const config = CONFIG_FLAG.exec(command)?.[1];
+      if (config === void 0) plain = true;
+      else configs.push(config.replace(/^["']|["']$/g, ""));
+    }
+  }
+  return { plain, configs };
+}
+function adapterTargets(configs, packageDirs) {
+  const root = configs.filter((file) => !file.includes("/"));
+  if (root.length > 0) return root;
+  const dirs = new Set(packageDirs);
+  return configs.filter((file) => dirs.has(path.posix.dirname(file)));
+}
+async function discoverRepository(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const [manifest, packageGraph, found, gitignore, branch] = await Promise.all([
+    readManifest(cwd),
+    loadPackageGraph(cwd).catch(() => null),
+    fg(
+      [
+        "**/vitest.config.{ts,mts,cts,js,mjs,cjs}",
+        "**/vite.config.{ts,mts,cts,js,mjs,cjs}",
+        "**/jest.config.{ts,mts,cts,js,mjs,cjs,json}",
+        "**/playwright.config.{ts,mts,cts,js,mjs,cjs}",
+        ".github/workflows/*.{yml,yaml}",
+        "turbo.json",
+        "nx.json"
+      ],
+      { cwd, onlyFiles: true, dot: true, ignore: IGNORE }
+    ),
+    readText(path.join(cwd, ".gitignore")),
+    defaultBranchRef(cwd)
+  ]);
+  const files = found.map((file) => file.replace(/\\/g, "/")).sort();
+  const named = (prefix) => files.filter((file) => path.posix.basename(file).startsWith(prefix));
+  const packageDirs = (packageGraph?.packages ?? []).map(
+    (pkg) => path.relative(cwd, pkg.dir).replace(/\\/g, "/")
+  );
+  const workflows = await Promise.all(
+    files.filter((file) => file.startsWith(".github/workflows/")).map(async (file) => {
+      const content = await readText(path.join(cwd, file)) ?? "";
+      return {
+        file,
+        content,
+        runsTests: runsTests(content),
+        shallow: withFullHistory(content) !== null
+      };
+    })
+  );
+  const vitestConfigs = adapterTargets(named("vitest.config."), packageDirs);
+  const hasRootConfig = vitestConfigs.some((file) => !file.includes("/"));
+  const configDirs = (prefix) => new Map(
+    named(prefix).map((file) => {
+      const dir = path.posix.dirname(file);
+      return [dir === "." ? "" : dir, file];
+    })
+  );
+  const vitestDirs = configDirs("vitest.config.");
+  const viteDirs = configDirs("vite.config.");
+  const members = (packageGraph?.packages ?? []).map((pkg) => ({
+    dir: path.relative(cwd, pkg.dir).replace(/\\/g, "/"),
+    manifest: pkg.manifest
+  })).filter((member) => member.dir !== "");
+  const usesVitest = (candidate) => "vitest" in (candidate?.devDependencies ?? {}) || "vitest" in (candidate?.dependencies ?? {});
+  const everyone = [{ dir: "", manifest }, ...members];
+  const runs = new Map(
+    everyone.map((member) => [member.dir, vitestRuns(member.manifest)])
+  );
+  const scripted = everyone.some((member) => {
+    const run = runs.get(member.dir);
+    return run !== void 0 && (run.plain || run.configs.length > 0);
+  });
+  const users = members.filter((member) => usesVitest(member.manifest));
+  const runners = scripted ? everyone.filter((member) => runs.get(member.dir)?.plain === true) : users.length > 0 ? users : usesVitest(manifest) ? [{ dir: "", manifest }] : [];
+  const unconfigured = hasRootConfig ? [] : runners.filter((runner) => !vitestDirs.has(runner.dir));
+  const scriptConfigs = everyone.flatMap(
+    (member) => (runs.get(member.dir)?.configs ?? []).map(
+      (config) => path.posix.normalize(path.posix.join(member.dir, config))
+    )
+  );
+  const allConfigs = [.../* @__PURE__ */ new Set([...vitestConfigs, ...scriptConfigs])].sort();
+  return {
+    packageManager: await detectPackageManager(cwd),
+    workspacePackages: packageDirs.filter((dir) => dir !== "").length,
+    taskRunner: files.includes("turbo.json") ? "turborepo" : files.includes("nx.json") ? "nx" : null,
+    vitestConfigs: allConfigs,
+    vitestWithoutConfig: unconfigured.filter((runner) => !viteDirs.has(runner.dir)).map((runner) => runner.dir).sort(),
+    viteConfigs: unconfigured.flatMap((runner) => viteDirs.get(runner.dir) ?? []).sort(),
+    reporterFlags: [{ dir: "", manifest }, ...members].filter(
+      (member) => Object.values(member.manifest?.scripts ?? {}).some(
+        (script) => typeof script === "string" && /\bvitest\b.*--reporter\b/.test(script)
+      )
+    ).map(
+      (member) => member.dir === "" ? "package.json" : `${member.dir}/package.json`
+    ).sort(),
+    jestConfigs: named("jest.config."),
+    playwrightConfigs: named("playwright.config."),
+    workflows,
+    defaultBranch: branch?.replace(/^origin\//, "") ?? null,
+    installed: "@blzsky/variant" in (manifest?.devDependencies ?? {}) || "@blzsky/variant" in (manifest?.dependencies ?? {}),
+    ignoresVariantDir: (gitignore ?? "").split("\n").some((line) => /^\/?\.variant\/?$/.test(line.trim())),
+    hasManifest: manifest !== null
+  };
+}
+
+export {
+  withFullHistory,
+  workflowStyle,
+  pullRequestWorkflow,
+  packageManagerOf,
+  discoverRepository
+};

package/dist/{chunk-Q7RLUZSN.js → chunk-NJSTAWDM.js}

@@ -1,16 +1,23 @@
 import {
   classifyChange
-} from "./chunk-FZEXZBXB.js";
+} from "./chunk-JEJRXPCU.js";
 import {
   readFileAtRef
-} from "./chunk-6BXSZPHC.js";
+} from "./chunk-OON6O4S5.js";
+import {
+  CliUsageError
+} from "./chunk-C3NZIFW6.js";
 
 // src/core/semantic/file-change.ts
 import { readFile } from "fs/promises";
 import path from "path";
 var DEFAULT_DIFF_BASE_REF = "HEAD~1";
 function toWorkspaceRelative(cwd, filePath) {
-  return path.relative(cwd, path.resolve(cwd, filePath)).replace(/\\/g, "/");
+  const relative = path.relative(cwd, path.resolve(cwd, filePath));
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new CliUsageError(`${filePath} is outside the repository at ${cwd}`);
+  }
+  return relative.replace(/\\/g, "/");
 }
 async function classifyFileAgainstRef(cwd, relPath, baseRef) {
   const [before, after] = await Promise.all([

package/dist/{chunk-26DHEXGS.js → chunk-NOC53Z5Q.js}

@@ -1,6 +1,6 @@
 import {
   ConfigError
-} from "./chunk-VYWPQKMS.js";
+} from "./chunk-C3NZIFW6.js";
 
 // src/core/config/loader.ts
 import { existsSync } from "fs";