@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/plugins/index.mjs

@@ -0,0 +1,279 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/plugins/vite.ts
+import { fluixi, createVitePlugin } from "@fluixi/vite-plugin";
+
+// src/lib/plugins/fluixi-routes-plugin.ts
+import * as path2 from "path";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+
+// src/lib/plugins/route-scanner.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+function scanRoutes(routesDir, options = {}) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const absDir = path.resolve(routesDir);
+  if (!fs.existsSync(absDir)) {
+    return [];
+  }
+  return scanDirectory(absDir, absDir, "", extensions);
+}
+function scanDirectory(dir, rootDir, parentUrlPath, extensions) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const routes = [];
+  const layoutRoute = null;
+  const files = [];
+  const dirs = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs.push(entry);
+    } else if (entry.isFile() && hasValidExtension(entry.name, extensions)) {
+      files.push(entry);
+    }
+  }
+  let layout;
+  const nonLayoutFiles = [];
+  for (const file of files) {
+    const baseName = stripExtension(file.name);
+    if (baseName === "layout") {
+      layout = buildFileRoute(file.name, dir, rootDir, parentUrlPath, true);
+    } else {
+      nonLayoutFiles.push(file);
+    }
+  }
+  const fileRoutes = [];
+  for (const file of nonLayoutFiles) {
+    fileRoutes.push(
+      buildFileRoute(file.name, dir, rootDir, parentUrlPath, false)
+    );
+  }
+  const dirRoutes = [];
+  for (const d of dirs) {
+    const dirName = d.name;
+    const isGroup = isRouteGroup(dirName);
+    const segment = isGroup ? "" : dirNameToSegment(dirName);
+    const childUrlPath = segment ? joinUrlPath(parentUrlPath, segment) : parentUrlPath;
+    const children = scanDirectory(
+      path.join(dir, dirName),
+      rootDir,
+      childUrlPath,
+      extensions
+    );
+    if (isGroup) {
+      dirRoutes.push(...children);
+    } else {
+      const childLayout = children.find((c) => c.isLayout && c.urlPath === childUrlPath);
+      const childNonLayout = children.filter((c) => !c.isLayout || c.urlPath !== childUrlPath);
+      if (childLayout) {
+        childLayout.children = [...childLayout.children, ...childNonLayout];
+        dirRoutes.push(childLayout);
+      } else if (childNonLayout.length > 0) {
+        dirRoutes.push(...childNonLayout);
+      }
+    }
+  }
+  if (layout) {
+    layout.children = [...fileRoutes, ...dirRoutes];
+    routes.push(layout);
+  } else {
+    routes.push(...fileRoutes, ...dirRoutes);
+  }
+  return sortRoutes(routes);
+}
+function buildFileRoute(fileName, dir, rootDir, parentUrlPath, isLayout) {
+  const baseName = stripExtension(fileName);
+  const filePath = path.relative(rootDir, path.join(dir, fileName));
+  const isIndex = baseName === "index";
+  const isCatchAll = baseName.startsWith("[...");
+  const isDynamic = !isCatchAll && baseName.startsWith("[") && baseName.endsWith("]");
+  let urlSegment;
+  if (isLayout) {
+    urlSegment = "";
+  } else if (isIndex) {
+    urlSegment = "/";
+  } else if (isCatchAll) {
+    const paramName = baseName.slice(4, -1);
+    urlSegment = `*${paramName}`;
+  } else if (isDynamic) {
+    const paramName = baseName.slice(1, -1);
+    urlSegment = `:${paramName}`;
+  } else {
+    urlSegment = baseName;
+  }
+  const urlPath = isLayout ? parentUrlPath || "/" : isIndex ? parentUrlPath || "/" : joinUrlPath(parentUrlPath, urlSegment);
+  const absoluteFilePath = path.join(dir, fileName);
+  let hasRouteData = false;
+  try {
+    const content = fs.readFileSync(absoluteFilePath, "utf-8");
+    hasRouteData = /export\s+(const|function|async\s+function)\s+routeData\b/.test(content);
+  } catch {
+  }
+  return {
+    filePath: filePath.replace(/\\/g, "/"),
+    // normalize to forward slashes
+    urlSegment,
+    urlPath,
+    isLayout,
+    isIndex,
+    isDynamic,
+    isCatchAll,
+    isGroup: false,
+    children: [],
+    parentUrlPath,
+    hasRouteData,
+    rootDir,
+    dir
+  };
+}
+function hasValidExtension(fileName, extensions) {
+  return extensions.some((ext) => fileName.endsWith(ext));
+}
+function stripExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot > 0 ? fileName.slice(0, lastDot) : fileName;
+}
+function isRouteGroup(dirName) {
+  return dirName.startsWith("(") && dirName.endsWith(")");
+}
+function dirNameToSegment(dirName) {
+  if (dirName.startsWith("[...") && dirName.endsWith("]")) {
+    return "*" + dirName.slice(4, -1);
+  }
+  if (dirName.startsWith("[") && dirName.endsWith("]")) {
+    return ":" + dirName.slice(1, -1);
+  }
+  return dirName;
+}
+function joinUrlPath(parent, segment) {
+  const base = parent.endsWith("/") ? parent : parent + "/";
+  return base + segment;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.isLayout && !b.isLayout) return -1;
+    if (!a.isLayout && b.isLayout) return 1;
+    if (a.isIndex && !b.isIndex) return -1;
+    if (!a.isIndex && b.isIndex) return 1;
+    if (!a.isDynamic && !a.isCatchAll && (b.isDynamic || b.isCatchAll)) return -1;
+    if ((a.isDynamic || a.isCatchAll) && !b.isDynamic && !b.isCatchAll) return 1;
+    if (a.isDynamic && b.isCatchAll) return -1;
+    if (a.isCatchAll && b.isDynamic) return 1;
+    return a.urlSegment.localeCompare(b.urlSegment);
+  });
+}
+
+// src/lib/plugins/route-codegen.ts
+function generateRouteModule(routes, routesDir) {
+  const lines = [];
+  lines.push(`// Auto-generated by fluixi route plugin`);
+  lines.push(`// Do not edit manually`);
+  lines.push(``);
+  lines.push(`import { lazy } from '@fluixi/core/router';`);
+  lines.push(``);
+  lines.push(`export const routes = ${generateRouteArray(routes, routesDir, 0)};`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateRouteArray(routes, routesDir, depth) {
+  if (routes.length === 0) return "[]";
+  const indent = "  ".repeat(depth);
+  const items = routes.map((route) => generateRouteObject(route, routesDir, depth + 1));
+  return `[
+${items.join(",\n")}
+${indent}]`;
+}
+function generateRouteObject(route, routesDir, depth) {
+  const indent = "  ".repeat(depth);
+  const props = [];
+  const importPath = buildImportPath(route.filePath, routesDir);
+  const routePath = computeRoutePath(route);
+  props.push(`${indent}  path: ${JSON.stringify(routePath)}`);
+  props.push(`${indent}  component: lazy(() => import(${JSON.stringify(importPath)}))`);
+  if (route.hasRouteData) {
+    props.push(
+      `${indent}  data: (args, __owner, __isCancelled, __deps) => import(${JSON.stringify(
+        importPath
+      )}).then(m => { if (typeof __isCancelled === 'function' && __isCancelled()) return undefined; if (!m.routeData) return undefined; if (typeof m.routeDeps === 'function') { if (typeof __deps === 'function') __deps(m.routeDeps); args = { ...args, deps: m.routeDeps() }; } return m.routeData(args); })`
+    );
+  }
+  if (route.children.length > 0) {
+    const childArray = generateRouteArray(route.children, routesDir, depth + 1);
+    props.push(`${indent}  children: ${childArray}`);
+  }
+  return `${indent}{
+${props.join(",\n")}
+${indent}}`;
+}
+function computeRoutePath(route) {
+  return route.urlPath;
+}
+function buildImportPath(filePath, routesDir) {
+  const base = routesDir.replace(/\\/g, "/").replace(/\/$/, "");
+  return `${base}/${filePath}`;
+}
+
+// src/lib/plugins/fluixi-routes-plugin.ts
+var VIRTUAL_MODULE_ID = "virtual:fluixi-routes";
+var RESOLVED_VIRTUAL_ID = "\0" + VIRTUAL_MODULE_ID;
+var PUBLIC_MODULE_ID = "@fluixi/core/routes";
+function fluixiRoutesPlugin(options = {}) {
+  const routesDir = options.routesDir ?? "src/routes";
+  const extensions = options.extensions ?? [".tsx", ".ts", ".jsx", ".js"];
+  let projectRoot = "";
+  let lastGenerated = null;
+  function generateModule(root) {
+    const absRoutesDir = path2.resolve(root, routesDir);
+    const scanOpts = { extensions };
+    const routes = scanRoutes(absRoutesDir, scanOpts);
+    return generateRouteModule(routes, "./" + routesDir);
+  }
+  const usePolyfills = options.polyfills !== false;
+  const polyfillsPlugin = usePolyfills ? Object.assign({}, nodePolyfills({ include: ["fs", "path"] }), { apply: "serve" }) : null;
+  const routesPlugin = {
+    name: "fluixi-routes",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root || process.cwd();
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID || id === PUBLIC_MODULE_ID) {
+        return RESOLVED_VIRTUAL_ID;
+      }
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_ID) return null;
+      lastGenerated = generateModule(projectRoot || process.cwd());
+      return lastGenerated;
+    },
+    // Vite dev server: watch routes directory for changes
+    configureServer(server) {
+      const root = projectRoot || process.cwd();
+      const absRoutesDir = path2.resolve(root, routesDir);
+      server.watcher.add(absRoutesDir);
+      server.watcher.on("all", (event, filePath) => {
+        if (!filePath.startsWith(absRoutesDir)) return;
+        if (!["add", "unlink", "addDir", "unlinkDir", "change"].includes(event)) return;
+        if (event !== "addDir" && event !== "unlinkDir" && !extensions.some((ext) => filePath.endsWith(ext))) {
+          return;
+        }
+        const next = generateModule(root);
+        if (next === lastGenerated) return;
+        lastGenerated = next;
+        const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+          server.ws.send({ type: "full-reload" });
+        }
+      });
+    }
+  };
+  return polyfillsPlugin ? [polyfillsPlugin, routesPlugin] : [routesPlugin];
+}
+export {
+  createVitePlugin,
+  fluixi,
+  fluixiRoutesPlugin,
+  scanRoutes
+};

package/dist/src/lib/plugins/route-codegen.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/plugins/route-codegen.ts
+var route_codegen_exports = {};
+__export(route_codegen_exports, {
+  generateRouteModule: () => generateRouteModule
+});
+module.exports = __toCommonJS(route_codegen_exports);
+function generateRouteModule(routes, routesDir) {
+  const lines = [];
+  lines.push(`// Auto-generated by fluixi route plugin`);
+  lines.push(`// Do not edit manually`);
+  lines.push(``);
+  lines.push(`import { lazy } from '@fluixi/core/router';`);
+  lines.push(``);
+  lines.push(`export const routes = ${generateRouteArray(routes, routesDir, 0)};`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateRouteArray(routes, routesDir, depth) {
+  if (routes.length === 0) return "[]";
+  const indent = "  ".repeat(depth);
+  const items = routes.map((route) => generateRouteObject(route, routesDir, depth + 1));
+  return `[
+${items.join(",\n")}
+${indent}]`;
+}
+function generateRouteObject(route, routesDir, depth) {
+  const indent = "  ".repeat(depth);
+  const props = [];
+  const importPath = buildImportPath(route.filePath, routesDir);
+  const routePath = computeRoutePath(route);
+  props.push(`${indent}  path: ${JSON.stringify(routePath)}`);
+  props.push(`${indent}  component: lazy(() => import(${JSON.stringify(importPath)}))`);
+  if (route.hasRouteData) {
+    props.push(
+      `${indent}  data: (args, __owner, __isCancelled, __deps) => import(${JSON.stringify(
+        importPath
+      )}).then(m => { if (typeof __isCancelled === 'function' && __isCancelled()) return undefined; if (!m.routeData) return undefined; if (typeof m.routeDeps === 'function') { if (typeof __deps === 'function') __deps(m.routeDeps); args = { ...args, deps: m.routeDeps() }; } return m.routeData(args); })`
+    );
+  }
+  if (route.children.length > 0) {
+    const childArray = generateRouteArray(route.children, routesDir, depth + 1);
+    props.push(`${indent}  children: ${childArray}`);
+  }
+  return `${indent}{
+${props.join(",\n")}
+${indent}}`;
+}
+function computeRoutePath(route) {
+  return route.urlPath;
+}
+function buildImportPath(filePath, routesDir) {
+  const base = routesDir.replace(/\\/g, "/").replace(/\/$/, "");
+  return `${base}/${filePath}`;
+}

package/dist/src/lib/plugins/route-codegen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module @fluixi/core/plugins/route-codegen
+ *
+ * Generates an ES module from a ScannedRoute tree.
+ * Uses lazy() for code-split component loading with Suspense integration.
+ */
+import type { ScannedRoute } from './route-scanner.js';
+/**
+ * Generate a virtual ES module string from a scanned route tree.
+ */
+export declare function generateRouteModule(routes: ScannedRoute[], routesDir: string): string;
+//# sourceMappingURL=route-codegen.d.ts.map

package/dist/src/lib/plugins/route-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-codegen.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/route-codegen.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAevD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,YAAY,EAAE,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAeR"}

package/dist/src/lib/plugins/route-codegen.js

@@ -0,0 +1,80 @@
+/**
+ * @module @fluixi/core/plugins/route-codegen
+ *
+ * Generates an ES module from a ScannedRoute tree.
+ * Uses lazy() for code-split component loading with Suspense integration.
+ */
+/**
+ * Collect all routes into a flat list for import generation.
+ */
+function collectRoutes(routes, out = []) {
+    for (const route of routes) {
+        out.push(route);
+        if (route.children.length > 0) {
+            collectRoutes(route.children, out);
+        }
+    }
+    return out;
+}
+/**
+ * Generate a virtual ES module string from a scanned route tree.
+ */
+export function generateRouteModule(routes, routesDir) {
+    const lines = [];
+    lines.push(`// Auto-generated by fluixi route plugin`);
+    lines.push(`// Do not edit manually`);
+    lines.push(``);
+    // router is lit-free; the old './router' barrel imported @fluixi/lit (extends
+    // HTMLElement at module init) which crashed SSR/prod server bundles. (runWithOwner was
+    // imported here but never used in the generated output: dropped.)
+    lines.push(`import { lazy } from '@fluixi/core/router';`);
+    lines.push(``);
+    lines.push(`export const routes = ${generateRouteArray(routes, routesDir, 0)};`);
+    lines.push(``);
+    return lines.join('\n');
+}
+function generateRouteArray(routes, routesDir, depth) {
+    if (routes.length === 0)
+        return '[]';
+    const indent = '  '.repeat(depth);
+    const items = routes.map((route) => generateRouteObject(route, routesDir, depth + 1));
+    return `[\n${items.join(',\n')}\n${indent}]`;
+}
+function generateRouteObject(route, routesDir, depth) {
+    const indent = '  '.repeat(depth);
+    const props = [];
+    const importPath = buildImportPath(route.filePath, routesDir);
+    // Path
+    const routePath = computeRoutePath(route);
+    props.push(`${indent}  path: ${JSON.stringify(routePath)}`);
+    // Component: lazy-loaded via dynamic import + Suspense
+    props.push(`${indent}  component: lazy(() => import(${JSON.stringify(importPath)}))`);
+    // Data loader, only generated for routes that export `routeData`
+    // This prevents unnecessary async imports and avoids calling d.data() for
+    // levels that have no data, which kept the router's if (d.data) check clean.
+    if (route.hasRouteData) {
+        props.push(`${indent}  data: (args, __owner, __isCancelled, __deps) => import(${JSON.stringify(importPath)}).then(m => { if (typeof __isCancelled === 'function' && __isCancelled()) return undefined; if (!m.routeData) return undefined; if (typeof m.routeDeps === 'function') { if (typeof __deps === 'function') __deps(m.routeDeps); args = { ...args, deps: m.routeDeps() }; } return m.routeData(args); })`);
+        // props.push(`${indent}  data: (args) => import(${JSON.stringify(importPath)}).then(m => m.routeData ? m.routeData(args) : undefined)`);
+    }
+    // Children
+    if (route.children.length > 0) {
+        const childArray = generateRouteArray(route.children, routesDir, depth + 1);
+        props.push(`${indent}  children: ${childArray}`);
+    }
+    return `${indent}{\n${props.join(',\n')}\n${indent}}`;
+}
+/**
+ * Compute the route path for a RouteDefinition.
+ * The scanner already resolves groups, dynamic segments, and index paths
+ * into the correct urlPath, just use it directly.
+ */
+function computeRoutePath(route) {
+    return route.urlPath;
+}
+/**
+ * Build the import path for a route file.
+ */
+function buildImportPath(filePath, routesDir) {
+    const base = routesDir.replace(/\\/g, '/').replace(/\/$/, '');
+    return `${base}/${filePath}`;
+}

package/dist/src/lib/plugins/route-codegen.mjs

@@ -0,0 +1,52 @@
+// src/lib/plugins/route-codegen.ts
+function generateRouteModule(routes, routesDir) {
+  const lines = [];
+  lines.push(`// Auto-generated by fluixi route plugin`);
+  lines.push(`// Do not edit manually`);
+  lines.push(``);
+  lines.push(`import { lazy } from '@fluixi/core/router';`);
+  lines.push(``);
+  lines.push(`export const routes = ${generateRouteArray(routes, routesDir, 0)};`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateRouteArray(routes, routesDir, depth) {
+  if (routes.length === 0) return "[]";
+  const indent = "  ".repeat(depth);
+  const items = routes.map((route) => generateRouteObject(route, routesDir, depth + 1));
+  return `[
+${items.join(",\n")}
+${indent}]`;
+}
+function generateRouteObject(route, routesDir, depth) {
+  const indent = "  ".repeat(depth);
+  const props = [];
+  const importPath = buildImportPath(route.filePath, routesDir);
+  const routePath = computeRoutePath(route);
+  props.push(`${indent}  path: ${JSON.stringify(routePath)}`);
+  props.push(`${indent}  component: lazy(() => import(${JSON.stringify(importPath)}))`);
+  if (route.hasRouteData) {
+    props.push(
+      `${indent}  data: (args, __owner, __isCancelled, __deps) => import(${JSON.stringify(
+        importPath
+      )}).then(m => { if (typeof __isCancelled === 'function' && __isCancelled()) return undefined; if (!m.routeData) return undefined; if (typeof m.routeDeps === 'function') { if (typeof __deps === 'function') __deps(m.routeDeps); args = { ...args, deps: m.routeDeps() }; } return m.routeData(args); })`
+    );
+  }
+  if (route.children.length > 0) {
+    const childArray = generateRouteArray(route.children, routesDir, depth + 1);
+    props.push(`${indent}  children: ${childArray}`);
+  }
+  return `${indent}{
+${props.join(",\n")}
+${indent}}`;
+}
+function computeRoutePath(route) {
+  return route.urlPath;
+}
+function buildImportPath(filePath, routesDir) {
+  const base = routesDir.replace(/\\/g, "/").replace(/\/$/, "");
+  return `${base}/${filePath}`;
+}
+export {
+  generateRouteModule
+};

package/dist/src/lib/plugins/route-scanner.cjs

@@ -0,0 +1,189 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/plugins/route-scanner.ts
+var route_scanner_exports = {};
+__export(route_scanner_exports, {
+  scanRoutes: () => scanRoutes
+});
+module.exports = __toCommonJS(route_scanner_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var DEFAULT_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+function scanRoutes(routesDir, options = {}) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const absDir = path.resolve(routesDir);
+  if (!fs.existsSync(absDir)) {
+    return [];
+  }
+  return scanDirectory(absDir, absDir, "", extensions);
+}
+function scanDirectory(dir, rootDir, parentUrlPath, extensions) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const routes = [];
+  const layoutRoute = null;
+  const files = [];
+  const dirs = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs.push(entry);
+    } else if (entry.isFile() && hasValidExtension(entry.name, extensions)) {
+      files.push(entry);
+    }
+  }
+  let layout;
+  const nonLayoutFiles = [];
+  for (const file of files) {
+    const baseName = stripExtension(file.name);
+    if (baseName === "layout") {
+      layout = buildFileRoute(file.name, dir, rootDir, parentUrlPath, true);
+    } else {
+      nonLayoutFiles.push(file);
+    }
+  }
+  const fileRoutes = [];
+  for (const file of nonLayoutFiles) {
+    fileRoutes.push(
+      buildFileRoute(file.name, dir, rootDir, parentUrlPath, false)
+    );
+  }
+  const dirRoutes = [];
+  for (const d of dirs) {
+    const dirName = d.name;
+    const isGroup = isRouteGroup(dirName);
+    const segment = isGroup ? "" : dirNameToSegment(dirName);
+    const childUrlPath = segment ? joinUrlPath(parentUrlPath, segment) : parentUrlPath;
+    const children = scanDirectory(
+      path.join(dir, dirName),
+      rootDir,
+      childUrlPath,
+      extensions
+    );
+    if (isGroup) {
+      dirRoutes.push(...children);
+    } else {
+      const childLayout = children.find((c) => c.isLayout && c.urlPath === childUrlPath);
+      const childNonLayout = children.filter((c) => !c.isLayout || c.urlPath !== childUrlPath);
+      if (childLayout) {
+        childLayout.children = [...childLayout.children, ...childNonLayout];
+        dirRoutes.push(childLayout);
+      } else if (childNonLayout.length > 0) {
+        dirRoutes.push(...childNonLayout);
+      }
+    }
+  }
+  if (layout) {
+    layout.children = [...fileRoutes, ...dirRoutes];
+    routes.push(layout);
+  } else {
+    routes.push(...fileRoutes, ...dirRoutes);
+  }
+  return sortRoutes(routes);
+}
+function buildFileRoute(fileName, dir, rootDir, parentUrlPath, isLayout) {
+  const baseName = stripExtension(fileName);
+  const filePath = path.relative(rootDir, path.join(dir, fileName));
+  const isIndex = baseName === "index";
+  const isCatchAll = baseName.startsWith("[...");
+  const isDynamic = !isCatchAll && baseName.startsWith("[") && baseName.endsWith("]");
+  let urlSegment;
+  if (isLayout) {
+    urlSegment = "";
+  } else if (isIndex) {
+    urlSegment = "/";
+  } else if (isCatchAll) {
+    const paramName = baseName.slice(4, -1);
+    urlSegment = `*${paramName}`;
+  } else if (isDynamic) {
+    const paramName = baseName.slice(1, -1);
+    urlSegment = `:${paramName}`;
+  } else {
+    urlSegment = baseName;
+  }
+  const urlPath = isLayout ? parentUrlPath || "/" : isIndex ? parentUrlPath || "/" : joinUrlPath(parentUrlPath, urlSegment);
+  const absoluteFilePath = path.join(dir, fileName);
+  let hasRouteData = false;
+  try {
+    const content = fs.readFileSync(absoluteFilePath, "utf-8");
+    hasRouteData = /export\s+(const|function|async\s+function)\s+routeData\b/.test(content);
+  } catch {
+  }
+  return {
+    filePath: filePath.replace(/\\/g, "/"),
+    // normalize to forward slashes
+    urlSegment,
+    urlPath,
+    isLayout,
+    isIndex,
+    isDynamic,
+    isCatchAll,
+    isGroup: false,
+    children: [],
+    parentUrlPath,
+    hasRouteData,
+    rootDir,
+    dir
+  };
+}
+function hasValidExtension(fileName, extensions) {
+  return extensions.some((ext) => fileName.endsWith(ext));
+}
+function stripExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot > 0 ? fileName.slice(0, lastDot) : fileName;
+}
+function isRouteGroup(dirName) {
+  return dirName.startsWith("(") && dirName.endsWith(")");
+}
+function dirNameToSegment(dirName) {
+  if (dirName.startsWith("[...") && dirName.endsWith("]")) {
+    return "*" + dirName.slice(4, -1);
+  }
+  if (dirName.startsWith("[") && dirName.endsWith("]")) {
+    return ":" + dirName.slice(1, -1);
+  }
+  return dirName;
+}
+function joinUrlPath(parent, segment) {
+  const base = parent.endsWith("/") ? parent : parent + "/";
+  return base + segment;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.isLayout && !b.isLayout) return -1;
+    if (!a.isLayout && b.isLayout) return 1;
+    if (a.isIndex && !b.isIndex) return -1;
+    if (!a.isIndex && b.isIndex) return 1;
+    if (!a.isDynamic && !a.isCatchAll && (b.isDynamic || b.isCatchAll)) return -1;
+    if ((a.isDynamic || a.isCatchAll) && !b.isDynamic && !b.isCatchAll) return 1;
+    if (a.isDynamic && b.isCatchAll) return -1;
+    if (a.isCatchAll && b.isDynamic) return 1;
+    return a.urlSegment.localeCompare(b.urlSegment);
+  });
+}