@blinkk/root 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/cli.js

@@ -1,204 +1,81 @@
+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/vite-plugin-root.ts
-import path2 from "path";
-import glob from "tiny-glob";
-
-// src/core/fsutils.ts
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import fsExtra from "fs-extra";
-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 copyDir(srcdir, dstdir) {
-  if (!fsExtra.existsSync(srcdir)) {
-    return;
-  }
-  fsExtra.copySync(srcdir, dstdir, { recursive: true, overwrite: true });
-}
-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);
-}
-
-// src/render/vite-plugin-root.ts
-var JSX_ELEMENTS_REGEX = /jsxs?\("(\w[\w-]+\w)"/g;
-var HTML_ELEMENTS_REGEX = /<(\w[\w-]+\w)/g;
-function pluginRoot(options) {
-  var _a, _b;
-  const elementsVirtualId = "virtual:root-elements";
-  const resolvedElementsVirtualId = "\0" + elementsVirtualId;
-  const rootDir = (options == null ? void 0 : options.rootDir) || process.cwd();
-  const rootConfig = (options == null ? void 0 : options.rootConfig) || {};
-  const elementsDirs = [path2.join(rootDir, "elements")];
-  const includeDirs = ((_a = rootConfig.elements) == null ? void 0 : _a.include) || [];
-  includeDirs.forEach((dirPath) => {
-    const elementsDir = path2.resolve(rootDir, dirPath);
-    if (!elementsDir.startsWith(rootDir)) {
-      throw new Error(
-        `the elements dir (${dirPath}) should be relative to the project's root dir (${rootDir})`
-      );
-    }
-    elementsDirs.push(elementsDir);
-  });
-  const excludePatterns = ((_b = rootConfig.elements) == null ? void 0 : _b.exclude) || [];
-  const excludeElement = (moduleId) => {
-    return excludePatterns.some((pattern) => Boolean(moduleId.match(pattern)));
-  };
-  let elementMap;
-  async function updateElementMap() {
-    elementMap = {};
-    await Promise.all(
-      elementsDirs.map(async (dirPath) => {
-        const dirExists = await isDirectory(dirPath);
-        if (!dirExists) {
-          return;
-        }
-        const files = await glob("**/*", { cwd: dirPath });
-        files.forEach((file) => {
-          const parts = path2.parse(file);
-          if (isJsFile(parts.base)) {
-            const fullPath = path2.join(dirPath, file);
-            const moduleId = fullPath.slice(rootDir.length);
-            if (!excludeElement(moduleId)) {
-              elementMap[parts.name] = moduleId;
-            }
-          }
-        });
-      })
-    );
-  }
-  async function getElementImport(tagname) {
-    if (!elementMap) {
-      await updateElementMap();
-    }
-    if (tagname in elementMap) {
-      return elementMap[tagname];
-    }
-    return null;
-  }
-  function isCustomElement(id) {
-    if (!isJsFile(id)) {
-      return false;
-    }
-    return elementsDirs.some((elementsDir) => {
-      return id.startsWith(elementsDir);
-    });
-  }
-  return {
-    name: "vite-plugin-root",
-    resolveId(id) {
-      if (id === elementsVirtualId) {
-        return resolvedElementsVirtualId;
-      }
-      return null;
-    },
-    async load(id) {
-      if (id === resolvedElementsVirtualId) {
-        await updateElementMap();
-        return `export const elementsMap = ${JSON.stringify(elementMap)}`;
-      }
-      return null;
-    },
-    async transform(src, id) {
-      if (isCustomElement(id)) {
-        const idParts = path2.parse(id);
-        const deps = /* @__PURE__ */ new Set();
-        const tagnames = [
-          ...src.matchAll(JSX_ELEMENTS_REGEX),
-          ...src.matchAll(HTML_ELEMENTS_REGEX)
-        ];
-        for (const match of tagnames) {
-          const tagname = match[1];
-          if (!tagname.includes("-")) {
-            continue;
-          }
-          if (tagname === idParts.name) {
-            continue;
-          }
-          deps.add(tagname);
-        }
-        const importUrls = [];
-        await Promise.all(
-          Array.from(deps).map(async (tagname) => {
-            const importUrl = await getElementImport(tagname);
-            if (importUrl) {
-              importUrls.push(importUrl);
-            }
-          })
-        );
-        if (importUrls.length > 0) {
-          const importLines = importUrls.map((url) => `import '${url}';`).join("\n");
-          const code = `${src}
-
-// autogenerated by root:
-${importLines}
-`;
-          return { code };
-        }
-        return null;
-      }
-      return null;
-    }
-  };
-}
 
 // src/render/asset-map/dev-asset-map.ts
-import path3 from "node:path";
+import path from "node:path";
+import { searchForWorkspaceRoot } from "vite";
 var DevServerAssetMap = class {
-  constructor(moduleGraph) {
+  constructor(rootConfig, moduleGraph) {
+    this.rootConfig = rootConfig;
     this.moduleGraph = moduleGraph;
   }
-  async get(moduleId) {
-    const viteModule = await this.moduleGraph.getModuleByUrl(moduleId);
-    if (!viteModule || !viteModule.id) {
+  async get(src) {
+    const file = path.resolve(this.rootConfig.rootDir, src);
+    const viteModules = this.moduleGraph.getModulesByFile(file);
+    if (viteModules && viteModules.size > 0) {
+      const [viteModule] = viteModules;
+      return new DevServerAsset(src, {
+        assetMap: this,
+        viteModule
+      });
+    }
+    if (file.startsWith(this.rootConfig.rootDir)) {
+      const assetUrl = file.slice(this.rootConfig.rootDir.length);
+      return {
+        src,
+        assetUrl,
+        getCssDeps: async () => [],
+        getJsDeps: async () => [assetUrl]
+      };
+    }
+    const workspaceRoot = searchForWorkspaceRoot(this.rootConfig.rootDir);
+    if (await directoryContains(workspaceRoot, file)) {
+      const assetUrl = `/@fs/${file}`;
       return {
-        moduleId,
-        assetUrl: moduleId,
+        src,
+        assetUrl,
         getCssDeps: async () => [],
-        getJsDeps: async () => [moduleId]
+        getJsDeps: async () => [assetUrl]
       };
     }
-    return new DevServerAsset(this, viteModule);
+    console.log(`could not find asset in asset map: ${src}`);
+    return null;
+  }
+  filePathToSrc(file) {
+    return path.relative(this.rootConfig.rootDir, file);
   }
 };
 var DevServerAsset = class {
-  constructor(assetMap, viteModule) {
-    this.assetMap = assetMap;
-    this.viteModule = viteModule;
+  constructor(src, options) {
+    this.src = src;
+    this.assetMap = options.assetMap;
+    this.viteModule = options.viteModule;
     this.moduleId = this.viteModule.id;
     this.assetUrl = this.viteModule.url;
   }
@@ -228,13 +105,17 @@ var DevServerAsset = class {
       return;
     }
     visited.add(asset.moduleId);
-    const parts = path3.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);
     }
     asset.getImportedModules().forEach((viteModule) => {
-      if (viteModule.id) {
-        const importedAsset = new DevServerAsset(this.assetMap, viteModule);
+      if (viteModule.file) {
+        const src = this.assetMap.filePathToSrc(viteModule.file);
+        const importedAsset = new DevServerAsset(src, {
+          assetMap: this.assetMap,
+          viteModule
+        });
         this.collectJs(importedAsset, urls, visited);
       }
     });
@@ -250,249 +131,347 @@ var DevServerAsset = class {
       return;
     }
     visited.add(asset.assetUrl);
-    if (asset.moduleId.endsWith(".scss")) {
-      const parts = path3.parse(asset.assetUrl);
+    if (asset.src.endsWith(".scss")) {
+      const parts = path.parse(asset.src);
       if (!parts.name.startsWith("_")) {
         urls.add(asset.assetUrl);
       }
     }
     asset.getImportedModules().forEach((viteModule) => {
-      if (viteModule.id) {
-        const importedAsset = new DevServerAsset(this.assetMap, viteModule);
+      if (viteModule.file) {
+        const src = this.assetMap.filePathToSrc(viteModule.file);
+        const importedAsset = new DevServerAsset(src, {
+          assetMap: this.assetMap,
+          viteModule
+        });
         this.collectCss(importedAsset, urls, visited);
       }
     });
   }
 };
 
-// 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 configBundle.mod.default || {};
-  }
-  return {};
+// src/cli/commands/dev.ts
+import { dim } from "kleur/colors";
+
+// src/core/middleware.ts
+function rootProjectMiddleware(options) {
+  return (req, _, next) => {
+    req.rootConfig = options.rootConfig;
+    next();
+  };
 }
 
-// src/render/html-minify.ts
-import { minify } from "html-minifier-terser";
-async function htmlMinify(html) {
-  try {
-    const min = await minify(html, {
-      collapseWhitespace: true,
-      removeComments: true,
-      preserveLineBreaks: true
+// src/utils/ports.ts
+import { createServer } from "node:net";
+function isPortOpen(port) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(false);
+        return;
+      }
+      reject(err);
     });
-    return min.trimStart();
-  } catch (e) {
-    console.error("failed to minify html:", e);
-    return html;
+    server.on("close", () => {
+      resolve(true);
+    });
+    server.listen(port, () => {
+      server.close((err) => {
+        if (err) {
+          console.log(`error closing server: ${err}`);
+          reject(err);
+        }
+      });
+    });
+  });
+}
+async function findOpenPort(min, max) {
+  let port = min;
+  while (port <= max) {
+    const isOpen = await isPortOpen(port);
+    if (isOpen) {
+      return port;
+    }
+    port += 1;
   }
+  throw new Error(`no ports open between ${min} and ${max}`);
 }
 
-// src/cli/commands/dev.ts
-import glob2 from "tiny-glob";
-import { dim } from "kleur/colors";
-var __dirname = path4.dirname(fileURLToPath(import.meta.url));
-async function createServer(options) {
-  const rootDir = (options == null ? void 0 : options.rootDir) || process.cwd();
-  const app = express();
-  app.use(express.static("public"));
-  const middlewares = await getMiddlewares({ rootDir });
-  middlewares.forEach((middleware) => app.use(middleware));
-  const port = parseInt(process.env.PORT || "4007");
-  console.log();
-  console.log(`${dim("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim("\u2503")} server:   http://localhost:${port}`);
-  console.log();
-  app.listen(port);
-}
-async function getMiddlewares(options) {
-  var _a, _b;
-  const rootDir = path4.resolve((options == null ? void 0 : options.rootDir) || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
-  const viteConfig = rootConfig.vite || {};
-  const renderModulePath = path4.resolve(__dirname, "./render.js");
-  const pages = [];
-  if (await isDirectory(path4.join(rootDir, "routes"))) {
-    const pageFiles = await glob2("routes/**/*", { cwd: rootDir });
-    pageFiles.forEach((file) => {
-      const parts = path4.parse(file);
-      if (!parts.name.startsWith("_") && isJsFile(parts.base)) {
-        pages.push(file);
+// src/node/element-graph.ts
+import fs from "node:fs";
+import path2 from "node:path";
+import { searchForWorkspaceRoot as searchForWorkspaceRoot2 } from "vite";
+import glob from "tiny-glob";
+var ElementGraph = class {
+  constructor(sourceFiles) {
+    this.sourceFiles = {};
+    this.deps = {};
+    this.sourceFiles = sourceFiles;
+  }
+  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);
+  }
+  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);
   }
-  const elementsDirs = [path4.join(rootDir, "elements")];
+};
+async function getElements(rootConfig) {
+  var _a, _b;
+  const rootDir = rootConfig.rootDir;
+  const workspaceRoot = searchForWorkspaceRoot2(rootDir);
+  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 = path4.resolve(rootDir, dirPath);
-    if (!elementsDir.startsWith(rootDir)) {
+    const elementsDir = path2.resolve(rootDir, dirPath);
+    if (!directoryContains(rootDir, elementsDir)) {
       throw new Error(
-        `the elements dir (${dirPath}) should be relative to the project's root dir (${rootDir})`
+        `the elements dir (${dirPath}) should be within the project's workspace (${workspaceRoot})`
       );
     }
     elementsDirs.push(elementsDir);
   }
-  const elements = [];
+  const elementFilePaths = {};
   for (const dirPath of elementsDirs) {
     if (await isDirectory(dirPath)) {
-      const elementFiles = await glob2("**/*", { cwd: dirPath });
-      elementFiles.forEach((file) => {
-        const parts = path4.parse(file);
-        if (isJsFile(parts.base)) {
-          const fullPath = path4.join(dirPath, file);
-          const moduleId = fullPath.slice(rootDir.length);
-          if (!excludeElement(moduleId)) {
-            elements.push(moduleId.slice(1));
+      const files = await glob("**/*", { cwd: dirPath });
+      files.forEach((file) => {
+        const parts = path2.parse(file);
+        if (isJsFile(parts.base) && isValidTagName(parts.name)) {
+          const tagName = parts.name;
+          const filePath = path2.join(dirPath, file);
+          const relPath = path2.relative(rootDir, filePath);
+          if (!excludeElement(relPath)) {
+            elementFilePaths[tagName] = { filePath, relPath };
           }
         }
       });
     }
   }
+  const graph = new ElementGraph(elementFilePaths);
+  return graph;
+}
+
+// src/cli/commands/dev.ts
+import glob2 from "tiny-glob";
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+async function dev(rootProjectDir) {
+  process.env.NODE_ENV = "development";
+  const rootDir = path3.resolve(rootProjectDir || process.cwd());
+  const defaultPort = parseInt(process.env.PORT || "4007");
+  const port = await findOpenPort(defaultPort, defaultPort + 10);
+  console.log();
+  console.log(`${dim("\u2503")} project:  ${rootDir}`);
+  console.log(`${dim("\u2503")} server:   http://localhost:${port}`);
+  console.log(`${dim("\u2503")} mode:     development`);
+  console.log();
+  const server = await createServer2({ rootDir, port });
+  server.listen(port);
+}
+async function createServer2(options) {
+  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({ rootConfig }));
+  server.use(await viteServerMiddleware({ rootConfig, port }));
+  const plugins = rootConfig.plugins || [];
+  await configureServerPlugins(
+    server,
+    async () => {
+      var _a;
+      const userMiddlewares = ((_a = rootConfig.server) == null ? void 0 : _a.middlewares) || [];
+      for (const middleware of userMiddlewares) {
+        server.use(middleware);
+      }
+      server.use(rootDevServerMiddleware());
+      server.use(rootDevServer404Middleware());
+      server.use(rootDevServer500Middleware());
+    },
+    plugins,
+    { type: "dev", rootConfig }
+  );
+  return server;
+}
+async function viteServerMiddleware(options) {
+  const rootConfig = options.rootConfig;
+  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 glob2(path4.join(rootDir, "bundles/*"));
+  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,
-    server: { middlewareMode: true },
-    appType: "custom",
-    optimizeDeps: {
-      include: [...pages, ...elements, ...bundleScripts]
-    },
-    ssr: {
-      noExternal: ["@blinkk/root"]
-    },
-    esbuild: {
-      jsx: "automatic",
-      jsxImportSource: "preact"
-    },
-    plugins: [...viteConfig.plugins || [], pluginRoot({ rootDir, rootConfig })]
+  const optimizeDeps = [...elements, ...bundleScripts];
+  const viteServer = await createViteServer(rootConfig, {
+    port: options.port,
+    optimizeDeps
   });
-  const rootMiddleware = async (req, res, next) => {
-    const url = req.originalUrl;
-    let renderer = null;
+  return async (req, res, next) => {
     try {
-      const render = await viteServer.ssrLoadModule(renderModulePath);
-      renderer = new render.Renderer(rootConfig);
-      const assetMap = new DevServerAssetMap(viteServer.moduleGraph);
-      const data = await renderer.render(url, {
-        assetMap
-      });
-      if (data.notFound || !data.html) {
-        next();
-        return;
-      }
-      let html = await viteServer.transformIndexHtml(url, data.html || "");
-      if (rootConfig.minifyHtml !== false) {
-        html = await htmlMinify(html);
-      }
-      res.status(200).set({ "Content-Type": "text/html" }).end(html);
+      req.viteServer = viteServer;
+      const renderModulePath = path3.resolve(__dirname, "./render.js");
+      const render = await viteServer.ssrLoadModule(
+        renderModulePath
+      );
+      const assetMap = new DevServerAssetMap(
+        rootConfig,
+        viteServer.moduleGraph
+      );
+      req.renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
+      viteServer.middlewares(req, res, next);
     } catch (e) {
-      viteServer.ssrFixStacktrace(e);
-      console.error(e);
-      try {
-        if (renderer) {
-          const { html } = await renderer.renderError(e);
-          res.status(500).set({ "Content-Type": "text/html" }).end(html);
-        } else {
-          next(e);
-        }
-      } catch (e2) {
-        console.error("failed to render custom error");
-        console.error(e2);
-        next(e);
-      }
+      next(e);
     }
   };
-  const notFoundMiddleware = async (req, res) => {
-    const url = req.originalUrl;
-    const ext = path4.extname(url);
-    if (!ext) {
-      const render = await viteServer.ssrLoadModule(renderModulePath);
-      const renderer = new render.Renderer(rootConfig);
-      const data = await renderer.renderDevNotFound();
-      const html = data.html || "";
-      res.status(404).set({ "Content-Type": "text/html" }).end(html);
-      return;
+}
+function rootDevServerMiddleware() {
+  return async (req, res, next) => {
+    const renderer = req.renderer;
+    const viteServer = req.viteServer;
+    try {
+      await renderer.handle(req, res, next);
+    } catch (err) {
+      viteServer.ssrFixStacktrace(err);
+      next(err);
+    }
+  };
+}
+function rootDevServer404Middleware() {
+  return async (req, res) => {
+    console.error(`\u2753 404 ${req.originalUrl}`);
+    if (req.renderer) {
+      const url = req.path;
+      const ext = path3.extname(url);
+      if (!ext) {
+        const renderer = req.renderer;
+        const data = await renderer.renderDevServer404(req);
+        const html = data.html || "";
+        res.status(404).set({ "Content-Type": "text/html" }).end(html);
+        return;
+      }
     }
     res.status(404).set({ "Content-Type": "text/plain" }).end("404");
   };
-  return [viteServer.middlewares, rootMiddleware, notFoundMiddleware];
 }
-async function dev(rootProjectDir) {
-  process.env.NODE_ENV = "development";
-  const rootDir = path4.resolve(rootProjectDir || process.cwd());
-  try {
-    await createServer({ rootDir });
-  } catch (err) {
-    console.error("an error occurred");
-  }
+function rootDevServer500Middleware() {
+  return async (err, req, res, next) => {
+    console.error(`\u2757 500 ${req.originalUrl}`);
+    console.error(String(err.stack || err));
+    if (req.renderer) {
+      const url = req.path;
+      const ext = path3.extname(url);
+      if (!ext) {
+        const renderer = req.renderer;
+        const data = await renderer.renderDevServer500(req, err);
+        const html = data.html || "";
+        res.status(500).set({ "Content-Type": "text/html" }).end(html);
+        return;
+      }
+    }
+    next(err);
+  };
 }
 
 // src/cli/commands/build.ts
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import fsExtra2 from "fs-extra";
+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 fs2 from "node:fs";
+import path4 from "node:path";
 var BuildAssetMap = class {
-  constructor() {
-    this.moduleIdToAsset = /* @__PURE__ */ new Map();
+  constructor(rootConfig) {
+    this.rootConfig = rootConfig;
+    this.srcToAsset = /* @__PURE__ */ new Map();
   }
-  async get(moduleId) {
-    return this.moduleIdToAsset.get(moduleId) || null;
+  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.moduleIdToAsset.set(asset.moduleId, asset);
+    this.srcToAsset.set(asset.src, asset);
   }
   toJson() {
     const result = {};
-    for (const moduleId of this.moduleIdToAsset.keys()) {
-      result[moduleId] = this.moduleIdToAsset.get(moduleId).toJson();
+    for (const src of this.srcToAsset.keys()) {
+      result[src] = this.srcToAsset.get(src).toJson();
     }
     return result;
   }
-  static fromViteManifest(viteManifest, elementMap) {
-    const assetMap = new BuildAssetMap();
-    const elementModuleIds = /* @__PURE__ */ new Set();
-    Object.values(elementMap).forEach(
-      (moduleId) => elementModuleIds.add(moduleId)
-    );
-    Object.keys(viteManifest).forEach((manifestKey) => {
-      const moduleId = `/${manifestKey}`;
-      const manifestChunk = viteManifest[manifestKey];
-      const isElement = elementModuleIds.has(moduleId);
+  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/") ? "" : `/${manifestChunk.file}`;
       const assetData = {
-        moduleId,
-        assetUrl: `/${manifestChunk.file}`,
-        importedModules: (manifestChunk.imports || []).map(
-          (relPath) => `/${relPath}`
-        ),
+        src,
+        assetUrl,
+        importedModules: manifestChunk.imports || [],
         importedCss: (manifestChunk.css || []).map((relPath) => `/${relPath}`),
         isElement
       };
@@ -500,8 +479,8 @@ var BuildAssetMap = class {
     });
     return assetMap;
   }
-  static fromRootManifest(rootManifest) {
-    const assetMap = new BuildAssetMap();
+  static fromRootManifest(rootConfig, rootManifest) {
+    const assetMap = new BuildAssetMap(rootConfig);
     Object.keys(rootManifest).forEach((moduleId) => {
       const assetData = rootManifest[moduleId];
       assetMap.add(new BuildAsset(assetMap, assetData));
@@ -509,10 +488,18 @@ var BuildAssetMap = class {
     return assetMap;
   }
 };
+function realPathRelativeTo(rootDir, src) {
+  const fullPath = path4.resolve(rootDir, src);
+  if (!fs2.existsSync(fullPath)) {
+    return src;
+  }
+  const realpath = fs2.realpathSync(path4.resolve(rootDir, src));
+  return path4.relative(rootDir, realpath);
+}
 var BuildAsset = class {
   constructor(assetMap, assetData) {
     this.assetMap = assetMap;
-    this.moduleId = assetData.moduleId;
+    this.src = assetData.src;
     this.assetUrl = assetData.assetUrl;
     this.importedModules = assetData.importedModules;
     this.importedCss = assetData.importedCss;
@@ -534,19 +521,19 @@ var BuildAsset = class {
     if (!asset) {
       return;
     }
-    if (!asset.moduleId) {
+    if (!asset.src) {
       return;
     }
-    if (visited.has(asset.moduleId)) {
+    if (visited.has(asset.src)) {
       return;
     }
-    visited.add(asset.moduleId);
+    visited.add(asset.src);
     if (asset.isElement) {
       urls.add(asset.assetUrl);
     }
     await Promise.all(
-      asset.importedModules.map(async (moduleId) => {
-        const importedAsset = await this.assetMap.get(moduleId);
+      asset.importedModules.map(async (src) => {
+        const importedAsset = await this.assetMap.get(src);
         this.collectJs(importedAsset, urls, visited);
       })
     );
@@ -555,13 +542,13 @@ var BuildAsset = class {
     if (!asset) {
       return;
     }
-    if (!asset.assetUrl) {
+    if (!asset.src) {
       return;
     }
-    if (visited.has(asset.moduleId)) {
+    if (visited.has(asset.src)) {
       return;
     }
-    visited.add(asset.moduleId);
+    visited.add(asset.src);
     if (asset.importedCss) {
       asset.importedCss.forEach((cssUrl) => urls.add(cssUrl));
     }
@@ -574,7 +561,7 @@ var BuildAsset = class {
   }
   toJson() {
     return {
-      moduleId: this.moduleId,
+      src: this.src,
       assetUrl: this.assetUrl,
       importedModules: this.importedModules,
       importedCss: this.importedCss,
@@ -584,95 +571,93 @@ var BuildAsset = class {
 };
 
 // src/cli/commands/build.ts
-import { dim as dim2 } from "kleur/colors";
+import { dim as dim2, cyan } from "kleur/colors";
 var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
 async function build(rootProjectDir, options) {
-  var _a, _b;
+  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 = path5.resolve(rootProjectDir || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
+  const rootConfig = await loadRootConfig(rootDir, { command: "build" });
   const distDir = path5.join(rootDir, "dist");
   const ssrOnly = (options == null ? void 0 : options.ssrOnly) || false;
-  const mode = (options == null ? void 0 : options.mode) || "production";
   console.log();
   console.log(`${dim2("\u2503")} project:  ${rootDir}`);
   console.log(`${dim2("\u2503")} output:   ${distDir}/html`);
+  console.log(`${dim2("\u2503")} mode:     ${mode}`);
   console.log();
   await rmDir(distDir);
   await makeDir(distDir);
-  const pages = [];
+  const routeFiles = [];
   if (await isDirectory(path5.join(rootDir, "routes"))) {
-    const pageFiles = await glob3(path5.join(rootDir, "routes/**/*"));
+    const pageFiles = await glob3("routes/**/*", { cwd: rootDir });
     pageFiles.forEach((file) => {
       const parts = path5.parse(file);
       if (!parts.name.startsWith("_") && isJsFile(parts.base)) {
-        pages.push(file);
+        routeFiles.push(path5.resolve(rootDir, file));
       }
     });
   }
-  const elementsDirs = [path5.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 = path5.resolve(rootDir, dirPath);
-    if (!elementsDir.startsWith(rootDir)) {
-      throw new Error(
-        `the elements dir (${dirPath}) should be relative to the project's root dir (${rootDir})`
-      );
-    }
-    elementsDirs.push(elementsDir);
-  }
-  const elements = [];
-  const elementMap = {};
-  for (const dirPath of elementsDirs) {
-    if (await isDirectory(dirPath)) {
-      const elementFiles = await glob3("**/*", { cwd: dirPath });
-      elementFiles.forEach((file) => {
-        const parts = path5.parse(file);
-        if (isJsFile(parts.base)) {
-          const fullPath = path5.join(dirPath, file);
-          const moduleId = fullPath.slice(rootDir.length);
-          if (!excludeElement(moduleId)) {
-            elements.push(fullPath);
-            elementMap[parts.name] = moduleId;
-          }
-        }
-      });
-    }
-  }
+  const elementGraph = await getElements(rootConfig);
+  const elements = Object.values(elementGraph.sourceFiles).map((sourceFile) => {
+    return sourceFile.filePath;
+  });
   const bundleScripts = [];
   if (await isDirectory(path5.join(rootDir, "bundles"))) {
-    const bundleFiles = await glob3(path5.join(rootDir, "bundles/*"));
+    const bundleFiles = await glob3("bundles/*", { cwd: rootDir });
     bundleFiles.forEach((file) => {
       const parts = path5.parse(file);
       if (isJsFile(parts.base)) {
-        bundleScripts.push(file);
+        bundleScripts.push(path5.resolve(rootDir, file));
       }
     });
   }
+  const rootPlugins = rootConfig.plugins || [];
   const viteConfig = rootConfig.vite || {};
+  const vitePlugins = [
+    ...viteConfig.plugins || [],
+    ...getVitePlugins(rootPlugins)
+  ];
   const baseConfig = {
     ...viteConfig,
     root: rootDir,
+    mode,
     esbuild: {
+      ...viteConfig.esbuild,
       jsx: "automatic",
       jsxImportSource: "preact",
       treeShaking: true
     },
-    plugins: [...viteConfig.plugins || [], pluginRoot({ rootDir, rootConfig })]
+    plugins: vitePlugins
+  };
+  const ssrInput = {
+    render: path5.resolve(__dirname2, "./render.js")
   };
+  rootPlugins.forEach((plugin) => {
+    if (plugin.ssrInput) {
+      Object.assign(ssrInput, plugin.ssrInput());
+    }
+  });
+  const noExternalConfig = (_a = viteConfig.ssr) == null ? void 0 : _a.noExternal;
+  const noExternal = [];
+  if (noExternalConfig) {
+    if (Array.isArray(noExternalConfig)) {
+      noExternal.push(...noExternalConfig);
+    } else {
+      noExternal.push(noExternalConfig);
+    }
+  }
   await viteBuild({
     ...baseConfig,
-    mode,
     publicDir: false,
     build: {
+      ...viteConfig == null ? void 0 : viteConfig.build,
       rollupOptions: {
-        input: [path5.resolve(__dirname2, "./render.js")],
+        ...(_b = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _b.rollupOptions,
+        input: ssrInput,
         output: {
           format: "esm",
-          chunkFileNames: "chunks/[name].[hash].js",
+          chunkFileNames: "chunks/[name].[hash].min.js",
           assetFileNames: "assets/[name].[hash][extname]"
         }
       },
@@ -682,89 +667,253 @@ async function build(rootProjectDir, options) {
       cssCodeSplit: true,
       target: "esnext",
       minify: false,
-      polyfillModulePreload: false,
+      modulePreload: { polyfill: false },
       reportCompressedSize: false
     },
     ssr: {
-      noExternal: ["@blinkk/root"]
+      ...viteConfig.ssr,
+      target: "node",
+      noExternal: ["@blinkk/root", ...noExternal]
     }
   });
   await viteBuild({
     ...baseConfig,
-    mode,
     publicDir: false,
     build: {
+      ...viteConfig == null ? void 0 : viteConfig.build,
       rollupOptions: {
-        input: [...pages, ...elements, ...bundleScripts],
+        ...(_c = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _c.rollupOptions,
+        input: [...routeFiles],
         output: {
           format: "esm",
-          chunkFileNames: "chunks/[name].[hash].js",
-          assetFileNames: "assets/[name].[hash][extname]"
+          entryFileNames: "assets/[name].[hash].min.js",
+          chunkFileNames: "chunks/[name].[hash].min.js",
+          assetFileNames: "assets/[name].[hash][extname]",
+          ...(_e = (_d = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _d.rollupOptions) == null ? void 0 : _e.output
         }
       },
-      outDir: path5.join(distDir, "client"),
+      outDir: path5.join(distDir, "routes"),
       ssr: false,
       ssrManifest: false,
       manifest: true,
       cssCodeSplit: true,
       target: "esnext",
       minify: true,
-      polyfillModulePreload: false,
+      modulePreload: { polyfill: false },
       reportCompressedSize: false
     }
   });
-  const viteManifest = await loadJson(
+  const clientInput = [...elements, ...bundleScripts];
+  if (clientInput.length > 0) {
+    await viteBuild({
+      ...baseConfig,
+      publicDir: false,
+      build: {
+        ...viteConfig == null ? void 0 : viteConfig.build,
+        rollupOptions: {
+          ...(_f = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _f.rollupOptions,
+          input: [...elements, ...bundleScripts],
+          output: {
+            format: "esm",
+            entryFileNames: "assets/[name].[hash].min.js",
+            chunkFileNames: "chunks/[name].[hash].min.js",
+            assetFileNames: "assets/[name].[hash][extname]",
+            ...(_h = (_g = viteConfig == null ? void 0 : viteConfig.build) == null ? void 0 : _g.rollupOptions) == null ? void 0 : _h.output
+          }
+        },
+        outDir: path5.join(distDir, "client"),
+        ssr: false,
+        ssrManifest: false,
+        manifest: true,
+        cssCodeSplit: true,
+        target: "esnext",
+        minify: true,
+        modulePreload: { polyfill: false },
+        reportCompressedSize: false
+      }
+    });
+  } else {
+    await writeFile(path5.join(distDir, "client/manifest.json"), "{}");
+  }
+  await copyGlob(
+    "*.css",
+    path5.join(distDir, "routes/assets"),
+    path5.join(distDir, "client/assets")
+  );
+  const routesManifest = await loadJson(
+    path5.join(distDir, "routes/manifest.json")
+  );
+  const clientManifest = await loadJson(
     path5.join(distDir, "client/manifest.json")
   );
-  const assetMap = BuildAssetMap.fromViteManifest(viteManifest, elementMap);
-  writeFile(
+  function collectRouteCss(asset, cssDeps, visited) {
+    if (!asset || !asset.file || visited.has(asset.file)) {
+      return;
+    }
+    visited.add(asset.file);
+    if (asset.css) {
+      asset.css.forEach((dep) => cssDeps.add(dep));
+    }
+    if (asset.imports) {
+      asset.imports.forEach((manifestKey) => {
+        collectRouteCss(routesManifest[manifestKey], cssDeps, visited);
+      });
+    }
+  }
+  Object.keys(routesManifest).forEach((manifestKey) => {
+    const asset = routesManifest[manifestKey];
+    if (asset.isEntry) {
+      const visited = /* @__PURE__ */ new Set();
+      const cssDeps = /* @__PURE__ */ new Set();
+      collectRouteCss(asset, cssDeps, visited);
+      asset.css = Array.from(cssDeps);
+      asset.imports = [];
+      clientManifest[manifestKey] = asset;
+    } else if (asset.file.endsWith(".css")) {
+      clientManifest[manifestKey] = asset;
+    }
+  });
+  const assetMap = BuildAssetMap.fromViteManifest(
+    rootConfig,
+    clientManifest,
+    elementGraph
+  );
+  const rootManifest = assetMap.toJson();
+  await writeFile(
     path5.join(distDir, "client/root-manifest.json"),
-    JSON.stringify(assetMap.toJson(), null, 2)
+    JSON.stringify(rootManifest, null, 2)
   );
   const buildDir = path5.join(distDir, "html");
   const publicDir = path5.join(rootDir, "public");
-  if (fsExtra2.existsSync(path5.join(rootDir, "public"))) {
-    fsExtra2.copySync(publicDir, buildDir);
+  if (fsExtra.existsSync(path5.join(rootDir, "public"))) {
+    fsExtra.copySync(publicDir, buildDir, { dereference: true });
   } else {
     makeDir(buildDir);
   }
-  copyDir(path5.join(distDir, "client/assets"), path5.join(buildDir, "assets"));
-  copyDir(path5.join(distDir, "client/chunks"), path5.join(buildDir, "chunks"));
+  console.log("\njs/css output:");
+  makeDir(path5.join(buildDir, "assets"));
+  makeDir(path5.join(buildDir, "chunks"));
+  await Promise.all(
+    Object.keys(rootManifest).map(async (src) => {
+      if (isRouteFile(src)) {
+        return;
+      }
+      const assetData = rootManifest[src];
+      const assetRelPath = assetData.assetUrl.slice(1);
+      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 fsExtra.copy(assetFrom, assetTo);
+      printFileOutput(fileSize(assetTo), "dist/html/", assetRelPath);
+    })
+  );
   if (!ssrOnly) {
     const render = await import(path5.join(distDir, "server/render.js"));
-    const renderer = new render.Renderer(rootConfig);
+    const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
     const sitemap = await renderer.getSitemap();
+    console.log("\nhtml output:");
     await Promise.all(
       Object.keys(sitemap).map(async (urlPath) => {
         const { route, params } = sitemap[urlPath];
         const data = await renderer.renderRoute(route, {
-          assetMap,
           routeParams: params
         });
-        let outPath = path5.join(distDir, `html${urlPath}`, "index.html");
-        if (outPath.endsWith("404/index.html")) {
-          outPath = outPath.replace("404/index.html", "404.html");
+        if (data.notFound) {
+          return;
+        }
+        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 = path5.join(buildDir, outFilePath);
+        let html = data.html || "";
+        if (rootConfig.prettyHtml !== false) {
+          html = await htmlPretty(html, rootConfig.prettyHtmlOptions);
+        }
+        if (rootConfig.minifyHtml !== false) {
+          html = await htmlMinify(html, rootConfig.minifyHtmlOptions);
         }
-        const html = await htmlMinify(data.html || "");
         await writeFile(outPath, html);
-        const relPath = outPath.slice(path5.dirname(distDir).length + 1);
-        console.log(`saved ${relPath}`);
+        printFileOutput(fileSize(outPath), "dist/html/", outFilePath);
       })
     );
   }
 }
+function isRouteFile(filepath) {
+  return filepath.startsWith("routes") && isJsFile(filepath);
+}
+function fileSize(filepath) {
+  const stats = fsExtra.statSync(filepath);
+  const bytes = stats.size;
+  const k = 1024;
+  if (bytes < k) {
+    return (bytes / k).toFixed(2) + " kB";
+  }
+  const units = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + units[i];
+}
+function printFileOutput(fileSize2, outputDir, outputFile) {
+  const indent = " ".repeat(2);
+  const paddedSize = fileSize2.padStart(9, " ");
+  console.log(
+    `${indent}${dim2(paddedSize)}  ${dim2(outputDir)}${cyan(outputFile)}`
+  );
+}
 
 // src/cli/commands/preview.ts
 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 = path6.resolve(rootProjectDir || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
+  const server = await createServer3({ rootDir });
+  const port = parseInt(process.env.PORT || "4007");
+  console.log();
+  console.log(`${dim3("\u2503")} project:  ${rootDir}`);
+  console.log(`${dim3("\u2503")} server:   http://localhost:${port}`);
+  console.log(`${dim3("\u2503")} mode:     preview`);
+  console.log();
+  server.listen(port);
+}
+async function createServer3(options) {
+  const rootDir = options.rootDir;
+  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({ rootConfig }));
+  server.use(await rootPreviewRendererMiddleware({ rootConfig, distDir }));
+  const plugins = rootConfig.plugins || [];
+  configureServerPlugins(
+    server,
+    async () => {
+      var _a;
+      const userMiddlewares = ((_a = rootConfig.server) == null ? void 0 : _a.middlewares) || [];
+      userMiddlewares.forEach((middleware) => {
+        server.use(middleware);
+      });
+      const publicDir = path6.join(distDir, "html");
+      server.use(sirv(publicDir, { dev: false }));
+      server.use(rootPreviewServerMiddleware());
+      server.use(rootPreviewServer404Middleware());
+      server.use(rootPreviewServer500Middleware());
+    },
+    plugins,
+    { type: "preview", rootConfig }
+  );
+  return server;
+}
+async function rootPreviewRendererMiddleware(options) {
+  const { distDir, rootConfig } = options;
   const render = await import(path6.join(distDir, "server/render.js"));
-  const renderer = new render.Renderer(rootConfig);
   const manifestPath = path6.join(distDir, "client/root-manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
@@ -772,25 +921,19 @@ async function preview(rootProjectDir) {
     );
   }
   const rootManifest = await loadJson(manifestPath);
-  const assetMap = BuildAssetMap.fromRootManifest(rootManifest);
-  const app = express2();
-  const publicDir = path6.join(distDir, "html");
-  app.use(express2.static(publicDir));
-  app.use(async (req, res, next) => {
+  const assetMap = BuildAssetMap.fromRootManifest(rootConfig, rootManifest);
+  const elementGraph = await getElements(rootConfig);
+  const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
+  return async (req, _, next) => {
+    req.renderer = renderer;
+    next();
+  };
+}
+function rootPreviewServerMiddleware() {
+  return async (req, res, next) => {
+    const renderer = req.renderer;
     try {
-      const url = req.originalUrl;
-      const data = await renderer.render(url, {
-        assetMap
-      });
-      if (data.notFound || !data.html) {
-        next();
-        return;
-      }
-      let html = data.html || "";
-      if (rootConfig.minifyHtml !== false) {
-        html = await htmlMinify(html);
-      }
-      res.status(200).set({ "Content-Type": "text/html" }).end(html);
+      await renderer.handle(req, res, next);
     } catch (e) {
       try {
         const { html } = await renderer.renderError(e);
@@ -801,26 +944,90 @@ async function preview(rootProjectDir) {
         next(e);
       }
     }
-  });
-  const port = parseInt(process.env.PORT || "4007");
-  console.log();
-  console.log(`${dim3("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim3("\u2503")} server:   http://localhost:${port}`);
-  console.log();
-  app.listen(port);
+  };
+}
+function rootPreviewServer404Middleware() {
+  return async (req, res) => {
+    console.error(`\u2753 404 ${req.originalUrl}`);
+    const url = req.path;
+    const ext = path6.extname(url);
+    const renderer = req.renderer;
+    if (!ext) {
+      const data = await renderer.render404();
+      const html = data.html || "";
+      res.status(404).set({ "Content-Type": "text/html" }).end(html);
+      return;
+    }
+    res.status(404).set({ "Content-Type": "text/plain" }).end("404");
+  };
+}
+function rootPreviewServer500Middleware() {
+  return async (err, req, res, next) => {
+    console.error(`\u2757 500 ${req.originalUrl}`);
+    console.error(String(err.stack || err));
+    const url = req.path;
+    const ext = path6.extname(url);
+    const renderer = req.renderer;
+    if (!ext) {
+      const data = await renderer.renderError(err);
+      const html = data.html || "";
+      res.status(500).set({ "Content-Type": "text/html" }).end(html);
+      return;
+    }
+    next(err);
+  };
 }
 
 // src/cli/commands/start.ts
 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 = path7.resolve(rootProjectDir || process.cwd());
-  const rootConfig = await loadRootConfig(rootDir);
+  const server = await createServer4({ rootDir });
+  const port = parseInt(process.env.PORT || "4007");
+  console.log();
+  console.log(`${dim4("\u2503")} project:  ${rootDir}`);
+  console.log(`${dim4("\u2503")} server:   http://localhost:${port}`);
+  console.log(`${dim4("\u2503")} mode:     production`);
+  console.log();
+  server.listen(port);
+}
+async function createServer4(options) {
+  const rootDir = options.rootDir;
+  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({ rootConfig }));
+  server.use(await rootProdRendererMiddleware({ rootConfig, distDir }));
+  const plugins = rootConfig.plugins || [];
+  configureServerPlugins(
+    server,
+    async () => {
+      var _a;
+      const userMiddlewares = ((_a = rootConfig.server) == null ? void 0 : _a.middlewares) || [];
+      userMiddlewares.forEach((middleware) => {
+        server.use(middleware);
+      });
+      const publicDir = path7.join(distDir, "html");
+      server.use(sirv2(publicDir, { dev: false }));
+      server.use(rootProdServerMiddleware());
+      server.use(rootProdServer404Middleware());
+      server.use(rootProdServer500Middleware());
+    },
+    plugins,
+    { type: "prod", rootConfig }
+  );
+  return server;
+}
+async function rootProdRendererMiddleware(options) {
+  const { distDir, rootConfig } = options;
   const render = await import(path7.join(distDir, "server/render.js"));
-  const renderer = new render.Renderer(rootConfig);
   const manifestPath = path7.join(distDir, "client/root-manifest.json");
   if (!await fileExists(manifestPath)) {
     throw new Error(
@@ -828,25 +1035,19 @@ async function start(rootProjectDir) {
     );
   }
   const rootManifest = await loadJson(manifestPath);
-  const assetMap = BuildAssetMap.fromRootManifest(rootManifest);
-  const app = express3();
-  const publicDir = path7.join(distDir, "html");
-  app.use(express3.static(publicDir));
-  app.use(async (req, res, next) => {
+  const assetMap = BuildAssetMap.fromRootManifest(rootConfig, rootManifest);
+  const elementGraph = await getElements(rootConfig);
+  const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
+  return async (req, _, next) => {
+    req.renderer = renderer;
+    next();
+  };
+}
+function rootProdServerMiddleware() {
+  return async (req, res, next) => {
+    const renderer = req.renderer;
     try {
-      const url = req.originalUrl;
-      const data = await renderer.render(url, {
-        assetMap
-      });
-      if (data.notFound || !data.html) {
-        next();
-        return;
-      }
-      let html = data.html || "";
-      if (rootConfig.minifyHtml !== false) {
-        html = await htmlMinify(html);
-      }
-      res.status(200).set({ "Content-Type": "text/html" }).end(html);
+      await renderer.handle(req, res, next);
     } catch (e) {
       try {
         const { html } = await renderer.renderError(e);
@@ -857,13 +1058,42 @@ async function start(rootProjectDir) {
         next(e);
       }
     }
-  });
-  const port = parseInt(process.env.PORT || "4007");
-  console.log();
-  console.log(`${dim4("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim4("\u2503")} server:   http://localhost:${port}`);
-  console.log();
-  app.listen(port);
+  };
+}
+function rootProdServer404Middleware() {
+  return async (req, res) => {
+    console.error(`\u2753 404 ${req.originalUrl}`);
+    if (req.renderer) {
+      const url = req.path;
+      const ext = path7.extname(url);
+      if (!ext) {
+        const renderer = req.renderer;
+        const data = await renderer.render404();
+        const html = data.html || "";
+        res.status(404).set({ "Content-Type": "text/html" }).end(html);
+        return;
+      }
+    }
+    res.status(404).set({ "Content-Type": "text/plain" }).end("404");
+  };
+}
+function rootProdServer500Middleware() {
+  return async (err, req, res, next) => {
+    console.error(`\u2757 500 ${req.originalUrl}`);
+    console.error(String(err.stack || err));
+    if (req.renderer) {
+      const url = req.path;
+      const ext = path7.extname(url);
+      if (!ext) {
+        const renderer = req.renderer;
+        const data = await renderer.renderError(err);
+        const html = data.html || "";
+        res.status(500).set({ "Content-Type": "text/html" }).end(html);
+        return;
+      }
+    }
+    next(err);
+  };
 }
 export {
   build,