@pyreon/zero 0.12.10 → 0.12.11

package/lib/fs-router-CQ7Zxeca.js

@@ -0,0 +1,955 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/fs-router.ts
+var fs_router_exports = /* @__PURE__ */ __exportAll({
+	detectRouteExports: () => detectRouteExports,
+	filePathToUrlPath: () => filePathToUrlPath,
+	generateMiddlewareModule: () => generateMiddlewareModule,
+	generateRouteModule: () => generateRouteModule,
+	generateRouteModuleFromRoutes: () => generateRouteModuleFromRoutes,
+	hasAnyMetaExport: () => hasAnyMetaExport,
+	parseFileRoutes: () => parseFileRoutes,
+	scanRouteFiles: () => scanRouteFiles,
+	scanRouteFilesWithExports: () => scanRouteFilesWithExports,
+	stripTypeAssertions: () => stripTypeAssertions
+});
+const ROUTE_EXTENSIONS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+/** Names whose top-level export presence we care about. */
+const ROUTE_EXPORT_NAMES = [
+	"loader",
+	"guard",
+	"meta",
+	"renderMode",
+	"error",
+	"middleware"
+];
+/**
+* Detect which optional metadata exports a route file source declares.
+*
+* Walks the source character-by-character, tracking string-literal and
+* comment state, then collects top-level `export …` statements. This is
+* more accurate than regex (no false matches inside string literals,
+* template literals, or comments) and lighter than a full AST parse
+* (no oxc/babel dependency, ~1µs per file).
+*
+* Recognizes:
+*   • `export const NAME = …`
+*   • `export let NAME = …`
+*   • `export var NAME = …`
+*   • `export function NAME(…)`
+*   • `export async function NAME(…)`
+*   • `export { NAME }` and `export { localName as NAME }`
+*   • `export { NAME } from '…'` (re-export)
+*
+* Names checked: loader, guard, meta, renderMode, error, middleware.
+*/
+function detectRouteExports(source) {
+	const found = /* @__PURE__ */ new Set();
+	const tokens = scanTopLevelExportTokens(source);
+	for (const tok of tokens) if (tok.kind === "declaration") {
+		if (ROUTE_EXPORT_NAMES.includes(tok.name)) found.add(tok.name);
+	} else for (const name of tok.names) if (ROUTE_EXPORT_NAMES.includes(name)) found.add(name);
+	const rawMeta = found.has("meta") ? extractLiteralExport(source, "meta") : void 0;
+	const rawRenderMode = found.has("renderMode") ? extractLiteralExport(source, "renderMode") : void 0;
+	const cleanMeta = rawMeta !== void 0 ? stripTypeAssertions(rawMeta) : void 0;
+	const cleanRenderMode = rawRenderMode !== void 0 ? stripTypeAssertions(rawRenderMode) : void 0;
+	const metaLiteral = cleanMeta !== void 0 && isPureLiteral(cleanMeta) ? cleanMeta : void 0;
+	const renderModeLiteral = cleanRenderMode !== void 0 && isPureLiteral(cleanRenderMode) ? cleanRenderMode : void 0;
+	return {
+		hasLoader: found.has("loader"),
+		hasGuard: found.has("guard"),
+		hasMeta: found.has("meta"),
+		hasRenderMode: found.has("renderMode"),
+		hasError: found.has("error"),
+		hasMiddleware: found.has("middleware"),
+		...metaLiteral !== void 0 ? { metaLiteral } : {},
+		...renderModeLiteral !== void 0 ? { renderModeLiteral } : {}
+	};
+}
+/**
+* Extract the literal initializer of an `export const NAME = …` statement
+* as a raw text slice — used by the route generator to inline `meta` and
+* `renderMode` values into the generated routes module.
+*
+* Walks the source character-by-character respecting strings, template
+* literals, comments, and brace/bracket/paren nesting. The slice runs
+* from the first non-whitespace character after `=` to the matching
+* end-of-expression terminator (`;`, newline at depth 0, or top-level
+* `export`). Whatever the slice contains is handed to V8 verbatim by
+* embedding it inside `{ … }` in the generated module — which means
+* the original source must already be valid JavaScript (which it is,
+* since the route file compiles).
+*
+* Returns `undefined` when extraction fails for any reason — the
+* generator falls back to a static module import in that case.
+*/
+function extractLiteralExport(source, name) {
+	const len = source.length;
+	let i = 0;
+	let depth = 0;
+	const isIdCont = (c) => /[A-Za-z0-9_$]/.test(c);
+	const skipWs = (p) => {
+		while (p < len && /\s/.test(source[p])) p++;
+		return p;
+	};
+	while (i < len) {
+		const ch = source[i];
+		const next = source[i + 1] ?? "";
+		if (ch === "/" && next === "/") {
+			while (i < len && source[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			i += 2;
+			while (i < len - 1 && !(source[i] === "*" && source[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			i++;
+			while (i < len && source[i] !== quote) if (source[i] === "\\") i += 2;
+			else i++;
+			i++;
+			continue;
+		}
+		if (ch === "`") {
+			i++;
+			while (i < len && source[i] !== "`") {
+				if (source[i] === "\\") {
+					i += 2;
+					continue;
+				}
+				if (source[i] === "$" && source[i + 1] === "{") {
+					i += 2;
+					let exprDepth = 1;
+					while (i < len && exprDepth > 0) {
+						const c = source[i];
+						if (c === "{") exprDepth++;
+						else if (c === "}") exprDepth--;
+						if (exprDepth === 0) {
+							i++;
+							break;
+						}
+						i++;
+					}
+					continue;
+				}
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (ch === "}") {
+			depth--;
+			i++;
+			continue;
+		}
+		if (depth === 0 && ch === "e") {
+			if (source.slice(i, i + 6) === "export" && !isIdCont(source[i + 6] ?? "")) {
+				let p = skipWs(i + 6);
+				if (source.slice(p, p + 5) === "const" && !isIdCont(source[p + 5] ?? "")) {
+					p = skipWs(p + 5);
+					if (source.slice(p, p + name.length) === name && !isIdCont(source[p + name.length] ?? "")) {
+						p = skipWs(p + name.length);
+						if (source[p] === "=") {
+							p = skipWs(p + 1);
+							return readExpressionUntilEnd(source, p);
+						}
+					}
+				}
+				i = i + 6;
+				continue;
+			}
+		}
+		i++;
+	}
+}
+/**
+* Read a JavaScript expression starting at `start` and return the raw
+* text up to (but not including) its end. The end is whichever comes
+* first of:
+*   • a `;` at depth 0
+*   • a newline at depth 0 that is not inside a string/template
+*   • the next top-level `export` / `const` / `function` keyword
+*   • end of file
+*
+* Tracks `()`, `[]`, and `{}` nesting plus string/template/comment
+* state so depth-0 boundaries are detected correctly even for nested
+* objects, arrays, and tagged templates.
+*/
+function readExpressionUntilEnd(source, start) {
+	const len = source.length;
+	let i = start;
+	let depth = 0;
+	while (i < len) {
+		const ch = source[i];
+		const next = source[i + 1] ?? "";
+		if (depth === 0) {
+			if (ch === ";") return source.slice(start, i).trim() || void 0;
+			if (ch === "\n") {
+				const trimmed = source.slice(start, i).trim();
+				if (trimmed.length === 0) {
+					i++;
+					continue;
+				}
+				return trimmed;
+			}
+		}
+		if (ch === "/" && next === "/") {
+			while (i < len && source[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			i += 2;
+			while (i < len - 1 && !(source[i] === "*" && source[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			i++;
+			while (i < len && source[i] !== quote) if (source[i] === "\\") i += 2;
+			else i++;
+			i++;
+			continue;
+		}
+		if (ch === "`") {
+			i++;
+			while (i < len && source[i] !== "`") {
+				if (source[i] === "\\") {
+					i += 2;
+					continue;
+				}
+				if (source[i] === "$" && source[i + 1] === "{") {
+					i += 2;
+					let exprDepth = 1;
+					while (i < len && exprDepth > 0) {
+						const c = source[i];
+						if (c === "{") exprDepth++;
+						else if (c === "}") exprDepth--;
+						if (exprDepth === 0) {
+							i++;
+							break;
+						}
+						i++;
+					}
+					continue;
+				}
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (ch === "{" || ch === "[" || ch === "(") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (ch === "}" || ch === "]" || ch === ")") {
+			depth--;
+			if (depth < 0) return source.slice(start, i).trim() || void 0;
+			i++;
+			continue;
+		}
+		i++;
+	}
+	const trimmed = source.slice(start).trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/**
+* True if `text` is a pure JS literal — only string/number/boolean/null
+* literals plus the structural punctuation needed to compose them into
+* objects, arrays, and tuples. Identifiers, operators, function calls,
+* template-literal expression slots, and references to other names all
+* disqualify the expression.
+*
+* Walks the source character-by-character, tracking string/template/
+* comment state. Inside a string or template head (no `${}` slot) every
+* character is fine; outside strings, only the structural symbols
+* `{}[](),:` plus whitespace, digits, the literal keywords `true`,
+* `false`, `null`, and `-` (for negative numbers) are allowed.
+*
+* The check is conservative on purpose — anything fancier than a flat
+* literal falls back to the static-import path, which still works,
+* just at the cost of one un-split chunk.
+*/
+function isPureLiteral(text) {
+	const len = text.length;
+	let i = 0;
+	while (i < len) {
+		const ch = text[i];
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			i++;
+			while (i < len && text[i] !== quote) if (text[i] === "\\") i += 2;
+			else i++;
+			i++;
+			continue;
+		}
+		if (ch === "`") {
+			i++;
+			while (i < len && text[i] !== "`") {
+				if (text[i] === "\\") {
+					i += 2;
+					continue;
+				}
+				if (text[i] === "$" && text[i + 1] === "{") return false;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			i++;
+			continue;
+		}
+		if (ch === "{" || ch === "}" || ch === "[" || ch === "]" || ch === "," || ch === ":") {
+			i++;
+			continue;
+		}
+		if (/[0-9]/.test(ch) || ch === "-" && /[0-9]/.test(text[i + 1] ?? "")) {
+			while (i < len && /[0-9a-fA-Fxob.eE+\-_]/.test(text[i])) i++;
+			continue;
+		}
+		if (text.slice(i, i + 4) === "true" && !isIdContChar(text[i + 4] ?? "")) {
+			i += 4;
+			continue;
+		}
+		if (text.slice(i, i + 5) === "false" && !isIdContChar(text[i + 5] ?? "")) {
+			i += 5;
+			continue;
+		}
+		if (text.slice(i, i + 4) === "null" && !isIdContChar(text[i + 4] ?? "")) {
+			i += 4;
+			continue;
+		}
+		if (text.slice(i, i + 9) === "undefined" && !isIdContChar(text[i + 9] ?? "")) {
+			i += 9;
+			continue;
+		}
+		if (/[A-Za-z_$]/.test(ch)) {
+			let end = i + 1;
+			while (end < len && isIdContChar(text[end])) end++;
+			let after = end;
+			while (after < len && /\s/.test(text[after])) after++;
+			if (text[after] === ":") {
+				i = end;
+				continue;
+			}
+			return false;
+		}
+		return false;
+	}
+	return true;
+}
+function isIdContChar(c) {
+	return /[A-Za-z0-9_$]/.test(c);
+}
+/**
+* Strip TypeScript type-only suffixes (`as const`, `as SomeType`,
+* `satisfies SomeType`) from a literal expression so the generated
+* JS module is syntactically valid.
+*
+* The route file is TypeScript so authors freely write
+* `export const renderMode = 'ssg' as const` — but the generated
+* `virtual:zero/routes` module is JavaScript and can't keep the cast.
+* Strip from the rightmost top-level `as` or `satisfies` keyword.
+*/
+function stripTypeAssertions(literal) {
+	let result = literal.trim();
+	let depth = 0;
+	for (let i = result.length - 1; i > 0; i--) {
+		const ch = result[i];
+		if (ch === ")" || ch === "]" || ch === "}") depth++;
+		else if (ch === "(" || ch === "[" || ch === "{") depth--;
+		if (depth !== 0) continue;
+		if (i >= 4 && result[i - 3] === " " && result[i - 2] === "a" && result[i - 1] === "s" && result[i] === " ") {
+			result = result.slice(0, i - 3).trim();
+			i = result.length;
+			depth = 0;
+			continue;
+		}
+		if (i >= 11 && result.slice(i - 10, i + 1) === " satisfies ") {
+			result = result.slice(0, i - 10).trim();
+			i = result.length;
+			depth = 0;
+			continue;
+		}
+	}
+	return result;
+}
+function scanTopLevelExportTokens(source) {
+	const tokens = [];
+	const len = source.length;
+	let i = 0;
+	let depth = 0;
+	const isIdStart = (c) => /[A-Za-z_$]/.test(c);
+	const isIdCont = (c) => /[A-Za-z0-9_$]/.test(c);
+	const readIdentifier = (p) => {
+		if (p >= len || !isIdStart(source[p])) return null;
+		let end = p + 1;
+		while (end < len && isIdCont(source[end])) end++;
+		return [source.slice(p, end), end];
+	};
+	const skipWs = (p) => {
+		while (p < len && /\s/.test(source[p])) p++;
+		return p;
+	};
+	const matchKeyword = (p, keyword) => {
+		if (source.slice(p, p + keyword.length) !== keyword) return -1;
+		const after = p + keyword.length;
+		if (after < len && isIdCont(source[after])) return -1;
+		if (p > 0 && isIdCont(source[p - 1])) return -1;
+		return after;
+	};
+	while (i < len) {
+		const ch = source[i];
+		const next = source[i + 1] ?? "";
+		if (ch === "/" && next === "/") {
+			while (i < len && source[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			i += 2;
+			while (i < len - 1 && !(source[i] === "*" && source[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			i++;
+			while (i < len && source[i] !== quote) if (source[i] === "\\") i += 2;
+			else i++;
+			i++;
+			continue;
+		}
+		if (ch === "`") {
+			i++;
+			while (i < len && source[i] !== "`") {
+				if (source[i] === "\\") {
+					i += 2;
+					continue;
+				}
+				if (source[i] === "$" && source[i + 1] === "{") {
+					i += 2;
+					let exprDepth = 1;
+					while (i < len && exprDepth > 0) {
+						const c = source[i];
+						if (c === "{") exprDepth++;
+						else if (c === "}") exprDepth--;
+						if (exprDepth === 0) {
+							i++;
+							break;
+						}
+						i++;
+					}
+					continue;
+				}
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			depth++;
+			i++;
+			continue;
+		}
+		if (ch === "}") {
+			depth--;
+			i++;
+			continue;
+		}
+		if (depth === 0 && ch === "e") {
+			const afterExport = matchKeyword(i, "export");
+			if (afterExport > 0) {
+				let p = skipWs(afterExport);
+				const afterDefault = matchKeyword(p, "default");
+				if (afterDefault > 0) {
+					i = afterDefault;
+					continue;
+				}
+				if (source[p] === "{") {
+					p++;
+					const names = [];
+					while (p < len && source[p] !== "}") {
+						p = skipWs(p);
+						if (source[p] === "}") break;
+						const id = readIdentifier(p);
+						if (!id) {
+							p++;
+							continue;
+						}
+						const [first, afterFirst] = id;
+						let exportedName = first;
+						const afterAs = matchKeyword(skipWs(afterFirst), "as");
+						if (afterAs > 0) {
+							const alias = readIdentifier(skipWs(afterAs));
+							if (alias) {
+								exportedName = alias[0];
+								p = alias[1];
+							} else p = afterFirst;
+						} else p = afterFirst;
+						names.push(exportedName);
+						p = skipWs(p);
+						if (source[p] === ",") p++;
+					}
+					tokens.push({
+						kind: "list",
+						names
+					});
+					i = p + 1;
+					continue;
+				}
+				const afterAsync = matchKeyword(p, "async");
+				if (afterAsync > 0) p = skipWs(afterAsync);
+				let foundDecl = false;
+				for (const kw of [
+					"const",
+					"let",
+					"var",
+					"function"
+				]) {
+					const afterKw = matchKeyword(p, kw);
+					if (afterKw > 0) {
+						const id = readIdentifier(skipWs(afterKw));
+						if (id) {
+							tokens.push({
+								kind: "declaration",
+								name: id[0]
+							});
+							i = id[1];
+							foundDecl = true;
+							break;
+						}
+					}
+				}
+				if (!foundDecl) i = afterExport;
+				continue;
+			}
+		}
+		i++;
+	}
+	return tokens;
+}
+/** All-false exports record. Used when source detection fails. */
+const EMPTY_EXPORTS = {
+	hasLoader: false,
+	hasGuard: false,
+	hasMeta: false,
+	hasRenderMode: false,
+	hasError: false,
+	hasMiddleware: false
+};
+/**
+* True if a route file declares ANY metadata export.
+* Used by the code generator to decide whether to emit a static
+* `import * as mod` (for metadata access) instead of lazy().
+*/
+function hasAnyMetaExport(exports) {
+	return exports.hasLoader || exports.hasGuard || exports.hasMeta || exports.hasRenderMode || exports.hasError || exports.hasMiddleware;
+}
+/**
+* Parse a set of file paths (relative to routes dir) into FileRoute objects.
+*
+* @param files Array of file paths like ["index.tsx", "users/[id].tsx"]
+* @param defaultMode Default rendering mode from config
+* @param exportsMap Optional map of filePath → detected exports. When
+*   provided, the resulting FileRoute objects carry export info that the
+*   code generator uses to optimize imports (skip metadata namespace
+*   imports for routes that only export `default`).
+*/
+function parseFileRoutes(files, defaultMode = "ssr", exportsMap) {
+	return files.filter((f) => ROUTE_EXTENSIONS.some((ext) => f.endsWith(ext))).map((filePath) => {
+		const route = parseFilePath(filePath, defaultMode);
+		const exp = exportsMap?.get(filePath);
+		return exp ? {
+			...route,
+			exports: exp
+		} : route;
+	}).sort(sortRoutes);
+}
+function parseFilePath(filePath, defaultMode) {
+	let route = filePath;
+	for (const ext of ROUTE_EXTENSIONS) if (route.endsWith(ext)) {
+		route = route.slice(0, -ext.length);
+		break;
+	}
+	const fileName = getFileName(route);
+	const isLayout = fileName === "_layout";
+	const isError = fileName === "_error";
+	const isLoading = fileName === "_loading";
+	const isNotFound = fileName === "_404" || fileName === "_not-found";
+	const isCatchAll = route.includes("[...");
+	const parts = route.split("/");
+	parts.pop();
+	const dirPath = parts.filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/");
+	const urlPath = filePathToUrlPath(route);
+	return {
+		filePath,
+		urlPath,
+		dirPath,
+		depth: urlPath === "/" ? 0 : urlPath.split("/").filter(Boolean).length,
+		isLayout,
+		isError,
+		isLoading,
+		isNotFound,
+		isCatchAll,
+		renderMode: defaultMode
+	};
+}
+/**
+* Convert a file path (without extension) to a URL path pattern.
+*
+* Examples:
+*   "index"            → "/"
+*   "about"            → "/about"
+*   "users/index"      → "/users"
+*   "users/[id]"       → "/users/:id"
+*   "blog/[...slug]"   → "/blog/:slug*"
+*   "(auth)/login"     → "/login"         (group stripped)
+*   "_layout"          → "/"              (layout marker)
+*/
+function filePathToUrlPath(filePath) {
+	const segments = filePath.split("/");
+	const urlSegments = [];
+	for (const seg of segments) {
+		if (seg.startsWith("(") && seg.endsWith(")")) continue;
+		if (seg === "_layout" || seg === "_error" || seg === "_loading" || seg === "_404" || seg === "_not-found") continue;
+		if (seg === "index") continue;
+		const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/);
+		if (catchAll) {
+			urlSegments.push(`:${catchAll[1]}*`);
+			continue;
+		}
+		const dynamic = seg.match(/^\[(\w+)\]$/);
+		if (dynamic) {
+			urlSegments.push(`:${dynamic[1]}`);
+			continue;
+		}
+		urlSegments.push(seg);
+	}
+	return `/${urlSegments.join("/")}` || "/";
+}
+/** Sort routes: static before dynamic, catch-all last. */
+function sortRoutes(a, b) {
+	if (a.isCatchAll !== b.isCatchAll) return a.isCatchAll ? 1 : -1;
+	if (a.isLayout !== b.isLayout) return a.isLayout ? -1 : 1;
+	const aDynamic = a.urlPath.includes(":");
+	if (aDynamic !== b.urlPath.includes(":")) return aDynamic ? 1 : -1;
+	return a.urlPath.localeCompare(b.urlPath);
+}
+function getFileName(filePath) {
+	const parts = filePath.split("/");
+	return parts[parts.length - 1] ?? "";
+}
+/**
+* Group flat file routes into a directory tree.
+*/
+function getOrCreateChild(node, segment) {
+	let child = node.children.get(segment);
+	if (!child) {
+		child = {
+			pages: [],
+			children: /* @__PURE__ */ new Map()
+		};
+		node.children.set(segment, child);
+	}
+	return child;
+}
+function resolveNode(root, dirPath) {
+	let node = root;
+	if (dirPath) for (const segment of dirPath.split("/")) node = getOrCreateChild(node, segment);
+	return node;
+}
+function placeRoute(node, route) {
+	if (route.isLayout) node.layout = route;
+	else if (route.isError) node.error = route;
+	else if (route.isLoading) node.loading = route;
+	else if (route.isNotFound) node.notFound = route;
+	else node.pages.push(route);
+}
+function buildRouteTree(routes) {
+	const root = {
+		pages: [],
+		children: /* @__PURE__ */ new Map()
+	};
+	for (const route of routes) placeRoute(resolveNode(root, route.dirPath), route);
+	return root;
+}
+function generateRouteModule(files, routesDir, options) {
+	const exportsMap = /* @__PURE__ */ new Map();
+	for (const filePath of files) {
+		if (!ROUTE_EXTENSIONS.some((ext) => filePath.endsWith(ext))) continue;
+		try {
+			const source = readFileSync(join(routesDir, filePath), "utf-8");
+			exportsMap.set(filePath, detectRouteExports(source));
+		} catch {
+			exportsMap.set(filePath, EMPTY_EXPORTS);
+		}
+	}
+	return generateRouteModuleFromRoutes(parseFileRoutes(files, void 0, exportsMap), routesDir, options);
+}
+/**
+* Lower-level entry point that accepts pre-parsed FileRoute[] (so callers
+* can attach `.exports` info from source detection). Use this when you've
+* already read the files and want optimal output.
+*/
+function generateRouteModuleFromRoutes(routes, routesDir, options) {
+	const tree = buildRouteTree(routes);
+	const imports = [];
+	let importCounter = 0;
+	const useStaticOnly = options?.staticImports ?? false;
+	let needsLazyImport = false;
+	function nextImport(filePath, exportName = "default") {
+		const name = `_${importCounter++}`;
+		const fullPath = `${routesDir}/${filePath}`;
+		if (exportName === "default") imports.push(`import ${name} from "${fullPath}"`);
+		else imports.push(`import { ${exportName} as ${name} } from "${fullPath}"`);
+		return name;
+	}
+	function nextModuleImport(filePath) {
+		const name = `_m${importCounter++}`;
+		const fullPath = `${routesDir}/${filePath}`;
+		imports.push(`import * as ${name} from "${fullPath}"`);
+		return name;
+	}
+	function nextLazy(filePath, loadingName, errorName) {
+		const name = `_${importCounter++}`;
+		const fullPath = `${routesDir}/${filePath}`;
+		needsLazyImport = true;
+		const opts = [];
+		if (loadingName) opts.push(`loading: ${loadingName}`);
+		if (errorName) opts.push(`error: ${errorName}`);
+		const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+		imports.push(`const ${name} = lazy(() => import("${fullPath}")${optsStr})`);
+		return name;
+	}
+	/**
+	* Emit a `meta: { ... }` prop using the literal initializers captured
+	* from the route file source. Either or both of `metaLiteral` and
+	* `renderModeLiteral` may be present; the result is always a single
+	* inline object literal.
+	*/
+	function emitInlineMeta(exp, props, indent) {
+		if (!exp.hasMeta && !exp.hasRenderMode) return;
+		const parts = [];
+		if (exp.hasMeta && exp.metaLiteral !== void 0) parts.push(`...(${exp.metaLiteral})`);
+		if (exp.hasRenderMode && exp.renderModeLiteral !== void 0) parts.push(`renderMode: ${exp.renderModeLiteral}`);
+		if (parts.length > 0) props.push(`${indent}  meta: { ${parts.join(", ")} }`);
+	}
+	function generatePageRoute(page, indent, loadingName, errorName, notFoundName) {
+		const exp = page.exports ?? EMPTY_EXPORTS;
+		const props = [`${indent}  path: ${JSON.stringify(page.urlPath)}`];
+		const hasMeta = hasAnyMetaExport(exp);
+		if (useStaticOnly) if (hasMeta) {
+			const mod = nextModuleImport(page.filePath);
+			props.push(`${indent}  component: ${mod}.default`);
+			if (exp.hasLoader) props.push(`${indent}  loader: ${mod}.loader`);
+			if (exp.hasGuard) props.push(`${indent}  beforeEnter: ${mod}.guard`);
+			if (exp.hasMeta || exp.hasRenderMode) {
+				const metaParts = [];
+				if (exp.hasMeta) metaParts.push(`...${mod}.meta`);
+				if (exp.hasRenderMode) metaParts.push(`renderMode: ${mod}.renderMode`);
+				props.push(`${indent}  meta: { ${metaParts.join(", ")} }`);
+			}
+			if (errorName) {
+				const errorRef = exp.hasError ? `${mod}.error || ${errorName}` : errorName;
+				props.push(`${indent}  errorComponent: ${errorRef}`);
+			}
+		} else {
+			const comp = nextImport(page.filePath, "default");
+			props.push(`${indent}  component: ${comp}`);
+			if (errorName) props.push(`${indent}  errorComponent: ${errorName}`);
+		}
+		else {
+			const inlineableMeta = (!exp.hasMeta || exp.metaLiteral !== void 0) && (!exp.hasRenderMode || exp.renderModeLiteral !== void 0);
+			const needsFunctionExports = exp.hasLoader || exp.hasGuard || exp.hasError;
+			if (hasMeta && inlineableMeta && !needsFunctionExports) {
+				const comp = nextLazy(page.filePath, loadingName, errorName);
+				props.push(`${indent}  component: ${comp}`);
+				emitInlineMeta(exp, props, indent);
+				if (errorName) props.push(`${indent}  errorComponent: ${errorName}`);
+			} else if (hasMeta && inlineableMeta) {
+				const comp = nextLazy(page.filePath, loadingName, errorName);
+				const fullPath = `${routesDir}/${page.filePath}`;
+				props.push(`${indent}  component: ${comp}`);
+				if (exp.hasLoader) props.push(`${indent}  loader: (ctx) => import("${fullPath}").then((m) => m.loader(ctx))`);
+				if (exp.hasGuard) props.push(`${indent}  beforeEnter: (to, from) => import("${fullPath}").then((m) => m.guard(to, from))`);
+				emitInlineMeta(exp, props, indent);
+				if (errorName) {
+					const errorRef = exp.hasError ? `lazy(() => import("${fullPath}").then((m) => ({ default: m.error })))` : errorName;
+					if (exp.hasError) needsLazyImport = true;
+					props.push(`${indent}  errorComponent: ${errorRef}`);
+				}
+			} else if (hasMeta) {
+				const mod = nextModuleImport(page.filePath);
+				props.push(`${indent}  component: ${mod}.default`);
+				if (exp.hasLoader) props.push(`${indent}  loader: ${mod}.loader`);
+				if (exp.hasGuard) props.push(`${indent}  beforeEnter: ${mod}.guard`);
+				if (exp.hasMeta || exp.hasRenderMode) {
+					const metaParts = [];
+					if (exp.hasMeta) metaParts.push(`...${mod}.meta`);
+					if (exp.hasRenderMode) metaParts.push(`renderMode: ${mod}.renderMode`);
+					props.push(`${indent}  meta: { ${metaParts.join(", ")} }`);
+				}
+				if (errorName) {
+					const errorRef = exp.hasError ? `${mod}.error || ${errorName}` : errorName;
+					props.push(`${indent}  errorComponent: ${errorRef}`);
+				}
+			} else {
+				const comp = nextLazy(page.filePath, loadingName, errorName);
+				props.push(`${indent}  component: ${comp}`);
+				if (errorName) props.push(`${indent}  errorComponent: ${errorName}`);
+			}
+		}
+		if (notFoundName) props.push(`${indent}  notFoundComponent: ${notFoundName}`);
+		return `${indent}{\n${props.join(",\n")}\n${indent}}`;
+	}
+	function wrapWithLayout(node, children, indent, errorName, notFoundName) {
+		const layout = node.layout;
+		const exp = layout.exports ?? EMPTY_EXPORTS;
+		const hasMeta = hasAnyMetaExport(exp);
+		let layoutComp;
+		let layoutMod;
+		if (hasMeta) {
+			layoutMod = nextModuleImport(layout.filePath);
+			layoutComp = `${layoutMod}.layout`;
+		} else layoutComp = nextImport(layout.filePath, "layout");
+		const props = [`${indent}path: ${JSON.stringify(layout.urlPath)}`, `${indent}component: ${layoutComp}`];
+		if (layoutMod !== void 0) {
+			if (exp.hasLoader) props.push(`${indent}loader: ${layoutMod}.loader`);
+			if (exp.hasGuard) props.push(`${indent}beforeEnter: ${layoutMod}.guard`);
+			if (exp.hasMeta || exp.hasRenderMode) {
+				const metaParts = [];
+				if (exp.hasMeta) metaParts.push(`...${layoutMod}.meta`);
+				if (exp.hasRenderMode) metaParts.push(`renderMode: ${layoutMod}.renderMode`);
+				props.push(`${indent}meta: { ${metaParts.join(", ")} }`);
+			}
+		}
+		if (errorName) props.push(`${indent}errorComponent: ${errorName}`);
+		if (notFoundName) props.push(`${indent}notFoundComponent: ${notFoundName}`);
+		if (children.length > 0) props.push(`${indent}children: [\n${children.join(",\n")}\n${indent}]`);
+		return `${indent}{\n${props.map((p) => `  ${p}`).join(",\n")}\n${indent}}`;
+	}
+	/**
+	* Generate route definitions for a tree node.
+	*/
+	function generateNode(node, depth) {
+		const indent = "  ".repeat(depth + 1);
+		const errorName = node.error ? nextImport(node.error.filePath) : void 0;
+		const loadingName = node.loading ? nextImport(node.loading.filePath) : void 0;
+		const notFoundName = node.notFound ? nextImport(node.notFound.filePath) : void 0;
+		const childRouteDefs = [];
+		for (const [, childNode] of node.children) childRouteDefs.push(...generateNode(childNode, depth + 1));
+		const allChildren = [...node.pages.map((page) => generatePageRoute(page, indent, loadingName, errorName, notFoundName)), ...childRouteDefs];
+		if (node.layout) return [wrapWithLayout(node, allChildren, indent, errorName, notFoundName)];
+		return allChildren;
+	}
+	const routeDefs = generateNode(tree, 0);
+	const lines = [];
+	if (needsLazyImport) lines.push(`import { lazy } from "@pyreon/router"`, "");
+	lines.push(...imports, "");
+	lines.push(`function clean(routes) {`, `  return routes.map(r => {`, `    const c = {}`, `    for (const k in r) if (r[k] !== undefined) c[k] = r[k]`, `    if (c.children) c.children = clean(c.children)`, `    return c`, `  })`, `}`, "", `export const routes = clean([`, routeDefs.join(",\n"), `])`);
+	return lines.join("\n");
+}
+/**
+* Generate a virtual module that maps URL patterns to their middleware exports.
+* Used by the server entry to dispatch per-route middleware.
+*/
+function generateMiddlewareModule(files, routesDir) {
+	const routes = parseFileRoutes(files);
+	const imports = [];
+	const entries = [];
+	let counter = 0;
+	for (const route of routes) {
+		if (route.isLayout || route.isError || route.isLoading || route.isNotFound) continue;
+		const name = `_mw${counter++}`;
+		const fullPath = `${routesDir}/${route.filePath}`;
+		imports.push(`import { middleware as ${name} } from "${fullPath}"`);
+		entries.push(`  { pattern: ${JSON.stringify(route.urlPath)}, middleware: ${name} }`);
+	}
+	return [
+		...imports,
+		"",
+		`export const routeMiddleware = [`,
+		entries.join(",\n"),
+		`].filter(e => e.middleware)`
+	].join("\n");
+}
+/**
+* Scan a directory for route files.
+* Returns paths relative to the routes directory.
+*/
+async function scanRouteFiles(routesDir) {
+	const { readdir } = await import("node:fs/promises");
+	const { relative } = await import("node:path");
+	const files = [];
+	async function walk(dir) {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) await walk(fullPath);
+			else if (ROUTE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) files.push(relative(routesDir, fullPath));
+		}
+	}
+	await walk(routesDir);
+	return files;
+}
+/**
+* Scan route files AND read each one to detect optional metadata exports
+* (loader, guard, meta, renderMode, error, middleware).
+*
+* Returns FileRoute[] with `.exports` populated, ready to feed into
+* `generateRouteModuleFromRoutes()` for optimal output:
+*   • lazy() for components without metadata (best code splitting)
+*   • Direct property access for components with metadata (no _pick)
+*   • No spurious IMPORT_IS_UNDEFINED warnings
+*/
+async function scanRouteFilesWithExports(routesDir, defaultMode = "ssr") {
+	const { readFile } = await import("node:fs/promises");
+	const files = await scanRouteFiles(routesDir);
+	const exportsMap = /* @__PURE__ */ new Map();
+	await Promise.all(files.map(async (filePath) => {
+		try {
+			const source = await readFile(join(routesDir, filePath), "utf-8");
+			exportsMap.set(filePath, detectRouteExports(source));
+		} catch {
+			exportsMap.set(filePath, EMPTY_EXPORTS);
+		}
+	}));
+	return parseFileRoutes(files, defaultMode, exportsMap);
+}
+
+//#endregion
+export { generateRouteModuleFromRoutes as a, scanRouteFilesWithExports as c, generateRouteModule as i, fs_router_exports as n, parseFileRoutes as o, generateMiddlewareModule as r, scanRouteFiles as s, filePathToUrlPath as t };
+//# sourceMappingURL=fs-router-CQ7Zxeca.js.map