dinou 6.1.1 → 7.1.0

package/dinou/core/config.js

@@ -0,0 +1,11 @@
+// dinou/core/config.js
+// Type helper for defining Dinou configuration and plugins
+
+function defineConfig(config) {
+  return config;
+}
+
+module.exports = {
+  defineConfig,
+};
+module.exports.default = defineConfig;

package/dinou/core/dinou-paths.js

@@ -0,0 +1,52 @@
+const path = require("path");
+const fs = require("fs");
+
+function getDinouCoreDir() {
+  // Edge runtime guard: en Cloudflare Workers / Deno Edge no hay sistema de archivos dinámico
+  if (typeof process !== "undefined" && process.env && process.env.DINOU_RUNTIME === "edge") {
+    return "/dinou/core";
+  }
+
+  // 1. Modo eyectado: ./dinou/core en la raíz del proyecto
+  try {
+    const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : "";
+    const localCore = path.resolve(cwd, "dinou/core");
+    if (fs.existsSync && fs.existsSync(localCore)) return localCore;
+  } catch (e) {}
+
+  // 2. Modo librería sin empaquetar: dinou-paths.js ya está en dinou/core
+  if (typeof __dirname !== "undefined") {
+    try {
+      if (fs.existsSync && fs.existsSync(path.join(__dirname, "handler.js"))) {
+        return __dirname;
+      }
+    } catch (e) {}
+  }
+
+  // 3. Resolución estándar de Node
+  try {
+    const serverPath = require.resolve("dinou/server");
+    const resolvedCore = path.join(path.dirname(serverPath), "core");
+    if (fs.existsSync && fs.existsSync(resolvedCore)) return resolvedCore;
+  } catch (e) { }
+
+  // 4. Modo bundle de Webpack (ej. corriendo desde .dinou/dist3/server/handler.js)
+  // La estructura del paquete instalado es node_modules/dinou/dinou/core
+  try {
+    const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : "";
+    const nodeModulesDinouCore = path.resolve(cwd, "node_modules/dinou/dinou/core");
+    if (fs.existsSync && fs.existsSync(nodeModulesDinouCore)) return nodeModulesDinouCore;
+
+    // 5. Fallback por si la estructura fuese plana
+    return path.resolve(cwd, "node_modules/dinou/core");
+  } catch (e) {}
+
+  return "/dinou/core";
+}
+
+const dinouCoreDir = getDinouCoreDir();
+
+module.exports = {
+  dinouCoreDir,
+  getDinouCoreDir,
+};

package/dinou/core/edge-ssr.js

@@ -0,0 +1,122 @@
+// dinou/core/edge-ssr.js
+// Native React 19 Edge SSR Streaming Engine for Dinou.
+// Reconstructs React element tree from RSC stream and renders native HTML stream via react-dom/server.edge.
+
+import { createFromReadableStream } from "react-server-dom-webpack/client.edge";
+import { renderToReadableStream } from "react-dom/server.edge";
+
+/**
+ * Reconstructs an RSC stream into a React element tree and streams HTML via react-dom/server.edge.
+ * @param {ReadableStream} rscStream The RSC binary stream
+ * @param {object} consumerManifest The client components consumer manifest ({ moduleMap, serverModuleMap, moduleLoading })
+ * @param {object} options Configuration options ({ bootstrapModules, bootstrapScriptContent, onError, waitForAll })
+ * @returns {Promise<ReadableStream>} The HTML stream
+ */
+export async function renderRscStreamToHtmlStream(rscStream, consumerManifest, options = {}) {
+  try {
+    let effectiveManifest = consumerManifest;
+    if (consumerManifest && consumerManifest.moduleMap && !consumerManifest.moduleMap.__isDinouProxy) {
+      const origMap = consumerManifest.moduleMap;
+      const proxyMap = new Proxy(origMap, {
+        get(target, prop) {
+          if (typeof prop !== "string") return target[prop];
+          if (prop === "__isDinouProxy") return true;
+          if (prop in target) return target[prop];
+
+          const dynamicMap = typeof globalThis !== "undefined" ? globalThis.__DINOU_DYNAMIC_SSR_MODULE_MAP__ : null;
+          if (dynamicMap) {
+            if (prop in dynamicMap) {
+              target[prop] = dynamicMap[prop];
+              return dynamicMap[prop];
+            }
+            const altProp = prop.startsWith("/") ? prop.slice(1) : "/" + prop;
+            if (altProp in dynamicMap) {
+              target[prop] = dynamicMap[altProp];
+              return dynamicMap[altProp];
+            }
+          }
+
+          const clientManifest = typeof globalThis !== "undefined" ? (globalThis.__DINOU_CLIENT_MANIFEST__ || globalThis.__DINOU_RAW_CLIENT_MANIFEST__) : null;
+          if (clientManifest) {
+            const cleanProp = prop.startsWith("/") ? prop.slice(1) : prop;
+            for (const [k, v] of Object.entries(clientManifest)) {
+              if (!v?.id) continue;
+              const cleanVId = v.id.startsWith("/") ? v.id.slice(1) : v.id;
+              if (v.id === prop || cleanVId === cleanProp || ("/" + cleanVId) === prop) {
+                const fileUrl = k.split("#")[0];
+                const entry = { "*": { id: fileUrl, chunks: [], name: "*" } };
+                target[prop] = entry;
+                return entry;
+              }
+            }
+          }
+
+          if (prop.startsWith("file://")) {
+            const canonicalProp = prop.startsWith("file:///") ? prop : "file:///" + prop.slice(7);
+            const entry = { "*": { id: canonicalProp, chunks: [], name: "*" } };
+            target[prop] = entry;
+            return entry;
+          }
+
+          return target[prop];
+        },
+        has(target, prop) {
+          if (prop === "__isDinouProxy") return true;
+          if (prop in target) return true;
+          const dynamicMap = typeof globalThis !== "undefined" ? globalThis.__DINOU_DYNAMIC_SSR_MODULE_MAP__ : null;
+          if (dynamicMap && (prop in dynamicMap || (prop.startsWith("/") ? prop.slice(1) : "/" + prop) in dynamicMap)) return true;
+          return false;
+        }
+      });
+      effectiveManifest = { ...consumerManifest, moduleMap: proxyMap, serverModuleMap: null };
+    } else if (effectiveManifest) {
+      effectiveManifest = { ...effectiveManifest, serverModuleMap: null };
+    }
+
+    // 1. Reconstruct JSX element tree from RSC wire stream
+    const elementTree = await createFromReadableStream(rscStream, {
+      serverConsumerManifest: effectiveManifest,
+    });
+
+    // 2. Stream HTML using React 19's native Edge renderer
+    const htmlStream = await renderToReadableStream(elementTree, {
+      bootstrapModules: options.bootstrapModules || ["/main.js"],
+      bootstrapScriptContent: options.bootstrapScriptContent,
+      onError(error) {
+        if (options.onError) {
+          options.onError(error);
+        } else {
+          console.error("[Edge Native SSR] Render error:", error);
+        }
+      },
+    });
+
+    if (options.waitForAll) {
+      await htmlStream.allReady;
+    }
+
+    const importMapHtml = options.importMapHtml || (typeof globalThis !== "undefined" && globalThis.__DINOU_IMPORT_MAP_HTML__) || "";
+    if (importMapHtml) {
+      const encoder = new TextEncoder();
+      const importMapBytes = encoder.encode(importMapHtml);
+      let injected = false;
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          if (!injected) {
+            injected = true;
+            controller.enqueue(importMapBytes);
+          }
+          controller.enqueue(chunk);
+        },
+      });
+      return htmlStream.pipeThrough(transform);
+    }
+
+    return htmlStream;
+  } catch (err) {
+    if (process.env.DINOU_DEBUG) {
+      console.error("[Edge Native SSR] Fatal stream reconstruction error:", err);
+    }
+    throw err;
+  }
+}

package/dinou/core/export-static.mjs

@@ -0,0 +1,64 @@
+// dinou/core/export-static.mjs
+// Exports a standalone static website from .dinou/dist3 (assets) and .dinou/dist2 (SSG HTML)
+// into an 'out/' directory, ready for Surge.sh, GitHub Pages, Cloudflare Pages (static), etc.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const projectRoot = process.cwd();
+const outDir = path.resolve(projectRoot, "out");
+const dist3Dir = path.resolve(projectRoot, ".dinou/dist3");
+const dist2Dir = path.resolve(projectRoot, ".dinou/dist2");
+
+const bundlerName = process.env.DINOU_BUILD_TOOL || "esbuild";
+console.log(`\n🦖 Dinou v7 (Static Export • ${bundlerName})`);
+
+// 1. Clean output directory
+if (fs.existsSync(outDir)) {
+  fs.rmSync(outDir, { recursive: true, force: true });
+}
+fs.mkdirSync(outDir, { recursive: true });
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(src)) return 0;
+  let count = 0;
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      count += copyRecursive(srcPath, destPath);
+    } else {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+  return count;
+}
+
+// 2. Copy production assets from .dinou/dist3 (JS bundles, CSS, favicons)
+let assetCount = 0;
+if (fs.existsSync(dist3Dir)) {
+  assetCount = copyRecursive(dist3Dir, outDir);
+  console.log(`  📦 Copied ${assetCount} production asset(s) from .dinou/dist3`);
+} else {
+  console.warn("⚠️ [Dinou Export] Warning: .dinou/dist3 not found. Did you run a production build first?");
+}
+
+// 3. Copy pre-rendered SSG HTML pages from .dinou/dist2
+let pageCount = 0;
+if (fs.existsSync(dist2Dir)) {
+  pageCount = copyRecursive(dist2Dir, outDir);
+  console.log(`  📄 Copied ${pageCount} static page/payload file(s) from .dinou/dist2`);
+} else {
+  console.warn("⚠️ [Dinou Export] Warning: .dinou/dist2 not found. Ensure your app has static routes.");
+}
+
+const relOut = path.relative(projectRoot, outDir) || "out";
+console.log(`\n✓ Standalone static site exported to: ${relOut}/`);
+console.log("  👉 Deploy with:");
+console.log("     • Surge.sh:       npx surge out <your-domain>.surge.sh");
+console.log("     • GitHub Pages:   npx gh-pages -d out");
+console.log("     • Cloudflare:     npx wrangler pages deploy out\n");

package/dinou/core/generate-route-types.js

@@ -0,0 +1,252 @@
+// dinou/core/generate-route-types.js
+const fs = require("fs");
+const path = require("path");
+
+const PAGE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+
+/**
+ * Recursively scans directory to collect all page routes according to Dinou conventions.
+ * - Ignores folders starting with '_' (private folders)
+ * - Ignores folders starting with '@' (parallel route slots)
+ * - Transparently handles route groups '(group)' by stripping them from URL paths
+ * - Tracks dynamic parameters: [id], [...slug], [[slug]], [[...slug]]
+ */
+function collectRoutes(dir, segments = [], routes = []) {
+  if (!fs.existsSync(dir)) return routes;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (e) {
+    return routes;
+  }
+
+  // Check if this folder has a page file
+  const hasPage = entries.some(
+    (e) => !e.isDirectory() && PAGE_EXTENSIONS.some((ext) => e.name === `page${ext}`)
+  );
+
+  if (hasPage) {
+    const routePath = segments.length === 0 ? "/" : "/" + segments.join("/");
+    routes.push({
+      path: routePath,
+      segments: [...segments],
+    });
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const name = entry.name;
+    // Ignore private folders (_*) and parallel route slots (@*)
+    if (name.startsWith("_") || name.startsWith("@")) continue;
+
+    // Route groups: (group) - do not add to URL path
+    if (name.startsWith("(") && name.endsWith(")")) {
+      collectRoutes(path.join(dir, name), segments, routes);
+      continue;
+    }
+
+    collectRoutes(path.join(dir, name), [...segments, name], routes);
+  }
+
+  return routes;
+}
+
+/**
+ * Generates TypeScript type definitions for all discovered routes.
+ */
+function generateRouteDefinitions(routes) {
+  const staticRoutes = new Set();
+  const dynamicTemplateRoutes = new Set();
+  const routeParamsMap = {};
+
+  for (const route of routes) {
+    const segments = route.segments;
+    const isDynamic = segments.some((s) => s.startsWith("[") && s.endsWith("]"));
+
+    // Calculate parameter types for Level 2
+    const params = {};
+    for (const seg of segments) {
+      if (seg.startsWith("[[...") && seg.endsWith("]]")) {
+        const paramName = seg.slice(5, -2);
+        params[paramName] = "string[] | undefined";
+      } else if (seg.startsWith("[[") && seg.endsWith("]]")) {
+        const paramName = seg.slice(2, -2);
+        params[paramName] = "string | undefined";
+      } else if (seg.startsWith("[...") && seg.endsWith("]")) {
+        const paramName = seg.slice(4, -1);
+        params[paramName] = "string[]";
+      } else if (seg.startsWith("[") && seg.endsWith("]")) {
+        const paramName = seg.slice(1, -1);
+        params[paramName] = "string";
+      }
+    }
+    routeParamsMap[route.path] = params;
+
+    if (!isDynamic) {
+      staticRoutes.add(route.path);
+    } else {
+      // Build template literal type for Level 1 autocomplete & validation
+      const transformedSegments = segments.map((seg) => {
+        if (seg.startsWith("[[...") && seg.endsWith("]]")) {
+          return "${string}";
+        } else if (seg.startsWith("[[") && seg.endsWith("]]")) {
+          return "${string | number}";
+        } else if (seg.startsWith("[...") && seg.endsWith("]")) {
+          return "${string}";
+        } else if (seg.startsWith("[") && seg.endsWith("]")) {
+          return "${string | number}";
+        }
+        return seg;
+      });
+
+      dynamicTemplateRoutes.add("`/" + transformedSegments.join("/") + "`");
+
+      // For optional segments ([[foo]] or [[...foo]]), progressively peel off trailing optional
+      // segments to register all valid intermediate route variants (including the base static route).
+      let cur = [...segments];
+      while (cur.length > 0 && cur[cur.length - 1].startsWith("[[") && cur[cur.length - 1].endsWith("]]")) {
+        cur.pop();
+        if (cur.length === 0) {
+          staticRoutes.add("/");
+        } else if (!cur.some((s) => s.startsWith("[") && s.endsWith("]"))) {
+          staticRoutes.add("/" + cur.join("/"));
+        } else {
+          const transformed = cur.map((seg) => {
+            if (seg.startsWith("[[...") && seg.endsWith("]]")) return "${string}";
+            if (seg.startsWith("[[") && seg.endsWith("]]")) return "${string | number}";
+            if (seg.startsWith("[...") && seg.endsWith("]")) return "${string}";
+            if (seg.startsWith("[") && seg.endsWith("]")) return "${string | number}";
+            return seg;
+          });
+          dynamicTemplateRoutes.add("`/" + transformed.join("/") + "`");
+        }
+      }
+    }
+  }
+
+  return {
+    staticRoutes: Array.from(staticRoutes).sort(),
+    dynamicRoutes: Array.from(dynamicTemplateRoutes).sort(),
+    routeParamsMap,
+  };
+}
+
+/**
+ * Generates the .dinou/types/routes.d.ts file and ensures dinou-env.d.ts references it.
+ * @param {string} projectRoot Root directory of the project (default process.cwd())
+ */
+function generateRouteTypes(projectRoot = process.cwd()) {
+  const srcDir = path.resolve(projectRoot, "src");
+  if (!fs.existsSync(srcDir)) return;
+
+  const routes = collectRoutes(srcDir);
+  const { staticRoutes, dynamicRoutes, routeParamsMap } = generateRouteDefinitions(routes);
+
+  const staticUnion = staticRoutes.length > 0
+    ? staticRoutes.map((r) => `  | ${JSON.stringify(r)}`).join("\n")
+    : "  | string";
+
+  const dynamicUnion = dynamicRoutes.length > 0
+    ? dynamicRoutes.map((r) => `  | ${r}`).join("\n")
+    : "  | never";
+
+  const paramsEntries = Object.entries(routeParamsMap)
+    .map(([rPath, pObj]) => {
+      const keys = Object.keys(pObj);
+      if (keys.length === 0) {
+        return `    ${JSON.stringify(rPath)}: Record<string, never>;`;
+      }
+      const props = keys
+        .map((k) => {
+          const isOptional = pObj[k].includes("undefined");
+          const cleanType = pObj[k].replace(" | undefined", "");
+          return `${k}${isOptional ? "?" : ""}: ${cleanType}`;
+        })
+        .join("; ");
+      return `    ${JSON.stringify(rPath)}: { ${props} };`;
+    })
+    .join("\n");
+
+  const content = `// This file is auto-generated by Dinou. Do not edit directly.
+import "dinou";
+
+declare module "dinou" {
+  export type DinouStaticRoutes =
+${staticUnion};
+
+  export type DinouDynamicRoutes =
+${dynamicUnion};
+
+  export type DinouInternalRoute = DinouStaticRoutes | DinouDynamicRoutes;
+
+  export type DinouRelativeOrExternalRoute =
+    | \`http://\${string}\`
+    | \`https://\${string}\`
+    | \`mailto:\${string}\`
+    | \`tel:\${string}\`
+    | \`./\${string}\`
+    | \`../\${string}\`
+    | \`#\${string}\`
+    | \`?\${string}\`;
+
+  export type DinouGeneratedRoute =
+    | DinouInternalRoute
+    | \`\${DinouInternalRoute}?\${string}\`
+    | \`\${DinouInternalRoute}#\${string}\`
+    | DinouRelativeOrExternalRoute;
+
+  export interface DinouRouteParamsMap {
+${paramsEntries}
+  }
+
+  namespace DinouRouter {
+    interface Register {
+      route: DinouGeneratedRoute;
+      params: DinouRouteParamsMap;
+    }
+  }
+}
+`;
+
+  // Write .dinou/types/routes.d.ts
+  const typesDir = path.resolve(projectRoot, ".dinou/types");
+  try {
+    fs.mkdirSync(typesDir, { recursive: true });
+    const targetFile = path.join(typesDir, "routes.d.ts");
+    const currentContent = fs.existsSync(targetFile) ? fs.readFileSync(targetFile, "utf8") : "";
+    if (currentContent !== content) {
+      fs.writeFileSync(targetFile, content, "utf8");
+    }
+  } catch (e) {
+    if (process.env.DINOU_DEBUG) {
+      console.warn("[Dinou] Could not write .dinou/types/routes.d.ts:", e.message);
+    }
+  }
+
+  // Ensure dinou-env.d.ts references .dinou/types/routes.d.ts
+  const envFile = path.resolve(projectRoot, "dinou-env.d.ts");
+  try {
+    if (fs.existsSync(envFile)) {
+      let envContent = fs.readFileSync(envFile, "utf8");
+      const refLine = '/// <reference path="./.dinou/types/routes.d.ts" />';
+      if (!envContent.includes(refLine)) {
+        envContent = envContent.trimEnd() + "\n" + refLine + "\n";
+        fs.writeFileSync(envFile, envContent, "utf8");
+      }
+    }
+  } catch (e) {}
+
+  return {
+    staticCount: staticRoutes.length,
+    dynamicCount: dynamicRoutes.length,
+    totalRoutes: routes.length,
+  };
+}
+
+module.exports = {
+  collectRoutes,
+  generateRouteDefinitions,
+  generateRouteTypes,
+};

package/dinou/core/generate-static-page.js

@@ -1,9 +1,11 @@
+// dinou/core/generate-static-page.js
+// Generates static HTML for a given path using the in-memory Dual-Bundle streaming engine.
+// Completely eliminates child_process.fork() and render-app-to-html.js.
+
 const path = require("path");
-const { mkdirSync, createWriteStream, existsSync } = require("fs");
 const fs = require("fs").promises;
-const renderAppToHtml = require("./render-app-to-html.js");
-const { getStaticMetadata } = require("./build-static-pages.js");
-const { processMetadata } = require("./get-ssg-metadata.js");
+const { existsSync, mkdirSync } = require("fs");
+const { pathToFileURL } = require("url");
 
 const OUT_DIR = path.resolve(".dinou/dist2");
 
@@ -12,107 +14,66 @@ async function generateStaticPage(reqPath) {
   const htmlPath = path.join(OUT_DIR, finalReqPath, "index.html");
   const tempHtmlPath = path.join(OUT_DIR, finalReqPath, `index.html.${Date.now()}-${Math.random()}.tmp`);
 
-  const query = {};
-  const paramsString = JSON.stringify(query);
-  const capturedStatus = {};
-
-  const contextForChild = {
-    req: {
-      query,
-      cookies: {},
-      headers: {
-        "user-agent": "Dinou-ISR-Revalidator",
-        host: "localhost",
-        "x-forwarded-proto": "http",
-      },
-      path: finalReqPath,
-      method: "GET",
-    },
-  };
-
   try {
     mkdirSync(path.dirname(htmlPath), { recursive: true });
-    const fileStream = createWriteStream(tempHtmlPath);
-    let htmlStream = null;
 
-    const mockRes = {
-      headersSent: true,
-      _cookies: [],
-      cookie(name, value, options) {
-        this._cookies.push({ name, value, options });
-      },
-      write: (chunk) => {
-        if (!fileStream.writableEnded) fileStream.write(chunk);
-      },
-      end: (chunk) => {
-        if (chunk && !fileStream.writableEnded) fileStream.write(chunk);
-        if (htmlStream) htmlStream.unpipe(fileStream);
-        if (!fileStream.writableEnded) fileStream.end();
-      },
-      status: (code) => {
-        capturedStatus.value = code;
-      },
-      setHeader: () => { },
-      clearCookie: () => { },
-      redirect: () => { },
-    };
+    const rscEnginePath = path.resolve(process.cwd(), ".dinou/node/rsc-engine.mjs");
+    const ssrEnginePath = path.resolve(process.cwd(), ".dinou/node/ssr-engine.mjs");
 
-    htmlStream = renderAppToHtml(
-      finalReqPath,
-      paramsString,
-      contextForChild,
-      mockRes,
-      capturedStatus
-    );
-
-    const metadata = getStaticMetadata(finalReqPath);
-    let sideEffectScripts = "";
-    if (metadata && metadata.effects) {
-      sideEffectScripts = processMetadata(metadata.effects);
+    let rscModule = null;
+    let ssrModule = null;
+    if (existsSync(rscEnginePath) && existsSync(ssrEnginePath)) {
+      rscModule = await import(pathToFileURL(rscEnginePath).href);
+      ssrModule = await import(pathToFileURL(ssrEnginePath).href);
     }
 
-    await new Promise((resolve, reject) => {
-      if (sideEffectScripts) fileStream.write(sideEffectScripts);
-      htmlStream.pipe(fileStream, { end: false });
-      htmlStream.on("end", () => {
-        if (!fileStream.writableEnded) fileStream.end();
-        resolve();
-      });
-      htmlStream.on("error", (err) => {
-        fileStream.end();
-        if (err.code === "ERR_STREAM_WRITE_AFTER_END") resolve();
-        else reject(err);
+    if (rscModule && ssrModule) {
+      const webReq = new Request(`http://localhost${finalReqPath}`);
+      const res = await rscModule.handleRequest(webReq, {
+        runtime: "node-bundle",
+        renderHtmlStream: ssrModule.renderHtml,
+        isSSG: true,
       });
-      fileStream.on("error", reject);
-    });
 
-    if (metadata) {
-      const metadataPath = path.join(OUT_DIR, finalReqPath, "metadata.json");
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify({
-          revalidate: metadata.revalidate,
-          generatedAt: Date.now(),
-          effects: metadata.effects,
-          tags: metadata.tags || [],
-        }, null, 2),
-        "utf8"
-      );
-    }
+      const text = await res.text();
+      await fs.writeFile(tempHtmlPath, text, "utf8");
+
+      const routeMeta = typeof rscModule.getStaticMetadata === "function" ? rscModule.getStaticMetadata(finalReqPath) : null;
+      let isRoutePpr = Boolean(routeMeta?.ppr);
+      if (!isRoutePpr) {
+        try {
+          const metaDisk = JSON.parse(await fs.readFile(path.join(OUT_DIR, finalReqPath, "metadata.json"), "utf8"));
+          if (metaDisk?.ppr) isRoutePpr = true;
+        } catch (e) {}
+      }
+      if (isRoutePpr) {
+        const shellHtmlPath = path.join(OUT_DIR, finalReqPath, "shell.html");
+        await fs.writeFile(shellHtmlPath, text, "utf8").catch(() => {});
+        try {
+          const pageReq = new Request(`http://localhost/____rsc_page____${finalReqPath}`);
+          const pageRes = await rscModule.handleRequest(pageReq, { runtime: "node-bundle" });
+          if (pageRes.status === 200) {
+            const pageRscText = await pageRes.text();
+            const shellRscPath = path.join(OUT_DIR, finalReqPath, "shell.rsc");
+            await fs.writeFile(shellRscPath, pageRscText, "utf8").catch(() => {});
+          }
+        } catch (e) {}
+      }
 
-    const status = capturedStatus.value || 200;
-    const success = status !== 500;
+      return {
+        success: res.status !== 500 && text.length > 0,
+        type: "html",
+        reqPath: finalReqPath,
+        tempPath: tempHtmlPath,
+        finalPath: htmlPath,
+        status: res.status || 200,
+        ppr: isRoutePpr,
+      };
+    }
 
-    return {
-      success,
-      type: "html",
-      reqPath: finalReqPath,
-      tempPath: tempHtmlPath,
-      finalPath: htmlPath,
-      status: status,
-    };
+    return { success: false, tempPath: tempHtmlPath };
   } catch (error) {
-    await fs.unlink(tempHtmlPath).catch(() => { });
+    await fs.unlink(tempHtmlPath).catch(() => {});
     return { success: false, tempPath: tempHtmlPath };
   }
 }