@pracht/vite-plugin 0.2.3 → 0.3.0

package/dist/index.mjs

@@ -1,17 +1,944 @@
 import { generatePagesManifestSource, scanPagesDirectory } from "./pages-router.mjs";
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import preact from "@preact/preset-vite";
-//#region src/index.ts
+import { resolve } from "node:path";
+import { parseAst } from "vite";
+import { existsSync, readFileSync } from "node:fs";
+//#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;
+}
+function getRolldownLang(id) {
+	const path = stripPrachtClientModuleQuery(id).split("?")[0];
+	if (/\.(c|m)?tsx$/i.test(path)) return "tsx";
+	if (/\.(c|m)?ts$/i.test(path)) return "ts";
+	if (/\.(c|m)?jsx$/i.test(path)) return "jsx";
+	if (/\.mdx?$/i.test(path)) return "jsx";
+	if (/\.(c|m)?js$/i.test(path)) return "js";
+	return "tsx";
+}
+//#endregion
+//#region src/scope-analysis-types.ts
+const JSX_COMPONENT_RE = /^[A-Z]/;
+const SKIPPED_KEYS = new Set([
+	"attributes",
+	"decorators",
+	"end",
+	"exportKind",
+	"importKind",
+	"optional",
+	"phase",
+	"raw",
+	"returnType",
+	"start",
+	"superTypeArguments",
+	"type",
+	"typeAnnotation",
+	"typeArguments",
+	"typeParameters",
+	"value"
+]);
+//#endregion
+//#region src/scope-analysis-helpers.ts
+function getStatementDeclaration(statement) {
+	if (statement.type === "ExportNamedDeclaration") return statement.declaration ?? null;
+	if (statement.type === "ExportDefaultDeclaration" && (statement.declaration.type === "FunctionDeclaration" || statement.declaration.type === "ClassDeclaration")) return statement.declaration;
+	if (statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration" || statement.type === "VariableDeclaration") return statement;
+	return null;
+}
+function collectBindingNamesFromPattern(pattern) {
+	if (!pattern) return [];
+	switch (pattern.type) {
+		case "Identifier": return [pattern.name];
+		case "AssignmentPattern": return collectBindingNamesFromPattern(pattern.left);
+		case "RestElement": return collectBindingNamesFromPattern(pattern.argument);
+		case "ObjectPattern": return pattern.properties.flatMap((property) => {
+			if (property.type === "Property") return collectBindingNamesFromPattern(property.value);
+			return collectBindingNamesFromPattern(property.argument);
+		});
+		case "ArrayPattern": return pattern.elements.flatMap((element) => collectBindingNamesFromPattern(element));
+		default: return [];
+	}
+}
+function getIdentifierName(node) {
+	if (!node) return null;
+	if (node.type === "Identifier" || node.type === "JSXIdentifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+function isNode(value) {
+	return !!value && typeof value === "object" && "type" in value;
+}
+function getTsRuntimeChildren(node) {
+	switch (node.type) {
+		case "TSAsExpression":
+		case "TSInstantiationExpression":
+		case "TSNonNullExpression":
+		case "TSSatisfiesExpression":
+		case "TSTypeAssertion": return [node.expression];
+		default: return [];
+	}
+}
+function collectFunctionScopedVarBindings(node) {
+	const names = /* @__PURE__ */ new Set();
+	collectFunctionScopedVarBindingsInto(node, names);
+	return names;
+}
+function collectFunctionScopedVarBindingsInto(node, names) {
+	if (!node) return;
+	if (node.type.startsWith("TS")) {
+		for (const child of getTsRuntimeChildren(node)) collectFunctionScopedVarBindingsInto(child, names);
+		return;
+	}
+	switch (node.type) {
+		case "ArrowFunctionExpression":
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ClassDeclaration":
+		case "ClassExpression": return;
+		case "VariableDeclaration":
+			if (node.kind === "var") for (const declarator of node.declarations) for (const name of collectBindingNamesFromPattern(declarator.id)) names.add(name);
+			return;
+		default: for (const [key, value] of Object.entries(node)) {
+			if (SKIPPED_KEYS.has(key)) continue;
+			if (key === "id" || key === "implements" || key === "superTypeArguments") continue;
+			collectFunctionScopedVarBindingsFromUnknown(value, names);
+		}
+	}
+}
+function collectFunctionScopedVarBindingsFromUnknown(value, names) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectFunctionScopedVarBindingsFromUnknown(item, names);
+		return;
+	}
+	if (!isNode(value)) return;
+	collectFunctionScopedVarBindingsInto(value, names);
+}
+//#endregion
+//#region src/client-module-transform-state.ts
+function createStatementStates(program) {
+	return program.body.map((node) => ({
+		node,
+		removed: false,
+		removedDeclarators: /* @__PURE__ */ new Set(),
+		removedSpecifiers: /* @__PURE__ */ new Set()
+	}));
+}
+function getRemainingDeclaratorIndices(state) {
+	const declaration = getStatementDeclaration(state.node);
+	if (!declaration || declaration.type !== "VariableDeclaration") return [];
+	return declaration.declarations.map((_item, index) => index).filter((index) => !state.removedDeclarators.has(index));
+}
+function getRemainingSpecifierIndices(state) {
+	const statement = state.node;
+	if (!("specifiers" in statement) || !Array.isArray(statement.specifiers)) return [];
+	return statement.specifiers.map((_item, index) => index).filter((index) => !state.removedSpecifiers.has(index));
+}
+function collectBindingNamesFromDeclaration(declaration) {
+	if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") return declaration.id ? [declaration.id.name] : [];
+	if (declaration.type === "VariableDeclaration") return declaration.declarations.flatMap((declarator) => collectBindingNamesFromPattern(declarator.id));
+	return [];
+}
+function normalizeRetainedStatements(states) {
+	return states.map((state) => normalizeRetainedStatement(state)).filter((state) => state !== null);
+}
+function normalizeRetainedStatement(state) {
+	if (state.removed) return null;
+	const statement = state.node;
+	if (statement.type === "ImportDeclaration" && state.removedSpecifiers.size > 0) return { node: {
+		...statement,
+		specifiers: getRemainingSpecifierIndices(state).map((index) => statement.specifiers[index])
+	} };
+	if (statement.type === "ExportNamedDeclaration" && !statement.declaration && state.removedSpecifiers.size > 0) return { node: {
+		...statement,
+		specifiers: getRemainingSpecifierIndices(state).map((index) => statement.specifiers[index])
+	} };
+	const declaration = getStatementDeclaration(statement);
+	if (declaration?.type === "VariableDeclaration" && state.removedDeclarators.size > 0) {
+		const retainedDeclaration = {
+			...declaration,
+			declarations: getRemainingDeclaratorIndices(state).map((index) => declaration.declarations[index])
+		};
+		if (statement.type === "ExportNamedDeclaration") return { node: {
+			...statement,
+			declaration: retainedDeclaration
+		} };
+		return { node: retainedDeclaration };
+	}
+	return { node: statement };
+}
+//#endregion
+//#region src/client-module-transform-render.ts
+function renderProgram(code, states) {
+	let cursor = 0;
+	let out = "";
+	for (const state of states) {
+		const statement = state.node;
+		out += code.slice(cursor, statement.start);
+		out += renderStatement(code, state);
+		cursor = statement.end;
+	}
+	out += code.slice(cursor);
+	return out;
+}
+function renderStatement(code, state) {
+	if (state.removed) return "";
+	const statement = state.node;
+	const declaration = getStatementDeclaration(statement);
+	if (statement.type === "ImportDeclaration" && state.removedSpecifiers.size > 0) return renderImportDeclaration(code, statement, state);
+	if (statement.type === "ExportNamedDeclaration" && !statement.declaration && state.removedSpecifiers.size > 0) return renderExportSpecifiers(code, statement, state);
+	if (declaration?.type === "VariableDeclaration" && state.removedDeclarators.size > 0) return renderVariableDeclaration(code, statement, declaration, state);
+	return code.slice(statement.start, statement.end);
+}
+function renderImportDeclaration(code, statement, state) {
+	const remaining = getRemainingSpecifierIndices(state).map((index) => statement.specifiers[index]);
+	if (remaining.length === 0) return "";
+	const defaultSpecifier = remaining.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+	const namespaceSpecifier = remaining.find((specifier) => specifier.type === "ImportNamespaceSpecifier");
+	const namedSpecifiers = remaining.filter((specifier) => specifier.type === "ImportSpecifier");
+	const clauseParts = [];
+	if (defaultSpecifier) clauseParts.push(code.slice(defaultSpecifier.start, defaultSpecifier.end));
+	if (namespaceSpecifier) clauseParts.push(code.slice(namespaceSpecifier.start, namespaceSpecifier.end));
+	if (namedSpecifiers.length > 0) clauseParts.push(`{ ${namedSpecifiers.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }`);
+	const importPrefix = ["import"];
+	if (statement.importKind === "type") importPrefix.push("type");
+	if (typeof statement.phase === "string" && statement.phase.length > 0) importPrefix.push(statement.phase);
+	return `${importPrefix.join(" ")} ${clauseParts.join(", ")} from ${code.slice(statement.source.start, statement.end)}`;
+}
+function renderExportSpecifiers(code, statement, state) {
+	const remaining = getRemainingSpecifierIndices(state).map((index) => statement.specifiers[index]);
+	if (remaining.length === 0) return "";
+	const exportPrefix = statement.exportKind === "type" ? "export type" : "export";
+	const sourceSuffix = statement.source ? ` from ${code.slice(statement.source.start, statement.end)}` : ";";
+	return `${exportPrefix} { ${remaining.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }${sourceSuffix}`;
+}
+function renderVariableDeclaration(code, statement, declaration, state) {
+	const remaining = getRemainingDeclaratorIndices(state).map((index) => declaration.declarations[index]);
+	if (remaining.length === 0) return "";
+	return `${statement.type === "ExportNamedDeclaration" ? "export " : ""}${declaration.kind} ${remaining.map((item) => code.slice(item.start, item.end)).join(", ")};`;
+}
+//#endregion
+//#region src/scope-analysis-declare.ts
+function createScope(type, parent, node) {
+	return {
+		bindings: /* @__PURE__ */ new Map(),
+		node,
+		parent,
+		type
+	};
+}
+function declareBinding(scope, name, kind, node) {
+	const binding = {
+		kind,
+		name,
+		node,
+		scope
+	};
+	scope.bindings.set(name, binding);
+	return binding;
+}
+function declareProgramScopes(statements, programScope, scopesByNode) {
+	for (const statement of statements) declareTopLevelStatement(statement.node, programScope);
+	for (const statement of statements) declareNodeScopes(statement.node, programScope, scopesByNode);
+}
+function declareTopLevelStatement(statement, programScope) {
+	if (statement.type === "ImportDeclaration") {
+		if (statement.importKind === "type") return;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+			const localName = getIdentifierName(specifier.local);
+			if (localName) declareBinding(programScope, localName, "import", specifier);
+		}
+		return;
+	}
+	const declaration = getStatementDeclaration(statement);
+	if (!declaration) return;
+	declareDeclarationBindings(programScope, declaration);
+}
+function declareNodeScopes(node, currentScope, scopesByNode) {
+	if (!node) return;
+	if (node.type.startsWith("TS")) {
+		for (const child of getTsRuntimeChildren(node)) declareNodeScopes(child, currentScope, scopesByNode);
+		return;
+	}
+	switch (node.type) {
+		case "ImportDeclaration": return;
+		case "ArrowFunctionExpression":
+		case "FunctionDeclaration":
+		case "FunctionExpression": {
+			const functionScope = createScope("function", currentScope, node);
+			scopesByNode.set(node, functionScope);
+			declareFunctionBindings(node, functionScope);
+			for (const param of node.params) declareNodeScopes(param, functionScope, scopesByNode);
+			declareNodeScopes(node.body, functionScope, scopesByNode);
+			return;
+		}
+		case "BlockStatement": {
+			const blockScope = createScope("block", currentScope, node);
+			scopesByNode.set(node, blockScope);
+			declareBlockBindings(node.body, blockScope);
+			for (const statement of node.body) declareNodeScopes(statement, blockScope, scopesByNode);
+			return;
+		}
+		case "CatchClause": {
+			const catchScope = createScope("catch", currentScope, node);
+			scopesByNode.set(node, catchScope);
+			declareCatchBindings(node, catchScope);
+			if (node.param) declareNodeScopes(node.param, catchScope, scopesByNode);
+			declareNodeScopes(node.body, catchScope, scopesByNode);
+			return;
+		}
+		case "ForStatement": {
+			const init = node.init;
+			if (init?.type === "VariableDeclaration" && init.kind !== "var") {
+				const loopScope = createScope("for", currentScope, node);
+				scopesByNode.set(node, loopScope);
+				declareDeclarationBindings(loopScope, init);
+				declareNodeScopes(init, loopScope, scopesByNode);
+				declareNodeScopes(node.test, loopScope, scopesByNode);
+				declareNodeScopes(node.update, loopScope, scopesByNode);
+				declareNodeScopes(node.body, loopScope, scopesByNode);
+				return;
+			}
+			declareNodeScopes(init, currentScope, scopesByNode);
+			declareNodeScopes(node.test, currentScope, scopesByNode);
+			declareNodeScopes(node.update, currentScope, scopesByNode);
+			declareNodeScopes(node.body, currentScope, scopesByNode);
+			return;
+		}
+		case "ForInStatement":
+		case "ForOfStatement": {
+			const left = node.left;
+			if (left?.type === "VariableDeclaration" && left.kind !== "var") {
+				const loopScope = createScope("for", currentScope, node);
+				scopesByNode.set(node, loopScope);
+				declareDeclarationBindings(loopScope, left);
+				declareNodeScopes(left, loopScope, scopesByNode);
+				declareNodeScopes(node.right, loopScope, scopesByNode);
+				declareNodeScopes(node.body, loopScope, scopesByNode);
+				return;
+			}
+			declareNodeScopes(left, currentScope, scopesByNode);
+			declareNodeScopes(node.right, currentScope, scopesByNode);
+			declareNodeScopes(node.body, currentScope, scopesByNode);
+			return;
+		}
+		case "SwitchStatement": {
+			declareNodeScopes(node.discriminant, currentScope, scopesByNode);
+			const switchScope = createScope("switch", currentScope, node);
+			scopesByNode.set(node, switchScope);
+			declareSwitchBindings(node.cases, switchScope);
+			for (const switchCase of node.cases) declareNodeScopes(switchCase, switchScope, scopesByNode);
+			return;
+		}
+		case "ClassDeclaration":
+		case "ClassExpression": {
+			declareNodeScopes(node.superClass, currentScope, scopesByNode);
+			const classScope = createScope("class", currentScope, node);
+			scopesByNode.set(node, classScope);
+			const name = getIdentifierName(node.id);
+			if (name) declareBinding(classScope, name, "class", node);
+			declareNodeScopes(node.body, classScope, scopesByNode);
+			return;
+		}
+		case "ExportNamedDeclaration":
+			if (node.declaration) declareNodeScopes(node.declaration, currentScope, scopesByNode);
+			return;
+		case "ExportDefaultDeclaration":
+			if (node.declaration.type !== "Identifier") declareNodeScopes(node.declaration, currentScope, scopesByNode);
+			return;
+		default: for (const [key, value] of Object.entries(node)) {
+			if (SKIPPED_KEYS.has(key)) continue;
+			if (key === "id" || key === "implements" || key === "superTypeArguments") continue;
+			declareUnknownValue(value, currentScope, scopesByNode);
+		}
+	}
+}
+function declareUnknownValue(value, currentScope, scopesByNode) {
+	if (Array.isArray(value)) {
+		for (const item of value) declareUnknownValue(item, currentScope, scopesByNode);
+		return;
+	}
+	if (!isNode(value)) return;
+	declareNodeScopes(value, currentScope, scopesByNode);
+}
+function declareFunctionBindings(node, scope) {
+	const functionName = getIdentifierName(node.id);
+	if (functionName) declareBinding(scope, functionName, "function", node);
+	for (const param of node.params) for (const name of collectBindingNamesFromPattern(param)) declareBinding(scope, name, "param", param);
+	for (const name of collectFunctionScopedVarBindings(node.body)) declareBinding(scope, name, "var", node.body);
+}
+function declareBlockBindings(statements, scope) {
+	for (const statement of statements) {
+		const declaration = getStatementDeclaration(statement);
+		if (!declaration) continue;
+		if (declaration.type === "VariableDeclaration" && declaration.kind === "var") continue;
+		declareDeclarationBindings(scope, declaration);
+	}
+}
+function declareCatchBindings(node, scope) {
+	if (!node.param) return;
+	for (const name of collectBindingNamesFromPattern(node.param)) declareBinding(scope, name, "catch", node.param);
+}
+function declareSwitchBindings(cases, scope) {
+	const statements = [];
+	for (const switchCase of cases) for (const statement of switchCase.consequent) statements.push(statement);
+	declareBlockBindings(statements, scope);
+}
+function declareDeclarationBindings(scope, declaration) {
+	if (declaration.type === "FunctionDeclaration") {
+		const name = getIdentifierName(declaration.id);
+		if (name) declareBinding(scope, name, "function", declaration);
+		return;
+	}
+	if (declaration.type === "ClassDeclaration") {
+		const name = getIdentifierName(declaration.id);
+		if (name) declareBinding(scope, name, "class", declaration);
+		return;
+	}
+	if (declaration.type !== "VariableDeclaration") return;
+	for (const declarator of declaration.declarations) for (const name of collectBindingNamesFromPattern(declarator.id)) declareBinding(scope, name, declaration.kind, declarator);
+}
+//#endregion
+//#region src/scope-analysis-references.ts
+function collectStatementReferences(statement, currentScope, scopesByNode, result, excludedNames) {
+	if (statement.type === "ImportDeclaration") return;
+	if (statement.type === "ExportNamedDeclaration") {
+		const declaration = statement.declaration;
+		if (declaration) collectNodeReferences(declaration, currentScope, scopesByNode, result, excludedNames);
+		return;
+	}
+	if (statement.type === "ExportDefaultDeclaration") {
+		const declaration = statement.declaration;
+		if (declaration.type !== "Identifier") collectNodeReferences(declaration, currentScope, scopesByNode, result, excludedNames);
+		return;
+	}
+	collectNodeReferences(statement, currentScope, scopesByNode, result, excludedNames);
+}
+function collectNodeReferences(node, currentScope, scopesByNode, result, excludedNames) {
+	if (!node) return;
+	if (node.type.startsWith("TS")) {
+		for (const child of getTsRuntimeChildren(node)) collectNodeReferences(child, currentScope, scopesByNode, result, excludedNames);
+		return;
+	}
+	switch (node.type) {
+		case "Identifier":
+			recordReference(node.name, node, currentScope, result, excludedNames);
+			return;
+		case "JSXIdentifier":
+			if (JSX_COMPONENT_RE.test(node.name)) recordReference(node.name, node, currentScope, result, excludedNames);
+			return;
+		case "ArrowFunctionExpression":
+		case "FunctionDeclaration":
+		case "FunctionExpression": {
+			const functionScope = scopesByNode.get(node) ?? currentScope;
+			for (const param of node.params) collectPatternReferences(param, functionScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.body, functionScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "BlockStatement": {
+			const blockScope = scopesByNode.get(node) ?? currentScope;
+			for (const statement of node.body) collectStatementReferences(statement, blockScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "CatchClause": {
+			const catchScope = scopesByNode.get(node) ?? currentScope;
+			if (node.param) collectPatternReferences(node.param, catchScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.body, catchScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "ForStatement": {
+			const loopScope = scopesByNode.get(node) ?? currentScope;
+			collectNodeReferences(node.init, loopScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.test, loopScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.update, loopScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.body, loopScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "ForInStatement":
+		case "ForOfStatement": {
+			const loopScope = scopesByNode.get(node) ?? currentScope;
+			collectNodeReferences(node.left, loopScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.right, loopScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.body, loopScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "SwitchStatement": {
+			collectNodeReferences(node.discriminant, currentScope, scopesByNode, result, excludedNames);
+			const switchScope = scopesByNode.get(node) ?? currentScope;
+			for (const switchCase of node.cases) {
+				collectNodeReferences(switchCase.test, switchScope, scopesByNode, result, excludedNames);
+				for (const statement of switchCase.consequent) collectStatementReferences(statement, switchScope, scopesByNode, result, excludedNames);
+			}
+			return;
+		}
+		case "ClassDeclaration":
+		case "ClassExpression": {
+			collectNodeReferences(node.superClass, currentScope, scopesByNode, result, excludedNames);
+			const classScope = scopesByNode.get(node) ?? currentScope;
+			collectNodeReferences(node.body, classScope, scopesByNode, result, excludedNames);
+			return;
+		}
+		case "VariableDeclaration":
+			for (const declarator of node.declarations) collectVariableDeclaratorReferences(declarator, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "MemberExpression":
+			collectNodeReferences(node.object, currentScope, scopesByNode, result, excludedNames);
+			if (node.computed) collectNodeReferences(node.property, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "MetaProperty": return;
+		case "LabeledStatement":
+			collectNodeReferences(node.body, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "BreakStatement":
+		case "ContinueStatement": return;
+		case "Property":
+			if (node.computed) collectNodeReferences(node.key, currentScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.value, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "ObjectPattern":
+		case "ArrayPattern":
+		case "AssignmentPattern":
+		case "RestElement":
+			collectPatternReferences(node, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXElement":
+			collectNodeReferences(node.openingElement, currentScope, scopesByNode, result, excludedNames);
+			for (const child of node.children) collectNodeReferences(child, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXFragment":
+			for (const child of node.children) collectNodeReferences(child, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXOpeningElement":
+			collectNodeReferences(node.name, currentScope, scopesByNode, result, excludedNames);
+			for (const attribute of node.attributes) collectNodeReferences(attribute, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXClosingElement":
+			collectNodeReferences(node.name, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXAttribute":
+			collectNodeReferences(node.value, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXExpressionContainer":
+			collectNodeReferences(node.expression, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "JSXMemberExpression":
+			collectNodeReferences(node.object, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "MethodDefinition":
+		case "PropertyDefinition":
+			if (node.computed) collectNodeReferences(node.key, currentScope, scopesByNode, result, excludedNames);
+			collectNodeReferences(node.value, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "ImportDeclaration": return;
+		case "ExportNamedDeclaration":
+			if (node.declaration) collectNodeReferences(node.declaration, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "ExportDefaultDeclaration":
+			if (node.declaration.type !== "Identifier") collectNodeReferences(node.declaration, currentScope, scopesByNode, result, excludedNames);
+			return;
+		default: for (const [key, value] of Object.entries(node)) {
+			if (SKIPPED_KEYS.has(key)) continue;
+			if (key === "id" || key === "implements" || key === "superTypeArguments") continue;
+			collectUnknownValueReferences(value, currentScope, scopesByNode, result, excludedNames);
+		}
+	}
+}
+function collectUnknownValueReferences(value, currentScope, scopesByNode, result, excludedNames) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectUnknownValueReferences(item, currentScope, scopesByNode, result, excludedNames);
+		return;
+	}
+	if (!isNode(value)) return;
+	collectNodeReferences(value, currentScope, scopesByNode, result, excludedNames);
+}
+function collectVariableDeclaratorReferences(declarator, currentScope, scopesByNode, result, excludedNames) {
+	collectPatternReferences(declarator.id, currentScope, scopesByNode, result, excludedNames);
+	collectNodeReferences(declarator.init, currentScope, scopesByNode, result, excludedNames);
+}
+function collectPatternReferences(node, currentScope, scopesByNode, result, excludedNames) {
+	if (!node) return;
+	if (node.type.startsWith("TS")) {
+		for (const child of getTsRuntimeChildren(node)) collectNodeReferences(child, currentScope, scopesByNode, result, excludedNames);
+		return;
+	}
+	switch (node.type) {
+		case "AssignmentPattern":
+			collectNodeReferences(node.right, currentScope, scopesByNode, result, excludedNames);
+			collectPatternReferences(node.left, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "ObjectPattern":
+			for (const property of node.properties) {
+				if (property.type === "Property") {
+					if (property.computed) collectNodeReferences(property.key, currentScope, scopesByNode, result, excludedNames);
+					collectPatternReferences(property.value, currentScope, scopesByNode, result, excludedNames);
+					continue;
+				}
+				collectPatternReferences(property.argument, currentScope, scopesByNode, result, excludedNames);
+			}
+			return;
+		case "ArrayPattern":
+			for (const element of node.elements) collectPatternReferences(element, currentScope, scopesByNode, result, excludedNames);
+			return;
+		case "RestElement":
+			collectPatternReferences(node.argument, currentScope, scopesByNode, result, excludedNames);
+			return;
+		default: return;
+	}
+}
+function recordReference(name, node, currentScope, result, excludedNames) {
+	const resolvedBinding = resolveBinding(name, currentScope);
+	result.references.push({
+		name,
+		node,
+		resolvedBinding
+	});
+	if (!resolvedBinding) return;
+	if (resolvedBinding.scope.type !== "program") return;
+	if (excludedNames.has(name)) return;
+	result.referencedTopLevelNames.add(name);
+}
+function resolveBinding(name, currentScope) {
+	let scope = currentScope;
+	while (scope) {
+		const binding = scope.bindings.get(name);
+		if (binding) return binding;
+		scope = scope.parent;
+	}
+	return null;
+}
+//#endregion
+//#region src/client-module-scope-analysis.ts
+function analyzeRetainedStatements(statements, options = {}) {
+	const programScope = createScope("program", null, null);
+	for (const name of options.knownTopLevelNames ?? []) declareBinding(programScope, name, "placeholder", null);
+	const scopesByNode = /* @__PURE__ */ new WeakMap();
+	declareProgramScopes(statements, programScope, scopesByNode);
+	const result = {
+		programScope,
+		referencedTopLevelNames: /* @__PURE__ */ new Set(),
+		references: []
+	};
+	const excludedNames = new Set(options.excludedNames);
+	for (const statement of statements) collectStatementReferences(statement.node, programScope, scopesByNode, result, excludedNames);
+	return result;
+}
+//#endregion
+//#region src/client-module-transform.ts
+const SERVER_ONLY_EXPORTS = new Set([
+	"loader",
+	"head",
+	"headers",
+	"getStaticPaths"
+]);
+function stripServerOnlyExportsForClient(code, id = "pracht-client-route.tsx") {
+	const states = createStatementStates(parseAst(code, { lang: getRolldownLang(id) }));
+	const initialBindingNames = collectCurrentTopLevelBindingNames(states);
+	const { changed, candidates } = removeServerOnlyExports(states, initialBindingNames);
+	if (!changed) return code;
+	pruneDeadBindings(states, initialBindingNames, candidates);
+	return renderProgram(code, states);
+}
+function removeServerOnlyExports(states, initialBindingNames) {
+	let changed = false;
+	const candidates = /* @__PURE__ */ new Set();
+	for (const state of states) {
+		const statement = state.node;
+		if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") continue;
+		const declaration = statement.declaration;
+		if (declaration?.type === "FunctionDeclaration") {
+			const name = declaration.id?.name;
+			if (!name || !SERVER_ONLY_EXPORTS.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)));
+			if (removable.length === 0) continue;
+			changed = true;
+			for (const index of removable) {
+				const declarator = declaration.declarations[index];
+				const declaredNames = new Set(collectBindingNamesFromPattern(declarator.id));
+				enqueueDependencies(candidates, collectVariableDeclaratorDependencies(declarator, declaration.kind, initialBindingNames, declaredNames));
+				state.removedDeclarators.add(index);
+			}
+			if (getRemainingDeclaratorIndices(state).length === 0) state.removed = true;
+			continue;
+		}
+		const removableSpecifiers = getRemainingSpecifierIndices(state).filter((index) => {
+			const specifier = statement.specifiers[index];
+			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 ?? "");
+		});
+		if (removableSpecifiers.length === 0) continue;
+		changed = true;
+		for (const index of removableSpecifiers) {
+			const specifier = statement.specifiers[index];
+			if (!statement.source) {
+				const localName = getIdentifierName(specifier.local);
+				if (localName) candidates.add(localName);
+			}
+			state.removedSpecifiers.add(index);
+		}
+		if (getRemainingSpecifierIndices(state).length === 0) state.removed = true;
+	}
+	return {
+		changed,
+		candidates
+	};
+}
+function pruneDeadBindings(states, initialBindingNames, candidates) {
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const bindings = collectTopLevelBindings(states, initialBindingNames);
+		const exportedNames = collectExportedBindingNames(states);
+		const referencedNames = collectProgramReferences(states);
+		const pendingNames = Array.from(candidates);
+		for (const name of pendingNames) {
+			const binding = bindings.get(name);
+			if (!binding) continue;
+			if (exportedNames.has(name) || referencedNames.has(name)) continue;
+			removeBinding(states, binding);
+			enqueueDependencies(candidates, binding.dependencies);
+			changed = true;
+		}
+	}
+}
+function collectTopLevelBindings(states, dependencyBindingNames) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const [statementIndex, state] of states.entries()) {
+		if (state.removed) continue;
+		const statement = state.node;
+		if (statement.type === "ImportDeclaration") {
+			if (statement.importKind === "type") continue;
+			for (const index of getRemainingSpecifierIndices(state)) {
+				const specifier = statement.specifiers[index];
+				if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+				const local = specifier.local;
+				const name = getIdentifierName(local);
+				if (!name) continue;
+				const info = {
+					dependencies: /* @__PURE__ */ new Set(),
+					kind: "import",
+					names: new Set([name]),
+					node: specifier,
+					specifierIndex: index,
+					statementIndex
+				};
+				bindings.set(name, info);
+			}
+			continue;
+		}
+		const declaration = getStatementDeclaration(statement);
+		if (!declaration) continue;
+		if (declaration.type === "FunctionDeclaration") {
+			const name = getIdentifierName(declaration.id);
+			if (!name) continue;
+			const info = {
+				dependencies: collectTopLevelReferences(declaration, dependencyBindingNames, new Set([name])),
+				kind: "function",
+				names: new Set([name]),
+				node: declaration,
+				statementIndex
+			};
+			bindings.set(name, info);
+			continue;
+		}
+		if (declaration.type === "ClassDeclaration") {
+			const name = getIdentifierName(declaration.id);
+			if (!name) continue;
+			const info = {
+				dependencies: collectTopLevelReferences(declaration, dependencyBindingNames, new Set([name])),
+				kind: "class",
+				names: new Set([name]),
+				node: declaration,
+				statementIndex
+			};
+			bindings.set(name, info);
+			continue;
+		}
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const index of getRemainingDeclaratorIndices(state)) {
+			const declarator = declaration.declarations[index];
+			const names = new Set(collectBindingNamesFromPattern(declarator.id));
+			if (names.size === 0) continue;
+			const info = {
+				declaratorIndex: index,
+				dependencies: collectVariableDeclaratorDependencies(declarator, declaration.kind, dependencyBindingNames, names),
+				kind: "variable",
+				names,
+				node: declarator,
+				statementIndex
+			};
+			for (const name of names) bindings.set(name, info);
+		}
+	}
+	return bindings;
+}
+function collectCurrentTopLevelBindingNames(states) {
+	const names = /* @__PURE__ */ new Set();
+	for (const state of states) {
+		if (state.removed) continue;
+		const statement = state.node;
+		if (statement.type === "ImportDeclaration") {
+			if (statement.importKind === "type") continue;
+			for (const index of getRemainingSpecifierIndices(state)) {
+				const specifier = statement.specifiers[index];
+				if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+				const localName = getIdentifierName(specifier.local);
+				if (localName) names.add(localName);
+			}
+			continue;
+		}
+		const declaration = getStatementDeclaration(statement);
+		if (!declaration) continue;
+		if (declaration.type === "VariableDeclaration") {
+			for (const index of getRemainingDeclaratorIndices(state)) {
+				const declarator = declaration.declarations[index];
+				for (const name of collectBindingNamesFromPattern(declarator.id)) names.add(name);
+			}
+			continue;
+		}
+		for (const name of collectBindingNamesFromDeclaration(declaration)) names.add(name);
+	}
+	return names;
+}
+function collectExportedBindingNames(states) {
+	const names = /* @__PURE__ */ new Set();
+	for (const state of states) {
+		if (state.removed) continue;
+		const statement = state.node;
+		if (statement.type === "ExportNamedDeclaration") {
+			const declaration = statement.declaration;
+			if (declaration) if (declaration.type === "VariableDeclaration") for (const index of getRemainingDeclaratorIndices(state)) {
+				const declarator = declaration.declarations[index];
+				for (const name of collectBindingNamesFromPattern(declarator.id)) names.add(name);
+			}
+			else for (const name of collectBindingNamesFromDeclaration(declaration)) names.add(name);
+			for (const index of getRemainingSpecifierIndices(state)) {
+				const specifier = statement.specifiers[index];
+				if (specifier.type !== "ExportSpecifier" || specifier.exportKind === "type") continue;
+				const localName = getIdentifierName(specifier.local);
+				if (localName) names.add(localName);
+			}
+		}
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = statement.declaration;
+		if (declaration.type === "Identifier") {
+			names.add(declaration.name);
+			continue;
+		}
+		if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id) names.add(declaration.id.name);
+	}
+	return names;
+}
+function collectProgramReferences(states) {
+	return analyzeRetainedStatements(normalizeRetainedStatements(states)).referencedTopLevelNames;
+}
+function removeBinding(states, binding) {
+	const state = states[binding.statementIndex];
+	if (binding.kind === "import" && binding.specifierIndex !== void 0) {
+		state.removedSpecifiers.add(binding.specifierIndex);
+		if (getRemainingSpecifierIndices(state).length === 0) state.removed = true;
+		return;
+	}
+	if (binding.kind === "variable" && binding.declaratorIndex !== void 0) {
+		state.removedDeclarators.add(binding.declaratorIndex);
+		if (getRemainingDeclaratorIndices(state).length === 0) state.removed = true;
+		return;
+	}
+	state.removed = true;
+}
+function collectVariableDeclaratorDependencies(declarator, declarationKind, topLevelBindingNames, excludedNames) {
+	return collectTopLevelReferences({
+		declarations: [declarator],
+		end: declarator.end,
+		kind: declarationKind,
+		start: declarator.start,
+		type: "VariableDeclaration"
+	}, topLevelBindingNames, excludedNames);
+}
+function collectTopLevelReferences(node, topLevelBindingNames, excludedNames) {
+	return analyzeRetainedStatements([{ node }], {
+		excludedNames,
+		knownTopLevelNames: topLevelBindingNames
+	}).referencedTopLevelNames;
+}
+function enqueueDependencies(target, dependencies) {
+	for (const name of dependencies) target.add(name);
+}
+//#endregion
+//#region src/plugin-assets.ts
 const PRACHT_CLIENT_MODULE_ID = "virtual:pracht/client";
 const PRACHT_SERVER_MODULE_ID = "virtual:pracht/server";
 const CLIENT_BROWSER_PATH = "/@pracht/client.js";
+function readClientBuildAssets(root = process.cwd()) {
+	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,
+		cssManifest: {},
+		jsManifest: {}
+	};
+	const rawManifest = readFileSync(manifestPath, "utf-8");
+	const manifest = JSON.parse(rawManifest);
+	const clientEntry = manifest[PRACHT_CLIENT_MODULE_ID];
+	const cssManifest = {};
+	const jsManifest = {};
+	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) => `/${f}`);
+		if (deps.js.length > 0) jsManifest[manifestKey] = deps.js.map((f) => `/${f}`);
+	}
+	return {
+		clientEntryUrl: clientEntry ? `/${clientEntry.file}` : null,
+		cssManifest,
+		jsManifest
+	};
+}
+function collectTransitiveDeps(manifest, key) {
+	const css = /* @__PURE__ */ new Set();
+	const js = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	function collect(k) {
+		if (visited.has(k)) return;
+		visited.add(k);
+		const entry = manifest[k];
+		if (!entry) return;
+		for (const c of entry.css ?? []) css.add(c);
+		js.add(entry.file);
+		for (const imp of entry.imports ?? []) collect(imp);
+	}
+	collect(key);
+	return {
+		css: [...css],
+		js: [...js]
+	};
+}
 function isClientModule(id) {
-	return id === "virtual:pracht/client" || id === CLIENT_BROWSER_PATH || id.endsWith("virtual:pracht/client");
+	return id === "virtual:pracht/client" || id === "/@pracht/client.js" || id.endsWith("virtual:pracht/client");
 }
 function isServerModule(id) {
 	return id === "virtual:pracht/server" || id.endsWith("virtual:pracht/server");
 }
+//#endregion
+//#region src/plugin-adapter.ts
 function createDefaultNodeAdapter() {
 	return {
 		id: "node",
@@ -55,6 +982,8 @@ function createDefaultNodeAdapter() {
 		}
 	};
 }
+//#endregion
+//#region src/plugin-options.ts
 const DEFAULTS = {
 	appFile: "/src/routes.ts",
 	middlewareDir: "/src/middleware",
@@ -66,98 +995,14 @@ const DEFAULTS = {
 	pagesDir: "",
 	pagesDefaultRender: "ssr"
 };
-async function pracht(options = {}) {
-	const resolved = resolveOptions(options);
-	const isPagesMode = !!resolved.pagesDir;
-	let root = process.cwd();
-	if (isPagesMode && options.appFile) console.warn("[pracht] Both `pagesDir` and `appFile` are set. `pagesDir` takes precedence — `appFile` will be ignored.");
-	let isBuild = false;
-	const prachtPlugin = {
-		name: "pracht",
-		enforce: "pre",
-		config(_config, env) {
-			const isEdge = resolved.adapter.id === "vercel" || resolved.adapter.id === "cloudflare";
-			const isSSRBuild = env.isSsrBuild;
-			return {
-				appType: "custom",
-				build: { rollupOptions: { output: { manualChunks(id) {
-					if (id.includes("node_modules/preact") || id.includes("node_modules/preact-suspense")) return "vendor";
-				} } } },
-				...isEdge && isSSRBuild ? { ssr: { noExternal: true } } : {}
-			};
-		},
-		configResolved(config) {
-			root = config.root;
-			isBuild = config.command === "build";
-		},
-		resolveId(id) {
-			if (isClientModule(id)) return PRACHT_CLIENT_MODULE_ID;
-			if (isServerModule(id)) return PRACHT_SERVER_MODULE_ID;
-			return null;
-		},
-		load(id) {
-			if (isClientModule(id)) return createPrachtClientModuleSource(resolved, { root });
-			if (isServerModule(id)) return createPrachtServerModuleSource(resolved, {
-				root,
-				isBuild
-			});
-			return null;
-		},
-		transform(code, id) {
-			if (id !== resolve(root, resolved.appFile.slice(1))) return null;
-			const transformed = code.replace(/\(\)\s*=>\s*import\(\s*(['"])([^'"]+)\1\s*\)/g, "$1$2$1");
-			if (transformed === code) return null;
-			return {
-				code: transformed,
-				map: null
-			};
-		},
-		configureServer(server) {
-			if (isPagesMode) {
-				const abs = resolve(root, resolved.pagesDir.slice(1));
-				server.watcher.on("add", (f) => {
-					if (f.startsWith(abs)) server.restart();
-				});
-				server.watcher.on("unlink", (f) => {
-					if (f.startsWith(abs)) server.restart();
-				});
-			}
-			if (resolved.adapter.ownsDevServer) return;
-			return () => {
-				server.middlewares.use(createDevSSRMiddleware(server, resolved));
-			};
-		},
-		handleHotUpdate({ file, server }) {
-			const root = server.config.root;
-			const relative = file.startsWith(root) ? file.slice(root.length) : file;
-			if (isPagesMode && relative.startsWith(resolved.pagesDir)) {
-				const clientMod = server.moduleGraph.getModuleById(PRACHT_CLIENT_MODULE_ID);
-				const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
-				if (clientMod) server.moduleGraph.invalidateModule(clientMod);
-				if (serverMod) server.moduleGraph.invalidateModule(serverMod);
-				return;
-			}
-			if (!isPagesMode && relative === resolved.appFile) {
-				server.restart();
-				return [];
-			}
-			if ([
-				resolved.routesDir,
-				resolved.shellsDir,
-				resolved.middlewareDir,
-				resolved.apiDir,
-				resolved.serverDir
-			].some((dir) => relative.startsWith(dir))) {
-				const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
-				if (serverMod) server.moduleGraph.invalidateModule(serverMod);
-			}
-		}
+function resolveOptions(options) {
+	return {
+		...DEFAULTS,
+		...options
 	};
-	const plugins = [...preact(), prachtPlugin];
-	const adapterPlugins = await resolved.adapter.vitePlugins?.();
-	if (adapterPlugins?.length) plugins.push(...adapterPlugins);
-	return plugins;
 }
+//#endregion
+//#region src/plugin-codegen.ts
 function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 	const resolved = resolveOptions(options);
 	const isPagesMode = !!resolved.pagesDir;
@@ -168,16 +1013,21 @@ function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
 		"import { resolveApp, initClientRouter, readHydrationState } from \"@pracht/core\";",
 		appImport,
 		"",
-		`const routeModules = import.meta.glob(${JSON.stringify(routeGlob)});`,
-		`const shellModules = import.meta.glob(${JSON.stringify(shellGlob)});`,
+		`const routeModules = import.meta.glob(${JSON.stringify(routeGlob)}, { query: ${JSON.stringify(PRACHT_CLIENT_MODULE_QUERY)} });`,
+		`const shellModules = import.meta.glob(${JSON.stringify(shellGlob)}, { query: ${JSON.stringify(PRACHT_CLIENT_MODULE_QUERY)} });`,
 		"",
 		"const resolvedApp = resolveApp(app);",
 		"",
+		"function normalizeModuleKey(key) {",
+		"  return key.split(\"?\")[0];",
+		"}",
+		"",
 		"function findModuleKey(modules, file) {",
 		"  if (file in modules) return file;",
 		"  const suffix = file.replace(/^\\.\\//,\"\");",
 		"  for (const key of Object.keys(modules)) {",
-		"    if (key.endsWith(\"/\" + suffix) || key.endsWith(suffix)) return key;",
+		"    const normalizedKey = normalizeModuleKey(key);",
+		"    if (normalizedKey.endsWith(\"/\" + suffix) || normalizedKey.endsWith(suffix)) return key;",
 		"  }",
 		"  return null;",
 		"}",
@@ -216,7 +1066,7 @@ function createPrachtServerModuleSource(options = {}, buildOptions = {}) {
 		"export const resolvedApp = resolveApp(app);",
 		`export const apiRoutes = resolveApiRoutes(Object.keys(apiModules), ${JSON.stringify(resolved.apiDir)});`,
 		`export const buildTarget = ${JSON.stringify(adapter?.id ?? "node")};`,
-		`export const clientEntryUrl = ${JSON.stringify(clientBuild.clientEntryUrl ?? CLIENT_BROWSER_PATH)};`,
+		`export const clientEntryUrl = ${JSON.stringify(clientBuild.clientEntryUrl ?? "/@pracht/client.js")};`,
 		`export const cssManifest = ${JSON.stringify(clientBuild.cssManifest)};`,
 		`export const jsManifest = ${JSON.stringify(clientBuild.jsManifest)};`,
 		"export { prerenderApp };",
@@ -254,7 +1104,11 @@ function generatePagesAppInlineSource(options, root = process.cwd()) {
 		pagesDirPrefix: options.pagesDir
 	});
 }
-function createDevSSRMiddleware(server, _pluginOptions) {
+//#endregion
+//#region src/plugin-dev-ssr.ts
+const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+const MAX_BODY_SIZE = 1024 * 1024;
+function createDevSSRMiddleware(server) {
 	return async (req, res, next) => {
 		const url = req.url ?? "/";
 		const pathname = new URL(url, "http://localhost").pathname;
@@ -290,34 +1144,36 @@ function createDevSSRMiddleware(server, _pluginOptions) {
 			});
 			res.end(body);
 		} catch (error) {
-			if (error instanceof Error) server.ssrFixStacktrace(error);
-			if (req.headers["x-pracht-route-state-request"] === "1") {
-				res.statusCode = 500;
-				res.setHeader("content-type", "application/json; charset=utf-8");
-				res.end(JSON.stringify({ error: {
-					message: error instanceof Error ? error.message : String(error),
-					name: error instanceof Error ? error.name : "Error",
-					status: 500
-				} }));
-				return;
-			}
-			try {
-				const { buildErrorOverlayHtml } = await server.ssrLoadModule("pracht/error-overlay");
-				let html = buildErrorOverlayHtml({
-					message: error instanceof Error ? error.message : String(error),
-					stack: error instanceof Error ? error.stack : void 0
-				});
-				html = await server.transformIndexHtml(url, html);
-				res.statusCode = 500;
-				res.setHeader("content-type", "text/html; charset=utf-8");
-				res.end(html);
-			} catch {
-				next(error);
-			}
+			await handleDevError(server, req, res, next, url, error);
 		}
 	};
 }
-const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+async function handleDevError(server, req, res, next, url, error) {
+	if (error instanceof Error) server.ssrFixStacktrace(error);
+	if (req.headers["x-pracht-route-state-request"] === "1") {
+		res.statusCode = 500;
+		res.setHeader("content-type", "application/json; charset=utf-8");
+		res.end(JSON.stringify({ error: {
+			message: error instanceof Error ? error.message : String(error),
+			name: error instanceof Error ? error.name : "Error",
+			status: 500
+		} }));
+		return;
+	}
+	try {
+		const { buildErrorOverlayHtml } = await server.ssrLoadModule("pracht/error-overlay");
+		let html = buildErrorOverlayHtml({
+			message: error instanceof Error ? error.message : String(error),
+			stack: error instanceof Error ? error.stack : void 0
+		});
+		html = await server.transformIndexHtml(url, html);
+		res.statusCode = 500;
+		res.setHeader("content-type", "text/html; charset=utf-8");
+		res.end(html);
+	} catch {
+		next(error);
+	}
+}
 async function nodeToWebRequest(req) {
 	const protocol = "http";
 	const host = req.headers.host ?? "localhost";
@@ -334,7 +1190,6 @@ async function nodeToWebRequest(req) {
 		headers
 	};
 	if (!BODYLESS_METHODS.has(method.toUpperCase())) {
-		const MAX_BODY_SIZE = 1024 * 1024;
 		const chunks = [];
 		let totalSize = 0;
 		for await (const chunk of req) {
@@ -351,54 +1206,151 @@ async function nodeToWebRequest(req) {
 	}
 	return new Request(url, init);
 }
-function resolveOptions(options) {
-	return {
-		...DEFAULTS,
-		...options
-	};
-}
-function readClientBuildAssets(root = process.cwd()) {
-	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,
-		cssManifest: {},
-		jsManifest: {}
+//#endregion
+//#region src/index.ts
+async function pracht(options = {}) {
+	const resolved = resolveOptions(options);
+	const isPagesMode = !!resolved.pagesDir;
+	let root = process.cwd();
+	let routeFileDirs = [];
+	if (isPagesMode && options.appFile) console.warn("[pracht] Both `pagesDir` and `appFile` are set. `pagesDir` takes precedence — `appFile` will be ignored.");
+	let isBuild = false;
+	const prachtPlugin = {
+		name: "pracht",
+		enforce: "pre",
+		config(_config, env) {
+			const isEdge = resolved.adapter.edge === true;
+			const isSSRBuild = env.isSsrBuild;
+			return {
+				appType: "custom",
+				build: { rollupOptions: { output: { manualChunks(id) {
+					if (id.includes("node_modules/preact") || id.includes("node_modules/preact-suspense")) return "vendor";
+				} } } },
+				...isEdge && isSSRBuild ? { ssr: { noExternal: true } } : {}
+			};
+		},
+		configResolved(config) {
+			root = config.root;
+			isBuild = config.command === "build";
+			routeFileDirs = computeRouteFileDirs(root, resolved);
+		},
+		resolveId(id) {
+			if (isClientModule(id)) return PRACHT_CLIENT_MODULE_ID;
+			if (isServerModule(id)) return PRACHT_SERVER_MODULE_ID;
+			return null;
+		},
+		load(id) {
+			if (isClientModule(id)) return createPrachtClientModuleSource(resolved, { root });
+			if (isServerModule(id)) return createPrachtServerModuleSource(resolved, {
+				root,
+				isBuild
+			});
+			return null;
+		},
+		transform(code, id) {
+			if (id !== resolve(root, resolved.appFile.slice(1))) return null;
+			const transformed = code.replace(/\(\)\s*=>\s*import\(\s*(['"])([^'"]+)\1\s*\)/g, "$1$2$1");
+			if (transformed === code) return null;
+			return {
+				code: transformed,
+				map: null
+			};
+		},
+		configureServer(server) {
+			if (isPagesMode) watchPagesDirectory(server, resolved, root);
+			if (resolved.adapter.ownsDevServer) return;
+			return () => {
+				server.middlewares.use(createDevSSRMiddleware(server));
+			};
+		},
+		handleHotUpdate({ file, server }) {
+			const serverRoot = server.config.root;
+			const relative = file.startsWith(serverRoot) ? file.slice(serverRoot.length) : file;
+			if (isPagesMode && relative.startsWith(resolved.pagesDir)) {
+				invalidateVirtualModules(server);
+				return;
+			}
+			if (!isPagesMode && relative === resolved.appFile) {
+				server.restart();
+				return [];
+			}
+			if ([
+				resolved.routesDir,
+				resolved.shellsDir,
+				resolved.middlewareDir,
+				resolved.apiDir,
+				resolved.serverDir
+			].some((dir) => relative.startsWith(dir))) {
+				const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
+				if (serverMod) server.moduleGraph.invalidateModule(serverMod);
+			}
+		}
 	};
-	const rawManifest = readFileSync(manifestPath, "utf-8");
-	const manifest = JSON.parse(rawManifest);
-	const clientEntry = manifest[PRACHT_CLIENT_MODULE_ID];
-	function collectTransitiveDeps(key) {
-		const css = /* @__PURE__ */ new Set();
-		const js = /* @__PURE__ */ new Set();
-		const visited = /* @__PURE__ */ new Set();
-		function collect(k) {
-			if (visited.has(k)) return;
-			visited.add(k);
-			const entry = manifest[k];
-			if (!entry) return;
-			for (const c of entry.css ?? []) css.add(c);
-			js.add(entry.file);
-			for (const imp of entry.imports ?? []) collect(imp);
-		}
-		collect(key);
-		return {
-			css: [...css],
-			js: [...js]
-		};
-	}
-	const cssManifest = {};
-	const jsManifest = {};
-	for (const [key, entry] of Object.entries(manifest)) {
-		if (!entry.src) continue;
-		const deps = collectTransitiveDeps(key);
-		if (deps.css.length > 0) cssManifest[key] = deps.css.map((f) => `/${f}`);
-		if (deps.js.length > 0) jsManifest[key] = deps.js.map((f) => `/${f}`);
-	}
-	return {
-		clientEntryUrl: clientEntry ? `/${clientEntry.file}` : null,
-		cssManifest,
-		jsManifest
+	const clientModuleTransformPlugin = {
+		name: "pracht:client-module-transform",
+		enforce: "post",
+		transform(code, id, transformOptions) {
+			if (!(isPrachtClientModuleId(id) || !transformOptions?.ssr && isRouteOrShellFile(id, routeFileDirs))) return null;
+			const transformed = stripServerOnlyExportsForClient(code, id);
+			if (transformed === code) return null;
+			return {
+				code: transformed,
+				map: null
+			};
+		}
 	};
+	const plugins = [
+		...preact(),
+		prachtPlugin,
+		clientModuleTransformPlugin
+	];
+	const adapterPlugins = await resolved.adapter.vitePlugins?.();
+	if (adapterPlugins?.length) plugins.push(...adapterPlugins);
+	return plugins;
+}
+function watchPagesDirectory(server, resolved, root) {
+	const abs = resolve(root, resolved.pagesDir.slice(1));
+	server.watcher.on("add", (f) => {
+		if (f.startsWith(abs)) server.restart();
+	});
+	server.watcher.on("unlink", (f) => {
+		if (f.startsWith(abs)) server.restart();
+	});
+}
+function invalidateVirtualModules(server) {
+	const clientMod = server.moduleGraph.getModuleById(PRACHT_CLIENT_MODULE_ID);
+	const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
+	if (clientMod) server.moduleGraph.invalidateModule(clientMod);
+	if (serverMod) server.moduleGraph.invalidateModule(serverMod);
+}
+const ROUTE_FILE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".md",
+	".mdx"
+]);
+function computeRouteFileDirs(root, resolved) {
+	return (resolved.pagesDir ? [resolved.pagesDir] : [resolved.routesDir, resolved.shellsDir]).map((dir) => toPosixPath(resolve(root, dir.replace(/^\//, "")))).map(withTrailingSep);
+}
+function isRouteOrShellFile(id, dirs) {
+	if (dirs.length === 0) return false;
+	const queryStart = id.indexOf("?");
+	const path = queryStart === -1 ? id : id.slice(0, queryStart);
+	if (path.startsWith("\0") || path.startsWith("virtual:")) return false;
+	const extIndex = path.lastIndexOf(".");
+	if (extIndex === -1) return false;
+	const ext = path.slice(extIndex);
+	if (!ROUTE_FILE_EXTENSIONS.has(ext)) return false;
+	const normalized = toPosixPath(path);
+	return dirs.some((dir) => normalized.startsWith(dir));
+}
+function toPosixPath(p) {
+	return p.replace(/\\/g, "/");
+}
+function withTrailingSep(p) {
+	return p.endsWith("/") ? p : `${p}/`;
 }
 //#endregion
 export { PRACHT_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, createPrachtClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, pracht };