@arcote.tech/arc-cli 0.7.0 → 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,
-  buildModulesByChunks,
   buildStyles,
   buildTranslations,
   discoverPackages,
   isContextPackage,
+  type BrowserAppResult,
   type BuildManifest,
   type ModuleDescriptor,
   type WorkspacePackage,
@@ -24,16 +25,13 @@ 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";
 
 // Re-export for convenience
-export { buildContextPackages, buildModulesByChunks, buildStyles, isContextPackage };
+export { buildContextPackages, buildStyles, isContextPackage };
 export type { BuildManifest, ModuleDescriptor, WorkspacePackage };
 
 // ---------------------------------------------------------------------------
@@ -68,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;
@@ -128,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,
@@ -191,16 +188,22 @@ export async function buildAll(
       .join(", ")}`,
   );
 
-  // Phase 4 — independent parallel build units. Module chunks are the only
-  // unit whose output we need for the manifest; others update the cache.
-  const [modulesResult] = await Promise.all([
-    buildModulesByChunks(ws.rootDir, ws.modulesDir, plan, cache, noCache),
-    buildShell(ws, cache, noCache),
+  // 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),
   ]);
 
+  // Finalize i18n catalogs once after all chunks + initial bundle collected.
+  const { finalizeTranslations } = await import("../i18n");
+  await finalizeTranslations(ws.rootDir, ws.arcDir, i18nCollector);
+
   // 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).
@@ -208,37 +211,28 @@ export async function buildAll(
 
   saveBuildCache(ws.arcDir, cache);
 
-  const finalManifest = assembleManifest(ws, modulesResult.modules, plan.chunks, 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[],
-  chunks: readonly string[],
+  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,
-    chunks,
-    shellHash,
+    initial: browser.initial,
+    groups: browser.groups,
+    sharedChunks: browser.sharedChunks,
     stylesHash,
     buildTime: new Date().toISOString(),
   };
@@ -399,212 +393,6 @@ 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
 // ---------------------------------------------------------------------------
@@ -618,9 +406,9 @@ export async function loadServerContext(
   (globalThis as any).ONLY_BROWSER = false;
   (globalThis as any).ONLY_CLIENT = false;
 
-  // Resolve platform from the project's node_modules. Bun picks the `bun`
-  // export condition from package.json, which points at `index.server.ts`
-  // (server-safe, no React/JSX at top level).
+  // 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");

package/src/platform/startup.ts

@@ -4,7 +4,6 @@ import { startPlatformServer, type PlatformServer } from "./server";
 import type { BuildManifest } from "./shared";
 import {
   buildAll,
-  collectArcPeerDeps,
   err,
   loadServerContext,
   log,
@@ -54,7 +53,7 @@ export async function startPlatform(
   if (devMode) {
     manifest = await buildAll(ws);
   } else {
-    const manifestPath = join(ws.modulesDir, "manifest.json");
+    const manifestPath = join(ws.arcDir, "manifest.json");
     if (!existsSync(manifestPath)) {
       err("No build found. Run `arc platform build` first.");
       process.exit(1);
@@ -75,7 +74,6 @@ export async function startPlatform(
 
   // 3. Start the platform server. Cache headers + SSE behaviour are
   // controlled inside the server by `devMode`; we just pass the flag.
-  const arcEntries = collectArcPeerDeps(ws.packages);
   const platform = await startPlatformServer({
     ws,
     port,
@@ -84,7 +82,6 @@ export async function startPlatform(
     moduleAccess,
     dbPath,
     devMode,
-    arcEntries,
   });
 
   ok(`Server on http://localhost:${port}`);
@@ -121,7 +118,9 @@ function attachDevWatcher(ws: WorkspaceInfo, platform: PlatformServer): void {
         const next = await buildAll(ws);
         platform.setManifest(next);
         platform.notifyReload(next);
-        ok(`Rebuilt — ${next.modules.length} module(s)`);
+        ok(
+          `Rebuilt — initial + ${Object.keys(next.groups).length} group(s)`,
+        );
       } catch (e) {
         console.error(`Rebuild failed: ${e}`);
       } finally {