@arcote.tech/arc-cli 0.6.2 → 0.7.1

package/src/platform/shared.ts

@@ -1,13 +1,14 @@
 import { findUpSync } from "find-up";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import {
+  buildBrowserApp,
   buildContextPackages,
-  buildModulesBundle,
   buildStyles,
   buildTranslations,
   discoverPackages,
   isContextPackage,
+  type BrowserAppResult,
   type BuildManifest,
   type ModuleDescriptor,
   type WorkspacePackage,
@@ -19,23 +20,18 @@ import {
   updateCache,
   type BuildCache,
 } from "../builder/build-cache";
+import { extractAccessMap } from "../builder/access-extractor";
+import { planChunks } from "../builder/chunk-planner";
+import { collectFrameworkDeps } from "../builder/dependency-collector";
 import {
   mtimeOf,
-  readInstalledVersion,
   sha256Hex,
-  sha256OfDir,
   sha256OfFiles,
   sha256OfJson,
 } from "../builder/hash";
-import { pAll } from "../builder/parallel";
-import {
-  collectFrameworkDeps,
-  collectModuleDeps,
-} from "../builder/dependency-collector";
-import { extractAccessMap } from "../builder/access-extractor";
 
 // Re-export for convenience
-export { buildContextPackages, buildModulesBundle, buildStyles, isContextPackage };
+export { buildContextPackages, buildStyles, isContextPackage };
 export type { BuildManifest, ModuleDescriptor, WorkspacePackage };
 
 // ---------------------------------------------------------------------------
@@ -70,8 +66,8 @@ export interface WorkspaceInfo {
   rootPkg: Record<string, any>;
   appName: string;
   arcDir: string;
-  modulesDir: string;
-  shellDir: string;
+  /** Single Bun.build output dir for browser app: `<arcDir>/browser/`. */
+  browserDir: string;
   /** Static assets generated z arc.browserAssets workspace deps. Serwowane pod /assets/*. */
   assetsDir: string;
   publicDir: string;
@@ -93,16 +89,15 @@ export function resolveWorkspace(): WorkspaceInfo {
 
   log("Scanning workspaces...");
   const packages = discoverPackages(rootDir);
-  ok(
-    `Found ${packages.length} package(s): ${packages.map((p) => p.name).join(", ")}`,
-  );
-
-  // Empty package list is allowed in pre-deploy runtime mode (container with
-  // freshly-mounted volume, no user code pushed yet). The CLI entry that
-  // forbids this (arc platform build/dev) checks explicitly.
-  if (packages.length === 0 && process.env.ARC_DEPLOY_API !== "1") {
-    err("No workspace packages found.");
-    process.exit(1);
+  if (packages.length > 0) {
+    ok(
+      `Found ${packages.length} package(s): ${packages.map((p) => p.name).join(", ")}`,
+    );
+  } else {
+    // Zero packages is valid for `platform start` in image runtime mode —
+    // the workspace tree isn't shipped, only `.arc/platform/` is. Build
+    // commands enforce non-empty packages where they need them.
+    log("No workspace packages found — assuming image runtime mode.");
   }
 
   // Detect manifest.json or manifest.webmanifest in root dir
@@ -131,8 +126,7 @@ export function resolveWorkspace(): WorkspaceInfo {
     rootPkg,
     appName,
     arcDir,
-    modulesDir: join(arcDir, "modules"),
-    shellDir: join(arcDir, "shell"),
+    browserDir: join(arcDir, "browser"),
     assetsDir: join(arcDir, "assets"),
     publicDir: join(rootDir, "public"),
     packages,
@@ -163,69 +157,115 @@ export async function buildAll(
 
   log(`Building (concurrency parallel${noCache ? ", no-cache" : ""})...`);
 
-  // Promise.all over independent units. buildModulesBundle is the only one
-  // that returns data we need (the manifest). The rest update the cache.
-  const [, modulesResult] = await Promise.all([
-    buildContextPackages(ws.rootDir, ws.packages, cache, noCache),
-    buildModulesBundle(ws.rootDir, ws.modulesDir, ws.packages, cache, noCache),
-    buildShell(ws, cache, noCache),
+  // 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/`).
+  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 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);
+
+  // Persist access map for the runtime host (server.ts reads at startup to
+  // wire up moduleAccessMap for filterManifestForTokens / signed URLs).
+  mkdirSync(ws.arcDir, { recursive: true });
+  writeFileSync(
+    join(ws.arcDir, "access.json"),
+    JSON.stringify(accessMap, null, 2) + "\n",
+  );
+
+  // Phase 3 — group modules into chunks (one Bun.build per group).
+  const plan = planChunks(ws.packages, accessMap);
+  ok(
+    `Chunks: ${plan.chunks
+      .map((c) => `${c}(${plan.groups.get(c)?.length ?? 0})`)
+      .join(", ")}`,
+  );
+
+  // Phase 4 — independent parallel build units. The browser app is a single
+  // Bun.build call covering initial + all token groups (replaces ~25 separate
+  // Bun.builds for shell + per-chunk + per-package).
+  const i18nCollector = new Map<string, Set<string>>();
+
+  const [browserResult] = await Promise.all([
+    buildBrowserApp(ws.rootDir, ws.browserDir, plan, cache, noCache, i18nCollector),
     buildStyles(ws.rootDir, ws.arcDir, ws.packages, themePath, cache, noCache),
     copyBrowserAssets(ws, cache, noCache),
     buildTranslations(ws.rootDir, ws.arcDir, cache, noCache),
   ]);
 
-  saveBuildCache(ws.arcDir, cache);
+  // Finalize i18n catalogs once after all chunks + initial bundle collected.
+  const { finalizeTranslations } = await import("../i18n");
+  await finalizeTranslations(ws.rootDir, ws.arcDir, i18nCollector);
 
-  // v0.6 deploy artifacts: framework + per-module dependency manifests + access
-  // map. Generated unconditionally — runtime container needs them to bun-install
-  // and to enforce protectBy rules. Order matters: deps before access (access
-  // extraction subprocess imports server bundles whose own deps may matter).
+  // Phase 5 — framework peer manifest at `<arcDir>/package.json`. Used by
+  // the deploy image build (single `bun install` for all peers, one copy
+  // shared across module bundles).
   collectFrameworkDeps(ws.arcDir, ws.rootDir, ws.packages);
-  for (const pkg of ws.packages) {
-    collectModuleDeps(ws.arcDir, pkg);
-  }
-  try {
-    await extractAccessMap(ws.arcDir, ws.packages);
-  } catch (e) {
-    err(`access-extractor failed: ${(e as Error).message}`);
-    // Don't fail the build — protection rules will be empty server-side but
-    // the rest of the deploy can still proceed.
-  }
 
-  const finalManifest = assembleManifest(ws, modulesResult.modules, cache);
+  saveBuildCache(ws.arcDir, cache);
+
+  const finalManifest = assembleManifest(ws, browserResult, cache);
   writeFileSync(
-    join(ws.modulesDir, "manifest.json"),
+    join(ws.arcDir, "manifest.json"),
     JSON.stringify(finalManifest, null, 2),
   );
   return finalManifest;
 }
 
 /**
- * Assemble the platform manifest from cached output hashes — no disk reads.
+ * Assemble the platform manifest from the browser app result + style hash.
  */
 function assembleManifest(
   ws: WorkspaceInfo,
-  modules: ModuleDescriptor[],
+  browser: BrowserAppResult,
   cache: BuildCache,
 ): BuildManifest {
-  // Aggregate shellHash from all shell:* unit output hashes.
-  const shellEntries: Record<string, string> = {};
-  for (const [unitId, entry] of Object.entries(cache.units)) {
-    if (unitId.startsWith("shell:") && entry.outputHash) {
-      shellEntries[unitId] = entry.outputHash;
-    }
-  }
-  const shellHash = sha256OfJson(shellEntries);
   const stylesHash = cache.units["styles"]?.outputHash ?? "";
 
   return {
-    modules,
-    shellHash,
+    initial: browser.initial,
+    groups: browser.groups,
+    sharedChunks: browser.sharedChunks,
     stylesHash,
     buildTime: new Date().toISOString(),
   };
 }
 
+// ---------------------------------------------------------------------------
+// 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).
@@ -353,258 +393,65 @@ async function copyBrowserAssets(
   updateCache(cache, unitId, inputHash, { outputHashes });
 }
 
-// ---------------------------------------------------------------------------
-// Shell builder — framework packages for import map
-// ---------------------------------------------------------------------------
-
-/** Collect all @arcote.tech/* peerDependencies from workspace packages. */
-export function collectArcPeerDeps(packages: WorkspacePackage[]): [string, string][] {
-  const seen = new Set<string>();
-  for (const pkg of ["@arcote.tech/arc", "@arcote.tech/arc-ds", "@arcote.tech/arc-react", "@arcote.tech/platform"]) {
-    seen.add(pkg);
-  }
-  for (const wp of packages) {
-    const peerDeps = wp.packageJson.peerDependencies ?? {};
-    for (const dep of Object.keys(peerDeps)) {
-      if (dep.startsWith("@arcote.tech/")) seen.add(dep);
-    }
-  }
-  return [...seen].map((pkg) => {
-    const short = pkg === "@arcote.tech/platform"
-      ? "platform"
-      : pkg.replace("@arcote.tech/", "");
-    return [short, pkg];
-  });
-}
-
-const REACT_ENTRIES: [string, string][] = [
-  [
-    "react",
-    `import React from "react";
-export default React;
-export const {
-  Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense,
-  cloneElement, createContext, createElement, createRef, forwardRef, isValidElement,
-  lazy, memo, startTransition, use, useCallback, useContext, useDebugValue,
-  useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect,
-  useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore,
-  useTransition, version, useActionState, useOptimistic,
-} = React;`,
-  ],
-  ["jsx-runtime", `export { jsx, jsxs, Fragment } from "react/jsx-runtime";`],
-  [
-    "jsx-dev-runtime",
-    `export { jsxDEV, Fragment } from "react/jsx-dev-runtime";`,
-  ],
-  [
-    "react-dom",
-    `import ReactDOM from "react-dom";
-export default ReactDOM;
-export const { createPortal, flushSync } = ReactDOM;`,
-  ],
-  [
-    "react-dom-client",
-    `export { createRoot, hydrateRoot } from "react-dom/client";`,
-  ],
-];
-
-const REACT_OUTPUT_FILES = REACT_ENTRIES.map(([n]) => `${n}.js`);
-
-const SHELL_BASE_EXTERNAL = [
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-dom/client",
-];
-
-const sourceFilter = (rel: string): boolean => {
-  if (rel.startsWith("dist/") || rel.startsWith("dist")) return false;
-  if (rel.includes("/node_modules/") || rel.startsWith("node_modules")) return false;
-  if (rel.startsWith(".arc/") || rel.startsWith(".arc")) return false;
-  return true;
-};
-
-function arcPkgSrcHash(rootDir: string, pkg: string): string {
-  // Prefer src/ tree (workspace links), fallback to whole package dir.
-  const srcDir = join(rootDir, "node_modules", pkg, "src");
-  if (existsSync(srcDir)) return sha256OfDir(srcDir, sourceFilter);
-  return sha256OfDir(join(rootDir, "node_modules", pkg), sourceFilter);
-}
-
-async function buildShellReact(
-  shellDir: string,
-  tmpDir: string,
-  rootDir: string,
-  cache: BuildCache,
-  noCache: boolean,
-): Promise<void> {
-  const unitId = "shell:react";
-  const inputHash = sha256OfJson({
-    react: readInstalledVersion(rootDir, "react"),
-    "react-dom": readInstalledVersion(rootDir, "react-dom"),
-    entries: REACT_ENTRIES.map(([k, v]) => [k, v]),
-  });
-
-  const requiredOutputs = REACT_OUTPUT_FILES.map((f) => join(shellDir, f));
-  if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
-    console.log(`  ✓ cached: shell:react`);
-    return;
-  }
-
-  console.log(`  building: shell:react`);
-
-  const reactEps: string[] = [];
-  for (const [name, code] of REACT_ENTRIES) {
-    const f = join(tmpDir, `${name}.ts`);
-    await Bun.write(f, code);
-    reactEps.push(f);
-  }
-
-  const r = await Bun.build({
-    entrypoints: reactEps,
-    outdir: shellDir,
-    splitting: true,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error("Shell React build failed");
-  }
-
-  const outputHash = sha256OfFiles(requiredOutputs);
-  updateCache(cache, unitId, inputHash, { outputHash });
-}
-
-async function buildShellArcEntry(
-  shortName: string,
-  pkg: string,
-  allArcPkgs: string[],
-  shellDir: string,
-  tmpDir: string,
-  rootDir: string,
-  cache: BuildCache,
-  noCache: boolean,
-): Promise<void> {
-  const unitId = `shell:arc:${shortName}`;
-  const otherExternals = allArcPkgs.filter((p) => p !== pkg);
-  const inputHash = sha256OfJson({
-    pkg,
-    version: readInstalledVersion(rootDir, pkg),
-    src: arcPkgSrcHash(rootDir, pkg),
-    base: SHELL_BASE_EXTERNAL,
-    others: [...otherExternals].sort(),
-  });
-
-  const outputFile = join(shellDir, `${shortName}.js`);
-  if (!noCache && isCacheHit(cache, unitId, inputHash, [outputFile])) {
-    console.log(`  ✓ cached: ${unitId}`);
-    return;
-  }
-
-  console.log(`  building: ${unitId}`);
-
-  const f = join(tmpDir, `${shortName}.ts`);
-  await Bun.write(f, `export * from "${pkg}";\n`);
-
-  const r = await Bun.build({
-    entrypoints: [f],
-    outdir: shellDir,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    external: [...SHELL_BASE_EXTERNAL, ...otherExternals],
-    define: {
-      ONLY_SERVER: "false",
-      ONLY_BROWSER: "true",
-      ONLY_CLIENT: "true",
-    },
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error(`Shell build failed for ${pkg}`);
-  }
-
-  const outputHash = sha256OfFiles([outputFile]);
-  updateCache(cache, unitId, inputHash, { outputHash });
-}
-
-/**
- * Build the framework shell — react layer + each @arcote.tech/* package as a
- * separate cacheable unit. Tasks run in parallel via pAll.
- */
-export async function buildShell(
-  ws: WorkspaceInfo,
-  cache: BuildCache,
-  noCache: boolean,
-): Promise<void> {
-  mkdirSync(ws.shellDir, { recursive: true });
-  const tmpDir = join(ws.shellDir, "_tmp");
-  mkdirSync(tmpDir, { recursive: true });
-
-  const arcEntries = collectArcPeerDeps(ws.packages);
-  const allArcPkgs = arcEntries.map(([, pkg]) => pkg);
-
-  const tasks: Array<() => Promise<void>> = [
-    () => buildShellReact(ws.shellDir, tmpDir, ws.rootDir, cache, noCache),
-    ...arcEntries.map(([short, pkg]) => () =>
-      buildShellArcEntry(short, pkg, allArcPkgs, ws.shellDir, tmpDir, ws.rootDir, cache, noCache),
-    ),
-  ];
-
-  await pAll(tasks);
-
-  rmSync(tmpDir, { recursive: true, force: true });
-}
-
 // ---------------------------------------------------------------------------
 // Server context loading
 // ---------------------------------------------------------------------------
 
 export async function loadServerContext(
-  packages: WorkspacePackage[],
+  ws: WorkspaceInfo,
 ): Promise<{ context: any | null; moduleAccess: Map<string, any> }> {
-  const ctxPackages = packages.filter((p) => isContextPackage(p.packageJson));
-  if (ctxPackages.length === 0) return { context: null, moduleAccess: new Map() };
-
   // Set globals for server context — framework packages (arc-auth etc.)
   // use these at runtime to tree-shake browser/server code paths.
   (globalThis as any).ONLY_SERVER = true;
   (globalThis as any).ONLY_BROWSER = false;
   (globalThis as any).ONLY_CLIENT = false;
 
-  // Resolve platform from the project's node_modules using an absolute path
-  // (see comment in original implementation for why).
+  // Resolve platform from the project's node_modules. Platform exports a
+  // single entry (./src/index.ts) — React imports at top level are benign
+  // in a non-render context (createContext, function defs only).
   const platformDir = join(process.cwd(), "node_modules", "@arcote.tech", "platform");
   const platformPkg = JSON.parse(readFileSync(join(platformDir, "package.json"), "utf-8"));
   const platformEntry = join(platformDir, platformPkg.main ?? "src/index.ts");
 
   await import(platformEntry);
 
-  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}`);
+  // Primary source: flattened server bundles at `<arcDir>/server/<safeName>.js`.
+  // 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}`);
+      }
     }
-  }
-
-  const nonCtxPackages = packages.filter((p) => !isContextPackage(p.packageJson));
-  for (const pkg of nonCtxPackages) {
-    try {
-      await import(pkg.entrypoint);
-    } catch {
-      // Non-context packages may fail on server (React components etc.) — that's OK,
-      // module().protectedBy().build() runs synchronously before any rendering
+  } 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 {
+    return { context: null, moduleAccess: new Map() };
   }
 
   const { getContext, getAllModuleAccess } = await import(platformEntry);