loly 0.1.0

package/bin/loly.js

@@ -0,0 +1,3015 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { config } from "dotenv";
+
+// src/server/dev-server.ts
+import { join as join3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import chokidar from "chokidar";
+
+// src/router/scanner.ts
+import { glob } from "glob";
+import { relative, dirname, sep } from "path";
+
+// src/constants/routes.ts
+var ROUTE_FILE_NAMES = [
+  "page.tsx",
+  "page.ts",
+  "layout.tsx",
+  "layout.ts",
+  "route.ts",
+  "route.tsx"
+];
+
+// src/constants/directories.ts
+var DIRECTORIES = {
+  SRC: "src",
+  APP: "app",
+  DIST: "dist",
+  CLIENT: "client",
+  SERVER: "server",
+  PUBLIC: "public",
+  LOLY: ".loly"
+};
+
+// src/constants/files.ts
+var FILE_NAMES = {
+  MANIFEST: "manifest.json",
+  BOOTSTRAP: "bootstrap.ts",
+  GLOBALS_CSS: "globals.css",
+  ROUTES_MANIFEST: "routes-manifest.json"
+};
+
+// src/constants/http.ts
+var HTTP_STATUS = {
+  OK: 200,
+  BAD_REQUEST: 400,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  REQUEST_TIMEOUT: 408,
+  INTERNAL_ERROR: 500
+};
+var HTTP_HEADERS = {
+  CONTENT_TYPE_JSON: "application/json",
+  CONTENT_TYPE_HTML: "text/html; charset=utf-8"
+};
+
+// src/constants/server.ts
+var SERVER = {
+  DEFAULT_PORT: 3e3,
+  RSC_ENDPOINT: "/__loly/rsc",
+  IMAGE_ENDPOINT: "/_loly/image",
+  ASYNC_ENDPOINT: "/__loly/async",
+  APP_CONTAINER_ID: "app"
+};
+
+// src/constants/node-builtins.ts
+var NODE_BUILTINS = [
+  "fs",
+  "path",
+  "url",
+  "util",
+  "stream",
+  "events",
+  "crypto",
+  "http",
+  "https",
+  "os",
+  "querystring",
+  "buffer",
+  "constants",
+  "child_process",
+  "module",
+  "fs/promises",
+  "worker_threads",
+  "zlib",
+  "inspector",
+  "perf_hooks"
+];
+
+// src/constants/errors.ts
+var ERROR_MESSAGES = {
+  CONTEXT_NOT_INITIALIZED: "[loly-core] Framework context not initialized. Call setContext() first.",
+  APP_DIR_NOT_FOUND: (dir) => `[loly-core] src/app/ directory not found in ${dir}. Please ensure your project has a src/app/ directory.`,
+  ROUTE_NOT_FOUND: (pathname) => `Route not found: ${pathname}`,
+  PAGE_COMPONENT_NOT_FOUND: (path4) => `[loly-core] Page component not found in ${path4}`,
+  PAGE_COMPONENT_MUST_BE_FUNCTION: "[loly-core] Page component must be a function",
+  COMPONENT_NOT_FOUND: (route) => `Component not found for route: ${route}`,
+  APP_CONTAINER_NOT_FOUND: "[loly-core] App container not found (#app)",
+  CLIENT_BUILD_DIR_NOT_FOUND: (dir) => `[loly-core] Client build directory not found: ${dir}. Run 'loly build' first or the client scripts won't load.`,
+  ROUTES_MANIFEST_NOT_FOUND: (path4) => `[loly-core] Routes manifest not found: ${path4}. Run 'loly build' first.`,
+  DIRECTORY_NOT_FOUND: (dir) => `[loly-core] Directory not found: ${dir}`,
+  CLIENT_BUILD_FAILED: "Client build failed",
+  SERVER_BUILD_FAILED: "Server build failed",
+  FAILED_TO_LOAD_MODULE: (path4) => `[loly-core] Failed to load module: ${path4}`,
+  FAILED_TO_LOAD_ROUTE_COMPONENT: (path4) => `[bootstrap] Failed to load component for route ${path4}`,
+  FAILED_TO_LOAD_NESTED_LAYOUT: (path4) => `[loly-core] Failed to load nested layout at ${path4}`,
+  FAILED_TO_READ_CLIENT_MANIFEST: "[loly-core] Failed to read client manifest:",
+  FAILED_TO_PARSE_ISLAND_DATA: "[loly-core] Failed to parse island data:",
+  FATAL_BOOTSTRAP_ERROR: "[bootstrap] Fatal error during bootstrap:",
+  UNEXPECTED_ERROR: "[loly-core] Unexpected error:",
+  ERROR_STARTING_DEV_SERVER: "[loly-core] Error starting dev server:",
+  ERROR_STARTING_PROD_SERVER: "[loly-core] Error starting production server:",
+  ERROR_BUILDING_PROJECT: "[loly-core] Error building project:",
+  ERROR_HANDLING_REQUEST: "[loly-core] Error handling request:",
+  ERROR_RENDERING_PAGE: "[loly-core] Error rendering page:",
+  RSC_ENDPOINT_ERROR: "[loly-core] RSC endpoint error:"
+};
+
+// src/utils/path.ts
+function normalizePath(path4) {
+  if (path4 === "/") return "/";
+  return path4.replace(/\/$/, "") || "/";
+}
+function normalizeUrlPath(pathname) {
+  return normalizePath(pathname);
+}
+
+// src/utils/module-loader.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+var tsxRegistered = false;
+var tsxRegistrationPromise = null;
+async function ensureTsxRegistered() {
+  if (tsxRegistered) {
+    return;
+  }
+  if (tsxRegistrationPromise) {
+    await tsxRegistrationPromise;
+    return;
+  }
+  tsxRegistrationPromise = (async () => {
+    try {
+      await import("tsx/esm");
+      tsxRegistered = true;
+    } catch (error) {
+      console.warn(
+        "[loly-core] tsx not available, TypeScript files won't load in development"
+      );
+      tsxRegistered = true;
+    }
+  })();
+  await tsxRegistrationPromise;
+}
+function resolveModuleUrl(path4) {
+  if (path4.startsWith("file://")) {
+    return path4;
+  }
+  const absolutePath = resolve(path4);
+  const normalizedPath = absolutePath.replace(/\\/g, "/");
+  if (normalizedPath.startsWith("/")) {
+    return `file://${normalizedPath}`;
+  }
+  return `file:///${normalizedPath}`;
+}
+async function loadModule(filePath, compiledPath) {
+  let pathToLoad = filePath;
+  if (compiledPath && existsSync(compiledPath)) {
+    pathToLoad = compiledPath;
+  }
+  try {
+    if (pathToLoad.endsWith(".ts") || pathToLoad.endsWith(".tsx")) {
+      await ensureTsxRegistered();
+    }
+    const fileUrl = resolveModuleUrl(pathToLoad);
+    const module = await import(fileUrl);
+    return module;
+  } catch (error) {
+    console.error(ERROR_MESSAGES.FAILED_TO_LOAD_MODULE(pathToLoad), error);
+    throw error;
+  }
+}
+
+// src/router/scanner.ts
+function parseSegment(segment) {
+  if (segment.startsWith("(") && segment.endsWith(")")) {
+    return {
+      segment,
+      // Keep original with parentheses: (admin)
+      isDynamic: false,
+      isCatchAll: false,
+      isOptional: true
+    };
+  }
+  if (segment.startsWith("[...") && segment.endsWith("]")) {
+    const paramName = segment.slice(4, -1);
+    return {
+      segment,
+      isDynamic: true,
+      isCatchAll: true,
+      isOptional: false,
+      paramName
+    };
+  }
+  if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+    const paramName = segment.slice(5, -2);
+    return {
+      segment,
+      isDynamic: true,
+      isCatchAll: true,
+      isOptional: true,
+      paramName
+    };
+  }
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    const paramName = segment.slice(1, -1);
+    return {
+      segment,
+      isDynamic: true,
+      isCatchAll: false,
+      isOptional: false,
+      paramName
+    };
+  }
+  return {
+    segment,
+    isDynamic: false,
+    isCatchAll: false,
+    isOptional: false
+  };
+}
+function segmentsToUrlPath(segments) {
+  const parts = [];
+  for (const seg of segments) {
+    if (seg.isOptional) {
+      continue;
+    }
+    if (seg.isCatchAll) {
+      parts.push(`*${seg.paramName || "slug"}`);
+    } else if (seg.isDynamic) {
+      parts.push(`:${seg.paramName || "param"}`);
+    } else {
+      parts.push(seg.segment);
+    }
+  }
+  const path4 = "/" + parts.join("/");
+  return normalizeUrlPath(path4);
+}
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+async function analyzeApiRoute(filePath) {
+  try {
+    const module = await loadModule(filePath);
+    const exports = Object.keys(module);
+    const httpMethods = [];
+    for (const exportName of exports) {
+      const upperExport = exportName.toUpperCase();
+      if (HTTP_METHODS.includes(upperExport) && typeof module[exportName] === "function") {
+        httpMethods.push(upperExport);
+      }
+    }
+    return httpMethods;
+  } catch (error) {
+    console.warn(`[loly-core] Failed to analyze API route ${filePath}:`, error);
+    return [];
+  }
+}
+async function scanRoutes(appDir) {
+  const routes = [];
+  const routeMap = /* @__PURE__ */ new Map();
+  const apiRouteMap = /* @__PURE__ */ new Map();
+  const patterns = ROUTE_FILE_NAMES.map((file) => `**/${file}`);
+  const files = await glob(patterns, { cwd: appDir, absolute: true });
+  let rootLayout;
+  for (const file of files) {
+    const absolutePath = file;
+    const relativePath = relative(appDir, absolutePath);
+    const dir = dirname(relativePath);
+    const fileName = file.split(sep).pop() || "";
+    let type;
+    if (fileName.startsWith("page.")) {
+      type = "page";
+    } else if (fileName.startsWith("layout.")) {
+      type = "layout";
+    } else if (fileName.startsWith("route.")) {
+      type = "route";
+    } else {
+      continue;
+    }
+    const pathSegments = dir === "." ? [] : dir.split(sep).filter(Boolean);
+    const segments = pathSegments.map(parseSegment);
+    const isRootLayout = type === "layout" && dir === ".";
+    let urlPath = "";
+    let isApiRoute = false;
+    let httpMethods = void 0;
+    if (type === "page") {
+      urlPath = segmentsToUrlPath(segments);
+    } else if (type === "route") {
+      httpMethods = await analyzeApiRoute(absolutePath);
+      if (httpMethods.length > 0) {
+        isApiRoute = true;
+        urlPath = segmentsToUrlPath(segments);
+      }
+    }
+    const routeFile = {
+      filePath: absolutePath,
+      segments,
+      type,
+      isRootLayout,
+      urlPath,
+      isApiRoute: isApiRoute || void 0,
+      httpMethods
+    };
+    routes.push(routeFile);
+    if (isRootLayout) {
+      rootLayout = routeFile;
+    }
+    if (type === "page") {
+      routeMap.set(urlPath, routeFile);
+    } else if (isApiRoute && urlPath) {
+      apiRouteMap.set(urlPath, routeFile);
+    }
+  }
+  return {
+    routes,
+    rootLayout,
+    routeMap,
+    apiRouteMap
+  };
+}
+
+// src/utils/route-component-factory.ts
+import { resolve as resolve2, join } from "path";
+import { existsSync as existsSync2 } from "fs";
+var RouteComponentFactory = class {
+  constructor() {
+    this.componentCache = /* @__PURE__ */ new Map();
+    this.layoutCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Load a route component
+   * @param route - Route file information
+   * @param compiledPath - Optional compiled path for production
+   * @returns The loaded component module
+   */
+  async loadRouteComponent(route, compiledPath) {
+    const cacheKey = compiledPath || route.filePath;
+    if (this.componentCache.has(cacheKey)) {
+      return this.componentCache.get(cacheKey);
+    }
+    const sourcePath = resolve2(route.filePath);
+    const module = await loadModule(sourcePath, compiledPath);
+    const component = module.default;
+    if (!component) {
+      throw new Error(
+        `[loly-core] Component not found in ${route.filePath}`
+      );
+    }
+    this.componentCache.set(cacheKey, component);
+    return component;
+  }
+  /**
+   * Load a layout component
+   * @param layout - Layout route file information
+   * @param compiledPath - Optional compiled path for production
+   * @returns The loaded layout component module
+   */
+  async loadLayoutComponent(layout, compiledPath) {
+    const cacheKey = compiledPath || layout.filePath;
+    if (this.layoutCache.has(cacheKey)) {
+      const cached = this.layoutCache.get(cacheKey);
+      return cached?.[0];
+    }
+    const sourcePath = resolve2(layout.filePath);
+    const module = await loadModule(sourcePath, compiledPath);
+    const layoutComponent = module.default;
+    if (!layoutComponent) {
+      throw new Error(
+        `[loly-core] Layout component not found in ${layout.filePath}`
+      );
+    }
+    this.layoutCache.set(cacheKey, [layoutComponent]);
+    return layoutComponent;
+  }
+  /**
+   * Load all layouts from root to route
+   * @param route - Target route file
+   * @param config - Route configuration
+   * @param appDir - Application directory
+   * @param manifestRoute - Optional manifest route data
+   * @returns Array of layout components in order (root to route)
+   */
+  async loadLayouts(route, config2, appDir, manifestRoute) {
+    const layouts = [];
+    const configWithManifest = config2;
+    const routesManifest = configWithManifest.routesManifest;
+    if (config2.rootLayout) {
+      const rootLayoutManifest = configWithManifest.rootLayoutManifest;
+      const layoutSourcePath = resolve2(config2.rootLayout.filePath);
+      const layoutCompiledPath = rootLayoutManifest?.serverPath ? resolve2(rootLayoutManifest.serverPath) : void 0;
+      const rootLayout = await this.loadLayoutComponent(
+        config2.rootLayout,
+        layoutCompiledPath
+      );
+      layouts.push(rootLayout);
+    }
+    const allRouteSegments = route.segments;
+    for (let i = 0; i < allRouteSegments.length; i++) {
+      const segmentPath = allRouteSegments.slice(0, i + 1);
+      let layoutManifest;
+      if (routesManifest) {
+        layoutManifest = routesManifest.find((r) => {
+          if (r.type !== "layout") return false;
+          if (r.isRootLayout) return false;
+          if (r.segments.length !== segmentPath.length) return false;
+          return r.segments.every((seg, idx) => {
+            const routeSeg = segmentPath[idx];
+            if (seg.segment === routeSeg.segment) return true;
+            if (seg.isDynamic && routeSeg.isDynamic && seg.paramName === routeSeg.paramName) {
+              return true;
+            }
+            if (seg.isOptional && routeSeg.isOptional && !seg.isDynamic && !routeSeg.isDynamic) {
+              const segName = seg.segment.replace(/^\(|\)$/g, "");
+              const routeSegName = routeSeg.segment.replace(/^\(|\)$/g, "");
+              if (segName === routeSegName) return true;
+            }
+            return false;
+          });
+        });
+      }
+      if (layoutManifest) {
+        const layoutSourcePath = resolve2(layoutManifest.sourcePath);
+        const layoutCompiledPath = layoutManifest.serverPath ? resolve2(layoutManifest.serverPath) : void 0;
+        try {
+          const layoutFile = {
+            filePath: layoutSourcePath,
+            segments: layoutManifest.segments,
+            type: "layout",
+            isRootLayout: false,
+            urlPath: ""
+          };
+          const layout = await this.loadLayoutComponent(
+            layoutFile,
+            layoutCompiledPath
+          );
+          layouts.push(layout);
+        } catch (error) {
+          console.warn(
+            `[loly-core] Failed to load nested layout at ${layoutSourcePath}:`,
+            error
+          );
+        }
+      } else {
+        const layoutPathParts = segmentPath.map((s) => s.segment);
+        const layoutDir = join(appDir, ...layoutPathParts);
+        const layoutFilePath = join(layoutDir, "layout.tsx");
+        const layoutFilePathAlt = join(layoutDir, "layout.ts");
+        const actualPath = existsSync2(layoutFilePath) ? layoutFilePath : existsSync2(layoutFilePathAlt) ? layoutFilePathAlt : null;
+        if (actualPath) {
+          try {
+            const layoutFile = {
+              filePath: actualPath,
+              segments: segmentPath,
+              type: "layout",
+              isRootLayout: false,
+              urlPath: ""
+            };
+            const layout = await this.loadLayoutComponent(layoutFile);
+            layouts.push(layout);
+          } catch (error) {
+            console.warn(
+              `[loly-core] Failed to load nested layout at ${actualPath}:`,
+              error
+            );
+          }
+        }
+      }
+    }
+    return layouts;
+  }
+  /**
+   * Clear component cache
+   */
+  clearCache() {
+    this.componentCache.clear();
+    this.layoutCache.clear();
+  }
+};
+
+// src/server/rendering/strategies.ts
+import { renderToHtmlStream, createHead } from "loly-jsx";
+
+// src/server/async-registry.ts
+var asyncTaskRegistry = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_AGE = 5 * 60 * 1e3;
+function registerAsyncTask(id, fn, props) {
+  asyncTaskRegistry.set(id, {
+    id,
+    fn,
+    props,
+    createdAt: Date.now()
+  });
+}
+async function resolveAsyncTask(id) {
+  const task = asyncTaskRegistry.get(id);
+  if (!task) {
+    throw new Error(`Async task not found: ${id}`);
+  }
+  return task.fn();
+}
+
+// src/server/rendering/strategies.ts
+import { resolve as resolve3 } from "path";
+
+// src/router/matcher.ts
+function matchRoute(pathname, config2, loadComponent) {
+  const normalized = normalizeUrlPath(pathname);
+  if (config2.routeMap.has(normalized)) {
+    const route = config2.routeMap.get(normalized);
+    return { route, params: {} };
+  }
+  for (const route of config2.routes) {
+    if (route.type !== "page") continue;
+    const match = matchRoutePattern(normalized, route);
+    if (match) {
+      return { route, params: match.params };
+    }
+  }
+  return null;
+}
+function matchRoutePattern(pathname, route) {
+  const pathSegments = pathname === "/" ? [""] : pathname.split("/").filter(Boolean);
+  const routeSegments = route.segments.filter((s) => !s.isOptional);
+  if (routeSegments.length === 0 && pathSegments.length === 1 && pathSegments[0] === "") {
+    return { params: {} };
+  }
+  const params = {};
+  let pathIdx = 0;
+  let routeIdx = 0;
+  while (pathIdx < pathSegments.length && routeIdx < routeSegments.length) {
+    const routeSeg = routeSegments[routeIdx];
+    const pathSeg = pathSegments[pathIdx];
+    if (routeSeg.isCatchAll) {
+      const remaining = pathSegments.slice(pathIdx);
+      if (routeSeg.paramName) {
+        params[routeSeg.paramName] = remaining.join("/");
+      }
+      return { params };
+    }
+    if (routeSeg.isDynamic) {
+      if (routeSeg.paramName) {
+        params[routeSeg.paramName] = decodeURIComponent(pathSeg);
+      }
+      pathIdx++;
+      routeIdx++;
+      continue;
+    }
+    if (routeSeg.segment === pathSeg) {
+      pathIdx++;
+      routeIdx++;
+      continue;
+    }
+    return null;
+  }
+  if (pathIdx === pathSegments.length && routeIdx === routeSegments.length) {
+    return { params };
+  }
+  return null;
+}
+
+// src/context.ts
+import { join as join2 } from "path";
+var globalContext = null;
+function setContext(context) {
+  globalContext = context;
+}
+function getContext() {
+  if (!globalContext) {
+    throw new Error(ERROR_MESSAGES.CONTEXT_NOT_INITIALIZED);
+  }
+  return globalContext;
+}
+function getProjectDir() {
+  return getContext().projectDir;
+}
+function getAppDir() {
+  return getContext().appDir;
+}
+function getSrcDir() {
+  return getContext().srcDir;
+}
+function getOutDir() {
+  return getContext().outDir;
+}
+function getAppDirPath(projectDir) {
+  return join2(projectDir, DIRECTORIES.SRC, DIRECTORIES.APP);
+}
+function getClientDir() {
+  return join2(getOutDir(), DIRECTORIES.CLIENT);
+}
+function getServerOutDir() {
+  return join2(getOutDir(), DIRECTORIES.SERVER);
+}
+function getManifestPath() {
+  return join2(getClientDir(), FILE_NAMES.MANIFEST);
+}
+function getRoutesManifestPath() {
+  return join2(getProjectDir(), DIRECTORIES.LOLY, FILE_NAMES.ROUTES_MANIFEST);
+}
+function getBootstrapPath() {
+  return join2(getProjectDir(), DIRECTORIES.LOLY, FILE_NAMES.BOOTSTRAP);
+}
+function getGlobalsCssPath() {
+  return join2(getClientDir(), FILE_NAMES.GLOBALS_CSS);
+}
+function getPublicDir() {
+  return join2(getProjectDir(), DIRECTORIES.PUBLIC);
+}
+function getRouteConfig() {
+  return getContext().routeConfig || null;
+}
+function setRouteConfig(config2) {
+  const context = getContext();
+  context.routeConfig = config2;
+}
+
+// src/utils/html.ts
+function generateErrorHtml(status, message) {
+  const statusText = status === HTTP_STATUS.NOT_FOUND ? "404 - Not Found" : status === HTTP_STATUS.INTERNAL_ERROR ? "500 - Internal Server Error" : `${status} - Error`;
+  return `<!doctype html><html><head><title>${statusText}</title></head><body><h1>${statusText}</h1>${message ? `<p>${message}</p>` : ""}</body></html>`;
+}
+function htmlStringToStream(html) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(html));
+      controller.close();
+    }
+  });
+}
+function extractIslandDataFromHtml(html) {
+  const islandData = {};
+  const islandDataRegex = /<script>window\.__LOLY_ISLAND_DATA__=window\.__LOLY_ISLAND_DATA__\|\|{};window\.__LOLY_ISLAND_DATA__\[([^\]]+)\]=([^<]+);<\/script>/gs;
+  const htmlWithoutScripts = html.replace(
+    islandDataRegex,
+    (match, id, data) => {
+      try {
+        let islandId;
+        const trimmedId = id.trim();
+        if (trimmedId.startsWith('"') || trimmedId.startsWith("'")) {
+          islandId = JSON.parse(trimmedId);
+        } else if (/^\d+$/.test(trimmedId)) {
+          islandId = trimmedId;
+        } else {
+          islandId = trimmedId;
+        }
+        const trimmedData = data.trim().replace(/;?\s*$/, "");
+        const islandProps = JSON.parse(trimmedData);
+        islandData[islandId] = islandProps;
+      } catch (e) {
+        console.warn(
+          "[loly-core] Failed to parse island data:",
+          e,
+          { id, data: data?.substring(0, 100) }
+        );
+      }
+      return "";
+    }
+  );
+  return { htmlWithoutScripts, islandData };
+}
+
+// src/utils/assets.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+function getMainScriptName() {
+  const manifestPath = getManifestPath();
+  if (!existsSync3(manifestPath)) {
+    return "main.js";
+  }
+  try {
+    const manifestContent = readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    const mainEntry = manifest["main"];
+    if (mainEntry?.file) {
+      return mainEntry.file;
+    }
+  } catch (error) {
+    console.warn("[loly-core] Failed to read client manifest:", error);
+  }
+  return "main.js";
+}
+function generateAssetTags(manifestRoute, publicPath = "/") {
+  let scripts = "";
+  let styles = "";
+  let preloads = "";
+  const mainScriptName = getMainScriptName();
+  const mainScriptPath = mainScriptName.startsWith("/") ? mainScriptName : `${publicPath}${mainScriptName}`;
+  preloads = `<link rel="modulepreload" href="${mainScriptPath}" crossorigin>`;
+  scripts = `<script type="module" src="${mainScriptPath}"></script>`;
+  const globalsCssPath = getGlobalsCssPath();
+  if (existsSync3(globalsCssPath)) {
+    const cssPath = `${publicPath}globals.css`;
+    styles += `
+<link rel="stylesheet" href="${cssPath}">`;
+  }
+  if (manifestRoute?.clientChunks) {
+    const { js = [], css = [] } = manifestRoute.clientChunks;
+    for (const jsFile of js) {
+      const scriptPath = jsFile.startsWith("/") ? jsFile : `${publicPath}${jsFile}`;
+      scripts += `
+<script type="module" src="${scriptPath}"></script>`;
+    }
+    for (const cssFile of css) {
+      const cssPath = cssFile.startsWith("/") ? cssFile : `${publicPath}${cssFile}`;
+      styles += `
+<link rel="stylesheet" href="${cssPath}">`;
+    }
+  }
+  return { scripts, styles, preloads };
+}
+function getClientAssetsForRoute(manifestRoute) {
+  return generateAssetTags(manifestRoute, "/");
+}
+
+// src/utils/errors.ts
+function handleRouteError(error, pathname) {
+  if (error.message.includes("Route not found")) {
+    return {
+      html: htmlStringToStream(generateErrorHtml(HTTP_STATUS.NOT_FOUND, "")),
+      status: HTTP_STATUS.NOT_FOUND
+    };
+  }
+  console.error(ERROR_MESSAGES.ERROR_RENDERING_PAGE, error);
+  return {
+    html: htmlStringToStream(generateErrorHtml(HTTP_STATUS.INTERNAL_ERROR, "")),
+    status: HTTP_STATUS.INTERNAL_ERROR
+  };
+}
+
+// src/utils/env.ts
+function getPublicEnv() {
+  const publicEnv = {};
+  if (typeof process !== "undefined" && process.env) {
+    for (const key in process.env) {
+      if (key.startsWith("LOLY_PUBLIC_")) {
+        const clientKey = key.replace(/^LOLY_PUBLIC_/, "");
+        publicEnv[clientKey] = process.env[key] || "";
+      }
+    }
+  }
+  return publicEnv;
+}
+function generatePublicEnvScript() {
+  const publicEnv = getPublicEnv();
+  const envJson = JSON.stringify(publicEnv);
+  return `<script>window.__LOLY_ENV__=Object.freeze(${envJson});</script>`;
+}
+
+// src/server/rendering/strategies.ts
+var RSCStrategy = class {
+  constructor(routeFactory2) {
+    this.routeFactory = routeFactory2;
+  }
+  async render(context, config2) {
+    const { pathname } = context;
+    const appDir = getAppDir();
+    const configWithManifest = config2;
+    const manifestRouteMap = configWithManifest.routeMapManifest;
+    const manifestRoute = manifestRouteMap?.get(pathname);
+    const match = matchRoute(pathname, config2, async (route2) => {
+      const routeManifest = manifestRouteMap?.get(pathname) || Array.from(manifestRouteMap?.values() || []).find(
+        (r) => r.urlPath === route2.urlPath
+      );
+      const compiledPath = routeManifest?.serverPath ? resolve3(routeManifest.serverPath) : void 0;
+      return await this.routeFactory.loadRouteComponent(route2, compiledPath);
+    });
+    if (!match) {
+      throw new Error(ERROR_MESSAGES.ROUTE_NOT_FOUND(pathname));
+    }
+    const { route, params } = match;
+    context.params = params;
+    const layouts = await this.routeFactory.loadLayouts(
+      route,
+      config2,
+      appDir,
+      manifestRoute
+    );
+    const pageCompiledPath = manifestRoute?.serverPath ? resolve3(manifestRoute.serverPath) : void 0;
+    const PageComponent = await this.routeFactory.loadRouteComponent(
+      route,
+      pageCompiledPath
+    );
+    const pageProps = {
+      params,
+      searchParams: context.searchParams
+    };
+    let pageContent;
+    if (typeof PageComponent === "function") {
+      const result = PageComponent(pageProps);
+      pageContent = result instanceof Promise ? await result : result;
+    } else {
+      throw new Error(ERROR_MESSAGES.PAGE_COMPONENT_MUST_BE_FUNCTION);
+    }
+    let content = pageContent;
+    for (let i = layouts.length - 1; i >= 0; i--) {
+      const Layout = layouts[i];
+      if (typeof Layout === "function") {
+        const layoutResult = Layout({ children: content, params });
+        content = layoutResult instanceof Promise ? await layoutResult : layoutResult;
+      }
+    }
+    const { renderToString: renderToString2 } = await import("loly-jsx");
+    const htmlWithScripts = await renderToString2(content);
+    const { htmlWithoutScripts, islandData } = extractIslandDataFromHtml(htmlWithScripts);
+    const { scripts, styles, preloads } = getClientAssetsForRoute(manifestRoute);
+    return { html: htmlWithoutScripts, scripts, styles, preloads, islandData };
+  }
+};
+var SSRStrategy = class {
+  constructor(routeFactory2) {
+    this.routeFactory = routeFactory2;
+  }
+  async render(context, config2) {
+    const { pathname } = context;
+    const appDir = getAppDir();
+    const configWithManifest = config2;
+    const manifestRouteMap = configWithManifest.routeMapManifest;
+    const manifestRoute = manifestRouteMap?.get(pathname);
+    const match = matchRoute(pathname, config2, async (route2) => {
+      const routeManifest = manifestRouteMap?.get(pathname) || Array.from(manifestRouteMap?.values() || []).find(
+        (r) => r.urlPath === route2.urlPath
+      );
+      const compiledPath = routeManifest?.serverPath ? resolve3(routeManifest.serverPath) : void 0;
+      return await this.routeFactory.loadRouteComponent(route2, compiledPath);
+    });
+    if (!match) {
+      return {
+        html: htmlStringToStream(generateErrorHtml(HTTP_STATUS.NOT_FOUND, "")),
+        status: HTTP_STATUS.NOT_FOUND
+      };
+    }
+    const { route, params } = match;
+    context.params = params;
+    try {
+      const layouts = await this.routeFactory.loadLayouts(
+        route,
+        config2,
+        appDir,
+        manifestRoute
+      );
+      const pageCompiledPath = manifestRoute?.serverPath ? resolve3(manifestRoute.serverPath) : void 0;
+      const PageComponent = await this.routeFactory.loadRouteComponent(
+        route,
+        pageCompiledPath
+      );
+      const pageProps = {
+        params,
+        searchParams: context.searchParams
+      };
+      let pageContent;
+      if (typeof PageComponent === "function") {
+        const result = PageComponent(pageProps);
+        pageContent = result instanceof Promise ? await result : result;
+      } else {
+        throw new Error(ERROR_MESSAGES.PAGE_COMPONENT_MUST_BE_FUNCTION);
+      }
+      let content = pageContent;
+      for (let i = layouts.length - 1; i >= 0; i--) {
+        const Layout = layouts[i];
+        if (typeof Layout === "function") {
+          const layoutResult = Layout({ children: content, params });
+          content = layoutResult instanceof Promise ? await layoutResult : layoutResult;
+        }
+      }
+      const head = createHead();
+      head.setTitle("Loly App");
+      const { scripts, styles, preloads } = getClientAssetsForRoute(manifestRoute);
+      const envScript = generatePublicEnvScript();
+      const headParts = [head.toString()];
+      if (preloads) headParts.push(preloads);
+      headParts.push(envScript);
+      const headContent = headParts.join("\n");
+      const htmlStream = renderToHtmlStream({
+        view: content,
+        head: headContent,
+        scripts,
+        styles,
+        appId: SERVER.APP_CONTAINER_ID,
+        onAsyncTask: (id, fn, props) => {
+          registerAsyncTask(id, fn, props);
+        }
+      });
+      return {
+        html: htmlStream,
+        status: HTTP_STATUS.OK
+      };
+    } catch (error) {
+      return handleRouteError(error, context.pathname);
+    }
+  }
+};
+
+// src/server/ssr.ts
+var routeFactory = new RouteComponentFactory();
+async function renderPageContent(context, config2, appDir) {
+  const rscStrategy = new RSCStrategy(routeFactory);
+  return await rscStrategy.render(context, config2);
+}
+async function renderPageStream(context, config2, appDir) {
+  const ssrStrategy = new SSRStrategy(routeFactory);
+  return await ssrStrategy.render(context, config2);
+}
+
+// src/server/base-server.ts
+import express2 from "express";
+
+// src/utils/express-setup.ts
+import express from "express";
+import { Readable } from "stream";
+import { existsSync as existsSync4 } from "fs";
+
+// src/server/handlers/image.ts
+import crypto2 from "crypto";
+
+// src/server/utils/image-optimizer.ts
+import sharp from "sharp";
+import fs2 from "fs";
+import path3 from "path";
+
+// src/server/utils/image-validation.ts
+import path from "path";
+function isRemoteUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function sanitizeImagePath(imagePath) {
+  const normalized = path.normalize(imagePath).replace(/^(\.\.(\/|\\|$))+/, "");
+  return normalized.replace(/^[/\\]+/, "");
+}
+function patternToRegex(pattern) {
+  const parts = [];
+  if (pattern.protocol) {
+    parts.push(pattern.protocol === "https" ? "https" : "http");
+  } else {
+    parts.push("https?");
+  }
+  parts.push("://");
+  let hostnamePattern = pattern.hostname.replace(/\./g, "\\.").replace(/\*\*/g, ".*").replace(/\*/g, "[^.]*");
+  parts.push(hostnamePattern);
+  if (pattern.port) {
+    parts.push(`:${pattern.port}`);
+  }
+  if (pattern.pathname) {
+    let pathnamePattern = pattern.pathname.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    parts.push(pathnamePattern);
+  } else {
+    parts.push(".*");
+  }
+  const regexSource = `^${parts.join("")}`;
+  return new RegExp(regexSource);
+}
+function validateRemoteUrl(url, config2) {
+  if (!config2 || !config2.remotePatterns && !config2.domains) {
+    return true;
+  }
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol.replace(":", "");
+    const hostname = urlObj.hostname;
+    const port = urlObj.port || "";
+    const pathname = urlObj.pathname;
+    if (config2.remotePatterns && config2.remotePatterns.length > 0) {
+      for (const pattern of config2.remotePatterns) {
+        const regex = patternToRegex(pattern);
+        const testUrl = `${protocol}://${hostname}${port ? `:${port}` : ""}${pathname}`;
+        if (regex.test(testUrl)) {
+          if (pattern.protocol && pattern.protocol !== protocol) {
+            continue;
+          }
+          if (pattern.port && pattern.port !== port) {
+            continue;
+          }
+          return true;
+        }
+      }
+    }
+    if (config2.domains && config2.domains.length > 0) {
+      for (const domain of config2.domains) {
+        const domainPattern = domain.replace(/\./g, "\\.").replace(/\*\*/g, ".*").replace(/\*/g, "[^.]*");
+        const regex = new RegExp(`^${domainPattern}$`);
+        if (regex.test(hostname)) {
+          if (process.env.NODE_ENV === "production" && protocol !== "https") {
+            continue;
+          }
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+function validateImageDimensions(width, height, config2) {
+  const maxWidth = config2?.maxWidth || 3840;
+  const maxHeight = config2?.maxHeight || 3840;
+  if (width !== void 0 && (width <= 0 || width > maxWidth)) {
+    return {
+      valid: false,
+      error: `Image width must be between 1 and ${maxWidth}, got ${width}`
+    };
+  }
+  if (height !== void 0 && (height <= 0 || height > maxHeight)) {
+    return {
+      valid: false,
+      error: `Image height must be between 1 and ${maxHeight}, got ${height}`
+    };
+  }
+  return { valid: true };
+}
+function validateQuality(quality) {
+  if (quality === void 0) {
+    return { valid: true };
+  }
+  if (typeof quality !== "number" || quality < 1 || quality > 100) {
+    return {
+      valid: false,
+      error: `Image quality must be between 1 and 100, got ${quality}`
+    };
+  }
+  return { valid: true };
+}
+
+// src/server/utils/image-cache.ts
+import fs from "fs";
+import path2 from "path";
+import crypto from "crypto";
+var ImageLRUCache = class {
+  constructor(maxSize = 50) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get an image from cache
+   */
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  /**
+   * Set an image in cache
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  /**
+   * Check if key exists in cache
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * Clear the cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache size
+   */
+  size() {
+    return this.cache.size;
+  }
+};
+var globalLRUCache = null;
+function getLRUCache(maxSize) {
+  if (!globalLRUCache) {
+    globalLRUCache = new ImageLRUCache(maxSize);
+  }
+  return globalLRUCache;
+}
+function generateCacheKey(src, width, height, quality, format) {
+  const data = `${src}-${width || ""}-${height || ""}-${quality || ""}-${format || ""}`;
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function getCacheDir() {
+  const projectDir = getProjectDir();
+  return path2.join(projectDir, DIRECTORIES.LOLY, "cache", "images");
+}
+function ensureCacheDir(cacheDir) {
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+}
+function getCachedImagePath(cacheKey, extension, cacheDir) {
+  return path2.join(cacheDir, `${cacheKey}.${extension}`);
+}
+function hasCachedImage(cacheKey, extension, cacheDir) {
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  return fs.existsSync(cachedPath);
+}
+function readCachedImage(cacheKey, extension, cacheDir) {
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  try {
+    if (fs.existsSync(cachedPath)) {
+      return fs.readFileSync(cachedPath);
+    }
+  } catch (error) {
+    console.warn(`[image-optimizer] Failed to read cached image: ${cachedPath}`, error);
+  }
+  return null;
+}
+function writeCachedImage(cacheKey, extension, cacheDir, imageBuffer) {
+  ensureCacheDir(cacheDir);
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  try {
+    fs.writeFileSync(cachedPath, imageBuffer);
+  } catch (error) {
+    console.warn(`[image-optimizer] Failed to write cached image: ${cachedPath}`, error);
+  }
+}
+function getImageMimeType(format) {
+  const formatMap = {
+    webp: "image/webp",
+    avif: "image/avif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    svg: "image/svg+xml"
+  };
+  const normalized = format.toLowerCase();
+  return formatMap[normalized] || "image/jpeg";
+}
+function getImageExtension(format) {
+  const formatMap = {
+    "image/webp": "webp",
+    "image/avif": "avif",
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/svg+xml": "svg",
+    webp: "webp",
+    avif: "avif",
+    jpeg: "jpg",
+    jpg: "jpg",
+    png: "png",
+    gif: "gif",
+    svg: "svg"
+  };
+  const normalized = format.toLowerCase();
+  return formatMap[normalized] || "jpg";
+}
+function cleanupCacheByAge(cacheDir, maxAgeDays = 30) {
+  const result = { deleted: 0, freed: 0 };
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
+  const now = Date.now();
+  try {
+    if (!fs.existsSync(cacheDir)) {
+      return result;
+    }
+    const files = fs.readdirSync(cacheDir);
+    for (const file of files) {
+      const filePath = path2.join(cacheDir, file);
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) {
+          const age = now - stat.mtime.getTime();
+          if (age > maxAgeMs) {
+            const size = stat.size;
+            fs.unlinkSync(filePath);
+            result.deleted++;
+            result.freed += size;
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.warn(`[image-cache] Failed to cleanup cache by age: ${cacheDir}`, error);
+  }
+  return result;
+}
+function cleanupCacheBySize(cacheDir, maxSizeMB = 500) {
+  const result = { deleted: 0, freed: 0 };
+  const maxSizeBytes = maxSizeMB * 1024 * 1024;
+  try {
+    if (!fs.existsSync(cacheDir)) {
+      return result;
+    }
+    const files = fs.readdirSync(cacheDir);
+    const fileInfos = [];
+    for (const file of files) {
+      const filePath = path2.join(cacheDir, file);
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) {
+          fileInfos.push({
+            path: filePath,
+            mtime: stat.mtime.getTime(),
+            size: stat.size
+          });
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    const totalSize = fileInfos.reduce((sum, info) => sum + info.size, 0);
+    if (totalSize <= maxSizeBytes) {
+      return result;
+    }
+    fileInfos.sort((a, b) => a.mtime - b.mtime);
+    let currentSize = totalSize;
+    for (const fileInfo of fileInfos) {
+      if (currentSize <= maxSizeBytes) {
+        break;
+      }
+      try {
+        fs.unlinkSync(fileInfo.path);
+        result.deleted++;
+        result.freed += fileInfo.size;
+        currentSize -= fileInfo.size;
+      } catch (error) {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.warn(`[image-cache] Failed to cleanup cache by size: ${cacheDir}`, error);
+  }
+  return result;
+}
+function cleanupCache(config2) {
+  const cacheDir = getCacheDir();
+  const maxSizeMB = config2?.maxSizeMB ?? 500;
+  const maxAgeDays = config2?.maxAgeDays ?? 30;
+  const ageResult = cleanupCacheByAge(cacheDir, maxAgeDays);
+  const sizeResult = cleanupCacheBySize(cacheDir, maxSizeMB);
+  return {
+    deleted: ageResult.deleted + sizeResult.deleted,
+    freed: ageResult.freed + sizeResult.freed
+  };
+}
+
+// src/server/utils/image-optimizer.ts
+var DEFAULT_IMAGE_CONFIG = {
+  maxWidth: 3840,
+  maxHeight: 3840,
+  quality: 70,
+  formats: ["image/avif", "image/webp"],
+  minimumCacheTTL: 31536e3,
+  // 1 año (en lugar de 60)
+  cacheMaxSize: 500,
+  cacheMaxAge: 30,
+  cacheLRUSize: 50,
+  cacheCleanupInterval: 100
+};
+var requestCount = 0;
+async function downloadRemoteImage(url, timeout = 1e4) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "Loly-Image-Optimizer/1.0"
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Image download timeout after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
+function readLocalImage(src, projectRoot) {
+  const sanitized = sanitizeImagePath(src);
+  const publicDir = getPublicDir();
+  const publicPath = path3.join(publicDir, sanitized);
+  if (fs2.existsSync(publicPath)) {
+    return fs2.readFileSync(publicPath);
+  }
+  if (src.startsWith("/")) {
+    const absolutePath = path3.join(projectRoot, sanitized);
+    if (fs2.existsSync(absolutePath)) {
+      return fs2.readFileSync(absolutePath);
+    }
+  }
+  throw new Error(`Image not found: ${src}`);
+}
+function determineOutputFormat(sourceFormat, requestedFormat, config2) {
+  if (sourceFormat === "svg") {
+    return "svg";
+  }
+  if (requestedFormat && requestedFormat !== "auto") {
+    return requestedFormat;
+  }
+  const supportedFormats = config2.formats || ["image/webp"];
+  if (supportedFormats.includes("image/avif")) {
+    return "avif";
+  }
+  if (supportedFormats.includes("image/webp")) {
+    return "webp";
+  }
+  return sourceFormat === "svg" ? "jpeg" : sourceFormat;
+}
+async function optimizeImage(options, config2) {
+  const imageConfig = config2 || DEFAULT_IMAGE_CONFIG;
+  const projectRoot = getProjectDir();
+  const dimValidation = validateImageDimensions(options.width, options.height, imageConfig);
+  if (!dimValidation.valid) {
+    throw new Error(dimValidation.error);
+  }
+  const qualityValidation = validateQuality(options.quality);
+  if (!qualityValidation.valid) {
+    throw new Error(qualityValidation.error);
+  }
+  if (isRemoteUrl(options.src)) {
+    if (!validateRemoteUrl(options.src, imageConfig)) {
+      throw new Error(`Remote image domain not allowed: ${options.src}`);
+    }
+  }
+  const sourceFormat = path3.extname(options.src).slice(1).toLowerCase() || "jpeg";
+  const outputFormat = determineOutputFormat(sourceFormat, options.format, imageConfig);
+  const cacheKey = generateCacheKey(
+    options.src,
+    options.width,
+    options.height,
+    options.quality || imageConfig.quality || 75,
+    outputFormat
+  );
+  const cacheDir = getCacheDir();
+  const extension = getImageExtension(outputFormat);
+  const fullCacheKey = `${cacheKey}.${extension}`;
+  const lruSize = imageConfig.cacheLRUSize || DEFAULT_IMAGE_CONFIG.cacheLRUSize || 50;
+  const lruCache = getLRUCache(lruSize);
+  const lruCached = lruCache.get(fullCacheKey);
+  if (lruCached) {
+    const metadata2 = await sharp(lruCached).metadata();
+    return {
+      buffer: lruCached,
+      format: outputFormat,
+      mimeType: getImageMimeType(outputFormat),
+      width: metadata2.width || options.width || 0,
+      height: metadata2.height || options.height || 0
+    };
+  }
+  if (hasCachedImage(cacheKey, extension, cacheDir)) {
+    const cached = readCachedImage(cacheKey, extension, cacheDir);
+    if (cached) {
+      lruCache.set(fullCacheKey, cached);
+      const metadata2 = await sharp(cached).metadata();
+      return {
+        buffer: cached,
+        format: outputFormat,
+        mimeType: getImageMimeType(outputFormat),
+        width: metadata2.width || options.width || 0,
+        height: metadata2.height || options.height || 0
+      };
+    }
+  }
+  let imageBuffer;
+  if (isRemoteUrl(options.src)) {
+    imageBuffer = await downloadRemoteImage(options.src);
+  } else {
+    imageBuffer = readLocalImage(options.src, projectRoot);
+  }
+  if (outputFormat === "svg" || sourceFormat === "svg") {
+    if (!imageConfig.dangerouslyAllowSVG) {
+      throw new Error("SVG images are not allowed. Set images.dangerouslyAllowSVG to true to enable.");
+    }
+    return {
+      buffer: imageBuffer,
+      format: "svg",
+      mimeType: "image/svg+xml",
+      width: options.width || 0,
+      height: options.height || 0
+    };
+  }
+  let sharpInstance = sharp(imageBuffer);
+  const metadata = await sharpInstance.metadata();
+  if (options.width || options.height) {
+    const fit = options.fit || "cover";
+    sharpInstance = sharpInstance.resize(options.width, options.height, {
+      fit,
+      withoutEnlargement: true
+    });
+  }
+  const quality = options.quality || imageConfig.quality || 75;
+  switch (outputFormat) {
+    case "webp":
+      sharpInstance = sharpInstance.webp({ quality });
+      break;
+    case "avif":
+      sharpInstance = sharpInstance.avif({ quality });
+      break;
+    case "jpeg":
+    case "jpg":
+      sharpInstance = sharpInstance.jpeg({ quality });
+      break;
+    case "png":
+      sharpInstance = sharpInstance.png({ quality: Math.round(quality / 100 * 9) });
+      break;
+    default:
+      sharpInstance = sharpInstance.jpeg({ quality });
+  }
+  const optimizedBuffer = await sharpInstance.toBuffer();
+  const finalMetadata = await sharp(optimizedBuffer).metadata();
+  lruCache.set(fullCacheKey, optimizedBuffer);
+  writeCachedImage(cacheKey, extension, cacheDir, optimizedBuffer);
+  requestCount++;
+  const cleanupInterval = imageConfig.cacheCleanupInterval || DEFAULT_IMAGE_CONFIG.cacheCleanupInterval || 100;
+  if (requestCount >= cleanupInterval) {
+    requestCount = 0;
+    setImmediate(() => {
+      try {
+        const cleanupResult = cleanupCache({
+          maxSizeMB: imageConfig.cacheMaxSize || DEFAULT_IMAGE_CONFIG.cacheMaxSize,
+          maxAgeDays: imageConfig.cacheMaxAge || DEFAULT_IMAGE_CONFIG.cacheMaxAge
+        });
+        if (cleanupResult.deleted > 0) {
+          console.log(
+            `[image-cache] Cleaned up ${cleanupResult.deleted} files, freed ${(cleanupResult.freed / 1024 / 1024).toFixed(2)} MB`
+          );
+        }
+      } catch (error) {
+        console.warn("[image-cache] Cleanup failed:", error);
+      }
+    });
+  }
+  return {
+    buffer: optimizedBuffer,
+    format: outputFormat,
+    mimeType: getImageMimeType(outputFormat),
+    width: finalMetadata.width || options.width || metadata.width || 0,
+    height: finalMetadata.height || options.height || metadata.height || 0
+  };
+}
+
+// src/server/handlers/image.ts
+async function handleImageRequest(options) {
+  const { req, res, config: config2 } = options;
+  try {
+    const src = req.query.src;
+    const width = req.query.w ? parseInt(req.query.w, 10) : void 0;
+    const height = req.query.h ? parseInt(req.query.h, 10) : void 0;
+    const quality = req.query.q ? parseInt(req.query.q, 10) : void 0;
+    const format = req.query.format;
+    const fit = req.query.fit;
+    if (!src) {
+      res.status(400).json({
+        error: "Missing required parameter: src"
+      });
+      return;
+    }
+    if (typeof src !== "string") {
+      res.status(400).json({
+        error: "Parameter 'src' must be a string"
+      });
+      return;
+    }
+    const etagInput = `${src}-${width || ""}-${height || ""}-${quality || ""}-${format || ""}-${fit || ""}`;
+    const etag = `"${crypto2.createHash("md5").update(etagInput).digest("hex")}"`;
+    const ifNoneMatch = req.headers["if-none-match"];
+    if (ifNoneMatch === etag) {
+      res.status(304).end();
+      return;
+    }
+    const result = await optimizeImage(
+      {
+        src,
+        width,
+        height,
+        quality,
+        format,
+        fit
+      },
+      config2
+    );
+    const imageConfig = config2 || {};
+    const cacheTTL = imageConfig.minimumCacheTTL ?? DEFAULT_IMAGE_CONFIG.minimumCacheTTL;
+    res.setHeader("Content-Type", result.mimeType);
+    res.setHeader("Content-Length", result.buffer.length);
+    res.setHeader("Cache-Control", `public, max-age=${cacheTTL}, immutable`);
+    res.setHeader("ETag", etag);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.send(result.buffer);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("not allowed")) {
+        res.status(403).json({
+          error: "Forbidden",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("not found") || error.message.includes("Image not found")) {
+        res.status(404).json({
+          error: "Not Found",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("must be")) {
+        res.status(400).json({
+          error: "Bad Request",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("timeout") || error.message.includes("download")) {
+        res.status(504).json({
+          error: "Gateway Timeout",
+          message: error.message
+        });
+        return;
+      }
+    }
+    console.error("[image-optimizer] Error processing image:", error);
+    res.status(500).json({
+      error: "Internal Server Error",
+      message: "Failed to process image"
+    });
+  }
+}
+
+// src/router/api-matcher.ts
+function matchRoutePattern2(pathname, route) {
+  const pathSegments = pathname === "/" ? [""] : pathname.split("/").filter(Boolean);
+  const routeSegments = route.segments.filter((s) => !s.isOptional);
+  if (routeSegments.length === 0 && pathSegments.length === 1 && pathSegments[0] === "") {
+    return { params: {} };
+  }
+  const params = {};
+  let pathIdx = 0;
+  let routeIdx = 0;
+  while (pathIdx < pathSegments.length && routeIdx < routeSegments.length) {
+    const routeSeg = routeSegments[routeIdx];
+    const pathSeg = pathSegments[pathIdx];
+    if (routeSeg.isCatchAll) {
+      const remaining = pathSegments.slice(pathIdx);
+      if (routeSeg.paramName) {
+        params[routeSeg.paramName] = remaining.join("/");
+      }
+      return { params };
+    }
+    if (routeSeg.isDynamic) {
+      if (routeSeg.paramName) {
+        params[routeSeg.paramName] = decodeURIComponent(pathSeg);
+      }
+      pathIdx++;
+      routeIdx++;
+      continue;
+    }
+    if (routeSeg.segment === pathSeg) {
+      pathIdx++;
+      routeIdx++;
+      continue;
+    }
+    return null;
+  }
+  if (pathIdx === pathSegments.length && routeIdx === routeSegments.length) {
+    return { params };
+  }
+  return null;
+}
+function matchApiRoute(pathname, config2) {
+  const normalized = normalizeUrlPath(pathname);
+  if (config2.apiRouteMap && config2.apiRouteMap.has(normalized)) {
+    const route = config2.apiRouteMap.get(normalized);
+    return { route, params: {} };
+  }
+  if (config2.apiRouteMap) {
+    for (const route of config2.apiRouteMap.values()) {
+      const match = matchRoutePattern2(normalized, route);
+      if (match) {
+        return { route, params: match.params };
+      }
+    }
+  }
+  for (const route of config2.routes) {
+    if (!route.isApiRoute || !route.urlPath) continue;
+    const match = matchRoutePattern2(normalized, route);
+    if (match) {
+      return { route, params: match.params };
+    }
+  }
+  return null;
+}
+
+// src/utils/api-route-loader.ts
+var HTTP_METHODS2 = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+async function loadApiRoute(route, compiledPath) {
+  if (!route.isApiRoute) {
+    throw new Error(`[loly-core] Route ${route.filePath} is not an API route`);
+  }
+  const sourcePath = route.filePath;
+  const module = await loadModule(sourcePath, compiledPath);
+  const handlers = /* @__PURE__ */ new Map();
+  for (const exportName of Object.keys(module)) {
+    const upperExport = exportName.toUpperCase();
+    if (HTTP_METHODS2.includes(upperExport) && typeof module[exportName] === "function") {
+      handlers.set(upperExport, module[exportName]);
+    }
+  }
+  if (handlers.size === 0) {
+    throw new Error(
+      `[loly-core] No valid HTTP method handlers found in API route ${route.filePath}`
+    );
+  }
+  return { handlers };
+}
+function hasMethod(loadedRoute, method) {
+  return loadedRoute.handlers.has(method.toUpperCase());
+}
+function getHandler(loadedRoute, method) {
+  return loadedRoute.handlers.get(method.toUpperCase());
+}
+
+// src/server/handlers/api-route.ts
+function createApiRouteHandler() {
+  return async (pathname, method, req, res, config2) => {
+    try {
+      const match = matchApiRoute(pathname, config2);
+      if (!match) {
+        return false;
+      }
+      const { route, params } = match;
+      const loadedRoute = await loadApiRoute(route);
+      const upperMethod = method.toUpperCase();
+      if (!hasMethod(loadedRoute, upperMethod)) {
+        res.status(HTTP_STATUS.METHOD_NOT_ALLOWED).json({ error: `Method ${method} not allowed` });
+        return true;
+      }
+      const handler = getHandler(loadedRoute, upperMethod);
+      if (!handler) {
+        res.status(HTTP_STATUS.METHOD_NOT_ALLOWED).json({ error: `Method ${method} not allowed` });
+        return true;
+      }
+      req.params = params;
+      await handler(req, res);
+      return true;
+    } catch (error) {
+      console.error("[loly-core] Error handling API route:", error);
+      if (!res.headersSent) {
+        res.status(HTTP_STATUS.INTERNAL_ERROR).json({
+          error: "Internal Server Error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+        return true;
+      }
+      return false;
+    }
+  };
+}
+
+// src/server/handlers/async-handler.ts
+import { renderToString } from "loly-jsx";
+async function handleAsyncRequest(req, res) {
+  try {
+    const asyncId = req.params.id;
+    if (!asyncId) {
+      res.status(HTTP_STATUS.BAD_REQUEST).json({
+        html: null,
+        error: "Missing async ID"
+      });
+      return;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Timeout")), 3e4);
+    });
+    try {
+      const resolvedVNode = await Promise.race([resolveAsyncTask(asyncId), timeoutPromise]);
+      const html = await renderToString(resolvedVNode);
+      res.status(HTTP_STATUS.OK).json({
+        html,
+        error: null
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message === "Timeout") {
+        res.status(HTTP_STATUS.REQUEST_TIMEOUT).json({
+          html: null,
+          error: "Async task timeout"
+        });
+        return;
+      }
+      if (error instanceof Error && error.message.includes("not found")) {
+        res.status(HTTP_STATUS.NOT_FOUND).json({
+          html: null,
+          error: error.message
+        });
+        return;
+      }
+      console.error("[loly] Error resolving async task:", error);
+      res.status(HTTP_STATUS.INTERNAL_ERROR).json({
+        html: null,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  } catch (error) {
+    console.error("[loly] Error handling async request:", error);
+    res.status(HTTP_STATUS.INTERNAL_ERROR).json({
+      html: null,
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
+  }
+}
+
+// src/utils/express-setup.ts
+import compression from "compression";
+function setupExpressMiddleware(app) {
+  app.use(compression({
+    level: 6,
+    // Compression level (1-9, 6 is good balance)
+    threshold: 1024,
+    // Only compress responses > 1KB
+    filter: (req, res) => {
+      if (req.headers["x-no-compression"]) {
+        return false;
+      }
+      return compression.filter(req, res);
+    }
+  }));
+  app.use((req, res, next) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    req.query = Object.fromEntries(url.searchParams);
+    next();
+  });
+}
+function setupStaticFiles(app, clientDir, publicDir) {
+  if (existsSync4(clientDir)) {
+    app.use(express.static(clientDir));
+  } else {
+    console.warn(ERROR_MESSAGES.CLIENT_BUILD_DIR_NOT_FOUND(clientDir));
+  }
+  if (existsSync4(publicDir)) {
+    app.use(express.static(publicDir));
+  }
+}
+function setupRSCEndpoint(app, handler) {
+  app.get(SERVER.RSC_ENDPOINT, async (req, res) => {
+    try {
+      const pathname = req.query.path || "/";
+      const search = req.query.search || "";
+      const searchParams = search ? Object.fromEntries(new URLSearchParams(search)) : {};
+      const result = await handler(pathname, searchParams);
+      res.setHeader("Content-Type", HTTP_HEADERS.CONTENT_TYPE_JSON);
+      res.json({
+        pathname,
+        params: result.params,
+        searchParams,
+        html: result.html,
+        scripts: result.scripts,
+        styles: result.styles,
+        preloads: result.preloads,
+        islandData: result.islandData
+      });
+    } catch (error) {
+      console.error(ERROR_MESSAGES.RSC_ENDPOINT_ERROR, error);
+      if (error.message.includes("Route not found")) {
+        res.status(HTTP_STATUS.NOT_FOUND).json({ error: "Route not found" });
+      } else {
+        res.status(HTTP_STATUS.INTERNAL_ERROR).json({
+          error: "Internal Server Error"
+        });
+      }
+    }
+  });
+}
+function setupImageEndpoint(app, config2) {
+  app.get(SERVER.IMAGE_ENDPOINT, async (req, res) => {
+    await handleImageRequest({ req, res, config: config2 });
+  });
+}
+function setupAsyncEndpoint(app) {
+  app.get(`${SERVER.ASYNC_ENDPOINT}/:id`, async (req, res) => {
+    await handleAsyncRequest(req, res);
+  });
+}
+function setupApiRoutes(app, getConfig) {
+  app.use(express.json({ limit: "10mb" }));
+  app.use(express.urlencoded({ extended: true, limit: "10mb" }));
+  const apiHandler = createApiRouteHandler();
+  app.use(async (req, res, next) => {
+    const config2 = getConfig();
+    if (!config2) {
+      return next();
+    }
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    const method = req.method;
+    if (config2.apiRouteMap && config2.apiRouteMap.size > 0) {
+      try {
+        const handled = await apiHandler(pathname, method, req, res, config2);
+        if (handled) {
+          return;
+        }
+      } catch (error) {
+        if (!res.headersSent) {
+          return next();
+        }
+        return;
+      }
+    }
+    next();
+  });
+}
+function setupSSREndpoint(app, handler) {
+  app.get("*", async (req, res) => {
+    try {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const result = await handler(
+        url.pathname,
+        Object.fromEntries(url.searchParams)
+      );
+      res.status(result.status);
+      res.setHeader("Content-Type", HTTP_HEADERS.CONTENT_TYPE_HTML);
+      const nodeStream = Readable.fromWeb(result.html);
+      nodeStream.pipe(res);
+      nodeStream.on("error", (err) => {
+        if (!res.headersSent) {
+          console.error(ERROR_MESSAGES.ERROR_HANDLING_REQUEST, err);
+          res.status(HTTP_STATUS.INTERNAL_ERROR).send("Internal Server Error");
+        }
+      });
+    } catch (error) {
+      console.error(ERROR_MESSAGES.ERROR_HANDLING_REQUEST, error);
+      res.status(HTTP_STATUS.INTERNAL_ERROR).send("Internal Server Error");
+    }
+  });
+}
+
+// src/server/base-server.ts
+var BaseServer = class {
+  constructor(port = SERVER.DEFAULT_PORT) {
+    this.app = express2();
+    this.port = port;
+  }
+  /**
+   * Template method - defines the algorithm structure
+   */
+  async setup() {
+    this.setupMiddleware();
+    this.setupStaticFiles();
+    this.setupImageEndpoint();
+    this.setupAsyncEndpoint();
+    this.setupApiRoutes();
+    this.setupRSCEndpoint();
+    this.setupSSREndpoint();
+  }
+  /**
+   * Setup Express middleware
+   */
+  setupMiddleware() {
+    setupExpressMiddleware(this.app);
+  }
+  /**
+   * Setup static file serving
+   */
+  setupStaticFiles() {
+    setupStaticFiles(this.app, getClientDir(), getPublicDir());
+  }
+  /**
+   * Setup image optimization endpoint
+   */
+  setupImageEndpoint() {
+    setupImageEndpoint(this.app);
+  }
+  /**
+   * Setup async component endpoint
+   */
+  setupAsyncEndpoint() {
+    setupAsyncEndpoint(this.app);
+  }
+  /**
+   * Setup API routes
+   */
+  setupApiRoutes() {
+    setupApiRoutes(this.app, () => {
+      try {
+        return getRouteConfig();
+      } catch {
+        return null;
+      }
+    });
+  }
+  /**
+   * Setup RSC endpoint
+   */
+  setupRSCEndpoint() {
+    setupRSCEndpoint(this.app, this.createRSCHandler());
+  }
+  /**
+   * Setup SSR endpoint
+   */
+  setupSSREndpoint() {
+    setupSSREndpoint(this.app, this.createSSRHandler());
+  }
+  /**
+   * Start the server
+   */
+  async start() {
+    await this.setup();
+    this.app.listen(this.port, () => {
+      console.log(
+        `[loly-core] Server running at http://localhost:${this.port}`
+      );
+    });
+  }
+  /**
+   * Get the Express app instance
+   */
+  getApp() {
+    return this.app;
+  }
+};
+
+// src/server/dev-server.ts
+var routeConfig = null;
+var routeConfigPromise = null;
+async function reloadRoutes(appDir) {
+  const config2 = await scanRoutes(appDir);
+  routeConfig = config2;
+  return config2;
+}
+async function getRouteConfig2(appDir) {
+  if (routeConfig) {
+    return routeConfig;
+  }
+  if (routeConfigPromise) {
+    return routeConfigPromise;
+  }
+  routeConfigPromise = reloadRoutes(appDir);
+  return routeConfigPromise;
+}
+var DevServer = class extends BaseServer {
+  constructor(options) {
+    super(options.port);
+    this.watcher = null;
+    this.projectDir = options.projectDir;
+  }
+  /**
+   * Initialize server context and load routes
+   */
+  async initialize() {
+    const appDir = getAppDirPath(this.projectDir);
+    const srcDir = join3(this.projectDir, DIRECTORIES.SRC);
+    const outDir = join3(this.projectDir, DIRECTORIES.LOLY, DIRECTORIES.DIST);
+    if (!existsSync5(appDir)) {
+      throw new Error(ERROR_MESSAGES.APP_DIR_NOT_FOUND(this.projectDir));
+    }
+    setContext({
+      projectDir: this.projectDir,
+      appDir,
+      srcDir,
+      outDir,
+      buildMode: "development",
+      isDev: true,
+      serverPort: this.port
+    });
+    const initialConfig = await reloadRoutes(getAppDir());
+    setRouteConfig(initialConfig);
+  }
+  /**
+   * Create RSC handler
+   */
+  createRSCHandler() {
+    return async (pathname, searchParams) => {
+      const config2 = await getRouteConfig2(getAppDir());
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      const result = await renderPageContent(context, config2, getAppDir());
+      return {
+        ...result,
+        params: context.params
+      };
+    };
+  }
+  /**
+   * Create SSR handler
+   */
+  createSSRHandler() {
+    return async (pathname, searchParams) => {
+      const config2 = await getRouteConfig2(getAppDir());
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      return await renderPageStream(context, config2, getAppDir());
+    };
+  }
+  /**
+   * Load route configuration
+   */
+  async loadRouteConfig() {
+    return await getRouteConfig2(getAppDir());
+  }
+  /**
+   * Setup hot reload watcher
+   */
+  setupHotReload() {
+    this.watcher = chokidar.watch(getAppDir(), {
+      ignored: /node_modules/,
+      persistent: true
+    });
+    const reloadHandler = async () => {
+      routeConfig = null;
+      routeConfigPromise = null;
+      await reloadRoutes(getAppDir());
+    };
+    this.watcher.on("change", reloadHandler);
+    this.watcher.on("add", reloadHandler);
+    this.watcher.on("unlink", reloadHandler);
+  }
+  /**
+   * Start the development server with hot reload
+   */
+  async start() {
+    await this.initialize();
+    await this.setup();
+    this.setupHotReload();
+    this.getApp().listen(this.port, () => {
+      console.log(
+        `[loly-core] Dev server running at http://localhost:${this.port}`
+      );
+    });
+  }
+  /**
+   * Stop the server and cleanup
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+async function startDevServer(options) {
+  const server = new DevServer(options);
+  await server.start();
+}
+
+// src/server/prod-server.ts
+import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+function loadRouteConfigFromManifest() {
+  const manifestPath = getRoutesManifestPath();
+  if (!existsSync6(manifestPath)) {
+    throw new Error(ERROR_MESSAGES.ROUTES_MANIFEST_NOT_FOUND(manifestPath));
+  }
+  const manifestContent = readFileSync2(manifestPath, "utf-8");
+  const manifest = JSON.parse(manifestContent);
+  const routes = manifest.routes.map((route) => ({
+    filePath: route.serverPath || route.sourcePath,
+    // Prefer compiled path
+    segments: route.segments,
+    type: route.type,
+    isRootLayout: route.isRootLayout,
+    urlPath: route.urlPath,
+    isApiRoute: route.isApiRoute || void 0,
+    httpMethods: route.httpMethods || void 0
+  }));
+  const rootLayout = manifest.rootLayout ? {
+    filePath: manifest.rootLayout.serverPath || manifest.rootLayout.sourcePath,
+    segments: manifest.rootLayout.segments,
+    type: manifest.rootLayout.type,
+    isRootLayout: manifest.rootLayout.isRootLayout,
+    urlPath: manifest.rootLayout.urlPath
+  } : void 0;
+  const routeMap = /* @__PURE__ */ new Map();
+  const apiRouteMap = /* @__PURE__ */ new Map();
+  for (const routeEntry of manifest.routeMap || []) {
+    const route = {
+      filePath: routeEntry.serverPath || routeEntry.sourcePath,
+      segments: routeEntry.segments,
+      type: routeEntry.type,
+      isRootLayout: routeEntry.isRootLayout,
+      urlPath: routeEntry.urlPath,
+      isApiRoute: routeEntry.isApiRoute || void 0,
+      httpMethods: routeEntry.httpMethods || void 0
+    };
+    if (routeEntry.type === "page") {
+      routeMap.set(routeEntry.path, route);
+    } else if (routeEntry.isApiRoute && routeEntry.urlPath) {
+      apiRouteMap.set(routeEntry.urlPath, route);
+    }
+  }
+  const routeMapManifest = /* @__PURE__ */ new Map();
+  for (const routeEntry of manifest.routeMap || []) {
+    routeMapManifest.set(routeEntry.path, routeEntry);
+  }
+  return {
+    routes,
+    rootLayout,
+    routeMap,
+    apiRouteMap,
+    routeMapManifest,
+    // Include manifest data for accessing compiled paths and chunks
+    rootLayoutManifest: manifest.rootLayout,
+    // Include root layout manifest
+    routesManifest: manifest.routes
+    // Include all routes from manifest for layout lookup
+  };
+}
+var ProdServer = class extends BaseServer {
+  constructor(options) {
+    super(options.port);
+    this.config = null;
+    this.projectDir = options.projectDir;
+  }
+  /**
+   * Initialize server context and load routes from manifest
+   */
+  async initialize() {
+    const appDir = getAppDirPath(this.projectDir);
+    const srcDir = join4(this.projectDir, DIRECTORIES.SRC);
+    const outDir = join4(this.projectDir, DIRECTORIES.LOLY, DIRECTORIES.DIST);
+    if (!existsSync6(appDir)) {
+      throw new Error(ERROR_MESSAGES.APP_DIR_NOT_FOUND(this.projectDir));
+    }
+    setContext({
+      projectDir: this.projectDir,
+      appDir,
+      srcDir,
+      outDir,
+      buildMode: "production",
+      isDev: false,
+      serverPort: this.port
+    });
+    this.config = loadRouteConfigFromManifest();
+    setRouteConfig(this.config);
+  }
+  /**
+   * Create RSC handler
+   */
+  createRSCHandler() {
+    return async (pathname, searchParams) => {
+      if (!this.config) {
+        this.config = await this.loadRouteConfig();
+      }
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      const result = await renderPageContent(context, this.config, getAppDir());
+      return {
+        ...result,
+        params: context.params
+      };
+    };
+  }
+  /**
+   * Create SSR handler
+   */
+  createSSRHandler() {
+    return async (pathname, searchParams) => {
+      if (!this.config) {
+        this.config = await this.loadRouteConfig();
+      }
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      return await renderPageStream(context, this.config, getAppDir());
+    };
+  }
+  /**
+   * Load route configuration from manifest
+   */
+  async loadRouteConfig() {
+    return loadRouteConfigFromManifest();
+  }
+  /**
+   * Start the production server
+   */
+  async start() {
+    await this.initialize();
+    await this.setup();
+    this.getApp().listen(this.port, () => {
+      console.log(
+        `[loly-core] Production server running at http://localhost:${this.port}`
+      );
+    });
+  }
+};
+async function startProdServer(options) {
+  const server = new ProdServer(options);
+  await server.start();
+}
+
+// src/build/index.ts
+import rspackBuild from "@rspack/core";
+import { join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+
+// src/build/manifest.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { join as join5, dirname as dirname2, relative as relative2 } from "path";
+function getServerCompiledPath(sourcePath, appDir) {
+  const relativePath = relative2(appDir, sourcePath);
+  const relativeWithoutExt = relativePath.replace(/\.(tsx?|jsx?)$/, ".js");
+  const serverDistDir = getServerOutDir();
+  return join5(serverDistDir, relativeWithoutExt).replace(/\\/g, "/");
+}
+function getClientChunksForRoute(routeIndex, clientManifestPath) {
+  if (!existsSync7(clientManifestPath)) {
+    return null;
+  }
+  try {
+    const manifestContent = readFileSync3(clientManifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    const chunkName = `route-${routeIndex}`;
+    const chunk = manifest[chunkName];
+    if (!chunk) {
+      return null;
+    }
+    const js = [];
+    const css = [];
+    if (chunk.file) {
+      js.push(chunk.file);
+    }
+    if (chunk.css && chunk.css.length > 0) {
+      css.push(...chunk.css);
+    }
+    if (chunk.imports && chunk.imports.length > 0) {
+      for (const importName of chunk.imports) {
+        const importChunk = manifest[importName];
+        if (importChunk?.file) {
+          js.push(importChunk.file);
+        }
+        if (importChunk?.css && importChunk.css.length > 0) {
+          css.push(...importChunk.css);
+        }
+      }
+    }
+    return { js, css };
+  } catch (error) {
+    return null;
+  }
+}
+function generateRoutesManifest(config2, projectDir, appDir) {
+  const manifestDir = join5(getProjectDir(), DIRECTORIES.LOLY);
+  if (!existsSync7(manifestDir)) {
+    mkdirSync(manifestDir, { recursive: true });
+  }
+  const clientManifestPath = getManifestPath();
+  const hasClientManifest = existsSync7(clientManifestPath);
+  const pageRoutes = config2.routes.filter((r) => r.type === "page");
+  let routeIndex = 0;
+  const routesData = config2.routes.map((route) => {
+    const sourcePath = route.filePath;
+    const serverPath = getServerCompiledPath(sourcePath, appDir);
+    let clientChunks = null;
+    if (route.type === "page" && hasClientManifest) {
+      clientChunks = getClientChunksForRoute(routeIndex, clientManifestPath);
+      routeIndex++;
+    }
+    return {
+      sourcePath,
+      // Original TSX path (for development)
+      serverPath,
+      // Compiled server path (for production)
+      segments: route.segments,
+      type: route.type,
+      isRootLayout: route.isRootLayout,
+      urlPath: route.urlPath,
+      isApiRoute: route.isApiRoute || void 0,
+      httpMethods: route.httpMethods || void 0,
+      clientChunks: clientChunks || void 0
+      // Client chunks for this route
+    };
+  });
+  const rootLayoutData = config2.rootLayout ? {
+    sourcePath: config2.rootLayout.filePath,
+    serverPath: getServerCompiledPath(
+      config2.rootLayout.filePath,
+      appDir
+    ),
+    segments: config2.rootLayout.segments,
+    type: config2.rootLayout.type,
+    isRootLayout: config2.rootLayout.isRootLayout,
+    urlPath: config2.rootLayout.urlPath
+  } : void 0;
+  routeIndex = 0;
+  const routeMapData = Array.from(config2.routeMap.entries()).map(
+    ([path4, route]) => {
+      const sourcePath = route.filePath;
+      const serverPath = getServerCompiledPath(sourcePath, appDir);
+      let clientChunks = null;
+      if (hasClientManifest) {
+        clientChunks = getClientChunksForRoute(routeIndex, clientManifestPath);
+        routeIndex++;
+      }
+      return {
+        path: path4,
+        sourcePath,
+        serverPath,
+        segments: route.segments,
+        type: route.type,
+        isRootLayout: route.isRootLayout,
+        urlPath: route.urlPath,
+        isApiRoute: route.isApiRoute || void 0,
+        httpMethods: route.httpMethods || void 0,
+        clientChunks: clientChunks || void 0
+      };
+    }
+  );
+  if (config2.apiRouteMap) {
+    for (const [path4, route] of config2.apiRouteMap.entries()) {
+      const sourcePath = route.filePath;
+      const serverPath = getServerCompiledPath(sourcePath, appDir);
+      routeMapData.push({
+        path: path4,
+        sourcePath,
+        serverPath,
+        segments: route.segments,
+        type: route.type,
+        isRootLayout: route.isRootLayout,
+        urlPath: route.urlPath,
+        isApiRoute: route.isApiRoute || void 0,
+        httpMethods: route.httpMethods || void 0,
+        clientChunks: void 0
+        // API routes don't have client chunks
+      });
+    }
+  }
+  const manifest = {
+    routes: routesData,
+    rootLayout: rootLayoutData,
+    routeMap: routeMapData
+  };
+  const manifestPath = getRoutesManifestPath();
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function generateBootstrap(projectDir, routes) {
+  const bootstrapDir = join5(getProjectDir(), DIRECTORIES.LOLY);
+  if (!existsSync7(bootstrapDir)) {
+    mkdirSync(bootstrapDir, { recursive: true });
+  }
+  const routeImports = routes.map((route, index) => {
+    const routePath = route.filePath.replace(/\\/g, "/");
+    const projectPath = getProjectDir().replace(/\\/g, "/");
+    let relativePath = routePath.replace(projectPath, "").replace(/^\//, "");
+    relativePath = `../${relativePath}`;
+    return `  {
+    path: "${route.urlPath}",
+    component: async () => {
+      const mod = await import(/* webpackChunkName: "route-${index}" */ "${relativePath}");
+      return mod.default || mod;
+    },
+  }`;
+  }).join(",\n");
+  const bootstrapContent = `import { bootstrapClient } from "loly/client";
+
+const routes = [
+${routeImports}
+];
+
+const notFoundRoute = null;
+const errorRoute = null;
+
+try {
+  bootstrapClient({
+    routes,
+    notFoundRoute,
+    errorRoute,
+  });
+} catch (error) {
+  console.error("[bootstrap] Fatal error during bootstrap:", error);
+  throw error;
+}
+`;
+  const bootstrapPath = getBootstrapPath();
+  writeFileSync(bootstrapPath, bootstrapContent);
+}
+
+// src/build/client.ts
+import { join as join6, normalize as normalize2, relative as relative3 } from "path";
+
+// src/build/server-only.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { glob as glob2 } from "glob";
+import { normalize } from "path";
+function hasUseServerDirective(filePath) {
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const trimmed = content.trim();
+    return trimmed.startsWith('"use server"') || trimmed.startsWith("'use server'") || trimmed.startsWith('"use server";') || trimmed.startsWith("'use server';");
+  } catch {
+    return false;
+  }
+}
+async function scanServerOnlyFiles(srcDir) {
+  const serverOnlyFiles = /* @__PURE__ */ new Set();
+  if (!srcDir) {
+    return serverOnlyFiles;
+  }
+  try {
+    const patterns = ["**/*.{ts,tsx,js,jsx}"];
+    const files = await glob2(patterns, {
+      cwd: srcDir,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/.loly/**", "**/dist/**", "**/.next/**"]
+    });
+    for (const file of files) {
+      if (hasUseServerDirective(file)) {
+        const normalizedPath = normalize(file);
+        serverOnlyFiles.add(normalizedPath);
+      }
+    }
+  } catch (error) {
+    console.warn("[loly-core] Failed to scan for server-only files:", error);
+  }
+  return serverOnlyFiles;
+}
+
+// src/build/client.ts
+function generateServerOnlyStubCode() {
+  return `
+const SERVER_ONLY_ERROR = "This module is marked with 'use server' and can only be imported in server components.";
+
+function createErrorFunction(propName) {
+  const errorFn = function (...args) {
+    throw new Error(SERVER_ONLY_ERROR + " Attempted to call: " + propName);
+  };
+  errorFn.toString = () => "[ServerOnlyStub:" + propName + "]";
+  errorFn[Symbol.toStringTag] = "Function";
+  errorFn.then = () => Promise.reject(new Error(SERVER_ONLY_ERROR + " Attempted to await: " + propName));
+  errorFn.catch = () => Promise.reject(new Error(SERVER_ONLY_ERROR + " Attempted to catch: " + propName));
+  return errorFn;
+}
+
+function createServerOnlyProxy() {
+  return new Proxy({}, {
+    get(_target, prop) {
+      return createErrorFunction(String(prop));
+    },
+    set() {
+      throw new Error(SERVER_ONLY_ERROR);
+    },
+    has() {
+      return true;
+    },
+    ownKeys() {
+      return [];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => createErrorFunction(String(prop)),
+      };
+    },
+  });
+}
+
+const serverOnlyStub = createServerOnlyProxy();
+export default serverOnlyStub;
+`;
+}
+function matchServerOnlyFile(request, serverOnlyFiles, srcDir) {
+  const normalizedSrcDir = normalize2(srcDir).replace(/\\/g, "/");
+  const normalizedRequest = request.replace(/\\/g, "/");
+  for (const serverOnlyPath of serverOnlyFiles) {
+    const normalizedPath = normalize2(serverOnlyPath).replace(/\\/g, "/");
+    if (normalizedRequest === normalizedPath) {
+      return serverOnlyPath;
+    }
+    const relativeFromSrc = normalizedPath.replace(normalizedSrcDir + "/", "").replace(/^\/+/, "");
+    const relativeWithoutExt = relativeFromSrc.replace(/\.(ts|tsx|js|jsx)$/, "");
+    if (normalizedRequest === relativeFromSrc || normalizedRequest === relativeWithoutExt) {
+      return serverOnlyPath;
+    }
+    if (normalizedRequest.endsWith("/" + relativeFromSrc) || normalizedRequest.endsWith("/" + relativeWithoutExt)) {
+      return serverOnlyPath;
+    }
+    try {
+      const relativePath = relative3(srcDir, serverOnlyPath).replace(/\\/g, "/");
+      const relativePathWithoutExt = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+      if (normalizedRequest === relativePath || normalizedRequest === relativePathWithoutExt) {
+        return serverOnlyPath;
+      }
+      if (normalizedRequest.endsWith("/" + relativePath) || normalizedRequest.endsWith("/" + relativePathWithoutExt)) {
+        return serverOnlyPath;
+      }
+      const requestParts = normalizedRequest.split("/").filter((p) => p && p !== ".");
+      const relativeParts = relativePathWithoutExt.split("/").filter((p) => p && p !== ".");
+      if (relativeParts.length > 0 && requestParts.length >= relativeParts.length) {
+        const requestEnd = requestParts.slice(-relativeParts.length).join("/");
+        const relativeEnd = relativeParts.join("/");
+        if (requestEnd === relativeEnd) {
+          return serverOnlyPath;
+        }
+      }
+    } catch {
+    }
+    const filename = normalizedPath.split("/").pop();
+    if (filename) {
+      const filenameWithoutExt = filename.replace(/\.(ts|tsx|js|jsx)$/, "");
+      if (normalizedRequest === filename || normalizedRequest === filenameWithoutExt) {
+        return serverOnlyPath;
+      }
+      if (normalizedRequest.endsWith("/" + filename) || normalizedRequest.endsWith("/" + filenameWithoutExt)) {
+        return serverOnlyPath;
+      }
+    }
+    try {
+      if (!normalizedRequest.startsWith("/") && !normalizedRequest.startsWith(".")) {
+        if (normalizedRequest === relativeWithoutExt || normalizedRequest === relativeFromSrc) {
+          return serverOnlyPath;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function createClientConfig(options) {
+  const { mode = "production" } = options;
+  const bootstrapEntry = getBootstrapPath();
+  const srcDir = getSrcDir();
+  const serverOnlyFiles = await scanServerOnlyFiles(srcDir);
+  const stubCode = generateServerOnlyStubCode();
+  const entries = {
+    main: bootstrapEntry
+  };
+  return {
+    mode,
+    entry: entries,
+    output: {
+      path: getClientDir(),
+      filename: "[name].[contenthash].js",
+      chunkFilename: "[name].[contenthash].js",
+      clean: true,
+      publicPath: "/"
+    },
+    resolve: {
+      extensions: [".ts", ".tsx", ".js", ".jsx"],
+      alias: {
+        "loly": join6(
+          getProjectDir(),
+          "node_modules",
+          "loly",
+          "dist",
+          "client.js"
+        )
+      }
+    },
+    externals: [
+      "express",
+      "chokidar",
+      "glob",
+      "@rspack/core",
+      "@rspack/cli",
+      "tsx",
+      ({ request, contextInfo }) => {
+        if (!request) return false;
+        if (request.startsWith("node:")) return request;
+        if (NODE_BUILTINS.includes(request)) return `node:${request}`;
+        return false;
+      }
+    ],
+    externalsType: "module",
+    module: {
+      rules: [
+        {
+          test: /\.tsx?$/,
+          use: [
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "typescript",
+                    tsx: true,
+                    decorators: false,
+                    dynamicImport: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic",
+                      importSource: "loly-jsx",
+                      throwIfNamespace: false
+                    }
+                  },
+                  target: "es2020"
+                },
+                module: {
+                  type: "es6"
+                }
+              }
+            }
+          ]
+        },
+        {
+          test: /\.css$/,
+          type: "css"
+        }
+      ]
+    },
+    optimization: {
+      minimize: mode === "production",
+      splitChunks: {
+        chunks: "all"
+      },
+      usedExports: true,
+      sideEffects: false,
+      // More aggressive tree shaking - assume no side effects
+      providedExports: true,
+      concatenateModules: true,
+      // Better for tree shaking
+      removeEmptyChunks: true,
+      mergeDuplicateChunks: true
+    },
+    plugins: [
+      {
+        name: "server-only-plugin",
+        apply(compiler) {
+          compiler.hooks.normalModuleFactory.tap("server-only-plugin", (factory) => {
+            factory.hooks.beforeResolve.tap("server-only-plugin", (data) => {
+              if (!data.request) return;
+              const request = data.request;
+              if (request.startsWith("data:")) {
+                return;
+              }
+              const matchedFile = matchServerOnlyFile(request, serverOnlyFiles, srcDir);
+              if (matchedFile) {
+                const encodedStub = Buffer.from(stubCode.trim()).toString("base64");
+                data.request = `data:text/javascript;base64,${encodedStub}`;
+              }
+            });
+          });
+        }
+      },
+      {
+        name: "manifest-plugin",
+        apply(compiler) {
+          compiler.hooks.emit.tap("manifest-plugin", (compilation) => {
+            const manifest = {};
+            const entrypoints = compilation.entrypoints || /* @__PURE__ */ new Map();
+            const entryChunkNames = /* @__PURE__ */ new Set();
+            for (const [name, entrypoint] of entrypoints) {
+              entryChunkNames.add(name);
+              const chunks2 = entrypoint.chunks || [];
+              for (const chunk of chunks2) {
+                const chunkName = chunk.name || chunk.id || "unknown";
+                entryChunkNames.add(chunkName);
+              }
+            }
+            const chunks = compilation.chunks || [];
+            for (const chunk of chunks) {
+              const name = chunk.name || chunk.id || "unknown";
+              const files = [];
+              const cssFiles = [];
+              const chunkFiles = chunk.files || [];
+              for (const file of chunkFiles) {
+                if (file.endsWith(".css")) {
+                  cssFiles.push(file);
+                } else {
+                  files.push(file);
+                }
+              }
+              const isEntry = entryChunkNames.has(name) || chunk.hasEntryModule && chunk.hasEntryModule() || name === "main";
+              manifest[name] = {
+                file: files[0] || "",
+                isEntry,
+                imports: [],
+                css: cssFiles.length > 0 ? cssFiles : void 0
+              };
+            }
+            const manifestJson = JSON.stringify(manifest, null, 2);
+            compilation.emitAsset("manifest.json", {
+              source: () => manifestJson,
+              size: () => Buffer.byteLength(manifestJson, "utf8")
+            });
+          });
+        }
+      }
+    ],
+    devtool: mode === "production" ? false : "source-map"
+  };
+}
+
+// src/build/server.ts
+import { join as join7 } from "path";
+import { existsSync as existsSync8, readdirSync } from "fs";
+function collectAppSources(appDir) {
+  const entries = [];
+  function walk(dir) {
+    if (!existsSync8(dir)) return;
+    const items = readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const full = join7(dir, item.name);
+      if (item.isDirectory()) {
+        if (item.name === "node_modules" || item.name.startsWith(".")) {
+          continue;
+        }
+        walk(full);
+        continue;
+      }
+      if (item.isFile()) {
+        const isRouteFile = ROUTE_FILE_NAMES.some(
+          (routeFile) => item.name === routeFile
+        );
+        if (isRouteFile && (full.endsWith(".ts") || full.endsWith(".tsx"))) {
+          if (full.endsWith(".d.ts")) continue;
+          entries.push(full);
+        }
+      }
+    }
+  }
+  walk(appDir);
+  return entries;
+}
+async function buildServerFiles(options) {
+  const { mode = "production" } = options;
+  const appDir = getAppDir();
+  const serverOutDir = getServerOutDir();
+  if (existsSync8(serverOutDir)) {
+    const { rmSync } = await import("fs");
+    rmSync(serverOutDir, { recursive: true, force: true });
+  }
+  const entryPoints = collectAppSources(appDir);
+  if (entryPoints.length === 0) {
+    return;
+  }
+  try {
+    const { build } = await import("esbuild");
+    await build({
+      entryPoints,
+      outdir: serverOutDir,
+      outbase: appDir,
+      // Preserve directory structure
+      format: "esm",
+      platform: "node",
+      target: "es2020",
+      bundle: true,
+      // Bundle to resolve relative imports
+      packages: "external",
+      // Externalize node_modules packages
+      external: [
+        // Explicitly externalize loly-jsx to avoid bundling it
+        "loly-jsx",
+        "loly-jsx/*",
+        "loly-jsx/jsx-runtime",
+        "loly-jsx/render/*",
+        "loly-jsx/router"
+      ],
+      sourcemap: true,
+      jsx: "automatic",
+      jsxImportSource: "loly-jsx",
+      logLevel: mode === "production" ? "warning" : "info"
+    });
+  } catch (error) {
+    console.error(`[loly-core] Failed to build server files:`, error);
+    throw error;
+  }
+}
+
+// src/build/css-processor.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, copyFileSync } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+async function processCssWithPostCSS(options) {
+  const { inputPath, outputPath, projectDir } = options;
+  let postcss;
+  try {
+    const postcssModule = await import("postcss");
+    postcss = postcssModule.default || postcssModule;
+  } catch {
+    mkdirSync2(dirname3(outputPath), { recursive: true });
+    copyFileSync(inputPath, outputPath);
+    return;
+  }
+  const configPaths = [
+    join8(projectDir, "postcss.config.js"),
+    join8(projectDir, "postcss.config.mjs"),
+    join8(projectDir, "postcss.config.cjs")
+  ];
+  const configPath = configPaths.find((p) => existsSync9(p));
+  if (!configPath) {
+    mkdirSync2(dirname3(outputPath), { recursive: true });
+    copyFileSync(inputPath, outputPath);
+    return;
+  }
+  const configUrl = pathToFileURL(configPath).href;
+  const configModule = await import(configUrl);
+  const config2 = configModule.default || configModule;
+  const css = readFileSync5(inputPath, "utf-8");
+  let plugins = config2.plugins || [];
+  const projectRequire = createRequire(join8(projectDir, "package.json"));
+  if (plugins && typeof plugins === "object" && !Array.isArray(plugins)) {
+    const pluginArray = [];
+    for (const [name, options2] of Object.entries(plugins)) {
+      try {
+        const pluginPath = projectRequire.resolve(name);
+        const pluginUrl = pathToFileURL(pluginPath).href;
+        const pluginModule = await import(pluginUrl);
+        const plugin = pluginModule.default || pluginModule;
+        const pluginOptions = options2 && typeof options2 === "object" && Object.keys(options2).length > 0 ? options2 : void 0;
+        pluginArray.push(pluginOptions ? plugin(pluginOptions) : plugin());
+      } catch (err) {
+        console.warn(`[loly-core] Failed to load PostCSS plugin "${name}":`, err);
+        throw err;
+      }
+    }
+    plugins = pluginArray;
+  }
+  const result = await postcss(plugins).process(css, {
+    from: inputPath,
+    to: outputPath
+  });
+  mkdirSync2(dirname3(outputPath), { recursive: true });
+  writeFileSync2(outputPath, result.css);
+  if (result.map) {
+    writeFileSync2(outputPath + ".map", result.map.toString());
+  }
+}
+
+// src/build/index.ts
+async function buildProject(options) {
+  const {
+    projectDir,
+    outDir = join9(projectDir, DIRECTORIES.LOLY, DIRECTORIES.DIST)
+  } = options;
+  const appDir = getAppDirPath(projectDir);
+  const srcDir = join9(projectDir, DIRECTORIES.SRC);
+  if (!existsSync10(appDir)) {
+    throw new Error(ERROR_MESSAGES.APP_DIR_NOT_FOUND(projectDir));
+  }
+  setContext({
+    projectDir,
+    appDir,
+    srcDir,
+    outDir,
+    buildMode: options.mode || "production",
+    isDev: options.mode === "development"
+  });
+  const routeConfig2 = await scanRoutes(getAppDir());
+  setRouteConfig(routeConfig2);
+  const pageRoutes = routeConfig2.routes.filter((r) => r.type === "page");
+  generateBootstrap(getProjectDir(), pageRoutes);
+  const clientConfig = await createClientConfig(options);
+  try {
+    await new Promise((resolve6, reject) => {
+      const compiler = rspackBuild(clientConfig);
+      compiler.run((err, stats) => {
+        if (err) {
+          console.error("[loly-core] Client build error:", err);
+          reject(err);
+          return;
+        }
+        if (stats && stats.hasErrors()) {
+          console.error("[loly-core] Client build has errors");
+          console.error(stats.compilation.errors);
+          reject(new Error(ERROR_MESSAGES.CLIENT_BUILD_FAILED));
+          return;
+        }
+        resolve6();
+      });
+    });
+  } catch (error) {
+    console.error(ERROR_MESSAGES.CLIENT_BUILD_FAILED, error);
+    throw error;
+  }
+  const globalsCssPath = existsSync10(join9(getSrcDir(), FILE_NAMES.GLOBALS_CSS)) ? join9(getSrcDir(), FILE_NAMES.GLOBALS_CSS) : existsSync10(join9(getAppDir(), FILE_NAMES.GLOBALS_CSS)) ? join9(getAppDir(), FILE_NAMES.GLOBALS_CSS) : null;
+  const clientOutDir = getClientDir();
+  if (globalsCssPath && existsSync10(globalsCssPath)) {
+    const destCssPath = join9(clientOutDir, FILE_NAMES.GLOBALS_CSS);
+    await processCssWithPostCSS({
+      inputPath: globalsCssPath,
+      outputPath: destCssPath,
+      projectDir: getProjectDir()
+    });
+  }
+  try {
+    await buildServerFiles(options);
+  } catch (error) {
+    console.error(ERROR_MESSAGES.SERVER_BUILD_FAILED, error);
+    throw error;
+  }
+  generateRoutesManifest(routeConfig2, getProjectDir(), getAppDir());
+}
+
+// src/cli/index.ts
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync11 } from "fs";
+function loadEnvFile(projectDir) {
+  const envPath = resolve5(projectDir, ".env");
+  if (existsSync11(envPath)) {
+    config({ path: envPath });
+  }
+  const envLocalPath = resolve5(projectDir, ".env.local");
+  if (existsSync11(envLocalPath)) {
+    config({ path: envLocalPath, override: true });
+  }
+}
+var commands = {
+  dev: async (args) => {
+    const projectDir = args[0] ? resolve5(args[0]) : process.cwd();
+    if (!existsSync11(projectDir)) {
+      console.error(`[loly-core] Directory not found: ${projectDir}`);
+      process.exit(1);
+    }
+    loadEnvFile(projectDir);
+    const port = args[1] ? parseInt(args[1], 10) : void 0;
+    try {
+      await startDevServer({
+        projectDir,
+        port
+      });
+    } catch (error) {
+      console.error("[loly-core] Error starting dev server:", error);
+      process.exit(1);
+    }
+  },
+  build: async (args) => {
+    const projectDir = args[0] ? resolve5(args[0]) : process.cwd();
+    if (!existsSync11(projectDir)) {
+      console.error(`[loly-core] Directory not found: ${projectDir}`);
+      process.exit(1);
+    }
+    loadEnvFile(projectDir);
+    const mode = args.includes("--dev") ? "development" : "production";
+    const outDir = args.find((arg) => arg.startsWith("--out-dir="))?.split("=")[1];
+    try {
+      await buildProject({
+        projectDir,
+        outDir: outDir ? resolve5(outDir) : void 0,
+        mode
+      });
+    } catch (error) {
+      console.error("[loly-core] Error building project:", error);
+      process.exit(1);
+    }
+  },
+  start: async (args) => {
+    const projectDir = args[0] ? resolve5(args[0]) : process.cwd();
+    if (!existsSync11(projectDir)) {
+      console.error(`[loly-core] Directory not found: ${projectDir}`);
+      process.exit(1);
+    }
+    loadEnvFile(projectDir);
+    const port = args[1] ? parseInt(args[1], 10) : void 0;
+    try {
+      await startProdServer({
+        projectDir,
+        port
+      });
+    } catch (error) {
+      console.error("[loly-core] Error starting production server:", error);
+      process.exit(1);
+    }
+  }
+};
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || !(command in commands)) {
+    console.log(`
+Usage: loly <command> [options]
+
+Commands:
+  dev [dir] [port]     Start development server
+    --stream           Use streaming SSR
+
+  build [dir]          Build for production
+    --dev              Build in development mode
+    --out-dir=<path>   Output directory
+
+  start [dir] [port]   Start production server
+    --stream           Use streaming SSR
+
+Examples:
+  loly dev
+  loly dev . 3000
+  loly build
+  loly build . --out-dir=dist
+  loly start
+  loly start . 3000
+`);
+    process.exit(1);
+  }
+  const commandArgs = args.slice(1);
+  await commands[command](commandArgs);
+}
+main().catch((error) => {
+  console.error("[loly-core] Unexpected error:", error);
+  process.exit(1);
+});