@arcote.tech/arc-cli 0.5.6 → 0.5.7

package/dist/index.js

@@ -26345,19 +26345,20 @@ ${colors3.yellow}Type declaration errors:${colors3.reset}`);
 }
 
 // src/platform/shared.ts
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname6, join as join7 } from "path";
+import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
 
 // src/builder/module-builder.ts
 import { execSync } from "child_process";
 import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync5,
-  readdirSync as readdirSync3,
-  writeFileSync as writeFileSync5
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync4,
+  rmSync,
+  writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname5, join as join6, relative as relative2 } from "path";
+import { dirname as dirname5, join as join8, relative as relative3 } from "path";
 
 // src/i18n/index.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
@@ -26630,43 +26631,154 @@ async function finalizeTranslations(rootDir, outDir, collector) {
   }
 }
 
+// src/builder/build-cache.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+var CACHE_VERSION = 1;
+var CACHE_FILE = ".build-cache.json";
+function emptyCache() {
+  return { version: CACHE_VERSION, units: {} };
+}
+function loadBuildCache(arcDir) {
+  const path4 = join6(arcDir, CACHE_FILE);
+  if (!existsSync5(path4))
+    return emptyCache();
+  try {
+    const raw = JSON.parse(readFileSync5(path4, "utf-8"));
+    if (raw?.version !== CACHE_VERSION || typeof raw.units !== "object") {
+      return emptyCache();
+    }
+    return raw;
+  } catch {
+    return emptyCache();
+  }
+}
+function saveBuildCache(arcDir, cache) {
+  mkdirSync5(arcDir, { recursive: true });
+  writeFileSync5(join6(arcDir, CACHE_FILE), JSON.stringify(cache, null, 2));
+}
+function isCacheHit(cache, unitId, inputHash, requiredOutputs = []) {
+  const entry = cache.units[unitId];
+  if (!entry || entry.inputHash !== inputHash)
+    return false;
+  for (const out of requiredOutputs) {
+    if (!existsSync5(out))
+      return false;
+  }
+  return true;
+}
+function updateCache(cache, unitId, inputHash, output = {}) {
+  cache.units[unitId] = {
+    inputHash,
+    ...output.outputHash !== undefined && { outputHash: output.outputHash },
+    ...output.outputHashes !== undefined && { outputHashes: output.outputHashes }
+  };
+}
+
+// src/builder/hash.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join7, relative as relative2, sep as sep2 } from "path";
+function sha256Hex(bytes) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(bytes);
+  return hasher.digest("hex");
+}
+function sha256OfFiles(paths) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  const sorted = [...paths].sort();
+  for (const p of sorted) {
+    if (!existsSync6(p))
+      continue;
+    hasher.update(readFileSync6(p));
+    hasher.update("\x00");
+  }
+  return hasher.digest("hex");
+}
+function sha256OfDir(dir, filter2) {
+  if (!existsSync6(dir))
+    return sha256Hex("");
+  const hasher = new Bun.CryptoHasher("sha256");
+  const entries = [];
+  function walk(absDir) {
+    for (const entry of readdirSync3(absDir, { withFileTypes: true })) {
+      const abs = join7(absDir, entry.name);
+      const rel = relative2(dir, abs).split(sep2).join("/");
+      if (filter2 && !filter2(rel))
+        continue;
+      if (entry.isDirectory())
+        walk(abs);
+      else if (entry.isFile())
+        entries.push({ rel, abs });
+    }
+  }
+  walk(dir);
+  entries.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  for (const { rel, abs } of entries) {
+    hasher.update(rel);
+    hasher.update("\x00");
+    hasher.update(readFileSync6(abs));
+    hasher.update("\x00");
+  }
+  return hasher.digest("hex");
+}
+function sha256OfJson(value) {
+  return sha256Hex(stableStringify(value));
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function readInstalledVersion(rootDir, pkgName) {
+  const pkgJson = join7(rootDir, "node_modules", pkgName, "package.json");
+  if (!existsSync6(pkgJson))
+    return null;
+  try {
+    return JSON.parse(readFileSync6(pkgJson, "utf-8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+function mtimeOf(path4) {
+  if (!existsSync6(path4))
+    return 0;
+  try {
+    return statSync(path4).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+// src/builder/parallel.ts
+import { cpus } from "os";
+var DEFAULT_CONCURRENCY = Math.max(1, cpus().length - 1);
+async function pAll(tasks, concurrency = DEFAULT_CONCURRENCY) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  const limit = Math.max(1, Math.min(concurrency, tasks.length));
+  async function worker() {
+    while (true) {
+      const i = nextIndex++;
+      if (i >= tasks.length)
+        return;
+      results[i] = await tasks[i]();
+    }
+  }
+  const workers = Array.from({ length: limit }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
 // src/builder/module-builder.ts
 var CONTEXT_CLIENTS = [
   { name: "server", target: "bun", defines: { ONLY_SERVER: "true", ONLY_BROWSER: "false", ONLY_CLIENT: "false" } },
   { name: "browser", target: "browser", defines: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" } }
 ];
-async function buildContextPackage(pkg) {
-  const entrypoint = pkg.entrypoint;
-  const outDir = join6(pkg.path, "dist");
-  const peerDeps = Object.keys(pkg.packageJson.peerDependencies || {});
-  const deps = Object.keys(pkg.packageJson.dependencies || {});
-  const externals = [...peerDeps, ...deps];
-  const allDeclErrors = [];
-  for (const client of CONTEXT_CLIENTS) {
-    const result = await Bun.build({
-      entrypoints: [entrypoint],
-      outdir: join6(outDir, client.name, "main"),
-      target: client.target,
-      format: "esm",
-      naming: "index.[ext]",
-      external: externals,
-      define: client.defines
-    });
-    if (!result.success) {
-      console.error(`Context ${client.name} build failed:`);
-      for (const log2 of result.logs)
-        console.error(log2);
-      throw new Error(`${client.name} build failed for ${pkg.name}`);
-    }
-    const globalsContent = Object.entries(client.defines).map(([k, v]) => `declare const ${k}: ${v};`).join(`
-`);
-    const declResult = await buildTypeDeclarations([entrypoint], join6(outDir, client.name), dirname5(entrypoint), globalsContent);
-    if (!declResult.success && declResult.errors.length > 0) {
-      allDeclErrors.push(...declResult.errors.map((e) => `[${pkg.name}/${client.name}] ${e}`));
-    }
-  }
-  return { declarationErrors: allDeclErrors };
-}
 var SHELL_EXTERNALS = [
   "react",
   "react-dom",
@@ -26680,57 +26792,41 @@ var SHELL_EXTERNALS = [
   "@arcote.tech/arc-workspace",
   "@arcote.tech/platform"
 ];
-function sha256Hex(bytes) {
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(bytes);
-  return hasher.digest("hex");
-}
-function sha256OfFiles(paths) {
-  const hasher = new Bun.CryptoHasher("sha256");
-  const sorted = [...paths].sort();
-  for (const p of sorted) {
-    if (!existsSync5(p))
-      continue;
-    hasher.update(readFileSync5(p));
-    hasher.update("\x00");
-  }
-  return hasher.digest("hex");
-}
 function discoverPackages(rootDir) {
-  const rootPkg = JSON.parse(readFileSync5(join6(rootDir, "package.json"), "utf-8"));
+  const rootPkg = JSON.parse(readFileSync7(join8(rootDir, "package.json"), "utf-8"));
   const workspaceGlobs = rootPkg.workspaces ?? [];
   const results = [];
   for (const glob2 of workspaceGlobs) {
     const base2 = glob2.replace("/*", "");
-    const baseDir = join6(rootDir, base2);
-    if (!existsSync5(baseDir))
+    const baseDir = join8(rootDir, base2);
+    if (!existsSync7(baseDir))
       continue;
     let entries;
     try {
-      entries = readdirSync3(baseDir);
+      entries = readdirSync4(baseDir);
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const pkgPath = join6(baseDir, entry, "package.json");
-      if (!existsSync5(pkgPath))
+      const pkgPath = join8(baseDir, entry, "package.json");
+      if (!existsSync7(pkgPath))
         continue;
-      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       if (pkg.name?.startsWith("@arcote.tech/"))
         continue;
-      const pkgDir = join6(baseDir, entry);
+      const pkgDir = join8(baseDir, entry);
       const candidates = [
-        join6(pkgDir, "src", "index.ts"),
-        join6(pkgDir, "src", "index.tsx"),
-        join6(pkgDir, "index.ts"),
-        join6(pkgDir, "index.tsx")
+        join8(pkgDir, "src", "index.ts"),
+        join8(pkgDir, "src", "index.tsx"),
+        join8(pkgDir, "index.ts"),
+        join8(pkgDir, "index.tsx")
       ];
-      const entrypoint = candidates.find((c) => existsSync5(c)) ?? null;
+      const entrypoint = candidates.find((c) => existsSync7(c)) ?? null;
       if (!entrypoint)
         continue;
       results.push({
         name: pkg.name,
-        path: join6(baseDir, entry),
+        path: join8(baseDir, entry),
         entrypoint,
         packageJson: pkg
       });
@@ -26749,95 +26845,198 @@ function isContextPackage(pkg) {
   }
   return false;
 }
-async function buildPackages(rootDir, outDir, packages) {
-  mkdirSync5(outDir, { recursive: true });
-  const contexts = packages.filter((p) => isContextPackage(p.packageJson));
-  const allDeclErrors = [];
-  for (const ctx of contexts) {
-    console.log(`  Building context: ${ctx.name}`);
-    const { declarationErrors } = await buildContextPackage(ctx);
-    allDeclErrors.push(...declarationErrors);
-  }
-  if (allDeclErrors.length > 0) {
-    console.warn(`
-\x1B[33mType declaration errors:\x1B[0m`);
-    for (const err of allDeclErrors) {
-      console.warn(`  ${err}`);
-    }
-    console.warn("");
-  }
-  const tmpDir = join6(outDir, "_entries");
-  mkdirSync5(tmpDir, { recursive: true });
-  const entrypoints = [];
-  const fileToName = new Map;
-  for (const pkg of packages) {
-    const safeName = pkg.path.split("/").pop();
-    const moduleName = pkg.name.includes("/") ? pkg.name.split("/").pop() : pkg.name;
-    fileToName.set(safeName, moduleName);
-    const wrapperFile = join6(tmpDir, `${safeName}.ts`);
-    writeFileSync5(wrapperFile, `export * from "${pkg.name}";
-`);
-    entrypoints.push(wrapperFile);
+var sourceFilter = (rel) => {
+  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 pkgSourceHash(pkg) {
+  return sha256OfDir(join8(pkg.path, "src"), sourceFilter);
+}
+function depVersionsHash(rootDir, pkg) {
+  const peerDeps = Object.keys(pkg.packageJson.peerDependencies ?? {});
+  const deps = Object.keys(pkg.packageJson.dependencies ?? {});
+  const versions = {};
+  for (const dep of [...peerDeps, ...deps].sort()) {
+    versions[dep] = readInstalledVersion(rootDir, dep);
+  }
+  return sha256OfJson(versions);
+}
+async function buildContextClient(pkg, rootDir, client, cache, noCache) {
+  const unitId = `context-pkg:${pkg.name}:${client.name}`;
+  const outDir = join8(pkg.path, "dist", client.name);
+  const inputHash = sha256OfJson({
+    src: pkgSourceHash(pkg),
+    pkg: pkg.packageJson,
+    deps: depVersionsHash(rootDir, pkg),
+    client: client.name,
+    target: client.target,
+    defines: client.defines
+  });
+  if (!noCache && isCacheHit(cache, unitId, inputHash, [join8(outDir, "main", "index.js")])) {
+    console.log(`  \u2713 cached: ${pkg.name} (${client.name})`);
+    return { pkgName: pkg.name, client: client.name, declarationErrors: [], cached: true };
   }
-  console.log(`  Bundling ${entrypoints.length} package(s)...`);
-  const i18nCollector = new Map;
-  const arcExternalPlugin = {
-    name: "arc-external",
-    setup(build2) {
-      build2.onResolve({ filter: /^@arcote\.tech\// }, (args) => {
-        return { path: args.path, external: true };
-      });
-    }
-  };
+  console.log(`  building: ${pkg.name} (${client.name})`);
+  const peerDeps = Object.keys(pkg.packageJson.peerDependencies ?? {});
+  const deps = Object.keys(pkg.packageJson.dependencies ?? {});
+  const externals = [...peerDeps, ...deps];
   const result = await Bun.build({
-    entrypoints,
-    outdir: outDir,
-    splitting: true,
+    entrypoints: [pkg.entrypoint],
+    outdir: join8(outDir, "main"),
+    target: client.target,
     format: "esm",
-    target: "browser",
-    external: SHELL_EXTERNALS,
-    plugins: [arcExternalPlugin, i18nExtractPlugin(i18nCollector, rootDir)],
-    naming: "[name].[ext]",
-    define: {
-      ONLY_SERVER: "false",
-      ONLY_BROWSER: "true",
-      ONLY_CLIENT: "true"
-    }
+    naming: "index.[ext]",
+    external: externals,
+    define: client.defines
   });
   if (!result.success) {
-    console.error("Build failed:");
+    console.error(`Context ${client.name} build failed:`);
     for (const log2 of result.logs)
       console.error(log2);
-    throw new Error("Module build failed");
-  }
-  await finalizeTranslations(rootDir, join6(outDir, ".."), i18nCollector);
-  const { rmSync } = await import("fs");
-  rmSync(tmpDir, { recursive: true, force: true });
-  const moduleEntries = result.outputs.filter((o) => o.kind === "entry-point").map((o) => {
-    const file = o.path.split("/").pop();
-    const safeName = file.replace(/\.js$/, "");
-    const bytes = readFileSync5(o.path);
-    return {
-      file,
-      name: fileToName.get(safeName) ?? safeName,
-      hash: sha256Hex(bytes)
-    };
+    throw new Error(`${client.name} build failed for ${pkg.name}`);
+  }
+  const globalsContent = Object.entries(client.defines).map(([k, v]) => `declare const ${k}: ${v};`).join(`
+`);
+  const declResult = await buildTypeDeclarations([pkg.entrypoint], outDir, dirname5(pkg.entrypoint), globalsContent);
+  const declarationErrors = !declResult.success && declResult.errors.length > 0 ? declResult.errors.map((e) => `[${pkg.name}/${client.name}] ${e}`) : [];
+  const outputHash = sha256OfDir(outDir);
+  updateCache(cache, unitId, inputHash, { outputHash });
+  return { pkgName: pkg.name, client: client.name, declarationErrors, cached: false };
+}
+async function buildContextPackages(rootDir, packages, cache, noCache) {
+  const contexts = packages.filter((p) => isContextPackage(p.packageJson));
+  if (contexts.length === 0)
+    return { declarationErrors: [] };
+  const tasks = contexts.flatMap((pkg) => CONTEXT_CLIENTS.map((client) => () => buildContextClient(pkg, rootDir, client, cache, noCache)));
+  const results = await pAll(tasks);
+  const declarationErrors = results.flatMap((r) => r.declarationErrors);
+  if (declarationErrors.length > 0) {
+    console.warn(`
+\x1B[33mType declaration errors:\x1B[0m`);
+    for (const err of declarationErrors)
+      console.warn(`  ${err}`);
+    console.warn("");
+  }
+  return { declarationErrors };
+}
+async function buildModulesBundle(rootDir, outDir, packages, cache, noCache) {
+  mkdirSync6(outDir, { recursive: true });
+  const unitId = "modules-bundle";
+  const pkgHashes = packages.map((p) => ({
+    name: p.name,
+    safeName: p.path.split("/").pop(),
+    srcHash: pkgSourceHash(p)
+  }));
+  const inputHash = sha256OfJson({
+    pkgHashes,
+    externals: SHELL_EXTERNALS,
+    define: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" }
   });
-  const manifest = {
-    modules: moduleEntries,
-    shellHash: "",
-    stylesHash: "",
-    buildTime: new Date().toISOString()
-  };
-  writeFileSync5(join6(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  return manifest;
+  if (!noCache && isCacheHit(cache, unitId, inputHash)) {
+    const existing = cache.units[unitId]?.outputHashes ?? {};
+    const modules = [];
+    for (const { safeName, name } of pkgHashes) {
+      const file = `${safeName}.js`;
+      const filePath = join8(outDir, file);
+      if (!existsSync7(filePath)) {
+        console.log(`  rebuilding modules-bundle: output ${file} missing`);
+        return await actuallyBuild();
+      }
+      modules.push({ file, name, hash: existing[safeName] ?? sha256Hex(readFileSync7(filePath)) });
+    }
+    console.log(`  \u2713 cached: modules-bundle (${modules.length} module(s))`);
+    return { modules, cached: true };
+  }
+  return await actuallyBuild();
+  async function actuallyBuild() {
+    console.log(`  building: modules-bundle (${packages.length} package(s))`);
+    const tmpDir = join8(outDir, "_entries");
+    mkdirSync6(tmpDir, { recursive: true });
+    const entrypoints = [];
+    const fileToName = new Map;
+    for (const pkg of packages) {
+      const safeName = pkg.path.split("/").pop();
+      const moduleName = pkg.name.includes("/") ? pkg.name.split("/").pop() : pkg.name;
+      fileToName.set(safeName, moduleName);
+      const wrapperFile = join8(tmpDir, `${safeName}.ts`);
+      writeFileSync6(wrapperFile, `export * from "${pkg.name}";
+`);
+      entrypoints.push(wrapperFile);
+    }
+    const i18nCollector = new Map;
+    const arcExternalPlugin = {
+      name: "arc-external",
+      setup(build2) {
+        build2.onResolve({ filter: /^@arcote\.tech\// }, (args) => {
+          return { path: args.path, external: true };
+        });
+      }
+    };
+    const result = await Bun.build({
+      entrypoints,
+      outdir: outDir,
+      splitting: true,
+      format: "esm",
+      target: "browser",
+      external: SHELL_EXTERNALS,
+      plugins: [arcExternalPlugin, i18nExtractPlugin(i18nCollector, rootDir)],
+      naming: "[name].[ext]",
+      define: {
+        ONLY_SERVER: "false",
+        ONLY_BROWSER: "true",
+        ONLY_CLIENT: "true"
+      }
+    });
+    if (!result.success) {
+      console.error("Modules bundle build failed:");
+      for (const log2 of result.logs)
+        console.error(log2);
+      throw new Error("Module build failed");
+    }
+    await finalizeTranslations(rootDir, join8(outDir, ".."), i18nCollector);
+    rmSync(tmpDir, { recursive: true, force: true });
+    const outputHashes = {};
+    const modules = result.outputs.filter((o) => o.kind === "entry-point").map((o) => {
+      const file = o.path.split("/").pop();
+      const safeName = file.replace(/\.js$/, "");
+      const bytes = readFileSync7(o.path);
+      const hash = sha256Hex(bytes);
+      outputHashes[safeName] = hash;
+      return {
+        file,
+        name: fileToName.get(safeName) ?? safeName,
+        hash
+      };
+    });
+    updateCache(cache, unitId, inputHash, { outputHashes });
+    return { modules, cached: false };
+  }
+}
+async function buildTranslations(rootDir, arcDir, cache, noCache) {
+  const localesDir = join8(rootDir, "locales");
+  if (!existsSync7(localesDir))
+    return;
+  const unitId = "translations";
+  const poFiles = readdirSync4(localesDir).filter((f) => f.endsWith(".po")).map((f) => join8(localesDir, f));
+  if (poFiles.length === 0)
+    return;
+  const inputHash = sha256OfFiles(poFiles);
+  if (!noCache && isCacheHit(cache, unitId, inputHash, [join8(arcDir, "locales")])) {
+    console.log(`  \u2713 cached: translations`);
+    return;
+  }
+  console.log(`  building: translations (${poFiles.length} catalog(s))`);
+  compileAllCatalogs(localesDir, join8(arcDir, "locales"));
+  const jsonFiles = readdirSync4(join8(arcDir, "locales")).filter((f) => f.endsWith(".json")).map((f) => join8(arcDir, "locales", f));
+  const outputHash = sha256OfFiles(jsonFiles);
+  updateCache(cache, unitId, inputHash, { outputHash });
 }
-async function buildStyles(rootDir, outDir) {
-  mkdirSync5(outDir, { recursive: true });
-  const inputCss = join6(outDir, "_input.css");
-  const outputCss = join6(outDir, "styles.css");
-  const rootRel = relative2(outDir, rootDir).replace(/\\/g, "/");
-  writeFileSync5(inputCss, `@import "tailwindcss";
+var TAILWIND_INPUT_TEMPLATE = (rootRel) => `@import "tailwindcss";
 @import "tw-animate-css";
 
 @source "${rootRel}/packages/*/*.{ts,tsx}";
@@ -26895,12 +27094,61 @@ async function buildStyles(rootDir, outDir) {
     min-height: 100vh;
   }
 }
-`);
-  console.log("  Building CSS...");
+`;
+async function buildStyles(rootDir, arcDir, packages, themePath, cache, noCache) {
+  mkdirSync6(arcDir, { recursive: true });
+  const inputCss = join8(arcDir, "_input.css");
+  const outputCss = join8(arcDir, "styles.css");
+  const themeOutput = join8(arcDir, "theme.css");
+  const rootRel = relative3(arcDir, rootDir).replace(/\\/g, "/");
+  const inputCssContent = TAILWIND_INPUT_TEMPLATE(rootRel);
+  const tsxFilter = (rel) => {
+    if (!sourceFilter(rel))
+      return false;
+    if (/\.[^/]+$/.test(rel) && !/\.(ts|tsx)$/.test(rel))
+      return false;
+    return true;
+  };
+  const wsHashes = {};
+  for (const p of packages) {
+    wsHashes[p.name] = sha256OfDir(join8(p.path, "src"), tsxFilter);
+  }
+  const platformSrc = join8(rootDir, "node_modules", "@arcote.tech", "platform", "src");
+  const arcDsSrc = join8(rootDir, "node_modules", "@arcote.tech", "arc-ds", "src");
+  const frameworkHashes = {
+    platform: sha256OfDir(platformSrc, tsxFilter),
+    arcDs: sha256OfDir(arcDsSrc, tsxFilter)
+  };
+  const themeContent = themePath && existsSync7(join8(rootDir, themePath)) ? readFileSync7(join8(rootDir, themePath)) : null;
+  const themeHash = themeContent ? sha256Hex(themeContent) : null;
+  const unitId = "styles";
+  const inputHash = sha256OfJson({
+    workspaces: wsHashes,
+    framework: frameworkHashes,
+    inputCss: inputCssContent,
+    themeHash
+  });
+  const requiredOutputs = [outputCss];
+  if (themePath)
+    requiredOutputs.push(themeOutput);
+  if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
+    console.log(`  \u2713 cached: styles`);
+    return;
+  }
+  console.log(`  building: styles`);
+  writeFileSync6(inputCss, inputCssContent);
   execSync(`bunx @tailwindcss/cli -i ${inputCss} -o ${outputCss} --minify`, {
     cwd: rootDir,
     stdio: "inherit"
   });
+  if (themePath && themeContent) {
+    writeFileSync6(themeOutput, themeContent);
+  }
+  const outFiles = [outputCss];
+  if (themePath && existsSync7(themeOutput))
+    outFiles.push(themeOutput);
+  const outputHash = sha256OfFiles(outFiles);
+  updateCache(cache, unitId, inputHash, { outputHash });
 }
 
 // src/platform/shared.ts
@@ -26920,9 +27168,9 @@ function resolveWorkspace() {
     process.exit(1);
   }
   const rootDir = dirname6(packageJsonPath);
-  const rootPkg = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  const rootPkg = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
   const appName = rootPkg.name ?? "Arc App";
-  const arcDir = join7(rootDir, ".arc", "platform");
+  const arcDir = join9(rootDir, ".arc", "platform");
   log2("Scanning workspaces...");
   const packages = discoverPackages(rootDir);
   ok(`Found ${packages.length} package(s): ${packages.map((p) => p.name).join(", ")}`);
@@ -26932,10 +27180,10 @@ function resolveWorkspace() {
   }
   let manifest;
   for (const name of ["manifest.json", "manifest.webmanifest"]) {
-    const manifestPath = join7(rootDir, name);
-    if (existsSync6(manifestPath)) {
+    const manifestPath = join9(rootDir, name);
+    if (existsSync8(manifestPath)) {
       try {
-        const data = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+        const data = JSON.parse(readFileSync8(manifestPath, "utf-8"));
         const icons = data.icons;
         manifest = {
           path: manifestPath,
@@ -26954,61 +27202,135 @@ function resolveWorkspace() {
     rootPkg,
     appName,
     arcDir,
-    modulesDir: join7(arcDir, "modules"),
-    shellDir: join7(arcDir, "shell"),
-    publicDir: join7(rootDir, "public"),
+    modulesDir: join9(arcDir, "modules"),
+    shellDir: join9(arcDir, "shell"),
+    assetsDir: join9(arcDir, "assets"),
+    publicDir: join9(rootDir, "public"),
     packages,
     manifest
   };
 }
-async function buildAll(ws) {
-  log2("Building packages...");
-  const manifest = await buildPackages(ws.rootDir, ws.modulesDir, ws.packages);
-  ok(`Built ${manifest.modules.length} module(s)`);
-  log2("Building styles...");
-  await buildStyles(ws.rootDir, ws.arcDir);
-  ok("Styles built");
+async function buildAll(ws, opts = {}) {
+  const cache = loadBuildCache(ws.arcDir);
+  const noCache = opts.noCache ?? false;
   const themePath = ws.rootPkg.arc?.theme;
-  if (themePath) {
-    const src = join7(ws.rootDir, themePath);
-    if (existsSync6(src)) {
-      copyFileSync(src, join7(ws.arcDir, "theme.css"));
-      ok("Theme copied");
-    }
-  }
-  log2("Building shell...");
-  await buildShell(ws.shellDir, ws.packages);
-  ok("Shell built");
-  const finalManifest = finalizeManifest(ws, manifest);
-  writeFileSync6(join7(ws.modulesDir, "manifest.json"), JSON.stringify(finalManifest, null, 2));
+  log2(`Building (concurrency parallel${noCache ? ", no-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);
+  writeFileSync7(join9(ws.modulesDir, "manifest.json"), JSON.stringify(finalManifest, null, 2));
   return finalManifest;
 }
-function finalizeManifest(ws, manifest) {
-  const shellFiles = listFilesRec(ws.shellDir);
-  const stylesFiles = [
-    join7(ws.arcDir, "styles.css"),
-    join7(ws.arcDir, "theme.css")
-  ].filter((p) => existsSync6(p));
+function assembleManifest(ws, modules, cache) {
+  const shellEntries = {};
+  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) {
-  if (!existsSync6(dir))
+function resolveAssetSource(from, pkgDir, rootDir) {
+  if (from.startsWith("./") || from.startsWith("../")) {
+    const resolved = join9(pkgDir, from);
+    return existsSync8(resolved) ? resolved : null;
+  }
+  const candidates = [
+    join9(rootDir, "node_modules", from),
+    join9(pkgDir, "node_modules", from)
+  ];
+  for (const c of candidates) {
+    if (existsSync8(c))
+      return c;
+  }
+  const bunCacheDir = join9(rootDir, "node_modules", ".bun");
+  if (existsSync8(bunCacheDir)) {
+    for (const entry of readdirSync5(bunCacheDir, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      const candidate = join9(bunCacheDir, entry.name, "node_modules", from);
+      if (existsSync8(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+function readBrowserAssets(pkgDir) {
+  const pkgJsonPath = join9(pkgDir, "package.json");
+  if (!existsSync8(pkgJsonPath))
+    return [];
+  try {
+    const pkg = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+    const assets = pkg.arc?.browserAssets;
+    if (!Array.isArray(assets))
+      return [];
+    return assets.filter((a) => typeof a?.from === "string" && typeof a?.to === "string");
+  } catch {
+    return [];
+  }
+}
+function discoverBrowserAssets(ws) {
+  const arcDir = join9(ws.rootDir, "node_modules", "@arcote.tech");
+  if (!existsSync8(arcDir))
     return [];
   const out = [];
-  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const p = join7(dir, entry.name);
-    if (entry.isDirectory())
-      out.push(...listFilesRec(p));
-    else if (entry.isFile())
-      out.push(p);
+  for (const entry of readdirSync5(arcDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink())
+      continue;
+    const pkgDir = join9(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;
 }
+async function copyBrowserAssets(ws, cache, noCache) {
+  mkdirSync7(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) => join9(ws.assetsDir, a.to));
+  if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
+    console.log(`  \u2713 cached: browser-assets (${assets.length})`);
+    return;
+  }
+  console.log(`  building: browser-assets (${assets.length})`);
+  const outputHashes = {};
+  for (const asset of assets) {
+    const dest = join9(ws.assetsDir, asset.to);
+    mkdirSync7(dirname6(dest), { recursive: true });
+    copyFileSync(asset.src, dest);
+    outputHashes[asset.to] = sha256Hex(readFileSync8(dest));
+  }
+  updateCache(cache, unitId, inputHash, { outputHashes });
+}
 function collectArcPeerDeps(packages) {
   const seen = new Set;
   for (const pkg of ["@arcote.tech/arc", "@arcote.tech/arc-ds", "@arcote.tech/arc-react", "@arcote.tech/platform"]) {
@@ -27026,14 +27348,10 @@ function collectArcPeerDeps(packages) {
     return [short, pkg];
   });
 }
-async function buildShell(outDir, packages) {
-  mkdirSync6(outDir, { recursive: true });
-  const tmpDir = join7(outDir, "_tmp");
-  mkdirSync6(tmpDir, { recursive: true });
-  const reactEntries = [
-    [
-      "react",
-      `import React from "react";
+var REACT_ENTRIES = [
+  [
+    "react",
+    `import React from "react";
 export default React;
 export const {
   Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense,
@@ -27043,84 +27361,133 @@ 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";`
+  ]
+];
+var REACT_OUTPUT_FILES = REACT_ENTRIES.map(([n]) => `${n}.js`);
+var SHELL_BASE_EXTERNAL = [
+  "react",
+  "react-dom",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react-dom/client"
+];
+var sourceFilter2 = (rel) => {
+  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, pkg) {
+  const srcDir = join9(rootDir, "node_modules", pkg, "src");
+  if (existsSync8(srcDir))
+    return sha256OfDir(srcDir, sourceFilter2);
+  return sha256OfDir(join9(rootDir, "node_modules", pkg), sourceFilter2);
+}
+async function buildShellReact(shellDir, tmpDir, rootDir, cache, noCache) {
+  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) => join9(shellDir, f));
+  if (!noCache && isCacheHit(cache, unitId, inputHash, requiredOutputs)) {
+    console.log(`  \u2713 cached: shell:react`);
+    return;
+  }
+  console.log(`  building: shell:react`);
   const reactEps = [];
-  for (const [name, code] of reactEntries) {
-    const f = join7(tmpDir, `${name}.ts`);
-    Bun.write(f, code);
+  for (const [name, code] of REACT_ENTRIES) {
+    const f = join9(tmpDir, `${name}.ts`);
+    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)
+  if (!r.success) {
+    for (const l of r.logs)
       console.error(l);
     throw new Error("Shell React build failed");
   }
-  const arcEntries = packages ? collectArcPeerDeps(packages) : [
-    ["arc", "@arcote.tech/arc"],
-    ["arc-ds", "@arcote.tech/arc-ds"],
-    ["arc-react", "@arcote.tech/arc-react"],
-    ["platform", "@arcote.tech/platform"]
-  ];
-  const baseExternal = [
-    "react",
-    "react-dom",
-    "react/jsx-runtime",
-    "react/jsx-dev-runtime",
-    "react-dom/client"
-  ];
-  const allArcPkgs = arcEntries.map(([, pkg]) => pkg);
-  for (const [name, pkg] of arcEntries) {
-    const f = join7(tmpDir, `${name}.ts`);
-    Bun.write(f, `export * from "${pkg}";
+  const outputHash = sha256OfFiles(requiredOutputs);
+  updateCache(cache, unitId, inputHash, { outputHash });
+}
+async function buildShellArcEntry(shortName, pkg, allArcPkgs, shellDir, tmpDir, rootDir, cache, noCache) {
+  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 = join9(shellDir, `${shortName}.js`);
+  if (!noCache && isCacheHit(cache, unitId, inputHash, [outputFile])) {
+    console.log(`  \u2713 cached: ${unitId}`);
+    return;
+  }
+  console.log(`  building: ${unitId}`);
+  const f = join9(tmpDir, `${shortName}.ts`);
+  await Bun.write(f, `export * from "${pkg}";
 `);
-    const r2 = await Bun.build({
-      entrypoints: [f],
-      outdir: outDir,
-      format: "esm",
-      target: "browser",
-      naming: "[name].[ext]",
-      external: [
-        ...baseExternal,
-        ...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}`);
+  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 { rmSync } = await import("fs");
-  rmSync(tmpDir, { recursive: true, force: true });
+  const outputHash = sha256OfFiles([outputFile]);
+  updateCache(cache, unitId, inputHash, { outputHash });
+}
+async function buildShell(ws, cache, noCache) {
+  mkdirSync7(ws.shellDir, { recursive: true });
+  const tmpDir = join9(ws.shellDir, "_tmp");
+  mkdirSync7(tmpDir, { recursive: true });
+  const arcEntries = collectArcPeerDeps(ws.packages);
+  const allArcPkgs = arcEntries.map(([, pkg]) => pkg);
+  const tasks = [
+    () => 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);
+  rmSync2(tmpDir, { recursive: true, force: true });
 }
 async function loadServerContext(packages) {
   const ctxPackages = packages.filter((p) => isContextPackage(p.packageJson));
@@ -27129,13 +27496,13 @@ async function loadServerContext(packages) {
   globalThis.ONLY_SERVER = true;
   globalThis.ONLY_BROWSER = false;
   globalThis.ONLY_CLIENT = false;
-  const platformDir = join7(process.cwd(), "node_modules", "@arcote.tech", "platform");
-  const platformPkg = JSON.parse(readFileSync6(join7(platformDir, "package.json"), "utf-8"));
-  const platformEntry = join7(platformDir, platformPkg.main ?? "src/index.ts");
+  const platformDir = join9(process.cwd(), "node_modules", "@arcote.tech", "platform");
+  const platformPkg = JSON.parse(readFileSync8(join9(platformDir, "package.json"), "utf-8"));
+  const platformEntry = join9(platformDir, platformPkg.main ?? "src/index.ts");
   await import(platformEntry);
   for (const ctx of ctxPackages) {
-    const serverDist = join7(ctx.path, "dist", "server", "main", "index.js");
-    if (!existsSync6(serverDist)) {
+    const serverDist = join9(ctx.path, "dist", "server", "main", "index.js");
+    if (!existsSync8(serverDist)) {
       err(`Context server dist not found: ${serverDist}`);
       continue;
     }
@@ -27159,26 +27526,26 @@ async function loadServerContext(packages) {
 }
 
 // src/commands/platform-build.ts
-async function platformBuild() {
+async function platformBuild(opts = {}) {
   const ws = resolveWorkspace();
-  const manifest = await buildAll(ws);
+  const manifest = await buildAll(ws, { noCache: opts.noCache });
   ok(`Platform built \u2014 ${manifest.modules.length} module(s)`);
 }
 
 // src/commands/platform-deploy.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 
 // src/deploy/bootstrap.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 
 // src/deploy/ansible.ts
 var {spawn: spawn2 } = globalThis.Bun;
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
 import { tmpdir } from "os";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 
 // src/deploy/assets.ts
 var TERRAFORM_MAIN_TF = `terraform {
@@ -27435,18 +27802,18 @@ var ASSETS = {
   }
 };
 async function materializeAssets(targetDir, files) {
-  const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync7 } = await import("fs");
-  const { join: join8 } = await import("path");
-  mkdirSync7(targetDir, { recursive: true });
+  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync8 } = await import("fs");
+  const { join: join10 } = await import("path");
+  mkdirSync8(targetDir, { recursive: true });
   for (const [name, content] of Object.entries(files)) {
-    writeFileSync7(join8(targetDir, name), content);
+    writeFileSync8(join10(targetDir, name), content);
   }
 }
 
 // src/deploy/ansible.ts
 async function runAnsible(inputs) {
-  const workDir = join8(tmpdir(), "arc-deploy", `ansible-${Date.now()}`);
-  mkdirSync7(workDir, { recursive: true });
+  const workDir = join10(tmpdir(), "arc-deploy", `ansible-${Date.now()}`);
+  mkdirSync8(workDir, { recursive: true });
   await materializeAssets(workDir, ASSETS.ansible);
   const user = inputs.asRoot ? "root" : inputs.target.user;
   const port = inputs.ansible?.sshPort ?? inputs.target.port;
@@ -27460,7 +27827,7 @@ async function runAnsible(inputs) {
     ""
   ].join(`
 `);
-  writeFileSync7(join8(workDir, "inventory.ini"), inventory);
+  writeFileSync8(join10(workDir, "inventory.ini"), inventory);
   const extraVars = [
     `username=${inputs.target.user}`,
     `ssh_port=${port}`
@@ -27585,15 +27952,15 @@ function generateCompose({ cfg }) {
 
 // src/deploy/terraform.ts
 var {spawn: spawn3 } = globalThis.Bun;
-import { existsSync as existsSync7, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 async function runTerraform(inputs) {
-  const workDir = join9(tmpdir2(), "arc-deploy", `tf-${Date.now()}`);
-  mkdirSync8(workDir, { recursive: true });
+  const workDir = join11(tmpdir2(), "arc-deploy", `tf-${Date.now()}`);
+  mkdirSync9(workDir, { recursive: true });
   await materializeAssets(workDir, ASSETS.terraform);
   const sshPubKey = inputs.tf.sshPublicKey ?? expandHome("~/.ssh/id_ed25519.pub");
-  if (!existsSync7(expandHome(sshPubKey))) {
+  if (!existsSync9(expandHome(sshPubKey))) {
     throw new Error(`SSH public key not found at ${sshPubKey}. Set provision.terraform.sshPublicKey in deploy.arc.json.`);
   }
   const tfvars = [
@@ -27606,7 +27973,7 @@ async function runTerraform(inputs) {
   ].join(`
 `) + `
 `;
-  writeFileSync8(join9(workDir, "terraform.tfvars"), tfvars);
+  writeFileSync9(join11(workDir, "terraform.tfvars"), tfvars);
   await runTf(workDir, ["init", "-input=false", "-no-color"]);
   await runTf(workDir, [
     "apply",
@@ -27658,21 +28025,21 @@ function expandHome(p) {
 }
 
 // src/deploy/config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { join as join12 } from "path";
 var DEPLOY_CONFIG_FILE = "deploy.arc.json";
 function deployConfigPath(rootDir) {
-  return join10(rootDir, DEPLOY_CONFIG_FILE);
+  return join12(rootDir, DEPLOY_CONFIG_FILE);
 }
 function deployConfigExists(rootDir) {
-  return existsSync8(deployConfigPath(rootDir));
+  return existsSync10(deployConfigPath(rootDir));
 }
 function loadDeployConfig(rootDir) {
   const path4 = deployConfigPath(rootDir);
-  if (!existsSync8(path4)) {
+  if (!existsSync10(path4)) {
     throw new Error(`Missing ${DEPLOY_CONFIG_FILE} at ${path4}`);
   }
-  const raw = readFileSync7(path4, "utf-8");
+  const raw = readFileSync9(path4, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -27683,7 +28050,7 @@ function loadDeployConfig(rootDir) {
   return validateDeployConfig(expanded);
 }
 function saveDeployConfig(rootDir, cfg) {
-  writeFileSync9(deployConfigPath(rootDir), JSON.stringify(cfg, null, 2) + `
+  writeFileSync10(deployConfigPath(rootDir), JSON.stringify(cfg, null, 2) + `
 `);
 }
 var VAR_REGEX = /\$\{([A-Z0-9_]+)\}|\$([A-Z0-9_]+)/g;
@@ -28083,22 +28450,22 @@ async function bootstrap(inputs) {
 }
 async function upStack(inputs) {
   const { cfg } = inputs;
-  const workDir = join11(tmpdir3(), "arc-deploy", `stack-${Date.now()}`);
-  mkdirSync9(workDir, { recursive: true });
-  writeFileSync10(join11(workDir, "Caddyfile"), generateCaddyfile(cfg));
-  writeFileSync10(join11(workDir, "docker-compose.yml"), generateCompose({ cfg }));
+  const workDir = join13(tmpdir3(), "arc-deploy", `stack-${Date.now()}`);
+  mkdirSync10(workDir, { recursive: true });
+  writeFileSync11(join13(workDir, "Caddyfile"), generateCaddyfile(cfg));
+  writeFileSync11(join13(workDir, "docker-compose.yml"), generateCompose({ cfg }));
   await assertExec(cfg.target, `sudo mkdir -p ${cfg.target.remoteDir} && sudo chown ${cfg.target.user}:${cfg.target.user} ${cfg.target.remoteDir}`);
   for (const name of Object.keys(cfg.envs)) {
     await assertExec(cfg.target, `mkdir -p ${cfg.target.remoteDir}/${name}`);
   }
-  await scpUpload(cfg.target, join11(workDir, "Caddyfile"), `${cfg.target.remoteDir}/Caddyfile`);
-  await scpUpload(cfg.target, join11(workDir, "docker-compose.yml"), `${cfg.target.remoteDir}/docker-compose.yml`);
+  await scpUpload(cfg.target, join13(workDir, "Caddyfile"), `${cfg.target.remoteDir}/Caddyfile`);
+  await scpUpload(cfg.target, join13(workDir, "docker-compose.yml"), `${cfg.target.remoteDir}/docker-compose.yml`);
   await assertExec(cfg.target, `cd ${cfg.target.remoteDir} && docker compose pull --ignore-pull-failures && docker compose up -d`);
 }
 
 // src/deploy/remote-sync.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { join as join12, relative as relative3 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join14, relative as relative4 } from "path";
 function diffManifests(local, remote) {
   const remoteByName = new Map(remote.modules.map((m) => [m.name, m]));
   const changedModules = local.modules.filter((m) => remoteByName.get(m.name)?.hash !== m.hash);
@@ -28115,11 +28482,11 @@ async function syncEnv(inputs) {
     throw new Error(`Unknown env: ${env2}`);
   const remotePath = `${cfg.target.remoteDir}/${env2}`;
   await rsyncDir(cfg.target, projectDir, remotePath);
-  const localManifestPath = join12(ws.modulesDir, "manifest.json");
-  if (!existsSync9(localManifestPath)) {
+  const localManifestPath = join14(ws.modulesDir, "manifest.json");
+  if (!existsSync11(localManifestPath)) {
     throw new Error(`Local build missing at ${localManifestPath}. Run arc platform build first.`);
   }
-  const localManifest = JSON.parse(readFileSync8(localManifestPath, "utf-8"));
+  const localManifest = JSON.parse(readFileSync10(localManifestPath, "utf-8"));
   const localPort = 15500 + hashEnvToOffset(env2);
   const tunnel = await openTunnel(cfg.target, localPort, "127.0.0.1", 2019);
   try {
@@ -28134,8 +28501,8 @@ async function syncEnv(inputs) {
       const shellFiles = collectFiles(ws.shellDir);
       const form = new FormData;
       for (const absPath of shellFiles) {
-        const rel = relative3(ws.shellDir, absPath);
-        form.append(rel, new Blob([readFileSync8(absPath)]), rel);
+        const rel = relative4(ws.shellDir, absPath);
+        form.append(rel, new Blob([readFileSync10(absPath)]), rel);
       }
       const res2 = await fetch(`${base2}/api/deploy/shell`, {
         method: "POST",
@@ -28147,9 +28514,9 @@ async function syncEnv(inputs) {
     if (diff.stylesChanged) {
       const form = new FormData;
       for (const name of ["styles.css", "theme.css"]) {
-        const p = join12(ws.arcDir, name);
-        if (existsSync9(p)) {
-          form.append(name, new Blob([readFileSync8(p)]), name);
+        const p = join14(ws.arcDir, name);
+        if (existsSync11(p)) {
+          form.append(name, new Blob([readFileSync10(p)]), name);
         }
       }
       const res2 = await fetch(`${base2}/api/deploy/shell`, {
@@ -28162,8 +28529,8 @@ async function syncEnv(inputs) {
     if (diff.changedModules.length > 0) {
       const form = new FormData;
       for (const mod of diff.changedModules) {
-        const p = join12(ws.modulesDir, mod.file);
-        form.append(mod.file, new Blob([readFileSync8(p)]), mod.file);
+        const p = join14(ws.modulesDir, mod.file);
+        form.append(mod.file, new Blob([readFileSync10(p)]), mod.file);
       }
       const res2 = await fetch(`${base2}/api/deploy/modules`, {
         method: "POST",
@@ -28190,12 +28557,12 @@ async function syncEnv(inputs) {
   }
 }
 function collectFiles(dir) {
-  if (!existsSync9(dir))
+  if (!existsSync11(dir))
     return [];
-  const { readdirSync: readdirSync5 } = __require("fs");
+  const { readdirSync: readdirSync6 } = __require("fs");
   const out = [];
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const p = join12(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const p = join14(dir, entry.name);
     if (entry.isDirectory())
       out.push(...collectFiles(p));
     else if (entry.isFile())
@@ -28907,13 +29274,13 @@ async function platformDeploy(envArg, options = {}) {
     err(`Unknown env "${envArg}". Known: ${Object.keys(cfg.envs).join(", ")}`);
     process.exit(1);
   })() : Object.keys(cfg.envs);
-  const manifestPath = join13(ws.modulesDir, "manifest.json");
-  const needBuild = options.rebuild || !existsSync10(manifestPath);
+  const manifestPath = join15(ws.modulesDir, "manifest.json");
+  const needBuild = options.rebuild || !existsSync12(manifestPath);
   if (needBuild && !options.skipBuild) {
     log2("Building platform...");
-    await buildAll(ws);
+    await buildAll(ws, { noCache: options.rebuild });
     ok("Build complete");
-  } else if (!existsSync10(manifestPath)) {
+  } else if (!existsSync12(manifestPath)) {
     err("No build found and --skip-build was set.");
     process.exit(1);
   }
@@ -28956,24 +29323,24 @@ async function platformDeploy(envArg, options = {}) {
 }
 function readCliVersion() {
   try {
-    const pkgPath = join13(import.meta.dir, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkgPath = join15(import.meta.dir, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
   }
 }
 async function hashDeployConfig(rootDir) {
-  const p2 = join13(rootDir, "deploy.arc.json");
-  const content = readFileSync9(p2);
+  const p2 = join15(rootDir, "deploy.arc.json");
+  const content = readFileSync11(p2);
   const hasher = new Bun.CryptoHasher("sha256");
   hasher.update(content);
   return hasher.digest("hex").slice(0, 16);
 }
 
 // src/commands/platform-dev.ts
-import { existsSync as existsSync13, watch } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, watch } from "fs";
+import { join as join18 } from "path";
 
 // ../host/src/create-server.ts
 var import_jsonwebtoken = __toESM(require_jsonwebtoken(), 1);
@@ -30292,7 +30659,10 @@ async function createArcServer(config) {
       "Access-Control-Allow-Origin": origin,
       "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
       "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Arc-Scope, X-Arc-Tokens",
-      "Access-Control-Allow-Credentials": "true"
+      "Access-Control-Allow-Credentials": "true",
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cross-Origin-Resource-Policy": "cross-origin"
     };
   }
   const corsHeaders = buildCorsHeaders();
@@ -30420,12 +30790,12 @@ async function createArcServer(config) {
   };
 }
 // src/platform/server.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12 } from "fs";
+import { join as join17 } from "path";
 
 // src/platform/deploy-api.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname7, join as join14, normalize as normalize2, relative as relative4, resolve } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname7, join as join16, normalize as normalize2, relative as relative5, resolve } from "path";
 function createDeployApiHandler(opts) {
   return async (req, url, ctx) => {
     const p3 = url.pathname;
@@ -30442,7 +30812,7 @@ function createDeployApiHandler(opts) {
       if (!validateManifest(body)) {
         return Response.json({ error: "Invalid manifest body" }, { status: 400, headers: ctx.corsHeaders });
       }
-      writeFileSync11(join14(opts.ws.modulesDir, "manifest.json"), JSON.stringify(body, null, 2));
+      writeFileSync12(join16(opts.ws.modulesDir, "manifest.json"), JSON.stringify(body, null, 2));
       opts.setManifest(body);
       opts.notifyReload(body);
       return Response.json({ ok: true, moduleCount: body.modules.length }, { headers: ctx.corsHeaders });
@@ -30468,8 +30838,8 @@ function createDeployApiHandler(opts) {
       const writtenShell = await writeUploadedFileList(shellFiles, opts.ws.shellDir);
       const writtenRoot = [];
       for (const { name, file } of rootFiles) {
-        const target = join14(opts.ws.arcDir, name);
-        writeFileSync11(target, Buffer.from(await file.arrayBuffer()));
+        const target = join16(opts.ws.arcDir, name);
+        writeFileSync12(target, Buffer.from(await file.arrayBuffer()));
         writtenRoot.push(name);
       }
       return Response.json({ ok: true, written: [...writtenShell, ...writtenRoot] }, { headers: ctx.corsHeaders });
@@ -30494,16 +30864,16 @@ function isFile(v3) {
 async function writeUploadedFileList(files, targetDir) {
   const written = [];
   const safeRoot = resolve(targetDir);
-  mkdirSync10(safeRoot, { recursive: true });
+  mkdirSync11(safeRoot, { recursive: true });
   for (const file of files) {
     const rel = normalize2(file.name);
     const full = resolve(safeRoot, rel);
     if (!full.startsWith(safeRoot + "/") && full !== safeRoot) {
       throw new Error(`Path traversal rejected: ${file.name}`);
     }
-    mkdirSync10(dirname7(full), { recursive: true });
-    writeFileSync11(full, Buffer.from(await file.arrayBuffer()));
-    written.push(relative4(safeRoot, full) || rel);
+    mkdirSync11(dirname7(full), { recursive: true });
+    writeFileSync12(full, Buffer.from(await file.arrayBuffer()));
+    written.push(relative5(safeRoot, full) || rel);
   }
   return written;
 }
@@ -30570,14 +30940,15 @@ var MIME = {
   ".ico": "image/x-icon",
   ".woff2": "font/woff2",
   ".woff": "font/woff",
-  ".ttf": "font/ttf"
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm"
 };
 function getMime(path4) {
   const ext2 = path4.substring(path4.lastIndexOf("."));
   return MIME[ext2] ?? "application/octet-stream";
 }
 function serveFile(filePath, headers = {}) {
-  if (!existsSync12(filePath))
+  if (!existsSync14(filePath))
     return new Response("Not Found", { status: 404 });
   return new Response(Bun.file(filePath), {
     headers: { "Content-Type": getMime(filePath), ...headers }
@@ -30666,7 +31037,7 @@ function staticFilesHandler(ws, devMode, moduleAccessMap) {
   return (_req, url, ctx) => {
     const path4 = url.pathname;
     if (path4.startsWith("/shell/"))
-      return serveFile(join15(ws.shellDir, path4.slice(7)), ctx.corsHeaders);
+      return serveFile(join17(ws.shellDir, path4.slice(7)), ctx.corsHeaders);
     if (path4.startsWith("/modules/")) {
       const fileWithParams = path4.slice(9);
       const filename = fileWithParams.split("?")[0];
@@ -30678,23 +31049,25 @@ function staticFilesHandler(ws, devMode, moduleAccessMap) {
           return new Response("Forbidden", { status: 403, headers: ctx.corsHeaders });
         }
       }
-      return serveFile(join15(ws.modulesDir, filename), {
+      return serveFile(join17(ws.modulesDir, filename), {
         ...ctx.corsHeaders,
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable"
       });
     }
     if (path4.startsWith("/locales/"))
-      return serveFile(join15(ws.arcDir, path4.slice(1)), ctx.corsHeaders);
+      return serveFile(join17(ws.arcDir, path4.slice(1)), ctx.corsHeaders);
+    if (path4.startsWith("/assets/"))
+      return serveFile(join17(ws.assetsDir, path4.slice(8)), ctx.corsHeaders);
     if (path4 === "/styles.css")
-      return serveFile(join15(ws.arcDir, "styles.css"), ctx.corsHeaders);
+      return serveFile(join17(ws.arcDir, "styles.css"), ctx.corsHeaders);
     if (path4 === "/theme.css")
-      return serveFile(join15(ws.arcDir, "theme.css"), ctx.corsHeaders);
+      return serveFile(join17(ws.arcDir, "theme.css"), ctx.corsHeaders);
     if ((path4 === "/manifest.json" || path4 === "/manifest.webmanifest") && ws.manifest) {
       return serveFile(ws.manifest.path, ctx.corsHeaders);
     }
     if (path4.lastIndexOf(".") > path4.lastIndexOf("/")) {
-      const publicFile = join15(ws.publicDir, path4.slice(1));
-      if (existsSync12(publicFile))
+      const publicFile = join17(ws.publicDir, path4.slice(1));
+      if (existsSync14(publicFile))
         return serveFile(publicFile, ctx.corsHeaders);
     }
     return null;
@@ -30791,7 +31164,10 @@ async function startPlatformServer(opts) {
     const cors = {
       "Access-Control-Allow-Origin": "*",
       "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Arc-Tokens"
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Arc-Tokens",
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cross-Origin-Resource-Policy": "cross-origin"
     };
     const server = Bun.serve({
       port,
@@ -30829,10 +31205,10 @@ async function startPlatformServer(opts) {
     };
   }
   const { createBunSQLiteAdapterFactory: createBunSQLiteAdapterFactory2 } = await Promise.resolve().then(() => (init_dist(), exports_dist2));
-  const dbPath = opts.dbPath || join15(ws.arcDir, "data", "arc.db");
+  const dbPath = opts.dbPath || join17(ws.arcDir, "data", "arc.db");
   const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
   if (dbDir)
-    mkdirSync11(dbDir, { recursive: true });
+    mkdirSync12(dbDir, { recursive: true });
   const arcServer = await createArcServer({
     context,
     dbAdapterFactory: createBunSQLiteAdapterFactory2(dbPath),
@@ -30857,10 +31233,10 @@ async function startPlatformServer(opts) {
 }
 
 // src/commands/platform-dev.ts
-async function platformDev() {
+async function platformDev(opts = {}) {
   const ws = resolveWorkspace();
   const port = 5005;
-  let manifest = await buildAll(ws);
+  let manifest = await buildAll(ws, { noCache: opts.noCache });
   log2("Loading server context...");
   const { context, moduleAccess } = await loadServerContext(ws.packages);
   if (context) {
@@ -30875,7 +31251,7 @@ async function platformDev() {
     manifest,
     context,
     moduleAccess,
-    dbPath: join16(ws.rootDir, ".arc", "data", "dev.db"),
+    dbPath: join18(ws.rootDir, ".arc", "data", "dev.db"),
     devMode: true,
     arcEntries
   });
@@ -30885,53 +31261,44 @@ async function platformDev() {
   log2("Watching for changes...");
   let rebuildTimer = null;
   let isRebuilding = false;
+  const triggerRebuild = () => {
+    if (rebuildTimer)
+      clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(async () => {
+      if (isRebuilding)
+        return;
+      isRebuilding = true;
+      log2("Rebuilding...");
+      try {
+        manifest = await buildAll(ws);
+        platform3.setManifest(manifest);
+        platform3.notifyReload(manifest);
+        ok(`Rebuilt \u2014 ${manifest.modules.length} module(s)`);
+      } catch (e2) {
+        console.error(`Rebuild failed: ${e2}`);
+      } finally {
+        isRebuilding = false;
+      }
+    }, 300);
+  };
   for (const pkg of ws.packages) {
-    const srcDir = join16(pkg.path, "src");
-    if (!existsSync13(srcDir))
+    const srcDir = join18(pkg.path, "src");
+    if (!existsSync15(srcDir))
       continue;
     watch(srcDir, { recursive: true }, (_event, filename) => {
       if (!filename || filename.includes(".arc") || filename.endsWith(".d.ts") || filename.includes("node_modules") || filename.includes("dist"))
         return;
       if (!filename.endsWith(".ts") && !filename.endsWith(".tsx"))
         return;
-      if (rebuildTimer)
-        clearTimeout(rebuildTimer);
-      rebuildTimer = setTimeout(async () => {
-        if (isRebuilding)
-          return;
-        isRebuilding = true;
-        log2("Rebuilding...");
-        try {
-          manifest = await buildPackages(ws.rootDir, ws.modulesDir, ws.packages);
-          await buildStyles(ws.rootDir, ws.arcDir);
-          platform3.setManifest(manifest);
-          platform3.notifyReload(manifest);
-          ok(`Rebuilt ${manifest.modules.length} module(s)`);
-        } catch (e2) {
-          console.error(`Rebuild failed: ${e2}`);
-        } finally {
-          isRebuilding = false;
-        }
-      }, 300);
+      triggerRebuild();
     });
   }
-  const localesDir = join16(ws.rootDir, "locales");
-  if (existsSync13(localesDir)) {
-    let poTimer = null;
+  const localesDir = join18(ws.rootDir, "locales");
+  if (existsSync15(localesDir)) {
     watch(localesDir, { recursive: false }, (_event, filename) => {
       if (!filename?.endsWith(".po"))
         return;
-      if (poTimer)
-        clearTimeout(poTimer);
-      poTimer = setTimeout(async () => {
-        try {
-          compileAllCatalogs(localesDir, join16(ws.arcDir, "locales"));
-          ok("Translations recompiled");
-          platform3.notifyReload(manifest);
-        } catch (e2) {
-          console.error(`Translation compile failed: ${e2}`);
-        }
-      }, 200);
+      triggerRebuild();
     });
   }
   const cleanup = () => {
@@ -30943,17 +31310,17 @@ async function platformDev() {
 }
 
 // src/commands/platform-start.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
+import { join as join19 } from "path";
 async function platformStart() {
   const ws = resolveWorkspace();
   const port = parseInt(process.env.PORT || "5005", 10);
-  const manifestPath = join17(ws.modulesDir, "manifest.json");
-  if (!existsSync14(manifestPath)) {
+  const manifestPath = join19(ws.modulesDir, "manifest.json");
+  if (!existsSync16(manifestPath)) {
     err("No build found. Run `arc platform build` first.");
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
   log2("Loading server context...");
   const { context, moduleAccess } = await loadServerContext(ws.packages);
   if (context) {
@@ -30971,7 +31338,7 @@ async function platformStart() {
     manifest,
     context,
     moduleAccess,
-    dbPath: join17(ws.rootDir, ".arc", "data", "prod.db"),
+    dbPath: join19(ws.rootDir, ".arc", "data", "prod.db"),
     devMode: false,
     deployApi,
     arcEntries
@@ -30993,8 +31360,8 @@ program2.name("arc").description("CLI tool for Arc framework").version("0.0.3");
 program2.command("dev").description("Run development mode for Arc framework").action(dev);
 program2.command("build").description("Build all clients and declarations").action(build);
 var platform3 = program2.command("platform").description("Platform commands \u2014 run full stack (server + UI)");
-platform3.command("dev").description("Start platform in dev mode (Bun server + Vite HMR)").action(platformDev);
-platform3.command("build").description("Build platform for production").action(platformBuild);
+platform3.command("dev").description("Start platform in dev mode (Bun server + Vite HMR)").option("--no-cache", "Force full rebuild on startup").action((opts) => platformDev({ noCache: opts.cache === false }));
+platform3.command("build").description("Build platform for production").option("--no-cache", "Force full rebuild").action((opts) => platformBuild({ noCache: opts.cache === false }));
 platform3.command("start").description("Start platform in production mode (requires prior build)").action(platformStart);
 platform3.command("deploy [env]").description("Deploy platform to a remote server (reads deploy.arc.json, surveys if missing)").option("--skip-build", "Skip local build step").option("--rebuild", "Force rebuild before deploy").action((env2, opts) => platformDeploy(env2, opts));
 program2.parse(process.argv);