@pracht/vite-plugin 0.2.3 → 0.2.4

package/README.md

@@ -29,7 +29,7 @@ export default defineConfig({
 
 ## Peer Dependencies
 
-- `vite@^7.0.0 || ^8.0.0`
+- `vite@^8.0.0`
 
 Target-specific Vite plugins (e.g. `@cloudflare/vite-plugin`) are pulled in by
 the adapter package you install (`@pracht/adapter-cloudflare`,

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { Plugin } from "vite";
+import { RenderMode } from "@pracht/core";
 
 //#region src/index.d.ts
 declare const PRACHT_CLIENT_MODULE_ID = "virtual:pracht/client";
@@ -36,7 +37,6 @@ interface PrachtAdapter {
    */
   ownsDevServer?: boolean;
 }
-type RenderMode = "spa" | "ssr" | "ssg" | "isg";
 interface PrachtPluginOptions {
   appFile?: string;
   routesDir?: string;
@@ -60,4 +60,4 @@ declare function createPrachtServerModuleSource(options?: PrachtPluginOptions, b
 }): string;
 declare function createPrachtRegistryModuleSource(options?: PrachtPluginOptions): string;
 //#endregion
-export { PRACHT_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, PrachtAdapter, PrachtPluginOptions, RenderMode, createPrachtClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, pracht };
+export { PRACHT_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, PrachtAdapter, PrachtPluginOptions, type RenderMode, createPrachtClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, pracht };

package/dist/index.mjs

@@ -1,7 +1,909 @@
 import { generatePagesManifestSource, scanPagesDirectory } from "./pages-router.mjs";
+import preact from "@preact/preset-vite";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import preact from "@preact/preset-vite";
+import { parseAst } from "vite";
+//#region src/client-module-scope-analysis.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"
+]);
+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;
+}
+function createScope(type, parent, node) {
+	return {
+		bindings: /* @__PURE__ */ new Map(),
+		node,
+		parent,
+		type
+	};
+}
+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$1(specifier.local);
+			if (localName) declareBinding(programScope, localName, "import", specifier);
+		}
+		return;
+	}
+	const declaration = getStatementDeclaration$1(statement);
+	if (!declaration) return;
+	declareDeclarationBindings(programScope, declaration);
+}
+function declareNodeScopes(node, currentScope, scopesByNode) {
+	if (!node) return;
+	if (node.type.startsWith("TS")) {
+		declareTsRuntimeChildren(node, 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$1(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$1(node.id);
+	if (functionName) declareBinding(scope, functionName, "function", node);
+	for (const param of node.params) for (const name of collectBindingNamesFromPattern$1(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$1(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$1(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$1(declaration.id);
+		if (name) declareBinding(scope, name, "function", declaration);
+		return;
+	}
+	if (declaration.type === "ClassDeclaration") {
+		const name = getIdentifierName$1(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$1(declarator.id)) declareBinding(scope, name, declaration.kind, declarator);
+}
+function declareBinding(scope, name, kind, node) {
+	const binding = {
+		kind,
+		name,
+		node,
+		scope
+	};
+	scope.bindings.set(name, binding);
+	return binding;
+}
+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")) {
+		collectTsRuntimeReferences(node, 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")) {
+		collectTsRuntimeReferences(node, 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;
+}
+function getStatementDeclaration$1(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$1(pattern) {
+	if (!pattern) return [];
+	switch (pattern.type) {
+		case "Identifier": return [pattern.name];
+		case "AssignmentPattern": return collectBindingNamesFromPattern$1(pattern.left);
+		case "RestElement": return collectBindingNamesFromPattern$1(pattern.argument);
+		case "ObjectPattern": return pattern.properties.flatMap((property) => {
+			if (property.type === "Property") return collectBindingNamesFromPattern$1(property.value);
+			return collectBindingNamesFromPattern$1(property.argument);
+		});
+		case "ArrayPattern": return pattern.elements.flatMap((element) => collectBindingNamesFromPattern$1(element));
+		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")) {
+		collectFunctionScopedVarBindingsFromTsNode(node, 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$1(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);
+}
+function declareTsRuntimeChildren(node, currentScope, scopesByNode) {
+	for (const child of getTsRuntimeChildren(node)) declareNodeScopes(child, currentScope, scopesByNode);
+}
+function collectTsRuntimeReferences(node, currentScope, scopesByNode, result, excludedNames) {
+	for (const child of getTsRuntimeChildren(node)) collectNodeReferences(child, currentScope, scopesByNode, result, excludedNames);
+}
+function collectFunctionScopedVarBindingsFromTsNode(node, names) {
+	for (const child of getTsRuntimeChildren(node)) collectFunctionScopedVarBindingsInto(child, names);
+}
+function getTsRuntimeChildren(node) {
+	switch (node.type) {
+		case "TSAsExpression":
+		case "TSInstantiationExpression":
+		case "TSNonNullExpression":
+		case "TSSatisfiesExpression":
+		case "TSTypeAssertion": return [node.expression];
+		default: return [];
+	}
+}
+function getIdentifierName$1(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;
+}
+//#endregion
+//#region src/client-module-transform.ts
+const CLIENT_MODULE_QUERY = "pracht-client";
+const SERVER_ONLY_EXPORTS = new Set([
+	"loader",
+	"head",
+	"headers",
+	"getStaticPaths"
+]);
+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 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 createStatementStates(program) {
+	return program.body.map((node) => ({
+		node,
+		removed: false,
+		removedDeclarators: /* @__PURE__ */ new Set(),
+		removedSpecifiers: /* @__PURE__ */ new Set()
+	}));
+}
+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 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(", ")};`;
+}
+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 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 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 };
+}
+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 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 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 enqueueDependencies(target, dependencies) {
+	for (const name of dependencies) target.add(name);
+}
+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 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/index.ts
 const PRACHT_CLIENT_MODULE_ID = "virtual:pracht/client";
 const PRACHT_SERVER_MODULE_ID = "virtual:pracht/server";
@@ -153,7 +1055,24 @@ async function pracht(options = {}) {
 			}
 		}
 	};
-	const plugins = [...preact(), prachtPlugin];
+	const clientModuleTransformPlugin = {
+		name: "pracht:client-module-transform",
+		enforce: "post",
+		transform(code, id) {
+			if (!isPrachtClientModuleId(id)) 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;
@@ -168,16 +1087,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;",
 		"}",
@@ -391,8 +1315,9 @@ function readClientBuildAssets(root = process.cwd()) {
 	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}`);
+		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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pracht/vite-plugin",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "license": "MIT",
   "homepage": "https://github.com/JoviDeCroock/pracht/tree/main/packages/vite-plugin",
   "bugs": {
@@ -31,11 +31,11 @@
   "dependencies": {
     "@preact/preset-vite": "^2.10.5",
     "@prefresh/vite": "^2.0.0",
-    "@pracht/adapter-node": "0.1.7",
-    "@pracht/core": "0.2.6"
+    "@pracht/adapter-node": "0.1.8",
+    "@pracht/core": "0.2.7"
   },
   "peerDependencies": {
-    "vite": "^7.0.0 || ^8.0.0"
+    "vite": "^8.0.0"
   },
   "scripts": {
     "build": "tsdown"