@arcote.tech/arc-cli 0.8.1 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",
@@ -12,13 +12,13 @@
     "build": "bun build --target=bun ./src/index.ts --outdir=dist --external @arcote.tech/arc --external @arcote.tech/arc-ds --external @arcote.tech/arc-react --external @arcote.tech/platform --external @arcote.tech/arc-map --external '@opentelemetry/*' && chmod +x dist/index.js"
   },
   "dependencies": {
-    "@arcote.tech/arc": "^0.8.1",
-    "@arcote.tech/arc-ds": "^0.8.1",
-    "@arcote.tech/arc-react": "^0.8.1",
-    "@arcote.tech/arc-host": "^0.8.1",
-    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.1",
-    "@arcote.tech/arc-adapter-db-postgres": "^0.8.1",
-    "@arcote.tech/arc-otel": "^0.8.1",
+    "@arcote.tech/arc": "^0.8.3",
+    "@arcote.tech/arc-ds": "^0.8.3",
+    "@arcote.tech/arc-react": "^0.8.3",
+    "@arcote.tech/arc-host": "^0.8.3",
+    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.3",
+    "@arcote.tech/arc-adapter-db-postgres": "^0.8.3",
+    "@arcote.tech/arc-otel": "^0.8.3",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.57.0",
     "@opentelemetry/core": "^1.30.0",
@@ -31,8 +31,8 @@
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/sdk-trace-node": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.27.0",
-    "@arcote.tech/platform": "^0.8.1",
-    "@arcote.tech/arc-map": "^0.8.1",
+    "@arcote.tech/platform": "^0.8.3",
+    "@arcote.tech/arc-map": "^0.8.3",
     "@clack/prompts": "^0.9.0",
     "commander": "^11.1.0",
     "chokidar": "^3.5.3",

package/src/builder/chunk-planner.ts

@@ -120,6 +120,20 @@ function collectModuleNames(dir: string, acc: Set<string>): void {
   }
 }
 
+/**
+ * Czy pakiet DEKLARUJE moduł Arc (`module("...")` w źródłach). Tylko takie
+ * pakiety są „członkami" wchodzącymi do initial/grup — czysta biblioteka bez
+ * modułu (np. pakiet z szablonami maili) NIE może być side-effect-importowana
+ * przez initial, bo z `sideEffects:true` wciągałaby całe swoje drzewo
+ * zależności do pierwszego wczytania (patrz: @react-email w NDT — 1,4 MB
+ * stosu maili w bundlu klienta przez samo `import "@ndt/email"`).
+ */
+export function packageDeclaresModule(pkg: WorkspacePackage): boolean {
+  const names = new Set<string>();
+  collectModuleNames(join(pkg.path, "src"), names);
+  return names.size > 0;
+}
+
 /**
  * Assert every workspace package declares at most one `module()`. Throws a
  * build error listing offenders, with the fix (split each extra module into

package/src/builder/module-builder.ts

@@ -239,6 +239,51 @@ function workspaceSourcePlugin(srcByName: Map<string, string>): import("bun").Bu
   };
 }
 
+// Builtiny node, które w przeglądarce NIGDY nie mają sensu (I/O, krypto,
+// procesy, sieć). Domyślnie Bun polyfilluje je ciężkimi shimami (crypto →
+// crypto-browserify ~360 KB gzip) — a że kod serwerowy (webhooki, hashowanie,
+// szyfrowanie OAuth) importuje je statycznie na górze modułu, polyfill ląduje
+// w bundlu klienta, mimo że ten kod nigdy nie biegnie w przeglądarce.
+//
+// CELOWO NIE stubujemy „przeglądarkowo-bezpiecznych" builtinów (buffer, util,
+// events, path, url, string_decoder, querystring, assert, process) — te bywają
+// realnie używane po stronie klienta i mają lekkie, działające polyfille.
+const SERVER_ONLY_NODE_BUILTINS = new Set([
+  "crypto", "stream", "zlib", "fs", "fs/promises", "net", "tls", "http",
+  "https", "http2", "dns", "dgram", "child_process", "worker_threads",
+  "cluster", "os", "v8", "vm", "readline", "repl", "tty", "perf_hooks",
+  "inspector", "async_hooks", "diagnostics_channel", "module", "constants",
+]);
+
+/**
+ * Zastępuje serwerowe builtiny node (SERVER_ONLY_NODE_BUILTINS) rzucającym
+ * stubem w buildzie przeglądarki — zamiast polyfilla. Dowolny named/default
+ * import przechodzi (interop CJS-Proxy), ale UŻYCIE na kliencie rzuca jasny
+ * błąd „server-only". Efekt: server-only kod importujący `node:crypto` itd.
+ * nie wciąga polyfilla do bundla klienta (NDT: −~360 KB gzip).
+ */
+function nodeServerBuiltinStubPlugin(): import("bun").BunPlugin {
+  return {
+    name: "node-server-builtin-stub",
+    setup(build) {
+      build.onResolve({ filter: /^(node:)?[a-z_/]+$/ }, (args) => {
+        const bare = args.path.replace(/^node:/, "");
+        if (!SERVER_ONLY_NODE_BUILTINS.has(bare)) return undefined;
+        return { path: args.path, namespace: "node-server-stub" };
+      });
+      build.onLoad({ filter: /.*/, namespace: "node-server-stub" }, (args) => ({
+        // CJS Proxy: `import { createHash } from "node:crypto"` czyta
+        // `module.exports.createHash` przez interop → getter rzuca dopiero przy
+        // realnym użyciu. `__esModule:false` żeby interop potraktował to jak CJS.
+        contents:
+          `const e=()=>{throw new Error("Node builtin '${args.path}' jest server-only — niedostępny w przeglądarce");};` +
+          `module.exports=new Proxy({},{get:(_,p)=>p==="__esModule"?false:e});`,
+        loader: "js",
+      }));
+    },
+  };
+}
+
 function jsxDevShimPlugin(): import("bun").BunPlugin {
   return {
     name: "jsx-dev-runtime-shim",
@@ -456,7 +501,13 @@ async function buildContextClient(
     format: "esm",
     naming: "index.[ext]",
     external: externals,
-    plugins: [jsxDevShimPlugin()],
+    plugins: [
+      jsxDevShimPlugin(),
+      // Browser dist: serwerowe builtiny node → rzucający stub zamiast ciężkiego
+      // polyfilla (np. @ndt/social szyfruje tokeny OAuth przez node:crypto —
+      // server-only, ale ląduje w dist/browser i wciągało crypto-browserify).
+      ...(client.target === "browser" ? [nodeServerBuiltinStubPlugin()] : []),
+    ],
     define: client.defines,
   });
 
@@ -677,9 +728,13 @@ export async function buildServerApp(
 
   let result;
   try {
+    // Bez `outdir` — artefakty w pamięci, pliki piszemy sami (niżej).
+    // Równoległy builder tego samego workspace'u (dev watcher) potrafi
+    // wipe'ować serverDir w trakcie zapisu outputów Buna (losowe `ENOENT:
+    // writing sourcemap for chunk` wywalało cały build). Ten sam wzorzec
+    // ochrony co w buildBrowserApp.
     result = await Bun.build({
       entrypoints: [entrySrc],
-      outdir: serverDir,
       target: "bun",
       format: "esm",
       // splitting:true is the whole point — it makes Bun emit eager top-level
@@ -720,6 +775,15 @@ export async function buildServerApp(
     );
   }
 
+  // Zapis wszystkich artefaktów (entry + chunki + sourcemapy) własną ręką —
+  // patrz komentarz przy Bun.build wyżej.
+  for (const out of result.outputs) {
+    writeFileSync(
+      join(serverDir, basename(out.path)),
+      new Uint8Array(await out.arrayBuffer()),
+    );
+  }
+
   // Third-party externals only — framework peers carry their own resolution in
   // collectFrameworkDeps, so drop them here to avoid double-sourcing versions.
   const externals: ServerExternal[] = [...recorded]
@@ -787,6 +851,194 @@ export interface BrowserAppResult {
   readonly cached: boolean;
 }
 
+/** Output builda przeglądarki trzymany w pamięci — bajty prosto z artefaktu
+ *  Bun.build, zapisywane na dysk przez NAS (patrz komentarz przy runBuild). */
+interface BrowserOutFile {
+  kind: "entry-point" | "chunk" | string;
+  name: string;
+  bytes: Uint8Array;
+}
+
+// ---------------------------------------------------------------------------
+// Build stats (ARC_BUILD_STATS=1) — rozbicie każdego chunku na biblioteki.
+//
+// Skąd dane: build w trybie stats emituje sourcemapy (`sourcemap: "external"`),
+// których `sources[]` niosą ścieżki KAŻDEGO pliku źródłowego wmieszanego do
+// chunku, a `sourcesContent[]` jego treść. Przypisujemy każdy plik do pakietu
+// (node_modules → zewnętrzny, packages/* → wewnętrzny) i sumujemy bajty źródeł
+// jako wagę wkładu. To odpowiada na pytanie "co i skąd wpadło do bundla" —
+// w szczególności KTÓRE wejście (initial vs grupa tokenu) ciągnie ciężką libę.
+// ---------------------------------------------------------------------------
+
+/** Czy build ma policzyć i wypisać rozbicie chunków na biblioteki. */
+export function buildStatsEnabled(): boolean {
+  return process.env.ARC_BUILD_STATS === "1";
+}
+
+interface PkgWeight {
+  pkg: string;
+  bytes: number;
+  external: boolean;
+}
+
+/** Ścieżka źródła (z sourcemapy) → nazwa pakietu + czy zewnętrzny. */
+function classifySource(src: string): { pkg: string; external: boolean } {
+  const nm = src.lastIndexOf("node_modules/");
+  if (nm >= 0) {
+    const rest = src.slice(nm + "node_modules/".length);
+    const parts = rest.split("/");
+    const pkg = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+    // @ndt/* i @arcote.tech/* rozwiązane przez symlink w node_modules to
+    // faktycznie kod wewnętrzny/frameworkowy — nie "zewnętrzna zależność npm".
+    const external = !pkg.startsWith("@ndt/") && !pkg.startsWith("@arcote.tech/");
+    return { pkg, external };
+  }
+  // Źródło workspace (np. "packages/mailing/src/ids.ts").
+  const m = src.match(/(?:^|\/)packages\/([^/]+)\//);
+  if (m) return { pkg: `packages/${m[1]}`, external: false };
+  return { pkg: src.split("/").slice(0, 2).join("/") || src, external: false };
+}
+
+/** Rozbij chunk (po sourcemapie) na wagi per pakiet, malejąco. */
+function chunkPkgWeights(map: {
+  sources?: string[];
+  sourcesContent?: (string | null)[];
+}): PkgWeight[] {
+  const acc = new Map<string, PkgWeight>();
+  const sources = map.sources ?? [];
+  const contents = map.sourcesContent ?? [];
+  for (let i = 0; i < sources.length; i++) {
+    const bytes = contents[i]?.length ?? 0;
+    const { pkg, external } = classifySource(sources[i]);
+    const cur = acc.get(pkg) ?? { pkg, bytes: 0, external };
+    cur.bytes += bytes;
+    acc.set(pkg, cur);
+  }
+  return [...acc.values()].sort((a, b) => b.bytes - a.bytes);
+}
+
+const kb = (n: number) => `${Math.round(n / 1024)} KB`;
+
+/** Usuń końcowe linie `//# debugId=` / `//# sourceMappingURL=` dopięte przez
+ *  Bun przy `sourcemap:"external"`, tak by bajty JS == build bez sourcemap. */
+function stripTrailingSourcemapComment(bytes: Uint8Array): Uint8Array {
+  let text = Buffer.from(bytes).toString("utf8");
+  text = text.replace(/\n*\/\/# (?:debugId|sourceMappingURL)=[^\n]*\s*$/, "");
+  if (!text.endsWith("\n")) text += "\n";
+  return new Uint8Array(Buffer.from(text, "utf8"));
+}
+
+/**
+ * Wypisz rozbicie buildu: dla każdego WEJŚCIA (initial + grupy tokenów)
+ * jego pierwsze wczytanie (statyczne domknięcie chunków) z wagą raw/gzip
+ * i najcięższymi bibliotekami, plus globalny ranking zewnętrznych libów
+ * z informacją, w którym chunku i pod którym wejściem lądują.
+ */
+function reportBrowserBuildStats(opts: {
+  label: string;
+  entries: { name: string; file: string }[];
+  jsByName: Map<string, Uint8Array>;
+  mapsByJs: Map<string, { sources?: string[]; sourcesContent?: (string | null)[] }>;
+}): void {
+  const { label, entries, jsByName, mapsByJs } = opts;
+
+  // Graf statycznych importów (bare `import"..."` / `from"..."`, NIE `import(...)`).
+  const staticEdge =
+    /(?:^|[;}\s])import\s*["'](\.\/[^"']+\.js)["']|from\s*["'](\.\/[^"']+\.js)["']/g;
+  const staticImports = (name: string): string[] => {
+    const bytes = jsByName.get(name);
+    if (!bytes) return [];
+    const s = Buffer.from(bytes).toString("utf8");
+    const out: string[] = [];
+    let m: RegExpExecArray | null;
+    staticEdge.lastIndex = 0;
+    while ((m = staticEdge.exec(s))) out.push(basename(m[1] ?? m[2]!));
+    return out;
+  };
+  const closure = (start: string): Set<string> => {
+    const seen = new Set<string>();
+    const stack = [start];
+    while (stack.length) {
+      const f = stack.pop()!;
+      if (seen.has(f) || !jsByName.has(f)) continue;
+      seen.add(f);
+      stack.push(...staticImports(f));
+    }
+    return seen;
+  };
+
+  const gz = (bytes: Uint8Array) =>
+    Bun.gzipSync(bytes as Uint8Array<ArrayBuffer>, { level: 6 }).length;
+
+  console.log(`\n━━━━━ Build stats: ${label} ━━━━━`);
+  const globalExt = new Map<string, { bytes: number; chunks: Set<string>; entries: Set<string> }>();
+
+  for (const entry of entries) {
+    const files = closure(entry.file);
+    let raw = 0;
+    let gzip = 0;
+    const pkgAcc = new Map<string, PkgWeight>();
+    for (const f of files) {
+      const bytes = jsByName.get(f)!;
+      raw += bytes.length;
+      gzip += gz(bytes);
+      const map = mapsByJs.get(f);
+      if (!map) continue;
+      for (const w of chunkPkgWeights(map)) {
+        const cur = pkgAcc.get(w.pkg) ?? { pkg: w.pkg, bytes: 0, external: w.external };
+        cur.bytes += w.bytes;
+        pkgAcc.set(w.pkg, cur);
+        if (w.external) {
+          const g = globalExt.get(w.pkg) ?? { bytes: 0, chunks: new Set(), entries: new Set() };
+          g.bytes = Math.max(g.bytes, w.bytes);
+          g.chunks.add(f);
+          g.entries.add(entry.name);
+          globalExt.set(w.pkg, g);
+        }
+      }
+    }
+    const top = [...pkgAcc.values()].sort((a, b) => b.bytes - a.bytes).slice(0, 10);
+    console.log(
+      `\n▸ ${entry.name}: pierwsze wczytanie ${kb(raw)} raw / ${kb(gzip)} gzip (${files.size} plików)`,
+    );
+    for (const w of top) {
+      const tag = w.external ? "ext" : "wewn";
+      console.log(`    ${kb(w.bytes).padStart(8)}  [${tag}] ${w.pkg}`);
+    }
+  }
+
+  const heaviest = [...globalExt.entries()].sort((a, b) => b[1].bytes - a[1].bytes).slice(0, 15);
+  if (heaviest.length) {
+    console.log(`\n▸ Najcięższe biblioteki ZEWNĘTRZNE (źródła) i gdzie lądują:`);
+    for (const [pkg, g] of heaviest) {
+      console.log(
+        `    ${kb(g.bytes).padStart(8)}  ${pkg}  → ${[...g.entries].join(", ")}`,
+      );
+    }
+  }
+  console.log(`\n━━━━━ koniec stats: ${label} ━━━━━\n`);
+}
+
+/**
+ * Heurystyka "czy output wygląda na zminifikowany": w plikach ≥ 16 KB liczymy
+ * średnią długość linii pierwszych 64 KB. Kod niezminifikowany z Bun to
+ * ~35-45 B/linię; zminifikowany to pojedyncze, bardzo długie linie (tysiące
+ * bajtów). Próg 200 B/linię zostawia szeroki margines po obu stronach.
+ * Małe pliki pomijamy — trywialny entry (np. federowany initial, ~150 B)
+ * ma za mało treści, żeby heurystyka miała sens.
+ */
+function looksMinified(files: readonly BrowserOutFile[]): boolean {
+  for (const f of files) {
+    if (!f.name.endsWith(".js") || f.bytes.length < 16 * 1024) continue;
+    const sample = f.bytes.subarray(0, 64 * 1024);
+    let newlines = 0;
+    for (const b of sample) if (b === 10) newlines++;
+    const avgLineLen = sample.length / Math.max(1, newlines);
+    if (avgLineLen < 200) return false;
+  }
+  return true;
+}
+
 export async function buildBrowserApp(
   rootDir: string,
   outDir: string,
@@ -810,10 +1062,19 @@ export async function buildBrowserApp(
      * — React inline, bez lazy-race. Patrz peer-shell.ts.
      */
     exposeRuntime?: boolean;
+    /**
+     * Minifikacja bundli przeglądarki (domyślnie true). Poza rozmiarem
+     * kluczowy jest jej `syntax`-pass: składa `ONLY_SERVER && (...)` do
+     * martwego kodu i usuwa go, dzięki czemu tree-shaking wycina serwerowe
+     * zależności (np. szablony maili, klientów płatności) z bundla klienta.
+     * Dev wyłącza (czytelny kod, szybszy rebuild watchera).
+     */
+    minify?: boolean;
   },
 ): Promise<BrowserAppResult> {
   const federated = opts?.federated ?? false;
   const exposeRuntime = opts?.exposeRuntime ?? false;
+  const minify = opts?.minify ?? true;
   mkdirSync(outDir, { recursive: true });
 
   const publicMembers = plan.groups.get("public") ?? [];
@@ -844,6 +1105,7 @@ export async function buildBrowserApp(
     define: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" },
     federated,
     exposeRuntime,
+    minify,
     // Zmiana listy peers (SHELL_EXTERNALS) musi unieważnić build federowany —
     // stary bundle miałby zbundlowany peer, który teraz jest external.
     externals: federated ? [...SHELL_EXTERNALS] : [],
@@ -852,7 +1114,9 @@ export async function buildBrowserApp(
     builderRev: 3,
   });
 
-  if (!noCache && isCacheHit(cache, unitId, inputHash)) {
+  // Tryb stats zawsze buduje od nowa — cache-hit pominąłby analizę i nie
+  // byłoby czego wypisać.
+  if (!noCache && !buildStatsEnabled() && isCacheHit(cache, unitId, inputHash)) {
     const cached = cache.units[unitId]?.outputHashes;
     if (cached?._manifest) {
       try {
@@ -885,30 +1149,41 @@ export async function buildBrowserApp(
     }
   }
 
-  const tmpDir = join(outDir, "_entries");
-  mkdirSync(tmpDir, { recursive: true });
+  // Entries POZA outDir (osobny katalog per unitId): równoległy builder tego
+  // samego workspace'u (dev watcher) wipe'uje i sprząta browser/_entries,
+  // wycinając nam pliki wejściowe spod Bun.build (ENOENT na wszystkich
+  // entry). Dedykowana ścieżka zawęża pole rażenia; resztę domyka retry
+  // (writeEntryFiles przed każdą próbą).
+  const tmpDir = join(rootDir, ".arc", "tmp", `entries-${unitId}`);
 
   const importLines = (pkgs: { pkg: { name: string } }[]): string =>
     pkgs.map((m) => `import "${m.pkg.name}";`).join("\n");
 
   const initialEntry = join(tmpDir, "initial.ts");
-  writeFileSync(
-    initialEntry,
-    // Prelude ekspozycji runtime MUSI być PIERWSZY (przed importami modułów) —
-    // globalThis.__ARC_RT gotowe zanim cokolwiek innego się załaduje.
-    (exposeRuntime ? runtimeExposePrelude() + "\n" : "") +
-      `${importLines(publicMembers)}\nexport { startApp } from "@arcote.tech/platform";\n`,
-  );
-
   const entryPaths: string[] = [initialEntry];
   const groupModuleMap = new Map<string, string[]>();
   for (const g of protectedGroups) {
-    const entry = join(tmpDir, `${g.name}.ts`);
-    writeFileSync(entry, `${importLines(g.members)}\n`);
-    entryPaths.push(entry);
+    entryPaths.push(join(tmpDir, `${g.name}.ts`));
     groupModuleMap.set(g.name, g.members.map((m) => m.moduleName));
   }
 
+  // Idempotentny zapis WSZYSTKICH plików entry. Wołany przed każdą próbą
+  // Bun.build (nie raz) — retry po wyścigu minify musi odtworzyć entries,
+  // gdyby cokolwiek zdążyło je sprzątnąć między próbami.
+  const writeEntryFiles = () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(
+      initialEntry,
+      // Prelude ekspozycji runtime MUSI być PIERWSZY (przed importami modułów) —
+      // globalThis.__ARC_RT gotowe zanim cokolwiek innego się załaduje.
+      (exposeRuntime ? runtimeExposePrelude() + "\n" : "") +
+        `${importLines(publicMembers)}\nexport { startApp } from "@arcote.tech/platform";\n`,
+    );
+    for (const g of protectedGroups) {
+      writeFileSync(join(tmpDir, `${g.name}.ts`), `${importLines(g.members)}\n`);
+    }
+  };
+
   // ---------------------------------------------------------------------
   // Temporarily flip `"sideEffects"` on every workspace package's
   // package.json from `false` to `true` for the duration of the build.
@@ -941,11 +1216,22 @@ export async function buildBrowserApp(
     patchedPkgJsons.push({ path: pkgJsonPath, original });
   }
 
+  const statsMode = buildStatsEnabled();
+  // JS-name → sparsowana sourcemapa (tylko w trybie stats).
+  const mapsByJs = new Map<string, { sources?: string[]; sourcesContent?: (string | null)[] }>();
+
   let result;
-  try {
-    result = await Bun.build({
+  const runBuild = () => {
+    writeEntryFiles();
+    // CELOWO bez `outdir` — artefakty zostają w pamięci i to MY piszemy pliki
+    // (niżej). Chroni build przed RÓWNOLEGŁYM procesem piszącym do tego samego
+    // workspace'u (klasyk: `arc platform dev` w drugim terminalu — patch
+    // sideEffects w package.json triggeruje jego watcher, a jego rebuild
+    // wypluwa NIEZMINIFIKOWANE bundle i wipe'uje outDir w trakcie naszego
+    // builda). Bajty z artefaktów + własny zapis + weryfikacja po zapisie
+    // (niżej) gwarantują, że wynik pochodzi z jednego spójnego passu.
+    return Bun.build({
       entrypoints: entryPaths,
-      outdir: outDir,
       // splitting:true is the whole point: shared deps (workspace context,
       // framework, lucide, etc.) land in chunk-<hash>.js, referenced by both
       // initial and token-group entries. One instance, no provider duplication.
@@ -964,9 +1250,19 @@ export async function buildBrowserApp(
         // teraz eager re-exportem, więc działa też przy external jsx-runtime.
         ...(federated ? [] : [singleReactPlugin(rootDir)]),
         jsxDevShimPlugin(),
+        // Serwerowe builtiny node → rzucający stub zamiast ciężkiego polyfilla
+        // (patrz plugin). Musi być PRZED i18nExtractPlugin (onResolve pierwszy
+        // wygrywa nie dotyczy onLoad, ale kolejność trzymamy spójnie).
+        nodeServerBuiltinStubPlugin(),
         i18nExtractPlugin(i18nCollector, rootDir),
       ],
       naming: "[name].[ext]",
+      minify,
+      // Tryb stats: sourcemapy niosą `sources[]`/`sourcesContent[]` do rozbicia
+      // chunków na biblioteki. NIE zapisujemy .map na dysk (analiza w pamięci),
+      // a komentarz `//# debugId=` zdejmujemy z JS niżej — bajty i hashe zostają
+      // identyczne jak w zwykłym buildzie.
+      sourcemap: statsMode ? "external" : "none",
       define: {
         ONLY_SERVER: "false",
         ONLY_BROWSER: "true",
@@ -976,6 +1272,58 @@ export async function buildBrowserApp(
         "process.env.NODE_ENV": '"production"',
       },
     });
+  };
+
+  let outFiles: BrowserOutFile[] | null = null;
+  try {
+    // Retry: równoległy proces budujący ten sam workspace (dev watcher)
+    // potrafi w trakcie naszego passu podmienić wejścia/wyjścia — objawy to
+    // niezminifikowany output mimo minify:true albo ENOENT na plikach entry.
+    // Ponawiamy do 3 prób; ostatnia porażka = twardy fail (lepszy głośny
+    // build-error niż niezauważony, ~4-5× cięższy deploy).
+    for (let attempt = 1; ; attempt++) {
+      result = await runBuild();
+      if (result.success) {
+        const files: BrowserOutFile[] = [];
+        mapsByJs.clear();
+        for (const out of result.outputs) {
+          const name = basename(out.path);
+          // Sourcemapy (tylko stats): sparsuj do pamięci, nie zapisuj na dysk.
+          if (name.endsWith(".map")) {
+            try {
+              mapsByJs.set(name.replace(/\.map$/, ""), JSON.parse(await out.text()));
+            } catch {
+              // uszkodzona mapa — pomiń, stats po prostu ją opuści
+            }
+            continue;
+          }
+          let bytes: Uint8Array = new Uint8Array(await out.arrayBuffer());
+          // Zdejmij dopięty przez `sourcemap:"external"` komentarz `//# debugId=`
+          // — inaczej tryb stats zmieniałby bajty (a więc i content-hash) JS.
+          if (statsMode && name.endsWith(".js")) {
+            bytes = stripTrailingSourcemapComment(bytes);
+          }
+          files.push({ kind: out.kind, name, bytes });
+        }
+        if (!minify || looksMinified(files)) {
+          outFiles = files;
+          break;
+        }
+      }
+      if (attempt >= 3) {
+        if (!result.success) break; // standardowa ścieżka błędu niżej wypisze logi
+        throw new Error(
+          "Browser app build: output NIEZMINIFIKOWANY mimo minify:true (3 próby). Przerwane, żeby nie wypuścić ciężkich bundli.",
+        );
+      }
+      console.warn(
+        `  ! browser build pass ${attempt} ${
+          result.success
+            ? "niezminifikowany mimo minify:true (wyścig minify Bun.build)"
+            : "nieudany (wyścig Bun.build — np. zniknięte pliki entry)"
+        } — powtarzam`,
+      );
+    }
   } finally {
     // Always restore — a crash here MUST NOT leave the user with mutated
     // workspace package.json files.
@@ -984,7 +1332,7 @@ export async function buildBrowserApp(
 
   rmSync(tmpDir, { recursive: true, force: true });
 
-  if (!result.success) {
+  if (!result.success || !outFiles) {
     for (const log of result.logs) console.error(log);
     throw new Error("Browser app build failed");
   }
@@ -998,17 +1346,12 @@ export async function buildBrowserApp(
   const groups: Record<string, BrowserGroupEntry> = {};
   const sharedChunks: string[] = [];
 
-  for (const out of result.outputs) {
-    const name = basename(out.path);
+  for (const out of outFiles) {
     if (out.kind === "entry-point") {
-      const bytes = readFileSync(out.path);
-      const hash = sha256Hex(bytes).slice(0, 16);
-      const stem = name.replace(/\.js$/, "");
+      const hash = sha256Hex(out.bytes).slice(0, 16);
+      const stem = out.name.replace(/\.js$/, "");
       const finalName = `${stem}.${hash}.js`;
-      const finalPath = join(outDir, finalName);
-      rmSync(finalPath, { force: true });
-      writeFileSync(finalPath, bytes);
-      rmSync(out.path, { force: true });
+      writeFileSync(join(outDir, finalName), out.bytes);
 
       if (stem === "initial") {
         initialFile = finalName;
@@ -1021,7 +1364,8 @@ export async function buildBrowserApp(
         };
       }
     } else if (out.kind === "chunk") {
-      sharedChunks.push(name);
+      writeFileSync(join(outDir, out.name), out.bytes);
+      sharedChunks.push(out.name);
     }
   }
 
@@ -1029,6 +1373,34 @@ export async function buildBrowserApp(
     throw new Error("Browser app build: initial entry not found in outputs");
   }
 
+  // Weryfikacja po zapisie: katalog ma zawierać DOKŁADNIE nasze pliki z
+  // DOKŁADNIE naszymi bajtami. Równoległy builder tego samego workspace'u
+  // (dev watcher) dorzucał do outDir własny, niezminifikowany zestaw plików
+  // (patrz komentarz przy runBuild) — jakikolwiek obcy plik/rozjazd treści
+  // = głośny fail zamiast cichego wypuszczenia niespójnego builda.
+  const written = new Map<string, string>();
+  for (const out of outFiles) {
+    const name =
+      out.kind === "entry-point"
+        ? `${out.name.replace(/\.js$/, "")}.${sha256Hex(out.bytes).slice(0, 16)}.js`
+        : out.name;
+    if (out.kind === "entry-point" || out.kind === "chunk") {
+      written.set(name, sha256Hex(out.bytes));
+    }
+  }
+  for (const f of readdirSync(outDir)) {
+    if (!f.endsWith(".js")) continue;
+    const expected = written.get(f);
+    const actual = sha256Hex(readFileSync(join(outDir, f)));
+    if (!expected || expected !== actual) {
+      throw new Error(
+        `Browser app build: plik "${f}" w ${outDir} nie zgadza się z artefaktami builda ` +
+          `(${expected ? "treść rozjechana z zapisem" : "obcy plik — coś innego pisze do outDir"}). ` +
+          `Przerwane, żeby nie wypuścić niespójnego builda.`,
+      );
+    }
+  }
+
   const manifest: BrowserAppResult = {
     initial: { file: initialFile, hash: initialHash },
     groups,
@@ -1036,6 +1408,36 @@ export async function buildBrowserApp(
     cached: false,
   };
 
+  if (statsMode) {
+    // Zmapuj bajty i sourcemapy na FINALNE nazwy plików (entry z hashem),
+    // żeby graf importów raportu (chunki referują `chunk-<hash>.js`) spinał się
+    // z tym, co realnie leży na dysku.
+    const jsByName = new Map<string, Uint8Array>();
+    const mapsByFinal = new Map<
+      string,
+      { sources?: string[]; sourcesContent?: (string | null)[] }
+    >();
+    const finalNameOf = (out: BrowserOutFile) =>
+      out.kind === "entry-point"
+        ? `${out.name.replace(/\.js$/, "")}.${sha256Hex(out.bytes).slice(0, 16)}.js`
+        : out.name;
+    for (const out of outFiles) {
+      const fn = finalNameOf(out);
+      jsByName.set(fn, out.bytes);
+      const map = mapsByJs.get(out.name);
+      if (map) mapsByFinal.set(fn, map);
+    }
+    reportBrowserBuildStats({
+      label: federated ? "browser-fed" : "browser",
+      entries: [
+        { name: "initial", file: initialFile },
+        ...Object.entries(groups).map(([stem, g]) => ({ name: stem, file: g.file })),
+      ],
+      jsByName,
+      mapsByJs: mapsByFinal,
+    });
+  }
+
   updateCache(cache, unitId, inputHash, {
     outputHashes: { _manifest: JSON.stringify(manifest) },
   });

package/src/commands/platform-build.ts

@@ -1,6 +1,11 @@
 import { buildAll, ok, resolveWorkspace } from "../platform/shared";
 
-export async function platformBuild(opts: { noCache?: boolean } = {}): Promise<void> {
+export async function platformBuild(
+  opts: { noCache?: boolean; stats?: boolean } = {},
+): Promise<void> {
+  // `--stats` = alias na ARC_BUILD_STATS=1 (env zostaje jako escape hatch, np.
+  // dla buildu w `dev`). Tryb stats wymusza pełny build (patrz buildBrowserApp).
+  if (opts.stats) process.env.ARC_BUILD_STATS = "1";
   const ws = resolveWorkspace();
   const manifest = await buildAll(ws, { noCache: opts.noCache });
   const groupCount = Object.keys(manifest.groups).length;