dinou 6.1.0 → 7.0.0

package/dinou/core/build-static-pages.js

@@ -7,9 +7,60 @@ const {
 } = require("./get-file-path-and-dynamic-params");
 const importModule = require("./import-module");
 const { requestStorage } = require("./request-context.js");
+const { getLayoutProps, resolveLayoutFunctionsConfig } = require("./layout-functions");
+const { runWithPprContext, getRegisteredHoles } = require("./ppr-context.js");
+const { resolveModulePpr } = require("./resolve-module-ppr");
+const { getDinouConfig } = require("./load-dinou-config");
+
+async function resolveBuildPprForRoute(segments, pagePath, pageFunctionsPath, srcFolder) {
+  const globalCfg = await getDinouConfig();
+  let inheritedPpr = Boolean(globalCfg?.ppr);
+  try {
+    const parentLayouts = getFilePathAndDynamicParams(
+      segments || [],
+      {},
+      srcFolder,
+      "layout",
+      true,
+      false,
+      undefined,
+      0,
+      {},
+      true
+    );
+    if (parentLayouts && Array.isArray(parentLayouts)) {
+      for (const [lPath, lParams] of parentLayouts) {
+        const lConfig = await resolveLayoutFunctionsConfig(lPath, lParams);
+        if (lConfig && lConfig.ppr !== null && lConfig.ppr !== undefined) {
+          inheritedPpr = Boolean(lConfig.ppr);
+        }
+      }
+    }
+  } catch (e) {}
+
+  let explicitPagePpr = null;
+  if (pageFunctionsPath) {
+    try {
+      const module = await importModule(pageFunctionsPath);
+      explicitPagePpr = await resolveModulePpr(module);
+    } catch (e) {}
+  }
+  if (explicitPagePpr === null && typeof globalThis !== "undefined" && globalThis.__DINOU_ROUTE_METADATA__) {
+    const normKey = pageFunctionsPath ? pageFunctionsPath.replace(/\\/g, "/") : "";
+    for (const [k, meta] of Object.entries(globalThis.__DINOU_ROUTE_METADATA__)) {
+      if (meta.ppr !== undefined && (normKey === k || normKey.endsWith("/" + k) || normKey.endsWith(k))) {
+        explicitPagePpr = Boolean(meta.ppr);
+        break;
+      }
+    }
+  }
+
+  return explicitPagePpr !== null ? explicitPagePpr : inheritedPpr;
+}
 
 const staticRoutes = new Set();
 const staticMetadata = new Map();
+const staticLayouts = new Map();
 
 function safeDecode(val) {
   try {
@@ -19,65 +70,21 @@ function safeDecode(val) {
   }
 }
 
-/**
- * Creates a spy that detects access to properties and marks the page as dynamic.
- * @param {Object} target - The real object (cookies, headers, query...)
- * @param {string} label - Name for the log (e.g., "Headers", "Cookies")
- * @param {Function} onBailout - Callback to execute when access is detected
- */
-function createBailoutProxy(target, label, onBailout) {
-  // If there is no target, use an empty object to avoid crashes,
-  // but ideally pass whatever you have.
-  const safeTarget = target || {};
-
-  return new Proxy(safeTarget, {
-    get(t, prop, receiver) {
-      // Ignore internal Node/Console symbols
-      if (
-        typeof prop === "symbol" ||
-        prop === "inspect" ||
-        prop === "valueOf" ||
-        prop === "toString" // Sometimes useful to ignore
-      ) {
-        return Reflect.get(t, prop, receiver);
-      }
-
-      // 🚨 ALARM: Access detected
-      console.log(
-        `[StaticBailout] Access to ${label} detected: "${String(prop)}".`,
-      );
-
-      // Execute logic to mark as dynamic
-      onBailout();
-
-      // IMPORTANT: Return the real value of the original object
-      return Reflect.get(t, prop, receiver);
-    },
-
-    ownKeys(t) {
-      console.log(`[StaticBailout] Iteration of ${label} detected.`);
-      onBailout();
-      return Reflect.ownKeys(t);
-    },
-
-    // Optional: Detect if they try to ask "prop in headers"
-    has(t, prop) {
-      console.log(
-        `[StaticBailout] Existence check (IN) in ${label}: "${String(prop)}".`,
-      );
-      onBailout();
-      return Reflect.has(t, prop);
-    },
-  });
+async function isDynamicRoute(revalidate) {
+  if (revalidate === undefined || revalidate === false) return false;
+  const val = typeof revalidate === "function" ? await revalidate() : revalidate;
+  return typeof val === "number" && val < 1;
 }
 
+const { createBailoutProxy } = require("./bailout-proxy.js");
+
 /**
  * Compiles all static pages in the application.
  * Crawls the "src/" folder to collect all routes, resolves dynamic path segments,
  * mock-renders them inside a server context, and serializes successful static renders
  * into RSC JSON payloads.
  */
-async function buildStaticPages() {
+async function buildStaticPages(onProgress = null) {
   const srcFolder = path.resolve(process.cwd(), "src");
 
   /**
@@ -95,8 +102,32 @@ async function buildStaticPages() {
     const entries = readdirSync(currentPath, { withFileTypes: true });
     const pages = [];
 
+    // 🛡️ Descubrir layout en esta carpeta si existe
+    const layoutExtensions = [".tsx", ".jsx", ".ts", ".js"];
+    for (const ext of layoutExtensions) {
+      const candidateLayout = path.join(currentPath, `layout${ext}`);
+      if (existsSync(candidateLayout)) {
+        const routePath = segments.length ? "/" + segments.join("/") : "/";
+        const { resolveLayoutFunctionsConfig } = require("./layout-functions");
+        const layoutConfig = await resolveLayoutFunctionsConfig(candidateLayout, params);
+        if (!layoutConfig.isDynamic) {
+          staticLayouts.set(routePath, {
+            folderPath: currentPath,
+            layoutPath: candidateLayout,
+            routePath,
+            segments,
+            params,
+          });
+        }
+        break;
+      }
+    }
+
     for (const entry of entries) {
       if (entry.isDirectory()) {
+        if (entry.name.startsWith("_")) {
+          continue;
+        }
         if (entry.name.startsWith("(") && entry.name.endsWith(")")) {
           pages.push(
             ...(await collectPages(
@@ -134,22 +165,26 @@ async function buildStaticPages() {
             segments.length,
           );
 
-          let dynamic, getStaticPaths;
+          let revalidate, getStaticPaths;
           if (pageFunctionsPath) {
             const module = await importModule(pageFunctionsPath);
             getStaticPaths = module.getStaticPaths;
-            dynamic = module.dynamic;
+            revalidate = module.revalidate;
           }
           const isLocalPage =
             pagePath && path.dirname(pagePath) === dynamicPath;
-          if (isLocalPage && !dynamic?.()) {
-            console.log(
-              `Found optional catch-all route: ${segments.join("/") ?? ""
-              }/[[...${paramName}]]`,
-            );
+          if (isLocalPage && !(await isDynamicRoute(revalidate))) {
+            if (process.env.DINOU_DEBUG) {
+              console.log(
+                `Found optional catch-all route: ${segments.join("/") ?? ""
+                }/[[...${paramName}]]`,
+              );
+            }
             try {
               if (getStaticPaths) {
-                const paths = await getStaticPaths();
+                const paths = await (typeof getStaticPaths === "function"
+                  ? getStaticPaths()
+                  : getStaticPaths);
                 for (const pathItem of paths) {
                   // 1. Preparation of Structure and Extraction
                   const currentStructure = [...dynamicStructure, paramName];
@@ -275,22 +310,26 @@ async function buildStaticPages() {
             segments.length,
           );
 
-          let dynamic, getStaticPaths;
+          let revalidate, getStaticPaths;
           if (pageFunctionsPath) {
             const module = await importModule(pageFunctionsPath);
             getStaticPaths = module.getStaticPaths;
-            dynamic = module.dynamic;
+            revalidate = module.revalidate;
           }
           const isLocalPage =
             pagePath && path.dirname(pagePath) === dynamicPath;
-          if (isLocalPage && !dynamic?.()) {
-            console.log(
-              `Found catch-all route: ${segments.join("/") ?? ""
-              }/[...${paramName}]`,
-            );
+          if (isLocalPage && !(await isDynamicRoute(revalidate))) {
+            if (process.env.DINOU_DEBUG) {
+              console.log(
+                `Found catch-all route: ${segments.join("/") ?? ""
+                }/[...${paramName}]`,
+              );
+            }
             try {
               if (getStaticPaths) {
-                const paths = await getStaticPaths();
+                const paths = await (typeof getStaticPaths === "function"
+                  ? getStaticPaths()
+                  : getStaticPaths);
                 for (const pathItem of paths) {
                   const currentStructure = [...dynamicStructure, paramName];
                   const isObject =
@@ -379,22 +418,26 @@ async function buildStaticPages() {
             segments.length,
           );
 
-          let dynamic, getStaticPaths;
+          let revalidate, getStaticPaths;
           if (pageFunctionsPath) {
             const module = await importModule(pageFunctionsPath);
             getStaticPaths = module.getStaticPaths;
-            dynamic = module.dynamic;
+            revalidate = module.revalidate;
           }
           const isLocalPage =
             pagePath && path.dirname(pagePath) === dynamicPath;
-          if (isLocalPage && !dynamic?.()) {
-            console.log(
-              `Found optional dynamic route: ${segments.join("/") ?? ""
-              }/[[${paramName}]]`,
-            );
+          if (isLocalPage && !(await isDynamicRoute(revalidate))) {
+            if (process.env.DINOU_DEBUG) {
+              console.log(
+                `Found optional dynamic route: ${segments.join("/") ?? ""
+                }/[[${paramName}]]`,
+              );
+            }
             try {
               if (getStaticPaths) {
-                const paths = await getStaticPaths();
+                const paths = await (typeof getStaticPaths === "function"
+                  ? getStaticPaths()
+                  : getStaticPaths);
                 for (const pathItem of paths) {
                   // 1. Preparation of Structure and Extraction
                   const currentStructure = [...dynamicStructure, paramName];
@@ -502,20 +545,50 @@ async function buildStaticPages() {
           );
           let dynamic;
           let getStaticPaths;
+          let revalidate;
           if (pageFunctionsPath) {
             const module = await importModule(pageFunctionsPath);
             getStaticPaths = module.getStaticPaths;
-            dynamic = module.dynamic;
+            revalidate = module.revalidate;
+          }
+          const { getLayoutFunctionsPath } = require("./layout-functions");
+          const lfPath = getLayoutFunctionsPath(dynamicPath);
+          if (lfPath) {
+            const lmod = await importModule(lfPath);
+            const lmodGetStaticPaths = lmod.getStaticPaths || lmod.default?.getStaticPaths;
+            const lmodRevalidate = lmod.revalidate || lmod.default?.revalidate;
+            if (!getStaticPaths && lmodGetStaticPaths) {
+              getStaticPaths = lmodGetStaticPaths;
+            }
+            if (revalidate === undefined && lmodRevalidate !== undefined) {
+              revalidate = lmodRevalidate;
+            }
           }
           const isLocalPage =
             pagePath && path.dirname(pagePath) === dynamicPath;
-          if (isLocalPage && !dynamic?.()) {
-            console.log(
-              `Found dynamic route: ${segments.join("/") ?? ""}/[${paramName}]`,
-            );
+          const [layoutPath] = getFilePathAndDynamicParams(
+            segments,
+            {},
+            dynamicPath,
+            "layout",
+            true,
+            true,
+            undefined,
+            segments.length,
+          );
+          const hasLocalLayout =
+            layoutPath && path.dirname(layoutPath) === dynamicPath;
+          if ((isLocalPage || hasLocalLayout) && !(await isDynamicRoute(revalidate))) {
+            if (process.env.DINOU_DEBUG) {
+              console.log(
+                `Found dynamic route: ${segments.join("/") ?? ""}/[${paramName}]`,
+              );
+            }
             try {
               if (getStaticPaths) {
-                const paths = await getStaticPaths();
+                const paths = await (typeof getStaticPaths === "function"
+                  ? getStaticPaths()
+                  : getStaticPaths);
                 for (const pathItem of paths) {
                   const currentStructure = [...dynamicStructure, paramName];
                   const isObject =
@@ -598,19 +671,21 @@ async function buildStaticPages() {
               undefined,
               segments.length,
             );
-            let dynamic;
+            let revalidate;
             let getStaticPaths;
             if (pageFunctionsPath) {
               const module = await importModule(pageFunctionsPath);
               getStaticPaths = module.getStaticPaths;
-              dynamic = module.dynamic;
+              revalidate = module.revalidate;
             }
             const isLocalPage =
               pagePath && path.dirname(pagePath) === dynamicPath;
-            if (isLocalPage && !dynamic?.()) {
+            if (isLocalPage && !(await isDynamicRoute(revalidate))) {
               try {
                 if (getStaticPaths) {
-                  const paths = await getStaticPaths();
+                  const paths = await (typeof getStaticPaths === "function"
+                    ? getStaticPaths()
+                    : getStaticPaths);
                   for (const pathItem of paths) {
                     const currentStructure = dynamicStructure;
                     const isObject =
@@ -707,19 +782,30 @@ async function buildStaticPages() {
       undefined,
       segments.length,
     );
-    let dynamic;
+    let revalidate;
     if (pageFunctionsPath) {
-      const module = await importModule(pageFunctionsPath);
-      dynamic = module.dynamic;
+      try {
+        const module = await importModule(pageFunctionsPath);
+        revalidate = module.revalidate;
+      } catch (e) {}
     }
 
-    if (pagePath && !dynamic?.() && !doNotPushAtEnd) {
+    const isPpr = await resolveBuildPprForRoute(segments, pagePath, pageFunctionsPath, srcFolder);
+
+    if (pagePath && (!(await isDynamicRoute(revalidate)) || isPpr) && !doNotPushAtEnd) {
       pages.push({
         path: currentPath,
         segments,
         params: dParams,
+        ppr: isPpr,
       });
-      console.log(`Found static route: ${segments.join("/") || "/"}`);
+      const routeName = segments.join("/") ? "/" + segments.join("/") : "/";
+      if (typeof onProgress === "function") {
+        onProgress({ phase: "crawling", route: routeName, count: pages.length });
+      }
+      if (process.env.DINOU_DEBUG) {
+        console.log(`Found static route: ${routeName}${isPpr ? " (PPR)" : ""}`);
+      }
     }
 
     return pages;
@@ -728,9 +814,14 @@ async function buildStaticPages() {
   // Crawl complete, start rendering and serialization loop for all discovered static pages
   const pages = await collectPages(srcFolder);
 
-  for (const { path: folderPath, segments, params } of pages) {
+  let pageIdx = 0;
+  for (const { path: folderPath, segments, params, ppr: pageIsPpr } of pages) {
+    pageIdx++;
     try {
       const reqPath = segments.length ? "/" + segments.join("/") + "/" : "/";
+      if (typeof onProgress === "function") {
+        onProgress({ phase: "discovering", route: reqPath, current: pageIdx, total: pages.length });
+      }
       // ====================================================================
       // 1. MOCK RES: Fulfilling ResponseProxy interface
       // ====================================================================
@@ -780,9 +871,11 @@ async function buildStaticPages() {
           this._redirectUrl = url;
 
           // Log warning because a redirect in SSG is usually problematic
-          console.warn(
-            `⚠️ [SSG] Redirect detected in ${reqPath} -> ${url} (${status})`,
-          );
+          if (process.env.DINOU_DEBUG) {
+            console.warn(
+              `⚠️ [SSG] Redirect detected in ${reqPath} -> ${url} (${status})`,
+            );
+          }
         },
       };
 
@@ -826,7 +919,8 @@ async function buildStaticPages() {
       let revalidate;
       let cacheTags = [];
       const jsx = await requestStorage.run(mockContext, async () => {
-        const [pagePath] = getFilePathAndDynamicParams(
+        return await runWithPprContext({ isPpr: Boolean(pageIsPpr) }, async () => {
+          const [pagePath] = getFilePathAndDynamicParams(
           segments,
           {},
           folderPath,
@@ -858,15 +952,18 @@ async function buildStaticPages() {
           const pageFunctionsModule = await importModule(pageFunctionsPath);
           const getProps = pageFunctionsModule.getProps;
           revalidate = pageFunctionsModule.revalidate;
-          if (pageFunctionsModule.getCacheTags) {
+          const rawTags = pageFunctionsModule.getCacheTags ?? pageFunctionsModule.default?.getCacheTags;
+          if (typeof rawTags === "function") {
             try {
-              cacheTags = await pageFunctionsModule.getCacheTags(params);
+              cacheTags = await rawTags(params);
             } catch (e) {
               console.error("Error running getCacheTags in buildStaticPages:", e);
             }
+          } else if (Array.isArray(rawTags)) {
+            cacheTags = rawTags;
           }
           pageFunctionsProps = await getProps?.(params);
-          props = { ...props, ...(pageFunctionsProps?.page ?? {}) };
+          props = { ...props, ...(pageFunctionsProps ?? {}) };
         }
 
         let jsx = React.createElement(Page, props);
@@ -902,19 +999,30 @@ async function buildStaticPages() {
                 false,
               )[0];
               const updatedSlots = {};
-              for (const [slotName, slotElement] of Object.entries(slots)) {
-                const alreadyFoundPath = slotElement.props?.__modulePath;
-                const slotElementWithModule = {
-                  ...slotElement,
-                  __modulePath: alreadyFoundPath ?? null,
-                };
-
+              for (const [slotName, slotValue] of Object.entries(slots)) {
                 let updatedSlotElement;
+                const slotFilePath = slotValue?.slotPath || slotValue?.props?.__modulePath;
+                const slotParams = slotValue?.slotParams || slotValue?.props?.params || {};
+
                 try {
-                  await asyncRenderJSXToClientJSX(slotElementWithModule);
-                  updatedSlotElement = slotElementWithModule;
+                  let elementToRender;
+                  if (slotValue && slotValue.slotPath) {
+                    const slotModule = await importModule(slotValue.slotPath);
+                    const Slot = slotModule.default ?? slotModule;
+                    elementToRender = React.createElement(Slot, {
+                      params: slotParams,
+                      key: slotName,
+                      __modulePath: slotValue.slotPath,
+                    });
+                  } else {
+                    elementToRender = {
+                      ...slotValue,
+                      __modulePath: slotFilePath ?? null,
+                    };
+                  }
+                  await asyncRenderJSXToClientJSX(elementToRender);
+                  updatedSlotElement = elementToRender;
                 } catch (e) {
-                  const slotFilePath = alreadyFoundPath;
                   if (slotFilePath) {
                     const realSlotFolder = path.dirname(slotFilePath);
                     const [slotErrorPath, slotErrorParams] =
@@ -959,13 +1067,12 @@ async function buildStaticPages() {
                 }
                 updatedSlots[slotName] = updatedSlotElement;
               }
+              const layoutProps = await getLayoutProps(layoutPath, dParams);
               let props = {
                 params: dParams,
                 ...updatedSlots,
+                ...(layoutProps ?? {}),
               };
-              if (index === layouts.length - 1 || resetLayoutPath) {
-                props = { ...props, ...(pageFunctionsProps?.layout ?? {}) };
-              }
               jsx = React.createElement(Layout, props, jsx);
               jsx = { ...jsx, __modulePath: layoutPath };
               if (resetLayoutPath) {
@@ -978,16 +1085,19 @@ async function buildStaticPages() {
 
         // Render the layout-nested React element tree to client-side RSC JSON format
         return await asyncRenderJSXToClientJSX(jsx);
+        });
       });
 
-      if (!isStatic) {
+      if (!isStatic && !pageIsPpr) {
         // ❌ DO NOT save file.
         // Will behave as pure SSR at runtime.
-        console.log(
-          `Skipping static generation for ${segments.join(
-            "/",
-          )} due to dynamic usage.`,
-        );
+        if (process.env.DINOU_DEBUG) {
+          console.log(
+            `Skipping static generation for ${segments.join(
+              "/",
+            )} due to dynamic usage.`,
+          );
+        }
         continue;
       }
 
@@ -996,20 +1106,27 @@ async function buildStaticPages() {
         cookies: mockRes._cookies,
       };
 
+      const holes = pageIsPpr ? getRegisteredHoles() : [];
       staticRoutes.add(reqPath);
       staticMetadata.set(reqPath, {
-        revalidate: revalidate?.(),
+        revalidate: typeof revalidate === "function" ? await revalidate() : revalidate,
         effects: sideEffects,
         tags: cacheTags,
+        ppr: Boolean(pageIsPpr),
+        holes,
       });
-      console.log(`Registered static page at ${reqPath}`);
+      if (process.env.DINOU_DEBUG) {
+        console.log(`Registered static page at ${reqPath}${pageIsPpr ? " (PPR)" : ""}`);
+      }
     } catch (err) {
       console.error(`Error building page ${segments.join("/")}:`, err);
       continue;
     }
   }
 
-  console.log(`Static site generated with ${pages.length} pages`);
+  if (process.env.DINOU_DEBUG) {
+    console.log(`Static site generated with ${pages.length} pages`);
+  }
 }
 
 /**
@@ -1031,7 +1148,8 @@ async function buildStaticPage(reqPath, isDynamic = null) {
         segment &&
         ((segment.startsWith("(") && segment.endsWith(")")) ||
           (segment.startsWith("[") && segment.endsWith("]")) ||
-          segment.startsWith("@"));
+          segment.startsWith("@") ||
+          segment.startsWith("_"));
       const currentPath = path.join(folderPath, segment);
       if (existsSync(currentPath) && !isRouterSyntaxInSegment) {
         folderPath = currentPath;
@@ -1110,9 +1228,11 @@ async function buildStaticPage(reqPath, isDynamic = null) {
         this._redirectUrl = url;
 
         // We log a warning because a redirect in SSG is usually problematic
-        console.warn(
-          `⚠️ [SSG] Redirect detected in ${reqPath} -> ${url} (${status})`,
-        );
+        if (process.env.DINOU_DEBUG) {
+          console.warn(
+            `⚠️ [SSG] Redirect detected in ${reqPath} -> ${url} (${status})`,
+          );
+        }
       },
     };
 
@@ -1155,6 +1275,7 @@ async function buildStaticPage(reqPath, isDynamic = null) {
 
     let revalidate;
     let cacheTags = [];
+    let pageIsPpr = false;
     const jsx = await requestStorage.run(mockContext, async () => {
       const [pagePath, dParams] = getFilePathAndDynamicParams(
         segments,
@@ -1171,8 +1292,6 @@ async function buildStaticPage(reqPath, isDynamic = null) {
 
       const pageModule = await importModule(pagePath);
       const Page = pageModule.default ?? pageModule;
-
-      let props = { params: dParams };
       const [pageFunctionsPath] = getFilePathAndDynamicParams(
         segments,
         {},
@@ -1184,22 +1303,30 @@ async function buildStaticPage(reqPath, isDynamic = null) {
         segments.length,
       );
 
+      pageIsPpr = await resolveBuildPprForRoute(segments, pagePath, pageFunctionsPath, srcFolder);
+
+      return await runWithPprContext({ isPpr: pageIsPpr }, async () => {
+        let props = { params: dParams };
+
       let pageFunctionsProps;
       if (pageFunctionsPath) {
         const pageFunctionsModule = await importModule(pageFunctionsPath);
         const getProps = pageFunctionsModule.getProps;
-        if (isDynamic && (isDynamic.value = pageFunctionsModule.dynamic?.()))
-          return;
         revalidate = pageFunctionsModule.revalidate;
-        if (pageFunctionsModule.getCacheTags) {
+        if (isDynamic && (isDynamic.value = await isDynamicRoute(revalidate)))
+          return;
+        const rawTags = pageFunctionsModule.getCacheTags ?? pageFunctionsModule.default?.getCacheTags;
+        if (typeof rawTags === "function") {
           try {
-            cacheTags = await pageFunctionsModule.getCacheTags(dParams);
+            cacheTags = await rawTags(dParams);
           } catch (e) {
             console.error("Error running getCacheTags:", e);
           }
+        } else if (Array.isArray(rawTags)) {
+          cacheTags = rawTags;
         }
         pageFunctionsProps = await getProps?.(dParams);
-        props = { ...props, ...(pageFunctionsProps?.page ?? {}) };
+        props = { ...props, ...(pageFunctionsProps ?? {}) };
       }
 
       let jsx = React.createElement(Page, props);
@@ -1233,19 +1360,30 @@ async function buildStaticPage(reqPath, isDynamic = null) {
               false,
             )[0];
             const updatedSlots = {};
-            for (const [slotName, slotElement] of Object.entries(slots)) {
-              const alreadyFoundPath = slotElement.props?.__modulePath;
-              const slotElementWithModule = {
-                ...slotElement,
-                __modulePath: alreadyFoundPath ?? null,
-              };
-
+            for (const [slotName, slotValue] of Object.entries(slots)) {
               let updatedSlotElement;
+              const slotFilePath = slotValue?.slotPath || slotValue?.props?.__modulePath;
+              const slotParams = slotValue?.slotParams || slotValue?.props?.params || {};
+
               try {
-                await asyncRenderJSXToClientJSX(slotElementWithModule);
-                updatedSlotElement = slotElementWithModule;
+                let elementToRender;
+                if (slotValue && slotValue.slotPath) {
+                  const slotModule = await importModule(slotValue.slotPath);
+                  const Slot = slotModule.default ?? slotModule;
+                  elementToRender = React.createElement(Slot, {
+                    params: slotParams,
+                    key: slotName,
+                    __modulePath: slotValue.slotPath,
+                  });
+                } else {
+                  elementToRender = {
+                    ...slotValue,
+                    __modulePath: slotFilePath ?? null,
+                  };
+                }
+                await asyncRenderJSXToClientJSX(elementToRender);
+                updatedSlotElement = elementToRender;
               } catch (e) {
-                const slotFilePath = alreadyFoundPath;
                 if (slotFilePath) {
                   const realSlotFolder = path.dirname(slotFilePath);
                   const [slotErrorPath, slotErrorParams] =
@@ -1294,12 +1432,11 @@ async function buildStaticPage(reqPath, isDynamic = null) {
               params: dParams,
               ...updatedSlots,
             };
-            if (index === layouts.length - 1 || resetLayoutPath) {
-              layoutProps = {
-                ...layoutProps,
-                ...(pageFunctionsProps?.layout ?? {}),
-              };
-            }
+            const customLayoutProps = await getLayoutProps(layoutPath, dParams);
+            layoutProps = {
+              ...layoutProps,
+              ...(customLayoutProps ?? {}),
+            };
             jsx = React.createElement(Layout, layoutProps, jsx);
             jsx = { ...jsx, __modulePath: layoutPath };
             if (resetLayoutPath) {
@@ -1310,17 +1447,20 @@ async function buildStaticPage(reqPath, isDynamic = null) {
         }
       }
 
-      return await asyncRenderJSXToClientJSX(jsx);
+        return await asyncRenderJSXToClientJSX(jsx);
+      });
     });
 
-    if (!isStatic) {
+    if (!isStatic && !pageIsPpr) {
       // ❌ DO NOT save file.
       // It will behave as pure SSR at runtime.
-      console.log(
-        `Skipping static generation for ${segments.join(
-          "/",
-        )} due to dynamic usage.`,
-      );
+      if (process.env.DINOU_DEBUG) {
+        console.log(
+          `Skipping static generation for ${segments.join(
+            "/",
+          )} due to dynamic usage.`,
+        );
+      }
       if (isDynamic) {
         isDynamic.value = true;
       }
@@ -1332,13 +1472,16 @@ async function buildStaticPage(reqPath, isDynamic = null) {
       cookies: mockRes._cookies,
     };
 
+    const holes = pageIsPpr ? getRegisteredHoles() : [];
     staticRoutes.add(reqPath);
     staticMetadata.set(reqPath, {
-      revalidate: revalidate?.(),
+      revalidate: typeof revalidate === "function" ? await revalidate() : revalidate,
       effects: sideEffects,
       tags: cacheTags,
+      ppr: pageIsPpr,
+      holes,
     });
-    console.warn(`Registered rebuilt static page at ${reqPath}`);
+    console.warn(`Registered rebuilt static page at ${reqPath}${pageIsPpr ? " (PPR)" : ""}`);
   } catch (error) {
     console.error(`Error building page ${reqPath}:`, error);
     throw error;
@@ -1350,7 +1493,14 @@ function getStaticPaths() {
 }
 
 function getStaticMetadata(reqPath) {
-  return staticMetadata.get(reqPath);
+  if (!reqPath) return null;
+  const noSlash = reqPath.endsWith("/") ? reqPath.slice(0, -1) : reqPath;
+  const withSlash = noSlash + "/";
+  return staticMetadata.get(reqPath) || staticMetadata.get(noSlash) || staticMetadata.get(withSlash) || null;
+}
+
+function getStaticLayouts() {
+  return Array.from(staticLayouts.values());
 }
 
 module.exports = {
@@ -1358,4 +1508,6 @@ module.exports = {
   buildStaticPage,
   getStaticPaths,
   getStaticMetadata,
+  getStaticLayouts,
 };
+