@blinkk/root 1.0.0-rc.4 → 1.0.0-rc.41

package/dist/{chunk-CY3DVKXO.js → chunk-XOOP364R.js}

@@ -1,9 +1,12 @@
 import {
+  headersMiddleware,
   rootProjectMiddleware,
   sessionMiddleware,
   trailingSlashMiddleware
-} from "./chunk-WNXIRMFF.js";
+} from "./chunk-TZAHHHA4.js";
 import {
+  bundleRootConfig,
+  copyDir,
   copyGlob,
   createViteServer,
   dirExists,
@@ -11,24 +14,31 @@ import {
   fileExists,
   isDirectory,
   isJsFile,
+  loadBundledConfig,
   loadJson,
   loadRootConfig,
   makeDir,
   rmDir,
-  writeFile
-} from "./chunk-J2ANSYAE.js";
+  writeFile,
+  writeJson
+} from "./chunk-UYHD775U.js";
 import {
   configureServerPlugins,
   getVitePlugins
 } from "./chunk-QKBMWK5B.js";
 import {
+  RouteTrie,
   htmlMinify,
   htmlPretty,
   isValidTagName,
   parseTagNames
-} from "./chunk-DFBTOMQF.js";
+} from "./chunk-IUQLRDFW.js";
 
-// src/cli/commands/build.ts
+// src/cli/cli.ts
+import { Command } from "commander";
+import { bgGreen, black } from "kleur/colors";
+
+// src/cli/build.ts
 import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 import fsExtra from "fs-extra";
@@ -102,10 +112,9 @@ var ElementGraph = class _ElementGraph {
   }
 };
 async function getElements(rootConfig) {
-  var _a;
   const rootDir = rootConfig.rootDir;
   const elementsDirs = getElementsDirs(rootConfig);
-  const excludePatterns = ((_a = rootConfig.elements) == null ? void 0 : _a.exclude) || [];
+  const excludePatterns = rootConfig.elements?.exclude || [];
   const excludeElement = (moduleId) => {
     return excludePatterns.some((pattern) => Boolean(moduleId.match(pattern)));
   };
@@ -130,11 +139,10 @@ async function getElements(rootConfig) {
   return graph;
 }
 function getElementsDirs(rootConfig) {
-  var _a;
   const rootDir = rootConfig.rootDir;
   const workspaceRoot = searchForWorkspaceRoot(rootDir);
   const elementsDirs = [path.join(rootDir, "elements")];
-  const elementsInclude = ((_a = rootConfig.elements) == null ? void 0 : _a.include) || [];
+  const elementsInclude = rootConfig.elements?.include || [];
   for (const dirPath of elementsInclude) {
     const elementsDir = path.resolve(rootDir, dirPath);
     if (!directoryContains(rootDir, elementsDir)) {
@@ -312,16 +320,15 @@ async function batchAsyncCalls(data, batchSize, asyncFunction) {
   return result;
 }
 
-// src/cli/commands/build.ts
+// src/cli/build.ts
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 async function build(rootProjectDir, options) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  const mode = (options == null ? void 0 : options.mode) || "production";
+  const mode = options?.mode || "production";
   process.env.NODE_ENV = mode;
   const rootDir = path3.resolve(rootProjectDir || process.cwd());
   const rootConfig = await loadRootConfig(rootDir, { command: "build" });
   const distDir = path3.join(rootDir, "dist");
-  const ssrOnly = (options == null ? void 0 : options.ssrOnly) || false;
+  const ssrOnly = options?.ssrOnly || false;
   console.log();
   console.log(`${dim("\u2503")} project:  ${rootDir}`);
   console.log(`${dim("\u2503")} output:   ${distDir}/html`);
@@ -379,7 +386,7 @@ async function build(rootProjectDir, options) {
       Object.assign(ssrInput, plugin.ssrInput());
     }
   });
-  const noExternalConfig = (_a = viteConfig.ssr) == null ? void 0 : _a.noExternal;
+  const noExternalConfig = viteConfig.ssr?.noExternal;
   const noExternal = [];
   if (noExternalConfig) {
     if (Array.isArray(noExternalConfig)) {
@@ -392,9 +399,9 @@ async function build(rootProjectDir, options) {
     ...baseConfig,
     publicDir: false,
     build: {
-      ...viteConfig == null ? void 0 : viteConfig.build,
+      ...viteConfig?.build,
       rollupOptions: {
-        ...(_b = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _b.rollupOptions,
+        ...viteConfig?.build?.rollupOptions,
         input: ssrInput,
         output: {
           format: "esm",
@@ -410,21 +417,22 @@ async function build(rootProjectDir, options) {
       target: "esnext",
       minify: false,
       modulePreload: { polyfill: false },
-      reportCompressedSize: false
+      reportCompressedSize: false,
+      sourcemap: "inline"
     },
     ssr: {
       ...viteConfig.ssr,
       target: "node",
-      noExternal: ["@blinkk/root", ...noExternal]
+      noExternal: ["@blinkk/root", "@blinkk/root-cms/richtext", ...noExternal]
     }
   });
   await viteBuild({
     ...baseConfig,
     publicDir: false,
     build: {
-      ...viteConfig == null ? void 0 : viteConfig.build,
+      ...viteConfig?.build,
       rollupOptions: {
-        ...(_c = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _c.rollupOptions,
+        ...viteConfig?.build?.rollupOptions,
         input: [...routeFiles],
         output: {
           format: "esm",
@@ -432,12 +440,12 @@ async function build(rootProjectDir, options) {
           assetFileNames: "assets/[name].[hash][extname]",
           chunkFileNames: "chunks/[hash].min.js",
           sanitizeFileName,
-          ...(_e = (_d = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _d.rollupOptions) == null ? void 0 : _e.output
+          ...viteConfig?.build?.rollupOptions?.output
         }
       },
-      outDir: path3.join(distDir, "routes"),
+      outDir: path3.join(distDir, ".build/routes"),
       ssr: true,
-      ssrManifest: true,
+      ssrManifest: false,
       ssrEmitAssets: true,
       manifest: true,
       cssCodeSplit: true,
@@ -453,9 +461,9 @@ async function build(rootProjectDir, options) {
       ...baseConfig,
       publicDir: false,
       build: {
-        ...viteConfig == null ? void 0 : viteConfig.build,
+        ...viteConfig?.build,
         rollupOptions: {
-          ...(_f = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _f.rollupOptions,
+          ...viteConfig?.build?.rollupOptions,
           input: [...elements, ...bundleScripts],
           output: {
             format: "esm",
@@ -463,10 +471,10 @@ async function build(rootProjectDir, options) {
             assetFileNames: "assets/[name].[hash][extname]",
             chunkFileNames: "chunks/[hash].min.js",
             sanitizeFileName,
-            ...(_h = (_g = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _g.rollupOptions) == null ? void 0 : _h.output
+            ...viteConfig?.build?.rollupOptions?.output
           }
         },
-        outDir: path3.join(distDir, "client"),
+        outDir: path3.join(distDir, ".build/client"),
         ssr: false,
         ssrManifest: false,
         manifest: true,
@@ -478,18 +486,22 @@ async function build(rootProjectDir, options) {
       }
     });
   } else {
-    await writeFile(path3.join(distDir, "client/manifest.json"), "{}");
+    await writeFile(
+      path3.join(distDir, ".build/client/.vite/manifest.json"),
+      "{}"
+    );
   }
+  await bundleRootConfig(rootDir, path3.join(distDir, "root.config.js"));
   await copyGlob(
     "**/*.css",
-    path3.join(distDir, "routes"),
-    path3.join(distDir, "client")
+    path3.join(distDir, ".build/routes"),
+    path3.join(distDir, ".build/client")
   );
   const routesManifest = await loadJson(
-    path3.join(distDir, "routes/manifest.json")
+    path3.join(distDir, ".build/routes/.vite/manifest.json")
   );
   const clientManifest = await loadJson(
-    path3.join(distDir, "client/manifest.json")
+    path3.join(distDir, ".build/client/.vite/manifest.json")
   );
   function collectRouteCss(asset, cssDeps, visited) {
     if (!asset || !asset.file || visited.has(asset.file)) {
@@ -525,12 +537,12 @@ async function build(rootProjectDir, options) {
   );
   const rootManifest = assetMap.toJson();
   await writeFile(
-    path3.join(distDir, "client/root-manifest.json"),
+    path3.join(distDir, ".root/manifest.json"),
     JSON.stringify(rootManifest, null, 2)
   );
   const elementGraphJson = elementGraph.toJson();
   await writeFile(
-    path3.join(distDir, "client/root-element-graph.json"),
+    path3.join(distDir, ".root/elements.json"),
     JSON.stringify(elementGraphJson, null, 2)
   );
   const buildDir = path3.join(distDir, "html");
@@ -540,25 +552,37 @@ async function build(rootProjectDir, options) {
   } else {
     await makeDir(buildDir);
   }
+  const seenAssets = /* @__PURE__ */ new Set();
+  async function copyAssetToDistHtml(assetUrl) {
+    if (seenAssets.has(assetUrl)) {
+      return;
+    }
+    seenAssets.add(assetUrl);
+    const assetRelPath = assetUrl.slice(1);
+    const assetFrom = path3.join(distDir, ".build/client", assetRelPath);
+    const assetTo = path3.join(buildDir, assetRelPath);
+    if (!await fileExists(assetFrom)) {
+      console.log(`${assetFrom} does not exist`);
+      return;
+    }
+    await fsExtra.copy(assetFrom, assetTo);
+    printFileOutput(fileSize(assetTo), "dist/html/", assetRelPath);
+  }
   console.log("\njs/css output:");
   await Promise.all(
     Object.keys(rootManifest).map(async (src) => {
+      const assetData = rootManifest[src];
       if (isRouteFile(src)) {
+        const importedCss = assetData.importedCss || [];
+        for (const cssAssetUrl of importedCss) {
+          await copyAssetToDistHtml(cssAssetUrl);
+        }
         return;
       }
-      const assetData = rootManifest[src];
       if (!assetData.assetUrl) {
         return;
       }
-      const assetRelPath = assetData.assetUrl.slice(1);
-      const assetFrom = path3.join(distDir, "client", assetRelPath);
-      const assetTo = path3.join(buildDir, assetRelPath);
-      if (!await fileExists(assetFrom)) {
-        console.log(`${assetFrom} does not exist`);
-        return;
-      }
-      await fsExtra.copy(assetFrom, assetTo);
-      printFileOutput(fileSize(assetTo), "dist/html/", assetRelPath);
+      await copyAssetToDistHtml(assetData.assetUrl);
     })
   );
   if (!ssrOnly) {
@@ -566,7 +590,7 @@ async function build(rootProjectDir, options) {
     const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
     const sitemap = await renderer.getSitemap();
     console.log("\nhtml output:");
-    const batchSize = Number((options == null ? void 0 : options.concurrency) || 10);
+    const batchSize = Number(options?.concurrency || 10);
     await batchAsyncCalls(Object.keys(sitemap), batchSize, async (urlPath) => {
       const { route, params } = sitemap[urlPath];
       try {
@@ -651,8 +675,164 @@ function formatParams(params) {
   }).join("\n");
 }
 
-// src/cli/commands/dev.ts
-import path5 from "node:path";
+// src/cli/create-package.ts
+import { promises as fs3 } 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 = path4.resolve(rootProjectDir || process.cwd());
+  const distDir = path4.join(rootDir, "dist");
+  const target = options?.target || await getDefaultTarget(rootDir);
+  const outDir = path4.resolve(options?.out || target || "out");
+  await build(rootProjectDir, { ssrOnly: true, mode });
+  await rmDir(outDir);
+  await makeDir(outDir);
+  await copyDir(distDir, path4.resolve(outDir, "dist"));
+  const collectionsDir = path4.resolve(rootDir, "collections");
+  if (await dirExists(collectionsDir)) {
+    await copyDir(collectionsDir, path4.join(outDir, "collections"));
+  }
+  const packageJson = await generatePackageJson(rootDir);
+  if (target === "appengine") {
+    await onAppEngine({ rootDir, packageJson, outDir });
+  } else if (target === "firebase") {
+    await onFirebase({ rootDir, packageJson, outDir });
+  }
+  await writeJson(path4.resolve(outDir, "package.json"), packageJson);
+  console.log("done!");
+  console.log(`saved package to ${outDir}`);
+}
+async function getDefaultTarget(rootDir) {
+  const firebaseConfigPath = path4.resolve(rootDir, "firebase.json");
+  if (await fileExists(firebaseConfigPath)) {
+    return "firebase";
+  }
+  const appEngineConfigPath = path4.resolve(rootDir, "app.yaml");
+  if (await fileExists(appEngineConfigPath)) {
+    return "appengine";
+  }
+  return null;
+}
+async function generatePackageJson(rootDir) {
+  const packageJson = await loadJson(
+    path4.resolve(rootDir, "package.json")
+  );
+  if (packageJson.peerDependencies) {
+    await updatePeerDepsFromWorkspace(rootDir, packageJson);
+  }
+  return packageJson;
+}
+async function updatePeerDepsFromWorkspace(rootDir, packageJson) {
+  const requiredPeerDeps = getRequiredPeerDeps(packageJson);
+  if (requiredPeerDeps.length === 0) {
+    return;
+  }
+  const workspaceRoot = await findWorkspaceRoot(rootDir);
+  if (!workspaceRoot) {
+    return;
+  }
+  const workspacePackageJsonPath = path4.resolve(workspaceRoot, "package.json");
+  const workspacePackageJson = await loadJson(
+    workspacePackageJsonPath
+  );
+  const workspaceDeps = workspacePackageJson.dependencies || {};
+  function setDep(name, value) {
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    packageJson.dependencies[name] = value;
+  }
+  for (const peerDep of requiredPeerDeps) {
+    const workspaceDepVersion = workspaceDeps[peerDep];
+    if (workspaceDepVersion) {
+      setDep(peerDep, workspaceDepVersion);
+    } else {
+      console.warn(
+        `could not find peer dep "${peerDep}" in workspace "${workspacePackageJsonPath}"`
+      );
+    }
+  }
+}
+async function findWorkspaceRoot(rootDir) {
+  const parentDir = path4.dirname(rootDir);
+  if (parentDir === "/") {
+    return null;
+  }
+  const pnpmWorkspaceFile = path4.resolve(parentDir, "pnpm-workspace.yaml");
+  if (await fileExists(pnpmWorkspaceFile)) {
+    return parentDir;
+  }
+  const packageJsonPath = path4.resolve(parentDir, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    const parentPackageJson = await loadJson(packageJsonPath);
+    if (parentPackageJson && parentPackageJson.workspaces) {
+      return parentDir;
+    }
+  }
+  return findWorkspaceRoot(parentDir);
+}
+function getRequiredPeerDeps(packageJson) {
+  const requiredPeerDeps = [];
+  const peerDeps = packageJson.peerDependencies || {};
+  const peerDepsMeta = packageJson.peerDependenciesMeta || {};
+  for (const key in peerDeps) {
+    const meta = peerDepsMeta[key];
+    if (!meta?.optional) {
+      requiredPeerDeps.push(key);
+    }
+  }
+  return requiredPeerDeps;
+}
+async function onAppEngine(options) {
+  const { rootDir, outDir } = options;
+  const configPath = path4.resolve(rootDir, "app.yaml");
+  if (await fileExists(configPath)) {
+    await fs3.copyFile(configPath, path4.resolve(outDir, "app.yaml"));
+  }
+}
+async function onFirebase(options) {
+  const { rootDir, outDir } = options;
+  const outBasename = path4.basename(outDir);
+  if (outBasename === "functions") {
+    const indexTsFile = path4.resolve(rootDir, "index.ts");
+    if (await fileExists(indexTsFile)) {
+      await bundleTsFile(indexTsFile, path4.resolve(outDir, "index.js"));
+    }
+  }
+}
+async function bundleTsFile(srcPath, outPath) {
+  await esbuild({
+    entryPoints: [srcPath],
+    bundle: true,
+    minify: true,
+    platform: "node",
+    outfile: outPath,
+    sourcemap: "inline",
+    metafile: true,
+    format: "esm",
+    plugins: [
+      {
+        name: "externalize-deps",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            const id = args.path;
+            if (id[0] !== "." && !path4.isAbsolute(id)) {
+              return {
+                external: true
+              };
+            }
+            return null;
+          });
+        }
+      }
+    ]
+  });
+}
+
+// src/cli/dev.ts
+import path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import cookieParser from "cookie-parser";
 import { default as express } from "express";
@@ -683,8 +863,53 @@ var Hooks = class {
   }
 };
 
+// src/middleware/redirects.ts
+function redirectsMiddleware(options) {
+  const routeTrie = new RouteTrie();
+  const redirects = options.redirects || [];
+  redirects.forEach((redirect) => {
+    if (!verifyRedirectConfig(redirect)) {
+      console.warn("ignoring invalid redirect config:", redirect);
+      return;
+    }
+    routeTrie.add(redirect.source, redirect);
+  });
+  return (req, res, next) => {
+    const [redirect, params] = routeTrie.get(req.path);
+    if (redirect) {
+      const destination = replaceParams(redirect.destination, params);
+      const code = redirect.type || 302;
+      res.redirect(code, destination);
+      return;
+    }
+    next();
+  };
+}
+function verifyRedirectConfig(redirect) {
+  if (!redirect.source) {
+    return false;
+  }
+  if (!redirect.destination) {
+    return false;
+  }
+  return true;
+}
+function replaceParams(urlPathFormat, params) {
+  const urlPath = urlPathFormat.replaceAll(
+    /\[\[?(\.\.\.)?([\w\-_]*)\]?\]/g,
+    (match, _wildcard, key) => {
+      const val = params[key];
+      if (!val) {
+        throw new Error(`unreplaced param ${match} in url: ${urlPathFormat}`);
+      }
+      return val;
+    }
+  );
+  return urlPath;
+}
+
 // src/render/asset-map/dev-asset-map.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import { searchForWorkspaceRoot as searchForWorkspaceRoot2 } from "vite";
 var DevServerAssetMap = class {
   constructor(rootConfig, moduleGraph) {
@@ -692,7 +917,7 @@ var DevServerAssetMap = class {
     this.moduleGraph = moduleGraph;
   }
   async get(src) {
-    const file = path4.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;
@@ -724,7 +949,7 @@ var DevServerAssetMap = class {
     return null;
   }
   filePathToSrc(file) {
-    return path4.relative(this.rootConfig.rootDir, file);
+    return path5.relative(this.rootConfig.rootDir, file);
   }
 };
 var DevServerAsset = class _DevServerAsset {
@@ -761,7 +986,7 @@ var DevServerAsset = class _DevServerAsset {
       return;
     }
     visited.add(asset.moduleId);
-    const parts = path4.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);
     }
@@ -788,7 +1013,7 @@ var DevServerAsset = class _DevServerAsset {
     }
     visited.add(asset.assetUrl);
     if (asset.src.endsWith(".scss")) {
-      const parts = path4.parse(asset.src);
+      const parts = path5.parse(asset.src);
       if (!parts.name.startsWith("_")) {
         urls.add(asset.assetUrl);
       }
@@ -854,47 +1079,63 @@ function randString(len) {
   return result.join("");
 }
 
-// src/cli/commands/dev.ts
-var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+// src/cli/dev.ts
+var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
 async function dev(rootProjectDir, options) {
   process.env.NODE_ENV = "development";
-  const rootDir = path5.resolve(rootProjectDir || process.cwd());
+  const rootDir = path6.resolve(rootProjectDir || process.cwd());
   const defaultPort = parseInt(process.env.PORT || "4007");
-  const host = (options == null ? void 0 : options.host) || "localhost";
+  const host = options?.host || "localhost";
   const port = await findOpenPort(defaultPort, defaultPort + 10);
+  const server = await createDevServer({ rootDir, port });
+  const rootConfig = server.get("rootConfig");
+  const basePath = rootConfig.base || "";
   console.log();
   console.log(`${dim2("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim2("\u2503")} server:   http://${host}:${port}`);
+  console.log(`${dim2("\u2503")} server:   http://${host}:${port}${basePath}`);
+  if (testCmsEnabled(rootConfig)) {
+    console.log(`${dim2("\u2503")} cms:      http://${host}:${port}/cms/`);
+  }
   console.log(`${dim2("\u2503")} mode:     development`);
   console.log();
-  const server = await createDevServer({ rootDir, port });
   server.listen(port, host);
 }
 async function createDevServer(options) {
-  var _a;
-  const rootDir = path5.resolve((options == null ? void 0 : options.rootDir) || process.cwd());
+  const rootDir = path6.resolve(options?.rootDir || process.cwd());
   const rootConfig = await loadRootConfig(rootDir, { command: "dev" });
-  const port = options == null ? void 0 : options.port;
+  const port = options?.port;
   const server = express();
+  server.set("rootConfig", rootConfig);
   server.disable("x-powered-by");
+  const { viteServer, viteMiddleware } = await createViteMiddleware({
+    rootConfig,
+    port
+  });
   server.use(rootProjectMiddleware({ rootConfig }));
-  server.use(await viteServerMiddleware({ rootConfig, port }));
+  server.use(viteMiddleware);
   server.use(hooksMiddleware());
-  const sessionCookieSecret = ((_a = rootConfig.server) == null ? void 0 : _a.sessionCookieSecret) || randString(36);
+  const sessionCookieSecret = rootConfig.server?.sessionCookieSecret || randString(36);
   server.use(cookieParser(sessionCookieSecret));
   server.use(sessionMiddleware());
   const plugins = rootConfig.plugins || [];
   await configureServerPlugins(
     server,
     async () => {
-      var _a2;
-      const userMiddlewares = ((_a2 = rootConfig.server) == null ? void 0 : _a2.middlewares) || [];
+      const userMiddlewares = rootConfig.server?.middlewares || [];
       for (const middleware of userMiddlewares) {
         server.use(middleware);
       }
-      const publicDir = path5.join(rootDir, "public");
+      if (rootConfig.server?.redirects) {
+        server.use(
+          redirectsMiddleware({ redirects: rootConfig.server.redirects })
+        );
+      }
+      if (rootConfig.server?.headers) {
+        server.use(headersMiddleware({ rootConfig }));
+      }
+      const publicDir = path6.join(rootDir, "public");
       if (await dirExists(publicDir)) {
-        server.use(sirv(publicDir, { dev: false }));
+        server.use(rootPublicDirMiddleware({ publicDir, viteServer }));
       }
       server.use(trailingSlashMiddleware({ rootConfig }));
       server.use(rootDevServerMiddleware());
@@ -906,7 +1147,7 @@ async function createDevServer(options) {
   );
   return server;
 }
-async function viteServerMiddleware(options) {
+async function createViteMiddleware(options) {
   const rootConfig = options.rootConfig;
   const rootDir = rootConfig.rootDir;
   let elementGraph = await getElements(rootConfig);
@@ -914,10 +1155,10 @@ async function viteServerMiddleware(options) {
     return sourceFile.relPath;
   });
   const bundleScripts = [];
-  if (await isDirectory(path5.join(rootDir, "bundles"))) {
+  if (await isDirectory(path6.join(rootDir, "bundles"))) {
     const bundleFiles = await glob3("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
-      const parts = path5.parse(file);
+      const parts = path6.parse(file);
       if (isJsFile(parts.base)) {
         bundleScripts.push(file);
       }
@@ -929,7 +1170,7 @@ async function viteServerMiddleware(options) {
     optimizeDeps
   });
   function isInElementsDir(changedFilePath) {
-    const filePath = path5.resolve(changedFilePath);
+    const filePath = path6.resolve(changedFilePath);
     const elementsDirs = getElementsDirs(rootConfig);
     return elementsDirs.some((dirPath) => filePath.startsWith(dirPath));
   }
@@ -945,10 +1186,10 @@ async function viteServerMiddleware(options) {
       console.log(`element deleted: ${filePath}`);
     }
   });
-  return async (req, res, next) => {
+  const viteMiddleware = async (req, res, next) => {
     try {
       req.viteServer = viteServer;
-      const renderModulePath = path5.resolve(__dirname2, "./render.js");
+      const renderModulePath = path6.resolve(__dirname2, "./render.js");
       const render = await viteServer.ssrLoadModule(
         renderModulePath
       );
@@ -962,6 +1203,28 @@ async function viteServerMiddleware(options) {
       next(e);
     }
   };
+  return { viteServer, viteMiddleware };
+}
+function rootPublicDirMiddleware(options) {
+  const publicDir = options.publicDir;
+  const sirvOptions = { dev: false };
+  let handler = sirv(publicDir, sirvOptions);
+  const reloadPublicDirCache = debounce(() => {
+    handler = sirv(publicDir, sirvOptions);
+  }, 1e3);
+  function isInPublicDir(changedFilePath) {
+    const filePath = path6.resolve(changedFilePath);
+    return filePath.startsWith(publicDir);
+  }
+  const watcher = options.viteServer.watcher;
+  watcher.on("all", (event, filepath) => {
+    if (isInPublicDir(filepath)) {
+      reloadPublicDirCache();
+    }
+  });
+  return (req, res, next) => {
+    handler(req, res, next);
+  };
 }
 function rootDevServerMiddleware() {
   return async (req, res, next) => {
@@ -980,7 +1243,7 @@ function rootDevServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path5.extname(url);
+      const ext = path6.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer404(req);
@@ -998,7 +1261,7 @@ function rootDevServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path5.extname(url);
+      const ext = path6.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer500(req, err);
@@ -1010,9 +1273,20 @@ function rootDevServer500Middleware() {
     next(err);
   };
 }
+function testCmsEnabled(rootConfig) {
+  const plugins = rootConfig.plugins || [];
+  return Boolean(plugins.find((plugin) => plugin.name === "root-cms"));
+}
+function debounce(fn, timeout) {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), timeout);
+  };
+}
 
-// src/cli/commands/preview.ts
-import path6 from "node:path";
+// src/cli/preview.ts
+import path7 from "node:path";
 import compression from "compression";
 import cookieParser2 from "cookie-parser";
 import { default as express2 } from "express";
@@ -1020,10 +1294,10 @@ import { dim as dim3 } from "kleur/colors";
 import sirv2 from "sirv";
 async function preview(rootProjectDir, options) {
   process.env.NODE_ENV = "development";
-  const rootDir = path6.resolve(rootProjectDir || process.cwd());
+  const rootDir = path7.resolve(rootProjectDir || process.cwd());
   const server = await createPreviewServer({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
-  const host = (options == null ? void 0 : options.host) || "localhost";
+  const host = options?.host || "localhost";
   console.log();
   console.log(`${dim3("\u2503")} project:  ${rootDir}`);
   console.log(`${dim3("\u2503")} server:   http://${host}:${port}`);
@@ -1032,29 +1306,35 @@ async function preview(rootProjectDir, options) {
   server.listen(port, host);
 }
 async function createPreviewServer(options) {
-  var _a;
   const rootDir = options.rootDir;
-  const rootConfig = await loadRootConfig(rootDir, { command: "preview" });
-  const distDir = path6.join(rootDir, "dist");
+  const rootConfig = await loadBundledConfig(rootDir, { command: "preview" });
+  const distDir = path7.join(rootDir, "dist");
   const server = express2();
   server.disable("x-powered-by");
   server.use(compression());
   server.use(rootProjectMiddleware({ rootConfig }));
   server.use(await rootPreviewRendererMiddleware({ rootConfig, distDir }));
   server.use(hooksMiddleware());
-  const sessionCookieSecret = ((_a = rootConfig.server) == null ? void 0 : _a.sessionCookieSecret) || randString(36);
+  const sessionCookieSecret = rootConfig.server?.sessionCookieSecret || randString(36);
   server.use(cookieParser2(sessionCookieSecret));
   server.use(sessionMiddleware());
   const plugins = rootConfig.plugins || [];
   configureServerPlugins(
     server,
     async () => {
-      var _a2;
-      const userMiddlewares = ((_a2 = rootConfig.server) == null ? void 0 : _a2.middlewares) || [];
+      const userMiddlewares = rootConfig.server?.middlewares || [];
       userMiddlewares.forEach((middleware) => {
         server.use(middleware);
       });
-      const publicDir = path6.join(distDir, "html");
+      if (rootConfig.server?.redirects) {
+        server.use(
+          redirectsMiddleware({ redirects: rootConfig.server.redirects })
+        );
+      }
+      if (rootConfig.server?.headers) {
+        server.use(headersMiddleware({ rootConfig }));
+      }
+      const publicDir = path7.join(distDir, "html");
       server.use(sirv2(publicDir, { dev: false }));
       server.use(trailingSlashMiddleware({ rootConfig }));
       server.use(rootPreviewServerMiddleware());
@@ -1068,20 +1348,17 @@ async function createPreviewServer(options) {
 }
 async function rootPreviewRendererMiddleware(options) {
   const { distDir, rootConfig } = options;
-  const render = await import(path6.join(distDir, "server/render.js"));
-  const manifestPath = path6.join(distDir, "client/root-manifest.json");
+  const render = await import(path7.join(distDir, "server/render.js"));
+  const manifestPath = path7.join(distDir, ".root/manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
       `could not find ${manifestPath}. run \`root build\` before \`root preview\`.`
     );
   }
-  const elementGraphJsonPath = path6.join(
-    distDir,
-    "client/root-element-graph.json"
-  );
+  const elementGraphJsonPath = path7.join(distDir, ".root/elements.json");
   if (!await fileExists(elementGraphJsonPath)) {
     throw new Error(
-      `could not find ${elementGraphJsonPath}. run \`root build\` before \`root start\`.`
+      `could not find ${elementGraphJsonPath}. run \`root build\` before \`root preview\`.`
     );
   }
   const rootManifest = await loadJson(manifestPath);
@@ -1103,7 +1380,7 @@ function rootPreviewServerMiddleware() {
       try {
         console.error(`error rendering ${req.originalUrl}`);
         console.error(e.stack || e);
-        const { html } = await renderer.renderError(e);
+        const { html } = await renderer.renderDevServer500(req, e);
         res.status(500).set({ "Content-Type": "text/html" }).end(html);
       } catch (e2) {
         console.error("failed to render custom error");
@@ -1118,7 +1395,7 @@ function rootPreviewServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path6.extname(url);
+      const ext = path7.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.render404({ currentPath: url });
@@ -1136,7 +1413,7 @@ function rootPreviewServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path6.extname(url);
+      const ext = path7.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer500(req, err);
@@ -1149,8 +1426,8 @@ function rootPreviewServer500Middleware() {
   };
 }
 
-// src/cli/commands/start.ts
-import path7 from "node:path";
+// src/cli/start.ts
+import path8 from "node:path";
 import compression2 from "compression";
 import cookieParser3 from "cookie-parser";
 import { default as express3 } from "express";
@@ -1158,10 +1435,10 @@ import { dim as dim4 } from "kleur/colors";
 import sirv3 from "sirv";
 async function start(rootProjectDir, options) {
   process.env.NODE_ENV = "production";
-  const rootDir = path7.resolve(rootProjectDir || process.cwd());
+  const rootDir = path8.resolve(rootProjectDir || process.cwd());
   const server = await createProdServer({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
-  const host = (options == null ? void 0 : options.host) || "localhost";
+  const host = options?.host || "localhost";
   console.log();
   console.log(`${dim4("\u2503")} project:  ${rootDir}`);
   console.log(`${dim4("\u2503")} server:   http://${host}:${port}`);
@@ -1170,29 +1447,35 @@ async function start(rootProjectDir, options) {
   server.listen(port, host);
 }
 async function createProdServer(options) {
-  var _a;
   const rootDir = options.rootDir;
-  const rootConfig = await loadRootConfig(rootDir, { command: "start" });
-  const distDir = path7.join(rootDir, "dist");
+  const rootConfig = await loadBundledConfig(rootDir, { command: "start" });
+  const distDir = path8.join(rootDir, "dist");
   const server = express3();
   server.disable("x-powered-by");
   server.use(compression2());
   server.use(rootProjectMiddleware({ rootConfig }));
   server.use(await rootProdRendererMiddleware({ rootConfig, distDir }));
   server.use(hooksMiddleware());
-  const sessionCookieSecret = ((_a = rootConfig.server) == null ? void 0 : _a.sessionCookieSecret) || randString(36);
+  const sessionCookieSecret = rootConfig.server?.sessionCookieSecret || randString(36);
   server.use(cookieParser3(sessionCookieSecret));
   server.use(sessionMiddleware());
   const plugins = rootConfig.plugins || [];
   configureServerPlugins(
     server,
     async () => {
-      var _a2;
-      const userMiddlewares = ((_a2 = rootConfig.server) == null ? void 0 : _a2.middlewares) || [];
+      const userMiddlewares = rootConfig.server?.middlewares || [];
       userMiddlewares.forEach((middleware) => {
         server.use(middleware);
       });
-      const publicDir = path7.join(distDir, "html");
+      if (rootConfig.server?.redirects) {
+        server.use(
+          redirectsMiddleware({ redirects: rootConfig.server.redirects })
+        );
+      }
+      if (rootConfig.server?.headers) {
+        server.use(headersMiddleware({ rootConfig }));
+      }
+      const publicDir = path8.join(distDir, "html");
       server.use(sirv3(publicDir, { dev: false }));
       server.use(trailingSlashMiddleware({ rootConfig }));
       server.use(rootProdServerMiddleware());
@@ -1206,17 +1489,14 @@ async function createProdServer(options) {
 }
 async function rootProdRendererMiddleware(options) {
   const { distDir, rootConfig } = options;
-  const render = await import(path7.join(distDir, "server/render.js"));
-  const manifestPath = path7.join(distDir, "client/root-manifest.json");
+  const render = await import(path8.join(distDir, "server/render.js"));
+  const manifestPath = path8.join(distDir, ".root/manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
       `could not find ${manifestPath}. run \`root build\` before \`root start\`.`
     );
   }
-  const elementGraphJsonPath = path7.join(
-    distDir,
-    "client/root-element-graph.json"
-  );
+  const elementGraphJsonPath = path8.join(distDir, ".root/elements.json");
   if (!await fileExists(elementGraphJsonPath)) {
     throw new Error(
       `could not find ${elementGraphJsonPath}. run \`root build\` before \`root start\`.`
@@ -1256,7 +1536,7 @@ function rootProdServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path7.extname(url);
+      const ext = path8.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.render404({ currentPath: url });
@@ -1274,7 +1554,7 @@ function rootProdServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path7.extname(url);
+      const ext = path8.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderError(err);
@@ -1287,13 +1567,61 @@ function rootProdServer500Middleware() {
   };
 }
 
+// src/cli/cli.ts
+var CliRunner = class {
+  constructor(name, version) {
+    this.name = name;
+    this.version = version;
+  }
+  async run(argv) {
+    const program = new Command("root");
+    program.version(this.version);
+    program.option("-q, --quiet", "quiet");
+    program.hook("preAction", (cmd) => {
+      if (!cmd.opts().quiet) {
+        console.log(
+          `\u{1F955} ${bgGreen(black(` ${this.name} `))} v${this.version}
+`
+        );
+      }
+    });
+    program.command("build [path]").description("generates a static build").option("--ssr-only", "produce a ssr-only build").option(
+      "--mode <mode>",
+      "see: https://vitejs.dev/guide/env-and-mode.html#modes",
+      "production"
+    ).option(
+      "-c, --concurrency <num>",
+      "number of files to build concurrently",
+      "10"
+    ).action(build);
+    program.command("create-package [path]").alias("package").description(
+      "creates a standalone npm package for deployment to various hosting services"
+    ).option("--target <target>", "hosting target, i.e. appengine or firebase").option("--out <outdir>", "output dir").option("--mode <mode>", "deployment mode, i.e. production or preview").action(createPackage);
+    program.command("dev [path]").description("starts the server in development mode").option(
+      "--host <host>",
+      "network address the server should listen on, e.g. 127.0.0.1"
+    ).action(dev);
+    program.command("preview [path]").description("starts the server in preview mode").option(
+      "--host <host>",
+      "network address the server should listen on, e.g. 127.0.0.1"
+    ).action(preview);
+    program.command("start [path]").description("starts the server in production mode").option(
+      "--host <host>",
+      "network address the server should listen on, e.g. 127.0.0.1"
+    ).action(start);
+    await program.parseAsync(argv);
+  }
+};
+
 export {
   build,
+  createPackage,
   dev,
   createDevServer,
   preview,
   createPreviewServer,
   start,
-  createProdServer
+  createProdServer,
+  CliRunner
 };
-//# sourceMappingURL=chunk-CY3DVKXO.js.map
+//# sourceMappingURL=chunk-XOOP364R.js.map