@lolyjs/core 0.2.0-alpha.30 → 0.2.0-alpha.31

package/dist/cli.js

@@ -10741,6 +10741,18 @@ function writeRoutesManifest({
   fs6.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
 }
 
+// modules/router/index.types.ts
+var RedirectResponse = class {
+  constructor(destination, permanent = false) {
+    this.destination = destination;
+    this.permanent = permanent;
+  }
+};
+var NotFoundResponse = class {
+  constructor() {
+  }
+};
+
 // modules/router/loader-routes.ts
 import fs7 from "fs";
 import path7 from "path";
@@ -13117,16 +13129,6 @@ async function runRouteServerHook(route, ctx) {
 // modules/server/handlers/response.ts
 function handleDataResponse(res, loaderResult, theme, layoutProps, pageProps, error, message) {
   res.setHeader("Content-Type", "application/json; charset=utf-8");
-  if (loaderResult.redirect) {
-    res.statusCode = 200;
-    res.end(JSON.stringify({ redirect: loaderResult.redirect }));
-    return;
-  }
-  if (loaderResult.notFound) {
-    res.statusCode = 404;
-    res.end(JSON.stringify({ notFound: true }));
-    return;
-  }
   const response = {
     // Combined props for backward compatibility
     props: loaderResult.props ?? {},
@@ -13301,6 +13303,145 @@ function mergeMetadata(base, override) {
 function isDataRequest(req) {
   return req.query && req.query.__fw_data === "1" || req.headers["x-fw-data"] === "1";
 }
+async function renderNotFoundPage(notFoundPage, req, res, urlPath, finalUrlPath, routerData, assetManifest, theme, clientJsPath, clientCssPath, faviconInfo, projectRoot, skipLayoutHooks, errorPage, routeChunks, env, config) {
+  const ctx = {
+    req,
+    res,
+    params: {},
+    pathname: urlPath,
+    locals: {},
+    Redirect: (destination, permanent = false) => new RedirectResponse(destination, permanent),
+    NotFound: () => new NotFoundResponse()
+  };
+  const layoutProps = {};
+  if (!skipLayoutHooks && notFoundPage.layoutServerHooks && notFoundPage.layoutServerHooks.length > 0) {
+    for (let i = 0; i < notFoundPage.layoutServerHooks.length; i++) {
+      const layoutServerHook = notFoundPage.layoutServerHooks[i];
+      const layoutMiddlewares = notFoundPage.layoutMiddlewares?.[i] || [];
+      if (layoutMiddlewares.length > 0) {
+        for (const mw of layoutMiddlewares) {
+          try {
+            await Promise.resolve(
+              mw(ctx, async () => {
+              })
+            );
+          } catch (error) {
+            const reqLogger = getRequestLogger(req);
+            const layoutFile = notFoundPage.layoutFiles[i];
+            const relativeLayoutPath = layoutFile ? path19.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            reqLogger.error("Layout middleware failed for not-found page", error instanceof Error ? error : new Error(String(error)), {
+              layoutIndex: i,
+              layoutFile: relativeLayoutPath
+            });
+            throw error;
+          }
+          if (ctx.res.headersSent) {
+            return;
+          }
+        }
+      }
+      if (layoutServerHook) {
+        try {
+          const layoutResult = await layoutServerHook(ctx);
+          if (layoutResult instanceof RedirectResponse) {
+            handleRedirect(res, { destination: layoutResult.destination, permanent: layoutResult.permanent });
+            return;
+          }
+          if (layoutResult instanceof NotFoundResponse) {
+            handleNotFound(res, urlPath);
+            return;
+          }
+          if (layoutResult.props) {
+            Object.assign(layoutProps, layoutResult.props);
+          }
+        } catch (error) {
+          const reqLogger = getRequestLogger(req);
+          const layoutFile = notFoundPage.layoutFiles[i];
+          const relativeLayoutPath = layoutFile ? path19.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+          reqLogger.warn("Layout server hook failed for not-found page", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0,
+            layoutFile: relativeLayoutPath,
+            layoutIndex: i
+          });
+        }
+      }
+    }
+  }
+  let loaderResult = await runRouteServerHook(notFoundPage, ctx);
+  if (loaderResult instanceof RedirectResponse) {
+    handleRedirect(res, { destination: loaderResult.destination, permanent: loaderResult.permanent });
+    return;
+  }
+  if (loaderResult instanceof NotFoundResponse) {
+    handleNotFound(res, urlPath);
+    return;
+  }
+  const notFoundLoaderResult = loaderResult;
+  if (!notFoundLoaderResult.theme) {
+    notFoundLoaderResult.theme = theme;
+  }
+  const combinedProps = {
+    ...layoutProps,
+    ...notFoundLoaderResult.props || {}
+  };
+  const combinedLoaderResult = {
+    ...notFoundLoaderResult,
+    props: combinedProps
+  };
+  const initialData = buildInitialData(finalUrlPath, {}, combinedLoaderResult);
+  const appTree = buildAppTree(notFoundPage, {}, initialData.props);
+  initialData.notFound = true;
+  const nonce = res.locals.nonce || void 0;
+  const entrypointFiles = [];
+  if (assetManifest?.entrypoints?.client) {
+    entrypointFiles.push(...assetManifest.entrypoints.client.map((file) => `${STATIC_PATH}/${file}`));
+  }
+  const documentTree = createDocumentTree({
+    appTree,
+    initialData,
+    routerData,
+    meta: combinedLoaderResult.metadata ?? null,
+    titleFallback: "Not found",
+    descriptionFallback: "Loly demo",
+    chunkHref: null,
+    entrypointFiles,
+    theme,
+    clientJsPath,
+    clientCssPath,
+    nonce,
+    faviconPath: faviconInfo?.path || null,
+    faviconType: faviconInfo?.type || null
+  });
+  let didError = false;
+  const { pipe, abort } = renderToPipeableStream(documentTree, {
+    onShellReady() {
+      if (didError || res.headersSent) return;
+      res.statusCode = 404;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      pipe(res);
+    },
+    onShellError(err) {
+      didError = true;
+      const reqLogger = getRequestLogger(req);
+      reqLogger.error("SSR shell error", err, { route: "not-found" });
+      if (!res.headersSent && errorPage) {
+        renderErrorPageWithStream(errorPage, req, res, err, routeChunks || {}, theme, projectRoot, env, config, notFoundPage);
+      } else if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end("<!doctype html><h1>Internal Server Error</h1>");
+      }
+      abort();
+    },
+    onError(err) {
+      didError = true;
+      const reqLogger = getRequestLogger(req);
+      reqLogger.error("SSR error", err, { route: "not-found" });
+    }
+  });
+  req.on("close", () => abort());
+}
 async function handlePageRequest(options) {
   try {
     await handlePageRequestInternal(options);
@@ -13308,7 +13449,7 @@ async function handlePageRequest(options) {
     const { errorPage, req, res, routeChunks, theme, projectRoot } = options;
     const reqLogger = getRequestLogger(req);
     if (errorPage) {
-      await renderErrorPageWithStream(errorPage, req, res, error, routeChunks || {}, theme, projectRoot, options.env, options.config);
+      await renderErrorPageWithStream(errorPage, req, res, error, routeChunks || {}, theme, projectRoot, options.env, options.config, options.notFoundPage);
     } else {
       reqLogger.error("Unhandled error in page request", error, {
         urlPath: options.urlPath,
@@ -13418,135 +13559,25 @@ async function handlePageRequestInternal(options) {
       return;
     }
     if (notFoundPage) {
-      const ctx2 = {
+      await renderNotFoundPage(
+        notFoundPage,
         req,
         res,
-        params: {},
-        pathname: urlPath,
-        locals: {}
-      };
-      const layoutProps2 = {};
-      if (!skipLayoutHooks && notFoundPage.layoutServerHooks && notFoundPage.layoutServerHooks.length > 0) {
-        for (let i = 0; i < notFoundPage.layoutServerHooks.length; i++) {
-          const layoutServerHook = notFoundPage.layoutServerHooks[i];
-          const layoutMiddlewares = notFoundPage.layoutMiddlewares?.[i] || [];
-          if (layoutMiddlewares.length > 0) {
-            for (const mw of layoutMiddlewares) {
-              try {
-                await Promise.resolve(
-                  mw(ctx2, async () => {
-                  })
-                );
-              } catch (error) {
-                const reqLogger2 = getRequestLogger(req);
-                const layoutFile = notFoundPage.layoutFiles[i];
-                const relativeLayoutPath = layoutFile ? path19.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
-                reqLogger2.error("Layout middleware failed for not-found page", error instanceof Error ? error : new Error(String(error)), {
-                  layoutIndex: i,
-                  layoutFile: relativeLayoutPath
-                });
-                throw error;
-              }
-              if (ctx2.res.headersSent) {
-                return;
-              }
-            }
-          }
-          if (layoutServerHook) {
-            try {
-              const layoutResult = await layoutServerHook(ctx2);
-              if (layoutResult.props) {
-                Object.assign(layoutProps2, layoutResult.props);
-              }
-            } catch (error) {
-              const reqLogger2 = getRequestLogger(req);
-              const layoutFile = notFoundPage.layoutFiles[i];
-              const relativeLayoutPath = layoutFile ? path19.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
-              reqLogger2.warn("Layout server hook failed for not-found page", {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : void 0,
-                layoutFile: relativeLayoutPath,
-                layoutIndex: i
-              });
-            }
-          }
-        }
-      }
-      let loaderResult2 = await runRouteServerHook(notFoundPage, ctx2);
-      if (!loaderResult2.theme) {
-        loaderResult2.theme = theme;
-      }
-      const combinedProps2 = {
-        ...layoutProps2,
-        ...loaderResult2.props || {}
-      };
-      const combinedLoaderResult2 = {
-        ...loaderResult2,
-        props: combinedProps2
-      };
-      if (isDataReq) {
-        const pagePropsOnly = loaderResult2.props || {};
-        handleDataResponse(
-          res,
-          combinedLoaderResult2,
-          theme,
-          skipLayoutHooks ? null : Object.keys(layoutProps2).length > 0 ? layoutProps2 : null,
-          pagePropsOnly
-        );
-        return;
-      }
-      const initialData2 = buildInitialData(finalUrlPath, {}, combinedLoaderResult2);
-      const appTree2 = buildAppTree(notFoundPage, {}, initialData2.props);
-      initialData2.notFound = true;
-      const nonce2 = res.locals.nonce || void 0;
-      const entrypointFiles2 = [];
-      if (assetManifest?.entrypoints?.client) {
-        entrypointFiles2.push(...assetManifest.entrypoints.client.map((file) => `${STATIC_PATH}/${file}`));
-      }
-      const documentTree2 = createDocumentTree({
-        appTree: appTree2,
-        initialData: initialData2,
+        urlPath,
+        finalUrlPath,
         routerData,
-        meta: combinedLoaderResult2.metadata ?? null,
-        titleFallback: "Not found",
-        descriptionFallback: "Loly demo",
-        chunkHref: null,
-        entrypointFiles: entrypointFiles2,
+        assetManifest,
         theme,
         clientJsPath,
         clientCssPath,
-        nonce: nonce2,
-        faviconPath: faviconInfo?.path || null,
-        faviconType: faviconInfo?.type || null
-      });
-      let didError2 = false;
-      const { pipe: pipe2, abort: abort2 } = renderToPipeableStream(documentTree2, {
-        onShellReady() {
-          if (didError2 || res.headersSent) return;
-          res.statusCode = 404;
-          res.setHeader("Content-Type", "text/html; charset=utf-8");
-          pipe2(res);
-        },
-        onShellError(err) {
-          didError2 = true;
-          const reqLogger2 = getRequestLogger(req);
-          reqLogger2.error("SSR shell error", err, { route: "not-found" });
-          if (!res.headersSent && errorPage) {
-            renderErrorPageWithStream(errorPage, req, res, err, routeChunks, theme, projectRoot, env, config);
-          } else if (!res.headersSent) {
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "text/html; charset=utf-8");
-            res.end("<!doctype html><h1>Internal Server Error</h1>");
-          }
-          abort2();
-        },
-        onError(err) {
-          didError2 = true;
-          const reqLogger2 = getRequestLogger(req);
-          reqLogger2.error("SSR error", err, { route: "not-found" });
-        }
-      });
-      req.on("close", () => abort2());
+        faviconInfo,
+        projectRoot,
+        skipLayoutHooks,
+        errorPage,
+        routeChunks,
+        env,
+        config
+      );
       return;
     }
     handleNotFound(res, urlPath);
@@ -13559,7 +13590,9 @@ async function handlePageRequestInternal(options) {
     res,
     params: sanitizedParams,
     pathname: urlPath,
-    locals: {}
+    locals: {},
+    Redirect: (destination, permanent = false) => new RedirectResponse(destination, permanent),
+    NotFound: () => new NotFoundResponse()
   };
   await runRouteMiddlewares(route, ctx);
   if (res.headersSent) {
@@ -13597,6 +13630,48 @@ async function handlePageRequestInternal(options) {
       if (layoutServerHook) {
         try {
           const layoutResult = await layoutServerHook(ctx);
+          if (layoutResult instanceof RedirectResponse) {
+            if (isDataReq) {
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json; charset=utf-8");
+              res.end(JSON.stringify({ redirect: { destination: layoutResult.destination, permanent: layoutResult.permanent } }));
+            } else {
+              handleRedirect(res, { destination: layoutResult.destination, permanent: layoutResult.permanent });
+            }
+            return;
+          }
+          if (layoutResult instanceof NotFoundResponse) {
+            if (isDataReq) {
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json; charset=utf-8");
+              res.end(JSON.stringify({ notFound: true }));
+            } else {
+              if (notFoundPage) {
+                await renderNotFoundPage(
+                  notFoundPage,
+                  req,
+                  res,
+                  urlPath,
+                  finalUrlPath,
+                  routerData,
+                  assetManifest,
+                  theme,
+                  clientJsPath,
+                  clientCssPath,
+                  faviconInfo,
+                  projectRoot,
+                  skipLayoutHooks,
+                  errorPage,
+                  routeChunks,
+                  env,
+                  config
+                );
+              } else {
+                handleNotFound(res, urlPath);
+              }
+            }
+            return;
+          }
           if (layoutResult.props) {
             Object.assign(layoutProps, layoutResult.props);
           }
@@ -13621,8 +13696,51 @@ async function handlePageRequestInternal(options) {
   let loaderResult;
   try {
     loaderResult = await runRouteServerHook(route, ctx);
-    if (!loaderResult.theme) {
-      loaderResult.theme = theme;
+    if (loaderResult instanceof RedirectResponse) {
+      if (isDataReq) {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ redirect: { destination: loaderResult.destination, permanent: loaderResult.permanent } }));
+      } else {
+        handleRedirect(res, { destination: loaderResult.destination, permanent: loaderResult.permanent });
+      }
+      return;
+    }
+    if (loaderResult instanceof NotFoundResponse) {
+      if (isDataReq) {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ notFound: true }));
+      } else {
+        if (notFoundPage) {
+          await renderNotFoundPage(
+            notFoundPage,
+            req,
+            res,
+            urlPath,
+            finalUrlPath,
+            routerData,
+            assetManifest,
+            theme,
+            clientJsPath,
+            clientCssPath,
+            faviconInfo,
+            projectRoot,
+            skipLayoutHooks,
+            errorPage,
+            routeChunks,
+            env,
+            config
+          );
+        } else {
+          handleNotFound(res, urlPath);
+        }
+      }
+      return;
+    }
+    const pageLoaderResult2 = loaderResult;
+    if (!pageLoaderResult2.theme) {
+      pageLoaderResult2.theme = theme;
     }
   } catch (error) {
     const relativePagePath = route.pageFile ? path19.relative(projectRoot || process.cwd(), route.pageFile) : "unknown";
@@ -13647,17 +13765,18 @@ async function handlePageRequestInternal(options) {
       return;
     } else {
       if (errorPage) {
-        await renderErrorPageWithStream(errorPage, req, res, error, routeChunks, theme, projectRoot, env, config);
+        await renderErrorPageWithStream(errorPage, req, res, error, routeChunks, theme, projectRoot, env, config, notFoundPage);
         return;
       } else {
         throw error;
       }
     }
   }
+  const pageLoaderResult = loaderResult;
   const combinedProps = {
     ...layoutProps,
     // Props from layouts (stable)
-    ...loaderResult.props || {}
+    ...pageLoaderResult.props || {}
     // Props from page (overrides layout)
   };
   let combinedMetadata = null;
@@ -13666,18 +13785,18 @@ async function handlePageRequestInternal(options) {
       combinedMetadata = mergeMetadata(combinedMetadata, layoutMeta);
     }
   }
-  if (loaderResult.metadata) {
-    combinedMetadata = mergeMetadata(combinedMetadata, loaderResult.metadata);
+  if (pageLoaderResult.metadata) {
+    combinedMetadata = mergeMetadata(combinedMetadata, pageLoaderResult.metadata);
   }
   const combinedLoaderResult = {
-    ...loaderResult,
+    ...pageLoaderResult,
     props: combinedProps,
     metadata: combinedMetadata,
     pathname: finalUrlPath
     // Include rewritten pathname for client-side matching
   };
   if (isDataReq) {
-    const pagePropsOnly = loaderResult.props || {};
+    const pagePropsOnly = pageLoaderResult.props || {};
     handleDataResponse(
       res,
       combinedLoaderResult,
@@ -13687,18 +13806,6 @@ async function handlePageRequestInternal(options) {
     );
     return;
   }
-  if (loaderResult.redirect) {
-    handleRedirect(res, loaderResult.redirect);
-    return;
-  }
-  if (loaderResult.notFound) {
-    if (isDataReq) {
-      res.status(200).json({ notFound: true });
-    } else {
-      handleNotFound(res, urlPath);
-    }
-    return;
-  }
   const initialData = buildInitialData(finalUrlPath, params, combinedLoaderResult);
   const appTree = buildAppTree(route, params, initialData.props);
   const chunkName = routeChunks[route.pattern];
@@ -13755,7 +13862,7 @@ async function handlePageRequestInternal(options) {
       }
       console.error("\u{1F4A1} This usually indicates a React rendering error\n");
       if (!res.headersSent && errorPage) {
-        renderErrorPageWithStream(errorPage, req, res, err, routeChunks, theme, projectRoot, env);
+        renderErrorPageWithStream(errorPage, req, res, err, routeChunks, theme, projectRoot, env, config, notFoundPage);
       } else if (!res.headersSent) {
         res.statusCode = 500;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -13777,7 +13884,7 @@ async function handlePageRequestInternal(options) {
     abort();
   });
 }
-async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks, theme, projectRoot, env = "dev", config) {
+async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks, theme, projectRoot, env = "dev", config, notFoundPage) {
   try {
     const isDataReq = isDataRequest(req);
     const skipLayoutHooks = isDataReq && req.headers["x-skip-layout-hooks"] === "true";
@@ -13786,7 +13893,9 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
       res,
       params: { error: String(error) },
       pathname: req.path,
-      locals: { error }
+      locals: { error },
+      Redirect: (destination, permanent = false) => new RedirectResponse(destination, permanent),
+      NotFound: () => new NotFoundResponse()
     };
     const faviconInfo = projectRoot && config ? getFaviconInfo(projectRoot, config.directories.static, env === "dev") : null;
     const layoutProps = {};
@@ -13819,6 +13928,26 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
         if (layoutServerHook) {
           try {
             const layoutResult = await layoutServerHook(ctx);
+            if (layoutResult instanceof RedirectResponse) {
+              if (isDataReq) {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json; charset=utf-8");
+                res.end(JSON.stringify({ redirect: { destination: layoutResult.destination, permanent: layoutResult.permanent } }));
+              } else {
+                handleRedirect(res, { destination: layoutResult.destination, permanent: layoutResult.permanent });
+              }
+              return;
+            }
+            if (layoutResult instanceof NotFoundResponse) {
+              if (isDataReq) {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json; charset=utf-8");
+                res.end(JSON.stringify({ notFound: true }));
+              } else {
+                handleNotFound(res, req.path);
+              }
+              return;
+            }
             if (layoutResult.props) {
               Object.assign(layoutProps, layoutResult.props);
             }
@@ -13836,22 +13965,69 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
       }
     }
     let loaderResult = await runRouteServerHook(errorPage, ctx);
-    if (!loaderResult.theme && theme) {
-      loaderResult.theme = theme;
+    if (loaderResult instanceof RedirectResponse) {
+      if (isDataReq) {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ redirect: { destination: loaderResult.destination, permanent: loaderResult.permanent } }));
+      } else {
+        handleRedirect(res, { destination: loaderResult.destination, permanent: loaderResult.permanent });
+      }
+      return;
+    }
+    if (loaderResult instanceof NotFoundResponse) {
+      if (isDataReq) {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ notFound: true }));
+      } else {
+        if (notFoundPage) {
+          const notFoundAssetManifest = env === "prod" && projectRoot ? loadAssetManifest(projectRoot) : null;
+          const notFoundClientJsPath = env === "dev" ? "/static/client.js" : projectRoot ? getClientJsPath(projectRoot) : "/static/client.js";
+          const notFoundClientCssPath = env === "dev" ? "/static/client.css" : projectRoot ? getClientCssPath(projectRoot) : "/static/client.css";
+          const notFoundFaviconInfo = projectRoot && config ? getFaviconInfo(projectRoot, config.directories.static, env === "dev") : null;
+          await renderNotFoundPage(
+            notFoundPage,
+            req,
+            res,
+            req.path,
+            req.path,
+            buildRouterData(req),
+            notFoundAssetManifest,
+            theme,
+            notFoundClientJsPath,
+            notFoundClientCssPath,
+            notFoundFaviconInfo,
+            projectRoot,
+            false,
+            errorPage,
+            routeChunks,
+            env,
+            config
+          );
+        } else {
+          handleNotFound(res, req.path);
+        }
+      }
+      return;
+    }
+    const errorLoaderResult = loaderResult;
+    if (!errorLoaderResult.theme && theme) {
+      errorLoaderResult.theme = theme;
     }
     const combinedProps = {
       ...layoutProps,
-      ...loaderResult.props || {}
+      ...errorLoaderResult.props || {}
     };
     const combinedLoaderResult = {
-      ...loaderResult,
+      ...errorLoaderResult,
       props: combinedProps
     };
     const initialData = buildInitialData(req.path, { error: String(error) }, combinedLoaderResult);
     const routerData = buildRouterData(req);
     initialData.error = true;
     if (isDataReq) {
-      const pagePropsOnly = loaderResult.props || {};
+      const pagePropsOnly = errorLoaderResult.props || {};
       handleDataResponse(
         res,
         combinedLoaderResult,
@@ -13980,7 +14156,9 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
     res,
     params,
     pathname: urlPath,
-    locals: {}
+    locals: {},
+    Redirect: (destination, permanent = false) => new RedirectResponse(destination, permanent),
+    NotFound: () => new NotFoundResponse()
   };
   for (const mw of route.middlewares) {
     await Promise.resolve(
@@ -13996,6 +14174,12 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
       if (layoutServerHook) {
         try {
           const layoutResult = await layoutServerHook(ctx);
+          if (layoutResult instanceof RedirectResponse || layoutResult instanceof NotFoundResponse) {
+            console.warn(
+              `\u26A0\uFE0F  [framework][ssg] Layout server hook ${i} returned redirect/notFound for route ${route.pattern}. Redirect/NotFound is not supported in SSG (Static Site Generation). Skipping this route.`
+            );
+            return;
+          }
           if (layoutResult.props) {
             Object.assign(layoutProps, layoutResult.props);
           }
@@ -14017,10 +14201,17 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
   let loaderResult = { props: {} };
   if (route.loader) {
     loaderResult = await route.loader(ctx);
+    if (loaderResult instanceof RedirectResponse || loaderResult instanceof NotFoundResponse) {
+      console.warn(
+        `\u26A0\uFE0F  [framework][ssg] Page server hook returned redirect/notFound for route ${route.pattern} (${urlPath}). Redirect/NotFound is not supported in SSG (Static Site Generation). Skipping this route.`
+      );
+      return;
+    }
   }
+  const pageLoaderResult = loaderResult;
   const combinedProps = {
     ...layoutProps,
-    ...loaderResult.props || {}
+    ...pageLoaderResult.props || {}
   };
   let combinedMetadata = null;
   for (const layoutMeta of layoutMetadata) {
@@ -14028,17 +14219,14 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
       combinedMetadata = mergeMetadata(combinedMetadata, layoutMeta);
     }
   }
-  if (loaderResult.metadata) {
-    combinedMetadata = mergeMetadata(combinedMetadata, loaderResult.metadata);
+  if (pageLoaderResult.metadata) {
+    combinedMetadata = mergeMetadata(combinedMetadata, pageLoaderResult.metadata);
   }
   const combinedLoaderResult = {
-    ...loaderResult,
+    ...pageLoaderResult,
     props: combinedProps,
     metadata: combinedMetadata
   };
-  if (combinedLoaderResult.redirect || combinedLoaderResult.notFound) {
-    return;
-  }
   const initialData = buildInitialData(urlPath, params, combinedLoaderResult);
   const routerData = buildRouterData(req);
   const appTree = buildAppTree(route, params, initialData.props);