loly 0.1.0

package/dist/index.js

@@ -0,0 +1,3826 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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/router/matcher.ts
+function matchRoute(pathname, config, loadComponent3) {
+  const normalized = normalizeUrlPath(pathname);
+  if (config.routeMap.has(normalized)) {
+    const route = config.routeMap.get(normalized);
+    return { route, params: {} };
+  }
+  for (const route of config.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;
+}
+function extractParams(pathname, route) {
+  const match = matchRoutePattern(pathname, route);
+  return match?.params || {};
+}
+
+// src/server/dev-server.ts
+import { join as join3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import chokidar from "chokidar";
+
+// 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, config, appDir, manifestRoute) {
+    const layouts = [];
+    const configWithManifest = config;
+    const routesManifest = configWithManifest.routesManifest;
+    if (config.rootLayout) {
+      const rootLayoutManifest = configWithManifest.rootLayoutManifest;
+      const layoutSourcePath = resolve2(config.rootLayout.filePath);
+      const layoutCompiledPath = rootLayoutManifest?.serverPath ? resolve2(rootLayoutManifest.serverPath) : void 0;
+      const rootLayout = await this.loadLayoutComponent(
+        config.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/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(config) {
+  const context = getContext();
+  context.routeConfig = config;
+}
+
+// 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>`;
+}
+function getEnv(key) {
+  if (typeof window !== "undefined" && window.__LOLY_ENV__) {
+    return window.__LOLY_ENV__[key];
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key] || process.env[`LOLY_PUBLIC_${key}`];
+  }
+  return void 0;
+}
+
+// src/server/rendering/strategies.ts
+var RSCStrategy = class {
+  constructor(routeFactory2) {
+    this.routeFactory = routeFactory2;
+  }
+  async render(context, config) {
+    const { pathname } = context;
+    const appDir = getAppDir();
+    const configWithManifest = config;
+    const manifestRouteMap = configWithManifest.routeMapManifest;
+    const manifestRoute = manifestRouteMap?.get(pathname);
+    const match = matchRoute(pathname, config, 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,
+      config,
+      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, config) {
+    const { pathname } = context;
+    const appDir = getAppDir();
+    const configWithManifest = config;
+    const manifestRouteMap = configWithManifest.routeMapManifest;
+    const manifestRoute = manifestRouteMap?.get(pathname);
+    const match = matchRoute(pathname, config, 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,
+        config,
+        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);
+    }
+  }
+};
+var RenderingStrategyFactory = class {
+  constructor(routeFactory2) {
+    this.routeFactory = routeFactory2;
+  }
+  /**
+   * Get SSR rendering strategy
+   * @returns SSR rendering strategy
+   */
+  getSSRStrategy() {
+    return new SSRStrategy(this.routeFactory);
+  }
+  /**
+   * Get RSC rendering strategy
+   * @returns RSC rendering strategy
+   */
+  getRSCStrategy() {
+    return new RSCStrategy(this.routeFactory);
+  }
+  /**
+   * Get rendering strategy based on type
+   * @param type - Strategy type: 'ssr' or 'rsc'
+   * @returns Appropriate rendering strategy (SSR only, RSC must be accessed via getRSCStrategy)
+   */
+  getStrategy(type) {
+    if (type === "ssr") {
+      return new SSRStrategy(this.routeFactory);
+    }
+    throw new Error(`Invalid strategy type: ${type}`);
+  }
+};
+
+// src/server/ssr.ts
+var routeFactory = new RouteComponentFactory();
+async function renderPageContent(context, config, appDir) {
+  const rscStrategy = new RSCStrategy(routeFactory);
+  return await rscStrategy.render(context, config);
+}
+async function renderPageStream(context, config, appDir) {
+  const ssrStrategy = new SSRStrategy(routeFactory);
+  return await ssrStrategy.render(context, config);
+}
+
+// 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, config) {
+  if (!config || !config.remotePatterns && !config.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 (config.remotePatterns && config.remotePatterns.length > 0) {
+      for (const pattern of config.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 (config.domains && config.domains.length > 0) {
+      for (const domain of config.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, config) {
+  const maxWidth = config?.maxWidth || 3840;
+  const maxHeight = config?.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(config) {
+  const cacheDir = getCacheDir();
+  const maxSizeMB = config?.maxSizeMB ?? 500;
+  const maxAgeDays = config?.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, config) {
+  if (sourceFormat === "svg") {
+    return "svg";
+  }
+  if (requestedFormat && requestedFormat !== "auto") {
+    return requestedFormat;
+  }
+  const supportedFormats = config.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, config) {
+  const imageConfig = config || 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 } = 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
+      },
+      config
+    );
+    const imageConfig = config || {};
+    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, config) {
+  const normalized = normalizeUrlPath(pathname);
+  if (config.apiRouteMap && config.apiRouteMap.has(normalized)) {
+    const route = config.apiRouteMap.get(normalized);
+    return { route, params: {} };
+  }
+  if (config.apiRouteMap) {
+    for (const route of config.apiRouteMap.values()) {
+      const match = matchRoutePattern2(normalized, route);
+      if (match) {
+        return { route, params: match.params };
+      }
+    }
+  }
+  for (const route of config.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, config) => {
+    try {
+      const match = matchApiRoute(pathname, config);
+      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, config) {
+  app.get(SERVER.IMAGE_ENDPOINT, async (req, res) => {
+    await handleImageRequest({ req, res, config });
+  });
+}
+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 config = getConfig();
+    if (!config) {
+      return next();
+    }
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    const method = req.method;
+    if (config.apiRouteMap && config.apiRouteMap.size > 0) {
+      try {
+        const handled = await apiHandler(pathname, method, req, res, config);
+        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 config = await scanRoutes(appDir);
+  routeConfig = config;
+  return config;
+}
+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 config = await getRouteConfig2(getAppDir());
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      const result = await renderPageContent(context, config, getAppDir());
+      return {
+        ...result,
+        params: context.params
+      };
+    };
+  }
+  /**
+   * Create SSR handler
+   */
+  createSSRHandler() {
+    return async (pathname, searchParams) => {
+      const config = await getRouteConfig2(getAppDir());
+      const context = {
+        pathname,
+        searchParams,
+        params: {}
+      };
+      return await renderPageStream(context, config, 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/client/router.ts
+import { bootIslands, mount, activateAsyncComponents } from "loly-jsx";
+
+// src/utils/route-matcher.ts
+function matchRoutePattern3(pattern, pathname) {
+  const normalizedPattern = normalizeUrlPath(pattern);
+  const normalizedPathname = normalizeUrlPath(pathname);
+  if (normalizedPattern === normalizedPathname) {
+    return { params: {} };
+  }
+  const patternParts = normalizedPattern.split("/").filter(Boolean);
+  const pathParts = normalizedPathname.split("/").filter(Boolean);
+  if (patternParts.length === 0 && pathParts.length === 0) {
+    return { params: {} };
+  }
+  const params = {};
+  let patternIdx = 0;
+  let pathIdx = 0;
+  while (patternIdx < patternParts.length && pathIdx < pathParts.length) {
+    const patternPart = patternParts[patternIdx];
+    const pathPart = pathParts[pathIdx];
+    if (patternPart.startsWith("*")) {
+      const paramName = patternPart.slice(1);
+      const remaining = pathParts.slice(pathIdx);
+      if (paramName) {
+        params[paramName] = remaining.join("/");
+      }
+      return { params };
+    }
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+      patternIdx++;
+      pathIdx++;
+      continue;
+    }
+    if (patternPart === pathPart) {
+      patternIdx++;
+      pathIdx++;
+      continue;
+    }
+    return null;
+  }
+  if (patternIdx === patternParts.length && pathIdx === pathParts.length) {
+    return { params };
+  }
+  return null;
+}
+function extractRouteParams(pattern, pathname) {
+  const match = matchRoutePattern3(pattern, pathname);
+  return match?.params || {};
+}
+function matchesRoute(pattern, pathname) {
+  if (pattern === pathname) return true;
+  const normalizedPattern = normalizeUrlPath(pattern);
+  const normalizedPathname = normalizeUrlPath(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const escaped = normalizedPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(
+    "^" + escaped.replace(/:[^/]+/g, "([^/]+)") + "/?$"
+  );
+  return regex.test(normalizedPathname);
+}
+
+// src/client/router.ts
+var LRUCache = class {
+  constructor(maxSize = 10) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  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(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 !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+function getInitialLocation() {
+  const { pathname, search, hash } = window.location;
+  return { pathname, search, hash };
+}
+function normalizePath2(path4) {
+  const url = new URL(path4, "http://localhost");
+  return {
+    pathname: normalizeUrlPath(url.pathname || "/"),
+    search: url.search,
+    hash: url.hash
+  };
+}
+async function fetchRSCPayload(pathname, search = "", options) {
+  const url = `${SERVER.RSC_ENDPOINT}?path=${encodeURIComponent(pathname)}${search ? `&search=${encodeURIComponent(search)}` : ""}`;
+  try {
+    const fetchOptions = {};
+    if (options?.priority) {
+      fetchOptions.priority = options.priority;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      if (response.status === 404) return null;
+      throw new Error(`Failed to fetch RSC: ${response.statusText}`);
+    }
+    const rscPayload = await response.json();
+    return {
+      html: rscPayload.html,
+      scripts: rscPayload.scripts || "",
+      styles: rscPayload.styles || "",
+      islandData: rscPayload.islandData || {}
+    };
+  } catch (error) {
+    return null;
+  }
+}
+async function loadComponent(route) {
+  try {
+    const module = await route.component();
+    const Component = module.default || module;
+    if (!Component) {
+      throw new Error(ERROR_MESSAGES.COMPONENT_NOT_FOUND(route.path));
+    }
+    return (props) => {
+      const safeProps = props && typeof props === "object" && !Array.isArray(props) ? props : { params: {}, searchParams: {} };
+      if (typeof Component === "function") {
+        return Component(safeProps);
+      }
+      return Component;
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+function bootIslandsNow() {
+  bootIslands();
+}
+var globalRouter = null;
+function setGlobalRouter(router) {
+  globalRouter = router;
+}
+var FrameworkRouter = class {
+  // Track links that have been pre-fetched
+  constructor(routes, appContainer) {
+    this.componentCache = /* @__PURE__ */ new Map();
+    this.loadedScripts = /* @__PURE__ */ new Set();
+    // Track loaded scripts
+    this.routeStyles = /* @__PURE__ */ new Map();
+    this.prefetchPromises = /* @__PURE__ */ new Map();
+    this.prefetchObserver = null;
+    this.MAX_CACHE_SIZE = 10;
+    this.invalidatedPaths = /* @__PURE__ */ new Set();
+    // Prepared for revalidatePath
+    this.prefetchedLinks = /* @__PURE__ */ new Set();
+    this.routes = routes;
+    this.appContainer = appContainer;
+    this.currentLocation = getInitialLocation();
+    this.rscPayloadCache = new LRUCache(this.MAX_CACHE_SIZE);
+    setGlobalRouter(this);
+    this.setupNavigation();
+    this.setupPopState();
+    this.setupPrefetch();
+  }
+  /**
+   * Check if pre-fetch should be performed based on connection
+   */
+  shouldPrefetch() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (!connection) {
+      return true;
+    }
+    if (connection.effectiveType === "slow-2g" || connection.effectiveType === "2g") {
+      return false;
+    }
+    if (connection.saveData === true) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Generate cache key from pathname and search
+   */
+  getCacheKey(pathname, search = "") {
+    return `${normalizeUrlPath(pathname)}${search || ""}`;
+  }
+  /**
+   * Check if href is an internal link
+   */
+  isInternalLink(href) {
+    if (!href) return false;
+    if (href.startsWith("http") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Pre-fetch route data (RSC payload and JS component)
+   */
+  async prefetchRoute(pathname, search = "") {
+    if (!this.shouldPrefetch()) {
+      return null;
+    }
+    const key = this.getCacheKey(pathname, search);
+    if (this.invalidatedPaths.has(key)) {
+      return null;
+    }
+    const cached = this.rscPayloadCache.get(key);
+    if (cached) {
+      this.prefetchedLinks.add(key);
+      return cached;
+    }
+    if (this.prefetchPromises.has(key)) {
+      return this.prefetchPromises.get(key);
+    }
+    const promise = fetchRSCPayload(pathname, search, { priority: "low" }).then((payload) => {
+      if (payload) {
+        this.rscPayloadCache.set(key, payload);
+        this.prefetchedLinks.add(key);
+        const route = this.findRoute(pathname);
+        if (route) {
+          this.loadComponentCached(route).catch(() => {
+          });
+        }
+      }
+      return payload;
+    }).catch((error) => {
+      if (typeof console !== "undefined" && console.debug) {
+        console.debug("[loly-core] Pre-fetch failed:", error);
+      }
+      return null;
+    }).finally(() => {
+      this.prefetchPromises.delete(key);
+    });
+    this.prefetchPromises.set(key, promise);
+    return promise;
+  }
+  /**
+   * Navigate to a new path
+   */
+  navigate(to, options = {}) {
+    const next = normalizePath2(to);
+    if (options.replace) {
+      window.history.replaceState({}, "", to);
+    } else {
+      window.history.pushState({}, "", to);
+    }
+    this.currentLocation = next;
+    this.updateContent();
+    if (!next.hash) {
+      window.scrollTo({ top: 0 });
+    } else {
+      const el = document.getElementById(next.hash.slice(1));
+      if (el) {
+        el.scrollIntoView();
+      }
+    }
+  }
+  /**
+   * Update app content based on current location
+   */
+  async updateContent() {
+    const { pathname, search } = this.currentLocation;
+    const key = this.getCacheKey(pathname, search);
+    let rscPayload = this.rscPayloadCache.get(key) || null;
+    if (!rscPayload) {
+      rscPayload = await fetchRSCPayload(pathname, search);
+      if (rscPayload) {
+        this.rscPayloadCache.set(key, rscPayload);
+      }
+    }
+    this.prefetchPromises.delete(key);
+    if (rscPayload) {
+      const hasIslands = rscPayload.html.includes("data-loly-island");
+      if (hasIslands) {
+        const route2 = this.findRoute(pathname);
+        if (route2) {
+          try {
+            await this.loadComponentCached(route2);
+          } catch (err) {
+            console.warn(
+              "[loly-core] Failed to load route component for island registration:",
+              err
+            );
+          }
+        }
+      }
+      if (rscPayload.islandData && Object.keys(rscPayload.islandData).length > 0) {
+        if (!window.__LOLY_ISLAND_DATA__) {
+          window.__LOLY_ISLAND_DATA__ = {};
+        }
+        Object.assign(
+          window.__LOLY_ISLAND_DATA__,
+          rscPayload.islandData
+        );
+      }
+      const fragment = document.createDocumentFragment();
+      const tempDiv = document.createElement("div");
+      tempDiv.innerHTML = rscPayload.html;
+      while (tempDiv.firstChild) {
+        fragment.appendChild(tempDiv.firstChild);
+      }
+      this.appContainer.innerHTML = "";
+      this.appContainer.appendChild(fragment);
+      if (rscPayload.styles) {
+        this.injectStyles(pathname, rscPayload.styles);
+      }
+      if (rscPayload.scripts) {
+        await this.injectScripts(rscPayload.scripts);
+      }
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          bootIslandsNow();
+          this.observeNewLinks(this.appContainer);
+        });
+      });
+      return;
+    }
+    const route = this.findRoute(pathname);
+    if (route) {
+      try {
+        const Component = await this.loadComponentCached(route);
+        const searchParams = Object.fromEntries(
+          new URLSearchParams(search || "")
+        );
+        const params = extractRouteParams(route.path, pathname);
+        const result = Component({ params, searchParams });
+        this.appContainer.innerHTML = "";
+        mount(result, this.appContainer);
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            bootIslandsNow();
+            activateAsyncComponents(this.appContainer);
+            this.observeNewLinks(this.appContainer);
+          });
+        });
+      } catch (err) {
+        this.appContainer.innerHTML = "<div>Error loading route</div>";
+      }
+    } else {
+      this.appContainer.innerHTML = "<div>404 - Not Found</div>";
+    }
+  }
+  /**
+   * Inject styles for a route with deduplication
+   */
+  injectStyles(routePath, styles) {
+    const existing = this.routeStyles.get(routePath);
+    if (existing) {
+      existing.forEach((link) => {
+        if (!link.href.includes("globals.css")) {
+          link.remove();
+        }
+      });
+    }
+    if (!styles.trim()) return;
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = styles.trim();
+    const linkElements = [];
+    const links = tempDiv.querySelectorAll('link[rel="stylesheet"]');
+    links.forEach((link) => {
+      const href = link.getAttribute("href") || "";
+      if (href.includes("globals.css")) {
+        return;
+      }
+      const linkEl = document.createElement("link");
+      linkEl.rel = "stylesheet";
+      linkEl.href = href;
+      linkEl.setAttribute("data-route-styles", routePath);
+      const existingLink = document.querySelector(
+        `link[rel="stylesheet"][href="${href}"]`
+      );
+      if (!existingLink) {
+        document.head.appendChild(linkEl);
+        linkElements.push(linkEl);
+      }
+    });
+    if (linkElements.length > 0) {
+      this.routeStyles.set(routePath, linkElements);
+    }
+  }
+  /**
+   * Inject scripts with deduplication
+   */
+  async injectScripts(scripts) {
+    if (!scripts.trim()) return;
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = scripts;
+    const scriptTags = tempDiv.querySelectorAll("script");
+    const loadPromises = [];
+    scriptTags.forEach((script) => {
+      const src = script.getAttribute("src");
+      if (src) {
+        if (this.loadedScripts.has(src)) {
+          return;
+        }
+        this.loadedScripts.add(src);
+        const promise = new Promise((resolve5, reject) => {
+          const newScript = document.createElement("script");
+          newScript.type = "module";
+          newScript.src = src;
+          newScript.onload = () => resolve5();
+          newScript.onerror = () => {
+            this.loadedScripts.delete(src);
+            reject(new Error(`Failed to load script: ${src}`));
+          };
+          document.head.appendChild(newScript);
+        });
+        loadPromises.push(promise);
+      } else {
+        const inlineScript = document.createElement("script");
+        inlineScript.type = "module";
+        inlineScript.textContent = script.textContent || "";
+        document.head.appendChild(inlineScript);
+        setTimeout(() => inlineScript.remove(), 0);
+      }
+    });
+    await Promise.all(loadPromises);
+  }
+  /**
+   * Find matching route for pathname
+   */
+  findRoute(pathname) {
+    const exact = this.routes.find((r) => r.path === pathname);
+    if (exact) return exact;
+    for (const route of this.routes) {
+      if (matchesRoute(route.path, pathname)) {
+        return route;
+      }
+    }
+    return null;
+  }
+  /**
+   * Load component with caching
+   */
+  async loadComponentCached(route) {
+    if (this.componentCache.has(route.path)) {
+      return this.componentCache.get(route.path);
+    }
+    const Component = await loadComponent(route);
+    this.componentCache.set(route.path, Component);
+    return Component;
+  }
+  /**
+   * Setup navigation interception
+   */
+  setupNavigation() {
+    document.addEventListener("click", (e) => {
+      const target = e.target;
+      const link = target.closest("a");
+      if (!link) return;
+      const href = link.getAttribute("href");
+      if (!href) return;
+      if (href.startsWith("http") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+        return;
+      }
+      if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey || e.button !== 0) {
+        return;
+      }
+      if (link.target && link.target !== "_self") {
+        return;
+      }
+      if (e.defaultPrevented) {
+        return;
+      }
+      e.preventDefault();
+      this.navigate(href);
+    });
+  }
+  /**
+   * Setup popstate handler for browser back/forward
+   */
+  setupPopState() {
+    window.addEventListener("popstate", () => {
+      this.currentLocation = getInitialLocation();
+      this.updateContent();
+    });
+  }
+  /**
+   * Observe new links in container (called after DOM updates)
+   */
+  observeNewLinks(container) {
+    if (!this.prefetchObserver) return;
+    const links = container.querySelectorAll("a[href]");
+    links.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (href && this.isInternalLink(href)) {
+        const { pathname, search } = normalizePath2(href);
+        const key = this.getCacheKey(pathname, search);
+        if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+          this.prefetchObserver.observe(link);
+        }
+      }
+    });
+  }
+  /**
+   * Setup pre-fetch with Intersection Observer and hover
+   */
+  setupPrefetch() {
+    this.prefetchObserver = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting) {
+            const link = entry.target;
+            const href = link.getAttribute("href");
+            if (href && this.isInternalLink(href)) {
+              const { pathname, search } = normalizePath2(href);
+              const key = this.getCacheKey(pathname, search);
+              if (this.rscPayloadCache.has(key) || this.prefetchPromises.has(key)) {
+                this.prefetchObserver.unobserve(link);
+                this.prefetchedLinks.add(key);
+                return;
+              }
+              if (this.prefetchedLinks.has(key)) {
+                this.prefetchObserver.unobserve(link);
+                return;
+              }
+              this.prefetchedLinks.add(key);
+              this.prefetchRoute(pathname, search).then(() => {
+                this.prefetchObserver.unobserve(link);
+              });
+            }
+          }
+        });
+      },
+      { rootMargin: "200px" }
+    );
+    const allLinks = document.querySelectorAll("a[href]");
+    allLinks.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (href && this.isInternalLink(href)) {
+        const { pathname, search } = normalizePath2(href);
+        const key = this.getCacheKey(pathname, search);
+        if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+          this.prefetchObserver.observe(link);
+        }
+      }
+    });
+    let hoverTimeout = null;
+    document.addEventListener(
+      "mouseenter",
+      (e) => {
+        const target = e.target;
+        if (!target || !(target instanceof Element)) {
+          return;
+        }
+        const link = target.closest("a");
+        if (link) {
+          const href = link.getAttribute("href");
+          if (href && this.isInternalLink(href)) {
+            const { pathname, search } = normalizePath2(href);
+            const key = this.getCacheKey(pathname, search);
+            if (this.rscPayloadCache.has(key) || this.prefetchedLinks.has(key)) {
+              return;
+            }
+            if (hoverTimeout) {
+              clearTimeout(hoverTimeout);
+            }
+            hoverTimeout = setTimeout(() => {
+              if (!this.rscPayloadCache.has(key) && !this.prefetchedLinks.has(key)) {
+                this.prefetchedLinks.add(key);
+                this.prefetchRoute(pathname, search);
+              }
+            }, 100);
+          }
+        }
+      },
+      true
+      // Capture phase
+    );
+  }
+  /**
+   * Initialize router (call after initial page load)
+   */
+  init() {
+    const self = this;
+    const initIslands = () => {
+      setTimeout(() => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            bootIslandsNow();
+            activateAsyncComponents(self.appContainer);
+            self.observeNewLinks(self.appContainer);
+          });
+        });
+      }, 0);
+    };
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", initIslands, { once: true });
+    } else {
+      initIslands();
+    }
+  }
+  /**
+   * Invalidate cache for a specific path (prepared for future revalidatePath implementation)
+   * TODO: Implementar invalidación completa cuando se implemente revalidatePath
+   */
+  revalidatePath(pathname, search = "") {
+    const key = this.getCacheKey(pathname, search);
+    this.invalidatedPaths.add(key);
+    this.rscPayloadCache.delete(key);
+    this.prefetchPromises.delete(key);
+    this.prefetchedLinks.delete(key);
+  }
+};
+
+// src/client/bootstrap.tsx
+async function loadComponent2(route) {
+  try {
+    const module = await route.component();
+    const Component = module.default || module;
+    if (!Component) {
+      throw new Error(ERROR_MESSAGES.COMPONENT_NOT_FOUND(route.path));
+    }
+    return Component;
+  } catch (error) {
+    console.error(ERROR_MESSAGES.FAILED_TO_LOAD_ROUTE_COMPONENT(route.path), error);
+    throw error;
+  }
+}
+function bootstrapClient(options) {
+  const { routes } = options;
+  const appContainer = document.getElementById(SERVER.APP_CONTAINER_ID);
+  if (!appContainer) {
+    console.error(ERROR_MESSAGES.APP_CONTAINER_NOT_FOUND);
+    return;
+  }
+  const currentPath = window.location.pathname;
+  const currentRoute = routes.find((route) => matchesRoute(route.path, currentPath));
+  if (currentRoute) {
+    loadComponent2(currentRoute).then(() => {
+    }).catch(() => {
+    });
+  }
+  const router = new FrameworkRouter(routes, appContainer);
+  router.init();
+}
+
+// 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(config, projectDir, appDir) {
+  const manifestDir = join5(getProjectDir(), DIRECTORIES.LOLY);
+  if (!existsSync7(manifestDir)) {
+    mkdirSync(manifestDir, { recursive: true });
+  }
+  const clientManifestPath = getManifestPath();
+  const hasClientManifest = existsSync7(clientManifestPath);
+  const pageRoutes = config.routes.filter((r) => r.type === "page");
+  let routeIndex = 0;
+  const routesData = config.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 = config.rootLayout ? {
+    sourcePath: config.rootLayout.filePath,
+    serverPath: getServerCompiledPath(
+      config.rootLayout.filePath,
+      appDir
+    ),
+    segments: config.rootLayout.segments,
+    type: config.rootLayout.type,
+    isRootLayout: config.rootLayout.isRootLayout,
+    urlPath: config.rootLayout.urlPath
+  } : void 0;
+  routeIndex = 0;
+  const routeMapData = Array.from(config.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 (config.apiRouteMap) {
+    for (const [path4, route] of config.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);
+}
+function readRspackManifest(manifestPath) {
+  const { readFileSync: readFileSync6 } = __require("fs");
+  const content = readFileSync6(manifestPath, "utf-8");
+  return JSON.parse(content);
+}
+function writeManifest(manifestPath, manifest) {
+  const { writeFileSync: writeFileSync3 } = __require("fs");
+  const dir = dirname2(manifestPath);
+  if (!existsSync7(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function generateAssetTags2(manifest, entryName, publicPath) {
+  const entry = manifest[entryName];
+  if (!entry) {
+    return { scripts: "", styles: "", preloads: "" };
+  }
+  let scripts = "";
+  let styles = "";
+  let preloads = "";
+  if (entry.file) {
+    const scriptPath = entry.file.startsWith("/") ? entry.file : `${publicPath}${entry.file}`;
+    preloads = `<link rel="modulepreload" href="${scriptPath}" crossorigin>`;
+    scripts = `<script type="module" src="${scriptPath}"></script>`;
+  }
+  if (entry.css && entry.css.length > 0) {
+    styles = entry.css.map((css) => {
+      const cssPath = css.startsWith("/") ? css : `${publicPath}${css}`;
+      return `<link rel="stylesheet" href="${cssPath}">`;
+    }).join("");
+  }
+  if (entry.imports && entry.imports.length > 0) {
+    for (const importName of entry.imports) {
+      const importEntry = manifest[importName];
+      if (importEntry?.file) {
+        const scriptPath = importEntry.file.startsWith("/") ? importEntry.file : `${publicPath}${importEntry.file}`;
+        scripts += `
+<script type="module" src="${scriptPath}"></script>`;
+      }
+      if (importEntry?.css && importEntry.css.length > 0) {
+        for (const css of importEntry.css) {
+          const cssPath = css.startsWith("/") ? css : `${publicPath}${css}`;
+          styles += `
+<link rel="stylesheet" href="${cssPath}">`;
+        }
+      }
+    }
+  }
+  return { scripts, styles, preloads };
+}
+
+// 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 config = configModule.default || configModule;
+  const css = readFileSync5(inputPath, "utf-8");
+  let plugins = config.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((resolve5, 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;
+        }
+        resolve5();
+      });
+    });
+  } 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/client/components/Image/index.tsx
+import { jsx, jsxs } from "loly-jsx/jsx-runtime";
+function getOptimizedImageUrl(src, width, height, quality, format) {
+  const params = new URLSearchParams();
+  params.set("src", src);
+  if (width) params.set("w", width.toString());
+  if (height) params.set("h", height.toString());
+  if (quality) params.set("q", quality.toString());
+  if (format && format !== "auto") params.set("format", format);
+  return `${SERVER.IMAGE_ENDPOINT}?${params.toString()}`;
+}
+function generateSrcSet(src, sizes, height, quality, format) {
+  return sizes.map((size) => {
+    const url = getOptimizedImageUrl(src, size, height, quality, format);
+    return `${url} ${size}w`;
+  }).join(", ");
+}
+function Image({
+  src,
+  alt,
+  width,
+  height,
+  priority = false,
+  fill = false,
+  sizes,
+  placeholder,
+  blurDataURL,
+  quality,
+  format,
+  className,
+  deviceSizes,
+  imageSizes,
+  style,
+  ...rest
+}) {
+  const defaultDeviceSizes = deviceSizes || [640, 750, 828, 1080, 1200, 1920, 2048, 3840];
+  const defaultImageSizes = imageSizes || [16, 32, 48, 64, 96, 128, 256, 384];
+  if (!fill && (!width || !height)) {
+    if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+      console.warn(
+        "[Image] width and height are required when fill is false. This helps prevent layout shift (CLS)."
+      );
+    }
+  }
+  const optimizedSrc = getOptimizedImageUrl(src, width, height, quality, format);
+  const srcSetSizes = width ? defaultDeviceSizes.filter((s) => s <= width * 2) : defaultImageSizes;
+  const srcSet = srcSetSizes.length > 0 ? generateSrcSet(src, srcSetSizes, height, quality, format) : void 0;
+  const imageStyle = typeof style === "string" ? {} : { ...style || {} };
+  if (fill) {
+    imageStyle.position = "absolute";
+    imageStyle.height = "100%";
+    imageStyle.width = "100%";
+    imageStyle.objectFit = "cover";
+    imageStyle.objectPosition = "center";
+    imageStyle.top = 0;
+    imageStyle.left = 0;
+  } else {
+    if (width) imageStyle.width = width;
+    if (height) imageStyle.height = height;
+  }
+  if (!fill && width && height) {
+    const aspectRatio = height / width * 100;
+    const containerStyle = {
+      display: "block",
+      position: "relative",
+      width,
+      maxWidth: "100%"
+    };
+    const spacerStyle = {
+      display: "block",
+      paddingBottom: `${aspectRatio}%`
+    };
+    return /* @__PURE__ */ jsxs("span", { style: containerStyle, className, children: [
+      /* @__PURE__ */ jsx("span", { style: spacerStyle }),
+      placeholder === "blur" && blurDataURL && /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: blurDataURL,
+          alt: "",
+          "aria-hidden": "true",
+          style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            width: "100%",
+            height: "100%",
+            objectFit: "cover",
+            filter: "blur(20px)",
+            transform: "scale(1.1)"
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: optimizedSrc,
+          alt,
+          width,
+          height,
+          srcSet,
+          sizes,
+          loading: priority ? "eager" : "lazy",
+          decoding: "async",
+          style: {
+            ...imageStyle,
+            position: "absolute",
+            top: 0,
+            left: 0,
+            height: "100%",
+            width: "100%"
+          },
+          ...rest
+        }
+      )
+    ] });
+  }
+  const finalStyle = typeof style === "string" ? style : imageStyle;
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      src: optimizedSrc,
+      alt,
+      width,
+      height,
+      srcSet,
+      sizes,
+      loading: priority ? "eager" : "lazy",
+      decoding: "async",
+      className,
+      style: finalStyle,
+      ...rest
+    }
+  );
+}
+export {
+  BaseServer,
+  DevServer,
+  Image,
+  ProdServer,
+  RSCStrategy,
+  RenderingStrategyFactory,
+  RouteComponentFactory,
+  SSRStrategy,
+  bootstrapClient,
+  buildProject,
+  extractParams,
+  generateAssetTags2 as generateAssetTags,
+  generateBootstrap,
+  generatePublicEnvScript,
+  generateRoutesManifest,
+  getEnv,
+  getPublicEnv,
+  matchRoute,
+  readRspackManifest,
+  renderPageContent,
+  renderPageStream,
+  scanRoutes,
+  startDevServer,
+  startProdServer,
+  writeManifest
+};
+//# sourceMappingURL=index.js.map