@markless/router 0.1.0

package/dist/typescript-plugin.js

@@ -0,0 +1,137 @@
+import { extname, isAbsolute, normalize, relative, resolve } from "pathe";
+//#region src/typescript-plugin/index.ts
+const PAGE_EXTENSIONS = new Set([".tsrx", ".mdx"]);
+function init(modules) {
+	const typeScript = modules.typescript;
+	return { create(info) {
+		(info.project.projectService?.logger)?.info("[markless-router] TypeScript plugin loaded");
+		const languageService = info.languageService;
+		const proxy = Object.create(null);
+		for (const key of Object.keys(languageService)) {
+			const value = languageService[key];
+			proxy[key] = typeof value === "function" ? value.bind(languageService) : value;
+		}
+		const pluginConfig = info.config ?? {};
+		const projectRoot = getProjectRoot(typeScript, info);
+		const pagesDir = resolvePagesDir(getConfiguredProjectRoot(info) ?? projectRoot, pluginConfig);
+		proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+			return withRouteHrefCompletions(typeScript, info, pagesDir, languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings));
+		};
+		return proxy;
+	} };
+}
+function withRouteHrefCompletions(typeScript, info, pagesDir, completions) {
+	const routeHrefs = routeHrefCompletions(typeScript, info, pagesDir);
+	if (routeHrefs.length === 0) return completions;
+	const baseCompletions = completions ?? emptyCompletionInfo();
+	const routeHrefSet = new Set(routeHrefs);
+	const routeEntries = routeHrefs.map((href) => ({
+		name: href,
+		kind: typeScript.ScriptElementKind.string,
+		kindModifiers: "",
+		sortText: `0 ${href}`
+	}));
+	return {
+		...baseCompletions,
+		entries: [...routeEntries, ...baseCompletions.entries.filter((entry) => !routeHrefSet.has(entry.name))]
+	};
+}
+function emptyCompletionInfo() {
+	return {
+		isGlobalCompletion: false,
+		isMemberCompletion: false,
+		isNewIdentifierLocation: false,
+		entries: []
+	};
+}
+function routeHrefCompletions(typeScript, info, pagesDir) {
+	const hrefs = /* @__PURE__ */ new Set();
+	for (const pageFileName of routeCompletionPageFileNames(typeScript, info, pagesDir)) {
+		const relativeFileId = relative(pagesDir, pageFileName);
+		if (!isRelativeInsidePath(relativeFileId)) continue;
+		if (!PAGE_EXTENSIONS.has(extname(relativeFileId))) continue;
+		const href = routeHrefCompletion(relativeFileId);
+		if (href) hrefs.add(href);
+	}
+	return Array.from(hrefs).toSorted();
+}
+function routeCompletionPageFileNames(typeScript, info, pagesDir) {
+	const fileNames = new Set(info.languageServiceHost.getScriptFileNames?.() ?? []);
+	for (const fileName of readPageFileNames(typeScript, pagesDir)) fileNames.add(fileName);
+	return [...fileNames];
+}
+function readPageFileNames(typeScript, pagesDir) {
+	if (typeScript.sys.directoryExists && !typeScript.sys.directoryExists(pagesDir)) return [];
+	try {
+		return typeScript.sys.readDirectory(pagesDir, Array.from(PAGE_EXTENSIONS), void 0, void 0);
+	} catch {
+		return [];
+	}
+}
+function routeHrefCompletion(fileId) {
+	if (isReservedOrUnsupportedPage(fileId)) return;
+	return routeFromFileId(fileId).pattern;
+}
+function isReservedOrUnsupportedPage(fileId) {
+	const extension = extname(fileId);
+	const routeFile = normalize(fileId.slice(0, -extension.length));
+	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
+	return segments[0] === "api" || segments.length === 1 && (segments[0] === "404" || segments[0] === "500");
+}
+function routeFromFileId(fileId) {
+	const extension = extname(fileId);
+	const routeFile = normalize(fileId.slice(0, -extension.length));
+	const segments = routeFile === "." ? [] : routeFile.split("/").filter(Boolean);
+	if (segments.at(-1) === "index") segments.pop();
+	const params = [];
+	const routeSegments = [];
+	for (const segment of segments) {
+		const catchAllName = bracketParamName(segment, "[...");
+		if (catchAllName) {
+			routeSegments.push(`[...${catchAllName}]`);
+			params.push(catchAllName);
+			continue;
+		}
+		const dynamicName = bracketParamName(segment, "[");
+		if (dynamicName) {
+			routeSegments.push(`[${dynamicName}]`);
+			params.push(dynamicName);
+			continue;
+		}
+		routeSegments.push(segment);
+	}
+	return {
+		pattern: routePathname(routeSegments),
+		params
+	};
+}
+function bracketParamName(segment, opening) {
+	if (!segment.startsWith(opening) || !segment.endsWith("]")) return;
+	const name = segment.slice(opening.length, -1);
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : void 0;
+}
+function routePathname(segments) {
+	if (segments.length === 0) return "/";
+	return `/${segments.join("/")}`;
+}
+function getProjectRoot(typeScript, info) {
+	return info.project.getCurrentDirectory() ?? info.languageServiceHost.getCurrentDirectory?.() ?? typeScript.sys.getCurrentDirectory();
+}
+function getConfiguredProjectRoot(info) {
+	const project = info.project;
+	try {
+		const configFilePath = project.getConfigFilePath?.();
+		return configFilePath ? configFilePath.slice(0, configFilePath.lastIndexOf("/")) : void 0;
+	} catch {
+		return;
+	}
+}
+function resolvePagesDir(projectRoot, config) {
+	const configured = config.pagesDir ?? "pages";
+	return isAbsolute(configured) ? configured : resolve(projectRoot, configured);
+}
+function isRelativeInsidePath(path) {
+	return path !== "" && path !== ".." && !path.startsWith("../") && !isAbsolute(path);
+}
+//#endregion
+export { init as default };

package/dist/vite/route-href.d.ts

@@ -0,0 +1,4 @@
+//#region src/vite/entries/route-href.d.ts
+declare function __marklessRouteHref(pattern: string, params: Readonly<Record<string, unknown>>): string;
+//#endregion
+export { __marklessRouteHref };

package/dist/vite/route-href.js

@@ -0,0 +1,18 @@
+//#region src/vite/entries/route-href.ts
+const routeParamPattern = /\[\.\.\.([A-Za-z_$][\w$]*)\]|\[([A-Za-z_$][\w$]*)\]/g;
+function __marklessRouteHref(pattern, params) {
+	return pattern.replace(routeParamPattern, (_match, catchAll, dynamic) => {
+		const name = catchAll || dynamic;
+		const value = params?.[name];
+		if (catchAll) return encodeCatchAllParam(pattern, value);
+		if (value === null || value === void 0) throw new Error(`Typed route error: ${pattern} requires params:\n- ${name}`);
+		return encodeURIComponent(String(value));
+	});
+}
+function encodeCatchAllParam(pattern, value) {
+	const segments = Array.isArray(value) ? value : value === null || value === void 0 ? [] : String(value).split("/");
+	if (segments.length === 0 || segments.some((segment) => String(segment) === "")) throw new Error(`Typed route error: ${pattern} requires a non-empty catch-all param.`);
+	return segments.map((segment) => encodeURIComponent(String(segment))).join("/");
+}
+//#endregion
+export { __marklessRouteHref };

package/dist/vite/runtime/create-route-discovery.d.ts

@@ -0,0 +1,8 @@
+//#region src/vite/runtime/create-route-discovery.d.ts
+interface RouteDiscovery {
+  readonly pageModuleLoaders: Record<string, () => Promise<unknown>>;
+  readonly routeFileIds: readonly string[];
+}
+declare function createRouteDiscovery(discoveredPageModuleLoaders: Record<string, () => Promise<unknown>>): RouteDiscovery;
+//#endregion
+export { RouteDiscovery, createRouteDiscovery };

package/dist/vite/runtime/create-route-discovery.js

@@ -0,0 +1,11 @@
+import { i as normalizeRouteFileId } from "../../route-manifest-OTaWQ_TC.js";
+//#region src/vite/runtime/create-route-discovery.ts
+function createRouteDiscovery(discoveredPageModuleLoaders) {
+	const pageModuleLoaders = Object.fromEntries(Object.entries(discoveredPageModuleLoaders).map(([file, loader]) => [normalizeRouteFileId(file), loader]));
+	return {
+		pageModuleLoaders,
+		routeFileIds: Object.keys(pageModuleLoaders)
+	};
+}
+//#endregion
+export { createRouteDiscovery };

package/dist/vite/runtime/create-server-entry.d.ts

@@ -0,0 +1,18 @@
+import { ModulePreloadInput } from "@markless/web/render-to-string";
+
+//#region src/vite/runtime/create-server-entry.d.ts
+interface ServerEntryOptions {
+  readonly navigationEntryPath?: string;
+  readonly resumeEntryPath?: string;
+  readonly routeModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
+  readonly routeSsrModulePreloads?: Record<string, readonly ModulePreloadInput[]>;
+  readonly documentModuleLoader: (() => Promise<unknown>) | undefined;
+  readonly pageModuleLoaders: Record<string, () => Promise<unknown>>;
+  readonly routeFileIds: readonly string[];
+  readonly render?: 'streaming' | 'blocking';
+}
+declare function createServerEntry(options: ServerEntryOptions): {
+  fetch: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { ServerEntryOptions, createServerEntry };

package/dist/vite/runtime/create-server-entry.js

@@ -0,0 +1,297 @@
+import { n as matchRouteManifest, t as buildRouteManifestFromFileIds } from "../../route-manifest-OTaWQ_TC.js";
+import { renderToString } from "@markless/web/render-to-string";
+import { renderToStream } from "@markless/web/render-to-stream";
+//#region src/vite/runtime/create-server-entry.ts
+const DOCUMENT_CHILDREN_PLACEHOLDER = "__markless_router_document_children__";
+function createServerEntry(options) {
+	const manifest = buildRouteManifestFromFileIds(options.routeFileIds);
+	async function fetch(request) {
+		const url = new URL(request.url);
+		if (isNitroApiPathname(url.pathname)) return new Response("Not found", { status: 404 });
+		const match = matchRouteManifest(url.pathname, manifest);
+		if (!match) return renderStatusPage(url, manifest.statusPages.notFound, 404, "Not found");
+		try {
+			return await renderPage(url, match.route.file, match.params, 200);
+		} catch (error) {
+			console.error("[markless-router] page render failed:", error);
+			return renderStatusPage(url, manifest.statusPages.error, 500, "Internal Server Error");
+		}
+	}
+	async function renderStatusPage(url, file, status, fallbackText) {
+		if (!file) return new Response(fallbackText, { status });
+		return renderPage(url, file, {}, status);
+	}
+	async function renderPage(url, file, params, status) {
+		const loadPageModule = options.pageModuleLoaders[file];
+		if (!loadPageModule) return new Response(`Page module not found: ${file}`, { status: 500 });
+		const pageModule = await loadPageModule();
+		const pageProps = {
+			params,
+			url: {
+				href: url.href,
+				pathname: url.pathname,
+				search: url.search
+			},
+			status
+		};
+		const documentModule = options.documentModuleLoader ? await options.documentModuleLoader() : void 0;
+		const headers = { "content-type": "text/html;charset=utf-8" };
+		const baseArtifact = pageModule.default;
+		const renderSsr = baseArtifact?.renderSsr ?? pageModule.marklessRenderSsr;
+		if (!renderSsr) {
+			const shell = await renderDocumentShell(documentModule, pageProps, "");
+			const message = `Page module must export an Markless compiled artifact: ${escapeHtml(file)}`;
+			return new Response(fillDocumentChildren(shell, message), {
+				status,
+				headers
+			});
+		}
+		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath);
+		const renderOptions = {
+			props: pageProps,
+			resumeModuleUrl: options.resumeEntryPath ?? baseArtifact?.resumeModuleUrl,
+			modulePreloads: (html) => modulePreloadsForPage(file, html, pageProps.url.href, manifest, options.routeModulePreloads, options.routeSsrModulePreloads)
+		};
+		if (options.render === "blocking") {
+			const pageHtml = splitLeadingModulePreloadLinks(await renderToString(pageArtifact, renderOptions));
+			const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
+			return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
+				status,
+				headers
+			});
+		}
+		const stream = await renderToStream(pageArtifact, renderOptions);
+		const pageHtml = splitLeadingModulePreloadLinks(stream.shell);
+		const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml);
+		if (stream.pendingArmCount === 0) return new Response(fillDocumentChildren(shell, pageHtml.bodyHtml), {
+			status,
+			headers
+		});
+		const placeholderAt = shell.indexOf(DOCUMENT_CHILDREN_PLACEHOLDER);
+		const prefix = placeholderAt === -1 ? shell : shell.slice(0, placeholderAt) + pageHtml.bodyHtml;
+		const suffix = placeholderAt === -1 ? "" : shell.slice(placeholderAt + 37);
+		const encoder = new TextEncoder();
+		const body = new ReadableStream({ async start(controller) {
+			controller.enqueue(encoder.encode(prefix));
+			try {
+				for await (const chunk of stream.appends()) controller.enqueue(encoder.encode(chunk));
+			} catch (error) {
+				console.error("[markless-router] streaming settle failed:", error);
+				controller.error(error);
+				return;
+			}
+			controller.enqueue(encoder.encode(suffix));
+			controller.close();
+		} });
+		return new Response(body, {
+			status,
+			headers
+		});
+	}
+	return { fetch };
+}
+function routedPageArtifact(renderSsr, baseArtifact, pageProps, file, navigationEntryPath) {
+	return {
+		resumeModuleUrl: baseArtifact?.resumeModuleUrl,
+		async renderSsr(renderProps, renderContext) {
+			const output = await renderSsr(renderProps ?? pageProps, renderContext);
+			if (!output) return { html: "" };
+			const routeScript = output.state || output.view ? renderRouteScript(file) : "";
+			const linkBridge = navigationEntryPath ? renderLinkBridgeScript(navigationEntryPath) : "";
+			const stateWithProps = withPagePropsCell(output.state, pageProps);
+			return routeScript || linkBridge || stateWithProps !== output.state ? {
+				...output,
+				state: stateWithProps,
+				html: `${output.html}${routeScript}${linkBridge}`
+			} : output;
+		}
+	};
+}
+function withPagePropsCell(state, props) {
+	if (!state || typeof state !== "object") return state;
+	const cells = state.cells;
+	if (!Array.isArray(cells) || cells.some((cell) => cell?.graphNodeId === "prop:props")) return state;
+	return {
+		...state,
+		cells: [...cells, {
+			graphNodeId: "prop:props",
+			name: "props",
+			valueKind: "object",
+			directValue: props
+		}]
+	};
+}
+function modulePreloadsForPage(file, html, baseHref, manifest, routeModulePreloads, routeSsrModulePreloads) {
+	const preloads = [];
+	const seen = /* @__PURE__ */ new Set();
+	addModulePreloads(preloads, seen, routeSsrModulePreloads?.[file]);
+	if (!routeModulePreloads || !html.includes("data-markless-router-link")) return preloads.length > 0 ? preloads : void 0;
+	for (const href of routerLinkHrefs(html)) {
+		const url = parseSameOriginUrl(href, baseHref);
+		const match = url && matchRouteManifest(url.pathname, manifest);
+		addModulePreloads(preloads, seen, match && routeModulePreloads[match.route.file]);
+	}
+	return preloads.length > 0 ? preloads : void 0;
+}
+function routerLinkHrefs(html) {
+	return [...html.matchAll(/<a\b(?=[^>]*\bdata-markless-router-link(?:[\s=>]|$))(?=[^>]*\bhref="([^"]*)")[^>]*>/g)].map((match) => unescapeHtmlAttribute(match[1] ?? ""));
+}
+function parseSameOriginUrl(href, base) {
+	try {
+		const current = new URL(base);
+		const url = new URL(href, current);
+		return url.origin === current.origin ? url : void 0;
+	} catch {
+		return;
+	}
+}
+function unescapeHtmlAttribute(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+function addModulePreloads(preloads, seen, items) {
+	for (const preload of items ?? []) {
+		const preloadHref = typeof preload === "string" ? preload : preload.href;
+		if (!preloadHref || seen.has(preloadHref)) continue;
+		seen.add(preloadHref);
+		preloads.push(preload);
+	}
+}
+function splitLeadingModulePreloadLinks(html) {
+	let bodyHtml = html;
+	const links = [];
+	while (bodyHtml.startsWith("<link ")) {
+		const end = bodyHtml.indexOf(">");
+		if (end === -1) break;
+		const link = bodyHtml.slice(0, end + 1);
+		if (!link.includes("rel=\"modulepreload\"")) break;
+		links.push(link);
+		bodyHtml = bodyHtml.slice(end + 1);
+	}
+	return {
+		bodyHtml,
+		headHtml: links.join("")
+	};
+}
+async function renderDocumentShell(documentModule, pageProps, headHtml) {
+	const attributes = htmlAttributes(documentModule, pageProps);
+	const documentHtml = await renderDocumentModule(documentModule, {
+		...pageProps,
+		children: DOCUMENT_CHILDREN_PLACEHOLDER
+	});
+	if (documentHtml !== void 0) return [
+		"<!doctype html>",
+		`<html${renderAttributes(attributes)}>`,
+		insertHeadHtml(documentHtml, headHtml),
+		"</html>"
+	].join("");
+	return [
+		"<!doctype html>",
+		`<html${renderAttributes(attributes)}>`,
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
+		headHtml,
+		"</head>",
+		"<body>",
+		DOCUMENT_CHILDREN_PLACEHOLDER,
+		"</body>",
+		"</html>"
+	].join("");
+}
+function fillDocumentChildren(documentShell, children) {
+	const at = documentShell.indexOf(DOCUMENT_CHILDREN_PLACEHOLDER);
+	if (at === -1) return documentShell;
+	return documentShell.slice(0, at) + children + documentShell.slice(at + 37);
+}
+async function renderDocumentModule(documentModule, props) {
+	return (await documentModule?.default?.renderSsr?.(props))?.html;
+}
+function insertHeadHtml(documentHtml, headHtml) {
+	if (!headHtml) return documentHtml;
+	const headEnd = documentHtml.indexOf("</head>");
+	if (headEnd === -1) return `${headHtml}${documentHtml}`;
+	return `${documentHtml.slice(0, headEnd)}${headHtml}${documentHtml.slice(headEnd)}`;
+}
+function renderRouteScript(file) {
+	return `<script type="@markless/core/route">${escapeScriptJson({ file })}<\/script>`;
+}
+function renderLinkBridgeScript(resumeEntryPath) {
+	return `<script data-markless-router-link-resumer>${escapeInlineScript(`(() => {
+	const d = document;
+	const s = d.currentScript;
+	const r = s && s.closest('[data-async-container]');
+	if (!r || r.__marklessRouterLinkResumerStarted) return;
+	r.__marklessRouterLinkResumerStarted = true;
+	const linkAttr = 'data-markless-router-link';
+	const replaceAttr = 'data-markless-router-replace';
+	const scrollAttr = 'data-markless-router-scroll';
+	const anchorFrom = (event) => {
+		const target = event.composedPath && event.composedPath()[0] || event.target;
+		return target && target.closest ? target.closest('a[href]') : target && target.parentElement && target.parentElement.closest ? target.parentElement.closest('a[href]') : null;
+	};
+	const sameOrigin = (href) => {
+		try {
+			const url = new URL(href, location.href);
+			return url.origin === location.origin ? url : null;
+		} catch {
+			return null;
+		}
+	};
+	if (location.hash && location.hash.startsWith('#/')) {
+		import(${JSON.stringify(resumeEntryPath)}).catch(() => {});
+	}
+	r.addEventListener('click', async (event) => {
+		if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) return;
+		const anchor = anchorFrom(event);
+		if (!anchor || !anchor.hasAttribute(linkAttr) || anchor.hasAttribute('download')) return;
+		const target = anchor.getAttribute('target');
+		if (target && target !== '_self') return;
+		if (anchor.relList && anchor.relList.contains('external')) return;
+		const url = sameOrigin(anchor.href);
+		if (!url) return;
+		event.preventDefault();
+		try {
+			const mod = await import(${JSON.stringify(resumeEntryPath)});
+			const navigate = mod.navigateMarklessRouterLink;
+			if (typeof navigate === 'function') {
+				await navigate({
+					href: url.href,
+					replace: anchor.hasAttribute(replaceAttr),
+					scroll: anchor.getAttribute(scrollAttr) === 'manual' ? 'manual' : undefined,
+				});
+			} else {
+				location.assign(url.href);
+			}
+		} catch (error) {
+			setTimeout(() => { throw error; });
+			location.assign(url.href);
+		}
+	}, true);
+})();`)}<\/script>`;
+}
+function htmlAttributes(documentModule, pageProps) {
+	const attributes = documentModule?.__marklessRouterHtmlAttributes?.(pageProps) ?? { lang: "en" };
+	const normalized = {};
+	for (const [name, value] of Object.entries(attributes)) {
+		if (value === false || value === null || value === void 0) continue;
+		normalized[name] = String(value);
+	}
+	return normalized;
+}
+function renderAttributes(attributes) {
+	return Object.entries(attributes).map(([name, value]) => ` ${name}="${escapeHtml(value)}"`).join("");
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+function escapeScriptJson(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c");
+}
+function escapeInlineScript(value) {
+	return value.replace(/<\/script/gi, "<\\/script");
+}
+function isNitroApiPathname(pathname) {
+	return pathname === "/api" || pathname.startsWith("/api/");
+}
+//#endregion
+export { createServerEntry };

package/dist/vite/runtime/mdx-route.d.ts

@@ -0,0 +1,68 @@
+//#region src/vite/runtime/mdx-route.d.ts
+type MdxRoutePart = {
+  readonly kind: 'html';
+  readonly elementCount: number;
+} | {
+  readonly kind: 'component';
+  readonly componentIndex: number;
+};
+type MdxRenderOutput = {
+  readonly html?: string;
+  readonly root?: ChildNode;
+  readonly state?: MdxStatePayload;
+  readonly view?: MdxViewPayload;
+  readonly loadSymbol?: (symbolId: string) => unknown;
+  readonly connectRuntime?: (context: unknown) => unknown;
+};
+type MdxChild = {
+  readonly componentIndex: number;
+  readonly hostPrefix: string;
+  readonly symbolPrefix: string;
+  readonly output?: MdxRenderOutput;
+};
+type MdxComponentArtifact = {
+  readonly renderSsr?: (props?: unknown) => MdxRenderOutput | Promise<MdxRenderOutput>;
+  readonly renderCsr?: (props?: unknown) => MdxRenderOutput | Promise<MdxRenderOutput>;
+};
+type MdxSymbolLoader = {
+  readonly prefix: string;
+  readonly loadSymbol: (symbolId: string) => unknown;
+};
+type MdxStatePayload = {
+  readonly version: unknown;
+  readonly cells?: readonly unknown[];
+  readonly computed?: readonly unknown[];
+  readonly sharedDefinitions?: readonly unknown[];
+};
+type MdxLocator = {
+  readonly hostNodeId: string;
+  readonly index: number;
+  readonly [key: string]: unknown;
+};
+type MdxEventRecord = {
+  readonly hostNodeId: string;
+  readonly symbolIds: readonly string[];
+  readonly [key: string]: unknown;
+};
+type MdxSymbolRecord = {
+  readonly hostNodeId: string;
+  readonly symbolId?: string;
+  readonly [key: string]: unknown;
+};
+type MdxViewPayload = {
+  readonly version: unknown;
+  readonly locators?: readonly MdxLocator[];
+  readonly events?: readonly MdxEventRecord[];
+  readonly domUpdates?: readonly MdxSymbolRecord[];
+  readonly behaviors?: readonly MdxSymbolRecord[];
+  readonly elementHandles?: readonly MdxSymbolRecord[];
+  readonly asyncBoundaries?: readonly unknown[];
+};
+declare function renderMdxChild(children: MdxChild[], component: MdxComponentArtifact, props: unknown, child: Omit<MdxChild, 'output'>): Promise<string>;
+declare function rootFromMdxHtml(html: string): Element;
+declare function replaceMdxChild(root: ParentNode, index: number, child: ChildNode | undefined): void;
+declare function composeMdxState(children: readonly MdxChild[]): MdxStatePayload | undefined;
+declare function composeMdxView(parts: readonly MdxRoutePart[], children: readonly MdxChild[], initialElementOffset: number): MdxViewPayload | undefined;
+declare function loadMdxSymbol(symbolId: string, children: readonly MdxChild[], loaders: readonly MdxSymbolLoader[]): unknown;
+//#endregion
+export { MdxChild, MdxComponentArtifact, MdxRenderOutput, MdxRoutePart, MdxSymbolLoader, composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml };

package/dist/vite/runtime/mdx-route.js

@@ -0,0 +1,113 @@
+//#region src/vite/runtime/mdx-route.ts
+async function renderMdxChild(children, component, props, child) {
+	const output = await component.renderSsr?.(props);
+	if (output) children.push({
+		...child,
+		output
+	});
+	return output?.html ?? "";
+}
+function rootFromMdxHtml(html) {
+	const template = document.createElement("template");
+	template.innerHTML = html;
+	const root = template.content.firstElementChild;
+	if (!root) throw new Error("Markless Router MDX render did not produce a root element.");
+	return root;
+}
+function replaceMdxChild(root, index, child) {
+	const placeholder = root.querySelector?.(`[data-markless-mdx-child="${index}"]`);
+	if (placeholder && child) {
+		placeholder.replaceWith(child);
+		return;
+	}
+	placeholder?.remove();
+}
+function composeMdxState(children) {
+	const childStates = children.map((child) => child.output?.state).filter(isDefined);
+	if (childStates.length === 0) return;
+	return {
+		version: childStates[0].version,
+		cells: childStates.flatMap((state) => state.cells ?? []),
+		computed: childStates.flatMap((state) => state.computed ?? []),
+		...childStates.some((state) => state.sharedDefinitions?.length) ? { sharedDefinitions: childStates.flatMap((state) => state.sharedDefinitions ?? []) } : {}
+	};
+}
+function composeMdxView(parts, children, initialElementOffset) {
+	const childViews = children.map((child) => ({
+		...child,
+		view: child.output?.view,
+		hostCount: child.output?.view?.locators?.length ?? 0
+	})).filter((child) => Boolean(child.view));
+	if (childViews.length === 0) return;
+	const childByIndex = new Map(childViews.map((child) => [child.componentIndex, child]));
+	const locators = [];
+	const events = [];
+	const domUpdates = [];
+	const behaviors = [];
+	const elementHandles = [];
+	let elementOffset = initialElementOffset;
+	for (const part of parts) {
+		if (part.kind === "html") {
+			elementOffset += part.elementCount;
+			continue;
+		}
+		const child = childByIndex.get(part.componentIndex);
+		if (!child) continue;
+		appendMdxChildView({
+			child,
+			elementOffset,
+			locators,
+			events,
+			domUpdates,
+			behaviors,
+			elementHandles
+		});
+		elementOffset += child.hostCount;
+	}
+	locators.sort((a, b) => a.index - b.index);
+	return {
+		version: childViews[0].view.version,
+		locators,
+		events,
+		domUpdates,
+		behaviors,
+		elementHandles,
+		asyncBoundaries: []
+	};
+}
+function loadMdxSymbol(symbolId, children, loaders) {
+	for (const child of children) if (symbolId.startsWith(child.symbolPrefix) && child.output?.loadSymbol) return child.output.loadSymbol(symbolId.slice(child.symbolPrefix.length));
+	for (const loader of loaders) if (symbolId.startsWith(loader.prefix)) return loader.loadSymbol(symbolId);
+	return Promise.reject(/* @__PURE__ */ new Error(`Unknown Markless MDX symbol ${symbolId}`));
+}
+function appendMdxChildView(context) {
+	const childView = context.child.view;
+	for (const locator of childView.locators ?? []) context.locators.push({
+		...locator,
+		hostNodeId: context.child.hostPrefix + locator.hostNodeId,
+		index: context.elementOffset + locator.index
+	});
+	for (const event of childView.events ?? []) context.events.push({
+		...event,
+		hostNodeId: context.child.hostPrefix + event.hostNodeId,
+		symbolIds: event.symbolIds.map((symbolId) => context.child.symbolPrefix + symbolId)
+	});
+	for (const update of childView.domUpdates ?? []) context.domUpdates.push(prefixMdxSymbolRecord(update, context.child));
+	for (const behavior of childView.behaviors ?? []) context.behaviors.push(prefixMdxSymbolRecord(behavior, context.child));
+	for (const handle of childView.elementHandles ?? []) context.elementHandles.push({
+		...handle,
+		hostNodeId: context.child.hostPrefix + handle.hostNodeId
+	});
+}
+function prefixMdxSymbolRecord(record, child) {
+	return {
+		...record,
+		hostNodeId: child.hostPrefix + record.hostNodeId,
+		...record.symbolId ? { symbolId: child.symbolPrefix + record.symbolId } : {}
+	};
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+//#endregion
+export { composeMdxState, composeMdxView, loadMdxSymbol, renderMdxChild, replaceMdxChild, rootFromMdxHtml };