@blinkk/root 3.0.6 → 3.1.2

package/dist/{chunk-3EFECH2D.js → chunk-GK3TDYUY.js}

@@ -1,21 +1,23 @@
 import {
-  RouteTrie,
-  isValidTagName,
-  parseTagNames,
-  transformHtml
-} from "./chunk-7HK6F5RQ.js";
+  collectPods,
+  createViteServer,
+  preactToRootJsxPlugin,
+  rootPodsVitePlugin
+} from "./chunk-YU22SAIG.js";
 import {
-  headersMiddleware,
-  rootProjectMiddleware,
-  sessionMiddleware,
-  trailingSlashMiddleware
-} from "./chunk-6NBKAR5Y.js";
+  RouteTrie
+} from "./chunk-I3RCAIW7.js";
+import {
+  BuildAssetMap,
+  ElementGraph,
+  buildPage,
+  getElements,
+  getElementsDirs
+} from "./chunk-M3E4RKS7.js";
 import {
   bundleRootConfig,
-  collectPods,
   copyDir,
   copyGlob,
-  createViteServer,
   dirExists,
   directoryContains,
   fileExists,
@@ -27,144 +29,35 @@ import {
   loadRootConfig,
   loadRootConfigWithDeps,
   makeDir,
-  preactToRootJsxPlugin,
   rmDir,
-  rootPodsVitePlugin,
   writeFile,
   writeJson
-} from "./chunk-7PSEEE6C.js";
+} from "./chunk-KHO3HMX6.js";
 import {
   configureServerPlugins,
   getVitePlugins
 } from "./chunk-XSNCF7WU.js";
+import {
+  compressionMiddleware,
+  headersMiddleware,
+  rootProjectMiddleware,
+  securityHeadersMiddleware,
+  sessionMiddleware,
+  trailingSlashMiddleware
+} from "./chunk-TM6QRBGS.js";
 
 // src/cli/cli.ts
-import { Command, InvalidArgumentError } from "commander";
+import { Command, InvalidArgumentError, Option } from "commander";
 import { bgGreen, black } from "kleur/colors";
 
 // src/cli/build.ts
-import path3 from "node:path";
-import { fileURLToPath } from "node:url";
+import os from "node:os";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import fsExtra from "fs-extra";
-import { dim as dim2, cyan } from "kleur/colors";
-import glob2 from "tiny-glob";
-import { build as viteBuild } from "vite";
-
-// src/node/element-graph.ts
-import fs from "node:fs";
-import path from "node:path";
+import { dim as dim3, cyan as cyan2 } from "kleur/colors";
 import glob from "tiny-glob";
-import { searchForWorkspaceRoot } from "vite";
-var ElementGraph = class _ElementGraph {
-  /**
-   * Element tagName => sourceFile.
-   */
-  sourceFiles = {};
-  /**
-   * Element tagName => set of element tagName dependencies.
-   */
-  deps = {};
-  constructor(sourceFiles) {
-    this.sourceFiles = sourceFiles;
-  }
-  toJson() {
-    for (const tagName in this.sourceFiles) {
-      this.deps[tagName] ??= this.parseDepsFromSource(tagName);
-    }
-    return {
-      sourceFiles: this.sourceFiles,
-      deps: this.deps
-    };
-  }
-  static fromJson(data) {
-    const graph = new _ElementGraph(data.sourceFiles);
-    graph.deps = data.deps;
-    return graph;
-  }
-  getDeps(tagName, visited) {
-    visited ??= /* @__PURE__ */ new Set();
-    if (visited.has(tagName)) {
-      return [];
-    }
-    visited.add(tagName);
-    this.deps[tagName] ??= this.parseDepsFromSource(tagName);
-    const deps = new Set(this.deps[tagName]);
-    for (const depTagName of this.deps[tagName]) {
-      for (const childDep of this.getDeps(depTagName, visited)) {
-        deps.add(childDep);
-      }
-    }
-    return Array.from(deps);
-  }
-  /**
-   * Parses an element's source file for usage of other custom elements.
-   */
-  parseDepsFromSource(tagName) {
-    const srcFile = this.sourceFiles[tagName];
-    if (!srcFile) {
-      throw new Error(`could not find file path for tagName <${tagName}>`);
-    }
-    const src = fs.readFileSync(srcFile.filePath, "utf-8");
-    const tagNames = parseTagNames(src);
-    const deps = /* @__PURE__ */ new Set();
-    for (const depTagName of tagNames) {
-      if (depTagName !== tagName && depTagName in this.sourceFiles) {
-        deps.add(depTagName);
-      }
-    }
-    return Array.from(deps);
-  }
-};
-async function getElements(rootConfig, pods) {
-  const rootDir = rootConfig.rootDir;
-  const elementsDirs = getElementsDirs(rootConfig, pods);
-  const excludePatterns = rootConfig.elements?.exclude || [];
-  const excludeElement = (moduleId) => {
-    return excludePatterns.some((pattern) => Boolean(moduleId.match(pattern)));
-  };
-  const elementFilePaths = {};
-  for (const dirPath of elementsDirs) {
-    if (await isDirectory(dirPath)) {
-      const files = await glob("**/*", { cwd: dirPath });
-      files.forEach((file) => {
-        const parts = path.parse(file);
-        if (isJsFile(parts.base) && isValidTagName(parts.name)) {
-          const tagName = parts.name;
-          const filePath = path.join(dirPath, file);
-          const relPath = path.relative(rootDir, filePath);
-          if (!excludeElement(relPath)) {
-            elementFilePaths[tagName] = { filePath, relPath };
-          }
-        }
-      });
-    }
-  }
-  const graph = new ElementGraph(elementFilePaths);
-  return graph;
-}
-function getElementsDirs(rootConfig, pods) {
-  const rootDir = rootConfig.rootDir;
-  const workspaceRoot = searchForWorkspaceRoot(rootDir);
-  const elementsDirs = [path.join(rootDir, "elements")];
-  const elementsInclude = rootConfig.elements?.include || [];
-  for (const dirPath of elementsInclude) {
-    const elementsDir = path.resolve(rootDir, dirPath);
-    if (!directoryContains(rootDir, elementsDir)) {
-      throw new Error(
-        `the elements dir (${dirPath}) should be within the project's workspace (${workspaceRoot})`
-      );
-    }
-    elementsDirs.push(elementsDir);
-  }
-  if (pods) {
-    for (const pod of pods) {
-      for (const dir of pod.elementsDirs) {
-        elementsDirs.push(dir);
-      }
-    }
-  }
-  return elementsDirs;
-}
+import { build as viteBuild } from "vite";
 
 // src/node/vite-plugin-prune-empty-chunks.ts
 import { dim } from "kleur/colors";
@@ -231,233 +124,371 @@ function removeSideEffectImport(code, fileName) {
   return code.replace(re, "");
 }
 
-// src/render/asset-map/build-asset-map.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-var BuildAssetMap = class _BuildAssetMap {
-  rootConfig;
-  srcToAsset;
-  constructor(rootConfig) {
-    this.rootConfig = rootConfig;
-    this.srcToAsset = /* @__PURE__ */ new Map();
-  }
-  async get(src) {
-    const asset = this.srcToAsset.get(src);
-    if (asset) {
-      return asset;
-    }
-    const realSrc = realPathRelativeTo(this.rootConfig.rootDir, src);
-    if (realSrc !== src) {
-      const asset2 = this.srcToAsset.get(realSrc);
-      if (asset2) {
-        return asset2;
-      }
-    }
-    console.log(`could not find build asset: ${src}`);
-    return null;
-  }
-  add(asset) {
-    this.srcToAsset.set(asset.src, asset);
-  }
-  toJson() {
-    const result = {};
-    for (const src of this.srcToAsset.keys()) {
-      result[src] = this.srcToAsset.get(src).toJson();
+// src/utils/batch.ts
+async function batchAsyncCalls(data, concurrency, asyncFunction) {
+  const result = new Array(data.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < data.length) {
+      const index = nextIndex++;
+      result[index] = await asyncFunction(data[index]);
     }
-    return result;
   }
-  static fromViteManifest(rootConfig, clientManifest, elementsGraph, podRoutes = []) {
-    const assetMap = new _BuildAssetMap(rootConfig);
-    const elementFiles = /* @__PURE__ */ new Set();
-    Object.values(elementsGraph.sourceFiles).forEach((elementSource) => {
-      elementFiles.add(elementSource.relPath);
-      const realSrc = realPathRelativeTo(
-        rootConfig.rootDir,
-        elementSource.relPath
-      );
-      if (realSrc !== elementSource.filePath) {
-        elementFiles.add(realSrc);
-      }
-    });
-    Object.keys(clientManifest).forEach((manifestKey) => {
-      const src = manifestKey;
-      const manifestChunk = clientManifest[manifestKey];
-      const isElement = elementFiles.has(src);
-      const assetUrl = src.startsWith("routes/") && isJsFile(src) ? "" : `/${manifestChunk.file}`;
-      const assetData = {
-        src,
-        assetUrl,
-        importedModules: manifestChunk.imports || [],
-        importedCss: (manifestChunk.css || []).map((relPath) => `/${relPath}`),
-        isElement
-      };
-      assetMap.add(new BuildAsset(assetMap, assetData));
-    });
-    podRoutes.forEach((podRoute) => {
-      if (assetMap.srcToAsset.has(podRoute.src)) {
-        return;
-      }
-      const relPath = path2.relative(rootConfig.rootDir, podRoute.filePath).replace(/\\/g, "/");
-      const realPath = realPathRelativeTo(rootConfig.rootDir, relPath).replace(
-        /\\/g,
-        "/"
-      );
-      const candidateKeys = [relPath, realPath];
-      for (const key of candidateKeys) {
-        const asset = assetMap.srcToAsset.get(key);
-        if (asset) {
-          assetMap.add(
-            new BuildAsset(assetMap, {
-              ...asset.toJson(),
-              src: podRoute.src,
-              assetUrl: ""
-            })
-          );
-          break;
-        }
-      }
-    });
-    return assetMap;
-  }
-  static fromRootManifest(rootConfig, rootManifest) {
-    const assetMap = new _BuildAssetMap(rootConfig);
-    Object.keys(rootManifest).forEach((moduleId) => {
-      const assetData = rootManifest[moduleId];
-      assetMap.add(new BuildAsset(assetMap, assetData));
-    });
-    return assetMap;
-  }
-};
-function realPathRelativeTo(rootDir, src) {
-  const fullPath = path2.resolve(rootDir, src);
-  if (!fs2.existsSync(fullPath)) {
-    return src;
-  }
-  const realpath = fs2.realpathSync(path2.resolve(rootDir, src));
-  return path2.relative(rootDir, realpath);
+  const workers = Array.from(
+    { length: Math.min(concurrency, data.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return result;
 }
-var BuildAsset = class {
-  src;
-  assetUrl;
-  assetMap;
-  importedModules;
-  importedCss;
-  isElement;
-  constructor(assetMap, assetData) {
-    this.assetMap = assetMap;
-    this.src = assetData.src;
-    this.assetUrl = assetData.assetUrl;
-    this.importedModules = assetData.importedModules;
-    this.importedCss = assetData.importedCss;
-    this.isElement = assetData.isElement;
+
+// src/cli/build-progress.ts
+import { cyan, dim as dim2, green } from "kleur/colors";
+function parseBuildLogMode(value) {
+  if (value === void 0 || value === null || value === "") {
+    return "progress";
   }
-  async getCssDeps() {
-    const visited = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    await this.collectCss(this, deps, visited);
-    return Array.from(deps);
+  if (value === "progress" || value === "verbose" || value === "quiet") {
+    return value;
   }
-  async getJsDeps() {
-    const visited = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    await this.collectJs(this, deps, visited);
-    return Array.from(deps);
+  throw new Error(
+    `invalid --log value: "${value}" (expected "progress", "verbose", or "quiet")`
+  );
+}
+function formatBytes(bytes) {
+  const k = 1024;
+  if (bytes < k) {
+    return (bytes / k).toFixed(2) + " kB";
   }
-  async collectJs(asset, urls, visited) {
-    if (!asset) {
+  const units = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + units[i];
+}
+function formatDuration(ms) {
+  const secs = ms / 1e3;
+  if (secs < 60) {
+    return `${secs.toFixed(1)}s`;
+  }
+  const mins = Math.floor(secs / 60);
+  const rem = Math.round(secs - mins * 60);
+  return `${mins}m${String(rem).padStart(2, "0")}s`;
+}
+var BAR_WIDTH = 20;
+var BuildProgress = class {
+  total;
+  mode;
+  itemLabel;
+  outputDirLabel;
+  stream;
+  now;
+  intervalMs;
+  summaryTopN;
+  isTTY;
+  startedAt;
+  completed = 0;
+  totalBytes = 0;
+  files = [];
+  lastPrintAt = 0;
+  lastMilestone = 0;
+  ttyLineActive = false;
+  done = false;
+  constructor(options) {
+    this.total = options.total;
+    this.mode = options.mode;
+    this.itemLabel = options.itemLabel ?? "pages";
+    this.outputDirLabel = options.outputDirLabel ?? "";
+    this.stream = options.stream ?? process.stdout;
+    this.now = options.now ?? Date.now;
+    this.isTTY = !!this.stream.isTTY;
+    this.intervalMs = options.intervalMs ?? (this.isTTY ? 80 : 5e3);
+    this.summaryTopN = options.summaryTopN ?? 5;
+    this.startedAt = this.now();
+  }
+  /** Records a completed output file. */
+  add(outputFile, sizeBytes) {
+    this.completed += 1;
+    this.totalBytes += sizeBytes;
+    this.files.push({ path: outputFile, size: sizeBytes });
+    if (this.mode === "verbose") {
+      const paddedSize = formatBytes(sizeBytes).padStart(9, " ");
+      this.println(
+        `  ${dim2(paddedSize)}  ${dim2(this.outputDirLabel)}${cyan(outputFile)}`
+      );
       return;
     }
-    if (!asset.src) {
-      return;
+    if (this.mode === "progress") {
+      this.maybePrintProgress();
     }
-    if (visited.has(asset.src)) {
+  }
+  /** Clears any in-place progress line (call before printing errors). */
+  abort() {
+    this.clearTtyLine();
+    this.done = true;
+  }
+  /** Prints the final summary. */
+  finish() {
+    if (this.done) {
       return;
     }
-    visited.add(asset.src);
-    if (asset.isElement) {
-      urls.add(asset.assetUrl);
+    this.done = true;
+    this.clearTtyLine();
+    const elapsed = formatDuration(this.now() - this.startedAt);
+    const summary = `${this.completed} ${this.itemLabel} (${formatBytes(
+      this.totalBytes
+    )}) in ${elapsed}`;
+    this.println(`  ${green("\u2713")} ${summary}`);
+    if (this.mode === "progress" && this.summaryTopN > 0) {
+      const largest = [...this.files].sort((a, b) => b.size - a.size).slice(0, this.summaryTopN);
+      if (largest.length > 0) {
+        this.println(`  ${dim2(`largest ${this.itemLabel}:`)}`);
+        for (const file of largest) {
+          const paddedSize = formatBytes(file.size).padStart(9, " ");
+          this.println(
+            `  ${dim2(paddedSize)}  ${dim2(this.outputDirLabel)}${cyan(
+              file.path
+            )}`
+          );
+        }
+      }
     }
-    await Promise.all(
-      asset.importedModules.map(async (src) => {
-        const importedAsset = await this.assetMap.get(src);
-        this.collectJs(importedAsset, urls, visited);
-      })
-    );
   }
-  async collectCss(asset, urls, visited) {
-    if (!asset) {
+  maybePrintProgress() {
+    const now = this.now();
+    if (this.isTTY) {
+      if (now - this.lastPrintAt < this.intervalMs) {
+        return;
+      }
+      this.lastPrintAt = now;
+      this.renderTtyLine(now);
       return;
     }
-    if (!asset.src) {
+    const milestone = Math.floor(this.completed / this.total * 10);
+    if (milestone <= this.lastMilestone || this.completed === this.total) {
       return;
     }
-    if (visited.has(asset.src)) {
+    if (now - this.lastPrintAt < this.intervalMs) {
       return;
     }
-    visited.add(asset.src);
-    if (asset.importedCss) {
-      asset.importedCss.forEach((cssUrl) => urls.add(cssUrl));
-    }
-    await Promise.all(
-      asset.importedModules.map(async (moduleId) => {
-        const importedAsset = await this.assetMap.get(moduleId);
-        this.collectCss(importedAsset, urls, visited);
-      })
+    this.lastMilestone = milestone;
+    this.lastPrintAt = now;
+    const pct = Math.floor(this.completed / this.total * 100);
+    this.println(
+      `  ${this.completed}/${this.total} ${this.itemLabel} (${pct}%) \xB7 ${formatBytes(this.totalBytes)} \xB7 ${formatDuration(now - this.startedAt)}${this.eta(now)}`
     );
   }
-  toJson() {
-    return {
-      src: this.src,
-      assetUrl: this.assetUrl,
-      importedModules: this.importedModules,
-      importedCss: this.importedCss,
-      isElement: this.isElement
-    };
+  renderTtyLine(now) {
+    const ratio = this.total > 0 ? this.completed / this.total : 0;
+    const filled = Math.round(ratio * BAR_WIDTH);
+    const bar = "\u2595" + "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled) + "\u258F";
+    const pct = String(Math.floor(ratio * 100)).padStart(3, " ");
+    const line = `  ${bar} ${pct}% \xB7 ${this.completed}/${this.total} ${this.itemLabel} \xB7 ${formatBytes(this.totalBytes)} \xB7 ${formatDuration(now - this.startedAt)}${this.eta(now)}`;
+    this.stream.write(`\r\x1B[2K${line}`);
+    this.ttyLineActive = true;
+  }
+  /** Returns an " · eta 12.3s" suffix once enough progress exists to estimate. */
+  eta(now) {
+    if (this.completed < 10 || this.completed / this.total < 0.05) {
+      return "";
+    }
+    const elapsed = now - this.startedAt;
+    const remaining = elapsed / this.completed * (this.total - this.completed);
+    return ` \xB7 eta ${formatDuration(remaining)}`;
+  }
+  clearTtyLine() {
+    if (this.ttyLineActive) {
+      this.stream.write("\r\x1B[2K");
+      this.ttyLineActive = false;
+    }
+  }
+  println(line) {
+    this.clearTtyLine();
+    this.stream.write(line + "\n");
   }
 };
 
-// src/utils/batch.ts
-async function batchAsyncCalls(data, concurrency, asyncFunction) {
-  const result = new Array(data.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < data.length) {
-      const index = nextIndex++;
-      result[index] = await asyncFunction(data[index]);
+// src/cli/build-worker-pool.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import v8 from "node:v8";
+import { Worker } from "node:worker_threads";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var WORKER_HEAP_LIMIT_MB = Math.ceil(
+  v8.getHeapStatistics().heap_size_limit / (1024 * 1024)
+);
+var BuildPageError = class extends Error {
+  urlPath;
+  params;
+  routeSrc;
+  workerError;
+  constructor(urlPath, params, routeSrc, workerError) {
+    super(
+      `BuildError: ${urlPath} (${routeSrc || "unknown route"}) failed to build.`
+    );
+    this.urlPath = urlPath;
+    this.params = params;
+    this.routeSrc = routeSrc;
+    this.workerError = workerError;
+  }
+};
+var BuildWorker = class {
+  worker;
+  pool;
+  concurrency;
+  inFlight = /* @__PURE__ */ new Map();
+  isReady = false;
+  ready;
+  constructor(pool, options) {
+    this.pool = pool;
+    this.concurrency = options.workerConcurrency;
+    this.worker = new Worker(path.resolve(__dirname, "./build-worker.js"), {
+      workerData: { rootDir: options.rootDir, mode: options.mode },
+      resourceLimits: { maxOldGenerationSizeMb: WORKER_HEAP_LIMIT_MB }
+    });
+    let onReady;
+    let onFailed;
+    this.ready = new Promise((resolve, reject) => {
+      onReady = resolve;
+      onFailed = reject;
+    });
+    this.worker.on("message", (msg) => {
+      if (msg.type === "ready") {
+        this.isReady = true;
+        onReady();
+        this.next();
+      } else if (msg.type === "result") {
+        const pending = this.inFlight.get(msg.id);
+        this.inFlight.delete(msg.id);
+        pending?.resolve(msg.result);
+        this.next();
+      } else if (msg.type === "error") {
+        const pending = this.inFlight.get(msg.id);
+        this.inFlight.delete(msg.id);
+        pending?.reject(
+          new BuildPageError(msg.urlPath, msg.params, msg.routeSrc, msg.error)
+        );
+        this.next();
+      } else if (msg.type === "fatal") {
+        const err = new Error(`build worker failed: ${msg.error}`);
+        onFailed(err);
+        this.failAll(err);
+      }
+    });
+    this.worker.on("error", (err) => {
+      onFailed(err);
+      this.failAll(err);
+    });
+    this.worker.on("exit", (code) => {
+      if (code !== 0) {
+        const err = new Error(`build worker exited with code ${code}`);
+        onFailed(err);
+        this.failAll(err);
+      }
+    });
+  }
+  /**
+   * Rejects all in-flight tasks after a worker-level failure (fatal error,
+   * crash, or non-zero exit — e.g. an OOM kill).
+   *
+   * Each task is rejected with its own `BuildPageError` so the build log
+   * names every page that was in flight when the worker died. Without this,
+   * worker deaths surface as a single generic error with no route context,
+   * making OOM crashes impossible to trace back to pages. Note the in-flight
+   * pages are the OOM *suspects*, not necessarily the cause (memory pressure
+   * is cumulative), which is why the message says "while rendering".
+   */
+  failAll(err) {
+    const pendingTasks = Array.from(this.inFlight.values());
+    this.inFlight.clear();
+    pendingTasks.forEach(
+      (pending) => pending.reject(
+        new BuildPageError(
+          pending.task.urlPath,
+          pending.task.params,
+          pending.task.routeSrc,
+          `worker thread died while rendering this page (${pendingTasks.length} page(s) were in flight): ` + String(err.message || err)
+        )
+      )
+    );
+  }
+  /** Pulls tasks off the pool's queue until at max concurrency. */
+  next() {
+    if (!this.isReady) {
+      return;
+    }
+    while (this.inFlight.size < this.concurrency) {
+      const pending = this.pool.dequeue();
+      if (!pending) {
+        return;
+      }
+      this.inFlight.set(pending.id, pending);
+      const req = {
+        type: "render",
+        id: pending.id,
+        task: pending.task
+      };
+      this.worker.postMessage(req);
     }
   }
-  const workers = Array.from(
-    { length: Math.min(concurrency, data.length) },
-    () => worker()
-  );
-  await Promise.all(workers);
-  return result;
-}
+  async terminate() {
+    await this.worker.terminate();
+  }
+};
+var BuildWorkerPool = class {
+  workers = [];
+  queue = [];
+  nextTaskId = 0;
+  constructor(options) {
+    for (let i = 0; i < options.numWorkers; i++) {
+      this.workers.push(new BuildWorker(this, options));
+    }
+  }
+  /** Waits for all workers to finish initializing. */
+  async ready() {
+    await Promise.all(this.workers.map((worker) => worker.ready));
+  }
+  /** Schedules a page build and resolves when the page finishes. */
+  run(task) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ id: this.nextTaskId++, task, resolve, reject });
+      this.workers.forEach((worker) => worker.next());
+    });
+  }
+  dequeue() {
+    return this.queue.shift();
+  }
+  async terminate() {
+    await Promise.all(this.workers.map((worker) => worker.terminate()));
+  }
+};
 
 // src/cli/build.ts
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
+var activeLogMode = "progress";
 async function build(rootProjectDir, options) {
   const mode = options?.mode || "production";
   process.env.NODE_ENV = mode;
-  const rootDir = path3.resolve(rootProjectDir || process.cwd());
+  activeLogMode = options?.quiet ? "quiet" : parseBuildLogMode(options?.log);
+  const rootDir = path2.resolve(rootProjectDir || process.cwd());
   const rootConfig = await loadRootConfig(rootDir, { command: "build" });
-  const distDir = path3.join(rootDir, "dist");
+  const distDir = path2.join(rootDir, "dist");
   const ssrOnly = options?.ssrOnly || false;
-  console.log();
-  console.log(`${dim2("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim2("\u2503")} output:   ${distDir}/html`);
-  console.log(`${dim2("\u2503")} mode:     ${mode}`);
-  console.log();
+  if (activeLogMode !== "quiet") {
+    console.log();
+    console.log(`${dim3("\u2503")} project:  ${rootDir}`);
+    console.log(`${dim3("\u2503")} output:   ${distDir}/html`);
+    console.log(`${dim3("\u2503")} mode:     ${mode}`);
+    console.log();
+  }
   await rmDir(distDir);
   await makeDir(distDir);
   const pods = await collectPods(rootConfig);
   const routeFiles = [];
-  if (await isDirectory(path3.join(rootDir, "routes"))) {
-    const pageFiles = await glob2("routes/**/*", { cwd: rootDir });
+  if (await isDirectory(path2.join(rootDir, "routes"))) {
+    const pageFiles = await glob("routes/**/*", { cwd: rootDir });
     pageFiles.forEach((file) => {
-      const parts = path3.parse(file);
+      const parts = path2.parse(file);
       if (!parts.name.startsWith("_") && isJsFile(parts.base)) {
-        routeFiles.push(path3.resolve(rootDir, file));
+        routeFiles.push(path2.resolve(rootDir, file));
       }
     });
   }
@@ -471,12 +502,12 @@ async function build(rootProjectDir, options) {
     return sourceFile.filePath;
   });
   const bundleScripts = [];
-  if (await isDirectory(path3.join(rootDir, "bundles"))) {
-    const bundleFiles = await glob2("bundles/*", { cwd: rootDir });
+  if (await isDirectory(path2.join(rootDir, "bundles"))) {
+    const bundleFiles = await glob("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
-      const parts = path3.parse(file);
+      const parts = path2.parse(file);
       if (isJsFile(parts.base)) {
-        bundleScripts.push(path3.resolve(rootDir, file));
+        bundleScripts.push(path2.resolve(rootDir, file));
       }
     });
   }
@@ -503,10 +534,12 @@ async function build(rootProjectDir, options) {
     ...viteConfig,
     root: rootDir,
     mode,
-    plugins: vitePlugins
+    plugins: vitePlugins,
+    // In quiet mode, only surface vite warnings and errors.
+    logLevel: activeLogMode === "quiet" ? "warn" : viteConfig.logLevel
   };
   const ssrInput = {
-    render: path3.resolve(__dirname, "./render.js")
+    render: path2.resolve(__dirname2, "./render.js")
   };
   rootPlugins.forEach((plugin) => {
     if (plugin.ssrInput) {
@@ -537,7 +570,7 @@ async function build(rootProjectDir, options) {
           sanitizeFileName
         }
       },
-      outDir: path3.join(distDir, "server"),
+      outDir: path2.join(distDir, "server"),
       ssr: true,
       ssrManifest: false,
       cssCodeSplit: true,
@@ -570,7 +603,7 @@ async function build(rootProjectDir, options) {
           ...viteConfig?.build?.rolldownOptions?.output
         }
       },
-      outDir: path3.join(distDir, ".build/routes"),
+      outDir: path2.join(distDir, ".build/routes"),
       ssr: true,
       ssrManifest: false,
       ssrEmitAssets: true,
@@ -601,7 +634,7 @@ async function build(rootProjectDir, options) {
             ...viteConfig?.build?.rolldownOptions?.output
           }
         },
-        outDir: path3.join(distDir, ".build/client"),
+        outDir: path2.join(distDir, ".build/client"),
         ssr: false,
         ssrManifest: false,
         manifest: true,
@@ -614,21 +647,21 @@ async function build(rootProjectDir, options) {
     });
   } else {
     await writeFile(
-      path3.join(distDir, ".build/client/.vite/manifest.json"),
+      path2.join(distDir, ".build/client/.vite/manifest.json"),
       "{}"
     );
   }
-  await bundleRootConfig(rootDir, path3.join(distDir, "root.config.js"));
+  await bundleRootConfig(rootDir, path2.join(distDir, "root.config.js"));
   await copyGlob(
     "**/*.css",
-    path3.join(distDir, ".build/routes"),
-    path3.join(distDir, ".build/client")
+    path2.join(distDir, ".build/routes"),
+    path2.join(distDir, ".build/client")
   );
   const routesManifest = await loadJson(
-    path3.join(distDir, ".build/routes/.vite/manifest.json")
+    path2.join(distDir, ".build/routes/.vite/manifest.json")
   );
   const clientManifest = await loadJson(
-    path3.join(distDir, ".build/client/.vite/manifest.json")
+    path2.join(distDir, ".build/client/.vite/manifest.json")
   );
   function collectRouteCss(asset, cssDeps, visited) {
     if (!asset || !asset.file || visited.has(asset.file)) {
@@ -671,17 +704,17 @@ async function build(rootProjectDir, options) {
   );
   const rootManifest = assetMap.toJson();
   await writeFile(
-    path3.join(distDir, ".root/manifest.json"),
+    path2.join(distDir, ".root/manifest.json"),
     JSON.stringify(rootManifest, null, 2)
   );
   const elementGraphJson = elementGraph.toJson();
   await writeFile(
-    path3.join(distDir, ".root/elements.json"),
+    path2.join(distDir, ".root/elements.json"),
     JSON.stringify(elementGraphJson, null, 2)
   );
-  const buildDir = path3.join(distDir, "html");
-  const publicDir = path3.join(rootDir, "public");
-  if (fsExtra.existsSync(path3.join(rootDir, "public"))) {
+  const buildDir = path2.join(distDir, "html");
+  const publicDir = path2.join(rootDir, "public");
+  if (fsExtra.existsSync(path2.join(rootDir, "public"))) {
     fsExtra.copySync(publicDir, buildDir, { dereference: true });
   } else {
     await makeDir(buildDir);
@@ -693,8 +726,8 @@ async function build(rootProjectDir, options) {
     }
     seenAssets.add(assetUrl);
     const assetRelPath = assetUrl.slice(1);
-    const assetFrom = path3.join(distDir, ".build/client", assetRelPath);
-    const assetTo = path3.join(buildDir, assetRelPath);
+    const assetFrom = path2.join(distDir, ".build/client", assetRelPath);
+    const assetTo = path2.join(buildDir, assetRelPath);
     if (!await fileExists(assetFrom)) {
       console.log(`${assetFrom} does not exist`);
       return;
@@ -702,7 +735,9 @@ async function build(rootProjectDir, options) {
     await fsExtra.copy(assetFrom, assetTo);
     printFileOutput(fileSize(assetTo), "dist/html/", assetRelPath);
   }
-  console.log("\njs/css output:");
+  if (activeLogMode !== "quiet") {
+    console.log("\njs/css output:");
+  }
   await Promise.all(
     Object.keys(rootManifest).map(async (src) => {
       const assetData = rootManifest[src];
@@ -724,7 +759,7 @@ async function build(rootProjectDir, options) {
     })
   );
   if (!ssrOnly) {
-    const render = await import(path3.join(distDir, "server/render.js"));
+    const render = await import(path2.join(distDir, "server/render.js"));
     const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
     let sitemap = await renderer.getSitemap();
     if (options?.filter) {
@@ -744,92 +779,141 @@ async function build(rootProjectDir, options) {
       );
     }
     const domain = rootConfig.domain;
-    console.log("\nhtml output:");
-    const batchSize = Number(options?.concurrency || 10);
-    await batchAsyncCalls(
-      Object.entries(sitemap),
-      batchSize,
-      async ([urlPath, sitemapItem]) => {
-        if (rootConfig.build?.excludeDefaultLocaleFromIntlPaths) {
-          const defaultLocale = rootConfig.i18n?.defaultLocale || "en";
-          if (sitemapItem.locale === defaultLocale) {
-            return;
-          }
+    const addSitemapXmlItem = (urlPath, sitemapItem, outFilePath) => {
+      if (!rootConfig.sitemap || !outFilePath.endsWith("index.html")) {
+        return;
+      }
+      const sitemapXmlItem = {
+        url: `${domain}${urlPath}`,
+        locale: sitemapItem.locale,
+        alts: []
+      };
+      sitemapXmlItems.push(sitemapXmlItem);
+      if (sitemapItem.alts) {
+        Object.entries(sitemapItem.alts).forEach(([altLocale, item]) => {
+          sitemapXmlItem.alts.push({
+            url: `${domain}${item.urlPath}`,
+            locale: altLocale,
+            hreflang: item.hrefLang
+          });
+        });
+      }
+    };
+    const onPageResult = (sitemapItem, result) => {
+      if (result.notFound || !result.outFilePath) {
+        return;
+      }
+      if (!result.staticContent) {
+        addSitemapXmlItem(result.urlPath, sitemapItem, result.outFilePath);
+      }
+      progress.add(
+        result.outFilePath,
+        fileSizeBytes(path2.join(buildDir, result.outFilePath))
+      );
+    };
+    const sitemapEntries = Object.entries(sitemap).filter(([, sitemapItem]) => {
+      if (rootConfig.build?.excludeDefaultLocaleFromIntlPaths) {
+        const defaultLocale = rootConfig.i18n?.defaultLocale || "en";
+        if (sitemapItem.locale === defaultLocale) {
+          return false;
         }
+      }
+      return true;
+    });
+    if (activeLogMode !== "quiet") {
+      console.log("\nhtml output:");
+    }
+    const concurrency = Number(options?.concurrency || 10);
+    const resolvedThreads = resolveNumThreads(
+      options?.threads,
+      sitemapEntries.length
+    );
+    const numThreads = resolvedThreads.count;
+    const workerConcurrency = numThreads > 0 ? Math.max(Math.ceil(concurrency / numThreads), 1) : 0;
+    if (activeLogMode !== "quiet") {
+      const threadsDesc = numThreads > 0 ? `${numThreads} workers x ${workerConcurrency} pages/worker` : `in-process, ${concurrency} concurrent pages`;
+      console.log(
+        `  ${dim3(`threads: ${threadsDesc} (${resolvedThreads.source})`)}`
+      );
+    }
+    const progress = new BuildProgress({
+      total: sitemapEntries.length,
+      mode: activeLogMode,
+      itemLabel: "pages",
+      outputDirLabel: "dist/html/"
+    });
+    try {
+      if (numThreads > 0) {
+        const pool = new BuildWorkerPool({
+          numWorkers: numThreads,
+          workerConcurrency,
+          rootDir,
+          mode
+        });
         try {
-          const routeModule = sitemapItem.route.module;
-          if (routeModule.getStaticContent) {
-            let props;
-            if (routeModule.getStaticProps) {
-              props = await routeModule.getStaticProps({
-                rootConfig,
-                params: sitemapItem.params
-              });
-              if (props?.notFound) {
-                return;
-              }
-            } else {
-              props = { rootConfig, params: sitemapItem.params };
-            }
-            const result = await routeModule.getStaticContent(props);
-            let body;
-            if (typeof result === "string") {
-              body = result;
-            } else if (result && typeof result === "object") {
-              body = result.body;
-            } else {
-              body = "";
-            }
-            const outFilePath2 = urlPath.slice(1);
-            const outPath2 = path3.join(buildDir, outFilePath2);
-            await makeDir(path3.dirname(outPath2));
-            await writeFile(outPath2, normalizeLineEndings(body));
-            printFileOutput(fileSize(outPath2), "dist/html/", outFilePath2);
-            return;
-          }
-          const data = await renderer.renderRoute(sitemapItem.route, {
-            routeParams: sitemapItem.params
-          });
-          if (data.notFound) {
-            return;
-          }
-          let outFilePath = path3.join(urlPath.slice(1), "index.html");
-          if (outFilePath.endsWith("404/index.html")) {
-            outFilePath = outFilePath.replace("404/index.html", "404.html");
-          }
-          const outPath = path3.join(buildDir, outFilePath);
-          if (rootConfig.sitemap && outFilePath.endsWith("index.html")) {
-            const sitemapXmlItem = {
-              url: `${domain}${urlPath}`,
-              locale: sitemapItem.locale,
-              alts: []
-            };
-            sitemapXmlItems.push(sitemapXmlItem);
-            if (sitemapItem.alts) {
-              Object.entries(sitemapItem.alts).forEach(([altLocale, item]) => {
-                sitemapXmlItem.alts.push({
-                  url: `${domain}${item.urlPath}`,
-                  locale: altLocale,
-                  hreflang: item.hrefLang
+          await pool.ready();
+          await Promise.all(
+            sitemapEntries.map(async ([urlPath, sitemapItem]) => {
+              try {
+                const result = await pool.run({
+                  urlPath,
+                  params: sitemapItem.params,
+                  routeSrc: sitemapItem.route.src,
+                  locale: sitemapItem.locale
                 });
-              });
-            }
-          }
-          const html = await transformHtml(data.html || "", rootConfig);
-          await writeFile(outPath, normalizeLineEndings(html));
-          printFileOutput(fileSize(outPath), "dist/html/", outFilePath);
-        } catch (e) {
-          logBuildError(
-            { route: sitemapItem.route, params: sitemapItem.params, urlPath },
-            e
-          );
-          throw new Error(
-            `BuildError: ${urlPath} (${sitemapItem.route.src}) failed to build.`,
-            { cause: e }
+                onPageResult(sitemapItem, result);
+              } catch (e) {
+                if (e instanceof BuildPageError) {
+                  progress.abort();
+                  logBuildError(
+                    {
+                      route: sitemapItem.route,
+                      params: sitemapItem.params,
+                      urlPath
+                    },
+                    new Error(e.workerError)
+                  );
+                }
+                throw e;
+              }
+            })
           );
+        } finally {
+          await pool.terminate();
         }
+      } else {
+        await batchAsyncCalls(
+          sitemapEntries,
+          concurrency,
+          async ([urlPath, sitemapItem]) => {
+            try {
+              const result = await buildPage(
+                renderer,
+                rootConfig,
+                buildDir,
+                sitemapItem.route,
+                { urlPath, params: sitemapItem.params }
+              );
+              onPageResult(sitemapItem, result);
+            } catch (e) {
+              progress.abort();
+              logBuildError(
+                { route: sitemapItem.route, params: sitemapItem.params, urlPath },
+                e
+              );
+              throw new Error(
+                `BuildError: ${urlPath} (${sitemapItem.route.src}) failed to build.`,
+                { cause: e }
+              );
+            }
+          }
+        );
       }
-    );
+    } catch (e) {
+      progress.abort();
+      throw e;
+    }
+    progress.finish();
     if (rootConfig.sitemap) {
       const sitemapXmlBuilder = [];
       sitemapXmlItems.sort((a, b) => a.url.localeCompare(b.url));
@@ -855,7 +939,7 @@ async function build(rootProjectDir, options) {
         "</urlset>"
       ];
       const sitemapXml = sitemapXmlLines.join("\n");
-      const outPath = path3.join(buildDir, "sitemap.xml");
+      const outPath = path2.join(buildDir, "sitemap.xml");
       await writeFile(outPath, sitemapXml);
       printFileOutput(fileSize(outPath), "dist/html/", "sitemap.xml");
     }
@@ -869,22 +953,46 @@ async function build(rootProjectDir, options) {
 function isRouteFile(filepath) {
   return filepath.startsWith("routes") && isJsFile(filepath);
 }
-function fileSize(filepath) {
-  const stats = fsExtra.statSync(filepath);
-  const bytes = stats.size;
-  const k = 1024;
-  if (bytes < k) {
-    return (bytes / k).toFixed(2) + " kB";
+var MIN_PAGES_PER_THREAD = 10;
+var MEMORY_PER_THREAD = 1024 * 1024 * 1024;
+function resolveNumThreads(threads, numPages) {
+  if (threads === void 0 || threads === false) {
+    return { count: 0, source: "--threads not set" };
+  }
+  if (threads === true || threads === "auto") {
+    const maxByCpu = Math.max(os.availableParallelism() - 1, 1);
+    const maxByPages = Math.floor(numPages / MIN_PAGES_PER_THREAD);
+    const maxByMemory = Math.max(
+      Math.floor(os.freemem() / MEMORY_PER_THREAD) - 1,
+      1
+    );
+    const numThreads = Math.min(maxByCpu, maxByPages, maxByMemory);
+    const source = `auto = min(cpu ${maxByCpu}, pages ${maxByPages}, memory ${maxByMemory})`;
+    if (numThreads <= 1) {
+      return { count: 0, source };
+    }
+    return { count: numThreads, source };
   }
-  const units = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + units[i];
+  const num = parseInt(threads);
+  if (isNaN(num) || num < 0) {
+    throw new Error(`invalid --threads value: ${threads}`);
+  }
+  return { count: num, source: `--threads=${num}` };
+}
+function fileSizeBytes(filepath) {
+  return fsExtra.statSync(filepath).size;
+}
+function fileSize(filepath) {
+  return formatBytes(fileSizeBytes(filepath));
 }
 function printFileOutput(fileSize2, outputDir, outputFile) {
+  if (activeLogMode === "quiet") {
+    return;
+  }
   const indent = " ".repeat(2);
   const paddedSize = fileSize2.padStart(9, " ");
   console.log(
-    `${indent}${dim2(paddedSize)}  ${dim2(outputDir)}${cyan(outputFile)}`
+    `${indent}${dim3(paddedSize)}  ${dim3(outputDir)}${cyan2(outputFile)}`
   );
 }
 function sanitizeFileName(name) {
@@ -917,18 +1025,15 @@ function formatParams(params) {
     return `  ${key}: ${value}`;
   }).join("\n");
 }
-function normalizeLineEndings(str) {
-  return str.replace(/\r\n?/g, "\n");
-}
 
 // src/cli/codegen.ts
-import { promises as fs3 } from "node:fs";
-import path4 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import glob3 from "tiny-glob";
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+import { promises as fs } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import glob2 from "tiny-glob";
+var __dirname3 = path3.dirname(fileURLToPath3(import.meta.url));
 async function codegen(type, name, options) {
-  const rootDir = path4.resolve(process.cwd());
+  const rootDir = path3.resolve(process.cwd());
   const project = new Project(rootDir);
   await project.generateCode(type, name, options);
 }
@@ -938,8 +1043,8 @@ var Project = class {
   constructor(rootDir) {
     this.rootDir = rootDir;
     this.tplDirs = [
-      path4.join(rootDir, "codegen"),
-      path4.join(__dirname2, "../codegen")
+      path3.join(rootDir, "codegen"),
+      path3.join(__dirname3, "../codegen")
     ];
   }
   async generateCode(type, name, options) {
@@ -949,7 +1054,7 @@ var Project = class {
       return;
     }
     const outname = options?.out || `${type}s`;
-    const outdir = path4.join(this.rootDir, outname, name);
+    const outdir = path3.join(this.rootDir, outname, name);
     if (await dirExists(outdir)) {
       await rmDir(outdir);
     }
@@ -958,7 +1063,7 @@ var Project = class {
       const tpl = await files[tplName].read();
       const content = tpl.replaceAll("[[name]]", name).replaceAll("[[name:camel_upper]]", toCamelCaseUpper(name));
       const filename = tplName.replace("[name]", name);
-      const filepath = path4.join(outdir, filename);
+      const filepath = path3.join(outdir, filename);
       await writeFile(filepath, content);
       console.log(`saved ${filepath}`);
     }
@@ -969,7 +1074,7 @@ var Project = class {
    */
   async loadFiles(type) {
     for (const tplDir of this.tplDirs) {
-      const typeDir = path4.join(tplDir, type);
+      const typeDir = path3.join(tplDir, type);
       if (await dirExists(typeDir)) {
         return this.loadTplFiles(typeDir);
       }
@@ -981,12 +1086,12 @@ var Project = class {
    */
   async loadTplFiles(dirpath) {
     const tplFiles = {};
-    const files = await glob3("*.tpl", { cwd: dirpath });
+    const files = await glob2("*.tpl", { cwd: dirpath });
     for (const filename of files) {
-      const filepath = path4.join(dirpath, filename);
+      const filepath = path3.join(dirpath, filename);
       const name = filename.slice(0, -4);
       tplFiles[name] = {
-        read: () => fs3.readFile(filepath, "utf-8")
+        read: () => fs.readFile(filepath, "utf-8")
       };
     }
     return tplFiles;
@@ -1002,23 +1107,23 @@ function toTitleCase(str) {
 }
 
 // src/cli/create-package.ts
-import { promises as fs4 } from "node:fs";
-import path5 from "node:path";
+import { promises as fs2 } from "node:fs";
+import path4 from "node:path";
 import { build as esbuild } from "esbuild";
 async function createPackage(rootProjectDir, options) {
   const mode = options?.mode || "production";
   process.env.NODE_ENV = mode;
-  const rootDir = path5.resolve(rootProjectDir || process.cwd());
-  const distDir = path5.join(rootDir, "dist");
+  const rootDir = path4.resolve(rootProjectDir || process.cwd());
+  const distDir = path4.join(rootDir, "dist");
   const target = options?.target || await getDefaultTarget(rootDir);
-  const outDir = path5.resolve(options?.out || target || "out");
+  const outDir = path4.resolve(options?.out || target || "out");
   await build(rootProjectDir, { ssrOnly: true, mode });
   await rmDir(outDir);
   await makeDir(outDir);
-  await copyDir(distDir, path5.resolve(outDir, "dist"));
-  const collectionsDir = path5.resolve(rootDir, "collections");
+  await copyDir(distDir, path4.resolve(outDir, "dist"));
+  const collectionsDir = path4.resolve(rootDir, "collections");
   if (await dirExists(collectionsDir)) {
-    await copyDir(collectionsDir, path5.join(outDir, "collections"));
+    await copyDir(collectionsDir, path4.join(outDir, "collections"));
   }
   const packageJson = await generatePackageJson(rootDir, options);
   if (options?.version && packageJson.dependencies) {
@@ -1033,21 +1138,21 @@ async function createPackage(rootProjectDir, options) {
     }
   }
   if (target === "appengine") {
-    const appYamlPath = options?.appYaml || path5.join(rootDir, "app.yaml");
+    const appYamlPath = options?.appYaml || path4.join(rootDir, "app.yaml");
     await onAppEngine({ packageJson, outDir, appYamlPath });
   } else if (target === "firebase") {
     await onFirebase({ rootDir, packageJson, outDir });
   }
-  await writeJson(path5.resolve(outDir, "package.json"), packageJson);
+  await writeJson(path4.resolve(outDir, "package.json"), packageJson);
   console.log("done!");
   console.log(`saved package to ${outDir}`);
 }
 async function getDefaultTarget(rootDir) {
-  const firebaseConfigPath = path5.resolve(rootDir, "firebase.json");
+  const firebaseConfigPath = path4.resolve(rootDir, "firebase.json");
   if (await fileExists(firebaseConfigPath)) {
     return "firebase";
   }
-  const appEngineConfigPath = path5.resolve(rootDir, "app.yaml");
+  const appEngineConfigPath = path4.resolve(rootDir, "app.yaml");
   if (await fileExists(appEngineConfigPath)) {
     return "appengine";
   }
@@ -1055,7 +1160,7 @@ async function getDefaultTarget(rootDir) {
 }
 async function generatePackageJson(rootDir, options) {
   const packageJson = await loadJson(
-    path5.resolve(rootDir, "package.json")
+    path4.resolve(rootDir, "package.json")
   );
   const allDeps = flattenPackageDepsFromMonorepo(rootDir);
   packageJson.dependencies ??= {};
@@ -1082,7 +1187,7 @@ async function generatePackageJson(rootDir, options) {
 async function onAppEngine(options) {
   const { outDir, packageJson, appYamlPath } = options;
   if (await fileExists(appYamlPath)) {
-    await fs4.copyFile(appYamlPath, path5.resolve(outDir, "app.yaml"));
+    await fs2.copyFile(appYamlPath, path4.resolve(outDir, "app.yaml"));
   }
   if (packageJson.scripts?.start) {
     packageJson.scripts = { start: packageJson.scripts.start };
@@ -1092,11 +1197,11 @@ async function onAppEngine(options) {
 }
 async function onFirebase(options) {
   const { rootDir, outDir, packageJson } = options;
-  const outBasename = path5.basename(outDir);
+  const outBasename = path4.basename(outDir);
   if (outBasename === "functions") {
-    const indexTsFile = path5.resolve(rootDir, "index.ts");
+    const indexTsFile = path4.resolve(rootDir, "index.ts");
     if (await fileExists(indexTsFile)) {
-      await bundleTsFile(indexTsFile, path5.resolve(outDir, "index.js"));
+      await bundleTsFile(indexTsFile, path4.resolve(outDir, "index.js"));
     }
   }
   if (packageJson.scripts?.start) {
@@ -1121,7 +1226,7 @@ async function bundleTsFile(srcPath, outPath) {
         setup(build2) {
           build2.onResolve({ filter: /.*/ }, (args) => {
             const id = args.path;
-            if (id[0] !== "." && !path5.isAbsolute(id)) {
+            if (id[0] !== "." && !path4.isAbsolute(id)) {
               return {
                 external: true
               };
@@ -1135,13 +1240,13 @@ async function bundleTsFile(srcPath, outPath) {
 }
 
 // src/cli/dev.ts
-import path12 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import cookieParser from "cookie-parser";
 import { default as express } from "express";
-import { dim as dim5 } from "kleur/colors";
+import { dim as dim6 } from "kleur/colors";
 import sirv from "sirv";
-import glob4 from "tiny-glob";
+import glob3 from "tiny-glob";
 
 // src/middleware/hooks.ts
 function hooksMiddleware() {
@@ -1229,8 +1334,8 @@ function testIsRedirectValid(url) {
 }
 
 // src/render/asset-map/dev-asset-map.ts
-import path6 from "node:path";
-import { searchForWorkspaceRoot as searchForWorkspaceRoot2 } from "vite";
+import path5 from "node:path";
+import { searchForWorkspaceRoot } from "vite";
 var DevServerAssetMap = class {
   rootConfig;
   moduleGraph;
@@ -1239,7 +1344,7 @@ var DevServerAssetMap = class {
     this.moduleGraph = moduleGraph;
   }
   async get(src) {
-    const file = path6.resolve(this.rootConfig.rootDir, src);
+    const file = path5.resolve(this.rootConfig.rootDir, src);
     const viteModules = this.moduleGraph.getModulesByFile(file);
     if (viteModules && viteModules.size > 0) {
       const [viteModule] = viteModules;
@@ -1257,7 +1362,7 @@ var DevServerAssetMap = class {
         getJsDeps: async () => [assetUrl]
       };
     }
-    const workspaceRoot = searchForWorkspaceRoot2(this.rootConfig.rootDir);
+    const workspaceRoot = searchForWorkspaceRoot(this.rootConfig.rootDir);
     if (await directoryContains(workspaceRoot, file)) {
       const assetUrl = `/@fs/${file}`;
       return {
@@ -1271,7 +1376,7 @@ var DevServerAssetMap = class {
     return null;
   }
   filePathToSrc(file) {
-    return path6.relative(this.rootConfig.rootDir, file);
+    return path5.relative(this.rootConfig.rootDir, file);
   }
 };
 var DevServerAsset = class _DevServerAsset {
@@ -1313,7 +1418,7 @@ var DevServerAsset = class _DevServerAsset {
       return;
     }
     visited.add(asset.moduleId);
-    const parts = path6.parse(asset.assetUrl);
+    const parts = path5.parse(asset.assetUrl);
     if ([".js", ".jsx", ".ts", ".tsx"].includes(parts.ext) && asset.moduleId.includes("/elements/")) {
       urls.add(asset.assetUrl);
     }
@@ -1340,7 +1445,7 @@ var DevServerAsset = class _DevServerAsset {
     }
     visited.add(asset.assetUrl);
     if (asset.src.endsWith(".scss")) {
-      const parts = path6.parse(asset.src);
+      const parts = path5.parse(asset.src);
       if (!parts.name.startsWith("_")) {
         urls.add(asset.assetUrl);
       }
@@ -1421,19 +1526,19 @@ function getSessionCookieSecret(rootConfig, rootDir) {
 
 // src/cli/secrets.ts
 import { spawn as spawn3 } from "node:child_process";
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs6 from "node:fs";
+import path9 from "node:path";
 import * as readline from "node:readline";
-import { dim as dim3, green, red, yellow } from "kleur/colors";
+import { dim as dim4, green as green2, red, yellow } from "kleur/colors";
 
 // src/secrets/manifest.ts
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs3 from "node:fs";
+import path6 from "node:path";
 var MANIFEST_FILENAME = ".root.secrets.json";
 var GSM_KEY_RE = /^[A-Za-z0-9_-]{1,255}$/;
 var ENV_NAME_RE = /^[A-Za-z0-9_]+$/;
 function manifestPath(dir) {
-  return path7.join(dir, MANIFEST_FILENAME);
+  return path6.join(dir, MANIFEST_FILENAME);
 }
 function isValidEnvName(name) {
   return ENV_NAME_RE.test(name);
@@ -1441,7 +1546,7 @@ function isValidEnvName(name) {
 async function readManifest(filePath) {
   let raw;
   try {
-    raw = await fs5.promises.readFile(filePath, "utf8");
+    raw = await fs3.promises.readFile(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return null;
@@ -1468,8 +1573,8 @@ async function writeManifest(filePath, manifest) {
     ...manifest.import ? { import: manifest.import } : {},
     secrets: sortedSecrets
   };
-  await fs5.promises.mkdir(path7.dirname(filePath), { recursive: true });
-  await fs5.promises.writeFile(
+  await fs3.promises.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs3.promises.writeFile(
     filePath,
     JSON.stringify(ordered, null, 2) + "\n",
     "utf8"
@@ -1497,7 +1602,7 @@ async function resolveManagedKeys(rootDir) {
   }
   let shared;
   if (site.import) {
-    const sharedPath = path7.resolve(rootDir, site.import.manifest);
+    const sharedPath = path6.resolve(rootDir, site.import.manifest);
     const loaded = await readManifest(sharedPath);
     if (!loaded) {
       throw new Error(`imported manifest not found: ${sharedPath}`);
@@ -1624,16 +1729,16 @@ function validateManifest(value, filePath) {
 
 // src/secrets/secrets.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs5 from "node:fs";
+import path8 from "node:path";
 
 // src/secrets/env-file.ts
-import fs6 from "node:fs";
-import path8 from "node:path";
+import fs4 from "node:fs";
+import path7 from "node:path";
 import dotenv from "dotenv";
 async function readEnvFile(envPath2) {
   try {
-    return await fs6.promises.readFile(envPath2, "utf8");
+    return await fs4.promises.readFile(envPath2, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return "";
@@ -1642,11 +1747,11 @@ async function readEnvFile(envPath2) {
   }
 }
 async function writeEnvFile(envPath2, content) {
-  const dir = path8.dirname(envPath2);
-  await fs6.promises.mkdir(dir, { recursive: true });
-  const tmp = path8.join(dir, `.env.tmp-${process.pid}-${Date.now()}`);
-  await fs6.promises.writeFile(tmp, content, "utf8");
-  await fs6.promises.rename(tmp, envPath2);
+  const dir = path7.dirname(envPath2);
+  await fs4.promises.mkdir(dir, { recursive: true });
+  const tmp = path7.join(dir, `.env.tmp-${process.pid}-${Date.now()}`);
+  await fs4.promises.writeFile(tmp, content, "utf8");
+  await fs4.promises.rename(tmp, envPath2);
 }
 function parseEnv(content) {
   return dotenv.parse(content);
@@ -1864,10 +1969,10 @@ function hashValue(salt, value) {
 // src/secrets/secrets.ts
 var STATE_FILENAME = "secrets-sync.json";
 function localStatePath(rootDir) {
-  return path9.join(rootDir, ".root", STATE_FILENAME);
+  return path8.join(rootDir, ".root", STATE_FILENAME);
 }
 function envPath(rootDir) {
-  return path9.join(rootDir, ".env");
+  return path8.join(rootDir, ".env");
 }
 var inFlight = /* @__PURE__ */ new Map();
 function syncSecrets(options) {
@@ -2093,7 +2198,7 @@ async function pushEnvToSecrets(options) {
   };
 }
 async function sharedImportedNames(rootDir, manifestFilePath) {
-  if (path9.resolve(manifestFilePath) !== path9.resolve(manifestPath(rootDir))) {
+  if (path8.resolve(manifestFilePath) !== path8.resolve(manifestPath(rootDir))) {
     return /* @__PURE__ */ new Set();
   }
   try {
@@ -2156,7 +2261,7 @@ function isSyncDisabledByEnv() {
 }
 async function readLocalState(rootDir) {
   try {
-    const raw = await fs7.promises.readFile(localStatePath(rootDir), "utf8");
+    const raw = await fs5.promises.readFile(localStatePath(rootDir), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && typeof parsed.salt === "string" && parsed.secrets && typeof parsed.secrets === "object") {
       return {
@@ -2170,8 +2275,8 @@ async function readLocalState(rootDir) {
 }
 async function writeLocalState(rootDir, state) {
   const file = localStatePath(rootDir);
-  await fs7.promises.mkdir(path9.dirname(file), { recursive: true });
-  await fs7.promises.writeFile(
+  await fs5.promises.mkdir(path8.dirname(file), { recursive: true });
+  await fs5.promises.writeFile(
     file,
     JSON.stringify(state, null, 2) + "\n",
     "utf8"
@@ -2197,7 +2302,7 @@ function getGitEmail() {
 }
 
 // src/cli/secrets.ts
-var BAR = dim3("\u2503");
+var BAR = dim4("\u2503");
 var DEV_SYNC_TIMEOUT_MS = 1e4;
 function registerSecretsCommands(program) {
   const secrets = program.command("secrets").description(
@@ -2237,7 +2342,7 @@ function registerSecretsCommands(program) {
 }
 async function secretsInit(opts) {
   const rootDir = process.cwd();
-  const target = opts.manifest ? path10.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
+  const target = opts.manifest ? path9.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
   if (await readManifest(target)) {
     console.log(
       `${BAR} ${yellow("secrets:")} manifest already exists at ${rel(rootDir, target)}`
@@ -2258,41 +2363,41 @@ async function secretsInit(opts) {
   await writeManifest(target, manifest);
   const addedGitignore = await ensureRootGitignored(rootDir);
   console.log();
-  console.log(`${BAR} ${green("secrets:")} created ${rel(rootDir, target)}`);
+  console.log(`${BAR} ${green2("secrets:")} created ${rel(rootDir, target)}`);
   if (addedGitignore) {
-    console.log(`${BAR}   added ${dim3(".root/")} to .gitignore`);
+    console.log(`${BAR}   added ${dim4(".root/")} to .gitignore`);
   }
   await warnIfEnvNotIgnored(rootDir);
   console.log(
-    `${BAR}   ${dim3("next: `root secrets set <NAME>` to store a value")}`
+    `${BAR}   ${dim4("next: `root secrets set <NAME>` to store a value")}`
   );
   console.log();
 }
 async function secretsSet(name, opts) {
   const rootDir = process.cwd();
-  const manifestFilePath = opts.manifest ? path10.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
+  const manifestFilePath = opts.manifest ? path9.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
   const secretValue = await readSecretValue(name);
   if (!secretValue) {
     throw new Error("no value provided on stdin");
   }
   await setSecret({ rootDir, manifestFilePath, name, value: secretValue });
-  console.log(`${BAR} ${green("secrets:")} set ${name}`);
+  console.log(`${BAR} ${green2("secrets:")} set ${name}`);
   console.log(
-    `${BAR}   ${dim3(`commit ${rel(rootDir, manifestFilePath)} to share this change`)}`
+    `${BAR}   ${dim4(`commit ${rel(rootDir, manifestFilePath)} to share this change`)}`
   );
 }
 async function secretsRm(name, opts) {
   const rootDir = process.cwd();
-  const manifestFilePath = opts.manifest ? path10.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
+  const manifestFilePath = opts.manifest ? path9.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
   await removeSecret({ rootDir, manifestFilePath, name });
-  console.log(`${BAR} ${green("secrets:")} removed ${name}`);
+  console.log(`${BAR} ${green2("secrets:")} removed ${name}`);
   console.log(
-    `${BAR}   ${dim3(`commit ${rel(rootDir, manifestFilePath)} to share this change`)}`
+    `${BAR}   ${dim4(`commit ${rel(rootDir, manifestFilePath)} to share this change`)}`
   );
 }
 async function secretsPush(opts) {
   const rootDir = process.cwd();
-  const manifestFilePath = opts.manifest ? path10.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
+  const manifestFilePath = opts.manifest ? path9.resolve(rootDir, opts.manifest) : manifestPath(rootDir);
   const only = opts.keys ? opts.keys.split(",").map((k) => k.trim()).filter(Boolean) : void 0;
   const confirm = opts.yes ? void 0 : async (names, gsmKey) => {
     if (!process.stdin.isTTY) {
@@ -2302,7 +2407,7 @@ async function secretsPush(opts) {
     }
     console.log();
     console.log(
-      `${BAR} ${green("secrets:")} push ${names.length} value(s) from .env to "${gsmKey}":`
+      `${BAR} ${green2("secrets:")} push ${names.length} value(s) from .env to "${gsmKey}":`
     );
     for (const name of names) {
       console.log(`${BAR}   ${name}`);
@@ -2345,13 +2450,13 @@ async function secretsStatus() {
   }
   console.log();
   console.log(
-    `${BAR} ${green("secrets:")} ${resolved.site.gsmKey} ${dim3(`(${resolved.site.gcpProjectId})`)}`
+    `${BAR} ${green2("secrets:")} ${resolved.site.gsmKey} ${dim4(`(${resolved.site.gcpProjectId})`)}`
   );
   if (resolved.shared) {
-    console.log(`${BAR}   imports ${dim3(resolved.shared.gsmKey)}`);
+    console.log(`${BAR}   imports ${dim4(resolved.shared.gsmKey)}`);
   }
   if (keys.length === 0) {
-    console.log(`${BAR}   ${dim3("no managed keys yet")}`);
+    console.log(`${BAR}   ${dim4("no managed keys yet")}`);
   }
   for (const key of keys) {
     console.log(`${BAR}   ${formatStatus(key)}`);
@@ -2379,15 +2484,15 @@ async function syncSecretsOnDev(rootDir) {
 function formatStatus(key) {
   switch (key.kind) {
     case "in-sync":
-      return `${green("\u2713")} ${key.name}`;
+      return `${green2("\u2713")} ${key.name}`;
     case "remote-newer":
-      return `${yellow("\u2193")} ${key.name} ${dim3("(update available \u2014 run `root secrets sync`)")}`;
+      return `${yellow("\u2193")} ${key.name} ${dim4("(update available \u2014 run `root secrets sync`)")}`;
     case "locally-edited":
-      return `${dim3("\u2022")} ${key.name} ${dim3("(locally edited)")}`;
+      return `${dim4("\u2022")} ${key.name} ${dim4("(locally edited)")}`;
     case "conflict":
-      return `${yellow("!")} ${key.name} ${dim3("(changed locally & remotely)")}`;
+      return `${yellow("!")} ${key.name} ${dim4("(changed locally & remotely)")}`;
     case "not-pulled":
-      return `${yellow("\u2193")} ${key.name} ${dim3("(not pulled yet)")}`;
+      return `${yellow("\u2193")} ${key.name} ${dim4("(not pulled yet)")}`;
     default:
       return key.name;
   }
@@ -2399,13 +2504,13 @@ function printSyncSummary(result, opts = {}) {
   }
   const parts = [];
   if (result.changed.length) {
-    parts.push(green(`${result.changed.length} updated`));
+    parts.push(green2(`${result.changed.length} updated`));
   }
   if (result.removed.length) {
     parts.push(`${result.removed.length} removed`);
   }
   if (result.kept.length) {
-    parts.push(dim3(`${result.kept.length} local`));
+    parts.push(dim4(`${result.kept.length} local`));
   }
   if (result.conflicts.length) {
     parts.push(yellow(`${result.conflicts.length} conflict`));
@@ -2415,22 +2520,22 @@ function printSyncSummary(result, opts = {}) {
   }
   console.log();
   console.log(
-    `${BAR} ${green("secrets:")} ${parts.length ? parts.join(", ") : "up to date"}`
+    `${BAR} ${green2("secrets:")} ${parts.length ? parts.join(", ") : "up to date"}`
   );
   for (const name of result.changed) {
-    console.log(`${BAR}   ${green("+")} ${name}`);
+    console.log(`${BAR}   ${green2("+")} ${name}`);
   }
   for (const name of result.removed) {
-    console.log(`${BAR}   ${dim3("-")} ${name} ${dim3("(removed)")}`);
+    console.log(`${BAR}   ${dim4("-")} ${name} ${dim4("(removed)")}`);
   }
   for (const name of result.overwritten) {
     console.log(
-      `${BAR}   ${yellow("!")} ${name} ${dim3("(local value replaced)")}`
+      `${BAR}   ${yellow("!")} ${name} ${dim4("(local value replaced)")}`
     );
   }
   for (const name of result.conflicts) {
     console.log(
-      `${BAR}   ${yellow("!")} ${name} ${dim3(
+      `${BAR}   ${yellow("!")} ${name} ${dim4(
         "(changed locally & remotely; keeping yours \u2014 `root secrets pull` to take remote)"
       )}`
     );
@@ -2452,28 +2557,28 @@ function printPushResult(result, rootDir, manifestFilePath) {
     console.log(`${BAR} ${yellow("secrets:")} nothing to push`);
   } else {
     console.log(
-      `${BAR} ${green("secrets:")} pushed ${result.pushed.length} value(s) to "${result.gsmKey}"`
+      `${BAR} ${green2("secrets:")} pushed ${result.pushed.length} value(s) to "${result.gsmKey}"`
     );
     for (const name of result.pushed) {
-      console.log(`${BAR}   ${green("+")} ${name}`);
+      console.log(`${BAR}   ${green2("+")} ${name}`);
     }
   }
   for (const skip of result.skipped) {
-    console.log(`${BAR}   ${dim3("-")} ${skip.name} ${dim3(`(${skip.reason})`)}`);
+    console.log(`${BAR}   ${dim4("-")} ${skip.name} ${dim4(`(${skip.reason})`)}`);
   }
   if (result.pushed.length > 0) {
     console.log(
-      `${BAR}   ${dim3(`commit ${rel(rootDir, manifestFilePath)} to share`)}`
+      `${BAR}   ${dim4(`commit ${rel(rootDir, manifestFilePath)} to share`)}`
     );
   }
   console.log();
 }
 async function ensureRootGitignored(rootDir) {
   const gitRoot = await gitToplevel(rootDir) ?? rootDir;
-  const gitignore = path10.join(gitRoot, ".gitignore");
+  const gitignore = path9.join(gitRoot, ".gitignore");
   let content = "";
   try {
-    content = await fs8.promises.readFile(gitignore, "utf8");
+    content = await fs6.promises.readFile(gitignore, "utf8");
   } catch {
   }
   const lines = content.split(/\r?\n/).map((line) => line.trim());
@@ -2481,7 +2586,7 @@ async function ensureRootGitignored(rootDir) {
     return false;
   }
   const prefix = content && !content.endsWith("\n") ? "\n" : "";
-  await fs8.promises.writeFile(gitignore, `${content}${prefix}.root/
+  await fs6.promises.writeFile(gitignore, `${content}${prefix}.root/
 `, "utf8");
   return true;
 }
@@ -2489,7 +2594,7 @@ async function warnIfEnvNotIgnored(rootDir) {
   const ignored = await isPathGitIgnored(rootDir, ".env");
   if (ignored === false) {
     console.log(
-      `${BAR}   ${yellow("warning:")} ${dim3(".env is not git-ignored \u2014 add it to .gitignore")}`
+      `${BAR}   ${yellow("warning:")} ${dim4(".env is not git-ignored \u2014 add it to .gitignore")}`
     );
   }
 }
@@ -2609,7 +2714,7 @@ function withTimeout(promise, ms) {
   });
 }
 function rel(rootDir, filePath) {
-  return path10.relative(rootDir, filePath) || path10.basename(filePath);
+  return path9.relative(rootDir, filePath) || path9.basename(filePath);
 }
 function firstLine(text) {
   return String(text).split("\n")[0];
@@ -2626,11 +2731,11 @@ function action(fn) {
 }
 
 // src/cli/startup/startup-tasks.ts
-import os from "node:os";
-import path11 from "node:path";
+import os2 from "node:os";
+import path10 from "node:path";
 
 // src/cli/startup/check-version.ts
-import { dim as dim4, green as green2, yellow as yellow2 } from "kleur/colors";
+import { dim as dim5, green as green3, yellow as yellow2 } from "kleur/colors";
 var PACKAGE_NAME = "@blinkk/root";
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
 var REGISTRY_TIMEOUT_MS = 3e3;
@@ -2701,16 +2806,16 @@ function parseVersion(version) {
   return [toInt(parts[0]), toInt(parts[1]), toInt(parts[2])];
 }
 function printUpdateNotice(current, latest) {
-  const bar = dim4("\u2503");
+  const bar = dim5("\u2503");
   const label = yellow2(`Update available for ${PACKAGE_NAME}:`);
   console.log();
-  console.log(`${bar} ${label} ${dim4(current)} \u2192 ${green2(latest)}`);
+  console.log(`${bar} ${label} ${dim5(current)} \u2192 ${green3(latest)}`);
   console.log();
 }
 
 // src/cli/startup/startup-tasks.ts
 var STARTUP_TASKS = [checkVersionTask];
-var STATE_FILE = path11.join(os.homedir(), ".root", "startup-tasks.json");
+var STATE_FILE = path10.join(os2.homedir(), ".root", "startup-tasks.json");
 async function runStartupTasks(ctx) {
   try {
     const state = await readState();
@@ -2761,13 +2866,13 @@ async function writeState(state) {
 }
 
 // src/cli/dev.ts
-var __dirname3 = path12.dirname(fileURLToPath3(import.meta.url));
+var __dirname4 = path11.dirname(fileURLToPath4(import.meta.url));
 var DEV_SERVER_404_LOG_IGNORE_PATHS = /* @__PURE__ */ new Set([
   "/.well-known/appspecific/com.chrome.devtools.json"
 ]);
 async function dev(rootProjectDir, options) {
   process.env.NODE_ENV = "development";
-  const rootDir = path12.resolve(rootProjectDir || process.cwd());
+  const rootDir = path11.resolve(rootProjectDir || process.cwd());
   const defaultPort = parseInt(process.env.PORT || "4007");
   const host = options?.host || "localhost";
   const port = await findOpenPort(defaultPort, defaultPort + 10);
@@ -2783,19 +2888,19 @@ async function dev(rootProjectDir, options) {
     const basePath = rootConfig.base || "";
     const homePagePath = rootConfig.server?.homePagePath || basePath;
     console.log();
-    console.log(`${dim5("\u2503")} project:  ${rootDir}`);
-    console.log(`${dim5("\u2503")} server:   http://${host}:${port}${homePagePath}`);
+    console.log(`${dim6("\u2503")} project:  ${rootDir}`);
+    console.log(`${dim6("\u2503")} server:   http://${host}:${port}${homePagePath}`);
     if (testCmsEnabled(rootConfig)) {
-      console.log(`${dim5("\u2503")} cms:      http://${host}:${port}/cms/`);
+      console.log(`${dim6("\u2503")} cms:      http://${host}:${port}/cms/`);
     }
-    console.log(`${dim5("\u2503")} mode:     development`);
+    console.log(`${dim6("\u2503")} mode:     development`);
     console.log();
     currentServer = server.listen(port, host);
     const rootConfigDependencies = server.get(
       "rootConfigDependencies"
     );
     const dependencies = [
-      path12.resolve(rootDir, "root.config.ts"),
+      path11.resolve(rootDir, "root.config.ts"),
       ...rootConfigDependencies
     ];
     viteServer.watcher.add(dependencies);
@@ -2803,7 +2908,7 @@ async function dev(rootProjectDir, options) {
       if (dependencies.includes(file)) {
         console.log(
           `
-${dim5("\u2503")} root.config.ts changed. restarting server...`
+${dim6("\u2503")} root.config.ts changed. restarting server...`
         );
         await restart();
       }
@@ -2823,7 +2928,7 @@ ${dim5("\u2503")} root.config.ts changed. restarting server...`
   await start2();
 }
 async function createDevServer(options) {
-  const rootDir = path12.resolve(options?.rootDir || process.cwd());
+  const rootDir = path11.resolve(options?.rootDir || process.cwd());
   const { rootConfig, dependencies } = await loadRootConfigWithDeps(rootDir, {
     command: "dev"
   });
@@ -2838,6 +2943,7 @@ async function createDevServer(options) {
   });
   server.set("viteServer", viteServer);
   server.use(rootProjectMiddleware({ rootConfig }));
+  server.use(securityHeadersMiddleware({ rootConfig }));
   server.use(viteMiddleware);
   server.use(hooksMiddleware());
   const sessionCookieSecret = getSessionCookieSecret(rootConfig, rootDir);
@@ -2859,7 +2965,7 @@ async function createDevServer(options) {
       if (rootConfig.server?.headers) {
         server.use(headersMiddleware({ rootConfig }));
       }
-      const publicDir = path12.join(rootDir, "public");
+      const publicDir = path11.join(rootDir, "public");
       if (await dirExists(publicDir)) {
         server.use(rootPublicDirMiddleware({ publicDir, viteServer }));
       }
@@ -2887,10 +2993,10 @@ async function createViteMiddleware(options) {
     return sourceFile.relPath;
   });
   const bundleScripts = [];
-  if (await isDirectory(path12.join(rootDir, "bundles"))) {
-    const bundleFiles = await glob4("bundles/*", { cwd: rootDir });
+  if (await isDirectory(path11.join(rootDir, "bundles"))) {
+    const bundleFiles = await glob3("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
-      const parts = path12.parse(file);
+      const parts = path11.parse(file);
       if (isJsFile(parts.base)) {
         bundleScripts.push(file);
       }
@@ -2907,7 +3013,7 @@ async function createViteMiddleware(options) {
     optimizeDeps
   });
   function isInElementsDir(changedFilePath) {
-    const filePath = path12.resolve(changedFilePath);
+    const filePath = path11.resolve(changedFilePath);
     const elementsDirs = getElementsDirs(rootConfig, pods);
     return elementsDirs.some((dirPath) => filePath.startsWith(dirPath));
   }
@@ -2926,7 +3032,7 @@ async function createViteMiddleware(options) {
   const viteMiddleware = async (req, res, next) => {
     try {
       req.viteServer = viteServer;
-      const renderModulePath = path12.resolve(__dirname3, "./render.js");
+      const renderModulePath = path11.resolve(__dirname4, "./render.js");
       const render = await viteServer.ssrLoadModule(
         renderModulePath
       );
@@ -2950,7 +3056,7 @@ function rootPublicDirMiddleware(options) {
     handler = sirv(publicDir, sirvOptions);
   }, 1e3);
   function isInPublicDir(changedFilePath) {
-    const filePath = path12.resolve(changedFilePath);
+    const filePath = path11.resolve(changedFilePath);
     return filePath.startsWith(publicDir);
   }
   const watcher = options.viteServer.watcher;
@@ -2982,7 +3088,7 @@ function rootDevServer404Middleware() {
     }
     if (req.renderer) {
       const url = req.path;
-      const ext = path12.extname(url);
+      const ext = path11.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer404(req);
@@ -3000,7 +3106,7 @@ function rootDevServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path12.extname(url);
+      const ext = path11.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer500(req, err);
@@ -3026,7 +3132,7 @@ function debounce(fn, timeout) {
 
 // src/cli/gae-deploy.ts
 import { execSync } from "node:child_process";
-import fs9 from "node:fs";
+import fs7 from "node:fs";
 import yaml from "js-yaml";
 async function gaeDeploy(appDir, options) {
   if (!appDir) {
@@ -3040,10 +3146,10 @@ async function gaeDeploy(appDir, options) {
   }
   process.chdir(appDir);
   const appYamlPath = "app.yaml";
-  if (!fs9.existsSync(appYamlPath)) {
+  if (!fs7.existsSync(appYamlPath)) {
     throw new Error(`[gae-deplopy] Missing: ${appYamlPath}`);
   }
-  const appYaml = yaml.load(fs9.readFileSync(appYamlPath, "utf8"));
+  const appYaml = yaml.load(fs7.readFileSync(appYamlPath, "utf8"));
   const service = appYaml.service;
   if (!service) {
     throw new Error(
@@ -3069,7 +3175,7 @@ async function gaeDeploy(appDir, options) {
     { stdio: "inherit" }
   );
   if (backupAppYaml) {
-    fs9.copyFileSync(backupAppYaml, "app.yaml");
+    fs7.copyFileSync(backupAppYaml, "app.yaml");
   }
   if (options?.healthcheckUrl) {
     const healthcheckPassed = await testHealth(
@@ -3156,8 +3262,8 @@ function testIsEnvPlaceholder(envValue) {
 }
 function updateAppYamlEnv(appYamlPath, appYaml) {
   const backupAppYaml = `${appYamlPath}.bak`;
-  fs9.copyFileSync(appYamlPath, backupAppYaml);
-  let content = fs9.readFileSync(appYamlPath, "utf8");
+  fs7.copyFileSync(appYamlPath, backupAppYaml);
+  let content = fs7.readFileSync(appYamlPath, "utf8");
   const envVars = appYaml.env_variables;
   Object.entries(envVars).forEach(([envVar, envValue]) => {
     if (testIsEnvPlaceholder(envValue)) {
@@ -3170,7 +3276,7 @@ function updateAppYamlEnv(appYamlPath, appYaml) {
       }
     }
   });
-  fs9.writeFileSync(appYamlPath, content, "utf8");
+  fs7.writeFileSync(appYamlPath, content, "utf8");
   return backupAppYaml;
 }
 function getTimestamp() {
@@ -3194,33 +3300,33 @@ function testManagedVersion(service, appInfo, prefix) {
 }
 
 // src/cli/preview.ts
-import path13 from "node:path";
-import compression from "compression";
+import path12 from "node:path";
 import cookieParser2 from "cookie-parser";
 import { default as express2 } from "express";
-import { dim as dim6 } from "kleur/colors";
+import { dim as dim7 } from "kleur/colors";
 import sirv2 from "sirv";
 async function preview(rootProjectDir, options) {
   process.env.NODE_ENV = "development";
-  const rootDir = path13.resolve(rootProjectDir || process.cwd());
+  const rootDir = path12.resolve(rootProjectDir || process.cwd());
   const server = await createPreviewServer({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
   const host = options?.host || "localhost";
   console.log();
-  console.log(`${dim6("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim6("\u2503")} server:   http://${host}:${port}`);
-  console.log(`${dim6("\u2503")} mode:     preview`);
+  console.log(`${dim7("\u2503")} project:  ${rootDir}`);
+  console.log(`${dim7("\u2503")} server:   http://${host}:${port}`);
+  console.log(`${dim7("\u2503")} mode:     preview`);
   console.log();
   server.listen(port, host);
 }
 async function createPreviewServer(options) {
   const rootDir = options.rootDir;
   const rootConfig = await loadBundledConfig(rootDir, { command: "preview" });
-  const distDir = path13.join(rootDir, "dist");
+  const distDir = path12.join(rootDir, "dist");
   const server = express2();
   server.disable("x-powered-by");
-  server.use(compression());
+  server.use(compressionMiddleware());
   server.use(rootProjectMiddleware({ rootConfig }));
+  server.use(securityHeadersMiddleware({ rootConfig }));
   server.use(await rootPreviewRendererMiddleware({ rootConfig, distDir }));
   server.use(hooksMiddleware());
   const sessionCookieSecret = getSessionCookieSecret(rootConfig, rootDir);
@@ -3242,7 +3348,7 @@ async function createPreviewServer(options) {
       if (rootConfig.server?.headers) {
         server.use(headersMiddleware({ rootConfig }));
       }
-      const publicDir = path13.join(distDir, "html");
+      const publicDir = path12.join(distDir, "html");
       server.use(sirv2(publicDir, { dev: false }));
       server.use(trailingSlashMiddleware({ rootConfig }));
       server.use(rootPreviewServerMiddleware());
@@ -3261,14 +3367,14 @@ async function createPreviewServer(options) {
 }
 async function rootPreviewRendererMiddleware(options) {
   const { distDir, rootConfig } = options;
-  const render = await import(path13.join(distDir, "server/render.js"));
-  const manifestPath2 = path13.join(distDir, ".root/manifest.json");
+  const render = await import(path12.join(distDir, "server/render.js"));
+  const manifestPath2 = path12.join(distDir, ".root/manifest.json");
   if (!await fileExists(manifestPath2)) {
     throw new Error(
       `could not find ${manifestPath2}. run \`root build\` before \`root preview\`.`
     );
   }
-  const elementGraphJsonPath = path13.join(distDir, ".root/elements.json");
+  const elementGraphJsonPath = path12.join(distDir, ".root/elements.json");
   if (!await fileExists(elementGraphJsonPath)) {
     throw new Error(
       `could not find ${elementGraphJsonPath}. run \`root build\` before \`root preview\`.`
@@ -3308,7 +3414,7 @@ function rootPreviewServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path13.extname(url);
+      const ext = path12.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.render404({ currentPath: url });
@@ -3326,7 +3432,7 @@ function rootPreviewServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path13.extname(url);
+      const ext = path12.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer500(req, err);
@@ -3340,33 +3446,33 @@ function rootPreviewServer500Middleware() {
 }
 
 // src/cli/start.ts
-import path14 from "node:path";
-import compression2 from "compression";
+import path13 from "node:path";
 import cookieParser3 from "cookie-parser";
 import { default as express3 } from "express";
-import { dim as dim7 } from "kleur/colors";
+import { dim as dim8 } from "kleur/colors";
 import sirv3 from "sirv";
 async function start(rootProjectDir, options) {
   process.env.NODE_ENV = "production";
-  const rootDir = path14.resolve(rootProjectDir || process.cwd());
+  const rootDir = path13.resolve(rootProjectDir || process.cwd());
   const server = await createProdServer({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
   const host = options?.host || "localhost";
   console.log();
-  console.log(`${dim7("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim7("\u2503")} server:   http://${host}:${port}`);
-  console.log(`${dim7("\u2503")} mode:     production`);
+  console.log(`${dim8("\u2503")} project:  ${rootDir}`);
+  console.log(`${dim8("\u2503")} server:   http://${host}:${port}`);
+  console.log(`${dim8("\u2503")} mode:     production`);
   console.log();
   server.listen(port, host);
 }
 async function createProdServer(options) {
   const rootDir = options.rootDir;
   const rootConfig = await loadBundledConfig(rootDir, { command: "start" });
-  const distDir = path14.join(rootDir, "dist");
+  const distDir = path13.join(rootDir, "dist");
   const server = express3();
   server.disable("x-powered-by");
-  server.use(compression2());
+  server.use(compressionMiddleware());
   server.use(rootProjectMiddleware({ rootConfig }));
+  server.use(securityHeadersMiddleware({ rootConfig }));
   server.use(await rootProdRendererMiddleware({ rootConfig, distDir }));
   server.use(hooksMiddleware());
   const sessionCookieSecret = getSessionCookieSecret(rootConfig, rootDir);
@@ -3388,7 +3494,7 @@ async function createProdServer(options) {
       if (rootConfig.server?.headers) {
         server.use(headersMiddleware({ rootConfig }));
       }
-      const publicDir = path14.join(distDir, "html");
+      const publicDir = path13.join(distDir, "html");
       server.use(sirv3(publicDir, { dev: false }));
       server.use(trailingSlashMiddleware({ rootConfig }));
       server.use(rootProdServerMiddleware());
@@ -3407,14 +3513,14 @@ async function createProdServer(options) {
 }
 async function rootProdRendererMiddleware(options) {
   const { distDir, rootConfig } = options;
-  const render = await import(path14.join(distDir, "server/render.js"));
-  const manifestPath2 = path14.join(distDir, ".root/manifest.json");
+  const render = await import(path13.join(distDir, "server/render.js"));
+  const manifestPath2 = path13.join(distDir, ".root/manifest.json");
   if (!await fileExists(manifestPath2)) {
     throw new Error(
       `could not find ${manifestPath2}. run \`root build\` before \`root start\`.`
     );
   }
-  const elementGraphJsonPath = path14.join(distDir, ".root/elements.json");
+  const elementGraphJsonPath = path13.join(distDir, ".root/elements.json");
   if (!await fileExists(elementGraphJsonPath)) {
     throw new Error(
       `could not find ${elementGraphJsonPath}. run \`root build\` before \`root start\`.`
@@ -3454,7 +3560,7 @@ function rootProdServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path14.extname(url);
+      const ext = path13.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.render404({ currentPath: url });
@@ -3472,7 +3578,7 @@ function rootProdServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path14.extname(url);
+      const ext = path13.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderError(err);
@@ -3513,11 +3619,21 @@ var CliRunner = class {
       "-c, --concurrency <num>",
       "number of files to build concurrently",
       "10"
+    ).option(
+      "--threads [num]",
+      'renders pages using worker threads; pass a number for exactly N workers, or omit the value (or pass "auto") to pick based on cpu cores and page count'
     ).option(
       "--filter <urlPathRegex>",
       'builds the url paths that match the given regex, e.g. "/products/.*"',
       ""
-    ).action(build);
+    ).addOption(
+      new Option(
+        "--log <mode>",
+        'build log output: "progress" (default) shows a progress indicator and a final summary, "verbose" prints one line per output file, "quiet" prints only the final summary'
+      ).choices(["progress", "verbose", "quiet"])
+    ).action(
+      (rootProjectDir, options, cmd) => build(rootProjectDir, cmd.optsWithGlobals())
+    );
     program.command("codegen [type] [name]").description("generates boilerplate code").option("--out <outdir>", "output dir").action(codegen);
     program.command("create-package [path]").alias("package").description(
       "creates a standalone npm package for deployment to various hosting services"
@@ -3579,4 +3695,4 @@ export {
   createProdServer,
   CliRunner
 };
-//# sourceMappingURL=chunk-3EFECH2D.js.map
+//# sourceMappingURL=chunk-GK3TDYUY.js.map