@pracht/vite-plugin 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -1,83 +1,17 @@
-import { c as createRouteLoaderHints, d as LEGACY_BARE_ROUTE_EXTENSIONS, f as extensionGlob, i as scanPagesDirectory, l as createRouteStaticPathsHints, m as withAdditionalExtensions, n as generatePagesManifestSource, o as createRouteHeadHints, p as normalizeAdditionalExtensions, s as createRouteHeadersHints, u as DEFAULT_ROUTE_EXTENSIONS } from "./pages-router-MA9rOl88.mjs";
+import { C as withAdditionalExtensions, D as isPrefreshCompatibleId, E as isPrachtClientModuleId, O as stripPrachtClientModuleQuery, S as normalizeAdditionalExtensions, T as getRolldownLang, _ as createRouteLoaderHints, b as LEGACY_BARE_ROUTE_EXTENSIONS, d as generatePagesManifestSource, g as createRouteHints, k as toPrachtClientPrefreshId, m as scanPagesDirectory, t as GENERATED_PAGES_LAYOUT_EXPORT, v as DEFAULT_ROUTE_EXTENSIONS, w as PRACHT_CLIENT_MODULE_QUERY, x as extensionGlob, y as DEFAULT_SHELL_EXTENSIONS } from "./pages-router-BI34Cani.mjs";
 import { createRequire, isBuiltin } from "node:module";
 import { preactSsrPrecompile } from "@pracht/preact-ssr-precompile";
 import preact from "@preact/preset-vite";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
-import { loadEnv, parseAst } from "vite";
+import { loadEnv, parseAst, runnerImport } from "vite";
 import { PRACHT_GRAPH_ONLY_ENV } from "@pracht/core/server";
+import { PUBLIC_ENV_PREFIX, VITE_BUILTIN_ENV_VARS, WHOLE_ENV_READ, extractCapabilityProjection, extractCapabilityRegistrations, extractDefineAppObjectBody, scanCodeForEnvLeaks, scanCodeForEnvLeaks as scanCodeForEnvLeaks$1, scanTopLevelProperties } from "@pracht/capabilities/static";
 import { DEV_ROUTE_DATA_STALE_EVENT } from "@pracht/core/client";
 import { CAPABILITY_SETTLED_EVENT, CAPABILITY_TRANSPORT_HEADER, CONFIRMATION_HEADER } from "@pracht/capabilities";
-import { extractCapabilityProjection, extractCapabilityRegistrations, extractDefineAppObjectBody, scanTopLevelProperties } from "@pracht/capabilities/static";
 import { createNodeServerEntryModule } from "@pracht/adapter-node";
 import { Readable } from "node:stream";
-import { applyDefaultSecurityHeaders, resolveRegistryModule } from "@pracht/core";
-//#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
+import { applyDefaultSecurityHeaders, normalizeResponseHeaders, resolveRegistryModule } from "@pracht/core";
 //#region src/scope-analysis-types.ts
 const JSX_COMPONENT_RE = /^[A-Z]/;
 const SKIPPED_KEYS = new Set([
@@ -692,15 +626,19 @@ const SERVER_ONLY_EXPORTS = new Set([
 	"getStaticPaths",
 	"markdown"
 ]);
-function stripServerOnlyExportsForClient(code, id = "pracht-client-route.tsx") {
+function stripServerOnlyExportsForClient(code, id = "pracht-client-route.tsx", options = {}) {
 	const states = createStatementStates(parseAst(code, { lang: getRolldownLang(id) }));
+	if (options.middleware === true) {
+		for (const state of states) state.removed = true;
+		return renderProgram(code, states);
+	}
 	const initialBindingNames = collectCurrentTopLevelBindingNames(states);
-	const { changed, candidates } = removeServerOnlyExports(states, initialBindingNames);
+	const { changed, candidates } = removeServerOnlyExports(states, initialBindingNames, SERVER_ONLY_EXPORTS);
 	if (!changed) return code;
 	pruneDeadBindings(states, initialBindingNames, candidates);
 	return renderProgram(code, states);
 }
-function removeServerOnlyExports(states, initialBindingNames) {
+function removeServerOnlyExports(states, initialBindingNames, serverOnlyExports) {
 	let changed = false;
 	const candidates = /* @__PURE__ */ new Set();
 	for (const state of states) {
@@ -709,14 +647,14 @@ function removeServerOnlyExports(states, initialBindingNames) {
 		const declaration = statement.declaration;
 		if (declaration?.type === "FunctionDeclaration") {
 			const name = declaration.id?.name;
-			if (!name || !SERVER_ONLY_EXPORTS.has(name)) continue;
+			if (!name || !serverOnlyExports.has(name)) continue;
 			changed = true;
 			state.removed = true;
 			enqueueDependencies(candidates, collectTopLevelReferences(declaration, initialBindingNames, new Set([name])));
 			continue;
 		}
 		if (declaration?.type === "VariableDeclaration") {
-			const removable = getRemainingDeclaratorIndices(state).filter((index) => collectBindingNamesFromPattern(declaration.declarations[index].id).some((name) => SERVER_ONLY_EXPORTS.has(name)));
+			const removable = getRemainingDeclaratorIndices(state).filter((index) => collectBindingNamesFromPattern(declaration.declarations[index].id).some((name) => serverOnlyExports.has(name)));
 			if (removable.length === 0) continue;
 			changed = true;
 			for (const index of removable) {
@@ -733,7 +671,7 @@ function removeServerOnlyExports(states, initialBindingNames) {
 			if (specifier.type !== "ExportSpecifier" || specifier.exportKind === "type") return false;
 			const localName = getIdentifierName(specifier.local);
 			const exportedName = getIdentifierName(specifier.exported);
-			return SERVER_ONLY_EXPORTS.has(localName ?? "") || SERVER_ONLY_EXPORTS.has(exportedName ?? "");
+			return serverOnlyExports.has(localName ?? "") || serverOnlyExports.has(exportedName ?? "");
 		});
 		if (removableSpecifiers.length === 0) continue;
 		changed = true;
@@ -1016,243 +954,14 @@ function isRecord(value) {
 }
 //#endregion
 //#region src/env-safety.ts
-/**
-* Env vars Vite defines on `import.meta.env` in every bundle, plus NODE_ENV
-* which Vite's define pass statically replaces at build time (so it can never
-* leak and is referenced by countless dependencies).
-*/
-const VITE_BUILTIN_ENV_VARS = new Set([
-	"MODE",
-	"DEV",
-	"PROD",
-	"SSR",
-	"BASE_URL",
-	"NODE_ENV"
-]);
-/** Prefix that marks an env var as intentionally public. */
-const PUBLIC_ENV_PREFIX = "PRACHT_PUBLIC_";
 /** Server-only core entry that must never resolve into client bundles. */
 const SERVER_ENV_MODULE_ID = "@pracht/core/env/server";
-const ENV_REFERENCE_RE = /\b(process\.env|import\.meta\.env)(?:\??\.([A-Za-z_$][A-Za-z0-9_$]*)|(?:\?\.)?\[\s*(["'])([A-Za-z_$][A-Za-z0-9_$]*)\3\s*\])/g;
-const WHOLE_ENV_READ_RE = /\bimport\.meta\.env\b(?!\s*\??\.\s*[A-Za-z_$])/g;
-/**
-* Scans JavaScript source for references to environment variables that are
-* neither public-prefixed, Vite built-ins, nor explicitly allowed, plus reads
-* that pull in the whole `import.meta.env` object.
-*/
-function scanCodeForEnvLeaks(code, allow = /* @__PURE__ */ new Set()) {
-	const codePositions = getCodePositionMask(code);
-	const matches = [];
-	for (const match of code.matchAll(ENV_REFERENCE_RE)) {
-		const index = match.index ?? -1;
-		if (!codePositions[index]) continue;
-		const accessor = match[1];
-		const name = match[2] ?? match[4];
-		if (!name) continue;
-		if (name.startsWith("PRACHT_PUBLIC_")) continue;
-		if (VITE_BUILTIN_ENV_VARS.has(name)) continue;
-		if (allow.has(name)) continue;
-		matches.push({
-			index,
-			reference: {
-				accessor,
-				name
-			}
-		});
-	}
-	if (!allow.has("*")) for (const match of code.matchAll(WHOLE_ENV_READ_RE)) {
-		const index = match.index ?? -1;
-		if (!codePositions[index]) continue;
-		matches.push({
-			index,
-			reference: {
-				accessor: "import.meta.env",
-				name: "*"
-			}
-		});
-	}
-	const findings = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const { reference } of matches.sort((a, b) => a.index - b.index)) {
-		const key = `${reference.accessor}.${reference.name}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		findings.push(reference);
-	}
-	return findings;
-}
-function getCodePositionMask(code) {
-	const mask = new Uint8Array(code.length);
-	const templateExpressionDepths = [];
-	let mode = "code";
-	let regexCharClass = false;
-	let i = 0;
-	while (i < code.length) {
-		const char = code[i];
-		const next = code[i + 1];
-		if (mode === "line-comment") {
-			if (char === "\n" || char === "\r") {
-				mode = "code";
-				mask[i] = 1;
-			}
-			i++;
-			continue;
-		}
-		if (mode === "block-comment") {
-			if (char === "*" && next === "/") {
-				mode = "code";
-				i += 2;
-			} else i++;
-			continue;
-		}
-		if (mode === "single" || mode === "double") {
-			const quote = mode === "single" ? "'" : "\"";
-			if (char === "\\") {
-				i += 2;
-				continue;
-			}
-			if (char === quote || char === "\n" || char === "\r") mode = "code";
-			i++;
-			continue;
-		}
-		if (mode === "regex") {
-			if (char === "\\") {
-				i += 2;
-				continue;
-			}
-			if (char === "[") {
-				regexCharClass = true;
-				i++;
-				continue;
-			}
-			if (char === "]") {
-				regexCharClass = false;
-				i++;
-				continue;
-			}
-			if (char === "/" && !regexCharClass) {
-				regexCharClass = false;
-				i++;
-				while (i < code.length && isIdentifierChar(code[i])) i++;
-				mode = "code";
-				continue;
-			}
-			if (char === "\n" || char === "\r") {
-				regexCharClass = false;
-				mode = "code";
-			}
-			i++;
-			continue;
-		}
-		if (mode === "template") {
-			if (char === "\\") {
-				i += 2;
-				continue;
-			}
-			if (char === "`") {
-				mode = "code";
-				i++;
-				continue;
-			}
-			if (char === "$" && next === "{") {
-				mask[i] = 1;
-				mask[i + 1] = 1;
-				templateExpressionDepths.push(1);
-				mode = "code";
-				i += 2;
-				continue;
-			}
-			i++;
-			continue;
-		}
-		mask[i] = 1;
-		if (char === "/" && next === "/") {
-			mask[i + 1] = 1;
-			mode = "line-comment";
-			i += 2;
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			mask[i + 1] = 1;
-			mode = "block-comment";
-			i += 2;
-			continue;
-		}
-		if (char === "/" && isRegexLiteralStart(code, i)) {
-			mode = "regex";
-			regexCharClass = false;
-			i++;
-			continue;
-		}
-		if (char === "'") {
-			mode = "single";
-			i++;
-			continue;
-		}
-		if (char === "\"") {
-			mode = "double";
-			i++;
-			continue;
-		}
-		if (char === "`") {
-			mode = "template";
-			i++;
-			continue;
-		}
-		if (templateExpressionDepths.length > 0) {
-			const top = templateExpressionDepths.length - 1;
-			if (char === "{") templateExpressionDepths[top]++;
-			else if (char === "}") {
-				templateExpressionDepths[top]--;
-				if (templateExpressionDepths[top] === 0) {
-					templateExpressionDepths.pop();
-					mode = "template";
-				}
-			}
-		}
-		i++;
-	}
-	return mask;
-}
-function isRegexLiteralStart(code, slashIndex) {
-	let i = slashIndex - 1;
-	while (i >= 0 && /\s/.test(code[i])) i--;
-	if (i < 0) return true;
-	const previous = code[i];
-	if (previous === ">" && code[i - 1] === "=") return true;
-	if ("([{=,:;!?&|^~<>*%+-".includes(previous)) return true;
-	if (isIdentifierChar(previous)) {
-		let start = i;
-		while (start >= 0 && isIdentifierChar(code[start])) start--;
-		const word = code.slice(start + 1, i + 1);
-		return new Set([
-			"await",
-			"case",
-			"delete",
-			"do",
-			"else",
-			"in",
-			"instanceof",
-			"new",
-			"of",
-			"return",
-			"throw",
-			"typeof",
-			"void",
-			"yield"
-		]).has(word);
-	}
-	return false;
-}
-function isIdentifierChar(char) {
-	return !!char && /[A-Za-z0-9_$]/.test(char);
-}
 function formatEnvLeakError(problems) {
 	const lines = problems.map((problem) => {
 		const source = problem.sources.length > 0 ? ` (likely from ${problem.sources.map((file) => JSON.stringify(file)).join(", ")})` : "";
-		return `  - ${problem.name === "*" ? "import.meta.env read as a whole object" : `${problem.accessor}.${problem.name}`} in chunk "${problem.chunk}"${source}`;
+		return `  - ${problem.name === WHOLE_ENV_READ ? "import.meta.env read as a whole object" : `${problem.accessor}.${problem.name}`} in chunk "${problem.chunk}"${source}`;
 	});
-	const wholeEnvGuidance = problems.some((problem) => problem.name === "*") ? [
+	const wholeEnvGuidance = problems.some((problem) => problem.name === WHOLE_ENV_READ) ? [
 		"",
 		"A whole-object `import.meta.env` read (bare reference, destructuring, spread, or bracket access)",
 		"is replaced at build time by an object literal containing every exposed variable — including the",
@@ -1293,7 +1002,7 @@ function createEnvSafetyPlugin(envSafety) {
 			if (transformOptions?.ssr) return null;
 			const moduleId = stripIdQuery(id);
 			if (moduleId.includes("node_modules")) return null;
-			const findings = scanCodeForEnvLeaks(code, allow);
+			const findings = scanCodeForEnvLeaks$1(code, allow);
 			if (findings.length > 0) moduleEnvReferences.set(moduleId, findings);
 			return null;
 		},
@@ -1321,7 +1030,7 @@ function createEnvSafetyPlugin(envSafety) {
 						sources: [moduleId]
 					});
 				}
-				for (const finding of scanCodeForEnvLeaks(output.code, allow)) {
+				for (const finding of scanCodeForEnvLeaks$1(output.code, allow)) {
 					const sources = moduleIds.filter((moduleId) => moduleEnvReferences.get(moduleId)?.some((reference) => reference.name === finding.name));
 					addProblem({
 						...finding,
@@ -1499,12 +1208,13 @@ const ISLANDS_CLIENT_BROWSER_PATH = "/@pracht/islands.js";
 function assetUrl(file, base) {
 	return `${base}${file}`;
 }
-function readClientBuildAssets(root = process.cwd(), base = "/") {
+function readClientBuildAssets(root = process.cwd(), base = "/", inlineCss = false) {
 	const manifestPath = ["dist/client/.vite/manifest.json", "dist/.vite/manifest.json"].map((candidate) => resolve(root, candidate)).find((candidate) => existsSync(candidate));
 	if (!manifestPath) return {
 		clientEntryUrl: null,
 		islandsEntryUrl: null,
 		cssManifest: {},
+		cssContentManifest: {},
 		jsManifest: {}
 	};
 	const rawManifest = readFileSync(manifestPath, "utf-8");
@@ -1512,12 +1222,20 @@ function readClientBuildAssets(root = process.cwd(), base = "/") {
 	const clientEntry = manifest[PRACHT_CLIENT_MODULE_ID];
 	const islandsEntry = manifest[PRACHT_ISLANDS_CLIENT_MODULE_ID];
 	const cssManifest = {};
+	const cssContentManifest = {};
 	const jsManifest = {};
+	const clientOutDir = dirname(dirname(manifestPath));
 	for (const [key, entry] of Object.entries(manifest)) {
 		if (!entry.src) continue;
 		const deps = collectTransitiveDeps(manifest, key);
 		const manifestKey = stripPrachtClientModuleQuery(entry.src);
-		if (deps.css.length > 0) cssManifest[manifestKey] = deps.css.map((f) => assetUrl(f, base));
+		if (deps.css.length > 0) {
+			cssManifest[manifestKey] = deps.css.map((f) => assetUrl(f, base));
+			if (inlineCss) for (const file of deps.css) {
+				const url = assetUrl(file, base);
+				cssContentManifest[url] ??= readFileSync(resolve(clientOutDir, file), "utf-8");
+			}
+		}
 		if (deps.js.length > 0) jsManifest[manifestKey] = deps.js.map((f) => assetUrl(f, base));
 	}
 	addEntryDeps(manifest, jsManifest, PRACHT_CLIENT_MODULE_ID, clientEntry, base);
@@ -1526,6 +1244,7 @@ function readClientBuildAssets(root = process.cwd(), base = "/") {
 		clientEntryUrl: clientEntry ? assetUrl(clientEntry.file, base) : null,
 		islandsEntryUrl: islandsEntry ? assetUrl(islandsEntry.file, base) : null,
 		cssManifest,
+		cssContentManifest,
 		jsManifest
 	};
 }
@@ -1584,10 +1303,14 @@ function createDefaultNodeAdapter() {
 }
 //#endregion
 //#region src/plugin-options.ts
-const CLIENT_FEATURE_DEFAULTS = { prefetch: true };
+const CLIENT_FEATURE_DEFAULTS = {
+	prefetch: true,
+	navigationGuards: true
+};
 const DEFAULTS = {
 	client: CLIENT_FEATURE_DEFAULTS,
 	vendorChunk: true,
+	inlineCss: false,
 	appFile: "/src/routes.ts",
 	middlewareDir: "/src/middleware",
 	routesDir: "/src/routes",
@@ -1615,6 +1338,7 @@ function resolveOptions(options) {
 	if (resolved.llmsTxt === void 0) resolved.llmsTxt = false;
 	resolved.client = resolveClientOptions(options.client);
 	if (typeof resolved.vendorChunk !== "boolean") throw new Error(`pracht({ vendorChunk }) expects a boolean, got ${JSON.stringify(resolved.vendorChunk)}.`);
+	if (typeof resolved.inlineCss !== "boolean") throw new Error(`pracht({ inlineCss }) expects a boolean, got ${JSON.stringify(resolved.inlineCss)}.`);
 	resolved.additionalExtensions = normalizeAdditionalExtensions(resolved.additionalExtensions);
 	if (!new Set([
 		"spa",
@@ -1677,18 +1401,50 @@ function validateBudgets(budgets) {
 * capability sources — the same approach the plugin already uses for
 * hydration-mode excludes. Only serializable metadata crosses the boundary:
 * capability names, HTTP endpoints, effects, and (for WebMCP tools)
-* description and input schema.
+* description and input schema. Inline JSON Schema remains a zero-execution
+* fast path; imported Standard JSON Schemas are resolved by loading the
+* server-only capability module during WebMCP code generation and serializing
+* only the converted schema.
 *
 * The static analyzer itself lives in `@pracht/capabilities/static` and is
 * shared with `pracht verify`, so the build and verification can never
-* disagree about what is analyzable. Constraint it imposes: a capability's
-* `expose`, HTTP-projected `effect`, and WebMCP `input` values must be inline
-* literals (no imported constants or spreads) — the extractor parses the
-* literal text as data.
+* disagree about what is analyzable. A capability's `expose` and
+* HTTP-projected `effect` stay inline literals because they decide which
+* client endpoints exist. WebMCP `input` may instead be a Standard JSON
+* Schema: codegen resolves it through the server module without putting the
+* validator or capability implementation in the client graph.
 * Extraction failures fail the build with a pointer to the offending file
 * rather than silently dropping an endpoint.
 */
 /**
+* The app manifest source these analyzers read.
+*
+* In pages mode there is no manifest file, so the generated one is
+* synthesized here — the exact source the virtual module serves. Analyzing the
+* generated text rather than re-deriving the registry from the file system is
+* what keeps pages mode and manifest mode from ever disagreeing about which
+* capabilities exist and how they are exposed.
+*
+* Throws when the manifest cannot be read or the pages tree is invalid; each
+* caller decides whether that means "assume the worst" or "report nothing".
+*/
+function readAppManifestSource(resolved, root) {
+	if (!resolved.pagesDir) return readFileSync(resolve(root, resolved.appFile.replace(/^\//, "")), "utf-8");
+	const pagesDir = resolve(root, resolved.pagesDir.replace(/^\//, ""));
+	return generatePagesManifestSource(scanPagesDirectory(pagesDir, [...resolved.additionalExtensions]), {
+		additionalExtensions: resolved.additionalExtensions,
+		capabilitiesDir: resolve(root, resolved.capabilitiesDir.replace(/^\//, "")),
+		capabilitiesDirPrefix: resolved.capabilitiesDir,
+		pagesDir,
+		pagesDefaultRender: resolved.pagesDefaultRender,
+		pagesDirPrefix: resolved.pagesDir
+	}).replace("const app = defineApp(", "export const app = defineApp(");
+}
+/** The directory manifest-relative module refs resolve against. */
+function appManifestDir(resolved, root) {
+	return resolved.pagesDir ? resolve(root, resolved.pagesDir.replace(/^\//, ""), "..") : dirname(resolve(root, resolved.appFile.replace(/^\//, "")));
+}
+/**
 * Whether the app can reach the agent surface at all — registered capabilities
 * or a `defineApp({ agents })` config. Drives the `__PRACHT_AGENT_SURFACE__`
 * define, which lets the bundler drop the capability and Web Bot Auth runtimes
@@ -1703,11 +1459,9 @@ function validateBudgets(budgets) {
 */
 function hasAgentSurface(options = {}, root = process.cwd()) {
 	const resolved = resolveOptions(options);
-	if (resolved.pagesDir) return false;
-	const appFileAbs = resolve(root, resolved.appFile.replace(/^\//, ""));
 	let manifestSource;
 	try {
-		manifestSource = readFileSync(appFileAbs, "utf-8");
+		manifestSource = readAppManifestSource(resolved, root);
 	} catch {
 		return true;
 	}
@@ -1765,23 +1519,21 @@ function hasOpaqueTopLevelProperty(objectBody) {
 	return false;
 }
 /**
-* Extract capability registrations (name → module path) from the app
-* manifest source and their exposure metadata from each capability source.
-* Pages-router apps have no manifest, so capabilities are manifest-mode only.
+* Extract capability registrations (name → module path) from a manifest app
+* or the pages router's generated manifest, then read exposure metadata from
+* each capability source.
 */
 function extractCapabilities(options = {}, root = process.cwd()) {
 	const resolved = resolveOptions(options);
-	if (resolved.pagesDir) return [];
-	const appFileAbs = resolve(root, resolved.appFile.replace(/^\//, ""));
 	let manifestSource;
 	try {
-		manifestSource = readFileSync(appFileAbs, "utf-8");
+		manifestSource = readAppManifestSource(resolved, root);
 	} catch {
 		return [];
 	}
 	const registrations = extractCapabilityRegistrations(manifestSource);
 	if (registrations.length === 0) return [];
-	const appDir = dirname(appFileAbs);
+	const appDir = appManifestDir(resolved, root);
 	return registrations.map(({ name, file }) => {
 		const capabilityFileAbs = file.startsWith("/") ? resolve(root, file.replace(/^\//, "")) : resolve(appDir, file);
 		let source;
@@ -1808,15 +1560,13 @@ function extractCapabilities(options = {}, root = process.cwd()) {
 */
 function resolveCapabilityModulePaths(options = {}, root = process.cwd()) {
 	const resolved = resolveOptions(options);
-	if (resolved.pagesDir) return [];
-	const appFileAbs = resolve(root, resolved.appFile.replace(/^\//, ""));
 	let manifestSource;
 	try {
-		manifestSource = readFileSync(appFileAbs, "utf-8");
+		manifestSource = readAppManifestSource(resolved, root);
 	} catch {
 		return [];
 	}
-	const appDir = dirname(appFileAbs);
+	const appDir = appManifestDir(resolved, root);
 	return extractCapabilityRegistrations(manifestSource).map(({ file }) => file.startsWith("/") ? resolve(root, file.replace(/^\//, "")) : resolve(appDir, file));
 }
 function extractCapabilityMetadata(name, file, source) {
@@ -1973,73 +1723,110 @@ function createPrachtCapabilitiesClientModuleSource(options = {}, buildOptions =
 	].join("\n");
 }
 /**
-* Generate `virtual:pracht/webmcp` — the disposable WebMCP registration shim.
-* One page tool per `expose.webmcp` capability; `execute` dispatches through
+* Generate `virtual:pracht/webmcp` — the WebMCP registration shim.
+* One page tool per `expose.webmcp` capability; dispatch goes through
 * `callCapability`, so the user's session authenticates the call and all
 * validation/middleware/policy stays server-side. Each dispatch carries the
 * transport marker header so audit events can attribute it to WebMCP.
 *
-* Targets the WebMCP CG draft API: `document.modelContext.registerTool()`
-* (ChatGPT desktop's built-in browser; Chromium 150+ within the 149–156
-* origin trial — the `document` getter landed in 150 and the deprecated
-* `navigator.modelContext` alias was removed in 152, so trial builds before
-* 150 are not targeted and no fallback is kept; current polyfills install the
-* `document` shape). No-ops silently when the API is absent.
-*
-* `execute()` returns the capability envelope (`{ ok, data }` /
-* `{ ok: false, error }`) as a plain object: per the spec the host serializes
-* the returned value itself, so wrapping it in MCP-style content blocks would
-* reach the agent double-encoded.
+* The registration runtime — feature detection, `registerTool()` calls, and
+* the WebMCP annotation policy — lives in
+* `@pracht/capabilities/webmcp` (published, so non-pracht sites register tools
+* with identical semantics); this module only
+* contributes the statically extracted tool metadata and the app-specific
+* dispatch. The registrar import is resolved from *this plugin's* copy of
+* `@pracht/capabilities` at codegen time: the virtual module has no importer
+* on disk, so a bare specifier would resolve against the app root — where an
+* older installed copy may predate the `./webmcp` entry point. The registrar
+* is stateless, so using the plugin's copy cannot split state.
 */
 function createPrachtWebmcpModuleSource(options = {}, buildOptions = {}) {
-	const tools = extractCapabilities(options, buildOptions.root).filter((capability) => capability.webmcp).map((capability) => ({
+	const capabilities = extractCapabilities(options, buildOptions.root).filter((capability) => capability.webmcp);
+	const unresolved = capabilities.find((capability) => !capability.inputSchema);
+	if (unresolved) throw new Error(`[pracht] Capability ${JSON.stringify(unresolved.name)} (${unresolved.file}) uses a non-literal WebMCP input schema. Vite resolves it from the server module during normal codegen; callers of createPrachtWebmcpModuleSource() must supply inline JSON Schema.`);
+	return buildPrachtWebmcpModuleSource(capabilities.map(webmcpTool));
+}
+async function createPrachtWebmcpModuleSourceAsync(options = {}, buildOptions = {}) {
+	const capabilities = extractCapabilities(options, buildOptions.root).filter((capability) => capability.webmcp);
+	const root = buildOptions.root ?? process.cwd();
+	const appDir = appManifestDir(resolveOptions(options), root);
+	const loadCapability = buildOptions.loadCapability ?? (async (file) => {
+		return (await runnerImport(file, {
+			...buildOptions.runnerConfig,
+			root,
+			logLevel: "silent"
+		})).module.default;
+	});
+	return buildPrachtWebmcpModuleSource(await Promise.all(capabilities.map(async (capability) => {
+		let title = capability.title;
+		let description = capability.description;
+		let inputSchema = capability.inputSchema;
+		if (!inputSchema) {
+			const file = capability.file.startsWith("/") ? resolve(root, capability.file.replace(/^\//, "")) : resolve(appDir, capability.file);
+			let loaded;
+			try {
+				loaded = await loadCapability(file);
+			} catch (error) {
+				throw new Error(`[pracht] Capability ${JSON.stringify(capability.name)} (${capability.file}) uses a non-literal WebMCP input schema, but its server module could not be loaded to derive that schema: ${error instanceof Error ? error.message : String(error)}. Keep the input as inline JSON Schema, or make the schema module loadable in the Node build environment.`);
+			}
+			if (!loaded || typeof loaded !== "object" || Array.isArray(loaded)) throw new Error(`[pracht] Capability ${JSON.stringify(capability.name)} (${capability.file}) did not default-export a capability object while deriving its WebMCP input schema.`);
+			const runtime = loaded;
+			if (!runtime.input || typeof runtime.input !== "object" || Array.isArray(runtime.input)) throw new Error(`[pracht] Capability ${JSON.stringify(capability.name)} (${capability.file}) did not resolve its WebMCP input to a JSON Schema object.`);
+			inputSchema = runtime.input;
+			if (typeof runtime.title === "string") title = runtime.title;
+			if (typeof runtime.description === "string") description = runtime.description;
+		}
+		return webmcpTool({
+			...capability,
+			title,
+			description,
+			inputSchema
+		});
+	})));
+}
+function webmcpTool(capability) {
+	return {
 		name: capability.name,
 		...capability.title ? { title: capability.title } : {},
 		description: capability.description,
 		inputSchema: capability.inputSchema,
-		annotations: {
-			readOnlyHint: capability.effect === "read",
-			...capability.effect === "read" ? { destructiveHint: false } : {},
-			idempotentHint: capability.effect === "read",
-			...capability.webmcpUntrustedContent ? { untrustedContentHint: true } : {}
-		}
-	}));
+		...capability.effect ? { effect: capability.effect } : {},
+		...capability.webmcpUntrustedContent ? { untrustedContent: true } : {}
+	};
+}
+function buildPrachtWebmcpModuleSource(tools) {
 	return [
 		"// Generated by @pracht/vite-plugin — WebMCP page-tool registration shim.",
+		`import { registerWebmcpTools } from ${JSON.stringify(resolveWebmcpRegistrarSpecifier())};`,
 		"import { callCapability } from \"virtual:pracht/capabilities\";",
 		"",
 		`const tools = ${JSON.stringify(tools)};`,
+		"const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));",
 		`const transportHeaders = { ${JSON.stringify(CAPABILITY_TRANSPORT_HEADER)}: "webmcp" };`,
+		"let registrationController;",
+		"let activeNames = import.meta.hot?.data.activeNames ?? [];",
 		"",
-		"export function registerPrachtWebmcpTools() {",
-		"  const modelContext =",
-		"    (typeof document !== \"undefined\" && document.modelContext) || null;",
-		"  if (!modelContext || typeof modelContext.registerTool !== \"function\") {",
-		"    return false;",
-		"  }",
-		"  for (const tool of tools) {",
-		"    try {",
-		"      const registration = modelContext.registerTool({",
-		"        ...tool,",
-		"        async execute(input, { signal } = {}) {",
-		"          return callCapability(tool.name, input, {",
-		"            headers: transportHeaders,",
-		"            signal,",
-		"          });",
-		"        },",
-		"      });",
-		"      if (registration && typeof registration.catch === \"function\") {",
-		"        registration.catch(() => {});",
-		"      }",
-		"    } catch {",
-		"      // The API is still an origin-trial surface; a failed registration",
-		"      // must never break the page.",
-		"    }",
-		"  }",
-		"  return true;",
+		"export function registerPrachtWebmcpTools(names) {",
+		"  activeNames = [...new Set(names)];",
+		"  registrationController?.abort();",
+		"  registrationController = new AbortController();",
+		"  return registerWebmcpTools(activeNames.flatMap((name) => {",
+		"    const tool = toolsByName.get(name);",
+		"    return tool ? [tool] : [];",
+		"  }), (name, input, { signal } = {}) =>",
+		"    callCapability(name, input, { headers: transportHeaders, signal }),",
+		"    { signal: registrationController.signal },",
+		"  );",
 		"}",
 		"",
-		"registerPrachtWebmcpTools();",
+		"if (import.meta.hot) {",
+		"  import.meta.hot.dispose((data) => {",
+		"    data.activeNames = activeNames;",
+		"    registrationController?.abort();",
+		"  });",
+		"}",
+		"",
+		"if (activeNames.length > 0) registerPrachtWebmcpTools(activeNames);",
 		""
 	].join("\n");
 }
@@ -2050,13 +1837,36 @@ function createPrachtWebmcpModuleSource(options = {}, buildOptions = {}) {
 */
 function createWebmcpBootstrapSource() {
 	return [
-		"// WebMCP page tools — loaded only when the browser exposes the API.",
-		"if (typeof document !== \"undefined\" && document.modelContext) {",
-		"  import(\"virtual:pracht/webmcp\").catch(() => {});",
+		"// WebMCP page tools — the active route owns the registration lifetime.",
+		"let webmcpRouteGeneration = 0;",
+		"let webmcpModulePromise;",
+		"function syncPrachtWebmcpTools(capabilities) {",
+		"  const generation = ++webmcpRouteGeneration;",
+		"  if (typeof document === \"undefined\" || !document.modelContext) return;",
+		"  if (capabilities.length === 0 && !webmcpModulePromise) return;",
+		"  webmcpModulePromise ??= import(\"virtual:pracht/webmcp\");",
+		"  webmcpModulePromise.then((module) => {",
+		"    if (generation === webmcpRouteGeneration) {",
+		"      module.registerPrachtWebmcpTools(capabilities);",
+		"    }",
+		"  }).catch(() => {});",
 		"}",
 		""
 	];
 }
+/**
+* Absolute module specifier for `@pracht/capabilities/webmcp`, resolved from
+* this plugin so the generated shim never depends on the app root carrying a
+* new-enough copy. Falls back to the bare specifier if resolution fails
+* (tests with unusual layouts); Vite then resolves it from the app root.
+*/
+function resolveWebmcpRegistrarSpecifier() {
+	try {
+		return createRequire(import.meta.url).resolve("@pracht/capabilities/webmcp").split("\\").join("/");
+	} catch {
+		return "@pracht/capabilities/webmcp";
+	}
+}
 function hasWebmcpCapabilities(options = {}, root = process.cwd()) {
 	try {
 		return extractCapabilities(options, root).some((capability) => capability.webmcp);
@@ -2156,19 +1966,29 @@ function createNonFullHydrationExcludes(resolved, root = process.cwd()) {
 function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 	const resolved = resolveOptions(options);
 	const isPagesMode = !!resolved.pagesDir;
-	const routeLoaderHints = createRouteLoaderHintsForVirtualModules(resolved, buildOptions.root);
-	const routeHeadHints = createRouteHeadHintsForVirtualModules(resolved, buildOptions.root);
-	const routeStaticPathsHints = createRouteStaticPathsHintsForVirtualModules(resolved, buildOptions.root);
-	const appImport = isPagesMode ? generatePagesAppInlineSource(resolved, buildOptions.root) : `import { app } from ${JSON.stringify(resolved.appFile)};`;
+	const routeHints = createRouteHintsForVirtualModules(resolved, buildOptions.root);
+	const routeLoaderHints = routeHints.loader;
+	const routeHeadHints = routeHints.head;
+	const routeStaticPathsHints = routeHints.staticPaths;
+	const webmcpEnabled = hasWebmcpCapabilities(resolved, buildOptions.root);
+	const appImport = isPagesMode ? generatePagesAppInlineSource(resolved, buildOptions.root, "client") : `import { app } from ${JSON.stringify(resolved.appFile)};`;
 	const bareRouteExtensions = [...withAdditionalExtensions(LEGACY_BARE_ROUTE_EXTENSIONS, resolved.additionalExtensions)];
 	const dirPrefix = isPagesMode ? resolved.pagesDir : resolved.routesDir;
 	const routeGlob = `${dirPrefix}/**/*.{ts,tsx,js,jsx,md,mdx}`;
 	const additionalRouteGlob = `${dirPrefix}/**/*.${extensionGlob(bareRouteExtensions)}`;
 	const routeExcludes = createNonFullHydrationExcludes(resolved, buildOptions.root);
+	const usesEjectedPagesLayout = isEjectedPagesLayout(resolved, buildOptions.root ?? process.cwd());
+	if (isPagesMode || usesEjectedPagesLayout) routeExcludes.push(...createUnderscoreReservedExcludes(isPagesMode ? resolved.pagesDir : resolved.routesDir));
 	const routeGlobPattern = routeExcludes.length > 0 ? [routeGlob, ...routeExcludes] : routeGlob;
 	const additionalRouteGlobPattern = additionalRouteGlob && routeExcludes.length > 0 ? [additionalRouteGlob, ...routeExcludes] : additionalRouteGlob;
 	const shellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.{ts,tsx,js,jsx}` : `${resolved.shellsDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
 	const additionalShellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.${extensionGlob(bareRouteExtensions)}` : `${resolved.shellsDir}/**/*.${extensionGlob(bareRouteExtensions)}`;
+	const root = buildOptions.root ?? process.cwd();
+	const usesEjectedPagesShellLayout = usesEjectedPagesLayout && (sameConfigDirectory(resolved.shellsDir, resolved.routesDir, root) || hasRootPagesAppShell(resolved.shellsDir, root, resolved.additionalExtensions));
+	const shellExcludes = isPagesMode ? createReservedSubtreeExcludes(resolved.pagesDir) : usesEjectedPagesShellLayout ? createUnderscoreReservedExcludes(resolved.shellsDir) : [];
+	const shellGlobPattern = shellExcludes.length > 0 ? [shellGlob, ...shellExcludes] : shellGlob;
+	const additionalShellGlobPattern = shellExcludes.length > 0 ? [additionalShellGlob, ...shellExcludes] : additionalShellGlob;
+	const ejectedPagesAppShellSources = usesEjectedPagesShellLayout ? [`  ...import.meta.glob(${JSON.stringify([`${resolved.shellsDir}/**/_app.{ts,tsx,js,jsx}`, ...createReservedSubtreeExcludes(resolved.shellsDir)])}, { query: ${JSON.stringify(PRACHT_CLIENT_MODULE_QUERY)} }),`, `  ...import.meta.glob(${JSON.stringify([`${resolved.shellsDir}/**/_app.${extensionGlob(bareRouteExtensions)}`, ...createReservedSubtreeExcludes(resolved.shellsDir)])}),`] : [];
 	const appFilePosix = resolved.appFile.replace(/\\/g, "/").replace(/^\.\//, "");
 	const appDir = (appFilePosix.startsWith("/") ? appFilePosix : `/${appFilePosix}`).replace(/\/[^/]*$/, "") || "/";
 	return [
@@ -2183,8 +2003,9 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 		`  ...import.meta.glob(${JSON.stringify(additionalRouteGlobPattern)}),`,
 		`};`,
 		`const shellModules = {`,
-		`  ...import.meta.glob(${JSON.stringify(shellGlob)}, { query: ${JSON.stringify(PRACHT_CLIENT_MODULE_QUERY)} }),`,
-		`  ...import.meta.glob(${JSON.stringify(additionalShellGlob)}),`,
+		`  ...import.meta.glob(${JSON.stringify(shellGlobPattern)}, { query: ${JSON.stringify(PRACHT_CLIENT_MODULE_QUERY)} }),`,
+		`  ...import.meta.glob(${JSON.stringify(additionalShellGlobPattern)}),`,
+		...ejectedPagesAppShellSources,
 		`};`,
 		"",
 		"const resolvedApp = resolveApp(app);",
@@ -2244,6 +2065,7 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 		"  return null;",
 		"}",
 		"",
+		...webmcpEnabled ? createWebmcpBootstrapSource() : [],
 		"const state = readHydrationState();",
 		"const root = document.getElementById(\"pracht-root\");",
 		"if (state && root) {",
@@ -2254,6 +2076,7 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 		"    initialState: state,",
 		"    root,",
 		"    findModuleKey,",
+		...webmcpEnabled ? ["    onRouteChange: syncPrachtWebmcpTools,"] : [],
 		"  });",
 		"}",
 		"",
@@ -2268,10 +2091,110 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 		"if (import.meta.hot) {",
 		"  import.meta.hot.on(DEV_ROUTE_DATA_STALE_EVENT, refreshDevRouteData);",
 		"}",
-		"",
-		...hasWebmcpCapabilities(resolved, buildOptions.root) ? createWebmcpBootstrapSource() : []
+		""
 	].join("\n");
 }
+function sameConfigDirectory(left, right, root) {
+	const canonicalize = (value) => {
+		const absolute = resolve(root, value.replace(/^[/\\]+/, ""));
+		try {
+			return realpathSync.native(absolute);
+		} catch {
+			return absolute;
+		}
+	};
+	return canonicalize(left) === canonicalize(right);
+}
+function hasRootPagesAppShell(directory, root, additionalExtensions) {
+	const absoluteDirectory = resolve(root, directory.replace(/^[/\\]+/, ""));
+	const extensions = withAdditionalExtensions(DEFAULT_SHELL_EXTENSIONS, additionalExtensions);
+	for (const extension of extensions) try {
+		if (statSync(join(absoluteDirectory, `_app${extension}`)).isFile()) return true;
+	} catch {}
+	return false;
+}
+function isEjectedPagesLayout(resolved, root) {
+	if (resolved.pagesDir) return false;
+	try {
+		const appFile = resolve(root, resolved.appFile.replace(/^\//, ""));
+		return hasTrueConstExport(readFileSync(appFile, "utf-8"), appFile, GENERATED_PAGES_LAYOUT_EXPORT);
+	} catch {
+		return false;
+	}
+}
+function hasTrueConstExport(source, file, name) {
+	const program = parseAst(source, { lang: getRolldownLang(file) });
+	const statements = (Array.isArray(program.body) ? program.body : []).map(asStaticProgramNode).filter((statement) => statement !== null);
+	const trueConstBindings = /* @__PURE__ */ new Set();
+	for (const statement of statements) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? asStaticProgramNode(statement.declaration) : statement;
+		if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		const declarators = Array.isArray(declaration.declarations) ? declaration.declarations : [];
+		for (const declaratorValue of declarators) {
+			const declarator = asStaticProgramNode(declaratorValue);
+			if (declarator?.type !== "VariableDeclarator") continue;
+			const identifier = asStaticProgramNode(declarator.id);
+			if (identifier?.type !== "Identifier" || typeof identifier.name !== "string") continue;
+			const initializer = unwrapStaticExpression(declarator.init);
+			if ((initializer?.type === "BooleanLiteral" || initializer?.type === "Literal") && initializer.value === true) trueConstBindings.add(identifier.name);
+		}
+	}
+	for (const statement of statements) {
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const declaration = asStaticProgramNode(statement.declaration);
+		if (declaration?.type === "VariableDeclaration") {
+			if ((Array.isArray(declaration.declarations) ? declaration.declarations : []).some((declaratorValue) => {
+				const identifier = asStaticProgramNode(asStaticProgramNode(declaratorValue)?.id);
+				return identifier?.type === "Identifier" && identifier.name === name;
+			}) && trueConstBindings.has(name)) return true;
+			continue;
+		}
+		if (statement.source) continue;
+		const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+		for (const specifierValue of specifiers) {
+			const specifier = asStaticProgramNode(specifierValue);
+			if (specifier?.type !== "ExportSpecifier" || specifier.exportKind === "type") continue;
+			const local = asStaticProgramNode(specifier.local);
+			const exported = asStaticProgramNode(specifier.exported);
+			const localName = getStaticProgramName(local);
+			if (localName !== null && getStaticProgramName(exported) === name && trueConstBindings.has(localName)) return true;
+		}
+	}
+	return false;
+}
+function unwrapStaticExpression(value) {
+	let node = asStaticProgramNode(value);
+	while (node && new Set([
+		"ParenthesizedExpression",
+		"TSAsExpression",
+		"TSNonNullExpression",
+		"TSSatisfiesExpression",
+		"TSTypeAssertion",
+		"TypeCastExpression"
+	]).has(node.type)) node = asStaticProgramNode(node.expression);
+	return node;
+}
+function asStaticProgramNode(value) {
+	if (!value || typeof value !== "object" || !("type" in value)) return null;
+	return typeof value.type === "string" ? value : null;
+}
+function getStaticProgramName(value) {
+	if (value?.type === "Identifier" && typeof value.name === "string") return value.name;
+	if (value?.type === "Literal" && typeof value.value === "string") return value.value;
+	return null;
+}
+function createUnderscoreReservedExcludes(directory) {
+	return [`!${directory}/**/_*`, ...createReservedSubtreeExcludes(directory)];
+}
+/**
+* Exclude the contents of underscore-reserved directory trees without
+* excluding underscore-prefixed files themselves. The shell registry needs
+* this narrower form: `_app.tsx` is a reserved *name* that must stay in the
+* registry, while `_components/_app.tsx` is a helper that must not.
+*/
+function createReservedSubtreeExcludes(directory) {
+	return [`!${directory}/**/_*/**`];
+}
 /**
 * Source of `virtual:pracht/islands-client` — the tiny bootstrap loaded by
 * `hydration: "islands"` routes. It deliberately does NOT import the app
@@ -2281,6 +2204,7 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 function createPrachtIslandsClientModuleSource(options = {}, buildOptions = {}) {
 	const resolved = resolveOptions(options);
 	const islandsGlob = `${resolved.islandsDir}/**/*.{ts,tsx,js,jsx}`;
+	const webmcpEnabled = hasWebmcpCapabilities(resolved, buildOptions.root);
 	return [
 		"import { hydrateIslands } from \"@pracht/core/islands-client\";",
 		"",
@@ -2288,20 +2212,28 @@ function createPrachtIslandsClientModuleSource(options = {}, buildOptions = {})
 		"",
 		"hydrateIslands({ modules: islandModules });",
 		"",
-		...hasWebmcpCapabilities(resolved, buildOptions.root) ? createWebmcpBootstrapSource() : []
+		...webmcpEnabled ? [
+			...createWebmcpBootstrapSource(),
+			"const webmcpEntry = document.querySelector(\"script[data-pracht-webmcp-tools]\");",
+			"const webmcpCapabilities = webmcpEntry?.getAttribute(\"data-pracht-webmcp-tools\")?.split(\",\").filter(Boolean) ?? [];",
+			"syncPrachtWebmcpTools(webmcpCapabilities);",
+			""
+		] : []
 	].join("\n");
 }
 function createPrachtServerModuleSource(options = {}, buildOptions = {}) {
 	const resolved = resolveOptions(options);
 	const isPagesMode = !!resolved.pagesDir;
 	const registrySource = createPrachtRegistryModuleSource(resolved);
-	const routeLoaderHints = createRouteLoaderHintsForVirtualModules(resolved, buildOptions.root);
-	const routeHeadHints = createRouteHeadHintsForVirtualModules(resolved, buildOptions.root);
-	const routeStaticPathsHints = createRouteStaticPathsHintsForVirtualModules(resolved, buildOptions.root);
-	const clientBuild = buildOptions.isBuild ? readClientBuildAssets(buildOptions.root, buildOptions.base ?? "/") : {
+	const routeHints = createRouteHintsForVirtualModules(resolved, buildOptions.root);
+	const routeLoaderHints = routeHints.loader;
+	const routeHeadHints = routeHints.head;
+	const routeStaticPathsHints = routeHints.staticPaths;
+	const clientBuild = buildOptions.isBuild ? readClientBuildAssets(buildOptions.root, buildOptions.base ?? "/", resolved.inlineCss) : {
 		clientEntryUrl: null,
 		islandsEntryUrl: null,
 		cssManifest: {},
+		cssContentManifest: {},
 		jsManifest: {}
 	};
 	const adapter = resolved.adapter;
@@ -2344,6 +2276,7 @@ function createPrachtServerModuleSource(options = {}, buildOptions = {}) {
 		`export const islandsEntryUrl = ${JSON.stringify(islandsEntryUrl ?? null)};`,
 		`export const islandsBootstrapRequired = ${JSON.stringify(islandsBootstrapRequired)};`,
 		`export const cssManifest = ${JSON.stringify(clientBuild.cssManifest)};`,
+		`export const cssContentManifest = ${JSON.stringify(clientBuild.cssContentManifest)};`,
 		`export const jsManifest = ${JSON.stringify(clientBuild.jsManifest)};`,
 		`export const prerenderConcurrency = ${JSON.stringify(resolved.prerenderConcurrency)};`,
 		`export const budgets = ${JSON.stringify(resolved.budgets)};`,
@@ -2368,9 +2301,10 @@ function createPrachtServerModuleSource(options = {}, buildOptions = {}) {
 */
 function createPrachtDevModuleSource(options = {}, buildOptions = {}) {
 	const resolved = resolveOptions(options);
-	const routeLoaderHints = createRouteLoaderHintsForVirtualModules(resolved, buildOptions.root);
-	const routeHeadHints = createRouteHeadHintsForVirtualModules(resolved, buildOptions.root);
-	const routeStaticPathsHints = createRouteStaticPathsHintsForVirtualModules(resolved, buildOptions.root);
+	const routeHints = createRouteHintsForVirtualModules(resolved, buildOptions.root);
+	const routeLoaderHints = routeHints.loader;
+	const routeHeadHints = routeHints.head;
+	const routeStaticPathsHints = routeHints.staticPaths;
 	return [
 		"import { resolveApp, resolveApiRoutes } from \"@pracht/core/server\";",
 		resolved.pagesDir ? generatePagesAppInlineSource(resolved, buildOptions.root) : `import { app } from ${JSON.stringify(resolved.appFile)};`,
@@ -2440,58 +2374,46 @@ function createApplyRouteLoaderHintsSource() {
 		""
 	];
 }
-function createRouteHeadHintsForVirtualModules(options, root = process.cwd()) {
-	const appFileDir = dirname(resolve(root, options.appFile.slice(1)));
-	const directories = options.pagesDir ? [[options.pagesDir, resolve(root, options.pagesDir.slice(1))]] : [[options.routesDir, resolve(root, options.routesDir.slice(1))], [options.shellsDir, resolve(root, options.shellsDir.slice(1))]];
-	return Object.assign({}, ...directories.map(([prefix, directory]) => createRouteHeadHints(directory, {
-		additionalExtensions: options.additionalExtensions,
-		appFileDir,
-		rootRelativePrefix: prefix
-	})));
-}
-function createRouteHeadersHintsForVirtualModules(options, root = process.cwd()) {
-	if (options.pagesDir) return createRouteHeadersHints(resolve(root, options.pagesDir.slice(1)), {
-		additionalExtensions: options.additionalExtensions,
-		rootRelativePrefix: options.pagesDir
-	});
-	const appFileDir = dirname(resolve(root, options.appFile.slice(1)));
-	const directories = [[options.routesDir, resolve(root, options.routesDir.slice(1))], [options.shellsDir, resolve(root, options.shellsDir.slice(1))]];
-	return Object.assign({}, ...directories.map(([prefix, directory]) => createRouteHeadersHints(directory, {
-		additionalExtensions: options.additionalExtensions,
-		appFileDir,
-		rootRelativePrefix: prefix
-	})));
-}
 /**
-* `getStaticPaths()` presence per route file. Only routes matter — a shell
-* cannot enumerate paths — so unlike the head hints this skips the shells
-* directory.
+* Every route hint table the generated client entry bakes in, resolved against
+* the plugin's configured directories and keyed the way the app manifest names
+* its modules.
+*
+* One call, one walk per directory, one parse per route file. The four tables
+* used to be built independently, which walked the routes directory four times
+* and re-parsed every route module four times — on each file of each save.
 */
-function createRouteStaticPathsHintsForVirtualModules(options, root = process.cwd()) {
+function createRouteHintsForVirtualModules(options, root = process.cwd()) {
 	const appFileDir = dirname(resolve(root, options.appFile.slice(1)));
 	const routesPrefix = options.pagesDir || options.routesDir;
-	return createRouteStaticPathsHints(resolve(root, routesPrefix.slice(1)), {
-		additionalExtensions: options.additionalExtensions,
-		appFileDir,
-		rootRelativePrefix: routesPrefix
-	});
-}
-function createRouteLoaderHintsForVirtualModules(options, root = process.cwd()) {
-	if (options.pagesDir) {
-		const pages = scanPagesDirectory(resolve(root, options.pagesDir.slice(1)), options.additionalExtensions);
-		const hints = {};
-		for (const page of pages) {
-			const key = `${options.pagesDir}/${page.relativePath.replace(/\\/g, "/")}`;
-			hints[key] = !!page.hasLoader;
+	const directories = options.pagesDir ? [[options.pagesDir, resolve(root, options.pagesDir.slice(1))]] : [[options.routesDir, resolve(root, options.routesDir.slice(1))], [options.shellsDir, resolve(root, options.shellsDir.slice(1))]];
+	const hints = {
+		capabilities: {},
+		head: {},
+		headers: {},
+		incomplete: false,
+		loader: {},
+		staticPaths: {}
+	};
+	for (const [prefix, directory] of directories) {
+		const scanned = createRouteHints(directory, {
+			additionalExtensions: options.additionalExtensions,
+			appFileDir,
+			rootRelativePrefix: prefix
+		});
+		hints.incomplete ||= scanned.incomplete;
+		Object.assign(hints.head, scanned.head);
+		Object.assign(hints.headers, scanned.headers);
+		if (prefix === routesPrefix) {
+			Object.assign(hints.loader, scanned.loader);
+			Object.assign(hints.staticPaths, scanned.staticPaths);
 		}
-		return hints;
 	}
-	const appFileDir = dirname(resolve(root, options.appFile.slice(1)));
-	return createRouteLoaderHints(resolve(root, options.routesDir.slice(1)), {
-		additionalExtensions: options.additionalExtensions,
-		appFileDir,
-		rootRelativePrefix: options.routesDir
-	});
+	if (options.pagesDir) {
+		hints.loader = {};
+		for (const page of scanPagesDirectory(resolve(root, options.pagesDir.slice(1)), options.additionalExtensions)) hints.loader[`${options.pagesDir}/${page.relativePath.replace(/\\/g, "/")}`] = !!page.hasLoader;
+	}
+	return hints;
 }
 /**
 * Server data modules that can own a separately wired route loader.
@@ -2513,8 +2435,8 @@ function createPrachtRegistryModuleSource(options = {}) {
 	const bareRouteExtensions = [...withAdditionalExtensions(LEGACY_BARE_ROUTE_EXTENSIONS, resolved.additionalExtensions)];
 	const routeGlob = isPagesMode ? `${resolved.pagesDir}/**/*.{ts,tsx,js,jsx,md,mdx}` : `${resolved.routesDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
 	const additionalRouteGlob = `${isPagesMode ? resolved.pagesDir : resolved.routesDir}/**/*.${extensionGlob(bareRouteExtensions)}`;
-	const shellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.{ts,tsx,js,jsx}` : `${resolved.shellsDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
-	const additionalShellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.${extensionGlob(bareRouteExtensions)}` : `${resolved.shellsDir}/**/*.${extensionGlob(bareRouteExtensions)}`;
+	const shellGlob = isPagesMode ? [`${resolved.pagesDir}/**/_app.{ts,tsx,js,jsx}`, ...createReservedSubtreeExcludes(resolved.pagesDir)] : `${resolved.shellsDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
+	const additionalShellGlob = isPagesMode ? [`${resolved.pagesDir}/**/_app.${extensionGlob(bareRouteExtensions)}`, ...createReservedSubtreeExcludes(resolved.pagesDir)] : `${resolved.shellsDir}/**/*.${extensionGlob(bareRouteExtensions)}`;
 	return [
 		`export const routeModules = {`,
 		`  ...import.meta.glob(${JSON.stringify(routeGlob)}),`,
@@ -2524,7 +2446,12 @@ function createPrachtRegistryModuleSource(options = {}) {
 		`  ...import.meta.glob(${JSON.stringify(shellGlob)}),`,
 		`  ...import.meta.glob(${JSON.stringify(additionalShellGlob)}),`,
 		`};`,
-		`export const middlewareModules = import.meta.glob(${JSON.stringify(`${resolved.middlewareDir}/**/*.{ts,tsx,js,jsx}`)});`,
+		...isPagesMode ? [
+			`export const middlewareModules = {`,
+			`  ...import.meta.glob(${JSON.stringify(`${resolved.middlewareDir}/**/*.{ts,tsx,js,jsx}`)}),`,
+			`  ...import.meta.glob(${JSON.stringify(`${resolved.pagesDir}/_middleware.{ts,tsx,js,jsx}`)}),`,
+			`};`
+		] : [`export const middlewareModules = import.meta.glob(${JSON.stringify(`${resolved.middlewareDir}/**/*.{ts,tsx,js,jsx}`)});`],
 		`export const apiModules = import.meta.glob(${JSON.stringify(apiGlobs)});`,
 		`export const dataModules = import.meta.glob(${JSON.stringify(`${resolved.serverDir}/**/*.{ts,js,tsx,jsx}`)});`,
 		`export const capabilityModules = import.meta.glob(${JSON.stringify(`${resolved.capabilitiesDir}/**/*.{ts,js,tsx,jsx}`)});`,
@@ -2543,21 +2470,36 @@ const pagesAppSourceCache = /* @__PURE__ */ new Map();
 function clearPagesAppSourceCache() {
 	pagesAppSourceCache.clear();
 }
-function generatePagesAppInlineSource(options, root = process.cwd()) {
+/**
+* The generated pages manifest, inlined into a virtual module.
+*
+* The client target drops `agents` and `constraints` — the two keys only the
+* server reads — along with the `_app.config.ts` import that supplies them.
+* Without that split the browser entry would import the config module, and
+* every Web Bot Auth key in it would ship to visitors.
+*/
+function generatePagesAppInlineSource(options, root = process.cwd(), target = "server") {
 	const absPagesDir = resolve(root, options.pagesDir.slice(1));
+	const absCapabilitiesDir = resolve(root, options.capabilitiesDir.slice(1));
 	const cacheKey = JSON.stringify({
 		additionalExtensions: options.additionalExtensions,
+		absCapabilitiesDir,
 		absPagesDir,
+		capabilitiesDirPrefix: options.capabilitiesDir,
 		pagesDefaultRender: options.pagesDefaultRender,
-		pagesDirPrefix: options.pagesDir
+		pagesDirPrefix: options.pagesDir,
+		target
 	});
 	const cached = pagesAppSourceCache.get(cacheKey);
 	if (cached) return cached;
 	const source = generatePagesManifestSource(scanPagesDirectory(absPagesDir, options.additionalExtensions), {
 		additionalExtensions: options.additionalExtensions,
+		capabilitiesDir: absCapabilitiesDir,
+		capabilitiesDirPrefix: options.capabilitiesDir,
 		pagesDir: absPagesDir,
 		pagesDefaultRender: options.pagesDefaultRender,
-		pagesDirPrefix: options.pagesDir
+		pagesDirPrefix: options.pagesDir,
+		target
 	});
 	pagesAppSourceCache.set(cacheKey, source);
 	return source;
@@ -2578,6 +2520,10 @@ function createAgentTrafficBuffer(limit = 200) {
 				outcome: event.outcome,
 				status: event.status,
 				durationMs: event.durationMs,
+				tokenAuth: event.tokenAuth ? {
+					subject: event.tokenAuth.subject,
+					clientId: event.tokenAuth.clientId ?? null
+				} : null,
 				agent: event.agent ? {
 					agentDomain: event.agent.agentDomain,
 					keyId: event.agent.keyId
@@ -2650,6 +2596,8 @@ function createDevSSRMiddleware(server, options = {}) {
 	return async (req, res, next) => {
 		const url = req.url ?? "/";
 		const requestUrl = new URL(url, "http://localhost");
+		let reportedError;
+		let hasReportedError = false;
 		try {
 			const [framework, serverMod] = await Promise.all([server.ssrLoadModule("@pracht/core/server"), server.ssrLoadModule(PRACHT_SERVER_MODULE_ID)]);
 			const routeMatchers = {
@@ -2704,7 +2652,7 @@ function createDevSSRMiddleware(server, options = {}) {
 			let routeError;
 			let capturedRouteError = false;
 			let routeErrorContext;
-			const response = await framework.handlePrachtRequest({
+			const response = normalizeResponseHeaders(await framework.handlePrachtRequest({
 				app: serverMod.resolvedApp,
 				registry: serverMod.registry,
 				request: webRequest,
@@ -2713,6 +2661,22 @@ function createDevSSRMiddleware(server, options = {}) {
 					capturedRouteError = true;
 					routeError = error;
 					routeErrorContext = context;
+					reportedError = error;
+					hasReportedError = true;
+					logDevRequestError(server, {
+						context,
+						error,
+						path: requestUrl.pathname
+					});
+				},
+				onApiError: (error, _requestPath, context) => {
+					reportedError = error;
+					hasReportedError = true;
+					logDevRequestError(server, {
+						context,
+						error,
+						path: requestUrl.pathname
+					});
 				},
 				clientEntryUrl: withDevBase(CLIENT_BROWSER_PATH),
 				islandsEntryUrl: withDevBase(ISLANDS_CLIENT_BROWSER_PATH),
@@ -2720,15 +2684,13 @@ function createDevSSRMiddleware(server, options = {}) {
 				apiRoutes: serverMod.apiRoutes,
 				timings,
 				onCapabilityAudit: agentTraffic.record
-			});
+			}));
 			const responseContentType = response.headers.get("content-type") ?? "";
 			if (response.status === 404 && !responseContentType.includes("application/json") && !routeMatchers.app?.notFound) return next();
 			const contentType = response.headers.get("content-type") ?? "";
 			if (response.body && isEventStreamContentType(contentType)) {
 				res.statusCode = response.status;
-				response.headers.forEach((value, key) => {
-					res.setHeader(key, value);
-				});
+				writeDevResponseHeaders(res, response.headers);
 				const source = Readable.fromWeb(response.body);
 				if (res.destroyed || res.writableEnded) {
 					source.destroy();
@@ -2754,21 +2716,254 @@ function createDevSSRMiddleware(server, options = {}) {
 				await respondWithErrorOverlay(server, res, url, routeError, routeErrorContext, devBase, response.status, serverTiming);
 				return;
 			}
-			let body = await response.text();
-			if (contentType.includes("text/html")) body = await transformDevHtml(server, url, body, devBase);
-			res.statusCode = response.status;
-			response.headers.forEach((value, key) => {
-				res.setHeader(key, value);
-			});
 			const serverTiming = framework.formatServerTimingHeader(timings);
+			if (shouldStreamDevHtmlResponse(framework, response, contentType)) {
+				await streamDevHtmlResponse(server, res, url, response, devBase, serverTiming);
+				return;
+			}
+			if (contentType.includes("text/html")) {
+				const html = await transformDevHtml(server, url, await response.text(), devBase);
+				res.statusCode = response.status;
+				writeDevResponseHeaders(res, response.headers);
+				res.removeHeader("content-length");
+				if (serverTiming) res.setHeader("Server-Timing", serverTiming);
+				res.end(html);
+				return;
+			}
+			res.statusCode = response.status;
+			writeDevResponseHeaders(res, response.headers);
 			if (serverTiming) res.setHeader("Server-Timing", serverTiming);
-			res.end(body);
+			if (!response.body) {
+				res.end();
+				return;
+			}
+			const source = Readable.fromWeb(response.body);
+			if (res.destroyed || res.writableEnded) {
+				source.destroy();
+				return;
+			}
+			res.on("close", () => {
+				if (!res.writableFinished) source.destroy();
+			});
+			source.on("error", (streamError) => {
+				logDevRequestError(server, {
+					error: streamError,
+					path: requestUrl.pathname
+				});
+				res.destroy();
+			});
+			source.pipe(res);
 		} catch (error) {
+			if (!hasReportedError || error !== reportedError) logDevRequestError(server, {
+				error,
+				path: requestUrl.pathname
+			});
 			await handleDevError(server, req, res, next, url, error, devBase);
 		}
 	};
 }
 /**
+* Print one line per dev-server failure, in the terminal running `pracht dev`.
+*
+* The browser overlay only reaches a document navigation. Everything else that
+* can fail — a route-state fetch during client-side navigation, `curl`, an
+* end-to-end test — used to get a 500 and no server-side trace of why.
+*/
+function formatDevRequestErrorLine(options) {
+	const route = options.routeId ? ` in route "${options.routeId}"` : "";
+	const file = options.file ? ` (${options.file})` : "";
+	return `[pracht] ${options.phase ?? "request"} error${route}${file} at ${options.path}: ${options.message}`;
+}
+/**
+* A `throw notFound()` that reaches `onRouteError` is a routing outcome, not a
+* crash: the app simply declares no not-found page. Redirects never reach it
+* at all — the runtime returns a thrown `Response` before the error path.
+*/
+function shouldLogDevRequestError(error) {
+	return devErrorStatus(error) >= 500;
+}
+function devErrorStatus(error) {
+	if (error instanceof Error && error.name === "PrachtHttpError" && typeof error.status === "number") return error.status;
+	return 500;
+}
+function logDevRequestError(server, options) {
+	if (!shouldLogDevRequestError(options.error)) return;
+	const { error } = options;
+	const line = formatDevRequestErrorLine({
+		file: describeAnnotatedUserModule(error, server.config.root) ?? describeContextUserModule(options.context),
+		message: error instanceof Error ? error.message : String(error),
+		path: options.path,
+		phase: options.context?.phase,
+		routeId: options.context?.routeId
+	});
+	const stack = error instanceof Error ? error.stack : void 0;
+	const wantsStack = shouldIncludeDevErrorStack({
+		context: options.context,
+		debug: Boolean(process.env?.DEBUG),
+		error,
+		root: server.config.root
+	});
+	server.config.logger.error(wantsStack && stack ? `${line}\n${stack}` : line, { timestamp: true });
+}
+/** Source modules the runtime matched before a handled request failure. */
+function describeContextUserModule(context) {
+	if (!context) return void 0;
+	if (context.phase === "middleware" && context.middlewareFiles?.length) return context.middlewareFiles.join(", ");
+	if (context.phase === "loader" && context.loaderFile) return context.loaderFile;
+	return context.routeFile;
+}
+/**
+* Whether the logged line should carry the stack trace.
+*
+* A failure the developer can locate — a route module, a loader, a Vite
+* transform error that names the file it could not compile — is already
+* pinpointed by the message and, for a document navigation, by the overlay.
+* Repeating the trace for every one of those (a failing route-state poll fires
+* on each navigation) buries the terminal. A failure that names no user module
+* is a framework or module-loading fault where the trace is the only clue, so
+* it always gets one; `DEBUG` opts back in for everything.
+*/
+function shouldIncludeDevErrorStack(options) {
+	if (options.debug) return true;
+	return !isAttributableToUserModule(options.context, options.error, options.root);
+}
+function isAttributableToUserModule(context, error, root) {
+	if (context?.routeFile || context?.loaderFile || context?.shellFile) return true;
+	const annotatedFile = readAnnotatedFile(error);
+	if (annotatedFile !== void 0) return isUserModulePath(annotatedFile, root);
+	const stack = error instanceof Error ? error.stack : void 0;
+	if (!stack) return false;
+	return stack.split("\n").slice(1).some((frame) => {
+		const match = /(?:\(|\bat\s)([^()\s]+):\d+:\d+\)?\s*$/.exec(frame.trim());
+		return match ? isUserModulePath(match[1], root) : false;
+	});
+}
+/** The module a Vite or Rollup build error blames, when it names one. */
+function readAnnotatedFile(error) {
+	const annotated = error;
+	if (typeof annotated?.id === "string") return annotated.id;
+	if (typeof annotated?.loc?.file === "string") return annotated.loc.file;
+}
+/**
+* The annotated module as `path/to/file.tsx:line:column`, relative to the
+* project root, or `undefined` when the error blames nothing of the user's.
+*/
+function describeAnnotatedUserModule(error, root) {
+	const file = readAnnotatedFile(error);
+	if (file === void 0 || !isUserModulePath(file, root)) return void 0;
+	const rootPrefix = root ? `${root.replace(/\/$/, "")}/` : void 0;
+	const label = rootPrefix && file.startsWith(rootPrefix) ? file.slice(rootPrefix.length) : file;
+	const loc = error?.loc;
+	if (typeof loc?.line !== "number") return label;
+	return typeof loc.column === "number" ? `${label}:${loc.line}:${loc.column}` : `${label}:${loc.line}`;
+}
+function isUserModulePath(candidate, root) {
+	const path = candidate.replace(/^file:\/\//, "").replace(/^\/@fs/, "").split("?")[0];
+	if (path.includes("/node_modules/") || path.startsWith("node:")) return false;
+	if (path.startsWith("\0") || path.startsWith("/@")) return false;
+	if (!root) return path.startsWith("/src/");
+	return path.startsWith(`${root.replace(/\/$/, "")}/`) || path.startsWith("/src/");
+}
+function shouldStreamDevHtmlResponse(framework, response, contentType) {
+	return response.body !== null && contentType.includes("text/html") && framework.isStreamingHtmlResponse?.(response) === true;
+}
+async function streamDevHtmlResponse(server, res, url, response, base, serverTiming) {
+	const reader = response.body.getReader();
+	let committed = false;
+	const cancel = () => {
+		if (!res.writableFinished) reader.cancel().catch(() => void 0);
+	};
+	res.on("close", cancel);
+	try {
+		const first = await reader.read();
+		const transformed = await transformStreamingDevHtmlPrefix(server, url, first.done ? "" : new TextDecoder().decode(first.value), base);
+		res.statusCode = response.status;
+		writeDevResponseHeaders(res, response.headers);
+		res.removeHeader("content-length");
+		if (serverTiming) res.setHeader("Server-Timing", serverTiming);
+		committed = true;
+		if (transformed.prefix) await writeDevResponseChunk(res, transformed.prefix);
+		let bodyEndInjected = transformed.beforeBodyClose === "";
+		const decoder = new TextDecoder();
+		while (!first.done) {
+			const next = await reader.read();
+			if (next.done) break;
+			let chunk = next.value;
+			if (!bodyEndInjected) {
+				const injection = injectStreamingBodyEnd(decoder.decode(next.value), transformed.beforeBodyClose);
+				chunk = injection.html;
+				bodyEndInjected = injection.injected;
+			}
+			await writeDevResponseChunk(res, chunk);
+		}
+		res.end();
+	} catch (error) {
+		if (committed || res.headersSent) {
+			res.destroy(error instanceof Error ? error : new Error(String(error)));
+			return;
+		}
+		throw error;
+	} finally {
+		res.removeListener("close", cancel);
+		reader.releaseLock();
+	}
+}
+const STREAM_PREFIX_END_MARKER = "<template data-pracht-stream-prefix-end=\"\"></template>";
+const STREAM_BODY_END_MARKER = "<template data-pracht-stream-body-end=\"\"></template>";
+/**
+* Run Vite's HTML hooks against a syntactically complete document, then split
+* their output back into the prefix that can be committed now and tags that
+* belong immediately before `</body>` once the stream finishes.
+*/
+async function transformStreamingDevHtmlPrefix(server, url, prefix, base) {
+	const transformed = await transformDevHtml(server, url, `${prefix}${STREAM_PREFIX_END_MARKER}</div>${STREAM_BODY_END_MARKER}</body></html>`, base);
+	const prefixEnd = transformed.indexOf(STREAM_PREFIX_END_MARKER);
+	const bodyMarker = transformed.indexOf(STREAM_BODY_END_MARKER, prefixEnd);
+	const bodyClose = transformed.indexOf("</body>", bodyMarker);
+	if (prefixEnd < 0 || bodyMarker < 0 || bodyClose < 0) throw new Error("A Vite transform removed Pracht's streaming HTML markers; the document cannot be streamed safely in development.");
+	return {
+		prefix: transformed.slice(0, prefixEnd),
+		beforeBodyClose: transformed.slice(bodyMarker + 52, bodyClose)
+	};
+}
+/** Insert deferred Vite `body` tags into the runtime-owned closing chunk. */
+function injectStreamingBodyEnd(html, beforeBodyClose) {
+	const bodyClose = html.indexOf("</body>");
+	if (bodyClose < 0) return {
+		html,
+		injected: false
+	};
+	return {
+		html: `${html.slice(0, bodyClose)}${beforeBodyClose}${html.slice(bodyClose)}`,
+		injected: true
+	};
+}
+async function writeDevResponseChunk(res, chunk) {
+	if (res.destroyed || res.writableEnded || res.write(chunk)) return;
+	await new Promise((resolve, reject) => {
+		const cleanup = () => {
+			res.removeListener("close", onClose);
+			res.removeListener("drain", onDrain);
+			res.removeListener("error", onError);
+		};
+		const onClose = () => {
+			cleanup();
+			resolve();
+		};
+		const onDrain = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		res.once("close", onClose);
+		res.once("drain", onDrain);
+		res.once("error", onError);
+	});
+}
+/**
 * Vite's HTML transform adds `config.base` to root-absolute asset attributes.
 * Pracht's runtime has already added it to URLs produced by `withBase()` — the
 * client entry, route-state preloads, image endpoints, and user-authored asset
@@ -2825,7 +3020,7 @@ function protectRootAbsoluteAssetAttributes(html) {
 * avoid a first-paint FOUC.
 */
 async function createDevCssManifest(server, options) {
-	const route = options.pathname === null ? void 0 : options.matchAppRoute(options.app, options.pathname)?.route ?? options.app.notFound;
+	const route = Object.hasOwn(options, "route") ? options.route : options.pathname === null ? void 0 : options.matchAppRoute(options.app, options.pathname)?.route ?? options.app.notFound;
 	if (!route) return {};
 	const manifest = {};
 	const modules = [...route.shellFile ? [{
@@ -2887,11 +3082,14 @@ async function resolveDevCssContextForPath(server, path, options = {}) {
 	const [framework, serverMod] = await Promise.all([server.ssrLoadModule("@pracht/core/server"), server.ssrLoadModule(PRACHT_DEV_MODULE_ID)]);
 	const publicPathname = new URL(path, "http://localhost").pathname;
 	const pathname = options.basePathRetained ? framework.stripBase(publicPathname) : publicPathname;
+	const route = pathname === null ? null : framework.matchAppRoute(serverMod.resolvedApp, pathname)?.route ?? serverMod.resolvedApp.notFound ?? null;
 	return {
 		app: serverMod.resolvedApp,
 		matchAppRoute: framework.matchAppRoute,
 		pathname,
-		registry: serverMod.registry
+		registry: serverMod.registry,
+		route,
+		streaming: route?.streaming === true
 	};
 }
 /**
@@ -2901,6 +3099,7 @@ async function resolveDevCssContextForPath(server, path, options = {}) {
 */
 function createDevCssInjectionMiddleware(server) {
 	let warned = false;
+	let warnedInjectionFailure = false;
 	return (req, res, next) => {
 		const method = (req.method ?? "GET").toUpperCase();
 		const accept = readRequestHeader(req.headers.accept).toLowerCase();
@@ -2916,31 +3115,91 @@ function createDevCssInjectionMiddleware(server) {
 			return null;
 		});
 		const chunks = [];
+		let buffered = 0;
+		let mode = "pending";
+		const originalWrite = res.write.bind(res);
 		const originalEnd = res.end.bind(res);
 		const originalWriteHead = res.writeHead.bind(res);
+		const releasePatches = () => {
+			res.write = originalWrite;
+			res.end = originalEnd;
+			res.writeHead = originalWriteHead;
+		};
+		const decide = (writeHeadArgs) => {
+			if (mode === "pending") {
+				mode = isHtmlContentType(readWriteHeadHeader(writeHeadArgs, "content-type") ?? res.getHeader("content-type")) ? "buffer" : "passthrough";
+				if (mode === "passthrough") releasePatches();
+				else res.removeHeader("content-length");
+			}
+			return mode;
+		};
+		const spillToPassthrough = () => {
+			mode = "passthrough";
+			releasePatches();
+			for (const chunk of chunks) originalWrite(chunk);
+			chunks.length = 0;
+			buffered = 0;
+		};
+		let streamingFlush;
+		const flushStreamingPrefix = () => {
+			if (streamingFlush || mode !== "buffer") return;
+			streamingFlush = (async () => {
+				const context = await contextPromise;
+				if (!context?.streaming || mode !== "buffer") return;
+				if (!Buffer.concat(chunks).includes("</head>")) return;
+				const manifest = await createDevCssManifest(server, context);
+				if (mode !== "buffer") return;
+				const html = injectDevCssLinks(Buffer.concat(chunks).toString("utf-8"), manifest, server.config.base || "/");
+				chunks.length = 0;
+				buffered = 0;
+				mode = "passthrough";
+				releasePatches();
+				originalWrite(html);
+			})().catch((error) => {
+				server.config.logger.error(`[pracht] Could not inject streaming development stylesheets: ${String(error)}`);
+				if (mode === "buffer") spillToPassthrough();
+			}).finally(() => {
+				streamingFlush = void 0;
+			});
+		};
 		res.writeHead = ((statusCode, ...args) => {
-			res.removeHeader("content-length");
+			if (decide(args) === "passthrough") return Reflect.apply(originalWriteHead, res, [statusCode, ...args]);
 			return Reflect.apply(originalWriteHead, res, [statusCode, ...args.map(stripContentLengthHeader)]);
 		});
 		res.write = ((chunk, encodingOrCallback, callback) => {
-			chunks.push(toBuffer(chunk, encodingOrCallback));
-			(typeof encodingOrCallback === "function" ? encodingOrCallback : typeof callback === "function" ? callback : void 0)?.();
+			if (decide() === "passthrough") return originalWrite(chunk, encodingOrCallback, callback);
+			const done = readNodeWriteCallback(encodingOrCallback, callback);
+			const buffer = toBuffer(chunk, encodingOrCallback);
+			if (buffered + buffer.length > 8388608) {
+				spillToPassthrough();
+				return originalWrite(buffer, done);
+			}
+			chunks.push(buffer);
+			buffered += buffer.length;
+			flushStreamingPrefix();
+			done?.();
 			return true;
 		});
 		res.end = ((chunk, encodingOrCallback, callback) => {
+			if (decide() === "passthrough") return originalEnd(chunk, encodingOrCallback, callback);
 			if (chunk != null) chunks.push(toBuffer(chunk, encodingOrCallback));
-			const done = typeof encodingOrCallback === "function" ? encodingOrCallback : typeof callback === "function" ? callback : void 0;
+			const done = readNodeWriteCallback(encodingOrCallback, callback);
 			(async () => {
-				const body = Buffer.concat(chunks);
-				if (!String(res.getHeader("content-type") ?? "").includes("text/html")) {
-					originalEnd(body, done);
+				await streamingFlush;
+				if (mode === "passthrough") {
+					originalEnd(void 0, done);
 					return;
 				}
+				const body = Buffer.concat(chunks);
 				try {
 					const context = await contextPromise;
 					const manifest = context ? await createDevCssManifest(server, context) : null;
 					originalEnd(manifest ? injectDevCssLinks(body.toString("utf-8"), manifest, server.config.base || "/") : body.toString("utf-8"), done);
-				} catch {
+				} catch (error) {
+					if (!warnedInjectionFailure) {
+						warnedInjectionFailure = true;
+						server.config.logger.error(`[pracht] Could not inject development stylesheets: ${error instanceof Error ? error.message : String(error)}`, { timestamp: true });
+					}
 					originalEnd(body, done);
 				}
 			})();
@@ -2949,6 +3208,22 @@ function createDevCssInjectionMiddleware(server) {
 		next();
 	};
 }
+function isHtmlContentType(value) {
+	return String(value ?? "").toLowerCase().includes("text/html");
+}
+/** Read a header out of the `writeHead(status[, statusMessage][, headers])` tail. */
+function readWriteHeadHeader(args, name) {
+	if (!args) return void 0;
+	for (const arg of args) if (Array.isArray(arg)) {
+		for (let index = 0; index < arg.length; index += 2) if (String(arg[index]).toLowerCase() === name) return String(arg[index + 1]);
+	} else if (arg && typeof arg === "object") {
+		for (const [key, value] of Object.entries(arg)) if (key.toLowerCase() === name) return String(value);
+	}
+}
+function readNodeWriteCallback(encodingOrCallback, callback) {
+	if (typeof encodingOrCallback === "function") return encodingOrCallback;
+	if (typeof callback === "function") return callback;
+}
 function toBuffer(chunk, encoding) {
 	if (Buffer.isBuffer(chunk)) return chunk;
 	if (chunk instanceof Uint8Array) return Buffer.from(chunk);
@@ -3044,6 +3319,8 @@ function shouldExposeDevServerErrors() {
 * `text/plain` renders every escape sequence literally.
 */
 async function respondWithErrorOverlay(server, res, url, error, context, base, status, serverTiming) {
+	if (finishAlreadySentResponse(res)) return;
+	discardPendingResponseHeaders(res);
 	if (error instanceof Error) server.ssrFixStacktrace(error);
 	const { buildErrorOverlayHtml } = await server.ssrLoadModule("@pracht/core/error-overlay");
 	let html = buildErrorOverlayHtml({
@@ -3066,7 +3343,43 @@ async function respondWithErrorOverlay(server, res, url, error, context, base, s
 	if (serverTiming) res.setHeader("Server-Timing", serverTiming);
 	res.end(html);
 }
+/**
+* True when the response has already reached the wire, so no error page can
+* replace it. Writing a second status line throws `ERR_HTTP_HEADERS_SENT`,
+* which would then be the error the developer sees instead of the real one —
+* a failure *after* `res.end()` (a rejected body stream, a late throw) is
+* exactly when that happens.
+*/
+/**
+* Headers that describe the body being abandoned. A `content-length` measuring
+* the response the error replaced would truncate the error page written in its
+* place, and a stale `content-type`/`content-encoding` would have the browser
+* decode HTML as something else.
+*/
+const ABANDONED_BODY_HEADERS = new Set([
+	"content-disposition",
+	"content-encoding",
+	"content-length",
+	"content-type",
+	"transfer-encoding"
+]);
+/**
+* Drop the headers that described the response being replaced, and only those.
+* Everything else staged on `res` belongs to a different concern — Vite's cors
+* middleware has already put `access-control-allow-origin` there, and clearing
+* it would turn a cross-origin 500 into a CORS failure with no overlay to read.
+*/
+function discardPendingResponseHeaders(res) {
+	for (const name of res.getHeaderNames()) if (ABANDONED_BODY_HEADERS.has(name.toLowerCase())) res.removeHeader(name);
+}
+function finishAlreadySentResponse(res) {
+	if (!res.headersSent && !res.writableEnded) return false;
+	if (!res.writableEnded && !res.destroyed) res.end();
+	return true;
+}
 async function handleDevError(server, req, res, next, url, error, base) {
+	if (finishAlreadySentResponse(res)) return;
+	discardPendingResponseHeaders(res);
 	if (error instanceof Error) server.ssrFixStacktrace(error);
 	if (req.headers["x-pracht-route-state-request"] === "1") {
 		res.statusCode = 500;
@@ -3160,6 +3473,24 @@ function readRequestHeader(value) {
 	if (Array.isArray(value)) return value.join(", ");
 	return value ?? "";
 }
+/**
+* Copy a `Response`'s headers onto a Node response the way the production
+* adapters do.
+*
+* `headers.forEach()` yields `set-cookie` once, joined with `, ` — and
+* `res.setHeader()` replaces rather than appends — so a loader or API route
+* that sets two cookies used to emit a single corrupted header in dev while
+* production (see `writeNodeResponseHeaders` in @pracht/adapter-node) sent
+* both. `getSetCookie()` is the only accessor that keeps them apart.
+*/
+function writeDevResponseHeaders(res, headers) {
+	const setCookieHeaders = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : [];
+	headers.forEach((value, key) => {
+		if (key.toLowerCase() === "set-cookie" && setCookieHeaders.length > 0) return;
+		res.setHeader(key, value);
+	});
+	if (setCookieHeaders.length > 0) res.setHeader("set-cookie", setCookieHeaders);
+}
 function hasKnownAssetExtension(pathname) {
 	const fileName = pathname.split("/").pop() ?? "";
 	const extensionIndex = fileName.lastIndexOf(".");
@@ -3245,17 +3576,29 @@ async function nodeToWebRequest(req, maxBodySize, base = "/") {
 }
 //#endregion
 //#region src/index.ts
+function emptyRouteHints() {
+	return {
+		capabilities: {},
+		head: {},
+		headers: {},
+		incomplete: false,
+		loader: {},
+		staticPaths: {}
+	};
+}
 function pracht(options = {}) {
 	const resolved = resolveOptions(options);
 	const isPagesMode = !!resolved.pagesDir;
 	let root = process.cwd();
 	let routeFileDirs = [];
-	let clientRouteHeadHints = {};
-	let clientRouteHeadersHints = {};
-	let clientRouteLoaderHints = {};
+	let clientRouteHints = emptyRouteHints();
 	let serverRouteLoaderHints = {};
+	let emittedRouteHints = emptyRouteHints();
+	let routeHintsNeedResync = false;
 	const routeFileExtensions = withAdditionalExtensions(DEFAULT_ROUTE_EXTENSIONS, resolved.additionalExtensions);
 	let capabilityModulePaths = /* @__PURE__ */ new Set();
+	let capabilityRunnerConfig = {};
+	let usesEjectedPagesLayout = false;
 	if (isPagesMode && options.appFile) console.warn("[pracht] Both `pagesDir` and `appFile` are set. `pagesDir` takes precedence — `appFile` will be ignored.");
 	let isBuild = false;
 	let base = "/";
@@ -3263,7 +3606,10 @@ function pracht(options = {}) {
 	const prachtPlugin = {
 		name: "pracht",
 		enforce: "pre",
-		api: { llmsTxtEnabled: Boolean(resolved.llmsTxt) },
+		api: {
+			llmsTxtEnabled: Boolean(resolved.llmsTxt),
+			pracht: { staticTarget: resolved.adapter.staticTarget === true }
+		},
 		config(_config, env) {
 			const isEdge = resolved.adapter.edge === true;
 			const isSSRBuild = env.isSsrBuild;
@@ -3273,7 +3619,10 @@ function pracht(options = {}) {
 			const publicEnvDefine = JSON.stringify(loadEnv(env.mode, envDir, PUBLIC_ENV_PREFIX));
 			const agentSurfaceDefine = env.command === "build" ? String(hasAgentSurface(resolved, configRoot)) : "true";
 			const staticTargetDefine = String(env.command === "build" && resolved.adapter.staticTarget === true);
-			const clientFeatureDefines = { __PRACHT_CLIENT_PREFETCH__: String(resolved.client.prefetch) };
+			const clientFeatureDefines = {
+				__PRACHT_CLIENT_BLOCKER__: String(resolved.client.navigationGuards),
+				__PRACHT_CLIENT_PREFETCH__: String(resolved.client.prefetch)
+			};
 			const clientChunkConfig = isSSRBuild || !resolved.vendorChunk ? {} : frameworkChunkConfig(_config.build?.rollupOptions?.output);
 			if (clientChunkConfig.warning) console.warn(`[pracht] ${clientChunkConfig.warning}`);
 			return {
@@ -3316,6 +3665,8 @@ function pracht(options = {}) {
 			base = config.base;
 			routeFileDirs = computeRouteFileDirs(root, resolved);
 			capabilityModulePaths = new Set(resolveCapabilityModulePaths(resolved, root).map(canonicalFilePath));
+			usesEjectedPagesLayout = isEjectedPagesLayout(resolved, root);
+			capabilityRunnerConfig = { resolve: { alias: config.resolve?.alias } };
 		},
 		resolveId(id, importer, resolveIdOptions) {
 			if (isIslandsClientModule(id)) return PRACHT_ISLANDS_CLIENT_MODULE_ID;
@@ -3330,10 +3681,10 @@ function pracht(options = {}) {
 		load(id) {
 			if (isIslandsClientModule(id)) return createPrachtIslandsClientModuleSource(resolved, { root });
 			if (isClientModule(id)) {
-				clientRouteHeadHints = createRouteHeadHintsForVirtualModules(resolved, root);
-				clientRouteHeadersHints = createRouteHeadersHintsForVirtualModules(resolved, root);
-				clientRouteLoaderHints = createRouteLoaderHintsForVirtualModules(resolved, root);
+				clientRouteHints = createRouteHintsForVirtualModules(resolved, root);
 				serverRouteLoaderHints = createServerLoaderHintsForHotUpdates(resolved, root);
+				emittedRouteHints = clientRouteHints;
+				routeHintsNeedResync = clientRouteHints.incomplete;
 				return createPrachtClientModuleSource(resolved, { root });
 			}
 			if (isDevModule(id)) return createPrachtDevModuleSource(resolved, {
@@ -3347,13 +3698,19 @@ function pracht(options = {}) {
 				configuredBase
 			});
 			if (isCapabilitiesModule(id)) return createPrachtCapabilitiesClientModuleSource(resolved, { root });
-			if (isWebmcpModule(id)) return createPrachtWebmcpModuleSource(resolved, { root });
+			if (isWebmcpModule(id)) return createPrachtWebmcpModuleSourceAsync(resolved, {
+				root,
+				runnerConfig: capabilityRunnerConfig
+			});
 			return null;
 		},
 		transform(code, id) {
+			const normalizedId = canonicalFilePath(id.split("?")[0]);
 			const appFileAbs = canonicalFilePath(resolveConfigPath(root, resolved.appFile));
-			if (canonicalFilePath(id.split("?")[0]) !== appFileAbs) return null;
-			const transformed = rewriteManifestCoreImports(code.replace(/\(\)\s*=>\s*import\(\s*(['"])([^'"]+)\1\s*\)/g, "$1$2$1"));
+			const isPagesAppConfig = isPagesMode && isPagesAppConfigModule(normalizedId, root, resolved);
+			if (normalizedId !== appFileAbs && !isPagesAppConfig) return null;
+			const withStringModuleRefs = code.replace(/\(\)\s*=>\s*import\(\s*(['"])([^'"]+)\1\s*\)/g, "$1$2$1");
+			const transformed = isPagesAppConfig ? withStringModuleRefs : rewriteManifestCoreImports(withStringModuleRefs);
 			if (transformed === code) return null;
 			return {
 				code: transformed,
@@ -3393,46 +3750,35 @@ function pracht(options = {}) {
 				serverRouteLoaderHints = createServerLoaderHintsForHotUpdates(resolved, root);
 			} catch {}
 			const loaderDependencyHints = {
-				...clientRouteLoaderHints,
+				...clientRouteHints.loader,
 				...previousServerRouteLoaderHints,
 				...serverRouteLoaderHints
 			};
-			const changesRouteHeadDependency = reachesRouteHintedModule(modules, serverRoot, clientRouteHeadHints, { startAtImporters: changesRouteHeadSource });
-			const changesRouteHeadersDependency = reachesRouteHintedModule(modules, serverRoot, clientRouteHeadersHints, { startAtImporters: changesRouteHeadSource });
+			const changesRouteHeadDependency = reachesRouteHintedModule(modules, serverRoot, clientRouteHints.head, { startAtImporters: changesRouteHeadSource });
+			const changesRouteHeadersDependency = reachesRouteHintedModule(modules, serverRoot, clientRouteHints.headers, { startAtImporters: changesRouteHeadSource });
 			const changesRouteLoaderDependency = reachesRouteHintedModule(modules, serverRoot, loaderDependencyHints, { startAtImporters: changesRouteLoaderSource });
-			let shouldReloadClientEntry = changesRouteHeadDependency || changesRouteHeadersDependency;
+			let shouldReloadClientEntry = changesRouteHeadDependency || changesRouteHeadersDependency || routeHintsNeedResync && (changesRouteHeadSource || changesRouteLoaderSource);
 			let clientHeadModule;
 			if (changesRouteHeadSource || changesRouteHeadDependency || changesRouteHeadersDependency) clientHeadModule = server.moduleGraph.getModuleById(PRACHT_CLIENT_MODULE_ID);
-			if (changesRouteHeadSource) {
-				const previousHint = clientRouteHeadHints[relative] === true;
-				try {
-					const nextHints = createRouteHeadHintsForVirtualModules(resolved, root);
-					shouldReloadClientEntry ||= previousHint !== (nextHints[relative] === true);
-					clientRouteHeadHints = nextHints;
-				} catch {
-					shouldReloadClientEntry = true;
-				}
-			} else if (changesRouteHeadDependency && clientHeadModule) server.moduleGraph.invalidateModule(clientHeadModule);
-			if (changesRouteHeadSource) {
-				const previouslyHadHeaders = clientRouteHeadersHints[relative] === true;
-				try {
-					const nextHints = createRouteHeadersHintsForVirtualModules(resolved, root);
-					shouldReloadClientEntry ||= previouslyHadHeaders || nextHints[relative] === true;
-					clientRouteHeadersHints = nextHints;
-				} catch {
-					shouldReloadClientEntry = true;
+			if (changesRouteHeadSource || changesRouteLoaderSource) try {
+				const nextHints = createRouteHintsForVirtualModules(resolved, root);
+				if (changesRouteHeadSource) {
+					shouldReloadClientEntry ||= JSON.stringify(emittedRouteHints.capabilities[relative] ?? []) !== JSON.stringify(nextHints.capabilities[relative] ?? []);
+					shouldReloadClientEntry ||= emittedRouteHints.head[relative] === true !== (nextHints.head[relative] === true);
+					shouldReloadClientEntry ||= emittedRouteHints.headers[relative] === true || nextHints.headers[relative] === true;
 				}
-			}
-			if (changesRouteLoaderSource) {
-				const previousHint = clientRouteLoaderHints[relative] === true;
-				try {
-					const nextHints = createRouteLoaderHintsForVirtualModules(resolved, root);
-					shouldReloadClientEntry ||= previousHint !== (nextHints[relative] === true);
-					clientRouteLoaderHints = nextHints;
-				} catch {
-					shouldReloadClientEntry = true;
+				if (changesRouteLoaderSource) {
+					shouldReloadClientEntry ||= emittedRouteHints.loader[relative] === true !== (nextHints.loader[relative] === true);
+					shouldReloadClientEntry ||= emittedRouteHints.staticPaths[relative] === true !== (nextHints.staticPaths[relative] === true);
 				}
+				shouldReloadClientEntry ||= nextHints.incomplete;
+				routeHintsNeedResync ||= nextHints.incomplete;
+				clientRouteHints = nextHints;
+			} catch {
+				shouldReloadClientEntry = true;
+				routeHintsNeedResync = true;
 			}
+			else if (changesRouteHeadDependency && clientHeadModule) server.moduleGraph.invalidateModule(clientHeadModule);
 			if (isPagesMode && relative.startsWith(resolved.pagesDir)) {
 				clearPagesAppSourceCache();
 				invalidateVirtualModules(server);
@@ -3466,14 +3812,17 @@ function pracht(options = {}) {
 					const islandsMod = server.moduleGraph.getModuleById(PRACHT_ISLANDS_CLIENT_MODULE_ID);
 					if (islandsMod) server.moduleGraph.invalidateModule(islandsMod);
 				}
-				if (relative.startsWith(resolved.capabilitiesDir)) for (const moduleId of [
-					PRACHT_CAPABILITIES_MODULE_ID,
-					PRACHT_WEBMCP_MODULE_ID,
-					PRACHT_CLIENT_MODULE_ID,
-					PRACHT_ISLANDS_CLIENT_MODULE_ID
-				]) {
-					const capabilityMod = server.moduleGraph.getModuleById(moduleId);
-					if (capabilityMod) server.moduleGraph.invalidateModule(capabilityMod);
+				if (relative.startsWith(resolved.capabilitiesDir)) {
+					if (isPagesMode) clearPagesAppSourceCache();
+					for (const moduleId of [
+						PRACHT_CAPABILITIES_MODULE_ID,
+						PRACHT_WEBMCP_MODULE_ID,
+						PRACHT_CLIENT_MODULE_ID,
+						PRACHT_ISLANDS_CLIENT_MODULE_ID
+					]) {
+						const capabilityMod = server.moduleGraph.getModuleById(moduleId);
+						if (capabilityMod) server.moduleGraph.invalidateModule(capabilityMod);
+					}
 				}
 			}
 			const sentFullReload = sendServerOnlyFullReload(server, file);
@@ -3495,8 +3844,9 @@ function pracht(options = {}) {
 		enforce: "post",
 		transform(code, id, transformOptions) {
 			if (!transformOptions?.ssr && isCapabilityModule(id, capabilityModulePaths)) throw new Error(`[pracht] Capability module ${JSON.stringify(toPosixPath(id))} was imported by client code. Capability modules are server-only — their run() implementation and its imports would be bundled for every visitor. Call the capability instead: \`callCapability\`/\`capabilities\` from "virtual:pracht/capabilities" in the browser, or \`invokeCapability\` from "@pracht/core/server" in loaders, middleware, and API routes.`);
-			if (!(isPrachtClientModuleId(id) || !transformOptions?.ssr && isRouteOrShellFile(id, routeFileDirs, routeFileExtensions))) return null;
-			const transformed = stripServerOnlyExportsForClient(code, id);
+			const isPagesMiddlewareModule = !transformOptions?.ssr && (isPagesMode || usesEjectedPagesLayout) && isRootMiddlewareModule(id, root, resolved);
+			if (!(isPrachtClientModuleId(id) || !transformOptions?.ssr && isRouteOrShellFile(id, routeFileDirs, routeFileExtensions) || isPagesMiddlewareModule)) return null;
+			const transformed = stripServerOnlyExportsForClient(code, id, { middleware: isPagesMiddlewareModule });
 			if (transformed === code) return null;
 			return {
 				code: transformed,
@@ -3700,19 +4050,28 @@ function mergeOptimizeDepsEntries(userEntries, prachtEntries) {
 function toOptimizeDepsEntry(path) {
 	return toPosixPath(path).replace(/^\.\//, "").replace(/^\//, "").replace(/\/$/, "");
 }
+/**
+* Restart the dev server when the pages graph gains or loses a file.
+*
+* `capabilitiesDir` is watched alongside `pagesDir` because the generated
+* manifest registers capabilities from it: without this, adding
+* `src/capabilities/x.ts` leaves its endpoint 404ing until some unrelated page
+* changes, and deleting one leaves a manifest pointing at a module that is
+* gone — a 500 on every capability endpoint. The cached manifest source is
+* cleared first so the restart regenerates it. Edits (as opposed to
+* add/unlink) go through `handleHotUpdate`, which clears the same cache
+* without a restart.
+*/
 function watchPagesDirectory(server, resolved, root) {
-	const abs = resolveConfigPath(root, resolved.pagesDir);
-	server.watcher.on("add", (f) => {
-		if (toPosixPath(f).startsWith(toPosixPath(abs))) {
-			clearPagesAppSourceCache();
-			server.restart();
-		}
-	});
-	server.watcher.on("unlink", (f) => {
-		if (toPosixPath(f).startsWith(toPosixPath(abs))) {
-			clearPagesAppSourceCache();
-			server.restart();
-		}
+	const watched = [toPosixPath(resolveConfigPath(root, resolved.pagesDir)), toPosixPath(resolveConfigPath(root, resolved.capabilitiesDir))];
+	const isWatched = (file) => {
+		const path = toPosixPath(file);
+		return watched.some((dir) => path === dir || path.startsWith(`${dir}/`));
+	};
+	for (const event of ["add", "unlink"]) server.watcher.on(event, (file) => {
+		if (!isWatched(file)) return;
+		clearPagesAppSourceCache();
+		server.restart();
 	});
 }
 function invalidateVirtualModules(server) {
@@ -3740,6 +4099,28 @@ function isCapabilityModule(id, capabilityModulePaths) {
 	if (path.startsWith("\0") || path.startsWith("virtual:")) return false;
 	return capabilityModulePaths.has(canonicalFilePath(path));
 }
+/** Whether `modulePath` is the pages directory's root `_app.config` module. */
+function isPagesAppConfigModule(modulePath, root, resolved) {
+	return [
+		".ts",
+		".tsx",
+		".js",
+		".jsx"
+	].some((extension) => modulePath === canonicalFilePath(resolveConfigPath(root, `${resolved.pagesDir}/_app.config${extension}`)));
+}
+function isRootMiddlewareModule(id, root, resolved) {
+	const queryStart = id.indexOf("?");
+	const path = queryStart === -1 ? id : id.slice(0, queryStart);
+	if (path.startsWith("\0") || path.startsWith("virtual:")) return false;
+	const middlewareDir = resolved.pagesDir || resolved.middlewareDir;
+	const modulePath = canonicalFilePath(path);
+	return [
+		".ts",
+		".tsx",
+		".js",
+		".jsx"
+	].some((extension) => modulePath === canonicalFilePath(resolveConfigPath(root, `${middlewareDir}/_middleware${extension}`)));
+}
 /**
 * Match Vite's canonical module ids even when the manifest path crosses a
 * symlink (including macOS' /var -> /private/var alias). Missing paths keep
@@ -3778,4 +4159,4 @@ function withTrailingSep(p) {
 	return p.endsWith("/") ? p : `${p}/`;
 }
 //#endregion
-export { FRAMEWORK_VENDOR_CHUNK, PRACHT_CAPABILITIES_MODULE_ID, PRACHT_CLIENT_MODULE_ID, PRACHT_ISLANDS_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, PRACHT_WEBMCP_MODULE_ID, PUBLIC_ENV_PREFIX, VITE_BUILTIN_ENV_VARS, createEnvSafetyPlugin, createPrachtCapabilitiesClientModuleSource, createPrachtClientModuleSource, createPrachtIslandsClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, createPrachtWebmcpModuleSource, extractCapabilities, formatEnvLeakError, frameworkChunkGroups, pracht, scanCodeForEnvLeaks };
+export { FRAMEWORK_VENDOR_CHUNK, PRACHT_CAPABILITIES_MODULE_ID, PRACHT_CLIENT_MODULE_ID, PRACHT_ISLANDS_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, PRACHT_WEBMCP_MODULE_ID, PUBLIC_ENV_PREFIX, VITE_BUILTIN_ENV_VARS, createEnvSafetyPlugin, createPrachtCapabilitiesClientModuleSource, createPrachtClientModuleSource, createPrachtIslandsClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, createPrachtWebmcpModuleSource, createPrachtWebmcpModuleSourceAsync, extractCapabilities, formatEnvLeakError, frameworkChunkGroups, pracht, scanCodeForEnvLeaks };