@pracht/vite-plugin 0.11.0 → 0.12.0

package/dist/pages-router-BI34Cani.mjs

@@ -0,0 +1,906 @@
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { parseAst } from "vite";
+import { PAGES_APP_CONFIG_EXPORTS, PAGES_APP_CONFIG_EXPORTS as PAGES_APP_CONFIG_EXPORTS$1, evaluateLiteral, findOwningPagesShell, findOwningPagesShell as findOwningPagesShell$1, hasNamedMiddlewareExport, hasNamedValueExport, hasValueStarExport, maskCommentsAndStrings, maskMarkdownFences, pagesShellName, pagesShellName as pagesShellName$1, readNamedExportInitializer, readPageRevalidation, readPageStreaming, readPageStringExport, resolvePagesCapabilityName } from "@pracht/capabilities/static";
+import { parse } from "@babel/parser";
+import { initSync, parse as parse$1 } from "es-module-lexer";
+//#region src/client-module-query.ts
+const CLIENT_MODULE_QUERY = "pracht-client";
+const PRACHT_CLIENT_MODULE_QUERY = `?${CLIENT_MODULE_QUERY}`;
+function isPrachtClientModuleId(id) {
+	const queryStart = id.indexOf("?");
+	if (queryStart === -1) return false;
+	return id.slice(queryStart + 1).split("&").includes(CLIENT_MODULE_QUERY);
+}
+function stripPrachtClientModuleQuery(id) {
+	const queryStart = id.indexOf("?");
+	if (queryStart === -1) return id;
+	const path = id.slice(0, queryStart);
+	const query = id.slice(queryStart + 1).split("&").filter((part) => part !== CLIENT_MODULE_QUERY);
+	return query.length > 0 ? `${path}?${query.join("&")}` : path;
+}
+/** Extensions `@prefresh/vite` accepts: `/\.(c|m)?(t|j)sx?$/`, anchored at end. */
+const PREFRESH_EXTENSION_RE = /\.((?:c|m)?[tj]sx?)$/i;
+function isPrefreshCompatibleId(id) {
+	return PREFRESH_EXTENSION_RE.test(id);
+}
+/**
+* The id to hand `@prefresh/vite` for a pracht client module.
+*
+* Prefresh uses the id for exactly three things: its `/\.(c|m)?(t|j)sx?$/`
+* filter, a `/\.tsx?$/` check that picks the TypeScript parser plugin, and the
+* key it embeds in the `$RefreshReg$` it injects. A query-carrying id fails the
+* first two, which is why route and shell modules got no Fast Refresh at all —
+* but simply stripping the query fails the third: one file under `src/routes`
+* can reach the browser as *two* module instances, once through the route glob
+* as `…/x.tsx?pracht-client` and once as a plain import from a sibling route.
+* Both would then register under the same key, and `@prefresh/core` treats a
+* second `register()` for a known key with a different function object as a
+* pending component replacement — which the next unrelated Fast Refresh
+* flushes, tearing down and re-running the untouched copy's effects.
+*
+* A reserved, length-prefixed namespace keeps the real extension last, so the
+* filter and parser check still pass, while giving each complete module id its
+* own registration key. Keeping the authored id verbatim makes the mapping
+* injective; keeping it behind a non-file prefix prevents a real sibling such
+* as `x.pracht-client.tsx` from colliding with the synthetic key. The id is
+* never resolved against the filesystem; the JSX dev transform has already
+* stamped `_jsxFileName` from the real id by the time prefresh runs, so dev
+* source locations and open-in-editor are unaffected.
+*
+* Compiled formats whose real extension prefresh rejects (`.md`, `.mdx`, and
+* configured additional formats) instead keep that extension in the basename
+* and receive a synthetic `.jsx`. Their companion Vite plugin has already
+* turned the authored format into JavaScript by the time this id is used.
+*/
+function toPrachtClientPrefreshId(id) {
+	const stripped = stripPrachtClientModuleQuery(id);
+	const queryStart = stripped.indexOf("?");
+	const path = queryStart === -1 ? stripped : stripped.slice(0, queryStart);
+	const parserExtension = PREFRESH_EXTENSION_RE.exec(path)?.[1] ?? "jsx";
+	return `pracht-client:${id.length}:${id}.${parserExtension}`;
+}
+function getRolldownLang(id) {
+	const path = stripPrachtClientModuleQuery(id).split("?")[0];
+	if (/\.(c|m)?tsx$/i.test(path)) return "tsx";
+	if (/\.(c|m)?ts$/i.test(path)) return "ts";
+	if (/\.(c|m)?jsx$/i.test(path)) return "jsx";
+	if (/\.mdx?$/i.test(path)) return "jsx";
+	if (/\.(c|m)?js$/i.test(path)) return "js";
+	return "tsx";
+}
+//#endregion
+//#region src/route-extensions.ts
+const BUILT_IN_ROUTE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".md",
+	".mdx"
+];
+const LEGACY_BARE_ROUTE_EXTENSIONS = [".tsrx"];
+const DEFAULT_ROUTE_EXTENSIONS = [...BUILT_IN_ROUTE_EXTENSIONS, ...LEGACY_BARE_ROUTE_EXTENSIONS];
+const DEFAULT_SHELL_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	...LEGACY_BARE_ROUTE_EXTENSIONS
+];
+const EXTENSION_RE = /^\.[a-z0-9][a-z0-9_-]*$/i;
+function normalizeAdditionalExtensions(extensions) {
+	if (extensions === void 0) return [];
+	if (!Array.isArray(extensions)) throw new Error("pracht({ additionalExtensions }) expects an array of dot-prefixed extensions.");
+	const normalized = extensions.map((extension) => {
+		if (typeof extension !== "string" || !EXTENSION_RE.test(extension)) throw new Error(`pracht({ additionalExtensions }) expects dot-prefixed extensions such as ".vue", got ${JSON.stringify(extension)}.`);
+		return extension.toLowerCase();
+	});
+	const defaults = new Set(BUILT_IN_ROUTE_EXTENSIONS);
+	return [...new Set(normalized)].filter((extension) => !defaults.has(extension));
+}
+function extensionGlob(extensions) {
+	const names = extensions.map((extension) => extension.slice(1));
+	return names.length === 1 ? names[0] : `{${names.join(",")}}`;
+}
+function withAdditionalExtensions(defaults, additionalExtensions) {
+	return new Set([...defaults, ...additionalExtensions]);
+}
+//#endregion
+//#region src/route-loader-hints.ts
+initSync();
+function namedDeclarationRe(exportName) {
+	return new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+${exportName}\\b`);
+}
+const HEAD_DECLARATION_RE = namedDeclarationRe("head");
+const HEADERS_DECLARATION_RE = namedDeclarationRe("headers");
+const STATIC_PATHS_DECLARATION_RE = namedDeclarationRe("getStaticPaths");
+const EXPORT_BLOCK_RE = /export\s*\{([^}]*)\}\s*(?:from\s*["'][^"']+["'])?/g;
+const EXPORT_ALL_RE = /export\s+\*\s+from\b/;
+const EXPORT_VARIABLE_DECLARATION_RE = /export\s+(?:const|let|var)\b/g;
+function isExportAllStatement(source) {
+	const withoutComments = source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, " ");
+	return /^\s*export\s*\*/.test(withoutComments);
+}
+function exportedVariableDeclarationIncludesLoader(source) {
+	for (const declaration of source.matchAll(/\bexport\s+(?:const|let|var)\b/g)) {
+		let index = (declaration.index ?? 0) + declaration[0].length;
+		while (index < source.length) {
+			while (/\s/.test(source[index] ?? "")) index += 1;
+			const bindingStart = index;
+			const opening = source[index];
+			if (opening === "{" || opening === "[") {
+				const closing = opening === "{" ? "}" : "]";
+				let depth = 0;
+				do {
+					const char = source[index++];
+					if (char === opening) depth += 1;
+					if (char === closing) depth -= 1;
+				} while (index < source.length && depth > 0);
+				if (/\bloader\b/.test(source.slice(bindingStart, index))) return true;
+			} else {
+				const binding = /^[A-Za-z_$][\w$]*/.exec(source.slice(index));
+				if (!binding) break;
+				if (binding[0] === "loader") return true;
+				index += binding[0].length;
+			}
+			let parentheses = 0;
+			let brackets = 0;
+			let braces = 0;
+			for (; index < source.length; index += 1) {
+				const char = source[index];
+				if (char === "(") parentheses += 1;
+				else if (char === ")") parentheses = Math.max(0, parentheses - 1);
+				else if (char === "[") brackets += 1;
+				else if (char === "]") brackets = Math.max(0, brackets - 1);
+				else if (char === "{") braces += 1;
+				else if (char === "}") braces = Math.max(0, braces - 1);
+				if (parentheses === 0 && brackets === 0 && braces === 0) {
+					if (char === ";") break;
+					if (char === ",") {
+						index += 1;
+						break;
+					}
+				}
+			}
+			if (source[index] === ";" || index >= source.length) break;
+		}
+	}
+	return false;
+}
+function detectLoaderExportFallback(source) {
+	const masked = maskCommentsAndStrings(source);
+	if (/\bexport\s+(?:async\s+)?function\s+loader\b/.test(masked)) return true;
+	if (exportedVariableDeclarationIncludesLoader(masked)) return true;
+	if (/\bexport\s*\*/.test(masked)) return true;
+	for (const match of masked.matchAll(/\bexport\s*\{([^}]*)\}/g)) if (match[1].split(",").map((specifier) => specifier.trim()).filter(Boolean).some((specifier) => {
+		const names = /^(?:type\s+)?([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/.exec(specifier);
+		if (!names || specifier.startsWith("type ")) return false;
+		return (names[2] ?? names[1]) === "loader";
+	})) return true;
+	return false;
+}
+function topLevelAssignmentIndex(source) {
+	let parentheses = 0;
+	let brackets = 0;
+	let braces = 0;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		if (char === "(") parentheses += 1;
+		else if (char === ")") parentheses = Math.max(0, parentheses - 1);
+		else if (char === "[") brackets += 1;
+		else if (char === "]") brackets = Math.max(0, brackets - 1);
+		else if (char === "{") braces += 1;
+		else if (char === "}") braces = Math.max(0, braces - 1);
+		else if (char === "=" && parentheses === 0 && brackets === 0 && braces === 0) return index;
+	}
+	return -1;
+}
+function bindingExportsName(source, exportName) {
+	const assignmentIndex = topLevelAssignmentIndex(source);
+	const binding = assignmentIndex === -1 ? source : source.slice(0, assignmentIndex);
+	return new RegExp(`\\b${exportName}\\b`).test(binding);
+}
+function variableDeclarationExports(source, exportName) {
+	for (const match of source.matchAll(EXPORT_VARIABLE_DECLARATION_RE)) {
+		let declarationStart = (match.index ?? 0) + match[0].length;
+		let parentheses = 0;
+		let brackets = 0;
+		let braces = 0;
+		for (let index = declarationStart; index <= source.length; index += 1) {
+			const char = source[index];
+			if (char === "(") parentheses += 1;
+			else if (char === ")") parentheses = Math.max(0, parentheses - 1);
+			else if (char === "[") brackets += 1;
+			else if (char === "]") brackets = Math.max(0, brackets - 1);
+			else if (char === "{") braces += 1;
+			else if (char === "}") braces = Math.max(0, braces - 1);
+			if (parentheses === 0 && brackets === 0 && braces === 0 && (char === "," || char === ";" || char === void 0)) {
+				if (bindingExportsName(source.slice(declarationStart, index), exportName)) return true;
+				if (char !== ",") break;
+				declarationStart = index + 1;
+			}
+		}
+	}
+	return false;
+}
+function exportSpecifiersInclude(specifiers, exportName) {
+	return specifiers.split(",").map((specifier) => specifier.trim()).filter(Boolean).some((specifier) => {
+		const match = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/.exec(specifier);
+		if (!match) return false;
+		const [, localName, exportedName] = match;
+		return (exportedName ?? localName) === exportName;
+	});
+}
+/**
+* Whether `source` exports `exportName`, via a declaration, an export block,
+* or an `export *` re-export (which could expose anything, so it counts).
+*
+* Ordinary TS/JS is parsed exactly, including string-literal export names.
+* Custom syntaxes fall back to masked lexical detection so prose or a string
+* literal mentioning the name cannot produce a false positive.
+*/
+function detectNamedExport(source, exportName, declarationRe) {
+	const parsedResult = inspectParsedModule(source, exportName);
+	if (parsedResult !== void 0) return parsedResult;
+	return detectNamedExportInMasked(maskCommentsAndStrings(source), exportName, declarationRe);
+}
+/**
+* The lexical half of `detectNamedExport()`, over already-masked source. Every
+* hint table falls back for the same file, so the mask is computed once.
+*/
+function detectNamedExportInMasked(analysisSource, exportName, declarationRe) {
+	if (declarationRe.test(analysisSource) || variableDeclarationExports(analysisSource, exportName)) return true;
+	for (const match of analysisSource.matchAll(EXPORT_BLOCK_RE)) if (exportSpecifiersInclude(match[1], exportName)) return true;
+	return EXPORT_ALL_RE.test(analysisSource);
+}
+function detectHeadExport(source) {
+	return detectNamedExport(source, "head", HEAD_DECLARATION_RE);
+}
+/** Whether the route or shell module exports document response headers. */
+function detectHeadersExport(source) {
+	return detectNamedExport(source, "headers", HEADERS_DECLARATION_RE);
+}
+function isSyntaxNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function bindingIncludesName(node, exportName) {
+	if (!isSyntaxNode(node)) return false;
+	if (node.type === "Identifier") return node.name === exportName;
+	if (node.type === "AssignmentPattern") return bindingIncludesName(node.left, exportName);
+	if (node.type === "RestElement") return bindingIncludesName(node.argument, exportName);
+	if (node.type === "ArrayPattern") return Array.isArray(node.elements) && node.elements.some((element) => bindingIncludesName(element, exportName));
+	if (node.type === "ObjectPattern") return Array.isArray(node.properties) && node.properties.some((property) => {
+		if (!isSyntaxNode(property)) return false;
+		return property.type === "RestElement" ? bindingIncludesName(property.argument, exportName) : bindingIncludesName(property.value, exportName);
+	});
+	return false;
+}
+function exportedNameMatches(node, exportName) {
+	if (!isSyntaxNode(node)) return false;
+	if (node.type === "Identifier") return node.name === exportName;
+	if (node.type === "StringLiteral") return node.value === exportName;
+	return false;
+}
+/**
+* Which of `exportNames` the module exports, or `undefined` when no parser
+* accepted the source (a custom route syntax such as TSRX).
+*
+* Every hint table asks the same question of the same file, so they share one
+* parse: four separate `inspectParsedModule()` calls used to parse each route
+* module four times, once per table.
+*/
+function inspectParsedModuleExports(source, exportNames) {
+	for (const plugins of [["typescript", "jsx"], ["typescript"]]) {
+		let body;
+		try {
+			body = parse(source, {
+				plugins: [...plugins],
+				sourceType: "module"
+			}).program.body;
+		} catch {
+			continue;
+		}
+		const found = {};
+		for (const exportName of exportNames) found[exportName] = false;
+		for (const statement of body) {
+			if (statement.type === "ExportAllDeclaration") {
+				if (statement.exportKind !== "type") {
+					for (const exportName of exportNames) found[exportName] = true;
+					return found;
+				}
+				continue;
+			}
+			if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") continue;
+			for (const exportName of exportNames) {
+				if (found[exportName]) continue;
+				if (Array.isArray(statement.specifiers) && statement.specifiers.some((specifier) => isSyntaxNode(specifier) && specifier.exportKind !== "type" && exportedNameMatches(specifier.exported, exportName))) {
+					found[exportName] = true;
+					continue;
+				}
+				const declaration = statement.declaration;
+				if (!isSyntaxNode(declaration)) continue;
+				if (declaration.declare === true || declaration.type.startsWith("TS")) continue;
+				if (declaration.type === "VariableDeclaration") {
+					if (Array.isArray(declaration.declarations) && declaration.declarations.some((declarator) => isSyntaxNode(declarator) && bindingIncludesName(declarator.id, exportName))) found[exportName] = true;
+				} else if (bindingIncludesName(declaration.id, exportName)) found[exportName] = true;
+			}
+		}
+		return found;
+	}
+}
+function inspectParsedModule(source, exportName) {
+	return inspectParsedModuleExports(source, [exportName])?.[exportName];
+}
+function detectLoaderExport(source) {
+	const parsedResult = inspectParsedModule(source, "loader");
+	if (parsedResult !== void 0) return parsedResult;
+	return detectLoaderExportWithoutParser(source);
+}
+/** The `loader` detection that applies once no standard parser accepted the source. */
+function detectLoaderExportWithoutParser(source) {
+	try {
+		const [imports, exports] = parse$1(source);
+		if (exports.some((entry) => entry.n === "loader")) return true;
+		for (const entry of imports) if (entry.d === -1 && isExportAllStatement(source.slice(entry.ss, entry.se))) return true;
+	} catch {}
+	return detectLoaderExportFallback(source);
+}
+/** `readdirSync` failing because the directory is simply absent is not a gap. */
+function isMissingDirectory(error) {
+	const code = error?.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+function scanRouteFiles(dir, extensions, scan) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch (error) {
+		if (!isMissingDirectory(error)) scan.incomplete = true;
+		return;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(abs);
+		} catch {
+			scan.incomplete = true;
+			continue;
+		}
+		if (stat.isDirectory()) {
+			scanRouteFiles(abs, extensions, scan);
+			continue;
+		}
+		if (extensions.has(extname(entry))) scan.files.push(abs);
+	}
+}
+function toPosixPath(path) {
+	return path.replace(/\\/g, "/");
+}
+const ROUTE_HINT_EXPORTS = [
+	"loader",
+	"head",
+	"headers",
+	"getStaticPaths"
+];
+function analyzeRouteExports(source) {
+	const parsed = inspectParsedModuleExports(source, ROUTE_HINT_EXPORTS);
+	if (parsed) return parsed;
+	const analysisSource = maskCommentsAndStrings(source);
+	return {
+		getStaticPaths: detectNamedExportInMasked(analysisSource, "getStaticPaths", STATIC_PATHS_DECLARATION_RE),
+		head: detectNamedExportInMasked(analysisSource, "head", HEAD_DECLARATION_RE),
+		headers: detectNamedExportInMasked(analysisSource, "headers", HEADERS_DECLARATION_RE),
+		loader: detectLoaderExportWithoutParser(source)
+	};
+}
+function routeHintKeys(routesDir, file, options) {
+	const keys = /* @__PURE__ */ new Set();
+	if (options.appFileDir) {
+		const relativeToAppFile = toPosixPath(relative(options.appFileDir, file));
+		keys.add(relativeToAppFile.startsWith(".") ? relativeToAppFile : `./${relativeToAppFile}`);
+	}
+	const routeRootPrefix = options.rootRelativePrefix?.replace(/\/$/, "");
+	if (routeRootPrefix) keys.add(`${routeRootPrefix}/${toPosixPath(relative(routesDir, file))}`);
+	return keys;
+}
+function createRouteHints(routesDir, options = {}) {
+	const additionalExtensions = normalizeAdditionalExtensions(options.additionalExtensions);
+	const extensions = withAdditionalExtensions(DEFAULT_ROUTE_EXTENSIONS, additionalExtensions);
+	const scan = {
+		files: [],
+		incomplete: false
+	};
+	scanRouteFiles(routesDir, extensions, scan);
+	const hints = {
+		capabilities: {},
+		head: {},
+		headers: {},
+		incomplete: scan.incomplete,
+		loader: {},
+		staticPaths: {}
+	};
+	for (const file of scan.files) {
+		let source;
+		try {
+			source = readFileSync(file, "utf-8");
+		} catch {
+			hints.incomplete = true;
+			continue;
+		}
+		const extension = extname(file);
+		const compiledFormat = extension === ".md" || extension === ".mdx";
+		const synthesizable = additionalExtensions.includes(extension);
+		const exports = analyzeRouteExports(source);
+		const capabilityInitializer = readNamedExportInitializer(source, "CAPABILITIES");
+		const capabilityValue = capabilityInitializer ? evaluateLiteral(capabilityInitializer) : void 0;
+		const capabilities = Array.isArray(capabilityValue) ? capabilityValue.filter((name) => typeof name === "string") : [];
+		const values = {
+			head: compiledFormat || synthesizable || exports.head,
+			headers: compiledFormat || synthesizable || exports.headers,
+			loader: exports.loader,
+			staticPaths: synthesizable || exports.getStaticPaths
+		};
+		for (const key of routeHintKeys(routesDir, file, options)) {
+			hints.capabilities[key] = capabilities;
+			hints.head[key] = values.head;
+			hints.headers[key] = values.headers;
+			hints.loader[key] = values.loader;
+			hints.staticPaths[key] = values.staticPaths;
+		}
+	}
+	return hints;
+}
+function createRouteLoaderHints(routesDir, options = {}) {
+	return createRouteHints(routesDir, options).loader;
+}
+//#endregion
+//#region src/pages-router.ts
+const GENERATED_PAGES_MANIFEST_MARKER = "Auto-generated from pages/ directory by @pracht/vite-plugin.";
+const GENERATED_PAGES_LAYOUT_EXPORT = "__PRACHT_EJECTED_PAGES_LAYOUT__";
+const MIDDLEWARE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+]);
+const CAPABILITY_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+]);
+/**
+* The root-level `_middleware.{ts,tsx,js,jsx}` file of a pages directory, or
+* null when the app has none. Fails loudly on every shape that would
+* otherwise fail open: a nested `_middleware` file, a `_middleware/`
+* directory, any exact `_middleware` basename using an extension the runtime
+* registry cannot load (all unsupported — they would be silently ignored while
+* looking like an auth gate), and multiple root files competing for the same
+* registration.
+*/
+function findPagesMiddlewareFile(pagesDir, _additionalExtensions = []) {
+	const allFiles = scanAllFiles(pagesDir);
+	const middlewareDirectories = scanAllDirectories(pagesDir).filter((directory) => basename(directory) === "_middleware");
+	if (middlewareDirectories.length > 0) {
+		const shown = middlewareDirectories.map((directory) => relative(pagesDir, directory).replace(/\\/g, "/"));
+		throw new Error(`[pracht] A \`_middleware\` directory is not supported: ${shown.map((file) => JSON.stringify(file)).join(", ")}. Pages middleware is a single root-level \`_middleware.ts\` file in the pages directory (it runs on every page route). Move the logic there, or eject to an explicit manifest for per-group middleware.`);
+	}
+	const unsupported = allFiles.filter((file) => basename(file, extname(file)) === "_middleware" && !MIDDLEWARE_EXTENSIONS.has(extname(file)));
+	if (unsupported.length > 0) {
+		const shown = unsupported.map((file) => relative(pagesDir, file).replace(/\\/g, "/"));
+		throw new Error(`[pracht] Pages middleware cannot use the ${shown.map((file) => JSON.stringify(extname(file))).join(", ")} extension (${shown.map((file) => JSON.stringify(file)).join(", ")}). The middleware registry loads \`.ts\`, \`.tsx\`, \`.js\`, and \`.jsx\` modules only — rename the file to \`_middleware.ts\`.`);
+	}
+	const middlewareFiles = allFiles.filter((file) => basename(file, extname(file)) === "_middleware" && MIDDLEWARE_EXTENSIONS.has(extname(file)));
+	const nested = middlewareFiles.filter((file) => relative(pagesDir, file).replace(/\\/g, "/").includes("/"));
+	if (nested.length > 0) {
+		const shown = nested.map((file) => relative(pagesDir, file).replace(/\\/g, "/"));
+		throw new Error(`[pracht] Nested pages middleware is not supported: ${shown.map((file) => JSON.stringify(file)).join(", ")}. Only a root-level \`_middleware.ts\` in the pages directory is applied (it runs on every page route). Move the logic there, or eject to an explicit manifest for per-group middleware.`);
+	}
+	if (middlewareFiles.length > 1) {
+		const shown = middlewareFiles.map((file) => basename(file));
+		throw new Error(`[pracht] Multiple pages middleware files resolve to the same registration: ${shown.map((file) => JSON.stringify(file)).join(", ")}. Keep exactly one root-level \`_middleware\` file.`);
+	}
+	const middlewareFile = middlewareFiles[0] ?? null;
+	if (middlewareFile && !exportsMiddleware(readFileSync(middlewareFile, "utf-8"), middlewareFile)) throw new Error(`[pracht] Pages middleware ${JSON.stringify(relative(pagesDir, middlewareFile).replace(/\\/g, "/"))} does not export \`middleware\`. It must declare a named value export such as \`export const middleware: MiddlewareFn = (args, next) => …\` (a default export is not used). The runtime validates that the exported value is callable.`);
+	return middlewareFile;
+}
+/** The registered shell name for an `_app` in `directory` (posix, `""` at the root). */
+/**
+* Every `_app` shell in a pages directory, deepest first.
+*
+* An `_app` in a subdirectory owns the routes in that subtree: like a group's
+* `shell` in an explicit manifest, the nearest one wins and REPLACES the
+* parent rather than rendering inside it — `resolveApp()` gives every route
+* exactly one shell, so file-system nesting cannot mean something the manifest
+* router cannot express.
+*
+* Two `_app` files in the same directory are rejected: they compete for one
+* registration, and picking either silently drops the other's `head()` and
+* `headers()` from every route below.
+*/
+function findPagesAppShellFiles(pagesDir, shellExtensions) {
+	const shells = scanAllFiles(pagesDir).filter((file) => {
+		if (basename(file, extname(file)) !== "_app" || !shellExtensions.has(extname(file))) return false;
+		return !relative(pagesDir, file).replace(/\\/g, "/").split("/").slice(0, -1).some((segment) => segment.startsWith("_"));
+	}).map((file) => {
+		if (readPageStreaming(readFileSync(file, "utf-8")) !== void 0) throw new Error(`[pracht] STREAMING belongs on a pages route, not ${JSON.stringify(file)}.`);
+		const directory = relative(pagesDir, file).replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+		return {
+			absolutePath: file,
+			directory,
+			name: pagesShellName(directory)
+		};
+	});
+	const byDirectory = /* @__PURE__ */ new Map();
+	for (const shell of shells) byDirectory.set(shell.directory, [...byDirectory.get(shell.directory) ?? [], shell]);
+	for (const [directory, candidates] of byDirectory) {
+		if (candidates.length < 2) continue;
+		const shown = candidates.map((shell) => JSON.stringify(relative(pagesDir, shell.absolutePath).replace(/\\/g, "/"))).join(", ");
+		throw new Error(`[pracht] Multiple \`_app\` shells in ${JSON.stringify(directory || ".")} compete for the same registration (${JSON.stringify(pagesShellName(directory))}): ${shown}. Keep exactly one \`_app\` file per directory.`);
+	}
+	return shells.sort((left, right) => right.directory.length - left.directory.length);
+}
+/** The `_app` that owns a page: the nearest ancestor directory with one. */
+/** Whether a middleware module explicitly exports, or may re-export, `middleware`. */
+function exportsMiddleware(source, file) {
+	return hasNamedMiddlewareExport(parseAst(source, { lang: getRolldownLang(file) }));
+}
+/**
+* The app-level config file of a pages directory: `_app.config.ts` at the
+* pages root.
+*
+* Named after the shell it configures, because that is what it is — the
+* app-level knobs a manifest passes to `defineApp()` that no single route
+* owns. It is root-only for the same reason `_middleware` is: `agents` and
+* `constraints` are app-wide, so a per-directory copy would look scoped while
+* being ignored.
+*/
+const PAGES_APP_CONFIG_BASENAME = "_app.config";
+/**
+* The root-level `_app.config.{ts,tsx,js,jsx}` of a pages directory, or null
+* when the app has none.
+*
+* Fails closed on every shape that would otherwise leave an app looking
+* configured while nothing is registered: a nested file, an unsupported
+* extension, duplicates, a module that exports none of the supported keys, and
+* a value `export *` whose names cannot be known without loading the module.
+*/
+function findPagesAppConfigFile(pagesDir) {
+	const named = scanAllFiles(pagesDir).filter((file) => basename(file, extname(file)) === PAGES_APP_CONFIG_BASENAME);
+	if (named.length === 0) return null;
+	const show = (file) => JSON.stringify(relative(pagesDir, file).replace(/\\/g, "/"));
+	const nested = named.filter((file) => relative(pagesDir, file).replace(/\\/g, "/").includes("/"));
+	if (nested.length > 0) throw new Error(`[pracht] Nested \`${PAGES_APP_CONFIG_BASENAME}\` is not supported: ${nested.map(show).join(", ")}. \`agents\` and \`constraints\` are app-wide, so only a root-level \`${PAGES_APP_CONFIG_BASENAME}.ts\` in the pages directory is read.`);
+	const unsupported = named.filter((file) => !MIDDLEWARE_EXTENSIONS.has(extname(file)));
+	if (unsupported.length > 0) throw new Error(`[pracht] Pages app config cannot use the ${unsupported.map((file) => JSON.stringify(extname(file))).join(", ")} extension (${unsupported.map(show).join(", ")}). Rename the file to \`${PAGES_APP_CONFIG_BASENAME}.ts\`.`);
+	if (named.length > 1) throw new Error(`[pracht] Multiple pages app config files resolve to the same registration: ${named.map(show).join(", ")}. Keep exactly one root-level \`${PAGES_APP_CONFIG_BASENAME}\` file.`);
+	const file = named[0];
+	const program = parseAst(readFileSync(file, "utf-8"), { lang: getRolldownLang(file) });
+	if (hasValueStarExport(program)) throw new Error(`[pracht] Pages app config ${show(file)} re-exports \`export * from …\`, whose names cannot be read without loading the module. Re-export the keys explicitly, for example \`export { agents } from "./_config/agents.ts"\`.`);
+	const exports = PAGES_APP_CONFIG_EXPORTS.filter((name) => hasNamedValueExport(program, name));
+	if (exports.length === 0) throw new Error(`[pracht] Pages app config ${show(file)} exports none of ${PAGES_APP_CONFIG_EXPORTS.map((name) => `\`${name}\``).join(", ")}. It must declare named value exports such as \`export const agents: PrachtAgentsConfig = { … }\` (a default export is not used), or be deleted.`);
+	return {
+		absolutePath: file,
+		exports: [...exports]
+	};
+}
+/**
+* Every capability module in `capabilitiesDir`, keyed by the name it registers
+* under.
+*
+* The pages router has no `capabilities` registry, so the directory *is* the
+* registry: one module per capability, named by `defineCapability({ name })`
+* or by its file stem. That keeps registration explicit — a file has to be in
+* `src/capabilities/` to be reachable — without inventing a second place to
+* repeat the name.
+*/
+function findPagesCapabilityFiles(capabilitiesDir) {
+	const files = scanAllFiles(capabilitiesDir).filter((file) => CAPABILITY_EXTENSIONS.has(extname(file))).filter((file) => !file.endsWith(".d.ts")).sort();
+	const capabilities = [];
+	const byName = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const show = JSON.stringify(relative(capabilitiesDir, file).replace(/\\/g, "/"));
+		const resolved = resolvePagesCapabilityName(basename(file, extname(file)), readFileSync(file, "utf-8"));
+		if (!resolved.ok) throw new Error(`[pracht] Capability module ${show} ${resolved.error}`);
+		capabilities.push({
+			absolutePath: file,
+			name: resolved.name
+		});
+		byName.set(resolved.name, [...byName.get(resolved.name) ?? [], show]);
+	}
+	for (const [name, shown] of byName) {
+		if (shown.length < 2) continue;
+		throw new Error(`[pracht] Multiple capability modules register the name ${JSON.stringify(name)}: ${shown.join(", ")}. Keep one module per capability name.`);
+	}
+	return capabilities;
+}
+function scanPagesDirectory(pagesDir, additionalExtensions = []) {
+	const normalizedExtensions = normalizeAdditionalExtensions(additionalExtensions);
+	const pageExtensions = withAdditionalExtensions(DEFAULT_ROUTE_EXTENSIONS, normalizedExtensions);
+	const shellExtensions = withAdditionalExtensions(DEFAULT_SHELL_EXTENSIONS, normalizedExtensions);
+	const pages = [];
+	scan(pagesDir, pagesDir, pages, pageExtensions, shellExtensions, new Set(normalizedExtensions));
+	const appShell = pages.find((page) => page.routePath === "__shell__");
+	if (appShell?.hasRevalidateExport) throw new Error(`[pracht] Pages app shell ${JSON.stringify(appShell.relativePath)} exports REVALIDATE, but app shells are not ISG routes. Declare the policy on each ISG page instead.`);
+	if ((appShell?.capabilities.length ?? 0) > 0) throw new Error(`[pracht] Pages app shell ${JSON.stringify(appShell.relativePath)} exports CAPABILITIES, but page tools are route-scoped. Declare CAPABILITIES on each page that should expose them.`);
+	return sortRoutes(pages);
+}
+function scan(dir, root, pages, pageExtensions, shellExtensions, additionalExtensions) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		if (statSync(abs).isDirectory()) {
+			if (entry.startsWith("_")) continue;
+			scan(abs, root, pages, pageExtensions, shellExtensions, additionalExtensions);
+			continue;
+		}
+		const ext = extname(entry);
+		if (!pageExtensions.has(ext)) continue;
+		const name = basename(entry, ext);
+		const isRootApp = dir === root && name === "_app";
+		if (name === "_app" && (!isRootApp || !shellExtensions.has(ext))) continue;
+		if (name.startsWith("_") && !isRootApp) continue;
+		const rel = relative(root, abs);
+		const routePath = filePathToRoutePath(rel);
+		const analysisSource = maskMarkdownFences(readFileSync(abs, "utf-8"), rel);
+		const renderMode = extractQuotedPageExport(analysisSource, "RENDER_MODE", rel);
+		const hydrationMode = extractQuotedPageExport(analysisSource, "HYDRATION", rel);
+		const streaming = readPageStreaming(analysisSource);
+		if (streaming === "invalid") throw new Error(`[pracht] Pages module ${JSON.stringify(rel)} must export STREAMING once as a boolean literal.`);
+		if (streaming !== void 0 && (isRootApp || routePath === "/404")) throw new Error(`[pracht] STREAMING belongs on a pages route, not ${JSON.stringify(rel)}.`);
+		const capabilities = extractPageCapabilities(analysisSource, rel);
+		const revalidate = extractRevalidateSeconds(analysisSource, rel);
+		const hasLoader = detectLoaderExport(analysisSource);
+		const hasHead = ext === ".md" || ext === ".mdx" || additionalExtensions.has(ext) || detectHeadExport(analysisSource);
+		const hasHeaders = ext === ".md" || ext === ".mdx" || additionalExtensions.has(ext) || detectHeadersExport(analysisSource);
+		pages.push({
+			absolutePath: abs,
+			capabilities,
+			relativePath: rel,
+			routePath,
+			isIndex: name === "index",
+			isCatchAll: routePath.split("/").includes("*"),
+			isDynamic: routePath.split("/").some((segment) => segment.startsWith(":")),
+			renderMode,
+			hydrationMode,
+			streaming,
+			revalidateSeconds: revalidate.seconds,
+			hasRevalidateExport: revalidate.present,
+			hasLoader,
+			hasHead,
+			hasHeaders
+		});
+	}
+}
+function extractPageCapabilities(source, relativePath) {
+	const initializer = readNamedExportInitializer(source, "CAPABILITIES");
+	if (initializer === null) {
+		if (/\bexport\s+const\s+CAPABILITIES\b/.test(maskCommentsAndStrings(source))) throw new Error(`[pracht] Pages route ${JSON.stringify(relativePath)} must export CAPABILITIES as an inline array of capability names (for example, \`export const CAPABILITIES = ["notes.search"]\`).`);
+		return [];
+	}
+	const value = evaluateLiteral(initializer);
+	if (!Array.isArray(value) || value.some((name) => typeof name !== "string" || name.length === 0)) throw new Error(`[pracht] Pages route ${JSON.stringify(relativePath)} must export CAPABILITIES as an inline array of non-empty capability names.`);
+	return [...new Set(value)];
+}
+function filePathToRoutePath(relativePath) {
+	const extension = extname(relativePath);
+	let route = extension ? relativePath.slice(0, -extension.length) : relativePath;
+	route = route.replace(/\\/g, "/");
+	if (route === "_app" || route.endsWith("/_app")) return "__shell__";
+	if (route === "index") return "/";
+	route = route.replace(/\/index$/, "");
+	route = route.replace(/\[([^\].]+)\]/g, ":$1");
+	route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*");
+	return `/${route}`;
+}
+function sortRoutes(pages) {
+	return [...pages].filter((p) => p.routePath !== "__shell__").sort(comparePagesBySpecificity);
+}
+function comparePagesBySpecificity(left, right) {
+	const leftSegments = splitRoutePath(left.routePath);
+	const rightSegments = splitRoutePath(right.routePath);
+	const length = Math.max(leftSegments.length, rightSegments.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftSegment = leftSegments[index];
+		const rightSegment = rightSegments[index];
+		if (!leftSegment) return -1;
+		if (!rightSegment) return 1;
+		const leftScore = getRouteSegmentSpecificity(leftSegment);
+		const rightScore = getRouteSegmentSpecificity(rightSegment);
+		if (leftScore !== rightScore) return rightScore - leftScore;
+		if (leftScore === 3 && leftSegment !== rightSegment) return leftSegment.localeCompare(rightSegment);
+	}
+	return left.routePath.localeCompare(right.routePath);
+}
+function splitRoutePath(routePath) {
+	return routePath.split("/").filter(Boolean);
+}
+function getRouteSegmentSpecificity(segment) {
+	if (segment === "*") return 1;
+	if (segment.startsWith(":")) return 2;
+	return 3;
+}
+function extractQuotedPageExport(source, name, relativePath) {
+	const { count, value } = readPageStringExport(source, name);
+	if (count > 1) throw new Error(`[pracht] Pages route ${JSON.stringify(relativePath)} exports ${name} more than once.`);
+	return value;
+}
+function extractRevalidateSeconds(source, relativePath) {
+	const result = readPageRevalidation(source);
+	if (result.kind === "missing") return { present: false };
+	if (result.kind === "time") return {
+		present: true,
+		seconds: result.seconds
+	};
+	const prefix = `[pracht] Pages route ${JSON.stringify(relativePath)}`;
+	if (result.reason === "duplicate") throw new Error(`${prefix} exports REVALIDATE more than once.`);
+	const detail = result.reason === "range" ? "positive integer literal number of seconds within JavaScript's safe integer range." : "positive integer literal number of seconds (for example, `export const REVALIDATE = 60`).";
+	throw new Error(`${prefix} must export REVALIDATE as a ${detail}`);
+}
+function generatePagesManifestSource(pages, options) {
+	const pagesDir = options.pagesDir;
+	const defaultRender = options.pagesDefaultRender ?? "ssr";
+	const prefix = options.pagesDirPrefix;
+	const useImport = options.useImportSyntax ?? false;
+	const appShells = findPagesAppShellFiles(pagesDir, withAdditionalExtensions(DEFAULT_SHELL_EXTENSIONS, normalizeAdditionalExtensions(options.additionalExtensions)));
+	const rootAppShell = appShells.find((shell) => shell.directory === "");
+	const middlewareFile = findPagesMiddlewareFile(pagesDir, options.additionalExtensions);
+	const appConfig = options.target === "client" ? null : findPagesAppConfigFile(pagesDir);
+	const capabilitiesDir = options.capabilitiesDir === null ? null : options.capabilitiesDir ?? resolve(pagesDir, "..", "capabilities");
+	const capabilities = capabilitiesDir ? findPagesCapabilityFiles(capabilitiesDir) : [];
+	const lines = [`import { ${pages.some((page) => page.revalidateSeconds !== void 0) ? "defineApp, group, route, timeRevalidate" : "defineApp, group, route"} } from "@pracht/core/manifest";`];
+	const referenceBaseDir = options.referenceBaseDir ?? join(pagesDir, "..");
+	const relativeModuleRef = (file) => {
+		const path = relative(referenceBaseDir, file).replace(/\\/g, "/");
+		return path.startsWith(".") ? path : `./${path}`;
+	};
+	const pageFileRef = (page) => {
+		const path = prefix ? `${prefix}/${page.relativePath.replace(/\\/g, "/")}` : relativeModuleRef(page.absolutePath);
+		return useImport ? `() => import(${JSON.stringify(path)})` : JSON.stringify(path);
+	};
+	const capabilityFileRef = (file) => {
+		const path = options.capabilitiesDirPrefix && capabilitiesDir ? `${options.capabilitiesDirPrefix}/${relative(capabilitiesDir, file).replace(/\\/g, "/")}` : relativeModuleRef(file);
+		return useImport ? `() => import(${JSON.stringify(path)})` : JSON.stringify(path);
+	};
+	const appConfigImportIndex = lines.push("") - 1;
+	const usedAppConfigExports = [];
+	lines.push("");
+	const routeEntries = [];
+	const notFoundPage = pages.find((page) => page.routePath === "/404");
+	if (notFoundPage?.hasRevalidateExport) throw new Error(`[pracht] Pages not-found module ${JSON.stringify(notFoundPage.relativePath)} exports REVALIDATE, but not-found responses are never ISG routes.`);
+	if ((notFoundPage?.capabilities.length ?? 0) > 0) throw new Error(`[pracht] Pages not-found module ${JSON.stringify(notFoundPage.relativePath)} exports CAPABILITIES, but the not-found page does not participate in route-scoped WebMCP activation.`);
+	for (const page of pages) {
+		if (page === notFoundPage) continue;
+		const render = page.renderMode ?? defaultRender;
+		if (render === "isg" && page.revalidateSeconds === void 0) throw new Error(`[pracht] Pages route ${JSON.stringify(page.relativePath)} uses render mode "isg" but does not export a revalidation policy. Add \`export const REVALIDATE = 60\` with a positive integer number of seconds, or use another render mode.`);
+		if (render !== "isg" && page.hasRevalidateExport) throw new Error(`[pracht] Pages route ${JSON.stringify(page.relativePath)} exports REVALIDATE but its effective render mode is ${JSON.stringify(render)}. REVALIDATE is only valid with \`RENDER_MODE = "isg"\` (or \`pagesDefaultRender: "isg"\`).`);
+		if (page.streaming && (render !== "ssr" || (page.hydrationMode ?? "full") !== "full")) throw new Error(`[pracht] Pages route ${JSON.stringify(page.relativePath)} requires SSR and full hydration for STREAMING.`);
+		const fileRef = pageFileRef(page);
+		const metaParts = [
+			`render: ${JSON.stringify(render)}`,
+			`hasLoader: ${page.hasLoader ? "true" : "false"}`,
+			`hasHead: ${page.hasHead ? "true" : "false"}`
+		];
+		if (page.streaming !== void 0) metaParts.push(`streaming: ${page.streaming}`);
+		if (page.capabilities.length > 0) metaParts.push(`capabilities: ${JSON.stringify(page.capabilities)}`);
+		if (page.hydrationMode) metaParts.push(`hydration: ${JSON.stringify(page.hydrationMode)}`);
+		if (page.revalidateSeconds !== void 0) metaParts.push(`revalidate: timeRevalidate(${page.revalidateSeconds})`);
+		const owningShell = findOwningPagesShell(appShells, page.relativePath);
+		if (owningShell && owningShell !== rootAppShell) metaParts.push(`shell: ${JSON.stringify(owningShell.name)}`);
+		routeEntries.push(`    route(${JSON.stringify(page.routePath)}, ${fileRef}, { ${metaParts.join(", ")} })`);
+	}
+	const notFoundEntry = notFoundPage ? buildNotFoundEntry(notFoundPage, {
+		fileRef: pageFileRef(notFoundPage),
+		withShell: !!rootAppShell
+	}) : null;
+	const specialFileRef = (file) => {
+		const path = prefix ? `${prefix}/${relative(pagesDir, file).replace(/\\/g, "/")}` : relativeModuleRef(file);
+		return useImport ? `() => import(${JSON.stringify(path)})` : JSON.stringify(path);
+	};
+	const groupMetaParts = [];
+	if (rootAppShell) groupMetaParts.push("shell: \"pages\"");
+	if (middlewareFile) groupMetaParts.push("middleware: [\"pages\"]");
+	lines.push("const app = defineApp({");
+	for (const name of appConfig?.exports ?? []) {
+		usedAppConfigExports.push(name);
+		lines.push(`  ${name},`);
+	}
+	if (capabilities.length > 0) {
+		lines.push("  capabilities: {");
+		for (const capability of capabilities) lines.push(`    ${JSON.stringify(capability.name)}: ${capabilityFileRef(capability.absolutePath)},`);
+		lines.push("  },");
+	}
+	if (appShells.length > 0) {
+		lines.push("  shells: {");
+		for (const shell of [...appShells].reverse()) {
+			const key = /^[A-Za-z_$][\w$]*$/.test(shell.name) ? shell.name : JSON.stringify(shell.name);
+			lines.push(`    ${key}: ${specialFileRef(shell.absolutePath)},`);
+		}
+		lines.push("  },");
+	}
+	if (middlewareFile) {
+		lines.push("  middleware: {");
+		lines.push(`    pages: ${specialFileRef(middlewareFile)},`);
+		lines.push("  },");
+	}
+	lines.push("  routes: [");
+	if (groupMetaParts.length > 0) {
+		lines.push(`    group({ ${groupMetaParts.join(", ")} }, [`);
+		lines.push(routeEntries.join(",\n"));
+		lines.push("    ]),");
+	} else lines.push(routeEntries.join(",\n"));
+	lines.push("  ],");
+	if (notFoundEntry) lines.push(notFoundEntry);
+	lines.push("});");
+	if (appConfig && usedAppConfigExports.length > 0) {
+		const path = prefix ? `${prefix}/${relative(pagesDir, appConfig.absolutePath).replace(/\\/g, "/")}` : relativeModuleRef(appConfig.absolutePath);
+		lines[appConfigImportIndex] = `import { ${usedAppConfigExports.join(", ")} } from ${JSON.stringify(path)};`;
+	} else lines.splice(appConfigImportIndex, 1);
+	lines.push("");
+	return lines.join("\n");
+}
+function buildNotFoundEntry(page, options) {
+	const configParts = [`component: ${options.fileRef}`];
+	if (options.withShell) configParts.push("shell: \"pages\"");
+	if (page.hydrationMode) configParts.push(`hydration: ${JSON.stringify(page.hydrationMode)}`);
+	return `  notFound: { ${configParts.join(", ")} },`;
+}
+function scanAllFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		if (statSync(abs).isDirectory()) results.push(...scanAllFiles(abs));
+		else results.push(abs);
+	}
+	return results;
+}
+function scanAllDirectories(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		if (!statSync(abs).isDirectory()) continue;
+		results.push(abs, ...scanAllDirectories(abs));
+	}
+	return results;
+}
+function generateRoutesFile(pagesDir, outputPath, options) {
+	const resolvedOutputPath = resolve(outputPath);
+	const manifestSource = generatePagesManifestSource(scanPagesDirectory(pagesDir, options.additionalExtensions).filter((page) => resolve(page.absolutePath) !== resolvedOutputPath), {
+		...options,
+		referenceBaseDir: dirname(outputPath),
+		useImportSyntax: true
+	}).replace("const app = defineApp(", "export const app = defineApp(");
+	writeFileSync(outputPath, [
+		`// ${GENERATED_PAGES_MANIFEST_MARKER}`,
+		"// Keep this exported marker: the client build uses it to preserve pages-router",
+		"// server-only boundaries after ejection without guessing from manifest syntax.",
+		`export const ${GENERATED_PAGES_LAYOUT_EXPORT} = true;`,
+		"// To use it directly: remove `pagesDir` from the pracht config, set `appFile` to this",
+		"// file, and point `routesDir`/`shellsDir`/`middlewareDir` at the pages directory (or",
+		"// move the referenced files into the conventional directories). The runtime resolves",
+		"// manifest refs through those directory registries.",
+		"",
+		manifestSource
+	].join("\n"), "utf-8");
+}
+//#endregion
+export { withAdditionalExtensions as C, isPrefreshCompatibleId as D, isPrachtClientModuleId as E, stripPrachtClientModuleQuery as O, normalizeAdditionalExtensions as S, getRolldownLang as T, createRouteLoaderHints as _, filePathToRoutePath as a, LEGACY_BARE_ROUTE_EXTENSIONS as b, findPagesAppShellFiles as c, generatePagesManifestSource as d, generateRoutesFile as f, createRouteHints as g, sortRoutes as h, PAGES_APP_CONFIG_EXPORTS$1 as i, toPrachtClientPrefreshId as k, findPagesCapabilityFiles as l, scanPagesDirectory as m, GENERATED_PAGES_MANIFEST_MARKER as n, findOwningPagesShell$1 as o, pagesShellName$1 as p, PAGES_APP_CONFIG_BASENAME as r, findPagesAppConfigFile as s, GENERATED_PAGES_LAYOUT_EXPORT as t, findPagesMiddlewareFile as u, DEFAULT_ROUTE_EXTENSIONS as v, PRACHT_CLIENT_MODULE_QUERY as w, extensionGlob as x, DEFAULT_SHELL_EXTENSIONS as y };