nukejs 0.0.17 → 0.0.18

package/dist/metadata.js

@@ -0,0 +1,42 @@
+import { pathToFileURL } from "url";
+import { escapeHtml } from "./utils.js";
+async function loadMetadata(filePath) {
+  try {
+    const mod = await import(pathToFileURL(filePath).href);
+    return mod.metadata ?? {};
+  } catch {
+    return {};
+  }
+}
+function mergeMetadata(ordered) {
+  const result = { title: "", scripts: [], styles: [] };
+  for (const m of ordered) {
+    if (m.title) result.title = m.title;
+    if (m.scripts?.length) result.scripts.push(...m.scripts);
+    if (m.styles?.length) result.styles.push(...m.styles);
+  }
+  return result;
+}
+function renderScriptTag(s) {
+  if (s.src) {
+    const attrs = [
+      `src="${escapeHtml(s.src)}"`,
+      s.type ? `type="${escapeHtml(s.type)}"` : "",
+      s.defer ? "defer" : "",
+      s.async ? "async" : ""
+    ].filter(Boolean).join(" ");
+    return `<script ${attrs}></script>`;
+  }
+  const typeAttr = s.type ? ` type="${escapeHtml(s.type)}"` : "";
+  return `<script${typeAttr}>${s.content ?? ""}</script>`;
+}
+function renderStyleTag(s) {
+  if (s.href) return `<link rel="stylesheet" href="${escapeHtml(s.href)}" />`;
+  return `<style>${s.content ?? ""}</style>`;
+}
+export {
+  loadMetadata,
+  mergeMetadata,
+  renderScriptTag,
+  renderStyleTag
+};

package/dist/middleware-loader.js

@@ -0,0 +1,53 @@
+import path from "path";
+import fs from "fs";
+import { pathToFileURL, fileURLToPath } from "url";
+import { log } from "./logger.js";
+const middlewares = [];
+async function loadMiddlewareFromPath(middlewarePath) {
+  if (!fs.existsSync(middlewarePath)) {
+    log.verbose(`No middleware found at ${middlewarePath}, skipping`);
+    return;
+  }
+  try {
+    const mod = await import(pathToFileURL(middlewarePath).href);
+    if (typeof mod.default === "function") {
+      middlewares.push({ fn: mod.default, src: middlewarePath });
+      log.info(`Middleware loaded from ${middlewarePath}`);
+    } else {
+      log.warn(`${middlewarePath} does not export a default function`);
+    }
+  } catch (error) {
+    log.error(`Error loading middleware from ${middlewarePath}:`, error);
+  }
+}
+async function loadMiddleware() {
+  const appDir = path.dirname(fileURLToPath(import.meta.url));
+  const builtinPath = path.join(
+    appDir,
+    `middleware.${appDir.endsWith("dist") ? "js" : "ts"}`
+  );
+  const userPath = path.join(process.cwd(), "middleware.ts");
+  const paths = [.../* @__PURE__ */ new Set([builtinPath, userPath])];
+  for (const middlewarePath of paths) {
+    await loadMiddlewareFromPath(middlewarePath);
+  }
+}
+async function runMiddleware(req, res) {
+  if (middlewares.length === 0) return false;
+  for (const { fn, src } of middlewares) {
+    await fn(req, res);
+    if (res.writableEnded || res.headersSent) {
+      const method = (req.method ?? "GET").toUpperCase();
+      const url = req.url ?? "/";
+      const status = res.statusCode;
+      const srcName = path.basename(src);
+      log.verbose(`middleware  ${method} ${url}  ${status}  (${srcName})`);
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  loadMiddleware,
+  runMiddleware
+};

package/dist/middleware.example.js

@@ -0,0 +1,57 @@
+async function middleware(req, res) {
+  console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${req.method} ${req.url}`);
+  if (req.url?.startsWith("/admin") && !isAuthenticated(req)) {
+    res.statusCode = 401;
+    res.setHeader("Content-Type", "text/html");
+    res.end("<h1>401 Unauthorized</h1><p>Please log in to access this page.</p>");
+    return;
+  }
+  if (req.url === "/old-page") {
+    req.url = "/new-page";
+  }
+  res.setHeader("X-Powered-By", "nukejs-framework");
+  res.setHeader("X-Request-Id", generateRequestId());
+  if (req.url?.startsWith("/api/")) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.statusCode = 204;
+      res.end();
+      return;
+    }
+  }
+  const clientIp = req.socket.remoteAddress || "unknown";
+  if (isRateLimited(clientIp)) {
+    res.statusCode = 429;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "Too many requests" }));
+    return;
+  }
+  if (process.env.MAINTENANCE_MODE === "true" && !req.url?.startsWith("/__")) {
+    res.statusCode = 503;
+    res.setHeader("Content-Type", "text/html");
+    res.end("<h1>503 Service Unavailable</h1><p>We are currently down for maintenance.</p>");
+    return;
+  }
+}
+function isAuthenticated(req) {
+  return req.headers.authorization === "Bearer valid-token";
+}
+function generateRequestId() {
+  return Math.random().toString(36).substring(2, 15);
+}
+const rateLimitMap = /* @__PURE__ */ new Map();
+function isRateLimited(ip) {
+  const now = Date.now();
+  const limit = rateLimitMap.get(ip);
+  if (!limit || now > limit.resetAt) {
+    rateLimitMap.set(ip, { count: 1, resetAt: now + 6e4 });
+    return false;
+  }
+  limit.count++;
+  return limit.count > 100;
+}
+export {
+  middleware as default
+};

package/dist/middleware.js

@@ -0,0 +1,71 @@
+import { build } from "esbuild";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { hmrClients } from "./hmr.js";
+import { getMimeType } from "./utils.js";
+let hmrBundlePromise = null;
+const PUBLIC_DIR = path.resolve("./app/public");
+async function middleware(req, res) {
+  const rawUrl = req.url ?? "/";
+  const pathname = rawUrl.split("?")[0];
+  if (fs.existsSync(PUBLIC_DIR)) {
+    const candidate = path.join(PUBLIC_DIR, pathname);
+    const publicBase = PUBLIC_DIR.endsWith(path.sep) ? PUBLIC_DIR : PUBLIC_DIR + path.sep;
+    const safe = candidate.startsWith(publicBase) || candidate === PUBLIC_DIR;
+    if (!safe) {
+      res.statusCode = 400;
+      res.end("Bad request");
+      return;
+    }
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+      const ext = path.extname(candidate);
+      res.setHeader("Content-Type", getMimeType(ext));
+      res.end(fs.readFileSync(candidate));
+      return;
+    }
+  }
+  if (rawUrl === "/__hmr.js") {
+    if (!hmrBundlePromise) {
+      const dir = path.dirname(fileURLToPath(import.meta.url));
+      const entry = path.join(dir, `hmr-bundle.${dir.endsWith("dist") ? "js" : "ts"}`);
+      hmrBundlePromise = build({
+        entryPoints: [entry],
+        write: false,
+        format: "esm",
+        minify: true,
+        bundle: true,
+        external: ["react", "react-dom/client", "react/jsx-runtime"]
+      }).then((r) => r.outputFiles[0].text);
+    }
+    res.setHeader("Content-Type", "application/javascript");
+    res.end(await hmrBundlePromise);
+    return;
+  }
+  if (rawUrl === "/__hmr") {
+    const MAX_SSE_PER_IP = 5;
+    const remoteAddr = req.socket?.remoteAddress;
+    if (remoteAddr) {
+      const fromSameIp = [...hmrClients].filter(
+        (c) => c.socket?.remoteAddress === remoteAddr
+      );
+      if (fromSameIp.length >= MAX_SSE_PER_IP) {
+        const oldest = fromSameIp[0];
+        oldest.destroy();
+        hmrClients.delete(oldest);
+      }
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.flushHeaders();
+    res.write('data: {"type":"connected"}\n\n');
+    hmrClients.add(res);
+    req.on("close", () => hmrClients.delete(res));
+    return;
+  }
+}
+export {
+  middleware as default
+};

package/dist/renderer.js

@@ -0,0 +1,151 @@
+import path from "path";
+import { createElement, Fragment } from "react";
+import { renderToString } from "react-dom/server";
+import { log } from "./logger.js";
+import { getComponentCache } from "./component-analyzer.js";
+import { escapeHtml } from "./utils.js";
+function isWrapperAttr(key) {
+  return key === "className" || key === "style" || key === "id" || key.startsWith("data-") || key.startsWith("aria-");
+}
+function splitWrapperAttrs(props) {
+  const wrapperAttrs = {};
+  const componentProps = {};
+  for (const [key, value] of Object.entries(props || {})) {
+    if (isWrapperAttr(key)) wrapperAttrs[key] = value;
+    else componentProps[key] = value;
+  }
+  return { wrapperAttrs, componentProps };
+}
+function buildWrapperAttrString(attrs) {
+  const parts = Object.entries(attrs).map(([key, value]) => {
+    if (key === "className") key = "class";
+    if (key === "style" && typeof value === "object") {
+      const css = "display:contents;" + Object.entries(value).map(([k, v]) => {
+        const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+        const safeVal = String(v).replace(/[<>"'`\\]/g, "");
+        return `${prop}:${safeVal}`;
+      }).join(";");
+      return `style="${css}"`;
+    }
+    if (typeof value === "boolean") return value ? key : "";
+    if (value == null) return "";
+    return `${key}="${escapeHtml(String(value))}"`;
+  }).filter(Boolean);
+  if (!("style" in attrs)) parts.push('style="display:contents"');
+  return parts.length ? " " + parts.join(" ") : "";
+}
+async function renderElementToHtml(element, ctx) {
+  if (element === null || element === void 0 || typeof element === "boolean") return "";
+  if (typeof element === "string" || typeof element === "number")
+    return escapeHtml(String(element));
+  if (Array.isArray(element)) {
+    const parts = await Promise.all(element.map((e) => renderElementToHtml(e, ctx)));
+    return parts.join("");
+  }
+  if (!element.type) return "";
+  const { type, props } = element;
+  if (type === Fragment) return renderElementToHtml(props.children, ctx);
+  if (typeof type === "string") return renderHtmlElement(type, props, ctx);
+  if (typeof type === "function") return renderFunctionComponent(type, props, ctx);
+  return "";
+}
+async function renderHtmlElement(type, props, ctx) {
+  const { children, ...attributes } = props || {};
+  const attrs = Object.entries(attributes).map(([key, value]) => {
+    if (key === "className") key = "class";
+    if (key === "htmlFor") key = "for";
+    if (key === "dangerouslySetInnerHTML") return "";
+    if (typeof value === "boolean") return value ? key : "";
+    if (key === "style" && typeof value === "object") {
+      const styleStr = Object.entries(value).map(([k, v]) => {
+        const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+        const safeVal = String(v).replace(/[<>"'`\\]/g, "");
+        return `${prop}:${safeVal}`;
+      }).join(";");
+      return `style="${styleStr}"`;
+    }
+    return `${key}="${escapeHtml(String(value))}"`;
+  }).filter(Boolean).join(" ");
+  const attrStr = attrs ? ` ${attrs}` : "";
+  if (props?.dangerouslySetInnerHTML) {
+    return `<${type}${attrStr}>${props.dangerouslySetInnerHTML.__html}</${type}>`;
+  }
+  if (["img", "br", "hr", "input", "meta", "link"].includes(type)) {
+    return `<${type}${attrStr} />`;
+  }
+  const childrenHtml = children ? await renderElementToHtml(children, ctx) : "";
+  return `<${type}${attrStr}>${childrenHtml}</${type}>`;
+}
+async function renderFunctionComponent(type, props, ctx) {
+  const componentCache = getComponentCache();
+  for (const [id, filePath] of ctx.registry.entries()) {
+    const info = componentCache.get(filePath);
+    if (!info?.isClientComponent) continue;
+    if (!info.exportedName || type.name !== info.exportedName) continue;
+    try {
+      ctx.hydrated.add(id);
+      const { wrapperAttrs, componentProps } = splitWrapperAttrs(props);
+      const wrapperAttrStr = buildWrapperAttrString(wrapperAttrs);
+      const serializedProps = serializePropsForHydration(componentProps, ctx.registry);
+      log.verbose(`Client component rendered for hydration: ${id} (${path.basename(filePath)})`);
+      const html = ctx.skipClientSSR ? "" : renderToString(createElement(type, componentProps));
+      return `<span data-hydrate-id="${id}"${wrapperAttrStr} data-hydrate-props="${escapeHtml(
+        JSON.stringify(serializedProps)
+      )}">${html}</span>`;
+    } catch (err) {
+      log.error("Error rendering client component:", err);
+      return `<div style="color:red">Error rendering client component: ${escapeHtml(String(err))}</div>`;
+    }
+  }
+  const result = type(props);
+  const resolved = result?.then ? await result : result;
+  return renderElementToHtml(resolved, ctx);
+}
+function serializePropsForHydration(props, registry) {
+  if (!props || typeof props !== "object") return props;
+  const out = {};
+  for (const [key, value] of Object.entries(props)) {
+    const s = serializeValue(value, registry);
+    if (s !== void 0) out[key] = s;
+  }
+  return out;
+}
+function serializeValue(value, registry) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "function") return void 0;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value))
+    return value.map((v) => serializeValue(v, registry)).filter((v) => v !== void 0);
+  if (value.$$typeof)
+    return serializeReactElement(value, registry);
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    const s = serializeValue(v, registry);
+    if (s !== void 0) out[k] = s;
+  }
+  return out;
+}
+function serializeReactElement(element, registry) {
+  const { type, props } = element;
+  if (typeof type === "string") {
+    return { __re: "html", tag: type, props: serializePropsForHydration(props, registry) };
+  }
+  if (typeof type === "function") {
+    const componentCache = getComponentCache();
+    for (const [id, filePath] of registry.entries()) {
+      const info = componentCache.get(filePath);
+      if (!info?.isClientComponent) continue;
+      if (info.exportedName && type.name === info.exportedName) {
+        return {
+          __re: "client",
+          componentId: id,
+          props: serializePropsForHydration(props, registry)
+        };
+      }
+    }
+  }
+  return void 0;
+}
+export {
+  renderElementToHtml
+};

package/dist/request-store.d.ts

@@ -0,0 +1,80 @@
+/**
+ * request-store.ts — Per-Request Server Context Store
+ *
+ * Provides a request-scoped store that server components can read via
+ * `useRequest()` during SSR.  The store is populated by the SSR pipeline
+ * before rendering and cleared in a `finally` block after — preventing any
+ * cross-request contamination.
+ *
+ * Why globalThis?
+ *   Node's module system may import this file multiple times when the page
+ *   module and the nukejs package resolve to different copies (common in dev
+ *   with tsx/tsImport).  Using a well-known Symbol on globalThis guarantees
+ *   all copies share the same store instance, exactly like html-store.ts.
+ *
+ * Request isolation:
+ *   runWithRequestStore() creates a fresh store before rendering and clears
+ *   it in the `finally` block, so concurrent requests cannot bleed into each
+ *   other even if rendering throws.
+ *
+ * Headers in __n_data:
+ *   A safe subset of headers is embedded in the HTML `__n_data` blob so
+ *   client components can read them after hydration.  Sensitive headers
+ *   (cookie, authorization, proxy-authorization) are intentionally excluded
+ *   from the client payload.  The server-side store always has ALL headers.
+ */
+export interface RequestContext {
+    /** Full URL with query string (e.g. '/blog/hello?lang=en'). */
+    url: string;
+    /** Pathname only, no query string (e.g. '/blog/hello'). */
+    pathname: string;
+    /**
+     * Dynamic route segments matched by the file-system router.
+     * e.g. for `/blog/[slug]` → `{ slug: 'hello' }`
+     */
+    params: Record<string, string | string[]>;
+    /**
+     * Query string parameters, parsed from the URL.
+     * Multi-value params (e.g. `?tag=a&tag=b`) become arrays.
+     * e.g. `{ lang: 'en', tag: ['a', 'b'] }`
+     */
+    query: Record<string, string | string[]>;
+    /**
+     * Incoming request headers.
+     *
+     * Server-side (SSR): all headers from IncomingMessage.headers.
+     * Client-side: safe subset embedded in __n_data (cookie, authorization,
+     *   proxy-authorization are stripped before serialisation).
+     *
+     * Multi-value headers are joined with ', '.
+     */
+    headers: Record<string, string>;
+}
+/**
+ * Normalises raw Node `IncomingMessage.headers` into a flat `Record<string,string>`.
+ * Array values (multi-value headers) are joined with `', '`.
+ * Undefined values are dropped.
+ *
+ * Used server-side so all headers — including cookies and auth tokens — are
+ * available to server components that need them.
+ */
+export declare function normaliseHeaders(raw: Record<string, string | string[] | undefined>): Record<string, string>;
+/**
+ * Same as `normaliseHeaders` but additionally strips headers that must never
+ * appear in a serialised HTML document.  Used when embedding headers in the
+ * `__n_data` blob so credentials cannot leak into cached or logged HTML pages.
+ */
+export declare function sanitiseHeaders(raw: Record<string, string | string[] | undefined>): Record<string, string>;
+/**
+ * Runs `fn` inside the context of the given request, then clears the store.
+ * The store is set synchronously before `fn` is called, so any code that
+ * reads getRequestStore() during the synchronous phase of a server component
+ * (before its first `await`) will always see the correct context.
+ */
+export declare function runWithRequestStore<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Returns the current request context, or `null` when called outside of
+ * an active `runWithRequestStore` scope (e.g. in the browser, in tests,
+ * or in a client component).
+ */
+export declare function getRequestStore(): RequestContext | null;

package/dist/request-store.js

@@ -0,0 +1,46 @@
+const SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "cookie",
+  "authorization",
+  "proxy-authorization",
+  "set-cookie",
+  "x-api-key"
+]);
+function normaliseHeaders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (v === void 0) continue;
+    out[k] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return out;
+}
+function sanitiseHeaders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (SENSITIVE_HEADERS.has(k.toLowerCase())) continue;
+    if (v === void 0) continue;
+    out[k] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return out;
+}
+const KEY = /* @__PURE__ */ Symbol.for("__nukejs_request_store__");
+const getGlobal = () => globalThis[KEY] ?? null;
+const setGlobal = (ctx) => {
+  globalThis[KEY] = ctx;
+};
+async function runWithRequestStore(ctx, fn) {
+  setGlobal(ctx);
+  try {
+    return await fn();
+  } finally {
+    setGlobal(null);
+  }
+}
+function getRequestStore() {
+  return getGlobal();
+}
+export {
+  getRequestStore,
+  normaliseHeaders,
+  runWithRequestStore,
+  sanitiseHeaders
+};

package/dist/router.js

@@ -0,0 +1,118 @@
+import path from "path";
+import fs from "fs";
+function findAllRoutes(dir, baseDir = dir) {
+  if (!fs.existsSync(dir)) return [];
+  const routes = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      routes.push(...findAllRoutes(fullPath, baseDir));
+    } else if (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts")) {
+      const stem = entry.name.replace(/\.(tsx|ts)$/, "");
+      if (stem === "layout") continue;
+      routes.push(path.relative(baseDir, fullPath).replace(/\.(tsx|ts)$/, ""));
+    }
+  }
+  return routes;
+}
+function matchDynamicRoute(urlSegments, routePath) {
+  const routeSegments = routePath.split(path.sep);
+  if (routeSegments.at(-1) === "index") routeSegments.pop();
+  const params = {};
+  let ri = 0;
+  let ui = 0;
+  while (ri < routeSegments.length) {
+    const seg = routeSegments[ri];
+    const optCatchAll = seg.match(/^\[\[\.\.\.(.+)\]\]$/);
+    if (optCatchAll) {
+      params[optCatchAll[1]] = urlSegments.slice(ui);
+      return { params };
+    }
+    const optDynamic = seg.match(/^\[\[([^.][^\]]*)\]\]$/);
+    if (optDynamic) {
+      if (ui < urlSegments.length) {
+        params[optDynamic[1]] = urlSegments[ui++];
+      } else {
+        params[optDynamic[1]] = "";
+      }
+      ri++;
+      continue;
+    }
+    const catchAll = seg.match(/^\[\.\.\.(.+)\]$/);
+    if (catchAll) {
+      const remaining = urlSegments.slice(ui);
+      if (!remaining.length) return null;
+      params[catchAll[1]] = remaining;
+      return { params };
+    }
+    const dynamic = seg.match(/^\[(.+)\]$/);
+    if (dynamic) {
+      if (ui >= urlSegments.length) return null;
+      params[dynamic[1]] = urlSegments[ui++];
+      ri++;
+      continue;
+    }
+    if (ui >= urlSegments.length || seg !== urlSegments[ui]) return null;
+    ui++;
+    ri++;
+  }
+  return ui < urlSegments.length ? null : { params };
+}
+function getRouteSpecificity(routePath) {
+  return routePath.split(path.sep).reduce((score, seg) => {
+    if (seg.match(/^\[\[\.\.\.(.+)\]\]$/)) return score + 1;
+    if (seg.match(/^\[\.\.\.(.+)\]$/)) return score + 2;
+    if (seg.match(/^\[\[([^.][^\]]*)\]\]$/)) return score + 3;
+    if (seg.match(/^\[(.+)\]$/)) return score + 4;
+    return score + 5;
+  }, 0);
+}
+function isWithinBase(baseDir, filePath) {
+  const rel = path.relative(baseDir, filePath);
+  return Boolean(rel) && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function matchRoute(urlPath, baseDir, extension = ".tsx") {
+  const normPath = urlPath.length > 1 ? urlPath.replace(/\/+$/, "") : urlPath;
+  const rawSegments = normPath === "/" ? [] : normPath.slice(1).split("/");
+  if (rawSegments.some((s) => s === ".." || s === ".")) return null;
+  const segments = rawSegments.length === 0 ? ["index"] : rawSegments;
+  const exactPath = path.join(baseDir, ...segments) + extension;
+  const exactStem = path.basename(exactPath, extension);
+  if (!isWithinBase(baseDir, exactPath)) return null;
+  if (exactStem !== "layout" && fs.existsSync(exactPath)) {
+    return { filePath: exactPath, params: {}, routePattern: segments.join("/") };
+  }
+  const sortedRoutes = findAllRoutes(baseDir).sort(
+    (a, b) => getRouteSpecificity(b) - getRouteSpecificity(a)
+  );
+  for (const route of sortedRoutes) {
+    const match = matchDynamicRoute(rawSegments, route);
+    if (!match) continue;
+    const filePath = path.join(baseDir, route) + extension;
+    if (!isWithinBase(baseDir, filePath)) continue;
+    if (fs.existsSync(filePath)) {
+      return { filePath, params: match.params, routePattern: route };
+    }
+  }
+  return null;
+}
+function findLayoutsForRoute(routeFilePath, pagesDir) {
+  const layouts = [];
+  const rootLayout = path.join(pagesDir, "layout.tsx");
+  if (fs.existsSync(rootLayout)) layouts.push(rootLayout);
+  const relativePath = path.relative(pagesDir, path.dirname(routeFilePath));
+  if (!relativePath || relativePath === ".") return layouts;
+  const segments = relativePath.split(path.sep).filter((s) => s !== ".");
+  for (let i = 1; i <= segments.length; i++) {
+    const layoutPath = path.join(pagesDir, ...segments.slice(0, i), "layout.tsx");
+    if (fs.existsSync(layoutPath)) layouts.push(layoutPath);
+  }
+  return layouts;
+}
+export {
+  findAllRoutes,
+  findLayoutsForRoute,
+  getRouteSpecificity,
+  matchDynamicRoute,
+  matchRoute
+};