@outfitter/tooling 0.3.4 → 0.3.5

package/dist/shared/@outfitter/tooling-0zjz8eg9.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  computeExpectedExports
+} from "./tooling-a6q3zh7t.js";
+import {
+  compareExports
+} from "./tooling-ayps7c4x.js";
+
+// packages/tooling/src/cli/check-exports.ts
+import { resolve } from "path";
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m"
+};
+function resolveJsonMode(options = {}) {
+  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
+}
+async function runCheckExports(options = {}) {
+  const cwd = process.cwd();
+  const configPath = resolve(cwd, "bunup.config.ts");
+  let workspaces;
+  try {
+    const configModule = await import(configPath);
+    const rawConfig = configModule.default;
+    if (!Array.isArray(rawConfig)) {
+      process.stderr.write(`bunup.config.ts must export a workspace array
+`);
+      process.exitCode = 1;
+      return;
+    }
+    workspaces = rawConfig;
+  } catch {
+    process.stderr.write(`Could not load bunup.config.ts from ${cwd}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const results = [];
+  for (const workspace of workspaces) {
+    const packageRoot = resolve(cwd, workspace.root);
+    const pkgPath = resolve(packageRoot, "package.json");
+    let pkg;
+    try {
+      pkg = await Bun.file(pkgPath).json();
+    } catch {
+      results.push({ name: workspace.name, status: "ok" });
+      continue;
+    }
+    const actual = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
+    const expected = computeExpectedExports(packageRoot, workspace, pkg);
+    results.push(compareExports({
+      name: workspace.name,
+      actual,
+      expected,
+      path: workspace.root
+    }));
+  }
+  const checkResult = {
+    ok: results.every((r) => r.status === "ok"),
+    packages: results
+  };
+  if (resolveJsonMode(options)) {
+    process.stdout.write(`${JSON.stringify(checkResult, null, 2)}
+`);
+  } else {
+    const drifted = results.filter((r) => r.status === "drift");
+    if (drifted.length === 0) {
+      process.stdout.write(`${COLORS.green}All ${results.length} packages have exports in sync.${COLORS.reset}
+`);
+    } else {
+      process.stderr.write(`${COLORS.red}Export drift detected in ${drifted.length} package(s):${COLORS.reset}
+
+`);
+      for (const result of drifted) {
+        const drift = result.drift;
+        if (!drift)
+          continue;
+        process.stderr.write(`  ${COLORS.yellow}${result.name}${COLORS.reset} ${COLORS.dim}(${drift.path})${COLORS.reset}
+`);
+        for (const key of drift.added) {
+          process.stderr.write(`    ${COLORS.green}+ ${key}${COLORS.reset}  ${COLORS.dim}(missing from package.json)${COLORS.reset}
+`);
+        }
+        for (const key of drift.removed) {
+          process.stderr.write(`    ${COLORS.red}- ${key}${COLORS.reset}  ${COLORS.dim}(not in source)${COLORS.reset}
+`);
+        }
+        for (const entry of drift.changed) {
+          process.stderr.write(`    ${COLORS.yellow}~ ${entry.key}${COLORS.reset}  ${COLORS.dim}(value mismatch)${COLORS.reset}
+`);
+        }
+        process.stderr.write(`
+`);
+      }
+      process.stderr.write(`Run ${COLORS.blue}bun run build${COLORS.reset} to regenerate exports.
+`);
+    }
+  }
+  process.exitCode = checkResult.ok ? 0 : 1;
+}
+
+export { resolveJsonMode, runCheckExports };

package/dist/shared/@outfitter/tooling-2vv5y3s4.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  canBypassRedPhaseByChangedFiles,
+  checkBunVersion,
+  createVerificationPlan,
+  getChangedFilesForPush,
+  getCurrentBranch,
+  hasPackageSourceChanges,
+  hasRedPhaseBranchInContext,
+  isRedPhaseBranch,
+  isReleaseBranch,
+  isScaffoldBranch,
+  printTsdocSummary,
+  readPackageScripts
+} from "./tooling-c8q6mj8z.js";
+// packages/tooling/src/cli/pre-push.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m"
+};
+function log(msg) {
+  process.stdout.write(`${msg}
+`);
+}
+function runScript(scriptName) {
+  log("");
+  log(`Running: ${COLORS.blue}bun run ${scriptName}${COLORS.reset}`);
+  const result = Bun.spawnSync(["bun", "run", scriptName], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  return result.exitCode === 0;
+}
+function maybeSkipForRedPhase(reason, branch) {
+  const changedFiles = getChangedFilesForPush();
+  if (!changedFiles.deterministic) {
+    log(`${COLORS.yellow}RED-phase bypass denied${COLORS.reset}: could not determine full push diff range`);
+    log("Running strict verification.");
+    log("");
+    return false;
+  }
+  if (!canBypassRedPhaseByChangedFiles(changedFiles)) {
+    log(`${COLORS.yellow}RED-phase bypass denied${COLORS.reset}: changed files are not test-only`);
+    if (changedFiles.files.length > 0) {
+      log(`Changed files (${changedFiles.source}): ${changedFiles.files.join(", ")}`);
+    } else {
+      log(`No changed files detected in ${changedFiles.source} range. Running strict verification.`);
+    }
+    log("");
+    return false;
+  }
+  if (reason === "branch") {
+    log(`${COLORS.yellow}TDD RED phase${COLORS.reset} detected: ${COLORS.blue}${branch}${COLORS.reset}`);
+  } else {
+    log(`${COLORS.yellow}Scaffold branch${COLORS.reset} with RED phase branch in context: ${COLORS.blue}${branch}${COLORS.reset}`);
+  }
+  log(`${COLORS.yellow}Skipping strict verification${COLORS.reset} - changed files are test-only`);
+  log(`Diff source: ${changedFiles.source}`);
+  log("");
+  log("Remember: GREEN phase (implementation) must make these tests pass!");
+  return true;
+}
+async function runPrePush(options = {}) {
+  log(`${COLORS.blue}Pre-push verify${COLORS.reset} (TDD-aware)`);
+  log("");
+  if (options.force) {
+    log(`${COLORS.yellow}Force flag set${COLORS.reset} - skipping strict verification`);
+    process.exitCode = 0;
+    return;
+  }
+  const versionCheck = checkBunVersion();
+  if (!versionCheck.matches) {
+    log(`${COLORS.red}Bun version mismatch${COLORS.reset}: running ${versionCheck.actual}, pinned ${versionCheck.expected}`);
+    log("Fix: bunx @outfitter/tooling upgrade-bun");
+    log("");
+    process.exitCode = 1;
+    return;
+  }
+  const branch = getCurrentBranch();
+  if (isReleaseBranch(branch)) {
+    log(`${COLORS.yellow}Release branch detected${COLORS.reset}: ${COLORS.blue}${branch}${COLORS.reset}`);
+    log(`${COLORS.yellow}Skipping strict verification${COLORS.reset} for automated changeset release push`);
+    process.exitCode = 0;
+    return;
+  }
+  if (isRedPhaseBranch(branch)) {
+    if (maybeSkipForRedPhase("branch", branch)) {
+      process.exitCode = 0;
+      return;
+    }
+  }
+  if (isScaffoldBranch(branch)) {
+    if (hasRedPhaseBranchInContext(branch)) {
+      if (maybeSkipForRedPhase("context", branch)) {
+        process.exitCode = 0;
+        return;
+      }
+    }
+  }
+  const plan = createVerificationPlan(readPackageScripts());
+  if (!plan.ok) {
+    log(`${COLORS.red}Strict pre-push verification is not configured${COLORS.reset}`);
+    log(plan.error);
+    log("");
+    log("Add one of:");
+    log("  - verify:push");
+    log("  - verify:ci");
+    log("  - typecheck + (check or lint) + build + test");
+    process.exitCode = 1;
+    return;
+  }
+  log(`Running strict verification for branch: ${COLORS.blue}${branch}${COLORS.reset}`);
+  if (plan.source === "verify:push" || plan.source === "verify:ci") {
+    log(`Using \`${plan.source}\` script.`);
+  } else {
+    log(`Using fallback scripts: ${plan.scripts.join(" -> ")}`);
+  }
+  for (const scriptName of plan.scripts) {
+    if (runScript(scriptName)) {
+      continue;
+    }
+    log("");
+    log(`${COLORS.red}Verification failed${COLORS.reset} on script: ${scriptName}`);
+    log("");
+    log("If this is intentional TDD RED phase work, name your branch:");
+    log("  - feature-tests");
+    log("  - feature/tests");
+    log("  - feature_tests");
+    process.exitCode = 1;
+    return;
+  }
+  const changedFiles = getChangedFilesForPush();
+  if (hasPackageSourceChanges(changedFiles)) {
+    try {
+      await printTsdocSummary(log);
+    } catch {}
+  }
+  log("");
+  log(`${COLORS.green}Strict verification passed${COLORS.reset}`);
+  process.exitCode = 0;
+}
+
+export { runPrePush };

package/dist/shared/@outfitter/{tooling-875svjnz.js → tooling-5xxctk9b.js}

@@ -3,44 +3,9 @@ import {
   __require
 } from "./tooling-jnrs9rqd.js";
 
-// packages/tooling/src/cli/check-tsdoc.ts
+// packages/tooling/src/cli/internal/tsdoc-analysis.ts
 import { resolve } from "path";
 import ts from "typescript";
-import { z } from "zod";
-var coverageLevelSchema = z.enum([
-  "documented",
-  "partial",
-  "undocumented"
-]);
-var declarationCoverageSchema = z.object({
-  name: z.string(),
-  kind: z.string(),
-  level: coverageLevelSchema,
-  file: z.string(),
-  line: z.number()
-});
-var coverageSummarySchema = z.object({
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var packageCoverageSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  declarations: z.array(declarationCoverageSchema),
-  documented: z.number(),
-  partial: z.number(),
-  undocumented: z.number(),
-  total: z.number(),
-  percentage: z.number()
-});
-var tsDocCheckResultSchema = z.object({
-  ok: z.boolean(),
-  packages: z.array(packageCoverageSchema),
-  summary: coverageSummarySchema
-});
 function isExportedDeclaration(node) {
   if (ts.isExportDeclaration(node))
     return false;
@@ -159,24 +124,6 @@ function calculateCoverage(declarations) {
   const percentage = Math.round(score / total * 100);
   return { documented, partial, undocumented, total, percentage };
 }
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  dim: "\x1B[2m",
-  bold: "\x1B[1m"
-};
-function resolveJsonMode(options = {}) {
-  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
-}
-function bar(percentage, width = 20) {
-  const filled = Math.round(percentage / 100 * width);
-  const empty = width - filled;
-  const color = percentage >= 80 ? COLORS.green : percentage >= 50 ? COLORS.yellow : COLORS.red;
-  return `${color}${"\u2588".repeat(filled)}${COLORS.dim}${"\u2591".repeat(empty)}${COLORS.reset}`;
-}
 function discoverPackages(cwd) {
   const packages = [];
   const seenEntryPoints = new Set;
@@ -344,63 +291,5 @@ function analyzeCheckTsdoc(options = {}) {
     summary
   };
 }
-function printCheckTsdocHuman(result, options) {
-  process.stdout.write(`
-${COLORS.bold}TSDoc Coverage Report${COLORS.reset}
-
-`);
-  for (const pkg of result.packages) {
-    const color = pkg.percentage >= 80 ? COLORS.green : pkg.percentage >= 50 ? COLORS.yellow : COLORS.red;
-    process.stdout.write(`  ${color}${pkg.percentage.toString().padStart(3)}%${COLORS.reset} ${bar(pkg.percentage)} ${pkg.name}
-`);
-    if (pkg.total > 0) {
-      const parts = [];
-      if (pkg.documented > 0)
-        parts.push(`${COLORS.green}${pkg.documented} documented${COLORS.reset}`);
-      if (pkg.partial > 0)
-        parts.push(`${COLORS.yellow}${pkg.partial} partial${COLORS.reset}`);
-      if (pkg.undocumented > 0)
-        parts.push(`${COLORS.red}${pkg.undocumented} undocumented${COLORS.reset}`);
-      process.stdout.write(`       ${COLORS.dim}${pkg.total} declarations:${COLORS.reset} ${parts.join(", ")}
-`);
-    } else {
-      process.stdout.write(`       ${COLORS.dim}no exported declarations${COLORS.reset}
-`);
-    }
-  }
-  const { summary } = result;
-  process.stdout.write(`
-  ${COLORS.bold}Summary:${COLORS.reset} ${summary.percentage}% coverage (${summary.documented} documented, ${summary.partial} partial, ${summary.undocumented} undocumented of ${summary.total} total)
-`);
-  const minCoverage = options?.minCoverage ?? 0;
-  if (options?.strict && summary.percentage < minCoverage) {
-    process.stderr.write(`
-  ${COLORS.red}Coverage ${summary.percentage}% is below minimum threshold of ${minCoverage}%${COLORS.reset}
-`);
-  }
-  process.stdout.write(`
-`);
-}
-async function runCheckTsdoc(options = {}) {
-  const result = analyzeCheckTsdoc(options);
-  if (!result) {
-    process.stderr.write(`No packages found with src/index.ts entry points.
-` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
-` + `Use --package <path> to specify a package path explicitly.
-`);
-    process.exitCode = 1;
-    return;
-  }
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-  } else {
-    printCheckTsdocHuman(result, {
-      strict: options.strict,
-      minCoverage: options.minCoverage
-    });
-  }
-  process.exitCode = result.ok ? 0 : 1;
-}
 
-export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema, isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, resolveJsonMode, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc };
+export { isExportedDeclaration, getDeclarationName, getDeclarationKind, classifyDeclaration, analyzeSourceFile, calculateCoverage, discoverPackages, collectReExportedSourceFiles, analyzePackage, analyzeCheckTsdoc };

package/dist/shared/@outfitter/tooling-5ynz680q.js

@@ -0,0 +1,59 @@
+// @bun
+// packages/tooling/src/cli/internal/tsdoc-formatting.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+function resolveJsonMode(options = {}) {
+  return options.json ?? process.env["OUTFITTER_JSON"] === "1";
+}
+function bar(percentage, width = 20) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  const color = percentage >= 80 ? COLORS.green : percentage >= 50 ? COLORS.yellow : COLORS.red;
+  return `${color}${"\u2588".repeat(filled)}${COLORS.dim}${"\u2591".repeat(empty)}${COLORS.reset}`;
+}
+function printCheckTsdocHuman(result, options) {
+  process.stdout.write(`
+${COLORS.bold}TSDoc Coverage Report${COLORS.reset}
+
+`);
+  for (const pkg of result.packages) {
+    const color = pkg.percentage >= 80 ? COLORS.green : pkg.percentage >= 50 ? COLORS.yellow : COLORS.red;
+    process.stdout.write(`  ${color}${pkg.percentage.toString().padStart(3)}%${COLORS.reset} ${bar(pkg.percentage)} ${pkg.name}
+`);
+    if (pkg.total > 0) {
+      const parts = [];
+      if (pkg.documented > 0)
+        parts.push(`${COLORS.green}${pkg.documented} documented${COLORS.reset}`);
+      if (pkg.partial > 0)
+        parts.push(`${COLORS.yellow}${pkg.partial} partial${COLORS.reset}`);
+      if (pkg.undocumented > 0)
+        parts.push(`${COLORS.red}${pkg.undocumented} undocumented${COLORS.reset}`);
+      process.stdout.write(`       ${COLORS.dim}${pkg.total} declarations:${COLORS.reset} ${parts.join(", ")}
+`);
+    } else {
+      process.stdout.write(`       ${COLORS.dim}no exported declarations${COLORS.reset}
+`);
+    }
+  }
+  const { summary } = result;
+  process.stdout.write(`
+  ${COLORS.bold}Summary:${COLORS.reset} ${summary.percentage}% coverage (${summary.documented} documented, ${summary.partial} partial, ${summary.undocumented} undocumented of ${summary.total} total)
+`);
+  const minCoverage = options?.minCoverage ?? 0;
+  if (options?.strict && summary.percentage < minCoverage) {
+    process.stderr.write(`
+  ${COLORS.red}Coverage ${summary.percentage}% is below minimum threshold of ${minCoverage}%${COLORS.reset}
+`);
+  }
+  process.stdout.write(`
+`);
+}
+
+export { resolveJsonMode, printCheckTsdocHuman };

package/dist/shared/@outfitter/tooling-7437rmy6.js

@@ -0,0 +1,39 @@
+// @bun
+// packages/tooling/src/cli/internal/tsdoc-types.ts
+import { z } from "zod";
+var coverageLevelSchema = z.enum([
+  "documented",
+  "partial",
+  "undocumented"
+]);
+var declarationCoverageSchema = z.object({
+  name: z.string(),
+  kind: z.string(),
+  level: coverageLevelSchema,
+  file: z.string(),
+  line: z.number()
+});
+var coverageSummarySchema = z.object({
+  documented: z.number(),
+  partial: z.number(),
+  undocumented: z.number(),
+  total: z.number(),
+  percentage: z.number()
+});
+var packageCoverageSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  declarations: z.array(declarationCoverageSchema),
+  documented: z.number(),
+  partial: z.number(),
+  undocumented: z.number(),
+  total: z.number(),
+  percentage: z.number()
+});
+var tsDocCheckResultSchema = z.object({
+  ok: z.boolean(),
+  packages: z.array(packageCoverageSchema),
+  summary: coverageSummarySchema
+});
+
+export { coverageLevelSchema, declarationCoverageSchema, coverageSummarySchema, packageCoverageSchema, tsDocCheckResultSchema };

package/dist/shared/@outfitter/tooling-8qcwr06t.d.ts

@@ -0,0 +1,74 @@
+/** Get current git branch name */
+declare function getCurrentBranch(): string;
+declare function runGit(args: readonly string[]): {
+	readonly ok: boolean;
+	readonly lines: readonly string[];
+};
+/** Check if branch is a TDD RED phase branch */
+declare function isRedPhaseBranch(branch: string): boolean;
+/** Check if branch is a scaffold branch */
+declare function isScaffoldBranch(branch: string): boolean;
+/** Check if branch is a changeset release branch */
+declare function isReleaseBranch(branch: string): boolean;
+/** Determine if a file path is test-related */
+declare function isTestOnlyPath(path: string): boolean;
+/** Check if all paths in the list are test-related */
+declare function areFilesTestOnly(paths: readonly string[]): boolean;
+interface PushChangedFiles {
+	readonly files: readonly string[];
+	readonly deterministic: boolean;
+	readonly source: "upstream" | "baseRef" | "undetermined";
+}
+/** Check if bypass is safe: deterministic range with test-only changes */
+declare function canBypassRedPhaseByChangedFiles(changedFiles: PushChangedFiles): boolean;
+/**
+* Check whether any changed files are package source files.
+*
+* Matches files under "packages/PKGNAME/src/" (any depth).
+*/
+declare function hasPackageSourceChanges(changedFiles: PushChangedFiles): boolean;
+/** Determine which files have changed for the current push */
+declare function getChangedFilesForPush(): PushChangedFiles;
+/** Check if any branch in context is a RED phase branch */
+declare function hasRedPhaseBranchInContext(currentBranch: string): boolean;
+type ScriptMap = Readonly<Record<string, string | undefined>>;
+type VerificationPlan = {
+	readonly ok: true;
+	readonly scripts: readonly string[];
+	readonly source: "verify:push" | "verify:ci" | "fallback";
+} | {
+	readonly ok: false;
+	readonly error: string;
+};
+/**
+* Derive strict pre-push verification from package scripts.
+*
+* Priority:
+* 1) `verify:push`
+* 2) `verify:ci`
+* 3) fallback sequence: `typecheck`, `check|lint`, `build`, `test`
+*/
+declare function createVerificationPlan(scripts: ScriptMap): VerificationPlan;
+/** Read and normalize scripts from package.json */
+declare function readPackageScripts(cwd?: string): ScriptMap;
+interface BunVersionCheckResult {
+	readonly matches: boolean;
+	readonly expected?: string;
+	readonly actual?: string;
+}
+/**
+* Check that the local Bun version matches the pinned version in ".bun-version".
+*
+* @param projectRoot - Directory containing ".bun-version" (defaults to cwd)
+* @returns Result indicating whether versions match
+*/
+declare function checkBunVersion(projectRoot?: string): BunVersionCheckResult;
+/**
+* Print a one-line TSDoc coverage summary across all workspace packages.
+*
+* Discovers package entry points ("packages/STAR/src/index.ts"), analyzes
+* TSDoc coverage, and outputs a single summary line. This is advisory
+* only -- the result does not affect the exit code.
+*/
+declare function printTsdocSummary(log: (msg: string) => void): Promise<void>;
+export { getCurrentBranch, runGit, isRedPhaseBranch, isScaffoldBranch, isReleaseBranch, isTestOnlyPath, areFilesTestOnly, PushChangedFiles, canBypassRedPhaseByChangedFiles, hasPackageSourceChanges, getChangedFilesForPush, hasRedPhaseBranchInContext, VerificationPlan, createVerificationPlan, readPackageScripts, BunVersionCheckResult, checkBunVersion, printTsdocSummary };

package/dist/shared/@outfitter/tooling-a59br34g.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  printCheckTsdocHuman,
+  resolveJsonMode
+} from "./tooling-5ynz680q.js";
+import {
+  analyzeCheckTsdoc
+} from "./tooling-5xxctk9b.js";
+// packages/tooling/src/cli/check-tsdoc.ts
+async function runCheckTsdoc(options = {}) {
+  const result = analyzeCheckTsdoc(options);
+  if (!result) {
+    process.stderr.write(`No packages found with src/index.ts entry points.
+` + `Searched: packages/*/src/index.ts, apps/*/src/index.ts, src/index.ts
+` + `Use --package <path> to specify a package path explicitly.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (resolveJsonMode(options)) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    printCheckTsdocHuman(result, {
+      strict: options.strict,
+      minCoverage: options.minCoverage
+    });
+  }
+  process.exitCode = result.ok ? 0 : 1;
+}
+
+export { runCheckTsdoc };

package/dist/shared/@outfitter/tooling-a6q3zh7t.js

@@ -0,0 +1,86 @@
+// @bun
+import {
+  entryToSubpath
+} from "./tooling-ayps7c4x.js";
+
+// packages/tooling/src/cli/internal/exports-fs.ts
+function matchesExclude(subpath, excludes) {
+  return excludes.some((pattern) => new Bun.Glob(pattern).match(subpath));
+}
+var CLI_EXCLUSION_PATTERNS = [
+  "**/cli.ts",
+  "**/cli/index.ts",
+  "**/bin.ts",
+  "**/bin/index.ts"
+];
+function isCliEntrypoint(entry) {
+  return CLI_EXCLUSION_PATTERNS.some((pattern) => new Bun.Glob(pattern).match(entry));
+}
+function buildExportValue(entry) {
+  const distPath = entry.replace(/^src\//, "").replace(/\.[cm]?[jt]sx?$/, "");
+  return {
+    import: {
+      types: `./dist/${distPath}.d.ts`,
+      default: `./dist/${distPath}.js`
+    }
+  };
+}
+function discoverEntries(packageRoot) {
+  const glob = new Bun.Glob("src/**/*.ts");
+  const entries = [];
+  for (const match of glob.scanSync({ cwd: packageRoot, dot: false })) {
+    if (match.includes("__tests__") || match.endsWith(".test.ts")) {
+      continue;
+    }
+    entries.push(match);
+  }
+  return entries.toSorted();
+}
+function addConfigFileExports(expected, pkg) {
+  const CONFIG_RE = /\.(json|jsonc|yml|yaml|toml)$/;
+  const configFiles = (pkg.files ?? []).filter((file) => CONFIG_RE.test(file) && file !== "package.json");
+  for (const file of configFiles) {
+    expected[`./${file}`] = `./${file}`;
+    let base = file.replace(CONFIG_RE, "");
+    const match = base.match(/^(.+)\.preset(?:\.(.+))?$/);
+    if (match?.[1]) {
+      base = match[2] ? `${match[1]}-${match[2]}` : match[1];
+    }
+    if (base !== file) {
+      expected[`./${base}`] = `./${file}`;
+    }
+  }
+}
+function computeExpectedExports(packageRoot, workspace, pkg) {
+  const entries = discoverEntries(packageRoot);
+  const exportsConfig = typeof workspace.config?.exports === "object" ? workspace.config.exports : undefined;
+  const excludes = exportsConfig?.exclude ?? [];
+  const customExports = exportsConfig?.customExports ?? {};
+  const expected = {};
+  const subpathEntries = new Map;
+  for (const entry of entries) {
+    if (isCliEntrypoint(entry))
+      continue;
+    const subpath = entryToSubpath(entry);
+    if (matchesExclude(subpath, excludes))
+      continue;
+    const existing = subpathEntries.get(subpath);
+    if (existing) {
+      if (!existing.endsWith("/index.ts") && entry.endsWith("/index.ts")) {
+        continue;
+      }
+    }
+    subpathEntries.set(subpath, entry);
+  }
+  for (const [subpath, entry] of subpathEntries) {
+    expected[subpath] = buildExportValue(entry);
+  }
+  for (const [key, value] of Object.entries(customExports)) {
+    expected[`./${key.replace(/^\.\//, "")}`] = value;
+  }
+  addConfigFileExports(expected, pkg);
+  expected["./package.json"] = "./package.json";
+  return expected;
+}
+
+export { computeExpectedExports };