@noego/forge 0.0.26 → 0.1.0

package/dist-ssr/server.js

@@ -2,122 +2,15 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import express from "express";
-import path from "path";
-import fs from "fs";
+import path__default from "path";
+import fs__default from "fs";
 import deepmerge from "deepmerge";
-import { pathToFileURL } from "url";
+import { p as parse_openapi_config, i as initialize_route_matchers, C as ComponentManager, V as ViteComponentLoader, P as ProdComponentLoader } from "./url_parser-DRWHePkU.js";
 import Handlebars from "handlebars";
-import fs$1 from "fs/promises";
-import { stringify } from "devalue";
-import yaml from "js-yaml";
-import "clone-deep";
-import join from "url-join";
-import { p as parsePathConfig } from "./path-BqcF5dbs.js";
+import fs from "fs/promises";
+import { uneval } from "devalue";
+import { pathToFileURL } from "url";
 import { render } from "svelte/server";
-import pathToRegex from "path-to-regex";
-class ViteComponentLoader {
-  constructor(basePath, vite) {
-    this.basePath = basePath;
-    this.vite = vite;
-  }
-  async load(componentPath, options = { use_base_path: true }) {
-    const absoluteComponentPath = this.getComponentFullPath(componentPath, options);
-    console.log(`[ViteComponentLoader] Loading component from path: ${absoluteComponentPath}`);
-    const jsPath = absoluteComponentPath.replace(/\.svelte$/, ".js");
-    fs.existsSync(jsPath);
-    let vitePath = path.relative(process.cwd(), absoluteComponentPath);
-    vitePath = vitePath.replace(/\\/g, "/");
-    if (!vitePath.startsWith("/")) {
-      vitePath = "/" + vitePath;
-    }
-    console.log(`[ViteComponentLoader] Resolved Vite path: ${vitePath} from componentPath: ${componentPath}`);
-    try {
-      console.log(`[ViteComponentLoader] Loading module for vitePath: ${vitePath}`);
-      const module = await this.vite.ssrLoadModule(vitePath);
-      console.log(`[ViteComponentLoader] Module loaded successfully for: ${vitePath}`);
-      if (!module || !module.default) {
-        console.error(`[ViteComponentLoader] Loaded module for ${vitePath} is invalid or missing a default export. Module content:`, module);
-        throw new Error(`Module ${vitePath} loaded successfully but is invalid or missing default export.`);
-      }
-      return module;
-    } catch (error) {
-      console.error(`[ViteComponentLoader] Error loading module for vitePath: ${vitePath} (derived from componentPath: ${componentPath})`, error);
-      try {
-        await fs.promises.access(absoluteComponentPath);
-      } catch (fsError) {
-      }
-      throw error;
-    }
-  }
-  getComponentFullPath(componentPath, options = { use_base_path: true }) {
-    const use_base_path = options.use_base_path || false;
-    if (use_base_path) {
-      return path.join(this.basePath, componentPath);
-    }
-    if (path.isAbsolute(componentPath)) {
-      return componentPath;
-    }
-    return componentPath;
-  }
-}
-class ProdComponentLoader {
-  constructor(base_path) {
-    __publicField(this, "componentMapPromise", null);
-    this.base_path = base_path;
-  }
-  async load(componentPath) {
-    const normalized = this.normalizeKey(componentPath);
-    try {
-      const map = await this.loadComponentMap();
-      const module2 = map[normalized];
-      if (module2) {
-        return module2;
-      }
-    } catch (error) {
-      console.warn(`[Forge] Failed to load component "${componentPath}" from entry manifest:`, error);
-    }
-    const component_path = this.getComponentFullPath(componentPath);
-    const fallbackPath = component_path.endsWith(".js") ? component_path : component_path.replace(/\.svelte$/, ".js");
-    const module = await import(pathToFileURL(fallbackPath).href);
-    return module;
-  }
-  getComponentFullPath(componentPath) {
-    return path.join(this.base_path, componentPath);
-  }
-  normalizeKey(componentPath) {
-    const trimmed = componentPath.replace(/^\.\//, "");
-    if (trimmed.endsWith(".svelte")) {
-      return trimmed.replace(/\.svelte$/, ".js");
-    }
-    return trimmed;
-  }
-  async loadComponentMap() {
-    if (!this.componentMapPromise) {
-      const entryPath = path.join(this.base_path, "entry-ssr.js");
-      const entryUrl = pathToFileURL(entryPath).href;
-      this.componentMapPromise = import(entryUrl).then((mod) => {
-        const source = mod.components ?? mod.default ?? {};
-        const normalized = {};
-        for (const [key, value] of Object.entries(source)) {
-          const cleanKey = key.replace(/^\.\//, "");
-          normalized[cleanKey] = value;
-          if (cleanKey.startsWith("ui/")) {
-            normalized[cleanKey.slice(3)] = value;
-          }
-          if (cleanKey.endsWith(".svelte")) {
-            const jsKey = cleanKey.replace(/\.svelte$/, ".js");
-            normalized[jsKey] = value;
-          }
-        }
-        return normalized;
-      }).catch((error) => {
-        this.componentMapPromise = null;
-        throw error;
-      });
-    }
-    return this.componentMapPromise;
-  }
-}
 const default_template = `
 <!DOCTYPE html>
 <html lang="en">
@@ -152,7 +45,7 @@ class BaseHTMLRender {
     if (configJson) {
       try {
         const configData = JSON.parse(configJson);
-        const safeConfigJson = stringify(configData);
+        const safeConfigJson = uneval(configData);
         const configScript = `<script>window.__CONFIGURATION__ = ${safeConfigJson};<\/script>`;
         if (html.includes("</head>")) {
           html = html.replace("</head>", `${configScript}
@@ -212,7 +105,7 @@ class LiveHTMLRender {
     if (configJson) {
       try {
         const configData = JSON.parse(configJson);
-        const safeConfigJson = stringify(configData);
+        const safeConfigJson = uneval(configData);
         const configScript = `<script>window.__CONFIGURATION__ = ${safeConfigJson};<\/script>`;
         if (html.includes("</head>")) {
           html = html.replace("</head>", `${configScript}
@@ -256,146 +149,10 @@ if (document.readyState === 'loading') {
     return html;
   }
   async getTemplate() {
-    const file_content = await fs$1.readFile(this.html_path, "utf8");
+    const file_content = await fs.readFile(this.html_path, "utf8");
     return file_content;
   }
 }
-const HTTP_METHODS = /* @__PURE__ */ new Set([
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options",
-  "trace"
-]);
-function getGlobalPathsMiddleware(openapi) {
-  if (!openapi || !openapi.paths) {
-    return [];
-  }
-  const value = openapi.paths["x-middleware"];
-  return Array.isArray(value) ? [...value] : [];
-}
-function parseConfigfile(file_content) {
-  let config = null;
-  try {
-    config = yaml.load(file_content);
-  } catch (e) {
-    console.log(e);
-  }
-  return config;
-}
-function parse_modules(openapi, inheritedMiddleware = []) {
-  const modules_config = openapi.modules || openapi.module;
-  if (!modules_config) {
-    return;
-  }
-  const modules = Object.entries(modules_config).map(([_, module]) => {
-    return module;
-  });
-  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
-  const modules_path = modules.map((module) => {
-    const basePath = module.basePath || "";
-    const baseLayouts = module.baseLayouts || [];
-    const moduleMiddleware = Array.isArray(module["x-middleware"]) ? module["x-middleware"] : [];
-    const inherited = [...globalMiddleware, ...moduleMiddleware];
-    const paths = module.paths;
-    if (!paths) {
-      return;
-    }
-    const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
-      return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
-        const methodName = String(method);
-        return parsePathConfig(path2, methodName, config, inherited);
-      });
-    });
-    const routes = configurations.reduce((flat_config, config) => {
-      return flat_config.concat(config);
-    }, []);
-    routes.forEach((route) => {
-      route.path = join(basePath, route.path);
-      route.layout = baseLayouts.concat(route.layout || []);
-    });
-    return routes;
-  });
-  return modules_path.reduce(
-    (flat_config, config) => {
-      if (!config) {
-        return flat_config;
-      }
-      return flat_config.concat(config);
-    },
-    []
-  );
-}
-function parse_paths(openapi, inheritedMiddleware = []) {
-  const paths = openapi.paths;
-  if (!paths) {
-    return;
-  }
-  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
-  const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
-    return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
-      const methodName = String(method);
-      return parsePathConfig(path2, methodName, config, globalMiddleware);
-    });
-  });
-  const routes = configurations.reduce((flat_config, config) => {
-    return flat_config.concat(config);
-  }, []);
-  return routes;
-}
-function isStitchConfig(document) {
-  return document && typeof document === "object" && "stitch" in document;
-}
-function isOpenAPIConfig(document) {
-  return document && typeof document === "object" && ("paths" in document || "module" in document || "modules" in document);
-}
-async function parse_openapi_config(openapi_config_path) {
-  const content = fs.readFileSync(openapi_config_path, "utf8");
-  const parsed_config = parseConfigfile(content);
-  let openapi_config;
-  if (isStitchConfig(parsed_config)) {
-    console.log("Detected stitch configuration, building with Node.js stitch engine...");
-    try {
-      const { StitchEngine } = await import("@noego/stitch");
-      const startTime = Date.now();
-      const engine = new StitchEngine();
-      const result = engine.buildSync(openapi_config_path, { format: "json" });
-      if (!result.success) {
-        throw new Error(`Stitch build failed: ${result.error}`);
-      }
-      const buildTime = Date.now() - startTime;
-      console.log(`INFO  Stitch build completed in ${buildTime} ms – ${parsed_config.stitch ? parsed_config.stitch.length : 0} modules processed`);
-      openapi_config = typeof result.data === "string" ? JSON.parse(result.data) : result.data;
-    } catch (error) {
-      throw new Error(`Failed to process stitch configuration: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  } else if (isOpenAPIConfig(parsed_config)) {
-    console.log("Detected regular OpenAPI configuration");
-    openapi_config = parsed_config;
-  } else {
-    throw new Error(`Invalid OpenAPI or stitch configuration file: ${openapi_config_path}. File must contain either 'stitch', 'paths', 'module', or 'modules' at the root level.`);
-  }
-  const globalPathsMiddleware = getGlobalPathsMiddleware(openapi_config);
-  let modules = parse_modules(openapi_config) || [];
-  let paths = parse_paths(openapi_config) || [];
-  let fallback_layout = openapi_config["x-fallback-layout"] || null;
-  let fallback_view = openapi_config["x-fallback-view"] || null;
-  const fallback_middleware = Array.isArray(openapi_config["x-fallback-middleware"]) ? [...openapi_config["x-fallback-middleware"]] : [...globalPathsMiddleware];
-  let fallback = {
-    layout: fallback_layout ? [fallback_layout] : [],
-    view: fallback_view,
-    middleware: fallback_middleware
-  };
-  const routes = [...modules, ...paths];
-  let config = {
-    fallback,
-    routes
-  };
-  return config;
-}
 const defaultViteOptions = {
   appType: "custom",
   root: process.cwd(),
@@ -410,7 +167,7 @@ const defaultOptions = {
   component_dir: "/",
   build_dir: "dist_ssr",
   renderer: "default",
-  open_api_path: path.join(process.cwd(), "openapi.yaml"),
+  open_api_path: path__default.join(process.cwd(), "openapi.yaml"),
   manifest_endpoint: "/manifest.json",
   middleware_path: void 0
 };
@@ -459,12 +216,12 @@ async function layout_requires_server(route, loader) {
   }
   const load_required = await Promise.all(layout.map(async (layoutPath) => {
     const fullPath = loader.getComponentFullPath(layoutPath);
-    const { dir, name } = path.parse(fullPath);
+    const { dir, name } = path__default.parse(fullPath);
     const extensions = [".js", ".ts"];
     for (const ext of extensions) {
-      const loaderFilePath = path.join(dir, `${name}.load${ext}`);
+      const loaderFilePath = path__default.join(dir, `${name}.load${ext}`);
       try {
-        if (fs.existsSync(loaderFilePath)) {
+        if (fs__default.existsSync(loaderFilePath)) {
           const module = await import(pathToFileURL(loaderFilePath).href);
           if (typeof (module == null ? void 0 : module.default) === "function") {
             return true;
@@ -488,12 +245,12 @@ async function view_requires_server(route, loader) {
     return false;
   }
   const fullPath = loader.getComponentFullPath(view);
-  const { dir, name } = path.parse(fullPath);
+  const { dir, name } = path__default.parse(fullPath);
   const extensions = [".js", ".ts"];
   for (const ext of extensions) {
-    const loaderFilePath = path.join(dir, `${name}.load${ext}`);
+    const loaderFilePath = path__default.join(dir, `${name}.load${ext}`);
     try {
-      if (fs.existsSync(loaderFilePath)) {
+      if (fs__default.existsSync(loaderFilePath)) {
         const module = await import(pathToFileURL(loaderFilePath).href);
         if (typeof (module == null ? void 0 : module.default) === "function") {
           return true;
@@ -605,106 +362,6 @@ class ApiAdapter {
     };
   }
 }
-class ComponentManager {
-  constructor(componentLoader) {
-    this.componentLoader = componentLoader;
-  }
-  async getLayoutComponents(route) {
-    const layout_paths = route.layout || [];
-    const layouts_components = await Promise.all(layout_paths.map((layout) => {
-      console.log("layout path", layout);
-      return this.componentLoader.load(layout);
-    }));
-    return layouts_components;
-  }
-  async getLayouts(route) {
-    const layout_paths = route.layout || [];
-    const layouts_components = await Promise.all(layout_paths.map(async (layout_path) => {
-      const layout = await this.componentLoader.load(layout_path);
-      return layout.default;
-    }));
-    return layouts_components;
-  }
-  async getLayoutLoaders(route) {
-    const layout_paths = route.layout || [];
-    const loaders_from_files = await Promise.all(
-      layout_paths.map((layoutPath) => this.resolveLoader(layoutPath))
-    );
-    const needs_fallback = loaders_from_files.some((loader) => !loader);
-    if (needs_fallback) {
-      const layout_components = await this.getLayoutComponents(route);
-      const old_style_loaders = layout_components.map((layout) => layout.load);
-      return loaders_from_files.map(
-        (loader, index) => loader || old_style_loaders[index] || null
-      );
-    }
-    return loaders_from_files;
-  }
-  async getViewComponent(route) {
-    return await this.componentLoader.load(route.view);
-  }
-  async hasLoaders(route) {
-    const componentPaths = [...route.layout || [], route.view];
-    for (const componentPath of componentPaths) {
-      const loader = await this.resolveLoader(componentPath);
-      if (loader) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async getLoaders(route) {
-    const layoutPaths = route.layout || [];
-    const layouts = await Promise.all(layoutPaths.map((layoutPath) => this.resolveLoader(layoutPath)));
-    const view = await this.resolveLoader(route.view);
-    return {
-      layouts,
-      view
-    };
-  }
-  getLoaderFilePath(componentPath, extension = ".js") {
-    if (!componentPath) {
-      return null;
-    }
-    const fullPath = this.componentLoader.getComponentFullPath(componentPath);
-    const { dir, name } = path.parse(fullPath);
-    return path.join(dir, `${name}.load${extension}`);
-  }
-  async resolveLoader(componentPath) {
-    if (!componentPath) {
-      return null;
-    }
-    const extensions = [".js", ".ts"];
-    for (const ext of extensions) {
-      const loaderFilePath = this.getLoaderFilePath(componentPath, ext);
-      if (!loaderFilePath) {
-        continue;
-      }
-      try {
-        console.log(`[ComponentManager] Trying loader path: ${loaderFilePath}`);
-        const module = await import(pathToFileURL(loaderFilePath).href);
-        const loader = module == null ? void 0 : module.default;
-        console.log(`[ComponentManager] Imported loader module: default=${typeof loader}`);
-        if (typeof loader === "function") {
-          console.log(`[ComponentManager] Loaded loader function from: ${loaderFilePath}`);
-          return loader;
-        }
-      } catch (error) {
-        const code = (error == null ? void 0 : error.code) || (error == null ? void 0 : error.name) || "UNKNOWN_ERROR";
-        if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-          console.warn(`[ComponentManager] Loader not found at ${loaderFilePath} (${ext}): ${(error == null ? void 0 : error.message) || code}`);
-          continue;
-        }
-        console.error(`[ComponentManager] Failed to load loader for ${componentPath} (${ext}) at ${loaderFilePath}:`, error);
-      }
-    }
-    return null;
-  }
-  async getView(route) {
-    const view = await this.componentLoader.load(route.view);
-    return view.default;
-  }
-}
 const EXTENSION_CANDIDATES = [".js", ".mjs", ".cjs", ".ts", ".tsx"];
 class MiddlewareAdapter {
   constructor(middlewarePath, fallbackPath) {
@@ -770,7 +427,7 @@ class MiddlewareAdapter {
   resolveMiddlewareFilePath(filePath) {
     const basePath = this.middlewarePath || this.fallbackPath || process.cwd();
     const transformed = this.middlewareFileTransform(filePath);
-    const baseCandidate = path.resolve(process.cwd(), path.join(basePath, transformed));
+    const baseCandidate = path__default.resolve(process.cwd(), path__default.join(basePath, transformed));
     const resolvedWithExt = this.findExistingFile(baseCandidate);
     if (resolvedWithExt) {
       return resolvedWithExt;
@@ -778,22 +435,22 @@ class MiddlewareAdapter {
     throw new Error(`Middleware file not found: ${transformed}`);
   }
   middlewareFileTransform(filePath) {
-    return filePath.split(".").join(path.sep);
+    return filePath.split(".").join(path__default.sep);
   }
   findExistingFile(basePathWithoutExt) {
-    const ext = path.extname(basePathWithoutExt);
+    const ext = path__default.extname(basePathWithoutExt);
     if (ext) {
-      return fs.existsSync(basePathWithoutExt) ? basePathWithoutExt : null;
+      return fs__default.existsSync(basePathWithoutExt) ? basePathWithoutExt : null;
     }
     const directCandidates = EXTENSION_CANDIDATES.map((extCandidate) => `${basePathWithoutExt}${extCandidate}`);
     for (const candidate of directCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs__default.existsSync(candidate)) {
         return candidate;
       }
     }
-    const indexCandidates = EXTENSION_CANDIDATES.map((extCandidate) => path.join(basePathWithoutExt, `index${extCandidate}`));
+    const indexCandidates = EXTENSION_CANDIDATES.map((extCandidate) => path__default.join(basePathWithoutExt, `index${extCandidate}`));
     for (const candidate of indexCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs__default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -887,20 +544,6 @@ class MiddlewareAdapter {
     return ordered;
   }
 }
-function makeUrlParser(pattern) {
-  const parser = new pathToRegex(pattern);
-  return (pathname) => {
-    const result = parser.match(pathname);
-    return result || null;
-  };
-}
-function initialize_route_matchers(routes) {
-  return routes.map((route) => {
-    const pattern = route.path;
-    const parser = makeUrlParser(pattern);
-    return { pattern, parser };
-  });
-}
 class ServerAdapter {
 }
 class ExpressServerAdapter extends ServerAdapter {
@@ -930,8 +573,8 @@ class ExpressServerAdapter extends ServerAdapter {
       return mod.default ?? mod;
     }
     const candidates = [
-      path.join(componentRoot, "RecursiveRender.js"),
-      path.join(componentRoot, "ssr", "RecursiveRender.js")
+      path__default.join(componentRoot, "RecursiveRender.js"),
+      path__default.join(componentRoot, "ssr", "RecursiveRender.js")
     ];
     let lastError;
     for (const fp of candidates) {
@@ -1126,20 +769,20 @@ ${e.stack}</pre>
       const clientComponentDir = this.isProd ? deriveClientBase(this.componentDir || "") : this.componentDir || "/assets";
       const head_routing = `
             <script type='text/javascript'>
-            window.__ROUTING__ = ${stringify(this.clientRoutes)}
+            window.__ROUTING__ = ${uneval(this.clientRoutes)}
             <\/script>
 
             <script type='text/javascript'>
-            window.__MANIFEST__ = ${stringify(manifest)}
+            window.__MANIFEST__ = ${uneval(manifest)}
             console.log('[MANIFEST INJECTED]', window.__MANIFEST__);
             <\/script>
 
             <script type='text/javascript'>
-            window.__INITIAL_DATA__ = ${stringify(server_data || {})}
+            window.__INITIAL_DATA__ = ${uneval(server_data || {})}
             <\/script>
 
             <script type='text/javascript'>
-            window.__COMPONENT_DIR__ = ${stringify(clientComponentDir)}
+            window.__COMPONENT_DIR__ = ${uneval(clientComponentDir)}
             <\/script>
             `;
       console.log("[SSR DEBUG] About to render HTML with APP length:", (body_render == null ? void 0 : body_render.length) || 0);
@@ -1229,7 +872,7 @@ view: ${route.view}</pre>`;
 }
 function pathExistsSync(p) {
   try {
-    return fs.existsSync(p);
+    return fs__default.existsSync(p);
   } catch {
     return false;
   }
@@ -1237,15 +880,15 @@ function pathExistsSync(p) {
 function resolveRuntimeRoot(candidate) {
   var _a;
   const envRoot = process.env.FORGE_ROOT;
-  if (envRoot && path.isAbsolute(envRoot) && pathExistsSync(envRoot)) {
-    return path.normalize(envRoot);
+  if (envRoot && path__default.isAbsolute(envRoot) && pathExistsSync(envRoot)) {
+    return path__default.normalize(envRoot);
   }
-  if (candidate && path.isAbsolute(candidate) && pathExistsSync(candidate)) {
-    return path.normalize(candidate);
+  if (candidate && path__default.isAbsolute(candidate) && pathExistsSync(candidate)) {
+    return path__default.normalize(candidate);
   }
   const entry = (_a = process.argv) == null ? void 0 : _a[1];
   if (entry) {
-    const entryDir = path.dirname(path.resolve(entry));
+    const entryDir = path__default.dirname(path__default.resolve(entry));
     if (pathExistsSync(entryDir)) return entryDir;
   }
   return process.cwd();
@@ -1257,7 +900,7 @@ async function createServer(app, options) {
   const root = resolveRuntimeRoot((_a = full_options.viteOptions) == null ? void 0 : _a.root);
   full_options.viteOptions.root = root;
   full_options.open_api_path = ensureFullPath(full_options.viteOptions.root, full_options.open_api_path);
-  const COMPONENT_DIR = !full_options.component_dir ? root : path.join(root, full_options.component_dir);
+  const COMPONENT_DIR = !full_options.component_dir ? root : path__default.join(root, full_options.component_dir);
   const isBuiltEnvironment = process.env.FORGE_BUILT === "true";
   const isProd = isBuiltEnvironment || full_options.development === false;
   console.log(`Running in ${isProd ? "production" : "development"} mode (built environment: ${isBuiltEnvironment}, development flag: ${full_options.development}, NODE_ENV: ${process.env.NODE_ENV})`);
@@ -1270,7 +913,7 @@ async function createServer(app, options) {
     }
     if (!entry || typeof entry !== "string") return root;
     const cleaned = entry.replace(/^\/+/, "");
-    return path.resolve(root, cleaned);
+    return path__default.resolve(root, cleaned);
   };
   if (full_options.assets) {
     for (const [asset_path, asset_dir] of Object.entries(full_options.assets)) {
@@ -1299,7 +942,7 @@ ${JSON.stringify(options, null, 2)}`);
     componentLoader = new ViteComponentLoader(COMPONENT_DIR, vite);
   } else {
     console.log("Starting Vite in production mode...");
-    const staticDir = path.join(full_options.viteOptions.root, full_options.build_dir);
+    const staticDir = path__default.join(full_options.viteOptions.root, full_options.build_dir);
     if (pathExistsSync(staticDir)) {
       app.use("/", express.static(staticDir));
       console.log(`Serving static files from ${staticDir} at /`);
@@ -1323,7 +966,7 @@ ${JSON.stringify(options, null, 2)}`);
   const api_adapter = new ApiAdapter(manager);
   let middlewareRoot;
   if (full_options.middleware_path) {
-    middlewareRoot = path.isAbsolute(full_options.middleware_path) ? full_options.middleware_path : path.resolve(full_options.viteOptions.root, full_options.middleware_path);
+    middlewareRoot = path__default.isAbsolute(full_options.middleware_path) ? full_options.middleware_path : path__default.resolve(full_options.viteOptions.root, full_options.middleware_path);
   }
   const middleware_adapter = MiddlewareAdapter.build(middlewareRoot, COMPONENT_DIR);
   const adapter = new ExpressServerAdapter(
@@ -1351,7 +994,7 @@ function getRenderer(root, renderer, isProd) {
     return new LiveHTMLRender(ensureFullPath(root, renderer));
   } else if (typeof renderer === "string" && isProd) {
     const html = ensureFullPath(root, renderer);
-    const template = fs.readFileSync(html, "utf8");
+    const template = fs__default.readFileSync(html, "utf8");
     return new BaseHTMLRender(template);
   } else if (renderer instanceof BaseHTMLRender) {
     return renderer;
@@ -1360,12 +1003,12 @@ function getRenderer(root, renderer, isProd) {
   }
 }
 function ensureFullPath(root, renderer) {
-  if (path.isAbsolute(renderer)) {
+  if (path__default.isAbsolute(renderer)) {
     console.log(`Renderer path is absolute: ${renderer}`);
     return urlJoin(root, renderer);
   } else {
     console.log(`Renderer path is relative: ${renderer}`);
-    return path.resolve(root, renderer);
+    return path__default.resolve(root, renderer);
   }
 }
 function urlJoin(base, path2) {