@blinkk/root 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/cli.js

@@ -1,88 +1,42 @@
-import {
-  configureServerPlugins,
-  getVitePlugins
-} from "./chunk-DTEQ2AIW.js";
 import {
   htmlMinify,
   htmlPretty,
   isValidTagName,
   parseTagNames
 } from "./chunk-GGQGZ7ZE.js";
+import {
+  copyGlob,
+  createViteServer,
+  directoryContains,
+  fileExists,
+  isDirectory,
+  isJsFile,
+  loadJson,
+  loadRootConfig,
+  makeDir,
+  rmDir,
+  writeFile
+} from "./chunk-LTSJAEBG.js";
+import {
+  configureServerPlugins,
+  getVitePlugins
+} from "./chunk-DTEQ2AIW.js";
 
 // src/cli/commands/dev.ts
-import path4 from "node:path";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 import { default as express } from "express";
-import { createServer as createViteServer } from "vite";
 
 // src/render/asset-map/dev-asset-map.ts
-import path2 from "node:path";
-import { searchForWorkspaceRoot } from "vite";
-
-// src/utils/fsutils.ts
-import { promises as fs } from "node:fs";
 import path from "node:path";
-import fsExtra from "fs-extra";
-import glob from "tiny-glob";
-function isJsFile(filename) {
-  return !!filename.match(/\.(j|t)sx?$/);
-}
-async function writeFile(filepath, content) {
-  const dirPath = path.dirname(filepath);
-  await makeDir(dirPath);
-  await fs.writeFile(filepath, content);
-}
-async function makeDir(dirpath) {
-  try {
-    await fs.access(dirpath);
-  } catch (e) {
-    await fs.mkdir(dirpath, { recursive: true });
-  }
-}
-async function copyGlob(pattern, srcdir, dstdir) {
-  const files = await glob(pattern, { cwd: srcdir });
-  if (files.length > 0) {
-    await makeDir(dstdir);
-  }
-  files.forEach((file) => {
-    fsExtra.copySync(path.resolve(srcdir, file), path.resolve(dstdir, file));
-  });
-}
-async function rmDir(dirpath) {
-  await fs.rm(dirpath, { recursive: true, force: true });
-}
-async function loadJson(filepath) {
-  const content = await fs.readFile(filepath, "utf-8");
-  return JSON.parse(content);
-}
-async function isDirectory(dirpath) {
-  return fs.stat(dirpath).then((fsStat) => {
-    return fsStat.isDirectory();
-  }).catch((err) => {
-    if (err.code === "ENOENT") {
-      return false;
-    }
-    throw err;
-  });
-}
-function fileExists(filepath) {
-  return fs.access(filepath).then(() => true).catch(() => false);
-}
-async function directoryContains(dirpath, subpath) {
-  const outer = await fs.realpath(dirpath);
-  const inner = await fs.realpath(subpath);
-  const rel = path.relative(outer, inner);
-  return !rel.startsWith("..");
-}
-
-// src/render/asset-map/dev-asset-map.ts
+import { searchForWorkspaceRoot } from "vite";
 var DevServerAssetMap = class {
   constructor(rootConfig, moduleGraph) {
     this.rootConfig = rootConfig;
     this.moduleGraph = moduleGraph;
   }
   async get(src) {
-    const file = path2.resolve(this.rootConfig.rootDir, src);
+    const file = path.resolve(this.rootConfig.rootDir, src);
     const viteModules = this.moduleGraph.getModulesByFile(file);
     if (viteModules && viteModules.size > 0) {
       const [viteModule] = viteModules;
@@ -114,7 +68,7 @@ var DevServerAssetMap = class {
     return null;
   }
   filePathToSrc(file) {
-    return path2.relative(this.rootConfig.rootDir, file);
+    return path.relative(this.rootConfig.rootDir, file);
   }
 };
 var DevServerAsset = class {
@@ -151,7 +105,7 @@ var DevServerAsset = class {
       return;
     }
     visited.add(asset.moduleId);
-    const parts = path2.parse(asset.assetUrl);
+    const parts = path.parse(asset.assetUrl);
     if ([".js", ".jsx", ".ts", ".tsx"].includes(parts.ext) && asset.moduleId.includes("/elements/")) {
       urls.add(asset.assetUrl);
     }
@@ -178,7 +132,7 @@ var DevServerAsset = class {
     }
     visited.add(asset.assetUrl);
     if (asset.src.endsWith(".scss")) {
-      const parts = path2.parse(asset.src);
+      const parts = path.parse(asset.src);
       if (!parts.name.startsWith("_")) {
         urls.add(asset.assetUrl);
       }
@@ -196,39 +150,18 @@ var DevServerAsset = class {
   }
 };
 
-// src/cli/load-config.ts
-import { bundleRequire } from "bundle-require";
-import JoyCon from "joycon";
-async function loadRootConfig(rootDir) {
-  const joycon = new JoyCon();
-  const configPath = await joycon.resolve({
-    cwd: rootDir,
-    files: ["root.config.ts"]
-  });
-  if (configPath) {
-    const configBundle = await bundleRequire({
-      filepath: configPath
-    });
-    return Object.assign({}, configBundle.mod.default || {}, { rootDir });
-  }
-  return { rootDir };
-}
-
 // src/cli/commands/dev.ts
-import glob3 from "tiny-glob";
 import { dim } from "kleur/colors";
 
 // src/core/middleware.ts
 function rootProjectMiddleware(options) {
   return (req, _, next) => {
-    req.rootConfig = Object.assign({}, options.rootConfig, {
-      rootDir: options.rootDir
-    });
+    req.rootConfig = options.rootConfig;
     next();
   };
 }
 
-// src/cli/ports.ts
+// src/utils/ports.ts
 import { createServer } from "node:net";
 function isPortOpen(port) {
   return new Promise((resolve, reject) => {
@@ -265,11 +198,11 @@ async function findOpenPort(min, max) {
   throw new Error(`no ports open between ${min} and ${max}`);
 }
 
-// src/core/element-graph.ts
-import fs2 from "node:fs";
-import path3 from "node:path";
+// src/node/element-graph.ts
+import fs from "node:fs";
+import path2 from "node:path";
 import { searchForWorkspaceRoot as searchForWorkspaceRoot2 } from "vite";
-import glob2 from "tiny-glob";
+import glob from "tiny-glob";
 var ElementGraph = class {
   constructor(sourceFiles) {
     this.sourceFiles = {};
@@ -296,7 +229,7 @@ var ElementGraph = class {
     if (!srcFile) {
       throw new Error(`could not find file path for tagName <${tagName}>`);
     }
-    const src = fs2.readFileSync(srcFile.filePath, "utf-8");
+    const src = fs.readFileSync(srcFile.filePath, "utf-8");
     const tagNames = parseTagNames(src);
     const deps = /* @__PURE__ */ new Set();
     for (const depTagName of tagNames) {
@@ -311,14 +244,14 @@ async function getElements(rootConfig) {
   var _a, _b;
   const rootDir = rootConfig.rootDir;
   const workspaceRoot = searchForWorkspaceRoot2(rootDir);
-  const elementsDirs = [path3.join(rootDir, "elements")];
+  const elementsDirs = [path2.join(rootDir, "elements")];
   const elementsInclude = ((_a = rootConfig.elements) == null ? void 0 : _a.include) || [];
   const excludePatterns = ((_b = rootConfig.elements) == null ? void 0 : _b.exclude) || [];
   const excludeElement = (moduleId) => {
     return excludePatterns.some((pattern) => Boolean(moduleId.match(pattern)));
   };
   for (const dirPath of elementsInclude) {
-    const elementsDir = path3.resolve(rootDir, dirPath);
+    const elementsDir = path2.resolve(rootDir, dirPath);
     if (!directoryContains(rootDir, elementsDir)) {
       throw new Error(
         `the elements dir (${dirPath}) should be within the project's workspace (${workspaceRoot})`
@@ -329,13 +262,13 @@ async function getElements(rootConfig) {
   const elementFilePaths = {};
   for (const dirPath of elementsDirs) {
     if (await isDirectory(dirPath)) {
-      const files = await glob2("**/*", { cwd: dirPath });
+      const files = await glob("**/*", { cwd: dirPath });
       files.forEach((file) => {
-        const parts = path3.parse(file);
+        const parts = path2.parse(file);
         if (isJsFile(parts.base) && isValidTagName(parts.name)) {
           const tagName = parts.name;
-          const filePath = path3.join(dirPath, file);
-          const relPath = path3.relative(rootDir, filePath);
+          const filePath = path2.join(dirPath, file);
+          const relPath = path2.relative(rootDir, filePath);
           if (!excludeElement(relPath)) {
             elementFilePaths[tagName] = { filePath, relPath };
           }
@@ -348,10 +281,11 @@ async function getElements(rootConfig) {
 }
 
 // src/cli/commands/dev.ts
-var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+import glob2 from "tiny-glob";
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 async function dev(rootProjectDir) {
   process.env.NODE_ENV = "development";
-  const rootDir = path4.resolve(rootProjectDir || process.cwd());
+  const rootDir = path3.resolve(rootProjectDir || process.cwd());
   const defaultPort = parseInt(process.env.PORT || "4007");
   const port = await findOpenPort(defaultPort, defaultPort + 10);
   console.log();
@@ -363,13 +297,13 @@ async function dev(rootProjectDir) {
   server.listen(port);
 }
 async function createServer2(options) {
-  const rootDir = path4.resolve((options == null ? void 0 : options.rootDir) || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
+  const rootDir = path3.resolve((options == null ? void 0 : options.rootDir) || process.cwd());
+  const rootConfig = await loadRootConfig(rootDir, { command: "dev" });
   const port = options == null ? void 0 : options.port;
   const server = express();
   server.disable("x-powered-by");
-  server.use(rootProjectMiddleware({ rootDir, rootConfig }));
-  server.use(await viteServerMiddleware({ rootDir, rootConfig, port }));
+  server.use(rootProjectMiddleware({ rootConfig }));
+  server.use(await viteServerMiddleware({ rootConfig, port }));
   const plugins = rootConfig.plugins || [];
   await configureServerPlugins(
     server,
@@ -389,76 +323,34 @@ async function createServer2(options) {
   return server;
 }
 async function viteServerMiddleware(options) {
-  var _a, _b;
-  const rootDir = options.rootDir;
   const rootConfig = options.rootConfig;
-  const viteConfig = rootConfig.vite || {};
-  let hmrOptions = (_a = viteConfig.server) == null ? void 0 : _a.hmr;
-  if (typeof hmrOptions === "undefined" && options.port) {
-    hmrOptions = { port: options.port + 10 };
-  }
-  const routeFiles = [];
-  if (await isDirectory(path4.join(rootDir, "routes"))) {
-    const pageFiles = await glob3("routes/**/*", { cwd: rootDir });
-    pageFiles.forEach((file) => {
-      const parts = path4.parse(file);
-      if (!parts.name.startsWith("_") && isJsFile(parts.base)) {
-        routeFiles.push(file);
-      }
-    });
-  }
+  const rootDir = rootConfig.rootDir;
   const elementGraph = await getElements(rootConfig);
   const elements = Object.values(elementGraph.sourceFiles).map((sourceFile) => {
     return sourceFile.relPath;
   });
   const bundleScripts = [];
-  if (await isDirectory(path4.join(rootDir, "bundles"))) {
-    const bundleFiles = await glob3("bundles/*", { cwd: rootDir });
+  if (await isDirectory(path3.join(rootDir, "bundles"))) {
+    const bundleFiles = await glob2("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
-      const parts = path4.parse(file);
+      const parts = path3.parse(file);
       if (isJsFile(parts.base)) {
         bundleScripts.push(file);
       }
     });
   }
-  const viteServer = await createViteServer({
-    ...viteConfig,
-    mode: "development",
-    root: rootDir,
-    publicDir: path4.join(rootDir, "public"),
-    server: {
-      ...viteConfig.server || {},
-      middlewareMode: true,
-      hmr: hmrOptions
-    },
-    appType: "custom",
-    optimizeDeps: {
-      ...viteConfig.optimizeDeps || {},
-      include: [
-        ...elements,
-        ...bundleScripts,
-        ...((_b = viteConfig.optimizeDeps) == null ? void 0 : _b.include) || []
-      ]
-    },
-    ssr: {
-      ...viteConfig.ssr || {},
-      noExternal: ["@blinkk/root"]
-    },
-    esbuild: {
-      ...viteConfig.esbuild || {},
-      jsx: "automatic",
-      jsxImportSource: "preact"
-    },
-    plugins: [
-      ...viteConfig.plugins || [],
-      ...getVitePlugins(rootConfig.plugins || [])
-    ]
+  const optimizeDeps = [...elements, ...bundleScripts];
+  const viteServer = await createViteServer(rootConfig, {
+    port: options.port,
+    optimizeDeps
   });
   return async (req, res, next) => {
     try {
       req.viteServer = viteServer;
-      const renderModulePath = path4.resolve(__dirname, "./render.js");
-      const render = await viteServer.ssrLoadModule(renderModulePath);
+      const renderModulePath = path3.resolve(__dirname, "./render.js");
+      const render = await viteServer.ssrLoadModule(
+        renderModulePath
+      );
       const assetMap = new DevServerAssetMap(
         rootConfig,
         viteServer.moduleGraph
@@ -487,7 +379,7 @@ function rootDevServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path4.extname(url);
+      const ext = path3.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer404(req);
@@ -505,7 +397,7 @@ function rootDevServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path4.extname(url);
+      const ext = path3.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderDevServer500(req, err);
@@ -519,15 +411,15 @@ function rootDevServer500Middleware() {
 }
 
 // src/cli/commands/build.ts
-import path6 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import fsExtra2 from "fs-extra";
-import glob4 from "tiny-glob";
+import fsExtra from "fs-extra";
+import glob3 from "tiny-glob";
 import { build as viteBuild } from "vite";
 
 // src/render/asset-map/build-asset-map.ts
-import fs3 from "node:fs";
-import path5 from "node:path";
+import fs2 from "node:fs";
+import path4 from "node:path";
 var BuildAssetMap = class {
   constructor(rootConfig) {
     this.rootConfig = rootConfig;
@@ -575,7 +467,7 @@ var BuildAssetMap = class {
       const src = manifestKey;
       const manifestChunk = clientManifest[manifestKey];
       const isElement = elementFiles.has(src);
-      const assetUrl = src.startsWith("routes/") ? "" : `/${manifestChunk.file}`;
+      const assetUrl = src.startsWith("routes/") && isJsFile(src) ? "" : `/${manifestChunk.file}`;
       const assetData = {
         src,
         assetUrl,
@@ -597,12 +489,12 @@ var BuildAssetMap = class {
   }
 };
 function realPathRelativeTo(rootDir, src) {
-  const fullPath = path5.resolve(rootDir, src);
-  if (!fs3.existsSync(fullPath)) {
+  const fullPath = path4.resolve(rootDir, src);
+  if (!fs2.existsSync(fullPath)) {
     return src;
   }
-  const realpath = fs3.realpathSync(path5.resolve(rootDir, src));
-  return path5.relative(rootDir, realpath);
+  const realpath = fs2.realpathSync(path4.resolve(rootDir, src));
+  return path4.relative(rootDir, realpath);
 }
 var BuildAsset = class {
   constructor(assetMap, assetData) {
@@ -680,14 +572,14 @@ var BuildAsset = class {
 
 // src/cli/commands/build.ts
 import { dim as dim2, cyan } from "kleur/colors";
-var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path5.dirname(fileURLToPath2(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";
   process.env.NODE_ENV = mode;
-  const rootDir = path6.resolve(rootProjectDir || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
-  const distDir = path6.join(rootDir, "dist");
+  const rootDir = path5.resolve(rootProjectDir || process.cwd());
+  const rootConfig = await loadRootConfig(rootDir, { command: "build" });
+  const distDir = path5.join(rootDir, "dist");
   const ssrOnly = (options == null ? void 0 : options.ssrOnly) || false;
   console.log();
   console.log(`${dim2("\u2503")} project:  ${rootDir}`);
@@ -697,12 +589,12 @@ async function build(rootProjectDir, options) {
   await rmDir(distDir);
   await makeDir(distDir);
   const routeFiles = [];
-  if (await isDirectory(path6.join(rootDir, "routes"))) {
-    const pageFiles = await glob4("routes/**/*", { cwd: rootDir });
+  if (await isDirectory(path5.join(rootDir, "routes"))) {
+    const pageFiles = await glob3("routes/**/*", { cwd: rootDir });
     pageFiles.forEach((file) => {
-      const parts = path6.parse(file);
+      const parts = path5.parse(file);
       if (!parts.name.startsWith("_") && isJsFile(parts.base)) {
-        routeFiles.push(path6.resolve(rootDir, file));
+        routeFiles.push(path5.resolve(rootDir, file));
       }
     });
   }
@@ -711,12 +603,12 @@ async function build(rootProjectDir, options) {
     return sourceFile.filePath;
   });
   const bundleScripts = [];
-  if (await isDirectory(path6.join(rootDir, "bundles"))) {
-    const bundleFiles = await glob4("bundles/*", { cwd: rootDir });
+  if (await isDirectory(path5.join(rootDir, "bundles"))) {
+    const bundleFiles = await glob3("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
-      const parts = path6.parse(file);
+      const parts = path5.parse(file);
       if (isJsFile(parts.base)) {
-        bundleScripts.push(path6.resolve(rootDir, file));
+        bundleScripts.push(path5.resolve(rootDir, file));
       }
     });
   }
@@ -739,7 +631,7 @@ async function build(rootProjectDir, options) {
     plugins: vitePlugins
   };
   const ssrInput = {
-    render: path6.resolve(__dirname2, "./render.js")
+    render: path5.resolve(__dirname2, "./render.js")
   };
   rootPlugins.forEach((plugin) => {
     if (plugin.ssrInput) {
@@ -769,7 +661,7 @@ async function build(rootProjectDir, options) {
           assetFileNames: "assets/[name].[hash][extname]"
         }
       },
-      outDir: path6.join(distDir, "server"),
+      outDir: path5.join(distDir, "server"),
       ssr: true,
       ssrManifest: false,
       cssCodeSplit: true,
@@ -800,7 +692,7 @@ async function build(rootProjectDir, options) {
           ...(_e = (_d = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _d.rollupOptions) == null ? void 0 : _e.output
         }
       },
-      outDir: path6.join(distDir, "routes"),
+      outDir: path5.join(distDir, "routes"),
       ssr: false,
       ssrManifest: false,
       manifest: true,
@@ -829,7 +721,7 @@ async function build(rootProjectDir, options) {
             ...(_h = (_g = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _g.rollupOptions) == null ? void 0 : _h.output
           }
         },
-        outDir: path6.join(distDir, "client"),
+        outDir: path5.join(distDir, "client"),
         ssr: false,
         ssrManifest: false,
         manifest: true,
@@ -841,18 +733,18 @@ async function build(rootProjectDir, options) {
       }
     });
   } else {
-    await writeFile(path6.join(distDir, "client/manifest.json"), "{}");
+    await writeFile(path5.join(distDir, "client/manifest.json"), "{}");
   }
   await copyGlob(
     "*.css",
-    path6.join(distDir, "routes/assets"),
-    path6.join(distDir, "client/assets")
+    path5.join(distDir, "routes/assets"),
+    path5.join(distDir, "client/assets")
   );
   const routesManifest = await loadJson(
-    path6.join(distDir, "routes/manifest.json")
+    path5.join(distDir, "routes/manifest.json")
   );
   const clientManifest = await loadJson(
-    path6.join(distDir, "client/manifest.json")
+    path5.join(distDir, "client/manifest.json")
   );
   function collectRouteCss(asset, cssDeps, visited) {
     if (!asset || !asset.file || visited.has(asset.file)) {
@@ -888,38 +780,41 @@ async function build(rootProjectDir, options) {
   );
   const rootManifest = assetMap.toJson();
   await writeFile(
-    path6.join(distDir, "client/root-manifest.json"),
+    path5.join(distDir, "client/root-manifest.json"),
     JSON.stringify(rootManifest, null, 2)
   );
-  const buildDir = path6.join(distDir, "html");
-  const publicDir = path6.join(rootDir, "public");
-  if (fsExtra2.existsSync(path6.join(rootDir, "public"))) {
-    fsExtra2.copySync(publicDir, buildDir, { dereference: true });
+  const buildDir = path5.join(distDir, "html");
+  const publicDir = path5.join(rootDir, "public");
+  if (fsExtra.existsSync(path5.join(rootDir, "public"))) {
+    fsExtra.copySync(publicDir, buildDir, { dereference: true });
   } else {
-    makeDir(buildDir);
+    await makeDir(buildDir);
   }
+  await makeDir(path5.join(buildDir, "assets"));
+  await makeDir(path5.join(buildDir, "chunks"));
   console.log("\njs/css output:");
-  makeDir(path6.join(buildDir, "assets"));
-  makeDir(path6.join(buildDir, "chunks"));
   await Promise.all(
     Object.keys(rootManifest).map(async (src) => {
       if (isRouteFile(src)) {
         return;
       }
       const assetData = rootManifest[src];
+      if (!assetData.assetUrl) {
+        return;
+      }
       const assetRelPath = assetData.assetUrl.slice(1);
-      const assetFrom = path6.join(distDir, "client", assetRelPath);
-      const assetTo = path6.join(buildDir, assetRelPath);
+      const assetFrom = path5.join(distDir, "client", assetRelPath);
+      const assetTo = path5.join(buildDir, assetRelPath);
       if (!await fileExists(assetFrom)) {
         console.log(`${assetFrom} does not exist`);
         return;
       }
-      await fsExtra2.copy(assetFrom, assetTo);
+      await fsExtra.copy(assetFrom, assetTo);
       printFileOutput(fileSize(assetTo), "dist/html/", assetRelPath);
     })
   );
   if (!ssrOnly) {
-    const render = await import(path6.join(distDir, "server/render.js"));
+    const render = await import(path5.join(distDir, "server/render.js"));
     const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
     const sitemap = await renderer.getSitemap();
     console.log("\nhtml output:");
@@ -932,11 +827,11 @@ async function build(rootProjectDir, options) {
         if (data.notFound) {
           return;
         }
-        let outFilePath = path6.join(urlPath.slice(1), "index.html");
+        let outFilePath = path5.join(urlPath.slice(1), "index.html");
         if (outFilePath.endsWith("404/index.html")) {
           outFilePath = outFilePath.replace("404/index.html", "404.html");
         }
-        const outPath = path6.join(buildDir, outFilePath);
+        const outPath = path5.join(buildDir, outFilePath);
         let html = data.html || "";
         if (rootConfig.prettyHtml !== false) {
           html = await htmlPretty(html, rootConfig.prettyHtmlOptions);
@@ -954,7 +849,7 @@ function isRouteFile(filepath) {
   return filepath.startsWith("routes") && isJsFile(filepath);
 }
 function fileSize(filepath) {
-  const stats = fsExtra2.statSync(filepath);
+  const stats = fsExtra.statSync(filepath);
   const bytes = stats.size;
   const k = 1024;
   if (bytes < k) {
@@ -973,14 +868,14 @@ function printFileOutput(fileSize2, outputDir, outputFile) {
 }
 
 // src/cli/commands/preview.ts
-import path7 from "node:path";
+import path6 from "node:path";
 import { default as express2 } from "express";
 import { dim as dim3 } from "kleur/colors";
 import sirv from "sirv";
 import compression from "compression";
 async function preview(rootProjectDir) {
   process.env.NODE_ENV = "development";
-  const rootDir = path7.resolve(rootProjectDir || process.cwd());
+  const rootDir = path6.resolve(rootProjectDir || process.cwd());
   const server = await createServer3({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
   console.log();
@@ -992,12 +887,12 @@ async function preview(rootProjectDir) {
 }
 async function createServer3(options) {
   const rootDir = options.rootDir;
-  const rootConfig = await loadRootConfig(rootDir);
-  const distDir = path7.join(rootDir, "dist");
+  const rootConfig = await loadRootConfig(rootDir, { command: "preview" });
+  const distDir = path6.join(rootDir, "dist");
   const server = express2();
   server.disable("x-powered-by");
   server.use(compression());
-  server.use(rootProjectMiddleware({ rootDir, rootConfig }));
+  server.use(rootProjectMiddleware({ rootConfig }));
   server.use(await rootPreviewRendererMiddleware({ rootConfig, distDir }));
   const plugins = rootConfig.plugins || [];
   configureServerPlugins(
@@ -1008,7 +903,7 @@ async function createServer3(options) {
       userMiddlewares.forEach((middleware) => {
         server.use(middleware);
       });
-      const publicDir = path7.join(distDir, "html");
+      const publicDir = path6.join(distDir, "html");
       server.use(sirv(publicDir, { dev: false }));
       server.use(rootPreviewServerMiddleware());
       server.use(rootPreviewServer404Middleware());
@@ -1021,8 +916,8 @@ async function createServer3(options) {
 }
 async function rootPreviewRendererMiddleware(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(path6.join(distDir, "server/render.js"));
+  const manifestPath = path6.join(distDir, "client/root-manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
       `could not find ${manifestPath}. run \`root build\` before \`root preview\`.`
@@ -1058,7 +953,7 @@ function rootPreviewServer404Middleware() {
   return async (req, res) => {
     console.error(`\u2753 404 ${req.originalUrl}`);
     const url = req.path;
-    const ext = path7.extname(url);
+    const ext = path6.extname(url);
     const renderer = req.renderer;
     if (!ext) {
       const data = await renderer.render404();
@@ -1074,7 +969,7 @@ function rootPreviewServer500Middleware() {
     console.error(`\u2757 500 ${req.originalUrl}`);
     console.error(String(err.stack || err));
     const url = req.path;
-    const ext = path7.extname(url);
+    const ext = path6.extname(url);
     const renderer = req.renderer;
     if (!ext) {
       const data = await renderer.renderError(err);
@@ -1087,14 +982,14 @@ function rootPreviewServer500Middleware() {
 }
 
 // src/cli/commands/start.ts
-import path8 from "node:path";
+import path7 from "node:path";
 import { default as express3 } from "express";
 import { dim as dim4 } from "kleur/colors";
 import sirv2 from "sirv";
 import compression2 from "compression";
 async function start(rootProjectDir) {
   process.env.NODE_ENV = "production";
-  const rootDir = path8.resolve(rootProjectDir || process.cwd());
+  const rootDir = path7.resolve(rootProjectDir || process.cwd());
   const server = await createServer4({ rootDir });
   const port = parseInt(process.env.PORT || "4007");
   console.log();
@@ -1106,12 +1001,12 @@ async function start(rootProjectDir) {
 }
 async function createServer4(options) {
   const rootDir = options.rootDir;
-  const rootConfig = await loadRootConfig(rootDir);
-  const distDir = path8.join(rootDir, "dist");
+  const rootConfig = await loadRootConfig(rootDir, { command: "start" });
+  const distDir = path7.join(rootDir, "dist");
   const server = express3();
   server.disable("x-powered-by");
   server.use(compression2());
-  server.use(rootProjectMiddleware({ rootDir, rootConfig }));
+  server.use(rootProjectMiddleware({ rootConfig }));
   server.use(await rootProdRendererMiddleware({ rootConfig, distDir }));
   const plugins = rootConfig.plugins || [];
   configureServerPlugins(
@@ -1122,7 +1017,7 @@ async function createServer4(options) {
       userMiddlewares.forEach((middleware) => {
         server.use(middleware);
       });
-      const publicDir = path8.join(distDir, "html");
+      const publicDir = path7.join(distDir, "html");
       server.use(sirv2(publicDir, { dev: false }));
       server.use(rootProdServerMiddleware());
       server.use(rootProdServer404Middleware());
@@ -1135,8 +1030,8 @@ async function createServer4(options) {
 }
 async function rootProdRendererMiddleware(options) {
   const { distDir, rootConfig } = options;
-  const render = await import(path8.join(distDir, "server/render.js"));
-  const manifestPath = path8.join(distDir, "client/root-manifest.json");
+  const render = await import(path7.join(distDir, "server/render.js"));
+  const manifestPath = path7.join(distDir, "client/root-manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
       `could not find ${manifestPath}. run \`root build\` before \`root start\`.`
@@ -1173,7 +1068,7 @@ function rootProdServer404Middleware() {
     console.error(`\u2753 404 ${req.originalUrl}`);
     if (req.renderer) {
       const url = req.path;
-      const ext = path8.extname(url);
+      const ext = path7.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.render404();
@@ -1191,7 +1086,7 @@ function rootProdServer500Middleware() {
     console.error(String(err.stack || err));
     if (req.renderer) {
       const url = req.path;
-      const ext = path8.extname(url);
+      const ext = path7.extname(url);
       if (!ext) {
         const renderer = req.renderer;
         const data = await renderer.renderError(err);