@arcote.tech/arc-cli 0.7.19 → 0.7.21

package/src/platform/server.ts

@@ -524,6 +524,9 @@ export async function startPlatformServer(
         mode: devMode ? "development" : "production",
         sampleRate: devMode ? 1.0 : 1.0, // head-based 100%, collector tail-samples
         debug: process.env.ARC_OTEL_DEBUG === "true",
+        // Production kill-switch for the console→OTLP bridge. Container
+        // stdout still reaches Loki via Alloy regardless.
+        patchConsole: process.env.ARC_OTEL_PATCH_CONSOLE !== "false",
       });
       telemetry = init.telemetry;
       telemetryShutdown = init.shutdown;

package/src/platform/shared.ts

@@ -4,10 +4,12 @@ import { dirname, join } from "path";
 import {
   buildBrowserApp,
   buildContextPackages,
+  buildServerApp,
   buildStyles,
   buildTranslations,
   discoverPackages,
   isContextPackage,
+  SERVER_ENTRY_FILE,
   type BrowserAppResult,
   type BuildManifest,
   type ModuleDescriptor,
@@ -161,20 +163,30 @@ export async function buildAll(
   // else chunk grouping (per-package) silently mis-assigns the extra module.
   assertOneModulePerPackage(ws.packages);
 
-  // Phase 1 — context packages must finish FIRST. The access-extractor
-  // subprocess imports workspace packages by name, which resolve through
-  // node_modules to packages' `main` field (typically `dist/server/main/`).
+  // Phase 1 — per-package BROWSER context bundles + type declarations.
   await buildContextPackages(ws.rootDir, ws.packages, cache, noCache);
 
-  // Phase 1b — relocate per-package server bundles into `.arc/platform/server/`
-  // so the deploy image can be self-contained (image COPY needs everything
-  // server-side under one root). loadServerContext reads from here in prod.
-  copyContextServerBundles(ws);
+  // Phase 1b — combined server bundle at `.arc/platform/server/_server.js`.
+  // ONE Bun.build for all context modules (deduped from source, cycle-safe)
+  // replaces the old per-package server bundles that nested each other's dist
+  // into multi-hundred-MB files. The deploy image COPYs this dir wholesale;
+  // loadServerContext + the access extractor import the entry, chunks ride along.
+  const serverDir = join(ws.arcDir, "server");
+  const { entryFile: serverEntry } = await buildServerApp(
+    ws.rootDir,
+    serverDir,
+    ws.packages,
+    cache,
+    noCache,
+  );
 
   // Phase 2 — extract access metadata (token name + hasCheck per module) in
-  // an isolated subprocess. This MUST run before chunk planning so we know
-  // which token group each module belongs to.
-  const accessMap = await extractAccessMap(ws.rootDir, ws.packages);
+  // an isolated subprocess that imports the combined server bundle. MUST run
+  // before chunk planning so we know which token group each module belongs to.
+  const accessMap = await extractAccessMap(
+    ws.rootDir,
+    join(serverDir, serverEntry),
+  );
 
   // Persist access map for the runtime host (server.ts reads at startup to
   // wire up moduleAccessMap for filterManifestForTokens / signed URLs).
@@ -242,34 +254,6 @@ function assembleManifest(
   };
 }
 
-// ---------------------------------------------------------------------------
-// Context server bundles — flatten to `<arcDir>/server/<safeName>.js`
-// ---------------------------------------------------------------------------
-
-/**
- * Copy each context package's compiled server bundle from
- * `packages/<pkg>/dist/server/main/index.js` to a flat location at
- * `<arcDir>/server/<safeName>.js`. The flat layout makes the deploy image
- * self-contained — `COPY .arc/platform/` pulls everything server-side, no
- * need to drag the entire `packages/` tree into the image.
- */
-function copyContextServerBundles(ws: WorkspaceInfo): void {
-  const outDir = join(ws.arcDir, "server");
-  mkdirSync(outDir, { recursive: true });
-
-  for (const pkg of ws.packages) {
-    if (!isContextPackage(pkg.packageJson)) continue;
-    const src = join(pkg.path, "dist", "server", "main", "index.js");
-    if (!existsSync(src)) {
-      err(`Server bundle missing for ${pkg.name}: ${src}`);
-      continue;
-    }
-    const safeName = pkg.path.split("/").pop()!;
-    const dst = join(outDir, `${safeName}.js`);
-    copyFileSync(src, dst);
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Browser assets — @arcote.tech/* deps deklarują w `arc.browserAssets` jakie
 // pliki muszą być dostępne w przeglądarce (np. SQLite WASM worker + .wasm).
@@ -419,44 +403,21 @@ export async function loadServerContext(
 
   await import(platformEntry);
 
-  // Primary source: flattened server bundles at `<arcDir>/server/<safeName>.js`.
+  // The combined server bundle lives at `<arcDir>/server/_server.js` (entry)
+  // next to its `chunk-<hash>.js` siblings. Importing the entry pulls the
+  // chunks transitively and registers every module via the platform singleton.
   // The deploy image only has this directory — there's no workspace `packages/`
-  // tree. In dev, `copyContextServerBundles` populates this same location, so
-  // both modes go through the same code path.
-  const serverDir = join(ws.arcDir, "server");
-  const bundles = existsSync(serverDir)
-    ? readdirSync(serverDir).filter((f) => f.endsWith(".js"))
-    : [];
-
-  if (bundles.length > 0) {
-    for (const file of bundles) {
-      const bundlePath = join(serverDir, file);
-      try {
-        await import(bundlePath);
-      } catch (e) {
-        err(`Failed to load server bundle ${file}: ${e}`);
-      }
-    }
-  } else if (ws.packages.length > 0) {
-    // Fallback for the "no .arc/platform/server/ yet" case (e.g. somebody
-    // wired up loadServerContext before running the build). This path goes
-    // through workspace packages directly — only meaningful in dev.
-    const ctxPackages = ws.packages.filter((p) => isContextPackage(p.packageJson));
-    for (const ctx of ctxPackages) {
-      const serverDist = join(ctx.path, "dist", "server", "main", "index.js");
-      if (!existsSync(serverDist)) {
-        err(`Context server dist not found: ${serverDist}`);
-        continue;
-      }
-      try {
-        await import(serverDist);
-      } catch (e) {
-        err(`Failed to load server context from ${ctx.name}: ${e}`);
-      }
-    }
-  } else {
+  // tree; dev and prod go through the exact same path.
+  const serverEntry = join(ws.arcDir, "server", SERVER_ENTRY_FILE);
+  if (!existsSync(serverEntry)) {
+    // No build yet (or a static-only workspace) — nothing to register.
     return { context: null, moduleAccess: new Map() };
   }
+  try {
+    await import(serverEntry);
+  } catch (e) {
+    err(`Failed to load server bundle ${SERVER_ENTRY_FILE}: ${e}`);
+  }
 
   const { getContext, getAllModuleAccess } = await import(platformEntry);
   return {

package/src/platform/startup.ts

@@ -62,8 +62,8 @@ export async function startPlatform(
   }
 
   // 2. Server context — same code path in both modes; loadServerContext
-  // prefers .arc/platform/server/*.js (the canonical location after the
-  // copyContextServerBundles step in buildAll).
+  // imports the combined server bundle at .arc/platform/server/_server.js
+  // (produced by the buildServerApp step in buildAll).
   log("Loading server context...");
   const { context, moduleAccess } = await loadServerContext(ws);
   if (context) {