@outfitter/tooling 0.3.3 → 0.3.5

package/dist/shared/{chunk-cmde0fwx.js → @outfitter/tooling-5xxctk9b.js}

@@ -1,45 +1,11 @@
+// @bun
 import {
   __require
-} from "./chunk-3s189drz.js";
+} from "./tooling-jnrs9rqd.js";
 
-// src/cli/check-tsdoc.ts
-import { resolve } from "node:path";
+// 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;
@@ -158,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}${"█".repeat(filled)}${COLORS.dim}${"░".repeat(empty)}${COLORS.reset}`;
-}
 function discoverPackages(cwd) {
   const packages = [];
   const seenEntryPoints = new Set;
@@ -195,7 +143,7 @@ function discoverPackages(cwd) {
       const pkgRoot = resolve(cwd, rootDir, pkgDir);
       let pkgName = pkgDir;
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
         if (pkgJson.name)
           pkgName = pkgJson.name;
       } catch {}
@@ -209,10 +157,10 @@ function discoverPackages(cwd) {
   if (packages.length === 0) {
     const entryPoint = resolve(cwd, "src/index.ts");
     try {
-      __require("node:fs").accessSync(entryPoint);
+      __require("fs").accessSync(entryPoint);
       let pkgName = "root";
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(cwd, "package.json"), "utf-8"));
         if (pkgJson.name)
           pkgName = pkgJson.name;
       } catch {}
@@ -224,7 +172,7 @@ function discoverPackages(cwd) {
       seenEntryPoints.add(entryPoint);
     } catch {}
   }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
+  return packages.toSorted((a, b) => a.name.localeCompare(b.name));
 }
 function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
   const result = [];
@@ -256,7 +204,7 @@ function collectReExportedSourceFiles(sourceFile, program, pkgPath) {
 }
 function analyzePackage(pkg, workspaceCwd) {
   try {
-    __require("node:fs").accessSync(pkg.entryPoint);
+    __require("fs").accessSync(pkg.entryPoint);
   } catch {
     return {
       name: pkg.name,
@@ -271,7 +219,7 @@ function analyzePackage(pkg, workspaceCwd) {
   }
   let tsconfigPath = resolve(pkg.path, "tsconfig.json");
   try {
-    __require("node:fs").accessSync(tsconfigPath);
+    __require("fs").accessSync(tsconfigPath);
   } catch {
     tsconfigPath = resolve(workspaceCwd, "tsconfig.json");
   }
@@ -318,7 +266,7 @@ function analyzeCheckTsdoc(options = {}) {
       const entryPoint = resolve(absPath, "src/index.ts");
       let name = p;
       try {
-        const pkgJson = JSON.parse(__require("node:fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(__require("fs").readFileSync(resolve(absPath, "package.json"), "utf-8"));
         if (pkgJson.name)
           name = pkgJson.name;
       } catch {}
@@ -343,79 +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.exit(1);
-  }
-  if (resolveJsonMode(options)) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
-  } else {
-    printCheckTsdocHuman(result, {
-      strict: options.strict,
-      minCoverage: options.minCoverage
-    });
-  }
-  process.exit(result.ok ? 0 : 1);
-}
-
-// src/version.ts
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-var DEFAULT_VERSION = "0.0.0";
-function readPackageVersion() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkgPath = require2.resolve("@outfitter/tooling/package.json");
-    const packageJson = JSON.parse(readFileSync(pkgPath, "utf8"));
-    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-      return packageJson.version;
-    }
-  } catch {}
-  return DEFAULT_VERSION;
-}
-var VERSION = readPackageVersion();
 
-export { coverageLevelSchema, declarationCoverageSchema, packageCoverageSchema, tsDocCheckResultSchema, analyzeSourceFile, calculateCoverage, analyzeCheckTsdoc, printCheckTsdocHuman, runCheckTsdoc, VERSION };
+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-9ram55dd.js

@@ -0,0 +1,69 @@
+// @bun
+// packages/tooling/src/cli/init.ts
+var FRAMEWORK_DETECTORS = {
+  react: ["react", "react-dom"],
+  next: ["next"],
+  vue: ["vue"],
+  nuxt: ["nuxt"],
+  svelte: ["svelte"],
+  angular: ["@angular/core"],
+  solid: ["solid-js"],
+  astro: ["astro"],
+  remix: ["@remix-run/react"],
+  qwik: ["@builder.io/qwik"]
+};
+function detectFrameworks(pkg) {
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const detected = [];
+  for (const [framework, packages] of Object.entries(FRAMEWORK_DETECTORS)) {
+    if (packages.some((p) => (p in allDeps))) {
+      detected.push(framework);
+    }
+  }
+  if (detected.length === 0) {
+    return [];
+  }
+  return ["--frameworks", ...detected];
+}
+function buildUltraciteCommand(options) {
+  const cmd = [
+    "ultracite",
+    "init",
+    "--linter",
+    "oxlint",
+    "--pm",
+    "bun",
+    "--quiet"
+  ];
+  if (options.frameworks && options.frameworks.length > 0) {
+    cmd.push("--frameworks", ...options.frameworks);
+  }
+  return cmd;
+}
+async function runInit(cwd = process.cwd()) {
+  const pkgPath = `${cwd}/package.json`;
+  const pkgFile = Bun.file(pkgPath);
+  if (!await pkgFile.exists()) {
+    process.stderr.write(`No package.json found in current directory
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const pkg = await pkgFile.json();
+  const frameworkFlags = detectFrameworks(pkg);
+  const frameworks = frameworkFlags.length > 0 ? frameworkFlags.slice(1) : [];
+  const cmd = buildUltraciteCommand({ frameworks });
+  process.stdout.write(`Running: bun x ${cmd.join(" ")}
+`);
+  const proc = Bun.spawn(["bun", "x", ...cmd], {
+    cwd,
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exitCode = exitCode;
+}
+
+export { detectFrameworks, buildUltraciteCommand, runInit };

package/dist/shared/@outfitter/tooling-9vs606gq.d.ts

@@ -0,0 +1,3 @@
+/** Package version, read from package.json at load time. */
+declare const VERSION: string;
+export { VERSION };

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

@@ -0,0 +1,21 @@
+// @bun
+// packages/tooling/src/cli/check.ts
+function buildCheckCommand(options) {
+  const cmd = ["ultracite", "check"];
+  if (options.paths && options.paths.length > 0) {
+    cmd.push(...options.paths);
+  }
+  return cmd;
+}
+async function runCheck(paths = []) {
+  const cmd = buildCheckCommand({ paths });
+  process.stdout.write(`Running: bun x ${cmd.join(" ")}
+`);
+  const proc = Bun.spawn(["bun", "x", ...cmd], {
+    stdio: ["inherit", "inherit", "inherit"]
+  });
+  const exitCode = await proc.exited;
+  process.exitCode = exitCode;
+}
+
+export { buildCheckCommand, runCheck };

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 };