@arcote.tech/arc-cli 0.5.6 → 0.5.8

package/src/builder/module-builder.ts

@@ -4,18 +4,32 @@ import {
   mkdirSync,
   readFileSync,
   readdirSync,
+  rmSync,
   writeFileSync,
 } from "fs";
-import { dirname, join, relative } from "path";
+import { basename, dirname, join, relative } from "path";
 import type { BuildManifest, ModuleDescriptor } from "@arcote.tech/platform";
-import {
-  buildTypeDeclarations,
-  type DeclarationResult,
-} from "../utils/build";
+import { buildTypeDeclarations } from "../utils/build";
 import { i18nExtractPlugin, finalizeTranslations } from "../i18n";
+import { compileAllCatalogs } from "../i18n/compile";
+import {
+  isCacheHit,
+  updateCache,
+  type BuildCache,
+} from "./build-cache";
+import {
+  readInstalledVersion,
+  sha256Hex,
+  sha256OfDir,
+  sha256OfFiles,
+  sha256OfJson,
+} from "./hash";
+import { pAll } from "./parallel";
 
 /** Re-export for internal CLI consumers (avoid direct platform dependency in consumers). */
 export type { BuildManifest, ModuleDescriptor };
+/** Re-export hash helpers for backward compatibility (deploy/remote-sync uses sha256OfFiles). */
+export { sha256Hex, sha256OfFiles };
 
 /** Clients that a context package is built for. */
 const CONTEXT_CLIENTS = [
@@ -23,62 +37,6 @@ const CONTEXT_CLIENTS = [
   { name: "browser", target: "browser" as const, defines: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" } },
 ];
 
-/**
- * Build a context package (browser/server split) using Bun.build directly,
- * then generate .d.ts declarations via tsgo (with tsc fallback).
- *
- * Returns declaration errors (if any) so the caller can display them.
- */
-async function buildContextPackage(
-  pkg: WorkspacePackage,
-): Promise<{ declarationErrors: string[] }> {
-  const entrypoint = pkg.entrypoint;
-  const outDir = join(pkg.path, "dist");
-  const peerDeps = Object.keys(pkg.packageJson.peerDependencies || {});
-  const deps = Object.keys(pkg.packageJson.dependencies || {});
-  const externals = [...peerDeps, ...deps];
-  const allDeclErrors: string[] = [];
-
-  for (const client of CONTEXT_CLIENTS) {
-    // JS bundle
-    const result = await Bun.build({
-      entrypoints: [entrypoint],
-      outdir: join(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 log of result.logs) console.error(log);
-      throw new Error(`${client.name} build failed for ${pkg.name}`);
-    }
-
-    // Type declarations — globals match the define values
-    const globalsContent = Object.entries(client.defines)
-      .map(([k, v]) => `declare const ${k}: ${v};`)
-      .join("\n");
-
-    const declResult = await buildTypeDeclarations(
-      [entrypoint],
-      join(outDir, client.name),
-      dirname(entrypoint),
-      globalsContent,
-    );
-
-    if (!declResult.success && declResult.errors.length > 0) {
-      allDeclErrors.push(
-        ...declResult.errors.map((e) => `[${pkg.name}/${client.name}] ${e}`),
-      );
-    }
-  }
-
-  return { declarationErrors: allDeclErrors };
-}
-
 /** Packages that shell provides — modules import them but don't bundle them. */
 export const SHELL_EXTERNALS = [
   "react",
@@ -104,26 +62,9 @@ export interface WorkspacePackage {
 /** @deprecated use ModuleDescriptor from @arcote.tech/platform */
 export type ModuleEntry = ModuleDescriptor;
 
-/**
- * sha256 hex of bytes. Uses Bun.CryptoHasher which is always available in the CLI runtime.
- */
-export function sha256Hex(bytes: Uint8Array | ArrayBuffer | string): string {
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(bytes as any);
-  return hasher.digest("hex");
-}
-
-/** Hash of concatenated file contents in a directory (stable order). */
-export function sha256OfFiles(paths: readonly string[]): string {
-  const hasher = new Bun.CryptoHasher("sha256");
-  const sorted = [...paths].sort();
-  for (const p of sorted) {
-    if (!existsSync(p)) continue;
-    hasher.update(readFileSync(p));
-    hasher.update("\0");
-  }
-  return hasher.digest("hex");
-}
+// ---------------------------------------------------------------------------
+// Discovery
+// ---------------------------------------------------------------------------
 
 /**
  * Discover workspace packages from root package.json.
@@ -155,7 +96,6 @@ export function discoverPackages(rootDir: string): WorkspacePackage[] {
       const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
       if (pkg.name?.startsWith("@arcote.tech/")) continue;
 
-      // Find entrypoint: src/index.ts, src/index.tsx, or root index.ts
       const pkgDir = join(baseDir, entry);
       const candidates = [
         join(pkgDir, "src", "index.ts"),
@@ -192,147 +132,333 @@ export function isContextPackage(pkg: Record<string, any>): boolean {
   return false;
 }
 
+// ---------------------------------------------------------------------------
+// Hash helpers (per-package source / dep version)
+// ---------------------------------------------------------------------------
+
+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;
+};
+
+const tsxOnlyFilter = (rel: string): boolean => {
+  if (!sourceFilter(rel)) return false;
+  // Allow directories (we cannot tell from rel alone, but walk descends regardless;
+  // we only filter at file level via extension check)
+  if (/\/$/.test(rel)) return true;
+  // Files: keep only .ts / .tsx (other dirent kinds come through as files too)
+  if (/\.(ts|tsx)$/.test(rel)) return true;
+  // Directory entries (no extension) — let them through so walker can descend
+  if (!/\.[^/]+$/.test(rel)) return true;
+  return false;
+};
+
+function pkgSourceHash(pkg: WorkspacePackage): string {
+  return sha256OfDir(join(pkg.path, "src"), sourceFilter);
+}
+
+function depVersionsHash(rootDir: string, pkg: WorkspacePackage): string {
+  const peerDeps = Object.keys(pkg.packageJson.peerDependencies ?? {});
+  const deps = Object.keys(pkg.packageJson.dependencies ?? {});
+  const versions: Record<string, string | null> = {};
+  for (const dep of [...peerDeps, ...deps].sort()) {
+    versions[dep] = readInstalledVersion(rootDir, dep);
+  }
+  return sha256OfJson(versions);
+}
+
+// ---------------------------------------------------------------------------
+// Context package build — per (pkg × client) cacheable unit
+// ---------------------------------------------------------------------------
+
+interface ContextClientResult {
+  pkgName: string;
+  client: string;
+  declarationErrors: string[];
+  cached: boolean;
+}
+
+async function buildContextClient(
+  pkg: WorkspacePackage,
+  rootDir: string,
+  client: typeof CONTEXT_CLIENTS[number],
+  cache: BuildCache,
+  noCache: boolean,
+): Promise<ContextClientResult> {
+  const unitId = `context-pkg:${pkg.name}:${client.name}`;
+  const outDir = join(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, [join(outDir, "main", "index.js")])) {
+    console.log(`  ✓ cached: ${pkg.name} (${client.name})`);
+    return { pkgName: pkg.name, client: client.name, declarationErrors: [], cached: 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: [pkg.entrypoint],
+    outdir: join(outDir, "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 log of result.logs) console.error(log);
+    throw new Error(`${client.name} build failed for ${pkg.name}`);
+  }
+
+  const globalsContent = Object.entries(client.defines)
+    .map(([k, v]) => `declare const ${k}: ${v};`)
+    .join("\n");
+
+  const declResult = await buildTypeDeclarations(
+    [pkg.entrypoint],
+    outDir,
+    dirname(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 };
+}
+
 /**
- * Build all workspace packages as ESM chunks using Bun.build.
- * Context packages get a wrapper that calls arc() to auto-register.
- * Regular modules already call arc() in their source.
+ * Build all context packages in parallel — each (pkg × client) is an independent task.
  */
-export async function buildPackages(
+export async function buildContextPackages(
   rootDir: string,
-  outDir: string,
   packages: WorkspacePackage[],
-): Promise<BuildManifest> {
-  mkdirSync(outDir, { recursive: true });
-
-  // Build contexts first (server/browser split via Bun.build + declarations)
+  cache: BuildCache,
+  noCache: boolean,
+): Promise<{ declarationErrors: string[] }> {
   const contexts = packages.filter((p) => isContextPackage(p.packageJson));
-  const allDeclErrors: string[] = [];
-  for (const ctx of contexts) {
-    console.log(`  Building context: ${ctx.name}`);
-    const { declarationErrors } = await buildContextPackage(ctx);
-    allDeclErrors.push(...declarationErrors);
-  }
+  if (contexts.length === 0) return { declarationErrors: [] };
+
+  const tasks = contexts.flatMap((pkg) =>
+    CONTEXT_CLIENTS.map((client) => () =>
+      buildContextClient(pkg, rootDir, client, cache, noCache),
+    ),
+  );
 
-  if (allDeclErrors.length > 0) {
+  const results = await pAll(tasks);
+  const declarationErrors = results.flatMap((r) => r.declarationErrors);
+
+  if (declarationErrors.length > 0) {
     console.warn("\n\x1b[33mType declaration errors:\x1b[0m");
-    for (const err of allDeclErrors) {
-      console.warn(`  ${err}`);
-    }
+    for (const err of declarationErrors) console.warn(`  ${err}`);
     console.warn("");
   }
 
-  // Generate wrapper entries in a tmp dir
-  const tmpDir = join(outDir, "_entries");
-  mkdirSync(tmpDir, { recursive: true });
-
-  const entrypoints: string[] = [];
-  const fileToName = new Map<string, string>(); // safeName → module name
-
-  for (const pkg of packages) {
-    const safeName = pkg.path.split("/").pop()!;
-    // Module name: strip scope (e.g. @ndt/admin → admin)
-    const moduleName = pkg.name.includes("/") ? pkg.name.split("/").pop()! : pkg.name;
-    fileToName.set(safeName, moduleName);
-
-    // All packages get a simple re-export wrapper.
-    // Context packages that use module().build() self-register via side effects.
-    // Legacy packages that export appContext will be picked up by arc(() => appContext).
-    const wrapperFile = join(tmpDir, `${safeName}.ts`);
-    writeFileSync(wrapperFile, `export * from "${pkg.name}";\n`);
-    entrypoints.push(wrapperFile);
-  }
+  return { declarationErrors };
+}
 
-  console.log(`  Bundling ${entrypoints.length} package(s)...`);
+// ---------------------------------------------------------------------------
+// Modules bundle — single Bun.build of all wrapper re-exports
+// ---------------------------------------------------------------------------
 
-  // i18n extraction — collect translatable strings during bundling
-  const i18nCollector = new Map<string, Set<string>>();
+interface ModulesBundleResult {
+  modules: ModuleDescriptor[];
+  cached: boolean;
+}
 
-  // Plugin to force all @arcote.tech/* imports as external,
-  // even when resolved through symlinks (bun link)
-  const arcExternalPlugin: import("bun").BunPlugin = {
-    name: "arc-external",
-    setup(build) {
-      build.onResolve({ filter: /^@arcote\.tech\// }, (args) => {
-        return { path: args.path, external: true };
-      });
-    },
-  };
+/**
+ * Bundle all workspace packages into ESM chunks for the platform shell.
+ * Cached as a single unit — any source change in any package invalidates.
+ */
+export async function buildModulesBundle(
+  rootDir: string,
+  outDir: string,
+  packages: WorkspacePackage[],
+  cache: BuildCache,
+  noCache: boolean,
+): Promise<ModulesBundleResult> {
+  mkdirSync(outDir, { recursive: 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",
-    },
+  const unitId = "modules-bundle";
+
+  // Per-package source hash — gives us deterministic input identity even though
+  // we run a single Bun.build for the whole bundle (chunk sharing wins).
+  const pkgHashes = packages.map((p) => ({
+    name: p.name,
+    safeName: basename(p.path),
+    srcHash: pkgSourceHash(p),
+  }));
+
+  const inputHash = sha256OfJson({
+    pkgHashes,
+    externals: SHELL_EXTERNALS,
+    define: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" },
   });
 
-  if (!result.success) {
-    console.error("Build failed:");
-    for (const log of result.logs) console.error(log);
-    throw new Error("Module build failed");
+  // Cache hit → reconstruct module descriptors from existing files in outDir.
+  if (!noCache && isCacheHit(cache, unitId, inputHash)) {
+    const existing = cache.units[unitId]?.outputHashes ?? {};
+    const modules: ModuleDescriptor[] = [];
+    for (const { safeName, name } of pkgHashes) {
+      const file = `${safeName}.js`;
+      const filePath = join(outDir, file);
+      if (!existsSync(filePath)) {
+        // Output missing despite hash match — fall through to rebuild.
+        console.log(`  rebuilding modules-bundle: output ${file} missing`);
+        return await actuallyBuild();
+      }
+      modules.push({ file, name, hash: existing[safeName] ?? sha256Hex(readFileSync(filePath)) });
+    }
+    console.log(`  ✓ cached: modules-bundle (${modules.length} module(s))`);
+    return { modules, cached: true };
   }
 
-  // Finalize translations — merge .po catalogs + compile .json
-  // outDir is modulesDir, translations JSON goes to parent (arcDir)
-  await finalizeTranslations(rootDir, join(outDir, ".."), i18nCollector);
-
-  // Clean tmp
-  const { rmSync } = await import("fs");
-  rmSync(tmpDir, { recursive: true, force: true });
-
-  // Build manifest — hash each module file for deploy diffing & client cache-bust
-  const moduleEntries: ModuleDescriptor[] = result.outputs
-    .filter((o) => o.kind === "entry-point")
-    .map((o) => {
-      const file = o.path.split("/").pop()!;
-      const safeName = file.replace(/\.js$/, "");
-      const bytes = readFileSync(o.path);
-      return {
-        file,
-        name: fileToName.get(safeName) ?? safeName,
-        hash: sha256Hex(bytes),
-      };
+  return await actuallyBuild();
+
+  async function actuallyBuild(): Promise<ModulesBundleResult> {
+    console.log(`  building: modules-bundle (${packages.length} package(s))`);
+
+    const tmpDir = join(outDir, "_entries");
+    mkdirSync(tmpDir, { recursive: true });
+
+    const entrypoints: string[] = [];
+    const fileToName = new Map<string, string>();
+
+    for (const pkg of packages) {
+      const safeName = basename(pkg.path);
+      const moduleName = pkg.name.includes("/") ? pkg.name.split("/").pop()! : pkg.name;
+      fileToName.set(safeName, moduleName);
+
+      const wrapperFile = join(tmpDir, `${safeName}.ts`);
+      writeFileSync(wrapperFile, `export * from "${pkg.name}";\n`);
+      entrypoints.push(wrapperFile);
+    }
+
+    const i18nCollector = new Map<string, Set<string>>();
+
+    const arcExternalPlugin: import("bun").BunPlugin = {
+      name: "arc-external",
+      setup(build) {
+        build.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",
+      },
     });
 
-  // shellHash / stylesHash are filled in by buildAll() after shell and styles are built.
-  const manifest: BuildManifest = {
-    modules: moduleEntries,
-    shellHash: "",
-    stylesHash: "",
-    buildTime: new Date().toISOString(),
-  };
+    if (!result.success) {
+      console.error("Modules bundle build failed:");
+      for (const log of result.logs) console.error(log);
+      throw new Error("Module build failed");
+    }
 
-  writeFileSync(
-    join(outDir, "manifest.json"),
-    JSON.stringify(manifest, null, 2),
-  );
-  return manifest;
+    // i18n extraction → write/update .po files (compileAllCatalogs handles .json).
+    await finalizeTranslations(rootDir, join(outDir, ".."), i18nCollector);
+
+    rmSync(tmpDir, { recursive: true, force: true });
+
+    const outputHashes: Record<string, string> = {};
+    const modules: ModuleDescriptor[] = result.outputs
+      .filter((o) => o.kind === "entry-point")
+      .map((o) => {
+        const file = basename(o.path);
+        const safeName = file.replace(/\.js$/, "");
+        const bytes = readFileSync(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 };
+  }
 }
 
+// ---------------------------------------------------------------------------
+// Translations — compile .po → .json as a separate cache unit
+// ---------------------------------------------------------------------------
+
 /**
- * Build CSS using tailwind CLI.
+ * Compile .po catalogs to .json. Independent cache unit — edits to .po
+ * regenerate .json without triggering a full module rebuild.
  */
-export async function buildStyles(
+export async function buildTranslations(
   rootDir: string,
-  outDir: string,
+  arcDir: string,
+  cache: BuildCache,
+  noCache: boolean,
 ): Promise<void> {
-  mkdirSync(outDir, { recursive: true });
+  const localesDir = join(rootDir, "locales");
+  if (!existsSync(localesDir)) return;
+
+  const unitId = "translations";
+  const poFiles = readdirSync(localesDir)
+    .filter((f) => f.endsWith(".po"))
+    .map((f) => join(localesDir, f));
+  if (poFiles.length === 0) return;
 
-  const inputCss = join(outDir, "_input.css");
-  const outputCss = join(outDir, "styles.css");
-  const rootRel = relative(outDir, rootDir).replace(/\\/g, "/");
+  const inputHash = sha256OfFiles(poFiles);
 
-  writeFileSync(
-    inputCss,
-    `@import "tailwindcss";
+  if (!noCache && isCacheHit(cache, unitId, inputHash, [join(arcDir, "locales")])) {
+    console.log(`  ✓ cached: translations`);
+    return;
+  }
+
+  console.log(`  building: translations (${poFiles.length} catalog(s))`);
+  compileAllCatalogs(localesDir, join(arcDir, "locales"));
+
+  const jsonFiles = readdirSync(join(arcDir, "locales"))
+    .filter((f) => f.endsWith(".json"))
+    .map((f) => join(arcDir, "locales", f));
+  const outputHash = sha256OfFiles(jsonFiles);
+  updateCache(cache, unitId, inputHash, { outputHash });
+}
+
+// ---------------------------------------------------------------------------
+// Styles (Tailwind) — cached unit
+// ---------------------------------------------------------------------------
+
+const TAILWIND_INPUT_TEMPLATE = (rootRel: string) => `@import "tailwindcss";
 @import "tw-animate-css";
 
 @source "${rootRel}/packages/*/*.{ts,tsx}";
@@ -390,12 +516,82 @@ export async function buildStyles(
     min-height: 100vh;
   }
 }
-`,
-  );
+`;
+
+/**
+ * Build styles + (optional) copy theme as a single cached unit.
+ * Theme.css is hashed as input so editing it invalidates the unit.
+ */
+export async function buildStyles(
+  rootDir: string,
+  arcDir: string,
+  packages: WorkspacePackage[],
+  themePath: string | undefined,
+  cache: BuildCache,
+  noCache: boolean,
+): Promise<void> {
+  mkdirSync(arcDir, { recursive: true });
+
+  const inputCss = join(arcDir, "_input.css");
+  const outputCss = join(arcDir, "styles.css");
+  const themeOutput = join(arcDir, "theme.css");
+  const rootRel = relative(arcDir, rootDir).replace(/\\/g, "/");
+  const inputCssContent = TAILWIND_INPUT_TEMPLATE(rootRel);
+
+  // Hash inputs: every workspace package src/, framework src/ trees, theme content,
+  // input css template content.
+  const tsxFilter = (rel: string): boolean => {
+    if (!sourceFilter(rel)) return false;
+    if (/\.[^/]+$/.test(rel) && !/\.(ts|tsx)$/.test(rel)) return false;
+    return true;
+  };
 
-  console.log("  Building CSS...");
+  const wsHashes: Record<string, string> = {};
+  for (const p of packages) {
+    wsHashes[p.name] = sha256OfDir(join(p.path, "src"), tsxFilter);
+  }
+  const platformSrc = join(rootDir, "node_modules", "@arcote.tech", "platform", "src");
+  const arcDsSrc = join(rootDir, "node_modules", "@arcote.tech", "arc-ds", "src");
+  const frameworkHashes = {
+    platform: sha256OfDir(platformSrc, tsxFilter),
+    arcDs: sha256OfDir(arcDsSrc, tsxFilter),
+  };
+  const themeContent =
+    themePath && existsSync(join(rootDir, themePath))
+      ? readFileSync(join(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(`  ✓ cached: styles`);
+    return;
+  }
+
+  console.log(`  building: styles`);
+  writeFileSync(inputCss, inputCssContent);
   execSync(`bunx @tailwindcss/cli -i ${inputCss} -o ${outputCss} --minify`, {
     cwd: rootDir,
     stdio: "inherit",
   });
+
+  // Copy theme.css if configured (output of the same unit).
+  if (themePath && themeContent) {
+    writeFileSync(themeOutput, themeContent);
+  }
+
+  const outFiles = [outputCss];
+  if (themePath && existsSync(themeOutput)) outFiles.push(themeOutput);
+  const outputHash = sha256OfFiles(outFiles);
+  updateCache(cache, unitId, inputHash, { outputHash });
 }