bundle-cop-vercel-plugin 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# bundle-cop-vercel-plugin
+
+Next.js adapter that attributes bundle cost to source files and enforces budgets during `next build`.
+
+## Requirements
+
+- Next.js **16+** (Adapters API / `adapterPath`)
+- Node.js 20+
+
+## Install
+
+```bash
+pnpm add bundle-cop-vercel-plugin
+# or: npm i bundle-cop-vercel-plugin
+```
+
+## Setup
+
+```ts
+// next.config.ts
+import type { NextConfig } from 'next'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+const nextConfig: NextConfig = {
+  adapterPath: require.resolve('bundle-cop-vercel-plugin/adapter'),
+}
+
+export default nextConfig
+```
+
+Optional budgets — create `bundle-cop.config.json` in the project root:
+
+```json
+{
+  "budgets": [
+    { "path": "/*", "maxSize": "250kb", "enforce": "warn" }
+  ],
+  "suggestions": true
+}
+```
+
+## What it does
+
+On `onBuildComplete`:
+
+1. Parses `.next` diagnostics / chunks (Turbopack-aware fallbacks)
+2. Attributes heavy packages (e.g. `moment`) to the importing file
+3. Checks budgets (`warn` or fail build on `error`)
+4. Writes `bundle-report.json`
+5. Uploads to Vercel Blob when `BLOB_READ_WRITE_TOKEN` is set (`access: 'private'`)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,655 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  adapter: () => adapter,
+  checkBudgets: () => checkBudgets,
+  default: () => index_default,
+  findCulprit: () => findCulprit,
+  findNextDir: () => findNextDir,
+  formatBytes: () => formatBytes,
+  loadConfig: () => loadConfig,
+  parseSize: () => parseSize,
+  parseStats: () => parseStats,
+  runBundleCop: () => runBundleCop,
+  suggestAlternative: () => suggestAlternative
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_path5 = require("path");
+
+// src/budgets.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var SIZE_RE = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i;
+function parseSize(input) {
+  const match = input.trim().match(SIZE_RE);
+  if (!match) {
+    throw new Error(`Invalid size: ${input}`);
+  }
+  const value = Number(match[1]);
+  const unit = (match[2] || "b").toLowerCase();
+  switch (unit) {
+    case "b":
+      return value;
+    case "kb":
+      return Math.round(value * 1024);
+    case "mb":
+      return Math.round(value * 1024 * 1024);
+    case "gb":
+      return Math.round(value * 1024 * 1024 * 1024);
+    default:
+      throw new Error(`Invalid size unit: ${unit}`);
+  }
+}
+function loadConfig(projectDir) {
+  const path = (0, import_node_path.join)(projectDir, "bundle-cop.config.json");
+  if (!(0, import_node_fs.existsSync)(path)) {
+    return {
+      budgets: [],
+      ignore: [],
+      githubComment: true,
+      suggestions: true
+    };
+  }
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch (error) {
+    console.warn("[bundle-cop] Failed to parse bundle-cop.config.json:", error);
+    return { budgets: [], suggestions: true, githubComment: true };
+  }
+}
+function checkBudgets(report, config) {
+  const budgets = config.budgets ?? [];
+  return budgets.map((rule) => {
+    const maxBytes = parseSize(rule.maxSize);
+    const matching = report.chunks.filter((chunk) => {
+      if (rule.path === "/*" || rule.path === "/") return true;
+      const route = chunk.route || "";
+      return route === rule.path || route.startsWith(rule.path.replace(/\/$/, ""));
+    });
+    const actualBytes = matching.length > 0 ? matching.reduce((sum, c) => sum + c.size, 0) : report.totalBytes;
+    return {
+      path: rule.path,
+      maxBytes,
+      actualBytes,
+      enforce: rule.enforce,
+      exceeded: actualBytes > maxBytes
+    };
+  });
+}
+function enforceBudgets(results) {
+  const errors = results.filter((r) => r.exceeded && r.enforce === "error");
+  for (const warn of results.filter((r) => r.exceeded && r.enforce === "warn")) {
+    console.warn(
+      `[bundle-cop] Budget warn ${warn.path}: ${formatBytes(warn.actualBytes)} > ${formatBytes(warn.maxBytes)}`
+    );
+  }
+  if (errors.length === 0) return;
+  const details = errors.map(
+    (e) => `${e.path}: ${formatBytes(e.actualBytes)} exceeds ${formatBytes(e.maxBytes)}`
+  ).join("; ");
+  throw new Error(`[bundle-cop] Budget exceeded \u2014 ${details}`);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+// src/find-next-dir.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "coverage",
+  ".turbo",
+  ".vercel"
+]);
+function findNextDir(startDir, preferredDir) {
+  if (preferredDir && (0, import_node_fs2.existsSync)(preferredDir)) {
+    return preferredDir;
+  }
+  const direct = (0, import_node_path2.join)(startDir, ".next");
+  if ((0, import_node_fs2.existsSync)(direct)) {
+    return direct;
+  }
+  let current = startDir;
+  for (let i = 0; i < 5; i++) {
+    const found = walkForNext(current, 4);
+    if (found) return found;
+    const parent = (0, import_node_path2.join)(current, "..");
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function walkForNext(dir, depth) {
+  if (depth < 0) return null;
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(dir);
+  } catch {
+    return null;
+  }
+  const nested = (0, import_node_path2.join)(dir, ".next");
+  if ((0, import_node_fs2.existsSync)(nested)) return nested;
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || entry.startsWith(".")) continue;
+    const full = (0, import_node_path2.join)(dir, entry);
+    try {
+      if (!(0, import_node_fs2.statSync)(full).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const found = walkForNext(full, depth - 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+// src/parser.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+
+// src/attribution.ts
+function isUserFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (!normalized) return false;
+  if (normalized.includes("node_modules/")) return false;
+  if (normalized.includes("/.next/")) return false;
+  if (normalized.startsWith(".next/")) return false;
+  return true;
+}
+function toPath(entry) {
+  if (typeof entry === "string") return entry;
+  return entry.path || entry.name || "";
+}
+function toName(entry) {
+  if (typeof entry === "string") return entry;
+  return entry.name || entry.path || "";
+}
+function findCulprit(module2) {
+  const raw = module2.issuerPath ?? [];
+  const chain = raw.map(toName).filter(Boolean);
+  for (let i = raw.length - 1; i >= 0; i--) {
+    const path = toPath(raw[i]);
+    if (isUserFile(path)) {
+      return { culpritFile: path, chain };
+    }
+  }
+  if (isUserFile(module2.name)) {
+    return { culpritFile: module2.name, chain };
+  }
+  return { culpritFile: "unknown", chain };
+}
+var ALTERNATIVES = {
+  moment: "date-fns (save ~270kb) -> npm i date-fns",
+  lodash: "lodash-es + tree-shake or individual imports",
+  "react-icons": "import directly: react-icons/fa/FaIcon",
+  "date-fns": "use subpath imports: date-fns/format"
+};
+function suggestAlternative(moduleName) {
+  const normalized = moduleName.replace(/\\/g, "/").toLowerCase();
+  for (const [key, suggestion] of Object.entries(ALTERNATIVES)) {
+    if (normalized === key || normalized.includes(`node_modules/${key}/`) || normalized.startsWith(`${key}/`) || normalized.includes(`/${key}/`)) {
+      return suggestion;
+    }
+  }
+  return null;
+}
+
+// src/parser.ts
+var KNOWN_HEAVY = [
+  "moment",
+  "lodash",
+  "lodash-es",
+  "date-fns",
+  "react-icons",
+  "rxjs",
+  "antd",
+  "chart.js",
+  "recharts"
+];
+async function parseStats(options) {
+  const {
+    nextDir,
+    projectDir,
+    commitSha = null,
+    withSuggestions = true
+  } = options;
+  const fromDiagnostics = tryParseDiagnostics(nextDir, withSuggestions);
+  if (fromDiagnostics && fromDiagnostics.modules.length > 0) {
+    return finalize(fromDiagnostics, commitSha);
+  }
+  const fromAnalyze = tryParseAnalyzeClient(nextDir, withSuggestions);
+  if (fromAnalyze && fromAnalyze.modules.length > 0) {
+    return finalize(fromAnalyze, commitSha);
+  }
+  const fromChunks = parseChunkFallback(nextDir);
+  const fromRouteStats = parseRouteBundleStats(nextDir);
+  const chunks = fromRouteStats.chunks.length > 0 ? fromRouteStats.chunks : fromChunks.chunks;
+  const totalBytes = fromRouteStats.totalBytes || fromChunks.totalBytes || chunks.reduce((s, c) => s + c.size, 0);
+  const modules = enrichWithKnownPackages({
+    nextDir,
+    projectDir: projectDir || (0, import_node_path3.join)(nextDir, ".."),
+    withSuggestions
+  });
+  return finalize(
+    {
+      totalBytes,
+      modules: sortBySize(modules),
+      chunks: sortBySize(chunks)
+    },
+    commitSha
+  );
+}
+function finalize(partial, commitSha) {
+  return {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    commitSha,
+    ...partial
+  };
+}
+function tryParseDiagnostics(nextDir, withSuggestions) {
+  const dir = (0, import_node_path3.join)(nextDir, "diagnostics", "analyze");
+  if (!(0, import_node_fs3.existsSync)(dir)) return null;
+  const modules = [];
+  const chunks = [];
+  for (const file of listJsonFiles(dir)) {
+    try {
+      const data = JSON.parse((0, import_node_fs3.readFileSync)(file, "utf8"));
+      absorbStats(data, modules, chunks, withSuggestions);
+    } catch {
+    }
+  }
+  if (modules.length === 0 && chunks.length === 0) return null;
+  const totalBytes = chunks.reduce((s, c) => s + c.size, 0) || modules.reduce((s, m) => s + m.size, 0);
+  return { totalBytes, modules: sortBySize(modules), chunks: sortBySize(chunks) };
+}
+function tryParseAnalyzeClient(nextDir, withSuggestions) {
+  const clientPath = (0, import_node_path3.join)(nextDir, "analyze", "client.json");
+  if (!(0, import_node_fs3.existsSync)(clientPath)) return null;
+  try {
+    const data = JSON.parse((0, import_node_fs3.readFileSync)(clientPath, "utf8"));
+    const modules = [];
+    const chunks = [];
+    absorbStats(data, modules, chunks, withSuggestions);
+    const totalBytes = chunks.reduce((s, c) => s + c.size, 0) || modules.reduce((s, m) => s + m.size, 0);
+    return {
+      totalBytes,
+      modules: sortBySize(modules),
+      chunks: sortBySize(chunks)
+    };
+  } catch {
+    return null;
+  }
+}
+function parseRouteBundleStats(nextDir) {
+  const path = (0, import_node_path3.join)(nextDir, "diagnostics", "route-bundle-stats.json");
+  if (!(0, import_node_fs3.existsSync)(path)) {
+    return { totalBytes: 0, modules: [], chunks: [] };
+  }
+  try {
+    const rows = JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+    const chunks = rows.map((row) => ({
+      name: row.route || "unknown",
+      size: Number(row.firstLoadUncompressedJsBytes || 0),
+      route: row.route
+    }));
+    const totalBytes = Math.max(...chunks.map((c) => c.size), 0);
+    return { totalBytes, modules: [], chunks: sortBySize(chunks) };
+  } catch {
+    return { totalBytes: 0, modules: [], chunks: [] };
+  }
+}
+function parseChunkFallback(nextDir) {
+  const chunksDir = (0, import_node_path3.join)(nextDir, "static", "chunks");
+  const chunks = [];
+  if ((0, import_node_fs3.existsSync)(chunksDir)) {
+    for (const file of walkFiles(chunksDir)) {
+      if (!file.endsWith(".js")) continue;
+      try {
+        const size = (0, import_node_fs3.statSync)(file).size;
+        const name = file.slice(chunksDir.length + 1);
+        chunks.push({ name, size, route: guessRoute(name) });
+      } catch {
+      }
+    }
+  }
+  for (const manifestName of ["build-manifest.json", "app-build-manifest.json"]) {
+    const manifestPath = (0, import_node_path3.join)(nextDir, manifestName);
+    if (!(0, import_node_fs3.existsSync)(manifestPath)) continue;
+    try {
+      const manifest = JSON.parse((0, import_node_fs3.readFileSync)(manifestPath, "utf8"));
+      for (const [route, files] of Object.entries(manifest.pages ?? {})) {
+        for (const file of files) {
+          const abs = (0, import_node_path3.join)(nextDir, file.replace(/^\//, ""));
+          if (!(0, import_node_fs3.existsSync)(abs)) continue;
+          const size = (0, import_node_fs3.statSync)(abs).size;
+          if (!chunks.some((c) => c.name === file)) {
+            chunks.push({ name: file, size, route });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const totalBytes = chunks.reduce((s, c) => s + c.size, 0);
+  return { totalBytes, modules: [], chunks: sortBySize(chunks) };
+}
+function enrichWithKnownPackages(opts) {
+  const chunksDir = (0, import_node_path3.join)(opts.nextDir, "static", "chunks");
+  const serverDir = (0, import_node_path3.join)(opts.nextDir, "server");
+  const scanDirs = [chunksDir, serverDir].filter((d) => (0, import_node_fs3.existsSync)(d));
+  if (scanDirs.length === 0) return [];
+  const present = /* @__PURE__ */ new Set();
+  for (const dir of scanDirs) {
+    for (const file of walkFiles(dir)) {
+      if (!file.endsWith(".js")) continue;
+      let text = "";
+      try {
+        const buf = (0, import_node_fs3.readFileSync)(file);
+        text = buf.subarray(0, Math.min(buf.length, 2e6)).toString("utf8");
+      } catch {
+        continue;
+      }
+      for (const pkg of KNOWN_HEAVY) {
+        if (text.includes(`node_modules/${pkg}`) || text.includes(`/${pkg}/`) || text.includes(`"${pkg}"`) || text.includes(`'${pkg}'`)) {
+          present.add(pkg);
+        }
+      }
+    }
+  }
+  const modules = [];
+  for (const pkg of present) {
+    const size = estimatePackageChunkSize(scanDirs, pkg);
+    const culpritFile = findImportCulprit(opts.projectDir, pkg) || "unknown";
+    modules.push({
+      name: pkg,
+      size: size || 50 * 1024,
+      culpritFile,
+      chain: [pkg, culpritFile],
+      issuerPath: [pkg, culpritFile],
+      suggestion: opts.withSuggestions ? suggestAlternative(pkg) : null
+    });
+  }
+  return modules;
+}
+function estimatePackageChunkSize(dirs, pkg) {
+  let best = 0;
+  for (const dir of dirs) {
+    for (const file of walkFiles(dir)) {
+      if (!file.endsWith(".js")) continue;
+      try {
+        const buf = (0, import_node_fs3.readFileSync)(file);
+        const text = buf.subarray(0, Math.min(buf.length, 5e5)).toString("utf8");
+        if (text.includes(pkg)) {
+          best = Math.max(best, (0, import_node_fs3.statSync)(file).size);
+        }
+      } catch {
+      }
+    }
+  }
+  return best;
+}
+function findImportCulprit(projectDir, pkg) {
+  const roots = ["app", "pages", "src", "components"];
+  for (const root of roots) {
+    const dir = (0, import_node_path3.join)(projectDir, root);
+    if (!(0, import_node_fs3.existsSync)(dir)) continue;
+    const hit = searchImport(dir, pkg, projectDir, 6);
+    if (hit) return hit;
+  }
+  return null;
+}
+function searchImport(dir, pkg, projectDir, depth) {
+  if (depth < 0) return null;
+  let entries;
+  try {
+    entries = (0, import_node_fs3.readdirSync)(dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry.startsWith(".")) continue;
+    const full = (0, import_node_path3.join)(dir, entry);
+    let st;
+    try {
+      st = (0, import_node_fs3.statSync)(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      const found = searchImport(full, pkg, projectDir, depth - 1);
+      if (found) return found;
+      continue;
+    }
+    if (!/\.(tsx?|jsx?|mjs|cjs)$/.test(entry)) continue;
+    try {
+      const text = (0, import_node_fs3.readFileSync)(full, "utf8");
+      if (text.includes(`from '${pkg}'`) || text.includes(`from "${pkg}"`) || text.includes(`require('${pkg}')`) || text.includes(`require("${pkg}")`) || text.includes(`from '${pkg}/`) || text.includes(`from "${pkg}/`)) {
+        return (0, import_node_path3.relative)(projectDir, full).replace(/\\/g, "/");
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function absorbStats(data, modules, chunks, withSuggestions) {
+  if (!data || typeof data !== "object") return;
+  const root = data;
+  if (Array.isArray(root.chunks)) {
+    for (const chunk of root.chunks) {
+      chunks.push({
+        name: String(chunk.name ?? chunk.id ?? "chunk"),
+        size: Number(chunk.size ?? chunk.parsedSize ?? 0),
+        route: typeof chunk.route === "string" ? chunk.route : void 0
+      });
+    }
+  }
+  const moduleList = [];
+  collectModules(root.modules, moduleList);
+  collectModules(root.tree, moduleList);
+  for (const mod of moduleList) {
+    const size = Number(mod.size ?? mod.gzipSize ?? 0);
+    if (!mod.name || size <= 0) continue;
+    const { culpritFile, chain } = findCulprit(mod);
+    modules.push({
+      name: mod.name,
+      size,
+      issuerPath: chain,
+      culpritFile,
+      chain,
+      suggestion: withSuggestions ? suggestAlternative(mod.name) : null
+    });
+  }
+}
+function collectModules(node, out) {
+  if (!node) return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectModules(item, out);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const obj = node;
+  if (typeof obj.name === "string" && (obj.size != null || obj.gzipSize != null)) {
+    out.push(obj);
+  }
+  if (Array.isArray(obj.children)) collectModules(obj.children, out);
+  if (Array.isArray(obj.modules)) collectModules(obj.modules, out);
+}
+function listJsonFiles(dir) {
+  return walkFiles(dir).filter((f) => f.endsWith(".json"));
+}
+function walkFiles(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs3.readdirSync)(dir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = (0, import_node_path3.join)(dir, entry);
+    try {
+      const st = (0, import_node_fs3.statSync)(full);
+      if (st.isDirectory()) out.push(...walkFiles(full));
+      else out.push(full);
+    } catch {
+    }
+  }
+  return out;
+}
+function guessRoute(chunkName) {
+  const match = chunkName.match(/(?:^|\/)app(\/.*)\/(?:page|layout|route)/);
+  if (match?.[1]) return match[1] || "/";
+  return void 0;
+}
+function sortBySize(items) {
+  return [...items].sort((a, b) => b.size - a.size);
+}
+
+// src/uploader.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+function writeLocalReport(projectDir, report) {
+  const outPaths = [
+    (0, import_node_path4.join)(projectDir, "bundle-report.json"),
+    (0, import_node_path4.join)(projectDir, ".vercel", "output", "static", "bundle-report.json")
+  ];
+  let primary = outPaths[0];
+  for (const outPath of outPaths) {
+    try {
+      (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(outPath), { recursive: true });
+      (0, import_node_fs4.writeFileSync)(outPath, JSON.stringify(report, null, 2));
+      primary = outPath;
+    } catch (error) {
+      console.warn(`[bundle-cop] Could not write ${outPath}:`, error);
+    }
+  }
+  return primary;
+}
+async function uploadReport(report) {
+  const token = process.env.BLOB_READ_WRITE_TOKEN;
+  const sha = report.commitSha || process.env.VERCEL_GIT_COMMIT_SHA || process.env.GITHUB_SHA || "local";
+  if (!token) {
+    console.warn(
+      "[bundle-cop] BLOB_READ_WRITE_TOKEN not set \u2014 skipping Blob upload"
+    );
+    return null;
+  }
+  try {
+    const { put } = await import("@vercel/blob");
+    const pathname = `bundle-reports/${sha}.json`;
+    const result = await put(pathname, JSON.stringify(report), {
+      access: "private",
+      contentType: "application/json",
+      addRandomSuffix: false,
+      allowOverwrite: true,
+      token
+    });
+    console.log(`[bundle-cop] Uploaded report to Blob: ${pathname}`);
+    return result.url;
+  } catch (error) {
+    console.warn("[bundle-cop] Blob upload failed:", error);
+    return null;
+  }
+}
+
+// src/index.ts
+async function runBundleCop(ctx) {
+  const nextDir = findNextDir(ctx.projectDir, ctx.distDir) || (0, import_node_path5.join)(ctx.projectDir, ".next");
+  const config = loadConfig(ctx.projectDir);
+  const report = await parseStats({
+    nextDir,
+    projectDir: ctx.projectDir,
+    commitSha: process.env.VERCEL_GIT_COMMIT_SHA || process.env.GITHUB_SHA || null,
+    withSuggestions: config.suggestions !== false
+  });
+  const budgetResults = checkBudgets(report, config);
+  report.budgetResults = budgetResults;
+  writeLocalReport(ctx.projectDir, report);
+  await uploadReport(report);
+  enforceBudgets(budgetResults);
+  console.log(
+    `[bundle-cop] Report total=${report.totalBytes}B modules=${report.modules.length} chunks=${report.chunks.length}`
+  );
+  return report;
+}
+var adapter = {
+  name: "bundle-cop",
+  async modifyConfig(config, ctx) {
+    if (ctx.phase !== "phase-production-build") {
+      return config;
+    }
+    if (!process.env.BUNDLE_COP_ANALYZE) {
+      process.env.BUNDLE_COP_ANALYZE = "1";
+    }
+    const experimental = typeof config.experimental === "object" && config.experimental ? { ...config.experimental } : {};
+    return {
+      ...config,
+      experimental
+    };
+  },
+  async onBuildComplete(ctx) {
+    const started = Date.now();
+    try {
+      await runBundleCop({
+        projectDir: ctx.projectDir || ctx.repoRoot,
+        distDir: ctx.distDir
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("[bundle-cop] Budget exceeded")) {
+        throw error;
+      }
+      console.warn("[bundle-cop] onBuildComplete error:", error);
+    } finally {
+      console.log(`[bundle-cop] finished in ${Date.now() - started}ms`);
+    }
+  }
+};
+var index_default = adapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adapter,
+  checkBudgets,
+  findCulprit,
+  findNextDir,
+  formatBytes,
+  loadConfig,
+  parseSize,
+  parseStats,
+  runBundleCop,
+  suggestAlternative
+});