@blinkk/root 3.1.1 → 3.1.3

package/dist/{chunk-E4F6CMO3.js → chunk-WGQNQPWG.js}

@@ -47,7 +47,7 @@ import {
 } 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
@@ -55,7 +55,7 @@ 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 { dim as dim3, cyan as cyan2 } from "kleur/colors";
 import glob from "tiny-glob";
 import { build as viteBuild } from "vite";
 
@@ -142,11 +142,253 @@ async function batchAsyncCalls(data, concurrency, asyncFunction) {
   return result;
 }
 
+// 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";
+  }
+  if (value === "progress" || value === "verbose" || value === "quiet") {
+    return value;
+  }
+  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";
+  }
+  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;
+  /** Writes to `this.stream`, bypassing the log interceptor. */
+  streamWrite;
+  /** Restores the original `write` of each intercepted stream. */
+  restoreWrites = [];
+  /** True when intercepted output ended without a trailing newline. */
+  foreignLineOpen = false;
+  redrawTimer = null;
+  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();
+    this.streamWrite = (str) => this.stream.write(str);
+    const interceptStreams = options.interceptStreams ?? (options.stream ? [] : [process.stdout, process.stderr]);
+    if (this.isTTY && this.mode === "progress") {
+      this.interceptLogs(interceptStreams);
+    }
+  }
+  /** 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 (this.mode === "progress") {
+      this.maybePrintProgress();
+    }
+  }
+  /** Clears any in-place progress line (call before printing errors). */
+  abort() {
+    this.clearTtyLine();
+    this.done = true;
+    this.restoreLogs();
+  }
+  /** Prints the final summary. */
+  finish() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    this.restoreLogs();
+    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
+            )}`
+          );
+        }
+      }
+    }
+  }
+  maybePrintProgress() {
+    const now = this.now();
+    if (this.isTTY) {
+      if (now - this.lastPrintAt < this.intervalMs) {
+        return;
+      }
+      this.lastPrintAt = now;
+      this.renderTtyLine(now);
+      return;
+    }
+    const milestone = Math.floor(this.completed / this.total * 10);
+    if (milestone <= this.lastMilestone || this.completed === this.total) {
+      return;
+    }
+    if (now - this.lastPrintAt < this.intervalMs) {
+      return;
+    }
+    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)}`
+    );
+  }
+  renderTtyLine(now) {
+    this.closeForeignLine();
+    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.streamWrite(`\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.streamWrite("\r\x1B[2K");
+      this.ttyLineActive = false;
+    }
+  }
+  println(line) {
+    this.clearTtyLine();
+    this.closeForeignLine();
+    this.streamWrite(line + "\n");
+  }
+  /**
+   * Patches `write` on each stream so foreign output (user logs) clears the
+   * progress bar line before printing and schedules a redraw after. The
+   * progress bar's own writes go through `streamWrite` and bypass the patch.
+   */
+  interceptLogs(streams) {
+    const self = this;
+    for (const stream of streams) {
+      const original = stream.write;
+      if (stream === this.stream) {
+        this.streamWrite = (str) => original.call(stream, str);
+      }
+      stream.write = function(...args) {
+        self.clearTtyLine();
+        const chunk = args[0];
+        const text = typeof chunk === "string" ? chunk : String(chunk ?? "");
+        self.foreignLineOpen = text.length > 0 && !text.endsWith("\n");
+        const result = original.apply(stream, args);
+        self.scheduleRedraw();
+        return result;
+      };
+      this.restoreWrites.push(() => {
+        stream.write = original;
+      });
+    }
+  }
+  /** Redraws the progress bar shortly after foreign output interrupts it. */
+  scheduleRedraw() {
+    if (this.done || this.redrawTimer !== null || this.completed === 0) {
+      return;
+    }
+    this.redrawTimer = setTimeout(() => {
+      this.redrawTimer = null;
+      if (!this.done) {
+        this.renderTtyLine(this.now());
+      }
+    }, 0);
+    this.redrawTimer.unref?.();
+  }
+  /**
+   * If intercepted output left a partial (unterminated) line, terminate it
+   * so the next progress bar render doesn't overwrite it with `\r`.
+   */
+  closeForeignLine() {
+    if (this.foreignLineOpen) {
+      this.streamWrite("\n");
+      this.foreignLineOpen = false;
+    }
+  }
+  restoreLogs() {
+    if (this.redrawTimer) {
+      clearTimeout(this.redrawTimer);
+      this.redrawTimer = null;
+    }
+    while (this.restoreWrites.length > 0) {
+      this.restoreWrites.pop()();
+    }
+  }
+};
+
 // 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;
@@ -173,7 +415,8 @@ var BuildWorker = class {
     this.pool = pool;
     this.concurrency = options.workerConcurrency;
     this.worker = new Worker(path.resolve(__dirname, "./build-worker.js"), {
-      workerData: { rootDir: options.rootDir, mode: options.mode }
+      workerData: { rootDir: options.rootDir, mode: options.mode },
+      resourceLimits: { maxOldGenerationSizeMb: WORKER_HEAP_LIMIT_MB }
     });
     let onReady;
     let onFailed;
@@ -216,10 +459,30 @@ var BuildWorker = class {
       }
     });
   }
+  /**
+   * 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(err));
+    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() {
@@ -274,18 +537,22 @@ var BuildWorkerPool = class {
 
 // src/cli/build.ts
 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;
+  activeLogMode = options?.quiet ? "quiet" : parseBuildLogMode(options?.log);
   const rootDir = path2.resolve(rootProjectDir || process.cwd());
   const rootConfig = await loadRootConfig(rootDir, { command: "build" });
   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);
@@ -341,7 +608,9 @@ 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: path2.resolve(__dirname2, "./render.js")
@@ -540,7 +809,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];
@@ -609,10 +880,9 @@ async function build(rootProjectDir, options) {
       if (!result.staticContent) {
         addSitemapXmlItem(result.urlPath, sitemapItem, result.outFilePath);
       }
-      printFileOutput(
-        fileSize(path2.join(buildDir, result.outFilePath)),
-        "dist/html/",
-        result.outFilePath
+      progress.add(
+        result.outFilePath,
+        fileSizeBytes(path2.join(buildDir, result.outFilePath))
       );
     };
     const sitemapEntries = Object.entries(sitemap).filter(([, sitemapItem]) => {
@@ -624,76 +894,100 @@ async function build(rootProjectDir, options) {
       }
       return true;
     });
-    console.log("\nhtml output:");
+    if (activeLogMode !== "quiet") {
+      console.log("\nhtml output:");
+    }
     const concurrency = Number(options?.concurrency || 10);
-    const numThreads = resolveNumThreads(
+    const resolvedThreads = resolveNumThreads(
       options?.threads,
       sitemapEntries.length
     );
-    if (numThreads > 0) {
-      const pool = new BuildWorkerPool({
-        numWorkers: numThreads,
-        workerConcurrency: Math.max(Math.ceil(concurrency / numThreads), 1),
-        rootDir,
-        mode
-      });
-      try {
-        await pool.ready();
-        await Promise.all(
-          sitemapEntries.map(async ([urlPath, sitemapItem]) => {
+    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 {
+          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
+                });
+                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 pool.run({
-                urlPath,
-                params: sitemapItem.params,
-                routeSrc: sitemapItem.route.src,
-                locale: sitemapItem.locale
-              });
+              const result = await buildPage(
+                renderer,
+                rootConfig,
+                buildDir,
+                sitemapItem.route,
+                { urlPath, params: sitemapItem.params }
+              );
               onPageResult(sitemapItem, result);
             } catch (e) {
-              if (e instanceof BuildPageError) {
-                logBuildError(
-                  {
-                    route: sitemapItem.route,
-                    params: sitemapItem.params,
-                    urlPath
-                  },
-                  new Error(e.workerError)
-                );
-              }
-              throw 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 }
+              );
             }
-          })
+          }
         );
-      } 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) {
-            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));
@@ -734,42 +1028,51 @@ function isRouteFile(filepath) {
   return filepath.startsWith("routes") && isJsFile(filepath);
 }
 var MIN_PAGES_PER_THREAD = 10;
+var MEMORY_PER_THREAD = 1024 * 1024 * 1024;
+function availableMemory() {
+  if (typeof process.availableMemory === "function") {
+    return process.availableMemory();
+  }
+  return os.freemem();
+}
 function resolveNumThreads(threads, numPages) {
   if (threads === void 0 || threads === false) {
-    return 0;
+    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 numThreads = Math.min(maxByCpu, maxByPages);
+    const maxByMemory = Math.max(
+      Math.floor(availableMemory() / 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 0;
+      return { count: 0, source };
     }
-    console.log(`rendering with ${numThreads} worker threads`);
-    return numThreads;
+    return { count: numThreads, source };
   }
   const num = parseInt(threads);
   if (isNaN(num) || num < 0) {
     throw new Error(`invalid --threads value: ${threads}`);
   }
-  return num;
+  return { count: num, source: `--threads=${num}` };
+}
+function fileSizeBytes(filepath) {
+  return fsExtra.statSync(filepath).size;
 }
 function fileSize(filepath) {
-  const stats = fsExtra.statSync(filepath);
-  const bytes = stats.size;
-  const k = 1024;
-  if (bytes < k) {
-    return (bytes / k).toFixed(2) + " kB";
-  }
-  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];
+  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) {
@@ -1021,7 +1324,7 @@ 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 glob3 from "tiny-glob";
 
@@ -1306,7 +1609,7 @@ import { spawn as spawn3 } from "node:child_process";
 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 fs3 from "node:fs";
@@ -2079,7 +2382,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(
@@ -2140,13 +2443,13 @@ 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();
 }
@@ -2158,18 +2461,18 @@ async function secretsSet(name, opts) {
     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 ? 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) {
@@ -2184,7 +2487,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}`);
@@ -2227,13 +2530,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)}`);
@@ -2261,15 +2564,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;
   }
@@ -2281,13 +2584,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`));
@@ -2297,22 +2600,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)"
       )}`
     );
@@ -2334,18 +2637,18 @@ 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();
@@ -2371,7 +2674,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")}`
     );
   }
 }
@@ -2512,7 +2815,7 @@ 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;
@@ -2583,10 +2886,10 @@ 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();
 }
 
@@ -2665,12 +2968,12 @@ 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(
@@ -2685,7 +2988,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();
       }
@@ -3080,7 +3383,7 @@ function testManagedVersion(service, appInfo, prefix) {
 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";
@@ -3089,9 +3392,9 @@ async function preview(rootProjectDir, options) {
   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);
 }
@@ -3226,7 +3529,7 @@ function rootPreviewServer500Middleware() {
 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";
@@ -3235,9 +3538,9 @@ async function start(rootProjectDir, options) {
   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);
 }
@@ -3403,7 +3706,14 @@ var CliRunner = class {
       "--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"
@@ -3465,4 +3775,4 @@ export {
   createProdServer,
   CliRunner
 };
-//# sourceMappingURL=chunk-E4F6CMO3.js.map
+//# sourceMappingURL=chunk-WGQNQPWG.js.map