@markless/router 0.1.0

package/dist/vite.js

@@ -0,0 +1,1355 @@
+import { t as buildRouteManifestFromFileIds } from "./route-manifest-OTaWQ_TC.js";
+import { r as transformRequestFileSource } from "./request-files-DTkeaKxU.js";
+import { dirname, extname, isAbsolute, join, normalize, relative } from "pathe";
+import { decodePath, joinURL, parsePath, parseQuery, parseURL, stringifyQuery, withLeadingSlash, withoutLeadingSlash } from "ufo";
+import { existsSync } from "node:fs";
+import { nitro } from "nitro/vite";
+import { sortUserPlugins } from "vite";
+import { symbolVirtualModuleSourceFile } from "@markless/bundler/preload";
+import { parseModule } from "@tsrx/core";
+import { toHtml } from "hast-util-to-html";
+import { HastReader, createMdxHastHandle, defineHastPlugin, dropHandle, materializeHastTree, resolveHastSubscriptions, serializeHandle, visitHastHandle } from "satteri";
+//#region src/route-types.ts
+const routeTypesEnvPath = "markless-router-env.d.ts";
+const routeTypesOutputPath = ".output/markless/router/types/routes.d.ts";
+const routeTypesEnvDeclaration = "/// <reference path=\"./.output/markless/router/types/routes.d.ts\" />\n";
+function createRouteTypesDeclaration(manifest) {
+	const routes = manifest.routes;
+	const staticHrefs = routes.filter((route) => route.params.length === 0).map((route) => stringLiteral(route.pathname));
+	const routePatterns = routes.filter((route) => route.params.length > 0).map((route) => stringLiteral(route.pattern));
+	return [
+		"/* This file is generated by Markless Router. Do not edit. */",
+		"",
+		createUnion("MarklessRouterStaticPageHref", staticHrefs),
+		"",
+		createUnion("MarklessRouterConcretePageHref", routes.map((route) => hrefType(route))),
+		"",
+		createUnion("MarklessRouterRoutePattern", routePatterns),
+		"",
+		createRouteParamsInterface(routes),
+		"",
+		createUnion("MarklessRouterExternalHref", [
+			"`http://${string}`",
+			"`https://${string}`",
+			"`mailto:${string}`",
+			"`tel:${string}`",
+			"`#${string}`",
+			"`?${string}`"
+		]),
+		"",
+		"export type MarklessRouterAssetHref = `/${string}.${string}`;",
+		"",
+		createLinkTypes(),
+		""
+	].join("\n");
+}
+function createUnion(name, members) {
+	if (members.length === 0) return `export type ${name} = never;`;
+	return [`export type ${name} =`, ...members.map((member, index) => `\t| ${member}${index === members.length - 1 ? ";" : ""}`)].join("\n");
+}
+function createRouteParamsInterface(routes) {
+	const dynamicRoutes = routes.filter((route) => route.params.length > 0);
+	if (dynamicRoutes.length === 0) return "export interface MarklessRouterRouteParams {}";
+	return [
+		"export interface MarklessRouterRouteParams {",
+		...dynamicRoutes.flatMap((route) => [
+			`\t${stringLiteral(route.pattern)}: {`,
+			...route.params.map((param) => `\t\treadonly ${param.name}: ${paramType(param.kind)};`),
+			"	};"
+		]),
+		"}"
+	].join("\n");
+}
+function hrefType(route) {
+	if (route.params.length === 0) return stringLiteral(route.pathname);
+	return templateLiteralHref(route.pathname);
+}
+function templateLiteralHref(pathname) {
+	return `\`/${splitPathname(pathname).map((segment) => {
+		if (segment === "**" || segment.startsWith(":")) return "${string}";
+		return segment;
+	}).join("/")}\``;
+}
+function splitPathname(pathname) {
+	return pathname === "/" ? [] : pathname.slice(1).split("/");
+}
+function paramType(kind) {
+	return kind === "catch-all" ? "string | number | readonly (string | number)[]" : "string | number";
+}
+function stringLiteral(value) {
+	return JSON.stringify(value);
+}
+function createLinkTypes() {
+	return [
+		"export type MarklessRouterRoutePatternLinkProps = {",
+		"	[Pattern in MarklessRouterRoutePattern]: {",
+		"		readonly href: Pattern;",
+		"		readonly params: MarklessRouterRouteParams[Pattern];",
+		"	};",
+		"}[MarklessRouterRoutePattern];",
+		"",
+		"export type MarklessRouterConcreteLinkProps = {",
+		"	readonly href?: MarklessRouterStaticPageHref | MarklessRouterExternalHref | MarklessRouterAssetHref;",
+		"	readonly params?: never;",
+		"};",
+		"",
+		"export type MarklessRouterNavigationProps = {",
+		"	readonly prefetch?: boolean | \"intent\" | \"viewport\";",
+		"	readonly replace?: boolean;",
+		"	readonly scroll?: boolean;",
+		"};",
+		"",
+		"export type MarklessRouterLinkProps = MarklessRouterNavigationProps &",
+		"	(MarklessRouterConcreteLinkProps | MarklessRouterRoutePatternLinkProps);",
+		"",
+		"declare module \"@markless/router\" {",
+		"	interface MarklessRouterGeneratedRoutes {",
+		"		readonly link: MarklessRouterLinkProps;",
+		"	}",
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/vite/route-typegen.ts
+const PAGE_EXTENSIONS = new Set([".tsrx", ".mdx"]);
+function routeTypegenPlugin() {
+	let root = "";
+	return {
+		name: "markless-router:typegen",
+		configResolved(config) {
+			root = config.root;
+		},
+		async buildStart() {
+			await writeRouteTypes(this.fs, root);
+		},
+		async watchChange() {
+			await writeRouteTypes(this.fs, root);
+		}
+	};
+}
+async function writeRouteTypes(fs, root) {
+	const manifest = buildRouteManifestFromFileIds(await discoverPageFiles(fs, root));
+	await writeIfChanged(fs, join(root, routeTypesEnvPath), routeTypesEnvDeclaration);
+	await writeIfChanged(fs, join(root, routeTypesOutputPath), createRouteTypesDeclaration(manifest));
+}
+async function discoverPageFiles(fs, root) {
+	const pagesDir = join(root, "pages");
+	const files = [];
+	await collectPageFiles(fs, root, pagesDir, files);
+	return files.toSorted((left, right) => left.localeCompare(right));
+}
+async function collectPageFiles(fs, root, dir, files) {
+	const entries = await readdirIfExists(fs, dir);
+	await Promise.all(entries.map((entry) => collectPageFile(fs, root, dir, files, entry)));
+}
+async function collectPageFile(fs, root, dir, files, entry) {
+	const path = join(dir, entry.name);
+	if (entry.isDirectory()) {
+		await collectPageFiles(fs, root, path, files);
+		return;
+	}
+	if (entry.isFile() && PAGE_EXTENSIONS.has(extname(path))) files.push(withLeadingSlash(relative(root, path)));
+}
+async function readdirIfExists(fs, dir) {
+	try {
+		return await fs.readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if (isNotFoundError(error)) return [];
+		throw error;
+	}
+}
+async function writeIfChanged(fs, path, contents) {
+	if (await readExistingText(fs, path) === contents) return;
+	await fs.mkdir(dirname(path), { recursive: true });
+	await fs.writeFile(path, contents, { encoding: "utf8" });
+}
+async function readExistingText(fs, path) {
+	try {
+		return await fs.readFile(path, { encoding: "utf8" });
+	} catch (error) {
+		if (isNotFoundError(error)) return;
+		throw error;
+	}
+}
+function isNotFoundError(error) {
+	return typeof error === "object" && error !== null && "code" in error ? error.code === "ENOENT" : false;
+}
+//#endregion
+//#region src/vite/anchor-transform.ts
+const ROUTE_HREF_HELPER_ID = "virtual:markless-router/route-href";
+const JSX_FILE_FILTER = /\.(?:[jt]sx|tsrx)(?:$|\?)/;
+const ROUTER_IMPORT_SOURCES = new Set(["@markless/router", "@markless/core/router"]);
+function anchorTransformPlugin() {
+	let root = "";
+	let routePatterns = /* @__PURE__ */ new Map();
+	let routesLoaded = false;
+	const refreshRoutes = async (fs) => {
+		routePatterns = routePatternMap(buildRouteManifestFromFileIds(await discoverPageFiles(fs, root)));
+		routesLoaded = true;
+	};
+	return {
+		name: "markless-router:anchors",
+		transform: {
+			order: "pre",
+			filter: { id: JSX_FILE_FILTER },
+			async handler(code, id) {
+				if (!isTransformCandidateCode(code)) return;
+				if (!routesLoaded) await refreshRoutes(this.fs);
+				const transformed = transformAnchorSource(code, parseTransformAst(code, id, (source, options) => this.parse(source, options)), routePatterns);
+				return transformed === code ? void 0 : {
+					code: transformed,
+					map: null
+				};
+			}
+		},
+		configResolved(config) {
+			root = config.root;
+		},
+		async buildStart() {
+			await refreshRoutes(this.fs);
+		},
+		async watchChange() {
+			await refreshRoutes(this.fs);
+		}
+	};
+}
+function parseTransformAst(code, id, parse) {
+	if (id.includes(".tsrx")) return parseModule(code, id);
+	return parse(code, {
+		astType: "ts",
+		lang: id.includes(".jsx") ? "jsx" : "tsx",
+		range: true
+	});
+}
+function isTransformCandidateCode(code) {
+	return code.includes("<a") || [...ROUTER_IMPORT_SOURCES].some((importSource) => code.includes(importSource));
+}
+function transformAnchorSource(code, astInput, routePatterns) {
+	const ast = node$1(astInput);
+	if (!ast) return code;
+	const edits = [];
+	const linkNames = marklessRouterLinkImportNames(ast);
+	walk(ast, (current) => {
+		if (current.type !== "JSXOpeningElement") return;
+		const name = jsxName$1(node$1(current.name));
+		if (name !== "a" && (!name || !linkNames.has(name))) return;
+		const attributes = nodes$1(current.attributes);
+		const href = findJsxAttribute(attributes, "href");
+		const hrefValue = href ? stringLiteralValue(node$1(href.value)) : void 0;
+		if (!href || !hrefValue || !isRoutePatternHref(hrefValue)) return;
+		const routeParams = routePatterns.get(hrefValue);
+		if (!routeParams) fail$1(`Typed route error: ${hrefValue} does not match any route in pages/.`);
+		const params = findJsxAttribute(attributes, "params");
+		if (!params) fail$1(missingParamsMessage(hrefValue, routeParams));
+		const paramsExpression = jsxExpression(node$1(params.value));
+		if (!paramsExpression) fail$1(missingParamsMessage(hrefValue, routeParams));
+		validateObjectLiteralParams(hrefValue, routeParams, paramsExpression);
+		edits.push({
+			...rangeOf(href),
+			text: `href={__marklessRouteHref(${JSON.stringify(hrefValue)}, ${slice$1(code, paramsExpression)})}`
+		});
+		edits.push({
+			...attributeRemovalRange(code, params),
+			text: ""
+		});
+	});
+	if (edits.length === 0) return code;
+	return `${helperImport()}${applyEdits(code, edits)}`;
+}
+function marklessRouterLinkImportNames(ast) {
+	const names = /* @__PURE__ */ new Set();
+	walk(ast, (current) => {
+		if (current.type !== "ImportDeclaration" || !ROUTER_IMPORT_SOURCES.has(literalString(node$1(current.source)) ?? "")) return;
+		for (const specifier of nodes$1(current.specifiers)) if (specifier.type === "ImportSpecifier" && identifierName(node$1(specifier.imported)) === "Link") {
+			const localName = identifierName(node$1(specifier.local));
+			if (localName) names.add(localName);
+		}
+	});
+	return names;
+}
+function routePatternMap(manifest) {
+	return new Map(manifest.routes.filter((route) => route.params.length > 0).map((route) => [route.pattern, route.params]));
+}
+function validateObjectLiteralParams(pattern, routeParams, paramsExpression) {
+	if (paramsExpression.type !== "ObjectExpression") return;
+	const expected = new Set(routeParams.map((param) => param.name));
+	const actual = objectLiteralKeys(paramsExpression);
+	const unknown = actual.filter((param) => !expected.has(param));
+	if (unknown.length > 0) fail$1(`Typed route error: ${pattern} does not define param:\n${list(unknown)}`);
+	const missing = routeParams.map((param) => param.name).filter((param) => !actual.includes(param));
+	if (missing.length > 0) fail$1(`Typed route error: ${pattern} requires params:\n${list(missing)}`);
+}
+function objectLiteralKeys(expression) {
+	return nodes$1(expression.properties).flatMap((property) => {
+		if (property.type !== "Property") return [];
+		const key = node$1(property.key);
+		const name = key?.type === "Identifier" ? string$1(key.name) : literalString(key);
+		return name ? [name] : [];
+	});
+}
+function helperImport() {
+	return `import { __marklessRouteHref } from "${ROUTE_HREF_HELPER_ID}";\n`;
+}
+function missingParamsMessage(pattern, routeParams) {
+	return `Typed route error: ${pattern} requires params:\n${list(routeParams.map((param) => param.name))}`;
+}
+function list(items) {
+	return items.map((item) => `- ${item}`).join("\n");
+}
+function findJsxAttribute(attributes, name) {
+	return attributes.find((attr) => attr.type === "JSXAttribute" && jsxName$1(node$1(attr.name)) === name);
+}
+function stringLiteralValue(value) {
+	return value?.type === "Literal" ? string$1(value.value) : void 0;
+}
+function literalString(value) {
+	return value?.type === "Literal" ? string$1(value.value) : void 0;
+}
+function identifierName(value) {
+	return value?.type === "Identifier" ? string$1(value.name) : void 0;
+}
+function jsxExpression(value) {
+	if (value?.type !== "JSXExpressionContainer") return;
+	const expression = node$1(value.expression);
+	return expression?.type === "JSXEmptyExpression" ? void 0 : expression;
+}
+function isRoutePatternHref(href) {
+	return href.includes("[") && href.includes("]");
+}
+function attributeRemovalRange(code, attribute) {
+	const range = rangeOf(attribute);
+	let start = range.start;
+	while (start > 0 && /\s/.test(code[start - 1] ?? "")) start--;
+	return {
+		start,
+		end: range.end
+	};
+}
+function applyEdits(code, edits) {
+	let transformed = code;
+	for (const edit of [...edits].toSorted((left, right) => right.start - left.start)) transformed = transformed.slice(0, edit.start) + edit.text + transformed.slice(edit.end);
+	return transformed;
+}
+function walk(root, visit) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = node$1(stack.pop());
+		if (!current) continue;
+		visit(current);
+		for (const child of Object.values(current)) if (Array.isArray(child)) stack.push(...child);
+		else stack.push(child);
+	}
+}
+function jsxName$1(name) {
+	return name?.type === "JSXIdentifier" ? string$1(name.name) : void 0;
+}
+function slice$1(code, value) {
+	const range = rangeOf(value);
+	return code.slice(range.start, range.end);
+}
+function rangeOf(value) {
+	const range = value.range;
+	if (range) return {
+		start: range[0],
+		end: range[1]
+	};
+	return {
+		start: value.start,
+		end: value.end
+	};
+}
+function nodes$1(value) {
+	return Array.isArray(value) ? value.filter((item) => !!node$1(item)) : [];
+}
+function node$1(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function string$1(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function fail$1(message) {
+	throw new Error(message);
+}
+//#endregion
+//#region src/vite/html-transform.ts
+const HELPER = "__marklessRouterHtmlAttributes";
+const SAFE_GLOBALS = new Set([
+	"String",
+	"Number",
+	"Boolean",
+	"Math",
+	"JSON"
+]);
+const DOCUMENT_FILE_LABEL = "document.tsx or document.jsx";
+const DOCUMENT_FILE_FILTER = /(?:^|\/)document\.[tj]sx(?:$|\?)/;
+function htmlTransformPlugin() {
+	return {
+		name: "markless-router:html",
+		transform: {
+			order: "pre",
+			filter: { id: DOCUMENT_FILE_FILTER },
+			handler(code, id) {
+				return transformHtmlSource(code, this.parse(code, {
+					astType: "ts",
+					lang: id.includes("document.jsx") ? "jsx" : "tsx",
+					range: true
+				}));
+			}
+		}
+	};
+}
+function transformHtmlSource(code, astInput) {
+	const ast = node(astInput);
+	if (!ast) fail(`MarklessRouter could not read ${DOCUMENT_FILE_LABEL}. Check it for syntax errors.`);
+	const fn = findDefaultDocumentFunction(ast);
+	if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression") fail(`MarklessRouter needs to see your document body in ${DOCUMENT_FILE_LABEL}. Write \`export default (props) => <Html>...</Html>\` instead of passing a named function.`);
+	const props = first(nodes(fn.params));
+	const propsName = props?.type === "Identifier" ? string(props.name) : void 0;
+	const propsSource = props ? slice(code, props) : "";
+	const attrs = nodes(node(findReturnedHtml(fn).openingElement)?.attributes).map((attr) => htmlAttr(code, attr, propsName));
+	const helper = `export function ${HELPER}(${propsSource}) {\n  return ${attrs.length ? `{\n${attrs.map(([name, value]) => `    ${JSON.stringify(name)}: ${value}`).join(",\n")}\n  }` : "{}"};\n}\n`;
+	return code.endsWith("\n") ? `${code}\n${helper}` : `${code}\n\n${helper}`;
+}
+function findDefaultDocumentFunction(ast) {
+	for (const statement of nodes(ast.body)) {
+		const declaration = node(statement.declaration);
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		if (declaration?.type === "ArrowFunctionExpression" || declaration?.type === "FunctionExpression") return declaration;
+	}
+	fail(`MarklessRouter could not find the document function. ${DOCUMENT_FILE_LABEL} must default export \`() => <Html>...</Html>\`.`);
+}
+function findReturnedHtml(fn) {
+	const body = unwrap(node(fn.body));
+	const returned = body?.type === "BlockStatement" ? unwrap(node(nodes(body.body).find((item) => item.type === "ReturnStatement")?.argument)) : body;
+	if (returned?.type !== "JSXElement") fail(`MarklessRouter expected ${DOCUMENT_FILE_LABEL} to return <Html> at the top level. Wrap your document shell in \`<Html>...</Html>\`.`);
+	if (jsxName(node(node(returned.openingElement)?.name)) !== "Html") fail(`MarklessRouter expected ${DOCUMENT_FILE_LABEL} to return <Html> at the top level. Put <head> and <body> inside \`<Html>...</Html>\`.`);
+	return returned;
+}
+function htmlAttr(code, attr, propsName) {
+	if (attr.type === "JSXSpreadAttribute") fail("MarklessRouter does not support spreading props onto <Html> yet. Write each html attribute directly, like `<Html lang=\"en\">`.");
+	const name = jsxName(node(attr.name));
+	if (!name) fail("MarklessRouter found an unsupported <Html> attribute name. Use plain html attributes like `lang`, `class`, or `data-theme`.");
+	const value = node(attr.value);
+	if (!value) return [name, "true"];
+	if (value.type === "Literal") return [name, JSON.stringify(value.value)];
+	if (value.type !== "JSXExpressionContainer") fail(`MarklessRouter could not understand the <Html> "${name}" attribute. Use a string or JSX expression, like \`${name}="value"\` or \`${name}={props.url.pathname}\`.`);
+	const expression = unwrap(node(value.expression));
+	if (!expression || expression.type === "JSXEmptyExpression") fail(`MarklessRouter found an empty <Html> "${name}" attribute expression. Add a value or remove the attribute.`);
+	const ref = unsupportedIdentifier(expression, propsName);
+	if (ref) fail(`MarklessRouter cannot use "${ref}" in <Html ${name}={...}> because html attributes are read before Markless renders ${DOCUMENT_FILE_LABEL}. Use props directly, like \`${name}={props.url.pathname}\`, or a literal value.`);
+	return [name, slice(code, expression)];
+}
+function unsupportedIdentifier(root, propsName) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = node(stack.pop());
+		if (!current) continue;
+		if (current.type === "Identifier") {
+			const name = string(current.name);
+			if (name && name !== propsName && !SAFE_GLOBALS.has(name)) return name;
+			continue;
+		}
+		if (current.type === "MemberExpression") {
+			stack.push(current.object);
+			if (current.computed === true) stack.push(current.property);
+			continue;
+		}
+		if (current.type === "Property") {
+			stack.push(current.value);
+			if (current.computed === true) stack.push(current.key);
+			continue;
+		}
+		for (const child of Object.values(current)) if (Array.isArray(child)) stack.push(...child);
+		else stack.push(child);
+	}
+}
+function jsxName(name) {
+	return name?.type === "JSXIdentifier" ? string(name.name) : void 0;
+}
+function unwrap(value) {
+	let current = value;
+	while (current?.type === "ParenthesizedExpression" || current?.type === "TSAsExpression" || current?.type === "TSNonNullExpression") current = node(current.expression);
+	return current;
+}
+function slice(code, value) {
+	const range = value.range;
+	if (range) return code.slice(range[0], range[1]);
+	return code.slice(value.start, value.end);
+}
+function nodes(value) {
+	return Array.isArray(value) ? value.filter((item) => !!node(item)) : [];
+}
+function node(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function first(items) {
+	return items[0];
+}
+function string(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function fail(message) {
+	throw new Error(message);
+}
+//#endregion
+//#region src/vite/mdx.ts
+function mdxTransformPlugin() {
+	return {
+		name: "markless-router:mdx",
+		enforce: "pre",
+		transform: {
+			order: "pre",
+			async handler(code, id) {
+				if (!isMdxFile(id)) return;
+				return {
+					code: await transformMdxRoute(code, id),
+					map: null
+				};
+			}
+		}
+	};
+}
+async function transformMdxRoute(source, id) {
+	const route = parseMdxRoute(source, id);
+	const html = route.parts.map((part) => part.kind === "html" ? part.html : "").join("");
+	if (route.components.length === 0) return [
+		"const marklessMdxPage = {",
+		"  renderSsr() {",
+		`    return { html: ${JSON.stringify(html)} };`,
+		"  }",
+		"};",
+		"export default marklessMdxPage;",
+		""
+	].join("\n");
+	return emitComposedMdxRoute(route);
+}
+function emitComposedMdxRoute(route) {
+	return [
+		`import { resumeFromPayloadDocument } from '@markless/core/web/resume';`,
+		`import { composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml } from '@markless/router/vite/runtime/mdx-route';`,
+		...route.imports,
+		"",
+		`const marklessMdxParts = ${JSON.stringify(route.parts)};`,
+		`const marklessMdxSymbolLoaders = ${renderSymbolLoaders(route.components)};`,
+		"",
+		"const marklessMdxPage = {",
+		"  async renderSsr(props = {}) {",
+		"    const marklessMdxChildren = [];",
+		`    const html = ${renderHtmlExpression(route, "ssr")};`,
+		"    const state = composeMdxState(marklessMdxChildren);",
+		"    const view = composeMdxView(marklessMdxParts, marklessMdxChildren, 0);",
+		"    return { html, ...(state ? { state } : {}), ...(view ? { view } : {}) };",
+		"  },",
+		"  renderCsr(props = {}) {",
+		"    const marklessMdxChildren = [];",
+		`    const root = rootFromMdxHtml(${renderCsrHtml(route)});`,
+		...route.components.flatMap((component, index) => [
+			`    const marklessMdxChild${index} = ${component.localName}.renderCsr?.(${componentPropsExpression(component)});`,
+			`    replaceMdxChild(root, ${index}, marklessMdxChild${index}?.root);`,
+			`    if (marklessMdxChild${index}) marklessMdxChildren.push({ componentIndex: ${index}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)}, output: marklessMdxChild${index} });`
+		]),
+		"    const state = composeMdxState(marklessMdxChildren);",
+		"    const view = composeMdxView(marklessMdxParts, marklessMdxChildren, 1);",
+		"    return {",
+		"      root,",
+		"      ...(state ? { state } : {}),",
+		"      ...(view ? { view } : {}),",
+		"      loadSymbol(symbolId) { return marklessMdxLoadSymbol(symbolId, marklessMdxChildren); },",
+		"      connectRuntime(context) { for (const child of marklessMdxChildren) child.output?.connectRuntime?.(context); },",
+		"    };",
+		"  },",
+		...renderMdxPreload(route.components),
+		"};",
+		"export default marklessMdxPage;",
+		"",
+		"export async function resumeContainerEvent(input) {",
+		"  input.root.__asyncResumeRuntimeStarted = true;",
+		"  const { runtime } = await resumeFromPayloadDocument({",
+		"    document: input.root,",
+		"    root: input.root,",
+		"    loadSymbol: marklessMdxLoadSymbol,",
+		"  });",
+		"  await runtime.dispatch(input.event, { syncPolicyAlreadyApplied: true });",
+		"}",
+		"",
+		"function marklessMdxLoadSymbol(symbolId, children = []) {",
+		"  return loadMdxSymbol(symbolId, children, marklessMdxSymbolLoaders);",
+		"}",
+		""
+	].join("\n");
+}
+function renderMdxPreload(components) {
+	return [
+		"  preload() {",
+		`    return Promise.all([${[...new Set(components.map((component) => component.localName))].map((localName) => `${localName}.preload?.()`).join(", ")}].filter(Boolean));`,
+		"  },"
+	];
+}
+function isMdxFile(id) {
+	return extname(decodePath(parseURL(id).pathname)) === ".mdx";
+}
+function parseMdxRoute(source, id) {
+	const imports = [];
+	const importedComponents = /* @__PURE__ */ new Map();
+	const components = [];
+	const handle = createMdxHastHandle(source);
+	let root;
+	try {
+		const importCollector = defineHastPlugin({
+			name: "markless-router-mdx-imports",
+			mdxjsEsm(node) {
+				for (const imported of tsrxImportsFromProgram(node.parseExpression(), id)) if (!importedComponents.has(imported.localName)) {
+					importedComponents.set(imported.localName, imported);
+					imports.push(`import ${imported.localName} from ${JSON.stringify(imported.specifier)};`);
+				}
+			}
+		});
+		visitHastHandle(handle, importCollector, resolveHastSubscriptions(importCollector), source, id);
+		root = materializeHastTree(new HastReader(serializeHandle(handle)));
+	} finally {
+		dropHandle(handle);
+	}
+	return {
+		imports,
+		components,
+		parts: routePartsFromHast(root.children ?? [], {
+			components,
+			id,
+			importedComponents
+		})
+	};
+}
+function tsrxImportsFromProgram(program, id) {
+	const imports = [];
+	if (!program) throw new Error(`Markless Router MDX could not parse ESM import syntax: ${id}`);
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration") throw new Error(`Markless Router MDX only supports importing TSRX components before content: ${id}`);
+		const specifier = statement.source.value;
+		const defaultImport = statement.specifiers.find((importSpecifier) => importSpecifier.type === "ImportDefaultSpecifier");
+		if (typeof specifier !== "string" || !specifier.endsWith(".tsrx") || !defaultImport || statement.specifiers.length !== 1) throw new Error(`Markless Router MDX currently supports default imports from .tsrx files only: ${id}`);
+		imports.push({
+			localName: defaultImport.local.name,
+			specifier
+		});
+	}
+	return imports;
+}
+function routePartsFromHast(nodes, context) {
+	const parts = [];
+	let staticNodes = [];
+	for (const node of nodes) {
+		if (isMdxEsm(node)) continue;
+		if (isMdxJsxFlowElement(node)) {
+			appendHtmlPart(parts, staticNodes, context.id);
+			staticNodes = [];
+			parts.push(componentPart(node, context));
+			continue;
+		}
+		staticNodes.push(node);
+	}
+	appendHtmlPart(parts, staticNodes, context.id);
+	return parts;
+}
+function componentPart(node, context) {
+	const name = node.name;
+	const imported = name ? context.importedComponents.get(name) : void 0;
+	if (!imported) throw new Error(`Markless Router MDX component is not imported from .tsrx: ${name}`);
+	const componentIndex = context.components.length;
+	const props = componentProps(node, context.id);
+	const children = renderStaticHtml(node.children, context.id);
+	context.components.push({
+		...imported,
+		prefix: `m${componentIndex}:`,
+		props: children ? [...props, {
+			name: "children",
+			valueExpression: JSON.stringify(children)
+		}] : props
+	});
+	return {
+		kind: "component",
+		componentIndex
+	};
+}
+function appendHtmlPart(parts, nodes, id) {
+	if (nodes.length === 0) return;
+	const staticNodes = normalizeStaticHastNodes(nodes, id);
+	const html = toHtml({
+		type: "root",
+		children: staticNodes
+	}, { allowDangerousHtml: true });
+	if (html) parts.push({
+		kind: "html",
+		html,
+		elementCount: countHastElements(staticNodes)
+	});
+}
+function renderStaticHtml(nodes, id) {
+	if (nodes.length === 0) return "";
+	return toHtml({
+		type: "root",
+		children: normalizeStaticHastNodes(nodes, id)
+	}, { allowDangerousHtml: true });
+}
+function normalizeStaticHastNodes(nodes, id) {
+	return nodes.flatMap((node) => normalizeStaticHastNode(node, id));
+}
+function normalizeStaticHastNode(node, id) {
+	if (isMdxEsm(node)) return [];
+	if (isMdxJsxFlowElement(node) || isMdxJsxTextElement(node)) throw new Error(`Markless Router MDX only supports imported TSRX components as route-level MDX elements or static markdown children: ${id}`);
+	if (isMdxExpression(node)) {
+		const value = literalSafeExpressionValue(node.value, id);
+		return [{
+			type: "text",
+			value: value == null ? "" : String(value)
+		}];
+	}
+	if ("children" in node && Array.isArray(node.children)) return [{
+		...node,
+		children: normalizeStaticHastNodes(node.children, id)
+	}];
+	return [node];
+}
+function componentProps(node, id) {
+	return node.attributes.map((attribute) => componentProp(attribute, id));
+}
+function componentProp(attribute, id) {
+	if (attribute.type === "mdxJsxExpressionAttribute") throw new Error(`Markless Router MDX cannot lower spread attributes because they depend on MDX JavaScript scope that Markless does not execute during resume: ${id}`);
+	const value = attribute.value;
+	if (value == null) return {
+		name: attribute.name,
+		valueExpression: "true"
+	};
+	if (typeof value === "string") return {
+		name: attribute.name,
+		valueExpression: JSON.stringify(value)
+	};
+	return {
+		name: attribute.name,
+		valueExpression: literalValueExpression(literalSafeExpressionValue(value.value, id), id)
+	};
+}
+function literalSafeExpressionValue(source, id) {
+	const program = parseMdxExpressionValue(source, id);
+	if (!program) throw new Error(`Markless Router MDX only supports literal-safe expressions in attributes and markdown: ${id}`);
+	const statement = program.body[0];
+	if (program.body.length !== 1 || statement?.type !== "ExpressionStatement") throw new Error(`Markless Router MDX only supports literal-safe expressions in attributes and markdown: ${id}`);
+	return evaluateLiteralExpression(statement.expression, id);
+}
+function parseMdxExpressionValue(source, id) {
+	const handle = createMdxHastHandle(`{${source}}`);
+	let program = null;
+	try {
+		const expressionParser = defineHastPlugin({
+			name: "markless-router-mdx-expression",
+			mdxFlowExpression(node) {
+				program = node.parseExpression();
+			},
+			mdxTextExpression(node) {
+				program = node.parseExpression();
+			}
+		});
+		visitHastHandle(handle, expressionParser, resolveHastSubscriptions(expressionParser), `{${source}}`, id);
+		return program;
+	} finally {
+		dropHandle(handle);
+	}
+}
+function evaluateLiteralExpression(node, id) {
+	if (!node) throw literalExpressionError(id);
+	if (node.type === "Literal") {
+		const value = node.value;
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) return value;
+		throw literalExpressionError(id);
+	}
+	if (node.type === "UnaryExpression") {
+		const value = evaluateLiteralExpression(node.argument, id);
+		if (node.operator === "-" && typeof value === "number") return -value;
+		if (node.operator === "+" && typeof value === "number") return value;
+		if (node.operator === "!") return !value;
+		throw literalExpressionError(id);
+	}
+	if (node.type === "ArrayExpression") return node.elements.map((element) => evaluateLiteralExpression(element ?? void 0, id));
+	if (node.type === "ObjectExpression") {
+		const value = {};
+		for (const property of node.properties) {
+			if (property.type !== "Property" || property.kind !== "init" || property.method || property.computed) throw literalExpressionError(id);
+			const key = property.key;
+			const name = key.type === "Identifier" ? key.name : key.type === "Literal" && typeof key.value === "string" ? key.value : void 0;
+			if (!name) throw literalExpressionError(id);
+			value[name] = evaluateLiteralExpression(property.value, id);
+		}
+		return value;
+	}
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis.map((quasi) => quasi.value?.cooked ?? "").join("");
+	throw literalExpressionError(id);
+}
+function literalValueExpression(value, id) {
+	if (typeof value === "number" && !Number.isFinite(value)) throw literalExpressionError(id);
+	const json = JSON.stringify(value);
+	if (json === void 0) throw literalExpressionError(id);
+	return json;
+}
+function literalExpressionError(id) {
+	return /* @__PURE__ */ new Error(`Markless Router MDX only supports literal-safe expressions in attributes and markdown: ${id}`);
+}
+function renderHtmlExpression(route, mode) {
+	return joinExpressions(route.parts.map((part) => {
+		if (part.kind === "html") return JSON.stringify(part.html);
+		if (mode === "csr") return JSON.stringify(`<span data-markless-mdx-child="${part.componentIndex}"></span>`);
+		const component = route.components[part.componentIndex];
+		return `(await renderMdxChild(marklessMdxChildren, ${component.localName}, ${componentPropsExpression(component)}, { componentIndex: ${part.componentIndex}, hostPrefix: ${JSON.stringify(component.prefix)}, symbolPrefix: ${JSON.stringify(component.prefix)} }))`;
+	}));
+}
+function componentPropsExpression(component) {
+	if (component.props.length === 0) return "{}";
+	return `{ ${component.props.map((prop) => `${JSON.stringify(prop.name)}: ${prop.valueExpression}`).join(", ")} }`;
+}
+function renderCsrHtml(route) {
+	return `"<main data-markless-mdx-root>" + ${renderHtmlExpression(route, "csr")} + "</main>"`;
+}
+function joinExpressions(expressions) {
+	const filtered = expressions.filter((expression) => expression !== "\"\"");
+	return filtered.length === 0 ? "\"\"" : filtered.join(" + ");
+}
+function countHastElements(nodes) {
+	let count = 0;
+	for (const node of nodes) {
+		if (node.type === "element") count += 1;
+		if ("children" in node && Array.isArray(node.children)) count += countHastElements(node.children);
+	}
+	return count;
+}
+function renderSymbolLoaders(components) {
+	return `[${components.map((component) => `{ prefix: ${JSON.stringify(component.prefix)}, loadSymbol(symbolId) { return import(${JSON.stringify(`${component.specifier}?markless-symbols`)}).then((mod) => mod.loadSymbol(symbolId.slice(${component.prefix.length}))); } }`).join(", ")}]`;
+}
+function isMdxEsm(node) {
+	return node.type === "mdxjsEsm";
+}
+function isMdxJsxFlowElement(node) {
+	return node.type === "mdxJsxFlowElement";
+}
+function isMdxJsxTextElement(node) {
+	return node.type === "mdxJsxTextElement";
+}
+function isMdxExpression(node) {
+	return node.type === "mdxFlowExpression" || node.type === "mdxTextExpression";
+}
+//#endregion
+//#region src/vite/index.ts
+const ROUTE_DISCOVERY_ID = "virtual:markless-router/routes";
+const CLIENT_ENTRY_ID = "virtual:markless-router/client-entry";
+const RESUME_ENTRY_ID = "virtual:markless-router/resume-entry";
+const RESUME_ENTRY_ORIGIN = "/entries/resume-entry.ts";
+const RESUME_ENTRY_PATH_ID = "virtual:markless-router/resume-entry-path";
+const NAVIGATION_ENTRY_ID = "virtual:markless-router/navigation-entry";
+const NAVIGATION_ENTRY_ORIGIN = "/entries/client-entry.ts";
+const NAVIGATION_ENTRY_PATH_ID = "virtual:markless-router/navigation-entry-path";
+const ROUTE_PRELOADS_ID = "virtual:markless-router/route-preloads";
+const ROUTE_PRELOADS_PLACEHOLDER = "__MARKLESS_ROUTER_ROUTE_PRELOADS__";
+const SERVER_ENTRY_ID = "virtual:markless-router/server-entry";
+const ROUTE_HREF_ID = "virtual:markless-router/route-href";
+const ROUTER_OPTIONS_ID = "virtual:markless-router/options";
+const PUBLIC_VIRTUAL_MODULE_ID_RE = /^virtual:markless-router\/(?:routes|client-entry|resume-entry|resume-entry-path|navigation-entry|navigation-entry-path|route-preloads|server-entry|route-href|options)(?:\?.*)?$/;
+const VITE_PLUGIN_FILE = decodePath(parseURL(import.meta.url).pathname);
+const VIRTUAL_ENTRY_DIR = VITE_PLUGIN_FILE.endsWith(".ts") ? join(dirname(VITE_PLUGIN_FILE), "entries") : join(dirname(dirname(VITE_PLUGIN_FILE)), "entries");
+const DEFAULT_WATCH_IGNORES = [
+	"**/.nitro/**",
+	"**/.output/**",
+	"**/node_modules/**",
+	"**/dist/**"
+];
+const virtualEntryFiles = {
+	[ROUTE_DISCOVERY_ID]: "route-discovery.ts",
+	[CLIENT_ENTRY_ID]: "client-entry.ts",
+	[RESUME_ENTRY_ID]: "resume-entry.ts",
+	[NAVIGATION_ENTRY_ID]: "client-entry.ts",
+	[SERVER_ENTRY_ID]: "server-entry.ts",
+	[ROUTE_HREF_ID]: "route-href.ts"
+};
+function router(options = {}) {
+	if (options.nitro === false) return [
+		mdxTransformPlugin(),
+		requestFileTransformPlugin(),
+		routeTypegenPlugin(),
+		anchorTransformPlugin(),
+		htmlTransformPlugin(),
+		virtualModulesPlugin()
+	];
+	const nitroPlugins = nitro();
+	const resumeEntry = resumeEntryState();
+	const navigationEntry = resumeEntryState();
+	const routePreloads = routePreloadState();
+	return [
+		routerConfigPlugin(nitroPlugins, resumeEntry, navigationEntry, routePreloads),
+		devSourceModuleRequestPlugin(),
+		mdxTransformPlugin(),
+		requestFileTransformPlugin(),
+		routeTypegenPlugin(),
+		anchorTransformPlugin(),
+		htmlTransformPlugin(),
+		virtualModulesPlugin(resumeEntry, navigationEntry, routePreloads),
+		nitroPlugins
+	];
+}
+function devSourceModuleRequestPlugin() {
+	let root = "";
+	return {
+		name: "markless-router:dev-source-module-requests",
+		apply: "serve",
+		configResolved(config) {
+			root = config.root;
+		},
+		configureServer(server) {
+			server.middlewares.use((req, _res, next) => {
+				const url = req.url ?? "";
+				const queryIndex = url.indexOf("?");
+				const pathname = queryIndex === -1 ? url : url.slice(0, queryIndex);
+				const query = queryIndex === -1 ? "" : url.slice(queryIndex + 1);
+				if (root !== "" && /\.(?:tsrx|mdx)$/.test(pathname) && /(?:^|&)(?:import(?:=|&|$)|markless-)/.test(query) && existsSync(join(root, decodePath(pathname)))) req.url = `/@fs${join(root, decodePath(pathname))}?${query}`;
+				next();
+			});
+		}
+	};
+}
+function routerConfigPlugin(nitroPluginsFromRouter, resumeEntry, navigationEntry, routePreloads) {
+	return {
+		name: "markless-router:vite",
+		enforce: "pre",
+		config(config) {
+			throwIfUserAddedNitro(config.plugins, nitroPluginsFromRouter);
+			config.environments ??= {};
+			const ssrEnvironment = config.environments.ssr ??= {};
+			ssrEnvironment.build ??= {};
+			ssrEnvironment.build.rolldownOptions ??= {};
+			ssrEnvironment.build.rolldownOptions.input ??= scopedVirtualEntryId(SERVER_ENTRY_ID, config.root);
+			const serverWatch = withWatchIgnores(config.server?.watch);
+			return {
+				nitro: createNitroConfig(config.nitro, config.root, serverWatch.ignored),
+				server: {
+					...config.server,
+					watch: serverWatch
+				}
+			};
+		},
+		configResolved(config) {
+			for (const entry of [
+				resumeEntry,
+				navigationEntry,
+				routePreloads
+			]) entry.base = config.base;
+			routePreloads.root = config.root;
+		},
+		configEnvironment(_name, config) {
+			configureRouteInputs(config);
+		},
+		generateBundle(_options, bundle) {
+			if (this.environment?.config.consumer !== "client") return;
+			const resumeChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, RESUME_ENTRY_ORIGIN));
+			if (resumeChunk) resumeEntry.fileName = resumeChunk.fileName;
+			const navigationChunk = Object.values(bundle).find((item) => item.type === "chunk" && isVirtualEntryChunk(item, NAVIGATION_ENTRY_ORIGIN));
+			if (navigationChunk) navigationEntry.fileName = navigationChunk.fileName;
+			routePreloads.routes = routeModulePreloadsFromBundle({
+				base: routePreloads.base,
+				bundle,
+				navigationChunk,
+				resumeChunk,
+				root: routePreloads.root
+			});
+			patchRoutePreloadsInBundle(bundle, routePreloads.routes);
+		}
+	};
+}
+function configureRouteInputs(config) {
+	config.build ??= {};
+	config.build.rolldownOptions ??= {};
+	if (config.consumer === "client") {
+		config.build.rolldownOptions.input = routerClientInput(config.build.rolldownOptions.input, configRoot(config));
+		config.build.rolldownOptions.preserveEntrySignatures ??= "exports-only";
+	} else {
+		config.build.rolldownOptions.input ??= scopedVirtualEntryId(SERVER_ENTRY_ID, configRoot(config));
+		config.build.rolldownOptions.external = withExternal(config.build.rolldownOptions.external, "nitro");
+	}
+}
+function withExternal(external, id) {
+	if (Array.isArray(external)) return external.includes(id) ? external : [...external, id];
+	if (typeof external === "string") return external === id ? external : [external, id];
+	if (external === void 0) return [id];
+	return external;
+}
+function requestFileTransformPlugin() {
+	let root = "";
+	return {
+		name: "markless-router:request-files",
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+		},
+		transform(code, id) {
+			const fileId = requestFileIdForTransform(root, id);
+			if (!fileId) return;
+			const transform = transformRequestFileSource(fileId, code);
+			return transform ? {
+				code: transform.code,
+				map: null
+			} : void 0;
+		}
+	};
+}
+function requestFileIdForTransform(root, id) {
+	if (id.startsWith("\0")) return;
+	const pathname = decodePath(parseURL(id).pathname);
+	if (!isAbsolute(pathname)) return;
+	const relativeFileId = root ? withoutLeadingSlash(normalize(relative(root, pathname))) : withoutLeadingSlash(normalize(pathname));
+	if (relativeFileId.startsWith("api/") || relativeFileId.startsWith("middleware/")) return relativeFileId;
+	return relativeFileId.match(/(?:^|\/)((?:api|middleware)\/.+\.ts)$/)?.[1];
+}
+function requestFileBuildTransformPlugin(root) {
+	return {
+		name: "markless-router:nitro-request-files",
+		transform(code, id) {
+			const fileId = requestFileIdForTransform(root, id);
+			if (!fileId) return;
+			const transform = transformRequestFileSource(fileId, code);
+			return transform ? {
+				code: transform.code,
+				map: null
+			} : void 0;
+		}
+	};
+}
+function createNitroConfig(nitroConfig, root = ".", serverWatchIgnored = []) {
+	const scanDirs = Array.isArray(nitroConfig?.scanDirs) ? nitroConfig.scanDirs.filter((dir) => typeof dir === "string") : [];
+	const watchOptions = withWatchIgnores(nitroConfig?.watchOptions, serverWatchIgnored);
+	const publicAssets = Array.isArray(nitroConfig?.publicAssets) ? nitroConfig.publicAssets : [];
+	return {
+		...nitroConfig,
+		apiDir: nitroConfig?.apiDir ?? "api",
+		devServer: nitroConfig?.devServer,
+		publicAssets: [
+			{
+				baseURL: "/assets",
+				dir: join(root, "dist/assets")
+			},
+			{
+				baseURL: "/assets",
+				dir: join(root, "node_modules/.nitro/vite/services/ssr/assets")
+			},
+			...publicAssets
+		],
+		routesDir: nitroConfig?.routesDir ?? ".output/markless/router/nitro-routes",
+		rolldownConfig: withRequestFileBuildPlugin(nitroConfig?.rolldownConfig, root),
+		rollupConfig: withRequestFileBuildPlugin(nitroConfig?.rollupConfig, root),
+		scanDirs: [...new Set([".", ...scanDirs])],
+		watchOptions
+	};
+}
+function withWatchIgnores(watchOptions, extraIgnored = []) {
+	const watchOptionsObject = isRecord(watchOptions) ? watchOptions : {};
+	return {
+		...watchOptionsObject,
+		followSymlinks: watchOptionsObject.followSymlinks ?? false,
+		ignored: [
+			...toArray(watchOptionsObject.ignored),
+			...extraIgnored,
+			...DEFAULT_WATCH_IGNORES
+		]
+	};
+}
+function toArray(value) {
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function withRequestFileBuildPlugin(config, root) {
+	const configObject = isRecord(config) ? config : {};
+	const plugins = Array.isArray(configObject.plugins) ? configObject.plugins : configObject.plugins ? [configObject.plugins] : [];
+	return {
+		...configObject,
+		plugins: [requestFileBuildTransformPlugin(root), ...plugins]
+	};
+}
+function throwIfUserAddedNitro(plugins, nitroPluginsFromRouter) {
+	const routerNitroPluginSet = new Set(nitroPluginsFromRouter);
+	if (sortUserPlugins(plugins).flat().filter(Boolean).find((plugin) => typeof plugin.name === "string" && plugin.name.startsWith("nitro:") && !routerNitroPluginSet.has(plugin))) throw new Error("Markless Router wires Nitro internally. Remove nitro() from vite.config.ts and keep plugins: [markless(), router()].");
+}
+function isRecord(input) {
+	return typeof input === "object" && input !== null;
+}
+function resumeEntryState() {
+	return {
+		base: "/",
+		fileName: void 0
+	};
+}
+function routePreloadState() {
+	return {
+		base: "/",
+		root: ".",
+		routes: {
+			navigation: {},
+			ssr: {}
+		}
+	};
+}
+function routerClientInput(input, root) {
+	const resumeEntryId = scopedVirtualEntryId(RESUME_ENTRY_ID, root);
+	const navigationEntryId = scopedVirtualEntryId(NAVIGATION_ENTRY_ID, root);
+	if (input === void 0) return [resumeEntryId, navigationEntryId];
+	if (typeof input === "string" || Array.isArray(input)) return [
+		resumeEntryId,
+		navigationEntryId,
+		...Array.isArray(input) ? input : [input]
+	];
+	if (isRecord(input)) return {
+		...input,
+		"markless-router-resume": resumeEntryId,
+		"markless-router-navigation": navigationEntryId
+	};
+	return input;
+}
+function isVirtualEntryChunk(chunk, origin) {
+	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => id ? decodePath(parseURL(id).pathname).endsWith(origin) : false);
+}
+function virtualModulesPlugin(resumeEntry = resumeEntryState(), navigationEntry = resumeEntryState(), routePreloads = routePreloadState()) {
+	let root = "";
+	return {
+		name: "markless-router:routes",
+		configResolved(config) {
+			root = config.root;
+		},
+		resolveId: {
+			filter: { id: PUBLIC_VIRTUAL_MODULE_ID_RE },
+			handler(id) {
+				const baseId = virtualModuleBaseId(id);
+				if (baseId === SERVER_ENTRY_ID || baseId === RESUME_ENTRY_PATH_ID || baseId === NAVIGATION_ENTRY_PATH_ID || baseId === ROUTE_PRELOADS_ID || baseId === ROUTER_OPTIONS_ID) return `\0${baseId}${rootScopeQuery(root, id)}`;
+				const entryFile = virtualEntryFiles[baseId];
+				if (!entryFile) return;
+				return `${join(VIRTUAL_ENTRY_DIR, entryFile)}${rootScopeQuery(root, id)}`;
+			}
+		},
+		load(id) {
+			if (id.startsWith(`\0${SERVER_ENTRY_ID}`)) return serverEntrySource(root);
+			if (id.startsWith(`\0${RESUME_ENTRY_PATH_ID}`)) return entryPathSource("resumeEntryPath", resumeEntry, RESUME_ENTRY_ID, root);
+			if (id.startsWith(`\0${NAVIGATION_ENTRY_PATH_ID}`)) return entryPathSource("navigationEntryPath", navigationEntry, NAVIGATION_ENTRY_ID, root);
+			if (id.startsWith(`\0${ROUTE_PRELOADS_ID}`)) return routePreloadsSource(routePreloads);
+			if (id.startsWith(`\0${ROUTER_OPTIONS_ID}`)) return "export const routerMode = \"path\"; // retained for compat; hash paths are always first-class";
+		}
+	};
+}
+function entryPathSource(exportName, entry, entryId, root) {
+	const path = entry.fileName ? joinURL(entry.base, entry.fileName) : joinURL(entry.base, "@id", scopedVirtualEntryId(entryId, root));
+	return `export const ${exportName} = ${JSON.stringify(path)};`;
+}
+function serverEntrySource(root) {
+	const query = rootScopeQuery(root);
+	return [
+		`import { createServerEntry } from '@markless/router/vite/runtime/create-server-entry';`,
+		`import { resumeEntryPath } from '${RESUME_ENTRY_PATH_ID}${query}';`,
+		`import { navigationEntryPath } from '${NAVIGATION_ENTRY_PATH_ID}${query}';`,
+		`import { routeModulePreloads, routeSsrModulePreloads } from '${ROUTE_PRELOADS_ID}${query}';`,
+		`import { pageModuleLoaders, routeFileIds } from '${ROUTE_DISCOVERY_ID}${query}';`,
+		`const documentModuleLoaders = import.meta.glob(['/document.tsrx']);`,
+		`const entry = createServerEntry({`,
+		`  resumeEntryPath,`,
+		`  navigationEntryPath,`,
+		`  routeModulePreloads,`,
+		`  routeSsrModulePreloads,`,
+		`  documentModuleLoader: documentModuleLoaders['/document.tsrx'],`,
+		`  pageModuleLoaders,`,
+		`  routeFileIds,`,
+		`});`,
+		`export const fetch = entry.fetch;`,
+		`export default entry;`
+	].join("\n");
+}
+function rootScopeQuery(root, id = "") {
+	const query = stringifyQuery({
+		...parseQuery(parsePath(id).search),
+		"markless-router-root": root || "."
+	});
+	return query ? `?${query}` : "";
+}
+function routePreloadsSource(state) {
+	return [
+		`const routePreloadsJson = globalThis.__marklessRouterRoutePreloadsJson ?? ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)};`,
+		`const routePreloadData = routePreloadsJson === ${JSON.stringify(ROUTE_PRELOADS_PLACEHOLDER)} ? ${JSON.stringify(state.routes)} : JSON.parse(routePreloadsJson);`,
+		`export const routeModulePreloads = routePreloadData.navigation ?? {};`,
+		`export const routeSsrModulePreloads = routePreloadData.ssr ?? {};`,
+		`export function preloadRouteModule(file, document = globalThis.document) {`,
+		`  const hrefs = routeModulePreloads[file];`,
+		`  if (!hrefs?.length || !document?.head) return [];`,
+		`  const seen = new Set([...document.querySelectorAll('link[rel="modulepreload"]')].map((link) => link.getAttribute?.('href') || link.href).filter(Boolean));`,
+		`  const appended = [];`,
+		`  for (const href of hrefs) {`,
+		`    if (!href || seen.has(href)) continue;`,
+		`    const link = document.createElement('link');`,
+		`    link.rel = 'modulepreload';`,
+		`    link.href = href;`,
+		`    link.crossOrigin = 'anonymous';`,
+		`    document.head.appendChild(link);`,
+		`    seen.add(href);`,
+		`    appended.push(href);`,
+		`  }`,
+		`  return appended;`,
+		`}`
+	].join("\n");
+}
+function patchRoutePreloadsInBundle(bundle, routes) {
+	const replacement = jsStringLiteralContent(JSON.stringify(routes));
+	for (const chunk of outputChunks(bundle)) {
+		if (!chunk.code?.includes(ROUTE_PRELOADS_PLACEHOLDER)) continue;
+		chunk.code = chunk.code.replace(ROUTE_PRELOADS_PLACEHOLDER, replacement);
+	}
+}
+function jsStringLiteralContent(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("'", "\\'").replaceAll("`", "\\`").replaceAll("${", "\\${");
+}
+function routeModulePreloadsFromBundle(input) {
+	const chunks = outputChunks(input.bundle);
+	const chunksByFileName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+	const routeChunks = /* @__PURE__ */ new Map();
+	const routeChunkFileNames = /* @__PURE__ */ new Set();
+	for (const chunk of chunks) {
+		const routeFile = routeFileForChunk(input.root, chunk);
+		if (!routeFile) continue;
+		routeChunks.set(routeFile, chunk);
+		routeChunkFileNames.add(chunk.fileName);
+	}
+	const symbolChunks = symbolChunksBySourceFile(chunks);
+	const navigation = {};
+	const ssr = {};
+	for (const [routeFile, routeChunk] of routeChunks) {
+		const navigationFileNames = /* @__PURE__ */ new Set();
+		if (input.navigationChunk) {
+			includeChunk(navigationFileNames, chunksByFileName, input.navigationChunk.fileName);
+			for (const fileName of input.navigationChunk.dynamicImports) if (!routeChunkFileNames.has(fileName)) includeChunk(navigationFileNames, chunksByFileName, fileName);
+		}
+		includeChunk(navigationFileNames, chunksByFileName, routeChunk.fileName);
+		includeChunk(navigationFileNames, chunksByFileName, routeChunk.fileName, true);
+		if (input.navigationChunk) for (const fileName of routeScopedDynamicImports(input.navigationChunk, routeFile)) includeChunk(navigationFileNames, chunksByFileName, fileName, true);
+		const ssrFileNames = /* @__PURE__ */ new Set();
+		if (input.resumeChunk) {
+			includeChunk(ssrFileNames, chunksByFileName, input.resumeChunk.fileName);
+			for (const fileName of routeScopedDynamicImports(input.resumeChunk, routeFile)) includeChunk(ssrFileNames, chunksByFileName, fileName, true);
+		}
+		includeChunk(ssrFileNames, chunksByFileName, routeChunk.fileName, true);
+		const routeSourceFiles = sourceFilesForChunks(new Set([...navigationFileNames, ...ssrFileNames]), chunksByFileName);
+		for (const [sourceFile, symbolFileNames] of symbolChunks) {
+			if (!routeSourceFiles.has(sourceFile)) continue;
+			for (const fileName of symbolFileNames) {
+				includeChunk(navigationFileNames, chunksByFileName, fileName, true);
+				includeChunk(ssrFileNames, chunksByFileName, fileName, true);
+			}
+		}
+		navigation[routeFile] = [...navigationFileNames].map((fileName) => joinURL(input.base, fileName));
+		ssr[routeFile] = [...ssrFileNames].map((fileName) => joinURL(input.base, fileName));
+	}
+	return {
+		navigation,
+		ssr
+	};
+}
+function symbolChunksBySourceFile(chunks) {
+	const bySourceFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) for (const moduleId of chunk.moduleIds ?? []) {
+		const sourceFile = symbolVirtualModuleSourceFile(moduleId);
+		if (!sourceFile) continue;
+		const key = sourceModulePathname(sourceFile);
+		const fileNames = bySourceFile.get(key) ?? [];
+		if (!fileNames.includes(chunk.fileName)) fileNames.push(chunk.fileName);
+		bySourceFile.set(key, fileNames);
+	}
+	return bySourceFile;
+}
+function sourceFilesForChunks(fileNames, chunksByFileName) {
+	const sourceFiles = /* @__PURE__ */ new Set();
+	for (const fileName of fileNames) for (const moduleId of chunksByFileName.get(fileName)?.moduleIds ?? []) {
+		if (moduleId.startsWith("\0")) continue;
+		const pathname = sourceModulePathname(moduleId);
+		if (/\.(?:tsrx|mdx)$/.test(pathname)) sourceFiles.add(pathname);
+	}
+	return sourceFiles;
+}
+function sourceModulePathname(moduleId) {
+	return decodePath(parseURL(moduleId).pathname);
+}
+function includeChunk(fileNames, chunksByFileName, fileName, includeDynamic = false, visitedDynamic = /* @__PURE__ */ new Set()) {
+	if (!fileNames.has(fileName)) fileNames.add(fileName);
+	const chunk = chunksByFileName.get(fileName);
+	if (!chunk) return;
+	for (const imported of chunk.imports) includeChunk(fileNames, chunksByFileName, imported, includeDynamic, visitedDynamic);
+	for (const imported of codeStaticImports(chunk)) {
+		if (!chunksByFileName.has(imported)) continue;
+		includeChunk(fileNames, chunksByFileName, imported, includeDynamic, visitedDynamic);
+	}
+	if (!includeDynamic || visitedDynamic.has(fileName)) return;
+	visitedDynamic.add(fileName);
+	for (const imported of chunk.dynamicImports) includeChunk(fileNames, chunksByFileName, imported, true, visitedDynamic);
+	for (const imported of codeDynamicImports(chunk)) {
+		if (!chunksByFileName.has(imported)) continue;
+		includeChunk(fileNames, chunksByFileName, imported, true, visitedDynamic);
+	}
+}
+function routeScopedDynamicImports(chunk, routeFile) {
+	if (!chunk.code) return [];
+	const imports = /* @__PURE__ */ new Set();
+	const routeLiteralIndex = chunk.code.indexOf(routeFile);
+	if (routeLiteralIndex === -1) return [];
+	const nextRouteLiteralIndex = chunk.code.slice(routeLiteralIndex + routeFile.length).search(/["'`]\/?pages\/[^"'`]+\.(?:tsrx|mdx)["'`]/);
+	const routeBlockEnd = nextRouteLiteralIndex === -1 ? chunk.code.length : routeLiteralIndex + routeFile.length + nextRouteLiteralIndex;
+	const routeBlock = chunk.code.slice(routeLiteralIndex, routeBlockEnd);
+	for (const specifier of codeDynamicImportSpecifiers(routeBlock)) imports.add(normalize(join(dirname(chunk.fileName), specifier)));
+	return [...imports];
+}
+function codeStaticImports(chunk) {
+	return codeImportSpecifiers(chunk, /(?:import\s*(?:[^('"`]*?\bfrom\s*)?|export\s*[^('"`]*?\bfrom\s*)["'](\.\/[^"']+\.js)["']/g);
+}
+function codeDynamicImports(chunk) {
+	return codeDynamicImportSpecifiers(chunk.code ?? "").map((specifier) => normalize(join(dirname(chunk.fileName), specifier)));
+}
+function codeDynamicImportSpecifiers(code) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const match of code.matchAll(/import\(\s*["'`](\.\/[^"'`]+\.js)["'`]\s*\)/g)) {
+		const specifier = match[1];
+		if (specifier) imports.add(specifier);
+	}
+	return [...imports];
+}
+function codeImportSpecifiers(chunk, pattern) {
+	if (!chunk.code) return [];
+	const imports = /* @__PURE__ */ new Set();
+	for (const match of chunk.code.matchAll(pattern)) {
+		const specifier = match[1];
+		if (specifier) imports.add(normalize(join(dirname(chunk.fileName), specifier)));
+	}
+	return [...imports];
+}
+function outputChunks(bundle) {
+	return Object.values(bundle).filter((item) => {
+		return isRecord(item) && item.type === "chunk" && typeof item.fileName === "string" && Array.isArray(item.imports) && Array.isArray(item.dynamicImports);
+	});
+}
+function routeFileForChunk(root, chunk) {
+	for (const moduleId of [chunk.facadeModuleId, ...chunk.moduleIds ?? []]) {
+		const routeFile = routeFileForModuleId(root, moduleId);
+		if (routeFile) return routeFile;
+	}
+}
+function routeFileForModuleId(root, moduleId) {
+	if (!moduleId || moduleId.startsWith("\0")) return void 0;
+	const pathname = decodePath(parseURL(moduleId).pathname);
+	if (!isAbsolute(pathname)) return void 0;
+	const routeFile = withoutLeadingSlash(normalize(relative(root, pathname)));
+	return /(?:^|\/)pages\/.+\.(?:tsrx|mdx)$/.test(routeFile) ? routeFile : void 0;
+}
+function scopedVirtualEntryId(id, root) {
+	return `${virtualModuleBaseId(id)}${rootScopeQuery(root ?? ".", id)}`;
+}
+function virtualModuleBaseId(id) {
+	return parsePath(id).pathname;
+}
+function configRoot(config) {
+	const root = config.root;
+	return typeof root === "string" ? root : ".";
+}
+//#endregion
+export { router };