@blinkk/root 3.0.5 → 3.1.1

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

@@ -1,22 +1,23 @@
 import {
-  RouteTrie,
-  htmlMinify,
-  htmlPretty,
-  isValidTagName,
-  parseTagNames
-} from "./chunk-6P3B7ZXL.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,
@@ -28,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 { 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 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";
@@ -232,167 +124,6 @@ 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();
-    }
-    return result;
-  }
-  static fromViteManifest(rootConfig, clientManifest, elementsGraph) {
-    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));
-    });
-    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);
-}
-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;
-  }
-  async getCssDeps() {
-    const visited = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    await this.collectCss(this, deps, visited);
-    return Array.from(deps);
-  }
-  async getJsDeps() {
-    const visited = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    await this.collectJs(this, deps, visited);
-    return Array.from(deps);
-  }
-  async collectJs(asset, urls, visited) {
-    if (!asset) {
-      return;
-    }
-    if (!asset.src) {
-      return;
-    }
-    if (visited.has(asset.src)) {
-      return;
-    }
-    visited.add(asset.src);
-    if (asset.isElement) {
-      urls.add(asset.assetUrl);
-    }
-    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) {
-      return;
-    }
-    if (!asset.src) {
-      return;
-    }
-    if (visited.has(asset.src)) {
-      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);
-      })
-    );
-  }
-  toJson() {
-    return {
-      src: this.src,
-      assetUrl: this.assetUrl,
-      importedModules: this.importedModules,
-      importedCss: this.importedCss,
-      isElement: this.isElement
-    };
-  }
-};
-
 // src/utils/batch.ts
 async function batchAsyncCalls(data, concurrency, asyncFunction) {
   const result = new Array(data.length);
@@ -411,14 +142,144 @@ async function batchAsyncCalls(data, concurrency, asyncFunction) {
   return result;
 }
 
+// src/cli/build-worker-pool.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+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 }
+    });
+    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);
+      }
+    });
+  }
+  failAll(err) {
+    const pendingTasks = Array.from(this.inFlight.values());
+    this.inFlight.clear();
+    pendingTasks.forEach((pending) => pending.reject(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);
+    }
+  }
+  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));
 async function build(rootProjectDir, options) {
   const mode = options?.mode || "production";
   process.env.NODE_ENV = mode;
-  const rootDir = path3.resolve(rootProjectDir || process.cwd());
+  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}`);
@@ -429,12 +290,12 @@ async function build(rootProjectDir, options) {
   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));
       }
     });
   }
@@ -448,12 +309,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));
       }
     });
   }
@@ -483,7 +344,7 @@ async function build(rootProjectDir, options) {
     plugins: vitePlugins
   };
   const ssrInput = {
-    render: path3.resolve(__dirname, "./render.js")
+    render: path2.resolve(__dirname2, "./render.js")
   };
   rootPlugins.forEach((plugin) => {
     if (plugin.ssrInput) {
@@ -514,7 +375,7 @@ async function build(rootProjectDir, options) {
           sanitizeFileName
         }
       },
-      outDir: path3.join(distDir, "server"),
+      outDir: path2.join(distDir, "server"),
       ssr: true,
       ssrManifest: false,
       cssCodeSplit: true,
@@ -547,7 +408,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,
@@ -578,7 +439,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,
@@ -591,21 +452,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)) {
@@ -634,24 +495,31 @@ async function build(rootProjectDir, options) {
       clientManifest[manifestKey] = asset;
     }
   });
+  const podRoutes = pods.flatMap(
+    (pod) => pod.routeFiles.map((route) => ({
+      src: `pod/${pod.name}/${route.relPath}`,
+      filePath: route.filePath
+    }))
+  );
   const assetMap = BuildAssetMap.fromViteManifest(
     rootConfig,
     clientManifest,
-    elementGraph
+    elementGraph,
+    podRoutes
   );
   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);
@@ -663,8 +531,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;
@@ -694,7 +562,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) {
@@ -714,97 +582,118 @@ 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);
+      }
+      printFileOutput(
+        fileSize(path2.join(buildDir, result.outFilePath)),
+        "dist/html/",
+        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;
         }
-        try {
-          const routeModule = sitemapItem.route.module;
-          if (routeModule.getStaticContent) {
-            let props;
-            if (routeModule.getStaticProps) {
-              props = await routeModule.getStaticProps({
-                rootConfig,
-                params: sitemapItem.params
+      }
+      return true;
+    });
+    console.log("\nhtml output:");
+    const concurrency = Number(options?.concurrency || 10);
+    const numThreads = 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]) => {
+            try {
+              const result = await pool.run({
+                urlPath,
+                params: sitemapItem.params,
+                routeSrc: sitemapItem.route.src,
+                locale: sitemapItem.locale
               });
-              if (props?.notFound) {
-                return;
+              onPageResult(sitemapItem, result);
+            } catch (e) {
+              if (e instanceof BuildPageError) {
+                logBuildError(
+                  {
+                    route: sitemapItem.route,
+                    params: sitemapItem.params,
+                    urlPath
+                  },
+                  new Error(e.workerError)
+                );
               }
-            } 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
-                });
-              });
+              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) {
+            logBuildError(
+              { route: sitemapItem.route, params: sitemapItem.params, urlPath },
+              e
+            );
+            throw new Error(
+              `BuildError: ${urlPath} (${sitemapItem.route.src}) failed to build.`,
+              { cause: e }
+            );
           }
-          let html = data.html || "";
-          if (rootConfig.prettyHtml) {
-            html = await htmlPretty(html, rootConfig.prettyHtmlOptions);
-          } else if (rootConfig.minifyHtml) {
-            html = await htmlMinify(html, rootConfig.minifyHtmlOptions);
-          }
-          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 }
-          );
         }
-      }
-    );
+      );
+    }
     if (rootConfig.sitemap) {
       const sitemapXmlBuilder = [];
       sitemapXmlItems.sort((a, b) => a.url.localeCompare(b.url));
@@ -830,7 +719,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");
     }
@@ -844,6 +733,27 @@ async function build(rootProjectDir, options) {
 function isRouteFile(filepath) {
   return filepath.startsWith("routes") && isJsFile(filepath);
 }
+var MIN_PAGES_PER_THREAD = 10;
+function resolveNumThreads(threads, numPages) {
+  if (threads === void 0 || threads === false) {
+    return 0;
+  }
+  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);
+    if (numThreads <= 1) {
+      return 0;
+    }
+    console.log(`rendering with ${numThreads} worker threads`);
+    return numThreads;
+  }
+  const num = parseInt(threads);
+  if (isNaN(num) || num < 0) {
+    throw new Error(`invalid --threads value: ${threads}`);
+  }
+  return num;
+}
 function fileSize(filepath) {
   const stats = fsExtra.statSync(filepath);
   const bytes = stats.size;
@@ -892,18 +802,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);
 }
@@ -913,8 +820,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) {
@@ -924,7 +831,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);
     }
@@ -933,7 +840,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}`);
     }
@@ -944,7 +851,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);
       }
@@ -956,12 +863,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;
@@ -977,23 +884,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) {
@@ -1008,21 +915,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";
   }
@@ -1030,7 +937,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 ??= {};
@@ -1057,7 +964,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 };
@@ -1067,11 +974,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) {
@@ -1096,7 +1003,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
               };
@@ -1110,13 +1017,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 sirv from "sirv";
-import glob4 from "tiny-glob";
+import glob3 from "tiny-glob";
 
 // src/middleware/hooks.ts
 function hooksMiddleware() {
@@ -1204,8 +1111,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;
@@ -1214,7 +1121,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;
@@ -1232,7 +1139,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 {
@@ -1246,7 +1153,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 {
@@ -1288,7 +1195,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);
     }
@@ -1315,7 +1222,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);
       }
@@ -1396,19 +1303,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";
 
 // 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);
@@ -1416,7 +1323,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;
@@ -1443,8 +1350,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"
@@ -1472,7 +1379,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}`);
@@ -1599,16 +1506,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 "";
@@ -1617,11 +1524,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);
@@ -1839,10 +1746,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) {
@@ -2068,7 +1975,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 {
@@ -2131,7 +2038,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 {
@@ -2145,8 +2052,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"
@@ -2212,7 +2119,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)}`
@@ -2245,7 +2152,7 @@ async function secretsInit(opts) {
 }
 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");
@@ -2258,7 +2165,7 @@ async function secretsSet(name, opts) {
 }
 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(
@@ -2267,7 +2174,7 @@ async function secretsRm(name, opts) {
 }
 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) {
@@ -2444,10 +2351,11 @@ function printPushResult(result, rootDir, manifestFilePath) {
   console.log();
 }
 async function ensureRootGitignored(rootDir) {
-  const gitignore = path10.join(rootDir, ".gitignore");
+  const gitRoot = await gitToplevel(rootDir) ?? rootDir;
+  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());
@@ -2455,7 +2363,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;
 }
@@ -2467,6 +2375,27 @@ async function warnIfEnvNotIgnored(rootDir) {
     );
   }
 }
+function gitToplevel(rootDir) {
+  return new Promise((resolve) => {
+    try {
+      const child = spawn3("git", ["rev-parse", "--show-toplevel"], {
+        cwd: rootDir
+      });
+      let stdout = "";
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.on("error", () => resolve(void 0));
+      child.on("close", (code) => {
+        const toplevel = stdout.trim();
+        resolve(code === 0 && toplevel ? toplevel : void 0);
+      });
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
 function isPathGitIgnored(rootDir, relPath) {
   return new Promise((resolve) => {
     try {
@@ -2562,7 +2491,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];
@@ -2579,8 +2508,8 @@ 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";
@@ -2663,7 +2592,7 @@ function printUpdateNotice(current, latest) {
 
 // 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();
@@ -2714,13 +2643,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);
@@ -2748,7 +2677,7 @@ async function dev(rootProjectDir, options) {
       "rootConfigDependencies"
     );
     const dependencies = [
-      path12.resolve(rootDir, "root.config.ts"),
+      path11.resolve(rootDir, "root.config.ts"),
       ...rootConfigDependencies
     ];
     viteServer.watcher.add(dependencies);
@@ -2776,7 +2705,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"
   });
@@ -2791,6 +2720,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);
@@ -2812,7 +2742,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 }));
       }
@@ -2840,10 +2770,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);
       }
@@ -2860,7 +2790,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));
   }
@@ -2879,7 +2809,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
       );
@@ -2903,7 +2833,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;
@@ -2935,7 +2865,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);
@@ -2953,7 +2883,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);
@@ -2979,7 +2909,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) {
@@ -2993,10 +2923,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(
@@ -3022,7 +2952,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(
@@ -3109,8 +3039,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)) {
@@ -3123,7 +3053,7 @@ function updateAppYamlEnv(appYamlPath, appYaml) {
       }
     }
   });
-  fs9.writeFileSync(appYamlPath, content, "utf8");
+  fs7.writeFileSync(appYamlPath, content, "utf8");
   return backupAppYaml;
 }
 function getTimestamp() {
@@ -3147,15 +3077,14 @@ 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 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";
@@ -3169,11 +3098,12 @@ async function preview(rootProjectDir, options) {
 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);
@@ -3195,7 +3125,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());
@@ -3214,14 +3144,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\`.`
@@ -3261,7 +3191,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 });
@@ -3279,7 +3209,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);
@@ -3293,15 +3223,14 @@ 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 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";
@@ -3315,11 +3244,12 @@ async function start(rootProjectDir, options) {
 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);
@@ -3341,7 +3271,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());
@@ -3360,14 +3290,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\`.`
@@ -3407,7 +3337,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 });
@@ -3425,7 +3355,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);
@@ -3466,6 +3396,9 @@ 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/.*"',
@@ -3532,4 +3465,4 @@ export {
   createProdServer,
   CliRunner
 };
-//# sourceMappingURL=chunk-VQPDCDKL.js.map
+//# sourceMappingURL=chunk-E4F6CMO3.js.map