@arcote.tech/arc-cli 0.5.6 → 0.5.8

package/src/platform/shared.ts

@@ -1,21 +1,37 @@
 import { findUpSync } from "find-up";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import {
-  buildPackages,
+  buildContextPackages,
+  buildModulesBundle,
   buildStyles,
+  buildTranslations,
   discoverPackages,
   isContextPackage,
-  sha256OfFiles,
   type BuildManifest,
   type ModuleDescriptor,
-  type ModuleEntry,
   type WorkspacePackage,
 } from "../builder/module-builder";
+import {
+  loadBuildCache,
+  saveBuildCache,
+  isCacheHit,
+  updateCache,
+  type BuildCache,
+} from "../builder/build-cache";
+import {
+  mtimeOf,
+  readInstalledVersion,
+  sha256Hex,
+  sha256OfDir,
+  sha256OfFiles,
+  sha256OfJson,
+} from "../builder/hash";
+import { pAll } from "../builder/parallel";
 
 // Re-export for convenience
-export { buildPackages, buildStyles, isContextPackage };
-export type { BuildManifest, ModuleDescriptor, ModuleEntry, WorkspacePackage };
+export { buildContextPackages, buildModulesBundle, buildStyles, isContextPackage };
+export type { BuildManifest, ModuleDescriptor, WorkspacePackage };
 
 // ---------------------------------------------------------------------------
 // Logging
@@ -51,6 +67,8 @@ export interface WorkspaceInfo {
   arcDir: string;
   modulesDir: string;
   shellDir: string;
+  /** Static assets generated z arc.browserAssets workspace deps. Serwowane pod /assets/*. */
+  assetsDir: string;
   publicDir: string;
   packages: WorkspacePackage[];
   manifest?: ManifestInfo;
@@ -107,6 +125,7 @@ export function resolveWorkspace(): WorkspaceInfo {
     arcDir,
     modulesDir: join(arcDir, "modules"),
     shellDir: join(arcDir, "shell"),
+    assetsDir: join(arcDir, "assets"),
     publicDir: join(rootDir, "public"),
     packages,
     manifest,
@@ -117,32 +136,39 @@ export function resolveWorkspace(): WorkspaceInfo {
 // Build pipeline — packages, CSS, theme, shell
 // ---------------------------------------------------------------------------
 
-export async function buildAll(ws: WorkspaceInfo): Promise<BuildManifest> {
-  log("Building packages...");
-  const manifest = await buildPackages(ws.rootDir, ws.modulesDir, ws.packages);
-  ok(`Built ${manifest.modules.length} module(s)`);
-
-  log("Building styles...");
-  await buildStyles(ws.rootDir, ws.arcDir);
-  ok("Styles built");
-
-  // Copy theme if configured
-  const themePath = ws.rootPkg.arc?.theme;
-  if (themePath) {
-    const src = join(ws.rootDir, themePath);
-    if (existsSync(src)) {
-      copyFileSync(src, join(ws.arcDir, "theme.css"));
-      ok("Theme copied");
-    }
-  }
-
-  log("Building shell...");
-  await buildShell(ws.shellDir, ws.packages);
-  ok("Shell built");
+export interface BuildOptions {
+  noCache?: boolean;
+}
 
-  // Compute aggregate hashes now that all artifacts are on disk, then rewrite
-  // manifest.json with full hash data (modules + shellHash + stylesHash).
-  const finalManifest = finalizeManifest(ws, manifest);
+/**
+ * Run the full build pipeline. All units run in parallel; each consults the
+ * source-hash cache and skips if its inputs are unchanged. Pass `noCache: true`
+ * to force a full rebuild (the cache is still updated).
+ */
+export async function buildAll(
+  ws: WorkspaceInfo,
+  opts: BuildOptions = {},
+): Promise<BuildManifest> {
+  const cache = loadBuildCache(ws.arcDir);
+  const noCache = opts.noCache ?? false;
+  const themePath = ws.rootPkg.arc?.theme as string | undefined;
+
+  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),
+    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);
+
+  const finalManifest = assembleManifest(ws, modulesResult.modules, cache);
   writeFileSync(
     join(ws.modulesDir, "manifest.json"),
     JSON.stringify(finalManifest, null, 2),
@@ -151,38 +177,158 @@ export async function buildAll(ws: WorkspaceInfo): Promise<BuildManifest> {
 }
 
 /**
- * Compute shellHash + stylesHash and produce the final manifest.
- * Pure function — does not touch disk.
+ * Assemble the platform manifest from cached output hashes — no disk reads.
  */
-export function finalizeManifest(
+function assembleManifest(
   ws: WorkspaceInfo,
-  manifest: BuildManifest,
+  modules: ModuleDescriptor[],
+  cache: BuildCache,
 ): BuildManifest {
-  const shellFiles = listFilesRec(ws.shellDir);
-  const stylesFiles = [
-    join(ws.arcDir, "styles.css"),
-    join(ws.arcDir, "theme.css"),
-  ].filter((p) => existsSync(p));
+  // 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: manifest.modules,
-    shellHash: sha256OfFiles(shellFiles),
-    stylesHash: sha256OfFiles(stylesFiles),
-    buildTime: manifest.buildTime,
+    modules,
+    shellHash,
+    stylesHash,
+    buildTime: new Date().toISOString(),
   };
 }
 
-function listFilesRec(dir: string): string[] {
-  if (!existsSync(dir)) return [];
-  const out: string[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const p = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...listFilesRec(p));
-    else if (entry.isFile()) out.push(p);
+// ---------------------------------------------------------------------------
+// Browser assets — @arcote.tech/* deps deklarują w `arc.browserAssets` jakie
+// pliki muszą być dostępne w przeglądarce (np. SQLite WASM worker + .wasm).
+// ---------------------------------------------------------------------------
+
+interface BrowserAsset {
+  /** Path to source file — relative to package dir or package-resolvable. */
+  from: string;
+  /** Target filename in /assets/. */
+  to: string;
+}
+
+interface ResolvedAsset {
+  arcPkg: string;
+  from: string;
+  to: string;
+  src: string;
+}
+
+function resolveAssetSource(
+  from: string,
+  pkgDir: string,
+  rootDir: string,
+): string | null {
+  if (from.startsWith("./") || from.startsWith("../")) {
+    const resolved = join(pkgDir, from);
+    return existsSync(resolved) ? resolved : null;
+  }
+  const candidates = [
+    join(rootDir, "node_modules", from),
+    join(pkgDir, "node_modules", from),
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  const bunCacheDir = join(rootDir, "node_modules", ".bun");
+  if (existsSync(bunCacheDir)) {
+    for (const entry of readdirSync(bunCacheDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const candidate = join(
+        bunCacheDir,
+        entry.name,
+        "node_modules",
+        from,
+      );
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function readBrowserAssets(pkgDir: string): BrowserAsset[] {
+  const pkgJsonPath = join(pkgDir, "package.json");
+  if (!existsSync(pkgJsonPath)) return [];
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    const assets = pkg.arc?.browserAssets;
+    if (!Array.isArray(assets)) return [];
+    return assets.filter(
+      (a): a is BrowserAsset =>
+        typeof a?.from === "string" && typeof a?.to === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+function discoverBrowserAssets(ws: WorkspaceInfo): ResolvedAsset[] {
+  const arcDir = join(ws.rootDir, "node_modules", "@arcote.tech");
+  if (!existsSync(arcDir)) return [];
+
+  const out: ResolvedAsset[] = [];
+  for (const entry of readdirSync(arcDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const pkgDir = join(arcDir, entry.name);
+    const assets = readBrowserAssets(pkgDir);
+    for (const asset of assets) {
+      const src = resolveAssetSource(asset.from, pkgDir, ws.rootDir);
+      if (!src) {
+        err(`browserAsset not found: ${asset.from} (from @arcote.tech/${entry.name})`);
+        continue;
+      }
+      out.push({ arcPkg: entry.name, from: asset.from, to: asset.to, src });
+    }
   }
   return out;
 }
 
+/**
+ * Copy browser assets as a single cached unit. Hash inputs: every (from, to, src-mtime).
+ */
+async function copyBrowserAssets(
+  ws: WorkspaceInfo,
+  cache: BuildCache,
+  noCache: boolean,
+): Promise<void> {
+  mkdirSync(ws.assetsDir, { recursive: true });
+  const assets = discoverBrowserAssets(ws);
+  if (assets.length === 0) return;
+
+  const unitId = "browser-assets";
+  const inputHash = sha256OfJson(
+    assets.map((a) => ({
+      arcPkg: a.arcPkg,
+      from: a.from,
+      to: a.to,
+      mtime: mtimeOf(a.src),
+    })),
+  );
+
+  const requiredOutputs = assets.map((a) => join(ws.assetsDir, a.to));
+  if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
+    console.log(`  ✓ cached: browser-assets (${assets.length})`);
+    return;
+  }
+
+  console.log(`  building: browser-assets (${assets.length})`);
+  const outputHashes: Record<string, string> = {};
+  for (const asset of assets) {
+    const dest = join(ws.assetsDir, asset.to);
+    mkdirSync(dirname(dest), { recursive: true });
+    copyFileSync(asset.src, dest);
+    outputHashes[asset.to] = sha256Hex(readFileSync(dest));
+  }
+  updateCache(cache, unitId, inputHash, { outputHashes });
+}
+
 // ---------------------------------------------------------------------------
 // Shell builder — framework packages for import map
 // ---------------------------------------------------------------------------
@@ -190,18 +336,15 @@ function listFilesRec(dir: string): string[] {
 /** Collect all @arcote.tech/* peerDependencies from workspace packages. */
 export function collectArcPeerDeps(packages: WorkspacePackage[]): [string, string][] {
   const seen = new Set<string>();
-  // Always include core framework packages
   for (const pkg of ["@arcote.tech/arc", "@arcote.tech/arc-ds", "@arcote.tech/arc-react", "@arcote.tech/platform"]) {
     seen.add(pkg);
   }
-  // Scan all workspace packages for @arcote.tech/* peerDeps
   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);
     }
   }
-  // Convert to [shortName, fullName] entries
   return [...seen].map((pkg) => {
     const short = pkg === "@arcote.tech/platform"
       ? "platform"
@@ -210,16 +353,10 @@ export function collectArcPeerDeps(packages: WorkspacePackage[]): [string, strin
   });
 }
 
-async function buildShell(outDir: string, packages?: WorkspacePackage[]): Promise<void> {
-  mkdirSync(outDir, { recursive: true });
-  const tmpDir = join(outDir, "_tmp");
-  mkdirSync(tmpDir, { recursive: true });
-
-  // Step 1: Build React layer (bundles React CJS → ESM)
-  const reactEntries: [string, string][] = [
-    [
-      "react",
-      `import React from "react";
+const REACT_ENTRIES: [string, string][] = [
+  [
+    "react",
+    `import React from "react";
 export default React;
 export const {
   Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense,
@@ -229,96 +366,172 @@ export const {
   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";
+  ],
+  ["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";`,
-    ],
-  ];
+  ],
+  [
+    "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 reactEntries) {
+  for (const [name, code] of REACT_ENTRIES) {
     const f = join(tmpDir, `${name}.ts`);
-    Bun.write(f, code);
+    await Bun.write(f, code);
     reactEps.push(f);
   }
 
-  const r1 = await Bun.build({
+  const r = await Bun.build({
     entrypoints: reactEps,
-    outdir: outDir,
+    outdir: shellDir,
     splitting: true,
     format: "esm",
     target: "browser",
     naming: "[name].[ext]",
   });
-  if (!r1.success) {
-    for (const l of r1.logs) console.error(l);
+  if (!r.success) {
+    for (const l of r.logs) console.error(l);
     throw new Error("Shell React build failed");
   }
 
-  // Step 2: Build Arc layer (react is EXTERNAL — resolved via import map)
-  // Dynamically collect only @arcote.tech/* packages actually used by workspace
-  const arcEntries = packages
-    ? collectArcPeerDeps(packages)
-    : [
-        // Fallback: core packages only (no workspace packages available)
-        ["arc", "@arcote.tech/arc"],
-        ["arc-ds", "@arcote.tech/arc-ds"],
-        ["arc-react", "@arcote.tech/arc-react"],
-        ["platform", "@arcote.tech/platform"],
-      ] as [string, string][];
-
-  const baseExternal = [
-    "react",
-    "react-dom",
-    "react/jsx-runtime",
-    "react/jsx-dev-runtime",
-    "react-dom/client",
-  ];
-  const allArcPkgs = arcEntries.map(([, pkg]) => pkg);
+  const outputHash = sha256OfFiles(requiredOutputs);
+  updateCache(cache, unitId, inputHash, { outputHash });
+}
 
-  // Build each arc entry separately so it can import sibling arc packages
-  // as externals (resolved via import map) without circular self-reference.
-  for (const [name, pkg] of arcEntries) {
-    const f = join(tmpDir, `${name}.ts`);
-    Bun.write(f, `export * from "${pkg}";\n`);
-
-    const r2 = await Bun.build({
-      entrypoints: [f],
-      outdir: outDir,
-      format: "esm",
-      target: "browser",
-      naming: "[name].[ext]",
-      external: [
-        ...baseExternal,
-        // Other arc packages are external (not self)
-        ...allArcPkgs.filter((p) => p !== pkg),
-      ],
-      define: {
-        ONLY_SERVER: "false",
-        ONLY_BROWSER: "true",
-        ONLY_CLIENT: "true",
-      },
-    });
-    if (!r2.success) {
-      for (const l of r2.logs) console.error(l);
-      throw new Error(`Shell build failed for ${pkg}`);
-    }
+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;
   }
 
-  // Clean tmp
-  const { rmSync } = await import("fs");
+  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 });
 }
 
@@ -338,20 +551,14 @@ export async function loadServerContext(
   (globalThis as any).ONLY_BROWSER = false;
   (globalThis as any).ONLY_CLIENT = false;
 
-  // Import all context packages — side effects from module().build()
-  // register context elements into the global registry via setContext().
-  // Resolve platform from the project's node_modules using an absolute path.
-  // When CLI is bun-linked, `import("@arcote.tech/platform")` would resolve to
-  // the CLI's own copy, creating a separate module instance from what context
-  // packages use. Using an absolute path ensures a single shared instance.
+  // Resolve platform from the project's node_modules using an absolute path
+  // (see comment in original implementation for why).
   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");
 
-  // Pre-import platform so it's cached with this absolute path
   await import(platformEntry);
 
-  // Import context packages from server dist (has server-only code paths)
   for (const ctx of ctxPackages) {
     const serverDist = join(ctx.path, "dist", "server", "main", "index.js");
     if (!existsSync(serverDist)) {
@@ -366,7 +573,6 @@ export async function loadServerContext(
     }
   }
 
-  // Import non-context packages from source to capture module().protectedBy() metadata
   const nonCtxPackages = packages.filter((p) => !isContextPackage(p.packageJson));
   for (const pkg of nonCtxPackages) {
     try {