litzjs 0.0.0

package/dist/vite.js

@@ -0,0 +1,1481 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_internal_transport = require("./internal-transport-DR0r68ff.js");
+const require_request_headers = require("./request-headers-ZPR3TQs3.js");
+let _vitejs_plugin_rsc = require("@vitejs/plugin-rsc");
+_vitejs_plugin_rsc = require_chunk.__toESM(_vitejs_plugin_rsc);
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let tinyglobby = require("tinyglobby");
+let typescript = require("typescript");
+typescript = require_chunk.__toESM(typescript);
+//#region src/client-projection.ts
+function createClientModuleProjection(filePath, source) {
+	const scriptKind = filePath.endsWith(".tsx") ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS;
+	const sourceFile = typescript.default.createSourceFile(filePath, source, typescript.default.ScriptTarget.Latest, true, scriptKind);
+	const compilerOptions = {
+		target: typescript.default.ScriptTarget.ESNext,
+		module: typescript.default.ModuleKind.ESNext,
+		jsx: typescript.default.JsxEmit.Preserve,
+		moduleResolution: typescript.default.ModuleResolutionKind.Bundler,
+		allowJs: true
+	};
+	const host = typescript.default.createCompilerHost(compilerOptions, true);
+	const originalGetSourceFile = host.getSourceFile.bind(host);
+	host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+		if (node_path.default.resolve(fileName) === node_path.default.resolve(filePath)) return sourceFile;
+		return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+	};
+	host.readFile = (fileName) => {
+		if (node_path.default.resolve(fileName) === node_path.default.resolve(filePath)) return source;
+		return (0, node_fs.readFileSync)(fileName, "utf8");
+	};
+	host.fileExists = (fileName) => {
+		if (node_path.default.resolve(fileName) === node_path.default.resolve(filePath)) return true;
+		return typescript.default.sys.fileExists(fileName);
+	};
+	const checker = typescript.default.createProgram([filePath], compilerOptions, host).getTypeChecker();
+	const topLevelDeclarations = collectTopLevelDeclarations(sourceFile);
+	const importStatements = sourceFile.statements.filter(typescript.default.isImportDeclaration);
+	const topLevelNames = new Set(topLevelDeclarations.keys());
+	const importBindings = collectImportBindings(importStatements);
+	const rootStatement = findProjectionRootStatement(sourceFile);
+	if (!rootStatement) return null;
+	const requiredStatements = new Set([rootStatement]);
+	const referencedImports = /* @__PURE__ */ new Set();
+	const queue = [rootStatement];
+	while (queue.length > 0) {
+		const statement = queue.pop();
+		if (!statement) continue;
+		const referencedNames = collectReferencedNames(statement, checker, topLevelNames, importBindings, shouldSkipProjectionSubtree);
+		for (const importName of referencedNames.imports) referencedImports.add(importName);
+		for (const declarationName of referencedNames.locals) {
+			const declarationStatement = topLevelDeclarations.get(declarationName);
+			if (!declarationStatement || requiredStatements.has(declarationStatement)) continue;
+			requiredStatements.add(declarationStatement);
+			queue.push(declarationStatement);
+		}
+	}
+	const printedImports = importStatements.map((statement) => projectImportStatement(statement, referencedImports)).filter((statement) => statement !== null);
+	const projectionStatements = sourceFile.statements.filter((statement) => requiredStatements.has(statement));
+	const needsPlaceholder = projectionStatements.some((statement) => projectionNeedsPlaceholder(statement));
+	const transformedStatements = projectionStatements.map((statement) => transformProjectionStatement(statement));
+	const printer = typescript.default.createPrinter({ newLine: typescript.default.NewLineKind.LineFeed });
+	const placeholder = needsPlaceholder ? [typescript.default.factory.createVariableStatement(void 0, typescript.default.factory.createVariableDeclarationList([typescript.default.factory.createVariableDeclaration(typescript.default.factory.createIdentifier("__litz_server_placeholder__"), void 0, void 0, typescript.default.factory.createObjectLiteralExpression())], typescript.default.NodeFlags.Const))] : [];
+	return `${[
+		...printedImports,
+		...placeholder,
+		...transformedStatements
+	].map((statement) => printer.printNode(typescript.default.EmitHint.Unspecified, statement, sourceFile)).join("\n\n")}\n`;
+}
+function findProjectionRootStatement(sourceFile) {
+	for (const statement of sourceFile.statements) {
+		if (!typescript.default.isVariableStatement(statement)) continue;
+		if (!statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword)) continue;
+		const declaration = statement.declarationList.declarations[0];
+		if (!declaration || !typescript.default.isIdentifier(declaration.name) || !declaration.initializer) continue;
+		const exportName = declaration.name.text;
+		if (exportName !== "route" && exportName !== "layout" && exportName !== "resource" && exportName !== "api") continue;
+		return statement;
+	}
+	return null;
+}
+function collectTopLevelDeclarations(sourceFile) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (typescript.default.isFunctionDeclaration(statement) && statement.name) {
+			declarations.set(statement.name.text, statement);
+			continue;
+		}
+		if (typescript.default.isClassDeclaration(statement) && statement.name) {
+			declarations.set(statement.name.text, statement);
+			continue;
+		}
+		if (typescript.default.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (typescript.default.isIdentifier(declaration.name)) declarations.set(declaration.name.text, statement);
+		}
+	}
+	return declarations;
+}
+function collectImportBindings(imports) {
+	const bindings = /* @__PURE__ */ new Set();
+	for (const statement of imports) {
+		if (!statement.importClause) continue;
+		if (statement.importClause.name) bindings.add(statement.importClause.name.text);
+		const namedBindings = statement.importClause.namedBindings;
+		if (!namedBindings) continue;
+		if (typescript.default.isNamespaceImport(namedBindings)) {
+			bindings.add(namedBindings.name.text);
+			continue;
+		}
+		for (const element of namedBindings.elements) bindings.add(element.name.text);
+	}
+	return bindings;
+}
+function collectReferencedNames(statement, checker, topLevelNames, importBindings, shouldSkipSubtree) {
+	const locals = /* @__PURE__ */ new Set();
+	const imports = /* @__PURE__ */ new Set();
+	const sourceFile = statement.getSourceFile();
+	function visit(node) {
+		if (shouldSkipSubtree(node)) return;
+		if (typescript.default.isTypeNode(node)) return;
+		if (typescript.default.isIdentifier(node)) {
+			if (isIgnoredIdentifierReference(node)) return;
+			const declarations = checker.getSymbolAtLocation(node)?.declarations ?? [];
+			const declaration = declarations[0];
+			if (importBindings.has(node.text)) {
+				if (!declaration) {
+					imports.add(node.text);
+					return;
+				}
+				if (isImportBindingDeclaration(declaration)) {
+					imports.add(node.text);
+					return;
+				}
+				if (declarations.every((candidate) => candidate.getSourceFile() !== sourceFile)) {
+					imports.add(node.text);
+					return;
+				}
+			}
+			if (!declaration) return;
+			if (isImportBindingDeclaration(declaration)) {
+				if (importBindings.has(node.text)) imports.add(node.text);
+				return;
+			}
+			if (declaration.getSourceFile() !== statement.getSourceFile()) {
+				if (importBindings.has(node.text)) imports.add(node.text);
+				return;
+			}
+			if (topLevelNames.has(node.text)) locals.add(node.text);
+			return;
+		}
+		typescript.default.forEachChild(node, visit);
+	}
+	visit(statement);
+	return {
+		locals,
+		imports
+	};
+}
+function isIgnoredIdentifierReference(node) {
+	const parent = node.parent;
+	if (typescript.default.isPropertyAccessExpression(parent) && parent.name === node) return true;
+	if (typescript.default.isPropertyAssignment(parent) && parent.name === node) return true;
+	if (typescript.default.isShorthandPropertyAssignment(parent)) return false;
+	if (typescript.default.isImportClause(parent) || typescript.default.isImportSpecifier(parent) || typescript.default.isNamespaceImport(parent)) return true;
+	if (typescript.default.isVariableDeclaration(parent) || typescript.default.isFunctionDeclaration(parent) || typescript.default.isParameter(parent) || typescript.default.isBindingElement(parent) || typescript.default.isClassDeclaration(parent)) return parent.name === node;
+	return false;
+}
+function shouldSkipProjectionSubtree(node) {
+	if (typescript.default.isCallExpression(node) && typescript.default.isIdentifier(node.expression) && node.expression.text === "server") return true;
+	if ((typescript.default.isPropertyAssignment(node) || typescript.default.isMethodDeclaration(node) || typescript.default.isShorthandPropertyAssignment(node)) && isServerOnlyProjectionProperty(node)) return true;
+	return false;
+}
+function projectImportStatement(statement, referencedImports) {
+	if (!statement.importClause) return statement;
+	const defaultImport = statement.importClause.name && referencedImports.has(statement.importClause.name.text) ? statement.importClause.name : void 0;
+	const namedBindings = statement.importClause.namedBindings;
+	let nextNamedBindings;
+	if (namedBindings) if (typescript.default.isNamespaceImport(namedBindings)) {
+		if (referencedImports.has(namedBindings.name.text)) nextNamedBindings = namedBindings;
+	} else {
+		const elements = namedBindings.elements.filter((element) => referencedImports.has(element.name.text));
+		if (elements.length > 0) nextNamedBindings = typescript.default.factory.updateNamedImports(namedBindings, elements);
+	}
+	if (!defaultImport && !nextNamedBindings) return null;
+	return typescript.default.factory.updateImportDeclaration(statement, statement.modifiers, typescript.default.factory.updateImportClause(statement.importClause, statement.importClause.isTypeOnly, defaultImport, nextNamedBindings), statement.moduleSpecifier, statement.attributes);
+}
+function projectionNeedsPlaceholder(statement) {
+	let required = false;
+	function visit(node) {
+		if (required) return;
+		if (typescript.default.isCallExpression(node) && typescript.default.isIdentifier(node.expression) && (node.expression.text === "server" || node.expression.text === "defineApiRoute")) {
+			required = true;
+			return;
+		}
+		typescript.default.forEachChild(node, visit);
+	}
+	visit(statement);
+	return required;
+}
+function transformProjectionStatement(statement) {
+	const result = typescript.default.transform(statement, [(context) => {
+		const visit = (node) => {
+			if (typescript.default.isCallExpression(node) && typescript.default.isIdentifier(node.expression)) {
+				if (node.expression.text === "server") return typescript.default.factory.createIdentifier("__litz_server_placeholder__");
+				if ((node.expression.text === "defineRoute" || node.expression.text === "defineLayout" || node.expression.text === "defineResource") && node.arguments[1] && typescript.default.isObjectLiteralExpression(node.arguments[1])) {
+					const pathArgument = node.arguments[0] ?? typescript.default.factory.createStringLiteral("");
+					const properties = node.arguments[1].properties.map((property) => {
+						if (typescript.default.isShorthandPropertyAssignment(property)) {
+							const name = property.name.text;
+							if (name === "loader" || name === "action") return typescript.default.factory.createPropertyAssignment(property.name, typescript.default.factory.createIdentifier("__litz_server_placeholder__"));
+							if (name === "middleware") return typescript.default.factory.createPropertyAssignment(property.name, typescript.default.factory.createArrayLiteralExpression());
+							return property;
+						}
+						if (!typescript.default.isPropertyAssignment(property)) return property;
+						const name = getObjectPropertyName(property.name);
+						if (name === "loader" || name === "action") return typescript.default.factory.updatePropertyAssignment(property, property.name, typescript.default.factory.createIdentifier("__litz_server_placeholder__"));
+						if (name === "middleware") return typescript.default.factory.updatePropertyAssignment(property, property.name, typescript.default.factory.createArrayLiteralExpression());
+						return typescript.default.visitEachChild(property, visit, context);
+					});
+					return typescript.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [pathArgument, typescript.default.factory.updateObjectLiteralExpression(node.arguments[1], properties)]);
+				}
+				if (node.expression.text === "defineApiRoute" && node.arguments[1] && typescript.default.isObjectLiteralExpression(node.arguments[1])) {
+					const pathArgument = node.arguments[0] ?? typescript.default.factory.createStringLiteral("");
+					const properties = node.arguments[1].properties.map((property) => {
+						if (typescript.default.isPropertyAssignment(property)) return typescript.default.factory.updatePropertyAssignment(property, property.name, typescript.default.factory.createIdentifier("__litz_server_placeholder__"));
+						if (typescript.default.isMethodDeclaration(property)) return typescript.default.factory.createPropertyAssignment(property.name, typescript.default.factory.createIdentifier("__litz_server_placeholder__"));
+						if (typescript.default.isShorthandPropertyAssignment(property)) return typescript.default.factory.createPropertyAssignment(property.name, typescript.default.factory.createIdentifier("__litz_server_placeholder__"));
+						return property;
+					});
+					return typescript.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [pathArgument, typescript.default.factory.updateObjectLiteralExpression(node.arguments[1], properties)]);
+				}
+			}
+			return typescript.default.visitEachChild(node, visit, context);
+		};
+		return (node) => typescript.default.visitNode(node, visit);
+	}]);
+	const [transformed] = result.transformed;
+	result.dispose();
+	return transformed ?? statement;
+}
+function getObjectPropertyName(name) {
+	if (typescript.default.isIdentifier(name) || typescript.default.isStringLiteral(name) || typescript.default.isNumericLiteral(name)) return name.text;
+	return null;
+}
+function isImportBindingDeclaration(declaration) {
+	return typescript.default.isImportClause(declaration) || typescript.default.isImportSpecifier(declaration) || typescript.default.isNamespaceImport(declaration) || typescript.default.isImportEqualsDeclaration(declaration);
+}
+function isServerOnlyProjectionProperty(node) {
+	const parent = node.parent;
+	if (!typescript.default.isObjectLiteralExpression(parent)) return false;
+	const call = parent.parent;
+	if (!typescript.default.isCallExpression(call) || !typescript.default.isIdentifier(call.expression)) return false;
+	const propertyName = typescript.default.isShorthandPropertyAssignment(node) ? node.name.text : getObjectPropertyName(node.name);
+	if (!propertyName) return false;
+	if (call.expression.text === "defineRoute" || call.expression.text === "defineLayout" || call.expression.text === "defineResource") return propertyName === "loader" || propertyName === "action" || propertyName === "middleware";
+	if (call.expression.text === "defineApiRoute") return true;
+	return false;
+}
+//#endregion
+//#region src/vite.ts
+const ROUTE_MANIFEST_ID = "virtual:litzjs:route-manifest";
+const RESOLVED_ROUTE_MANIFEST_ID = "\0virtual:litzjs:route-manifest";
+const RESOURCE_MANIFEST_ID = "virtual:litzjs:resource-manifest";
+const RESOLVED_RESOURCE_MANIFEST_ID = "\0virtual:litzjs:resource-manifest";
+const SERVER_MANIFEST_ID = "virtual:litzjs:server-manifest";
+const RESOLVED_SERVER_MANIFEST_ID = "\0virtual:litzjs:server-manifest";
+const LITZ_RSC_ENTRY_ID = "virtual:litzjs:rsc-entry";
+const RESOLVED_LITZ_RSC_ENTRY_ID = "\0virtual:litzjs:rsc-entry";
+const LITZ_BROWSER_ENTRY_ID = "virtual:litzjs:browser-entry";
+const RESOLVED_LITZ_BROWSER_ENTRY_ID = "\0virtual:litzjs:browser-entry";
+const LITZ_RSC_RENDERER_ID = "virtual:litzjs:rsc-renderer";
+const RESOLVED_LITZ_RSC_RENDERER_ID = "\0virtual:litzjs:rsc-renderer";
+function litz(options = {}) {
+	let root = process.cwd();
+	let browserEntryPath = "src/main.tsx";
+	let serverEntryPath = null;
+	let serverEntryFilePath = null;
+	let outputRootDir = node_path.default.resolve(root, "dist");
+	let clientOutDir = node_path.default.resolve(root, "dist/client");
+	let serverOutDir = node_path.default.resolve(root, "dist/server");
+	let serverRscOutDir = node_path.default.resolve(root, "dist/server/_rsc");
+	let routeManifest = [];
+	let layoutManifest = [];
+	let resourceManifest = [];
+	let apiManifest = [];
+	let clientProjectedFiles = /* @__PURE__ */ new Set();
+	let hasFinalizedServerArtifacts = false;
+	let hasRegisteredExitFinalizer = false;
+	const routePatterns = options.routes ?? [
+		"src/routes/**/*.{ts,tsx}",
+		"!src/routes/api/**/*.{ts,tsx}",
+		"!src/routes/resources/**/*.{ts,tsx}"
+	];
+	const resourcePatterns = options.resources ?? ["src/routes/resources/**/*.{ts,tsx}"];
+	const apiPatterns = options.api ?? ["src/routes/api/**/*.{ts,tsx}"];
+	const rscPlugins = (0, _vitejs_plugin_rsc.default)({
+		entries: {
+			client: LITZ_BROWSER_ENTRY_ID,
+			rsc: LITZ_RSC_ENTRY_ID
+		},
+		serverHandler: false
+	});
+	const litzPlugin = {
+		name: "litzjs/vite",
+		config(userConfig) {
+			const baseOutDir = userConfig.build?.outDir ?? "dist";
+			return { environments: {
+				client: { build: {
+					outDir: node_path.default.join(baseOutDir, "client"),
+					manifest: true
+				} },
+				rsc: { build: { outDir: node_path.default.join(baseOutDir, "server", "_rsc") } },
+				ssr: { build: { outDir: node_path.default.join(baseOutDir, "server", "_ssr") } }
+			} };
+		},
+		async configResolved(config) {
+			root = config.root;
+			outputRootDir = node_path.default.resolve(root, config.build.outDir || "dist");
+			clientOutDir = node_path.default.resolve(root, config.environments.client?.build.outDir || node_path.default.join("dist", "client"));
+			serverOutDir = node_path.default.resolve(root, node_path.default.join(config.build.outDir || "dist", "server"));
+			serverRscOutDir = node_path.default.resolve(root, config.environments.rsc?.build.outDir || node_path.default.join("dist", "server", "_rsc"));
+			browserEntryPath = await discoverBrowserEntry(root);
+			serverEntryPath = await discoverServerEntry(root, options.server);
+			serverEntryFilePath = serverEntryPath ? node_path.default.resolve(root, serverEntryPath) : null;
+			({routeManifest, layoutManifest, resourceManifest, apiManifest} = await discoverAllManifests(root, routePatterns, resourcePatterns, apiPatterns));
+			clientProjectedFiles = createClientProjectedFileSet(root, routeManifest, layoutManifest, resourceManifest, apiManifest);
+		},
+		resolveId(id) {
+			if (id === ROUTE_MANIFEST_ID) return RESOLVED_ROUTE_MANIFEST_ID;
+			if (id === RESOURCE_MANIFEST_ID) return RESOLVED_RESOURCE_MANIFEST_ID;
+			if (id === SERVER_MANIFEST_ID) return RESOLVED_SERVER_MANIFEST_ID;
+			if (id === LITZ_RSC_ENTRY_ID) return RESOLVED_LITZ_RSC_ENTRY_ID;
+			if (id === LITZ_BROWSER_ENTRY_ID) return RESOLVED_LITZ_BROWSER_ENTRY_ID;
+			if (id === LITZ_RSC_RENDERER_ID) return RESOLVED_LITZ_RSC_RENDERER_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_ROUTE_MANIFEST_ID) return createRouteManifestModule(routeManifest, root, this.environment.name === "client");
+			if (id === RESOLVED_RESOURCE_MANIFEST_ID) return createResourceManifestModule(resourceManifest);
+			if (id === RESOLVED_SERVER_MANIFEST_ID) return createServerManifestModule(routeManifest, resourceManifest, apiManifest);
+			if (id === RESOLVED_LITZ_RSC_ENTRY_ID) {
+				if (serverEntryPath) return `export { default } from ${JSON.stringify(toProjectImportSpecifier(serverEntryPath))};`;
+				return `
+import { createServer } from "litzjs/server";
+import { serverManifest } from ${JSON.stringify(SERVER_MANIFEST_ID)};
+
+export default createServer({
+  manifest: serverManifest,
+  createContext() {
+    return undefined;
+  },
+});
+`;
+			}
+			if (id === RESOLVED_LITZ_BROWSER_ENTRY_ID) return `import ${JSON.stringify(toImportSpecifier(root, browserEntryPath))};`;
+			if (id === RESOLVED_LITZ_RSC_RENDERER_ID) return `
+import { renderToReadableStream } from "@vitejs/plugin-rsc/rsc";
+
+export async function renderView(node, metadata = {}) {
+  const stream = renderToReadableStream(node);
+  return new Response(stream, {
+    status: metadata.status ?? 200,
+    headers: {
+      "content-type": "text/x-component",
+      "x-litzjs-kind": "view",
+      "x-litzjs-status": String(metadata.status ?? 200),
+      "x-litzjs-view-id": metadata.viewId ?? "litzjs#view",
+      "x-litzjs-revalidate": Array.isArray(metadata.revalidate) ? metadata.revalidate.join(",") : ""
+    }
+  });
+}
+`;
+			return null;
+		},
+		configureServer(server) {
+			const refreshManifests = async (changedFile) => {
+				if (changedFile && !/\.(ts|tsx)$/.test(changedFile)) return;
+				const next = await discoverAllManifests(root, routePatterns, resourcePatterns, apiPatterns);
+				const changed = JSON.stringify(routeManifest) !== JSON.stringify(next.routeManifest) || JSON.stringify(layoutManifest) !== JSON.stringify(next.layoutManifest) || JSON.stringify(resourceManifest) !== JSON.stringify(next.resourceManifest) || JSON.stringify(apiManifest) !== JSON.stringify(next.apiManifest);
+				routeManifest = next.routeManifest;
+				layoutManifest = next.layoutManifest;
+				resourceManifest = next.resourceManifest;
+				apiManifest = next.apiManifest;
+				clientProjectedFiles = createClientProjectedFileSet(root, routeManifest, layoutManifest, resourceManifest, apiManifest);
+				if (!changed) return;
+				invalidateVirtualModule(server, RESOLVED_ROUTE_MANIFEST_ID);
+				invalidateVirtualModule(server, RESOLVED_RESOURCE_MANIFEST_ID);
+				server.ws.send({ type: "full-reload" });
+			};
+			const onFsChange = (file) => {
+				refreshManifests(file);
+			};
+			server.watcher.on("add", onFsChange);
+			server.watcher.on("change", onFsChange);
+			server.watcher.on("unlink", onFsChange);
+			server.middlewares.use((request, response, next) => {
+				handleLitzResourceRequest(server, resourceManifest, request, response, next);
+			});
+			server.middlewares.use((request, response, next) => {
+				handleLitzRouteRequest(server, routeManifest, request, response, next);
+			});
+			server.middlewares.use((request, response, next) => {
+				handleLitzApiRequest(server, apiManifest, request, response, next);
+			});
+			server.middlewares.use((request, response, next) => {
+				handleLitzDocumentRequest(server, request, response, next);
+			});
+		},
+		async handleHotUpdate(context) {
+			if (!/\.(ts|tsx)$/.test(context.file)) return;
+			return context.modules;
+		},
+		async transform(code, id) {
+			const cleanId = normalizeViteModuleId(id);
+			if (this.environment.name === "rsc" && serverEntryFilePath && cleanId === serverEntryFilePath) {
+				const transformed = injectServerManifestIntoServerEntry(cleanId, code);
+				if (!transformed) return null;
+				return {
+					code: transformed,
+					map: null
+				};
+			}
+			if (this.environment.name !== "client") return null;
+			if (!clientProjectedFiles.has(cleanId)) return null;
+			const projected = createClientModuleProjection(cleanId, code);
+			if (!projected) return null;
+			return {
+				code: projected,
+				map: null
+			};
+		},
+		async closeBundle() {
+			await Promise.all([writeProductionIndexHtml(root, clientOutDir), removeLegacyBuildArtifacts(outputRootDir)]);
+			if (hasFinalizedServerArtifacts) return;
+			if (!hasRegisteredExitFinalizer) {
+				hasRegisteredExitFinalizer = true;
+				process.once("exit", () => {
+					if (hasFinalizedServerArtifacts) return;
+					hasFinalizedServerArtifacts = finalizeServerArtifacts(serverOutDir, serverRscOutDir, clientOutDir, !serverEntryPath);
+				});
+			}
+			hasFinalizedServerArtifacts = finalizeServerArtifacts(serverOutDir, serverRscOutDir, clientOutDir, !serverEntryPath);
+		}
+	};
+	return [...rscPlugins, litzPlugin];
+}
+async function discoverAllManifests(root, routePatterns, resourcePatterns, apiPatterns) {
+	const [nextRouteManifest, nextLayoutManifest, nextResourceManifest, nextApiManifest] = await Promise.all([
+		discoverRoutes(root, routePatterns),
+		discoverLayouts(root, routePatterns),
+		discoverResources(root, resourcePatterns),
+		discoverApiRoutes(root, apiPatterns)
+	]);
+	return {
+		routeManifest: require_internal_transport.sortByPathSpecificity(nextRouteManifest),
+		layoutManifest: nextLayoutManifest,
+		resourceManifest: nextResourceManifest,
+		apiManifest: require_internal_transport.sortByPathSpecificity(nextApiManifest)
+	};
+}
+async function discoverBrowserEntry(root) {
+	const indexHtmlPath = node_path.default.join(root, "index.html");
+	try {
+		const scriptSrc = (await (0, node_fs_promises.readFile)(indexHtmlPath, "utf8")).match(/<script[^>]+type=["']module["'][^>]+src=["']([^"']+)["'][^>]*><\/script>/i)?.[1];
+		if (!scriptSrc) return "src/main.tsx";
+		return scriptSrc.startsWith("/") ? scriptSrc.slice(1) : scriptSrc;
+	} catch {
+		return "src/main.tsx";
+	}
+}
+async function discoverServerEntry(root, configuredPath) {
+	const candidates = configuredPath ? [configuredPath] : ["src/server.ts", "src/server/index.ts"];
+	for (const candidate of candidates) {
+		const absolutePath = node_path.default.resolve(root, candidate);
+		if (typescript.default.sys.fileExists(absolutePath)) return normalizeRelativePath(root, absolutePath);
+	}
+	return null;
+}
+async function discoverRoutes(root, patterns) {
+	const files = await (0, tinyglobby.glob)(patterns, {
+		cwd: root,
+		absolute: true
+	});
+	return (await Promise.all(files.map(async (file) => discoverRouteFromFile(root, file)))).filter((entry) => entry !== null);
+}
+async function discoverLayouts(root, patterns) {
+	const files = await (0, tinyglobby.glob)(patterns, {
+		cwd: root,
+		absolute: true
+	});
+	return (await Promise.all(files.map(async (file) => discoverLayoutFromFile(root, file)))).filter((entry) => entry !== null);
+}
+async function discoverRouteFromFile(root, file) {
+	const match = (await (0, node_fs_promises.readFile)(file, "utf8")).match(/export\s+const\s+route\s*=\s*defineRoute(?:<[\s\S]*?>)?\(\s*["'`]([^"'`]+)["'`]/);
+	if (!match) return null;
+	const routePath = match[1];
+	if (!routePath) return null;
+	return {
+		id: routePath,
+		path: routePath,
+		modulePath: normalizeRelativePath(root, file)
+	};
+}
+async function discoverLayoutFromFile(root, file) {
+	const match = (await (0, node_fs_promises.readFile)(file, "utf8")).match(/export\s+const\s+layout\s*=\s*defineLayout(?:<[\s\S]*?>)?\(\s*["'`]([^"'`]+)["'`]/);
+	if (!match) return null;
+	const layoutPath = match[1];
+	if (!layoutPath) return null;
+	return {
+		id: layoutPath,
+		path: layoutPath,
+		modulePath: normalizeRelativePath(root, file)
+	};
+}
+async function discoverResources(root, patterns) {
+	const files = await (0, tinyglobby.glob)(patterns, {
+		cwd: root,
+		absolute: true
+	});
+	return (await Promise.all(files.map(async (file) => discoverResourceFromFile(root, file)))).filter((entry) => entry !== null);
+}
+async function discoverResourceFromFile(root, file) {
+	const source = await (0, node_fs_promises.readFile)(file, "utf8");
+	const pathMatch = source.match(/export\s+const\s+resource\s*=\s*defineResource(?:<[\s\S]*?>)?\(\s*["'`]([^"'`]+)["'`]/);
+	if (!pathMatch) return null;
+	const resourcePath = pathMatch[1];
+	if (!resourcePath) return null;
+	return {
+		path: resourcePath,
+		modulePath: normalizeRelativePath(root, file),
+		hasLoader: /\bloader\s*:/.test(source),
+		hasAction: /\baction\s*:/.test(source),
+		hasComponent: /\bcomponent\s*:/.test(source)
+	};
+}
+async function discoverApiRoutes(root, patterns) {
+	const files = await (0, tinyglobby.glob)(patterns, {
+		cwd: root,
+		absolute: true
+	});
+	return (await Promise.all(files.map(async (file) => discoverApiRouteFromFile(root, file)))).filter((entry) => entry !== null);
+}
+async function discoverApiRouteFromFile(root, file) {
+	const match = (await (0, node_fs_promises.readFile)(file, "utf8")).match(/export\s+const\s+api\s*=\s*defineApiRoute(?:<[\s\S]*?>)?\(\s*["'`]([^"'`]+)["'`]/);
+	if (!match) return null;
+	const apiPath = match[1];
+	if (!apiPath) return null;
+	return {
+		path: apiPath,
+		modulePath: normalizeRelativePath(root, file)
+	};
+}
+function createRouteManifestModule(manifest, root, lazy) {
+	if (!lazy) {
+		const imports = [];
+		const lines = manifest.map((route, index) => {
+			const importName = `routeModule${index}`;
+			imports.push(`import * as ${importName} from ${JSON.stringify(toProjectImportSpecifier(route.modulePath))};`);
+			return [
+				`  {`,
+				`    id: ${JSON.stringify(route.id)},`,
+				`    path: ${JSON.stringify(route.path)},`,
+				`    load: async () => ({ route: ${importName}.route })`,
+				`  }${index === manifest.length - 1 ? "" : ","}`
+			].join("\n");
+		});
+		return [
+			...imports,
+			"",
+			`export const routeManifest = [`,
+			lines.join("\n"),
+			`];`
+		].join("\n");
+	}
+	return [
+		`export const routeManifest = [`,
+		manifest.map((route, index) => {
+			const importPath = toImportSpecifier(root, route.modulePath);
+			return [
+				`  {`,
+				`    id: ${JSON.stringify(route.id)},`,
+				`    path: ${JSON.stringify(route.path)},`,
+				`    load: () => import(${JSON.stringify(importPath)})`,
+				`  }${index === manifest.length - 1 ? "" : ","}`
+			].join("\n");
+		}).join("\n"),
+		`];`
+	].join("\n");
+}
+function createClientProjectedFileSet(root, routes, layouts, resources, apiRoutes) {
+	return new Set([
+		...routes,
+		...layouts,
+		...resources,
+		...apiRoutes
+	].map((entry) => node_path.default.resolve(root, entry.modulePath)));
+}
+function injectServerManifestIntoServerEntry(filePath, source) {
+	const scriptKind = filePath.endsWith(".tsx") ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS;
+	const sourceFile = typescript.default.createSourceFile(filePath, source, typescript.default.ScriptTarget.Latest, true, scriptKind);
+	const createServerImportNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!typescript.default.isImportDeclaration(statement) || !typescript.default.isStringLiteral(statement.moduleSpecifier)) continue;
+		if (statement.moduleSpecifier.text !== "litzjs/server") continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (!namedBindings || !typescript.default.isNamedImports(namedBindings)) continue;
+		for (const element of namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "createServer") createServerImportNames.add(element.name.text);
+	}
+	if (createServerImportNames.size === 0) return null;
+	const result = typescript.default.transform(sourceFile, [(context) => {
+		const visit = (node) => {
+			if (typescript.default.isCallExpression(node) && typescript.default.isIdentifier(node.expression) && createServerImportNames.has(node.expression.text)) return typescript.default.factory.updateCallExpression(node, node.expression, node.typeArguments, [typescript.default.factory.createCallExpression(typescript.default.factory.createIdentifier("__litzjsMergeServerOptions"), void 0, [node.arguments[0] ?? typescript.default.factory.createIdentifier("undefined")])]);
+			return typescript.default.visitEachChild(node, visit, context);
+		};
+		return (node) => typescript.default.visitEachChild(node, visit, context);
+	}]);
+	const transformedSource = result.transformed[0];
+	result.dispose();
+	const importStatement = typescript.default.factory.createImportDeclaration(void 0, typescript.default.factory.createImportClause(false, void 0, typescript.default.factory.createNamedImports([typescript.default.factory.createImportSpecifier(false, typescript.default.factory.createIdentifier("serverManifest"), typescript.default.factory.createIdentifier("__litzjsServerManifest"))])), typescript.default.factory.createStringLiteral(SERVER_MANIFEST_ID), void 0);
+	const helperStatement = typescript.default.factory.createVariableStatement(void 0, typescript.default.factory.createVariableDeclarationList([typescript.default.factory.createVariableDeclaration(typescript.default.factory.createIdentifier("__litzjsMergeServerOptions"), void 0, void 0, typescript.default.factory.createArrowFunction(void 0, void 0, [typescript.default.factory.createParameterDeclaration(void 0, void 0, typescript.default.factory.createIdentifier("options"))], void 0, typescript.default.factory.createToken(typescript.default.SyntaxKind.EqualsGreaterThanToken), typescript.default.factory.createParenthesizedExpression(typescript.default.factory.createObjectLiteralExpression([typescript.default.factory.createPropertyAssignment(typescript.default.factory.createIdentifier("manifest"), typescript.default.factory.createIdentifier("__litzjsServerManifest")), typescript.default.factory.createSpreadAssignment(typescript.default.factory.createBinaryExpression(typescript.default.factory.createIdentifier("options"), typescript.default.factory.createToken(typescript.default.SyntaxKind.QuestionQuestionToken), typescript.default.factory.createObjectLiteralExpression()))], true))))], typescript.default.NodeFlags.Const));
+	const printer = typescript.default.createPrinter({ newLine: typescript.default.NewLineKind.LineFeed });
+	return [
+		printer.printNode(typescript.default.EmitHint.Unspecified, importStatement, transformedSource),
+		printer.printNode(typescript.default.EmitHint.Unspecified, helperStatement, transformedSource),
+		...transformedSource.statements.map((statement) => printer.printNode(typescript.default.EmitHint.Unspecified, statement, transformedSource)),
+		""
+	].join("\n\n");
+}
+function normalizeViteModuleId(id) {
+	return node_path.default.resolve(id.replace(/[?#].*$/, ""));
+}
+function createResourceManifestModule(manifest) {
+	return `export const resourceManifest = ${JSON.stringify(manifest, null, 2)};`;
+}
+function createServerManifestModule(routes, resources, apiRoutes) {
+	const imports = [];
+	const routeEntries = routes.map((entry, index) => {
+		const name = `routeModule${index}`;
+		imports.push(`import * as ${name} from ${JSON.stringify(toProjectImportSpecifier(entry.modulePath))};`);
+		return `{ id: ${JSON.stringify(entry.id)}, path: ${JSON.stringify(entry.path)}, route: ${name}.route }`;
+	});
+	const resourceEntries = resources.map((entry, index) => {
+		const name = `resourceModule${index}`;
+		imports.push(`import * as ${name} from ${JSON.stringify(toProjectImportSpecifier(entry.modulePath))};`);
+		return `{ path: ${JSON.stringify(entry.path)}, resource: ${name}.resource }`;
+	});
+	const apiEntries = apiRoutes.map((entry, index) => {
+		const name = `apiModule${index}`;
+		imports.push(`import * as ${name} from ${JSON.stringify(toProjectImportSpecifier(entry.modulePath))};`);
+		return `{ path: ${JSON.stringify(entry.path)}, api: ${name}.api }`;
+	});
+	return [
+		...imports,
+		"",
+		"export const serverManifest = {",
+		`  routes: [${routeEntries.join(", ")}],`,
+		`  resources: [${resourceEntries.join(", ")}],`,
+		`  apiRoutes: [${apiEntries.join(", ")}],`,
+		"};"
+	].join("\n");
+}
+function invalidateVirtualModule(server, id) {
+	const module = server.moduleGraph.getModuleById(id);
+	if (module) server.moduleGraph.invalidateModule(module);
+}
+function normalizeRelativePath(root, file) {
+	return node_path.default.relative(root, file).split(node_path.default.sep).join("/");
+}
+function toImportSpecifier(root, relativeModulePath) {
+	return `/@fs/${node_path.default.resolve(root, relativeModulePath).split(node_path.default.sep).join("/")}`;
+}
+function toProjectImportSpecifier(relativeModulePath) {
+	return `/${relativeModulePath}`;
+}
+async function handleLitzResourceRequest(server, manifest, request, response, next) {
+	if (!request.url?.startsWith("/_litzjs/resource")) {
+		next();
+		return;
+	}
+	if (request.method !== "POST") {
+		response.statusCode = 405;
+		response.end("Method Not Allowed");
+		return;
+	}
+	try {
+		const internalRequest = await createNodeRequest(request);
+		const body = await require_request_headers.parseInternalRequestBody(internalRequest);
+		const resourcePath = body.path;
+		const operation = body.operation ?? "loader";
+		const entry = manifest.find((resource) => resource.path === resourcePath);
+		if (!resourcePath || !entry) {
+			sendLitzJson(response, 404, {
+				kind: "error",
+				message: "Resource not found."
+			});
+			return;
+		}
+		const resource = (await loadLitzServerModule(server, toImportSpecifier(server.config.root, entry.modulePath))).resource;
+		if (!resource) {
+			sendLitzJson(response, 500, {
+				kind: "fault",
+				message: "Resource module did not export resource."
+			});
+			return;
+		}
+		const handler = operation === "action" ? resource.action : resource.loader;
+		if (!handler) {
+			sendLitzJson(response, 405, {
+				kind: "error",
+				message: `Resource does not define a ${operation}.`
+			});
+			return;
+		}
+		const normalizedRequest = normalizeInternalResourceRequest(internalRequest, resourcePath, body.request, body.payload);
+		const signal = new AbortController().signal;
+		await sendServerResult(server, response, await runDevMiddlewareChain({
+			middleware: resource.middleware ?? [],
+			request: normalizedRequest.request,
+			params: normalizedRequest.params,
+			signal,
+			context: void 0,
+			execute(nextContext) {
+				return handler({
+					request: normalizedRequest.request,
+					params: normalizedRequest.params,
+					signal,
+					context: nextContext
+				});
+			}
+		}), `${entry.path}#${operation}`);
+	} catch (error) {
+		server.ssrFixStacktrace(error);
+		sendLitzJson(response, 500, {
+			kind: "fault",
+			message: error instanceof Error ? error.message : "Resource request failed."
+		});
+	}
+}
+async function handleLitzRouteRequest(server, manifest, request, response, next) {
+	if (!request.url?.startsWith("/_litzjs/route") && !request.url?.startsWith("/_litzjs/action")) {
+		next();
+		return;
+	}
+	if (request.method !== "POST") {
+		response.statusCode = 405;
+		response.end("Method Not Allowed");
+		return;
+	}
+	try {
+		const internalRequest = await createNodeRequest(request);
+		const body = await require_request_headers.parseInternalRequestBody(internalRequest);
+		const routePath = body.path;
+		const targetId = body.target;
+		const operation = body.operation ?? (request.url.startsWith("/_litzjs/action") ? "action" : "loader");
+		const entry = manifest.find((route) => route.path === routePath);
+		if (!routePath || !entry) {
+			sendLitzJson(response, 404, {
+				kind: "error",
+				message: "Route not found."
+			});
+			return;
+		}
+		const route = (await loadLitzServerModule(server, toImportSpecifier(server.config.root, entry.modulePath))).route;
+		if (!route) {
+			sendLitzJson(response, 500, {
+				kind: "fault",
+				message: "Route module did not export route."
+			});
+			return;
+		}
+		const chain = getDevRouteMatchChain({
+			id: entry.id,
+			path: entry.path,
+			route
+		});
+		const target = operation === "action" ? chain[chain.length - 1] : findDevTargetRouteMatch(chain, targetId ?? routePath);
+		if (!target) {
+			sendLitzJson(response, 404, {
+				kind: "error",
+				message: "Route target not found."
+			});
+			return;
+		}
+		const targetIndex = chain.findIndex((candidate) => candidate.id === target.id);
+		const handler = operation === "action" ? route.action ?? route.options?.action : target.loader;
+		if (!handler) {
+			sendLitzJson(response, 405, {
+				kind: "error",
+				message: `Route does not define a ${operation}.`
+			});
+			return;
+		}
+		const normalizedRequest = normalizeInternalResourceRequest(internalRequest, routePath, body.request, body.payload);
+		const signal = new AbortController().signal;
+		await sendServerResult(server, response, await runDevMiddlewareChain({
+			middleware: chain.slice(0, targetIndex + 1).flatMap((candidate) => candidate.middleware),
+			request: normalizedRequest.request,
+			params: operation === "action" ? normalizedRequest.params : require_internal_transport.extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params,
+			signal,
+			context: void 0,
+			execute(nextContext) {
+				const params = operation === "action" ? normalizedRequest.params : require_internal_transport.extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params;
+				return handler({
+					request: normalizedRequest.request,
+					params,
+					signal,
+					context: nextContext
+				});
+			}
+		}), `${target.id}#${operation}`);
+	} catch (error) {
+		server.ssrFixStacktrace(error);
+		sendLitzJson(response, 500, {
+			kind: "fault",
+			message: error instanceof Error ? error.message : "Route request failed."
+		});
+	}
+}
+async function handleLitzDocumentRequest(server, request, response, next) {
+	const url = request.url ?? "/";
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		next();
+		return;
+	}
+	if (url.startsWith("/_litzjs/") || url.startsWith("/@") || url.startsWith("/node_modules/")) {
+		next();
+		return;
+	}
+	if (node_path.default.extname(url)) {
+		next();
+		return;
+	}
+	const accept = request.headers.accept ?? "";
+	if (!accept.includes("text/html") && !accept.includes("*/*")) {
+		next();
+		return;
+	}
+	try {
+		const template = await (0, node_fs_promises.readFile)(node_path.default.join(server.config.root, "index.html"), "utf8");
+		const html = await server.transformIndexHtml(url, template);
+		response.statusCode = 200;
+		response.setHeader("content-type", "text/html; charset=utf-8");
+		response.end(html);
+	} catch (error) {
+		server.ssrFixStacktrace(error);
+		next(error);
+	}
+}
+async function handleLitzApiRequest(server, manifest, request, response, next) {
+	const requestUrl = request.url ? new URL(request.url, "http://litzjs.local") : null;
+	if (!requestUrl) {
+		next();
+		return;
+	}
+	const matched = manifest.find((entry) => matchPathPattern(entry.path, requestUrl.pathname));
+	if (!matched) {
+		next();
+		return;
+	}
+	try {
+		const api = (await server.ssrLoadModule(toImportSpecifier(server.config.root, matched.modulePath))).api;
+		const method = (request.method ?? "GET").toUpperCase();
+		const handler = api?.methods?.[method] ?? api?.methods?.ALL;
+		const matchedParams = require_internal_transport.matchPathname(matched.path, requestUrl.pathname);
+		if (!handler) {
+			response.statusCode = 405;
+			response.end("Method Not Allowed");
+			return;
+		}
+		const apiRequest = await createNodeRequest(request, requestUrl);
+		const signal = new AbortController().signal;
+		await writeFetchResponseToNode(response, await runDevMiddlewareChain({
+			middleware: api?.middleware ?? [],
+			request: apiRequest,
+			params: matchedParams ?? {},
+			signal,
+			context: void 0,
+			execute(nextContext) {
+				return handler({
+					request: apiRequest,
+					params: matchedParams ?? {},
+					signal,
+					context: nextContext
+				});
+			}
+		}));
+	} catch (error) {
+		server.ssrFixStacktrace(error);
+		response.statusCode = 500;
+		response.end(error instanceof Error ? error.message : "API route failed.");
+	}
+}
+async function readRequestBuffer(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+async function createNodeRequest(request, url = createIncomingRequestUrl(request)) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(request.headers)) if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+	else if (typeof value === "string") headers.set(key, value);
+	const body = request.method === "GET" || request.method === "HEAD" ? void 0 : await readRequestBuffer(request);
+	return new Request(url, {
+		method: request.method,
+		headers,
+		body: body ? new Uint8Array(body) : void 0
+	});
+}
+function createIncomingRequestUrl(request) {
+	const host = getForwardedRequestValue(request.headers["x-forwarded-host"]) ?? request.headers.host;
+	const socket = request.socket;
+	const protocol = getForwardedRequestValue(request.headers["x-forwarded-proto"]) ?? (socket.encrypted ? "https" : "http");
+	return new URL(request.url ?? "/", `${protocol}://${host ?? "litzjs.local"}`);
+}
+function getForwardedRequestValue(value) {
+	const raw = Array.isArray(value) ? value[0] : value;
+	if (!raw) return;
+	return raw.split(",").map((entry) => entry.trim()).find(Boolean);
+}
+function normalizeInternalResourceRequest(originalRequest, resourcePath, requestData, payload) {
+	const params = requestData?.params ?? {};
+	const search = new URLSearchParams(requestData?.search ?? {});
+	const url = new URL(originalRequest.url);
+	url.pathname = interpolatePath(resourcePath, params);
+	url.search = search.toString();
+	url.hash = "";
+	let body;
+	if (payload) {
+		body = new FormData();
+		for (const [key, value] of payload.entries) body.append(key, value);
+	}
+	return {
+		request: new Request(url, {
+			method: body ? "POST" : "GET",
+			headers: require_request_headers.createInternalHandlerHeaders(originalRequest.headers),
+			body
+		}),
+		params
+	};
+}
+async function sendServerResult(server, response, result, viewId = "litzjs#view") {
+	if (!result || typeof result !== "object" || !("kind" in result)) {
+		sendLitzJson(response, 500, {
+			kind: "fault",
+			message: "Handler returned an unknown result."
+		});
+		return;
+	}
+	const serverResult = result;
+	applyHeaders(response, serverResult.headers);
+	applyRevalidateHeader(response, serverResult.revalidate);
+	switch (serverResult.kind) {
+		case "data":
+			sendLitzJson(response, serverResult.status ?? 200, {
+				kind: "data",
+				data: serverResult.data,
+				revalidate: serverResult.revalidate ?? []
+			});
+			return;
+		case "invalid":
+			sendLitzJson(response, serverResult.status ?? 422, {
+				kind: "invalid",
+				fields: serverResult.fields,
+				formError: serverResult.formError,
+				data: serverResult.data
+			});
+			return;
+		case "redirect":
+			sendLitzJson(response, serverResult.status ?? 303, {
+				kind: "redirect",
+				location: serverResult.location,
+				replace: serverResult.replace ?? false,
+				revalidate: serverResult.revalidate ?? []
+			});
+			return;
+		case "error":
+			sendLitzJson(response, serverResult.status ?? 500, {
+				kind: "error",
+				message: serverResult.message ?? "Error",
+				code: serverResult.code,
+				data: serverResult.data
+			});
+			return;
+		case "fault":
+			sendLitzJson(response, serverResult.status ?? 500, {
+				kind: "fault",
+				message: serverResult.message ?? "Fault",
+				digest: serverResult.digest
+			});
+			return;
+		case "view":
+			await writeFetchResponseToNode(response, await (await loadRscRenderer(server)).renderView(serverResult.node, {
+				status: serverResult.status ?? 200,
+				viewId,
+				revalidate: serverResult.revalidate ?? []
+			}));
+			return;
+		default: sendLitzJson(response, 500, {
+			kind: "fault",
+			message: `Unsupported result kind "${serverResult.kind}".`
+		});
+	}
+}
+async function loadLitzServerModule(server, id) {
+	const environment = getRscEnvironment(server);
+	const resolved = await environment.pluginContainer.resolveId(id);
+	if (!resolved) throw new Error(`Failed to resolve Litz server module "${id}".`);
+	return environment.runner.import(resolved.id);
+}
+async function loadRscRenderer(server) {
+	return loadLitzServerModule(server, LITZ_RSC_RENDERER_ID);
+}
+function getRscEnvironment(server) {
+	return server.environments.rsc;
+}
+function sendLitzJson(response, status, body) {
+	response.statusCode = status;
+	response.setHeader("content-type", "application/vnd.litzjs.result+json");
+	response.end(JSON.stringify(body));
+}
+function applyHeaders(response, headers) {
+	if (!headers) return;
+	new Headers(headers).forEach((value, key) => {
+		response.setHeader(key, value);
+	});
+}
+function applyRevalidateHeader(response, revalidate) {
+	if (!revalidate?.length) return;
+	response.setHeader("x-litzjs-revalidate", revalidate.join(","));
+}
+async function writeFetchResponseToNode(response, fetchResponse) {
+	response.statusCode = fetchResponse.status;
+	fetchResponse.headers.forEach((value, key) => {
+		response.setHeader(key, value);
+	});
+	if (!fetchResponse.body) {
+		response.end();
+		return;
+	}
+	const reader = fetchResponse.body.getReader();
+	while (true) {
+		const chunk = await reader.read();
+		if (chunk.done) break;
+		response.write(Buffer.from(chunk.value));
+	}
+	response.end();
+}
+function interpolatePath(pathPattern, params) {
+	return pathPattern.replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
+		const value = params[key];
+		if (value === void 0) throw new Error(`Missing required resource param "${key}" for path "${pathPattern}".`);
+		return encodeURIComponent(value);
+	});
+}
+function matchPathPattern(pathPattern, pathname) {
+	return require_internal_transport.matchPathname(pathPattern, pathname) !== null;
+}
+function getDevRouteMatchChain(entry) {
+	return [...collectDevLayouts(entry.route.options?.layout).map((layout) => ({
+		id: layout.id,
+		path: layout.path,
+		loader: layout.options?.loader,
+		middleware: layout.options?.middleware ?? []
+	})), {
+		id: entry.id,
+		path: entry.path,
+		loader: entry.route.loader ?? entry.route.options?.loader,
+		middleware: entry.route.options?.middleware ?? []
+	}];
+}
+function collectDevLayouts(layout) {
+	if (!layout) return [];
+	return [...isDevLayout(layout.options?.layout) ? collectDevLayouts(layout.options?.layout) : [], layout];
+}
+function isDevLayout(value) {
+	return typeof value === "object" && value !== null && "id" in value && "path" in value && typeof value.id === "string" && typeof value.path === "string";
+}
+function findDevTargetRouteMatch(chain, targetId) {
+	return chain.find((entry) => entry.id === targetId);
+}
+async function runDevMiddlewareChain(options) {
+	const dispatch = async (index, context) => {
+		const middleware = options.middleware[index];
+		if (!middleware) return options.execute(context);
+		let called = false;
+		return middleware({
+			request: options.request,
+			params: options.params,
+			signal: options.signal,
+			context
+		}, async (overrides) => {
+			if (called) throw new Error("Litz middleware next() called multiple times.");
+			called = true;
+			const nextContext = overrides && Object.prototype.hasOwnProperty.call(overrides, "context") ? overrides.context : context;
+			return dispatch(index + 1, nextContext);
+		});
+	};
+	return dispatch(0, options.context);
+}
+async function writeProductionIndexHtml(root, clientOutDir) {
+	const sourceHtmlPath = node_path.default.join(root, "index.html");
+	const clientManifestPath = node_path.default.join(clientOutDir, ".vite", "manifest.json");
+	let sourceHtml;
+	let manifest;
+	try {
+		[sourceHtml, manifest] = await Promise.all([(0, node_fs_promises.readFile)(sourceHtmlPath, "utf8"), readJson(clientManifestPath)]);
+	} catch {
+		return;
+	}
+	const entry = Object.values(manifest).find((item) => item.isEntry) ?? Object.values(manifest).find((item) => Boolean(item.file));
+	if (!entry) return;
+	const headTags = (entry.css ?? []).map((cssFile) => `    <link rel="stylesheet" href="/${cssFile}">`).join("\n");
+	const scriptTag = `    <script type="module" src="/${entry.file}"><\/script>`;
+	let html = sourceHtml.replace(/<script[^>]+type=["']module["'][^>]+src=["'][^"']+["'][^>]*><\/script>\s*/gi, "");
+	if (headTags) html = html.replace("</head>", `${headTags}\n  </head>`);
+	html = html.replace("</body>", `${scriptTag}\n  </body>`);
+	await (0, node_fs_promises.mkdir)(clientOutDir, { recursive: true });
+	await (0, node_fs_promises.writeFile)(node_path.default.join(clientOutDir, "index.html"), html, "utf8");
+}
+async function readJson(filePath) {
+	return JSON.parse(await (0, node_fs_promises.readFile)(filePath, "utf8"));
+}
+async function removeLegacyBuildArtifacts(outputRootDir) {
+	await Promise.all([
+		(0, node_fs_promises.rm)(node_path.default.join(outputRootDir, "index.html"), { force: true }),
+		(0, node_fs_promises.rm)(node_path.default.join(outputRootDir, "rsc"), {
+			force: true,
+			recursive: true
+		}),
+		(0, node_fs_promises.rm)(node_path.default.join(outputRootDir, "ssr"), {
+			force: true,
+			recursive: true
+		})
+	]);
+}
+function finalizeServerArtifacts(serverOutDir, serverRscOutDir, clientOutDir, inlineClientAssets) {
+	const rscIndexPath = node_path.default.join(serverRscOutDir, "index.mjs");
+	const rscAssetsManifestPath = node_path.default.join(serverRscOutDir, "__vite_rsc_assets_manifest.js");
+	let rscEntrySource;
+	let rscAssetsManifestSource;
+	let documentHtml = "";
+	let clientAssets = [];
+	try {
+		[rscEntrySource, rscAssetsManifestSource] = [(0, node_fs.readFileSync)(rscIndexPath, "utf8"), (0, node_fs.readFileSync)(rscAssetsManifestPath, "utf8")];
+		if (inlineClientAssets) {
+			documentHtml = (0, node_fs.readFileSync)(node_path.default.join(clientOutDir, "index.html"), "utf8");
+			clientAssets = collectEmbeddedClientAssets(clientOutDir);
+		}
+	} catch {
+		return false;
+	}
+	const manifestBindingSource = rscAssetsManifestSource.replace(/^export default\s+/, "const assetsManifest = ");
+	const asyncLocalStorageShimSource = [
+		"class __LitzAsyncLocalStorage {",
+		"  run(store, callback, ...args) {",
+		"    const previousStore = this.store;",
+		"    this.store = store;",
+		"    try {",
+		"      return callback(...args);",
+		"    } finally {",
+		"      this.store = previousStore;",
+		"    }",
+		"  }",
+		"",
+		"  getStore() {",
+		"    return this.store;",
+		"  }",
+		"",
+		"  enterWith(store) {",
+		"    this.store = store;",
+		"  }",
+		"}",
+		"",
+		"globalThis.AsyncLocalStorage ??= __LitzAsyncLocalStorage;"
+	].join("\n");
+	const inlinedServerSource = rscEntrySource.replace("import assetsManifest from \"./__vite_rsc_assets_manifest.js\";", manifestBindingSource).replace(/import \* as __viteRscAsyncHooks from "node:async_hooks";\s*/g, "").replace(/const __viteRscAsyncHooks = require\("node:async_hooks"\);\s*/g, "").replace(/globalThis\.AsyncLocalStorage = __viteRscAsyncHooks\.AsyncLocalStorage;/g, asyncLocalStorageShimSource);
+	const bundledWrapperSource = bundleServerWrapper(serverRscOutDir, inlineClientAssets ? createInlineAssetServerWrapper(inlinedServerSource, documentHtml, clientAssets) : createServerModuleWrapper(inlinedServerSource));
+	if (!bundledWrapperSource) return false;
+	(0, node_fs.mkdirSync)(serverOutDir, { recursive: true });
+	(0, node_fs.writeFileSync)(node_path.default.join(serverOutDir, "index.js"), bundledWrapperSource, "utf8");
+	(0, node_fs.rmSync)(serverRscOutDir, {
+		force: true,
+		recursive: true
+	});
+	(0, node_fs.rmSync)(node_path.default.join(serverOutDir, "_ssr"), {
+		force: true,
+		recursive: true
+	});
+	return true;
+}
+function createServerModuleWrapper(serverModuleSource) {
+	const { source, handlerName } = transformServerModuleSource(serverModuleSource);
+	return [
+		source,
+		"",
+		`export default ${handlerName};`,
+		""
+	].join("\n");
+}
+function transformServerModuleSource(serverModuleSource) {
+	const handlerName = "__litzjsServerHandler";
+	const sourceFile = typescript.default.createSourceFile("server/index.js", serverModuleSource, typescript.default.ScriptTarget.Latest, true, typescript.default.ScriptKind.JS);
+	const transformedStatements = [];
+	let defaultBinding = null;
+	let handlerDeclared = false;
+	const setDefaultBinding = (expression) => {
+		if (defaultBinding) throw new Error("Expected a single default export in the bundled Litz server module.");
+		defaultBinding = expression;
+	};
+	const createHandlerDeclaration = (expression) => typescript.default.factory.createVariableStatement(void 0, typescript.default.factory.createVariableDeclarationList([typescript.default.factory.createVariableDeclaration(typescript.default.factory.createIdentifier(handlerName), void 0, void 0, expression)], typescript.default.NodeFlags.Const));
+	const stripExportModifiers = (modifiers) => modifiers?.filter((modifier) => modifier.kind !== typescript.default.SyntaxKind.DefaultKeyword && modifier.kind !== typescript.default.SyntaxKind.ExportKeyword) ?? [];
+	for (const statement of sourceFile.statements) {
+		if (typescript.default.isExportDeclaration(statement) && statement.exportClause && typescript.default.isNamedExports(statement.exportClause)) {
+			const remainingElements = [];
+			for (const element of statement.exportClause.elements) {
+				if (element.name.text === "default" && !statement.moduleSpecifier) {
+					setDefaultBinding(typescript.default.factory.createIdentifier(element.propertyName?.text ?? element.name.text));
+					continue;
+				}
+				remainingElements.push(element);
+			}
+			if (remainingElements.length === statement.exportClause.elements.length) {
+				transformedStatements.push(statement);
+				continue;
+			}
+			if (remainingElements.length > 0) transformedStatements.push(typescript.default.factory.updateExportDeclaration(statement, statement.modifiers, statement.isTypeOnly, typescript.default.factory.updateNamedExports(statement.exportClause, remainingElements), statement.moduleSpecifier, statement.attributes));
+			continue;
+		}
+		if (typescript.default.isExportAssignment(statement) && !statement.isExportEquals) {
+			transformedStatements.push(createHandlerDeclaration(statement.expression));
+			handlerDeclared = true;
+			continue;
+		}
+		if (typescript.default.isFunctionDeclaration(statement)) {
+			const modifiers = stripExportModifiers(statement.modifiers);
+			if (!(statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword) && statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.DefaultKeyword))) {
+				transformedStatements.push(statement);
+				continue;
+			}
+			if (statement.name) {
+				transformedStatements.push(typescript.default.factory.updateFunctionDeclaration(statement, modifiers, statement.asteriskToken, statement.name, statement.typeParameters, statement.parameters, statement.type, statement.body ?? typescript.default.factory.createBlock([], false)));
+				setDefaultBinding(typescript.default.factory.createIdentifier(statement.name.text));
+				continue;
+			}
+			transformedStatements.push(createHandlerDeclaration(typescript.default.factory.createFunctionExpression(modifiers, statement.asteriskToken, void 0, statement.typeParameters, statement.parameters, statement.type, statement.body ?? typescript.default.factory.createBlock([], false))));
+			handlerDeclared = true;
+			continue;
+		}
+		if (typescript.default.isClassDeclaration(statement)) {
+			const modifiers = stripExportModifiers(statement.modifiers);
+			if (!(statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword) && statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.DefaultKeyword))) {
+				transformedStatements.push(statement);
+				continue;
+			}
+			if (statement.name) {
+				transformedStatements.push(typescript.default.factory.updateClassDeclaration(statement, modifiers, statement.name, statement.typeParameters, statement.heritageClauses, statement.members));
+				setDefaultBinding(typescript.default.factory.createIdentifier(statement.name.text));
+				continue;
+			}
+			transformedStatements.push(createHandlerDeclaration(typescript.default.factory.createClassExpression(modifiers, void 0, statement.typeParameters, statement.heritageClauses, statement.members)));
+			handlerDeclared = true;
+			continue;
+		}
+		transformedStatements.push(statement);
+	}
+	if (!handlerDeclared) {
+		if (!defaultBinding) throw new Error("Unable to locate the default export in the bundled Litz server module.");
+		transformedStatements.push(createHandlerDeclaration(defaultBinding));
+	}
+	const printer = typescript.default.createPrinter({ newLine: typescript.default.NewLineKind.LineFeed });
+	const transformedSourceFile = typescript.default.factory.updateSourceFile(sourceFile, transformedStatements);
+	return {
+		source: printer.printFile(transformedSourceFile),
+		handlerName
+	};
+}
+function createInlineAssetServerWrapper(serverModuleSource, documentHtml, clientAssets) {
+	const serializedClientAssets = JSON.stringify(clientAssets);
+	const serializedDocumentHtml = JSON.stringify(documentHtml);
+	const { source, handlerName } = transformServerModuleSource(serverModuleSource);
+	return [
+		`const LITZ_DOCUMENT_HTML = ${serializedDocumentHtml};`,
+		`const LITZ_CLIENT_ASSETS = new Map(${serializedClientAssets}.map((asset) => [asset.path, asset]));`,
+		"",
+		source,
+		"",
+		"function __litzjsDecodeBase64(value) {",
+		"  if (typeof atob !== 'function') {",
+		"    throw new Error('Base64 asset decoding requires global atob.');",
+		"  }",
+		"",
+		"  const binary = atob(value);",
+		"  const bytes = new Uint8Array(binary.length);",
+		"",
+		"  for (let index = 0; index < binary.length; index += 1) {",
+		"    bytes[index] = binary.charCodeAt(index);",
+		"  }",
+		"",
+		"  return bytes;",
+		"}",
+		"",
+		"function __litzjsCreateStaticAssetResponse(asset, request) {",
+		"  const body = request.method === 'HEAD'",
+		"    ? null",
+		"    : asset.encoding === 'base64'",
+		"      ? __litzjsDecodeBase64(asset.body)",
+		"      : asset.body;",
+		"",
+		"  return new Response(body, {",
+		"    status: 200,",
+		"    headers: asset.headers,",
+		"  });",
+		"}",
+		"",
+		"function __litzjsShouldServeDocument(request, pathname) {",
+		"  if (pathname.startsWith('/_litz/') || pathname.startsWith('/api/')) {",
+		"    return false;",
+		"  }",
+		"",
+		"  const lastSegment = pathname.split('/').at(-1) ?? '';",
+		"",
+		"  if (lastSegment.includes('.')) {",
+		"    return pathname === '/index.html';",
+		"  }",
+		"",
+		"  const accept = request.headers.get('accept') ?? '';",
+		"  return accept.includes('text/html') || accept.includes('*/*');",
+		"}",
+		"",
+		"async function handle(request) {",
+		"  const url = new URL(request.url);",
+		"  const asset = LITZ_CLIENT_ASSETS.get(url.pathname);",
+		"",
+		"  if ((request.method === 'GET' || request.method === 'HEAD') && asset) {",
+		"    return __litzjsCreateStaticAssetResponse(asset, request);",
+		"  }",
+		"",
+		"  if ((request.method === 'GET' || request.method === 'HEAD') && __litzjsShouldServeDocument(request, url.pathname)) {",
+		"    return new Response(request.method === 'HEAD' ? null : LITZ_DOCUMENT_HTML, {",
+		"      status: 200,",
+		"      headers: {",
+		"        'content-type': 'text/html; charset=utf-8',",
+		"      },",
+		"    });",
+		"  }",
+		"",
+		`  return ${handlerName}.fetch(request);`,
+		"}",
+		"",
+		"export default { fetch: handle };",
+		""
+	].join("\n");
+}
+function bundleServerWrapper(serverRscOutDir, wrapperSource) {
+	const wrapperEntryPath = node_path.default.join(serverRscOutDir, "__litzjs_wrapped_server_entry.mjs");
+	const bundleOutDir = node_path.default.join(serverRscOutDir, "__litzjs_bundle_out");
+	const bundleScript = `
+const entryPath = process.env.LITZ_SERVER_ENTRY_PATH;
+const outDir = process.env.LITZ_SERVER_OUT_DIR;
+
+if (!entryPath || !outDir) {
+  throw new Error("Missing Litz server bundle paths.");
+}
+
+(async () => {
+  const { build } = await import("vite");
+
+  await build({
+    appType: "custom",
+    configFile: false,
+    publicDir: false,
+    logLevel: "silent",
+    build: {
+      ssr: entryPath,
+      copyPublicDir: false,
+      emptyOutDir: false,
+      minify: false,
+      outDir,
+      target: "esnext",
+      write: true,
+      rollupOptions: {
+        output: {
+          entryFileNames: "index.js",
+          format: "es",
+          inlineDynamicImports: true,
+        },
+      },
+    },
+  });
+})().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+`;
+	(0, node_fs.writeFileSync)(wrapperEntryPath, wrapperSource, "utf8");
+	(0, node_fs.rmSync)(bundleOutDir, {
+		force: true,
+		recursive: true
+	});
+	(0, node_fs.mkdirSync)(bundleOutDir, { recursive: true });
+	const result = (0, node_child_process.spawnSync)(process.execPath, ["-e", bundleScript], {
+		cwd: serverRscOutDir,
+		encoding: "utf8",
+		env: {
+			...process.env,
+			LITZ_SERVER_ENTRY_PATH: wrapperEntryPath,
+			LITZ_SERVER_OUT_DIR: bundleOutDir
+		}
+	});
+	try {
+		if (result.status !== 0) {
+			const stderr = result.stderr.trim();
+			const stdout = result.stdout.trim();
+			const failureMessage = stderr || stdout || "Failed to bundle the production Litz server.";
+			throw new Error(failureMessage);
+		}
+		return (0, node_fs.readFileSync)(node_path.default.join(bundleOutDir, "index.js"), "utf8");
+	} finally {
+		(0, node_fs.rmSync)(wrapperEntryPath, { force: true });
+		(0, node_fs.rmSync)(bundleOutDir, {
+			force: true,
+			recursive: true
+		});
+	}
+}
+function collectEmbeddedClientAssets(clientOutDir) {
+	const assets = [];
+	walkClientAssets(clientOutDir, clientOutDir, assets);
+	return assets;
+}
+function walkClientAssets(rootDir, currentDir, assets) {
+	for (const entry of (0, node_fs.readdirSync)(currentDir, { withFileTypes: true })) {
+		const fullPath = node_path.default.join(currentDir, entry.name);
+		const relativePath = node_path.default.relative(rootDir, fullPath).split(node_path.default.sep).join("/");
+		if (relativePath === ".vite" || relativePath.startsWith(".vite/")) continue;
+		if (entry.isDirectory()) {
+			walkClientAssets(rootDir, fullPath, assets);
+			continue;
+		}
+		if (relativePath === "index.html") continue;
+		const buffer = (0, node_fs.readFileSync)(fullPath);
+		const encoding = isUtf8Asset(relativePath) ? "utf8" : "base64";
+		assets.push({
+			path: `/${relativePath}`,
+			headers: { "content-type": getContentType(relativePath) },
+			body: encoding === "utf8" ? buffer.toString("utf8") : buffer.toString("base64"),
+			encoding
+		});
+	}
+}
+function isUtf8Asset(filePath) {
+	const extension = node_path.default.extname(filePath).toLowerCase();
+	return extension === ".js" || extension === ".mjs" || extension === ".css" || extension === ".html" || extension === ".json" || extension === ".svg" || extension === ".txt" || extension === ".map";
+}
+function getContentType(filePath) {
+	switch (node_path.default.extname(filePath).toLowerCase()) {
+		case ".html": return "text/html; charset=utf-8";
+		case ".js":
+		case ".mjs": return "text/javascript; charset=utf-8";
+		case ".css": return "text/css; charset=utf-8";
+		case ".json":
+		case ".map": return "application/json; charset=utf-8";
+		case ".svg": return "image/svg+xml";
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".webp": return "image/webp";
+		case ".woff": return "font/woff";
+		case ".woff2": return "font/woff2";
+		case ".txt": return "text/plain; charset=utf-8";
+		default: return "application/octet-stream";
+	}
+}
+//#endregion
+exports.discoverServerEntry = discoverServerEntry;
+exports.litz = litz;
+exports.transformServerModuleSource = transformServerModuleSource;