@markless/router 0.5.0 → 0.7.0

package/dist/create-server-entry-yboa-2m6.js

@@ -0,0 +1,1333 @@
+import { a as ROUTE_SCRIPT_TYPE, c as servedHtmlAttributesScript, d as REPLACE_ATTRIBUTE, f as SCROLL_ATTRIBUTE, i as HTML_ATTRIBUTES_SLOT, l as LINK_ATTRIBUTE, n as requestLocals, o as SERVED_HTML_ATTRIBUTES_PROPERTY, r as takeMiddlewareHeaders, u as PREFETCH_ATTRIBUTE } from "./request-locals-BDAhNpEa.js";
+import { i as matchRouteManifest, n as buildRouteManifestFromFileIds, o as normalizeRouteFileId } from "./route-manifest-DMizh42B.js";
+import { n as __marklessDebugBootstrapSource } from "./debug-channel-Di6SppZv.js";
+import { CONTAINER_ATTRIBUTE, PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE } from "@markless/web/fns/container-region";
+import { CONTAINER_RETIRE_PROPERTY, renderToString, splitSsrContainer } from "@markless/web/render-to-string";
+import { STREAMED_ARM_SELECTOR, STREAM_ARM_EXECUTOR_GLOBAL, renderToStream } from "@markless/web/render-to-stream";
+import { normalizeMarklessDevError, renderMarklessDevErrorDocument } from "@markless/bundler/dev-error";
+//#region src/vite/link-intent.ts
+function listenForLinkIntent(root, linkAttribute, preload, prefetchAttribute) {
+	const listener = (event) => {
+		if (event.defaultPrevented) return;
+		const target = event.composedPath()[0] ?? event.target;
+		const anchor = (target instanceof Element ? target : target?.parentElement)?.closest("a[href]");
+		if (!anchor?.hasAttribute(linkAttribute) || anchor.hasAttribute("download")) return;
+		if (prefetchAttribute && anchor.getAttribute(prefetchAttribute) === "none") return;
+		if (anchor.target && anchor.target !== "_self") return;
+		if (anchor.relList.contains("external")) return;
+		const url = new URL(anchor.href, anchor.ownerDocument.baseURI);
+		if (url.origin !== new URL(anchor.ownerDocument.URL).origin) return;
+		preload(url);
+	};
+	const events = [
+		"pointerover",
+		"focusin",
+		"pointerdown"
+	];
+	for (const event of events) root.addEventListener(event, listener, { passive: true });
+	return () => {
+		for (const event of events) root.removeEventListener(event, listener);
+	};
+}
+function appendModulePreloads(document, items) {
+	if (!document?.head || !items?.length) return [];
+	const absolute = (href) => new URL(href, document.baseURI).href;
+	const seen = new Set([...document.querySelectorAll("link[rel=\"modulepreload\"]")].map((link) => absolute(link.getAttribute("href") || link.href)));
+	const appended = [];
+	for (const item of items) {
+		const href = typeof item === "string" ? item : item.href;
+		if (!href || seen.has(absolute(href))) continue;
+		const link = document.createElement("link");
+		link.rel = "modulepreload";
+		link.href = href;
+		link.crossOrigin = typeof item === "string" ? "anonymous" : item.crossOrigin ?? "anonymous";
+		if (typeof item !== "string" && item.fetchPriority) link.fetchPriority = item.fetchPriority;
+		document.head.appendChild(link);
+		seen.add(absolute(href));
+		appended.push(href);
+	}
+	return appended;
+}
+//#endregion
+//#region src/vite/fragment-navigation.ts
+function startFragmentNavigation(d, linkAttributeOf, routes, importModule, loadRun, intentOf) {
+	const w = d.defaultView;
+	if (!w) return;
+	const host = d;
+	const known = host.__marklessFragmentNav?.routes ?? host.__marklessFragmentWake;
+	if (known) return void Object.assign(known, routes);
+	host.__marklessFragmentWake = routes;
+	const scrolled = /* @__PURE__ */ new Set();
+	const arriving = /* @__PURE__ */ new Map();
+	let running;
+	let starting;
+	let pressed;
+	const preload = (item) => {
+		const href = new URL(typeof item === "string" ? item : item.href, d.baseURI).href;
+		if (arriving.has(href)) return;
+		const link = d.createElement("link");
+		link.rel = "modulepreload";
+		link.href = href;
+		link.crossOrigin = "anonymous";
+		arriving.set(href, new Promise((done) => link.onload = link.onerror = done));
+		d.head.appendChild(link);
+	};
+	const anchorOf = (event) => {
+		const target = event.composedPath()[0] ?? event.target;
+		return (target.nodeType === 1 ? target : target.parentElement)?.closest("a[href]");
+	};
+	const followed = (anchor) => {
+		if (anchor.hasAttribute("download") || anchor.relList.contains("external")) return;
+		if (anchor.target && anchor.target !== "_self") return;
+		const url = new URL(anchor.href, d.baseURI);
+		return url.origin === w.location.origin ? url : void 0;
+	};
+	const here = (url) => url.pathname + url.search === w.location.pathname + w.location.search;
+	const press = (anchor) => {
+		const intent = intentOf();
+		if (!intent || pressed || anchor.getAttribute(intent.prefetchAttribute) === "none") return;
+		const url = followed(anchor);
+		const code = url && routes[url.pathname];
+		if (!code || here(url)) return;
+		const target = new URL(url.href);
+		target.hash = "";
+		target.pathname = intent.requestPrefix + target.pathname;
+		const controller = new AbortController();
+		const response = w.fetch(target.href, {
+			credentials: "same-origin",
+			headers: { purpose: "prefetch" },
+			signal: controller.signal
+		});
+		response.catch(() => {});
+		for (const item of [...intent.code, ...code]) preload(item);
+		pressed = {
+			url: url.href,
+			at: w.performance.now(),
+			controller,
+			response
+		};
+	};
+	const wake = (event) => {
+		starting ??= loadRun().then((run) => {
+			delete host.__marklessFragmentWake;
+			return running = run(d, routes, importModule, scrolled, arriving, pressed);
+		});
+		starting.then((api) => api.replay(event), () => starting = void 0);
+		return starting;
+	};
+	let rest = 0;
+	let at = "";
+	const listen = (event) => {
+		const target = event.composedPath()[0] ?? event.target;
+		if (event.type === "pointermove") {
+			const pointer = event;
+			w.clearTimeout(rest);
+			if (at === (at = `${pointer.clientX},${pointer.clientY}`)) return;
+			const anchor = !running && pointer.pointerType === "mouse" && anchorOf(event);
+			const dwell = anchor && intentOf()?.hoverDwellMs;
+			if (dwell) rest = w.setTimeout(() => running || press(anchor), dwell);
+		} else if (event.type === "scroll") {
+			if (target !== d) scrolled.add(target);
+		} else if (event.type === "popstate") wake().then((api) => api.traverse(event));
+		else if (!running) {
+			const anchor = anchorOf(event);
+			if (!anchor) return;
+			if (event.type !== "click") {
+				if (event.type !== "pointerover") press(anchor);
+				wake(event);
+			} else if (anchor.hasAttribute(linkAttributeOf())) early(event);
+			else d.addEventListener("click", (later) => later === event && early(later), { once: true });
+		}
+	};
+	for (const type of [
+		"pointermove",
+		"scroll",
+		"pointerover",
+		"pointerdown",
+		"touchstart",
+		"focusin",
+		"popstate"
+	]) w.addEventListener(type, listen, {
+		capture: true,
+		passive: true
+	});
+	w.addEventListener("click", listen, true);
+	const early = (event) => {
+		const mouse = event;
+		if (running || mouse.defaultPrevented || mouse.button !== 0) return;
+		if (mouse.metaKey || mouse.altKey || mouse.ctrlKey || mouse.shiftKey) return;
+		const anchor = anchorOf(event);
+		const url = followed(anchor);
+		if (!url || url.hash.startsWith("#/") || url.hash && here(url)) return;
+		event.preventDefault();
+		wake().then((api) => api.go(anchor) || w.location.assign(url.href), () => w.location.assign(url.href));
+	};
+	if (Object.keys(routes).length) {
+		const idle = () => w.requestIdleCallback ? w.requestIdleCallback(() => wake(), { timeout: 3e3 }) : w.setTimeout(() => wake(), 500);
+		if (d.readyState === "complete") idle();
+		else w.addEventListener("load", idle, { once: true });
+	}
+}
+function runFragmentNavigation(d, config, routes, importModule, scrolled, arriving, early) {
+	const w = d.defaultView;
+	const host = d;
+	const location = w.location;
+	const connection = w.navigator.connection;
+	const pageKey = (url) => url.pathname + url.search;
+	let module;
+	let loaded;
+	const load = () => {
+		if (!module) {
+			module = importModule(config.entry);
+			module.then((entry) => loaded = entry, () => module = void 0);
+		}
+		return module;
+	};
+	const underEndpoints = (pathname) => config.endpointPrefixes.some((prefix) => (pathname + "/").startsWith(prefix + "/"));
+	const pages = config.pages.map((page) => [underEndpoints(page), page.split("/").filter(Boolean)]);
+	const isPage = (pathname) => {
+		const endpoint = underEndpoints(pathname);
+		const parts = pathname.split("/").filter(Boolean);
+		return pages.some(([under, page]) => {
+			if (endpoint && !under) return false;
+			const rest = page.indexOf("**");
+			if (rest === -1 ? page.length !== parts.length : parts.length <= rest) return false;
+			return page.every((segment, index) => segment === "**" || segment === ":" || segment === parts[index]);
+		});
+	};
+	const eligible = (anchor, forClick = false) => {
+		if (!anchor || anchor.localName !== "a") return;
+		const link = anchor;
+		if (link.hasAttribute("download") || link.relList.contains("external")) return;
+		if (link.target && link.target !== "_self") return;
+		if (!forClick && link.getAttribute(config.prefetchAttribute) === "none") return;
+		let url;
+		try {
+			url = new URL(link.href, d.baseURI);
+		} catch {
+			return;
+		}
+		if (url.origin !== location.origin || url.hash.startsWith("#/")) return;
+		if (!isPage(url.pathname)) return;
+		const here = forClick ? pageKey(new URL(location.href)) : state.shown;
+		if (pageKey(url) === here && (!forClick || url.href.includes("#"))) return;
+		return url;
+	};
+	const anchorOf = (event) => {
+		const target = event.composedPath?.()[0] ?? event.target;
+		return (target && target.nodeType === 1 ? target : target?.parentElement)?.closest("a[href]");
+	};
+	const preloadCode = (url, low) => {
+		const present = new Set([...d.querySelectorAll("link[rel=\"modulepreload\"]")].map((link) => link.href));
+		for (const item of [
+			config.entry,
+			...config.entryImports,
+			...state.routes[url.pathname] ?? []
+		]) {
+			const entry = typeof item === "string" ? { href: item } : item;
+			const href = new URL(entry.href, d.baseURI).href;
+			if (present.has(href) || arriving.has(href)) continue;
+			present.add(href);
+			const link = d.createElement("link");
+			link.rel = "modulepreload";
+			link.href = href;
+			link.crossOrigin = entry.crossOrigin ?? "anonymous";
+			if (low) link.fetchPriority = "low";
+			arriving.set(href, new Promise((done) => {
+				link.addEventListener("load", done, { once: true });
+				link.addEventListener("error", done, { once: true });
+			}));
+			d.head.appendChild(link);
+		}
+	};
+	const parse = (url, text) => {
+		const at = text.indexOf(config.regionEndMarker);
+		const prefix = at === -1 ? text : text.slice(0, at);
+		return {
+			url,
+			prefix,
+			doc: new DOMParser().parseFromString(prefix, "text/html"),
+			tail: at === -1 ? "" : text.slice(at + config.regionEndMarker.length)
+		};
+	};
+	const drain = (reader, closed) => {
+		const chunks = [];
+		let ended = false;
+		let wake = () => {};
+		const end = () => {
+			ended = true;
+			closed();
+			wake();
+		};
+		(async () => {
+			for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+				chunks.push(chunk.value);
+				wake();
+			}
+		})().then(end, end);
+		return {
+			read: async () => {
+				while (!chunks.length && !ended) await new Promise((done) => wake = done);
+				return chunks.length ? {
+					done: false,
+					value: chunks.shift()
+				} : {
+					done: true,
+					value: void 0
+				};
+			},
+			cancel: () => reader.cancel()
+		};
+	};
+	const request = (url, speculative, started) => {
+		const controller = started?.controller ?? new AbortController();
+		const read = async () => {
+			const prefix = config.requestPrefix;
+			const target = new URL(url.href);
+			target.hash = "";
+			target.pathname = prefix + target.pathname;
+			const response = await (started?.response ?? w.fetch(target.href, {
+				credentials: "same-origin",
+				headers: speculative ? { purpose: "prefetch" } : {},
+				priority: speculative ? "auto" : "high",
+				signal: controller.signal
+			}));
+			const type = response.headers.get("content-type") ?? "";
+			if (!response.ok || !type.includes("text/html") || !response.body) throw new Error(`MARKLESS_ROUTER_FRAGMENT_UNAVAILABLE: ${response.status}`);
+			const finalUrl = new URL(response.url || target.href);
+			if (finalUrl.origin !== location.origin) throw new Error("MARKLESS_ROUTER_FRAGMENT_OFF_ORIGIN");
+			if (!finalUrl.pathname.startsWith(`${prefix}/`)) throw new Error("MARKLESS_ROUTER_FRAGMENT_UNAVAILABLE: redirected");
+			finalUrl.pathname = finalUrl.pathname.slice(prefix.length);
+			finalUrl.hash = url.hash;
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let text = "";
+			for (;;) {
+				if (text.includes(config.regionEndMarker)) return {
+					...parse(finalUrl.href, text),
+					rest: speculative ? drain(reader, closed) : reader
+				};
+				const chunk = await reader.read();
+				if (chunk.done) {
+					closed();
+					return parse(finalUrl.href, text + decoder.decode());
+				}
+				text += decoder.decode(chunk.value, { stream: true });
+			}
+		};
+		const closed = () => {
+			entry.open = false;
+			queueMicrotask(pumpIdle);
+		};
+		const entry = {
+			at: started?.at ?? w.performance.now(),
+			result: read(),
+			open: true,
+			abort: () => {
+				closed();
+				controller.abort();
+			}
+		};
+		entry.result.catch(closed);
+		return entry;
+	};
+	const prefetch = (url, code = true, started) => {
+		const key = pageKey(url);
+		if (!config.prefetch || key === state.shown) return;
+		const existing = state.prefetches.get(key);
+		if (existing && w.performance.now() - existing.at < config.prefetchTtlMs) return void (code && preloadCode(url, false));
+		existing?.abort();
+		const open = [...state.prefetches].filter(([, entry]) => entry.open);
+		for (const [stale, entry] of open.slice(0, Math.max(0, open.length + 1 - config.prefetchConnections))) {
+			state.prefetches.delete(stale);
+			entry.abort();
+		}
+		const entry = request(url, true, started);
+		state.prefetches.set(key, entry);
+		w.setTimeout(() => {
+			if (state.prefetches.get(key) !== entry) return;
+			state.prefetches.delete(key);
+			entry.abort();
+		}, config.prefetchTtlMs);
+		if (code) preloadCode(url, false);
+	};
+	let scanning = false;
+	let idleQueue = [];
+	const pumpIdle = () => {
+		while (idleQueue.length) {
+			let open = 0;
+			for (const entry of state.prefetches.values()) if (entry.open) open += 1;
+			if (open >= config.prefetchConnections) return;
+			const url = idleQueue.shift();
+			if (state.prefetches.has(pageKey(url))) continue;
+			prefetch(url, false);
+			preloadCode(url, true);
+		}
+	};
+	const rescan = () => {
+		if (!state.idleDownloads || scanning) return;
+		scanning = true;
+		const run = () => {
+			scanning = false;
+			const visible = /* @__PURE__ */ new Map();
+			for (const anchor of d.querySelectorAll("a[href]")) {
+				const url = eligible(anchor);
+				if (!url || !state.routes[url.pathname]) continue;
+				const box = anchor.getBoundingClientRect();
+				if (!box.width || box.bottom < 0 || box.top > w.innerHeight) continue;
+				if (box.right < 0 || box.left > w.innerWidth) continue;
+				const hit = d.elementFromPoint(box.left + box.width / 2, box.top + box.height / 2);
+				if (!hit || hit !== anchor && !anchor.contains(hit)) continue;
+				visible.set(pageKey(url), url);
+			}
+			idleQueue = [];
+			for (const [key, url] of visible) if (idleQueue.length < config.idleFragments && !state.prefetches.has(key)) idleQueue.push(url);
+			pumpIdle();
+		};
+		const idle = () => w.requestIdleCallback ? w.requestIdleCallback(run, { timeout: 3e3 }) : w.setTimeout(run, 500);
+		if (d.readyState === "complete") idle();
+		else w.addEventListener("load", idle, { once: true });
+	};
+	const state = {
+		config,
+		routes,
+		prefetches: /* @__PURE__ */ new Map(),
+		visited: /* @__PURE__ */ new Map(),
+		shown: pageKey(new URL(location.href)),
+		eligible,
+		preloadCode,
+		request,
+		prefetch,
+		parse,
+		idleDownloads: config.prefetch && (connection ? connection.effectiveType === "4g" && connection.saveData !== true : config.idleWithoutConnectionInfo),
+		rescan,
+		scrolled,
+		arriving
+	};
+	host.__marklessFragmentNav = state;
+	if (early) prefetch(new URL(early.url), true, early);
+	let restTimer = 0;
+	let previous;
+	const hover = (event) => {
+		const pointer = event;
+		if (pointer.pointerType !== "mouse") return;
+		const point = {
+			x: pointer.clientX,
+			y: pointer.clientY,
+			t: pointer.timeStamp
+		};
+		if (previous && point.x === previous.x && point.y === previous.y) return void w.clearTimeout(restTimer);
+		const gap = previous ? point.t - previous.t : 0;
+		const creeping = !!previous && gap > 0 && Math.hypot(point.x - previous.x, point.y - previous.y) / gap < .1;
+		previous = point;
+		w.clearTimeout(restTimer);
+		const url = eligible(anchorOf(event));
+		if (!url) return;
+		if (creeping) prefetch(url);
+		else restTimer = w.setTimeout(() => prefetch(url), Math.max(config.hoverDwellMs, gap * 1.5));
+	};
+	d.addEventListener("pointermove", hover, { passive: true });
+	d.addEventListener("pointerout", () => w.clearTimeout(restTimer), { passive: true });
+	const press = (event) => {
+		w.clearTimeout(restTimer);
+		const anchor = anchorOf(event);
+		const url = eligible(anchor);
+		if (url) prefetch(url);
+		if (url || eligible(anchor, true)) load();
+	};
+	for (const type of [
+		"pointerdown",
+		"touchstart",
+		"focusin"
+	]) d.addEventListener(type, press, { passive: true });
+	const go = (anchor) => {
+		const url = eligible(anchor, true);
+		if (!url) return false;
+		const current = new URL(location.href);
+		w.clearTimeout(restTimer);
+		const replace = anchor.hasAttribute(config.replaceAttribute) || url.href === current.href;
+		const manual = anchor.getAttribute(config.scrollAttribute) === "manual";
+		const swap = (entry) => entry.navigate(d, url, replace ? "replace" : "push", manual ? "manual" : "reset");
+		if (loaded) swap(loaded);
+		else load().then(swap, () => location.assign(url.href));
+		return true;
+	};
+	const follow = (routedPhase) => (event) => {
+		const mouse = event;
+		if (mouse.defaultPrevented || mouse.button !== 0) return;
+		if (mouse.metaKey || mouse.altKey || mouse.ctrlKey || mouse.shiftKey) return;
+		const anchor = anchorOf(event);
+		if (!anchor || anchor.hasAttribute(config.linkAttribute) !== routedPhase) return;
+		if (go(anchor)) event.preventDefault();
+	};
+	d.addEventListener("click", follow(true), true);
+	d.addEventListener("click", follow(false));
+	rescan();
+	const traverse = (event) => {
+		const url = new URL(location.href);
+		if (url.hash.startsWith("#/") || pageKey(url) === state.shown) return;
+		const saved = event.state?.__marklessFragment;
+		load().then((entry) => entry.navigate(d, url, "traverse", saved ?? {
+			x: 0,
+			y: 0
+		}), () => location.reload());
+	};
+	const replay = (event) => {
+		if (event?.type === "pointerover") hover(event);
+		else if (event && event.type !== "popstate") press(event);
+	};
+	return {
+		traverse,
+		replay,
+		go
+	};
+}
+const FRAGMENT_PATH_PREFIX = "/_markless/fragment";
+function fragmentPageUrl(url) {
+	if (!url.pathname.startsWith(`/_markless/fragment/`)) return void 0;
+	const page = new URL(url);
+	page.pathname = url.pathname.slice(19);
+	return page;
+}
+const FRAGMENT_REGION_END = "<!--markless:region-end-->";
+const FRAGMENT_APPEND_END = "<!--markless:append-end-->";
+const FRAGMENT_PREFETCH_TTL_MS = 3e4;
+//#endregion
+//#region src/vite/runtime/link-bridge-module.ts
+/** Marks the page's link bridge script: inline in dev, a module stub importing the shared bridge in a build. */
+const LINK_BRIDGE_SCRIPT_ATTRIBUTE = "data-markless-router-link-resumer";
+/** The client output folder a build writes its link bridge files into, served as immutable static assets. */
+const LINK_BRIDGE_DIR = "_markless/links";
+function linkBridgeModulePath(base, hash) {
+	return `${base.replace(/\/?$/, "/")}${LINK_BRIDGE_DIR}/${hash}.js`;
+}
+//#endregion
+//#region src/vite/runtime/page-http.ts
+const RESPONSE_COMMITTED_CODE = "MARKLESS_ROUTER_RESPONSE_COMMITTED";
+function createPageHttp(request, url) {
+	let committed;
+	let status;
+	let statusText;
+	const refuse = (write) => {
+		throw new Error(`${RESPONSE_COMMITTED_CODE}: ${write} ran after the page's response started streaming to the browser, so its status and headers were already sent. Set http.response before the first byte goes out: in the page body, before any await that outlives the first flush.`);
+	};
+	const headers = new PageHeaders((write, unchanged) => {
+		if (committed && !unchanged(committed.headers)) refuse(write);
+	});
+	const response = {
+		headers,
+		get status() {
+			return status;
+		},
+		set status(value) {
+			if (committed && value !== committed.status) refuse(`http.response.status = ${value}`);
+			status = value;
+		},
+		get statusText() {
+			return statusText;
+		},
+		set statusText(value) {
+			if (committed && value !== committed.statusText) refuse(`http.response.statusText = ${JSON.stringify(value)}`);
+			statusText = value;
+		}
+	};
+	return {
+		context: {
+			locals: requestLocals(request) ?? {},
+			request,
+			response,
+			url
+		},
+		commit(fallbackStatus, routerHeaders) {
+			const sent = new Headers(routerHeaders);
+			const middleware = takeMiddlewareHeaders(request);
+			for (const source of middleware ? [middleware, headers] : [headers]) {
+				for (const [name, value] of source) if (name !== "set-cookie") sent.set(name, value);
+				for (const cookie of source.getSetCookie()) sent.append("set-cookie", cookie);
+			}
+			committed = {
+				status: status ?? fallbackStatus,
+				statusText,
+				headers: sent
+			};
+			return {
+				status: committed.status,
+				...statusText === void 0 ? {} : { statusText },
+				headers: sent
+			};
+		}
+	};
+}
+var PageHeaders = class extends Headers {
+	#guard;
+	constructor(guard) {
+		super();
+		this.#guard = guard;
+	}
+	set(name, value) {
+		this.#guard(`http.response.headers.set(${JSON.stringify(name)})`, (sent) => name.toLowerCase() === "set-cookie" ? sent.getSetCookie().includes(value) : sent.get(name) === value);
+		super.set(name, value);
+	}
+	append(name, value) {
+		this.#guard(`http.response.headers.append(${JSON.stringify(name)})`, (sent) => name.toLowerCase() === "set-cookie" ? sent.getSetCookie().includes(value) : (sent.get(name)?.split(", ") ?? []).includes(value));
+		if (!headerValues(this, name).includes(value)) super.append(name, value);
+	}
+	delete(name) {
+		this.#guard(`http.response.headers.delete(${JSON.stringify(name)})`, (sent) => !sent.has(name));
+		super.delete(name);
+	}
+};
+function headerValues(headers, name) {
+	return name.toLowerCase() === "set-cookie" ? headers.getSetCookie() : headers.get(name)?.split(", ") ?? [];
+}
+//#endregion
+//#region src/vite/runtime/page-region.ts
+const REGION_HOSTS = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"blockquote",
+	"body",
+	"dd",
+	"details",
+	"dialog",
+	"div",
+	"fieldset",
+	"figure",
+	"footer",
+	"form",
+	"header",
+	"li",
+	"main",
+	"nav",
+	"section",
+	"td",
+	"th"
+]);
+const PAGE_END_MARKER = `<!--${PROTOCOL_CONTAINER_END_COMMENT}-->`;
+const PAGE_START_MARKER = `<!--${PROTOCOL_CONTAINER_START_COMMENT}-->`;
+const VOID_TAGS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+]);
+const RAW_TEXT_TAGS = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"textarea",
+	"title"
+]);
+function splitPageHtml(html) {
+	const parts = splitSsrContainer(html);
+	if (!parts) return {
+		headHtml: "",
+		bodyHtml: html
+	};
+	return {
+		headHtml: parts.before,
+		bodyHtml: html.slice(parts.before.length),
+		region: {
+			attributes: parts.attributes,
+			inner: parts.inner
+		}
+	};
+}
+/**
+* The document with the page in its children slot, split where streamed appends go:
+* `prefix + suffix` is the whole document. When the slot sits inside an element that can hold any
+* content, that element becomes the container: the page's markup lands as its children, a comment
+* closes the page's nodes and, when document content precedes the slot, another opens them, so
+* the document's content on either side stays where the author wrote it.
+*/
+function placePage(shell, slot, page) {
+	const at = shell.indexOf(slot);
+	if (at === -1) return {
+		prefix: shell,
+		suffix: ""
+	};
+	const rest = shell.slice(at + slot.length);
+	const host = regionHost(shell, at, page);
+	if (!host) return {
+		prefix: shell.slice(0, at) + page.bodyHtml,
+		suffix: rest
+	};
+	return {
+		prefix: `${shell.slice(0, host.start)}${host.open}${host.before}${page.region.inner}`,
+		suffix: `${PAGE_END_MARKER}${rest}`
+	};
+}
+function fragmentPage(shell, slot, page) {
+	const at = shell.indexOf(slot);
+	const bodyAt = shell.search(/<body[\s>]/i);
+	const bodyOpenEnd = bodyAt === -1 ? -1 : shell.indexOf(">", bodyAt);
+	if (at === -1 || bodyOpenEnd === -1) {
+		const placed = placePage(shell, slot, page);
+		return placed.prefix + placed.suffix;
+	}
+	const host = regionHost(shell, at, page);
+	const inner = (host?.before ? PAGE_START_MARKER : "") + (page.region?.inner ?? "");
+	if (host?.tag === "body") return `${shell.slice(0, host.start)}${host.open}${inner}</body></html>`;
+	const region = host ? `${host.open}${inner}</${host.tag}>` : page.bodyHtml;
+	return `${shell.slice(0, bodyOpenEnd + 1)}${region}</body></html>`;
+}
+function regionHost(shell, at, page) {
+	if (!page.region) return void 0;
+	const open = innermostOpenTag(shell, at);
+	if (!open || !REGION_HOSTS.has(open.tag)) return void 0;
+	const before = shell.slice(open.end + 1, at);
+	return {
+		start: open.start,
+		open: `${shell.slice(open.start, open.end)}${page.region.attributes}>`,
+		tag: open.tag,
+		before: before.trim() ? before + PAGE_START_MARKER : ""
+	};
+}
+function innermostOpenTag(html, at) {
+	const stack = [];
+	let cursor = 0;
+	let lower;
+	while (cursor < at) {
+		const start = html.indexOf("<", cursor);
+		if (start === -1 || start >= at) break;
+		if (html.startsWith("<!--", start)) {
+			const close = html.indexOf("-->", start + 4);
+			cursor = close === -1 ? at : close + 3;
+			continue;
+		}
+		const end = tagEnd(html, start);
+		if (end === -1 || end >= at) break;
+		cursor = end + 1;
+		const name = /^<(\/?)([a-zA-Z][a-zA-Z0-9-]*)/.exec(html.slice(start, end + 1));
+		if (!name) continue;
+		const tag = name[2].toLowerCase();
+		if (name[1]) {
+			const match = stack.findLastIndex((entry) => entry.tag === tag);
+			if (match !== -1) stack.length = match;
+			continue;
+		}
+		if (VOID_TAGS.has(tag) || html[end - 1] === "/") continue;
+		if (RAW_TEXT_TAGS.has(tag)) {
+			const close = (lower ??= html.toLowerCase()).indexOf(`</${tag}`, cursor);
+			cursor = close === -1 ? at : close;
+			continue;
+		}
+		stack.push({
+			tag,
+			start,
+			end
+		});
+	}
+	return stack.at(-1);
+}
+function tagEnd(html, from) {
+	let quote = "";
+	for (let at = from; at < html.length; at++) {
+		const char = html[at];
+		if (quote) {
+			if (char === quote) quote = "";
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === ">") return at;
+	}
+	return -1;
+}
+//#endregion
+//#region src/vite/runtime/create-server-entry.ts
+const DOCUMENT_CHILDREN_PLACEHOLDER = "__markless_router_document_children__";
+function fragmentBridgeFor(options, manifest) {
+	return options.fragmentEntryPath !== void 0 && options.navigation !== "render" ? {
+		entry: options.fragmentEntryPath,
+		entryImports: options.fragmentEntryImports ?? [],
+		source: options.fragmentNavigationSource ?? startFragmentNavigation.toString(),
+		runSource: options.fragmentNavigationRunSource ?? runFragmentNavigation.toString(),
+		prefetch: options.prefetch !== false,
+		pages: manifest.routes.map((route) => route.pathname.replace(/:[^/]+/g, ":"))
+	} : void 0;
+}
+/** The link bridge modules a built app's pages import; the build writes them as static client files. */
+function routerLinkBridgeModules(options, manifest = buildRouteManifestFromFileIds(options.routeFileIds)) {
+	if (!options.navigationEntryPath) return void 0;
+	const fragmentBridge = fragmentBridgeFor(options, manifest);
+	return linkBridgeModules(options.base ?? "/", options.navigationEntryPath, fragmentBridge !== void 0 || options.prefetch !== false, options.documentNavigation === "document", fragmentBridge, options.debug);
+}
+function createServerEntry(options) {
+	const manifest = buildRouteManifestFromFileIds(options.routeFileIds);
+	assertCurrentRouteAssets(options);
+	const fragmentBridge = fragmentBridgeFor(options, manifest);
+	const fragmentNavigation = fragmentBridge !== void 0;
+	const linkBridgeModules = options.dev || options.linkBridgePaths ? void 0 : routerLinkBridgeModules(options, manifest);
+	const linkBridges = options.dev ? void 0 : options.linkBridgePaths ?? (linkBridgeModules && [linkBridgeModules[0].path, linkBridgeModules[1].path]);
+	async function fetch(request) {
+		const requestUrl = new URL(request.url);
+		const fragmentUrl = fragmentNavigation ? fragmentPageUrl(requestUrl) : void 0;
+		const fragment = fragmentUrl !== void 0;
+		const url = fragmentUrl ?? requestUrl;
+		const match = matchRouteManifest(url.pathname, manifest);
+		if (isNitroApiPathname(url.pathname) && !(match && isNitroApiPathname(match.route.pathname))) return new Response("Not found", createPageHttp(request, url).commit(404, {}));
+		if (!match) return renderStatusPage(url, manifest.statusPages.notFound, 404, "Not found", fragment, request);
+		try {
+			return await renderPage(url, match.route.file, match.params, 200, fragment, request);
+		} catch (error) {
+			console.error("[markless-router] page render failed:", error);
+			if (options.dev) return renderDevelopmentError(url, error);
+			try {
+				return await renderStatusPage(url, manifest.statusPages.error, 500, "Internal Server Error", fragment, request);
+			} catch (errorPageError) {
+				console.error("[markless-router] error page render failed:", errorPageError);
+				return new Response("Internal Server Error", {
+					status: 500,
+					headers: { "content-type": "text/plain;charset=utf-8" }
+				});
+			}
+		}
+	}
+	function renderDevelopmentError(url, error) {
+		const headers = {
+			"cache-control": "no-store",
+			"content-type": "text/html;charset=utf-8"
+		};
+		try {
+			const payload = normalizeMarklessDevError(error, { id: `navigation:${url.pathname}` });
+			return new Response(renderMarklessDevErrorDocument(payload), {
+				status: 500,
+				headers
+			});
+		} catch {
+			return new Response(escapeHtml(flattenError(error)), {
+				status: 500,
+				headers: {
+					...headers,
+					"content-type": "text/plain;charset=utf-8"
+				}
+			});
+		}
+	}
+	async function renderStatusPage(url, file, status, fallbackText, fragment, request) {
+		if (!file) return new Response(fallbackText, createPageHttp(request, url).commit(status, {}));
+		return renderPage(url, file, {}, status, fragment, request);
+	}
+	async function renderPage(url, file, params, status, fragment, request) {
+		const loadPageModule = options.pageModuleLoaders[file];
+		if (!loadPageModule) return new Response(`Page module not found: ${file}`, { status: 500 });
+		const cookie = request.headers.get("cookie");
+		const pageModule = await loadPageModule();
+		const http = createPageHttp(request, url);
+		const pageProps = {
+			http: http.context,
+			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), http.commit(status, headers));
+		}
+		const documentLoads = options.documentNavigation === "document";
+		const linkIntent = fragmentNavigation || options.prefetch !== false;
+		const destinationPreloads = documentLoads || fragmentNavigation ? options.routeSsrModulePreloads : options.routeModulePreloads;
+		const pageArtifact = routedPageArtifact(renderSsr, baseArtifact, pageProps, file, options.navigationEntryPath, pageStylesheets(options, file), documentModule?.default?.headInjections ?? [], linkIntent ? (html) => linkIntentPreloads(html, pageProps.url.href, manifest, destinationPreloads, fragmentNavigation) : void 0, documentLoads, fragmentBridge, linkBridges);
+		let rendersStorage = false;
+		const routedArtifact = {
+			...pageArtifact,
+			...options.prerenderWakeEntryPath ? { prerenderWakeModuleUrl: options.prerenderWakeEntryPath } : {},
+			async renderSsr(renderProps, renderContext) {
+				const output = await pageArtifact.renderSsr(renderProps, renderContext);
+				if (documentStorageRecords(output.state).length > 0) rendersStorage = true;
+				return output;
+			}
+		};
+		const privateToVisitor = () => {
+			if (!rendersStorage) return;
+			headers["cache-control"] = "private";
+			headers.vary = headers.vary ? `${headers.vary}, cookie` : "cookie";
+		};
+		const renderOptions = {
+			cookie,
+			props: pageProps,
+			resumeModuleUrl: options.resumeEntryPath ?? baseArtifact?.resumeModuleUrl,
+			modulePreloads: (html, resumes) => landingModulePreloads(resumes ? options.routeSsrModulePreloads?.[file] : void 0, linkBridges?.[html.includes("href=\"#/") ? 1 : 0])
+		};
+		const headStart = (documentLoads && fragmentNavigation && !fragment ? servedHtmlAttributesScript() : "") + (options.importMap ?? "");
+		if (options.render === "blocking") {
+			const pageHtml = splitPageHtml(await renderToString(routedArtifact, renderOptions));
+			privateToVisitor();
+			const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml, headStart);
+			return new Response(wholeDocument(shell, pageHtml, fragment, documentLoads), http.commit(status, headers));
+		}
+		const stream = await renderToStream(routedArtifact, renderOptions);
+		privateToVisitor();
+		const pageHtml = splitPageHtml(stream.shell);
+		const shell = await renderDocumentShell(documentModule, pageProps, pageHtml.headHtml, headStart);
+		if (stream.pendingArmCount === 0) return new Response(wholeDocument(shell, pageHtml, fragment, documentLoads), http.commit(status, headers));
+		const placed = placePage(shell, DOCUMENT_CHILDREN_PLACEHOLDER, pageHtml);
+		const prefix = fragment ? fragmentDocument(shell, pageHtml, documentLoads) + FRAGMENT_REGION_END : placed.prefix;
+		const suffix = fragment ? "" : placed.suffix;
+		const appendEnd = fragment ? FRAGMENT_APPEND_END : "";
+		const encoder = new TextEncoder();
+		const sent = http.commit(status, headers);
+		let cancelled = false;
+		let completed = false;
+		const body = new ReadableStream({
+			async start(controller) {
+				controller.enqueue(encoder.encode(prefix));
+				try {
+					for await (const chunk of stream.appends()) {
+						if (cancelled) return;
+						controller.enqueue(encoder.encode(chunk + appendEnd));
+					}
+				} catch (error) {
+					if (cancelled) return;
+					console.error("[markless-router] streaming settle failed:", error);
+					controller.error(error);
+					completed = true;
+					return;
+				}
+				if (cancelled) return;
+				if (suffix) controller.enqueue(encoder.encode(suffix));
+				controller.close();
+				completed = true;
+			},
+			cancel(reason) {
+				if (completed) return;
+				cancelled = true;
+				stream.cancel(reason);
+			}
+		});
+		return new Response(body, sent);
+	}
+	return {
+		fetch,
+		linkBridgeModules
+	};
+}
+function flattenError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
+	return String(error);
+}
+function assertCurrentRouteAssets(options) {
+	if (options.routeStylesheets === void 0) return;
+	const routeMaps = [
+		["navigation", options.routeModulePreloads ?? {}],
+		["SSR", options.routeSsrModulePreloads ?? {}],
+		["style", options.routeStylesheets]
+	];
+	const expected = [...new Set(options.routeFileIds.map(normalizeRouteFileId))].filter((file) => /^pages\/.+\.(?:tsrx|mdx)$/.test(file)).toSorted();
+	for (const [label, routes] of routeMaps) {
+		const actual = Object.keys(routes).toSorted();
+		if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`Markless Router ${label} client-asset routes are stale; expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}. Rebuild the client environment before the server environment.`);
+	}
+}
+function dedupeHeadLinks(injections) {
+	const seen = /* @__PURE__ */ new Set();
+	return injections.filter((injection) => {
+		const href = injection.tag === "link" ? injection.attributes?.href : void 0;
+		if (typeof href !== "string") return true;
+		if (seen.has(href)) return false;
+		seen.add(href);
+		return true;
+	});
+}
+function pageStylesheets(options, file) {
+	const documentHrefs = options.documentStylesheets ?? [];
+	const routeHrefs = options.routeStylesheets?.[file];
+	if (documentHrefs.length === 0) return routeHrefs;
+	return [.../* @__PURE__ */ new Set([...documentHrefs, ...routeHrefs ?? []])];
+}
+function routedPageArtifact(renderSsr, baseArtifact, pageProps, file, navigationEntryPath, stylesheetHrefs, documentHeadInjections = [], intentPreloads, documentLoads = false, fragment, linkBridgePaths) {
+	const headInjections = dedupeHeadLinks([
+		...documentHeadInjections,
+		...baseArtifact?.headInjections ?? [],
+		...(stylesheetHrefs ?? []).map((href) => ({
+			tag: "link",
+			location: "head",
+			attributes: {
+				rel: "stylesheet",
+				href
+			}
+		}))
+	]);
+	return {
+		resumeModuleUrl: baseArtifact?.resumeModuleUrl,
+		inlineResumerSources: baseArtifact?.inlineResumerSources,
+		storageSeeds: baseArtifact?.storageSeeds,
+		...headInjections.length > 0 ? { headInjections } : {},
+		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, intentPreloads?.(output.html), documentLoads, fragment, output.html.includes("href=\"#/"), linkBridgePaths) : "";
+			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 { http: _serverOnly, ...browserProps } = props;
+	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: browserProps
+		}]
+	};
+}
+function landingModulePreloads(routePreloads, linkBridgePath) {
+	const preloads = [];
+	addModulePreloads(preloads, /* @__PURE__ */ new Set(), routePreloads);
+	if (linkBridgePath) preloads.push(linkBridgePath);
+	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 anchorHrefs(html) {
+	return [...html.matchAll(/<a\b(?=[^>]*\bhref="([^"]*)")[^>]*>/g)].map((match) => unescapeHtmlAttribute(match[1] ?? ""));
+}
+function linkIntentPreloads(html, baseHref, manifest, routes, plainAnchors = false) {
+	const destinations = Object.create(null);
+	for (const href of plainAnchors ? anchorHrefs(html) : routerLinkHrefs(html)) {
+		const url = parseSameOriginUrl(href, baseHref);
+		const match = url && matchRouteManifest(url.pathname, manifest);
+		const preloads = match && routes?.[match.route.file];
+		if (url && preloads && (preloads.length > 0 || plainAnchors)) destinations[url.pathname] = preloads;
+	}
+	return destinations;
+}
+function indexedPreloads(intentPreloads) {
+	const preloads = [];
+	const indexes = /* @__PURE__ */ new Map();
+	const destinations = Object.create(null);
+	for (const [pathname, list] of Object.entries(intentPreloads)) destinations[pathname] = list.map((preload) => {
+		const key = JSON.stringify(preload);
+		let index = indexes.get(key);
+		if (index === void 0) {
+			index = preloads.push(preload) - 1;
+			indexes.set(key, index);
+		}
+		return index;
+	});
+	return {
+		preloads,
+		destinations
+	};
+}
+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);
+	}
+}
+async function renderDocumentShell(documentModule, pageProps, headHtml, importMap = "") {
+	const written = {};
+	const documentHtml = await renderDocumentModule(documentModule, {
+		...pageProps,
+		children: DOCUMENT_CHILDREN_PLACEHOLDER
+	}, written);
+	const attributes = htmlAttributes(documentModule, pageProps, written);
+	if (documentHtml !== void 0) return [
+		"<!doctype html>",
+		`<html${renderAttributes(attributes)}>`,
+		insertImportMap(insertHeadHtml(documentHtml, headHtml), importMap),
+		"</html>"
+	].join("");
+	return [
+		"<!doctype html>",
+		`<html${renderAttributes(attributes)}>`,
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		importMap,
+		"<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);
+}
+function fragmentDocument(shell, page, documentLoads) {
+	if (!documentLoads) return fragmentPage(shell, DOCUMENT_CHILDREN_PLACEHOLDER, page);
+	const placed = placePage(shell, DOCUMENT_CHILDREN_PLACEHOLDER, page);
+	return placed.prefix + placed.suffix;
+}
+function wholeDocument(shell, page, fragment, documentLoads) {
+	if (fragment) return fragmentDocument(shell, page, documentLoads) + FRAGMENT_REGION_END;
+	const placed = placePage(shell, DOCUMENT_CHILDREN_PLACEHOLDER, page);
+	return placed.prefix + placed.suffix;
+}
+async function renderDocumentModule(documentModule, props, htmlAttributes) {
+	const output = await documentModule?.default?.renderSsr?.(props, { [HTML_ATTRIBUTES_SLOT]: htmlAttributes });
+	assertDocumentStorageFree(output);
+	return output?.html;
+}
+function assertDocumentStorageFree(output) {
+	const storage = documentStorageRecords(output?.state);
+	if (storage.length === 0) return;
+	const keys = storage.map((record) => record.key).join(", ");
+	throw new Error(`MARKLESS_ROUTER_DOCUMENT_STORAGE_UNSUPPORTED: the document declares storage cells (${keys}), but the router serves only the document's HTML, so their state payload never reaches the browser and they can never resume. Declare storage() at module scope in a component the page renders instead.`);
+}
+function documentStorageRecords(state) {
+	if (!state || typeof state !== "object") return [];
+	const storage = state.storage;
+	return Array.isArray(storage) ? storage : [];
+}
+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="${ROUTE_SCRIPT_TYPE}">${escapeScriptJson({ file })}<\/script>`;
+}
+function linkBridgeBody(resumeEntryPath, linkIntent, documentLoads, fragment, page, debug = debugDefined()) {
+	const inline = !("module" in page);
+	const fragmentNavigation = fragment !== void 0;
+	const fragmentSource = fragment ? `
+(${fragment.source})(d,()=>${JSON.stringify(LINK_ATTRIBUTE)},${inline ? escapeScriptJson(page.intentPreloads ?? {}) : "r"},(href)=>import(href),${"runPath" in page && page.runPath ? `()=>import(${JSON.stringify(page.runPath)}).then((m)=>m.default)` : `()=>Promise.resolve(${boundFragmentRun(fragment, documentLoads)})`},()=>(${fragment.prefetch ? escapeScriptJson({
+		code: [fragment.entry, ...fragment.entryImports],
+		hoverDwellMs: 20,
+		requestPrefix: FRAGMENT_PATH_PREFIX,
+		prefetchAttribute: PREFETCH_ATTRIBUTE
+	}) : "null"}));` : "";
+	const indexed = !fragmentNavigation && linkIntent ? inline ? page.intentPreloads && indexedPreloads(page.intentPreloads) : {
+		preloads: "preloads",
+		destinations: "destinations"
+	} : void 0;
+	const intentSource = indexed ? `
+	const preloads = ${inline ? escapeScriptJson(indexed.preloads) : "p"};
+	const destinations = ${inline ? escapeScriptJson(indexed.destinations) : "q"};
+	const destination = (url) => destinations[url.pathname]?.map((index) => preloads[index]);
+	const append = (${appendModulePreloads.toString()});
+	(${listenForLinkIntent.toString()})(d, linkAttr, (url) => {
+		append(d, destination(url));
+	}, prefetchAttr);` : "";
+	const hashClickSource = fragment && !page.hashLinks ? "" : `
+	if (d.__marklessRouterHashClickStarted) return;
+	d.__marklessRouterHashClickStarted = true;
+	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;
+		}
+	};
+	d.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${documentLoads || fragmentNavigation ? " || !url.hash.startsWith('#/')" : ""}) 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);`;
+	const debugRegistration = debug ? `
+	try {
+		const key = Symbol.for('markless.debug.channel.v1.bootstrap');
+		const md = globalThis[key];
+		if (md) { md.router('ssr-link-bridge'); md.activate(); }
+	} catch {}` : "";
+	return `${fragmentSource}${fragment && !hashClickSource ? "" : `
+if(d.__marklessRouterLinkResumerStarted${fragment ? "&&d.__marklessRouterHashClickStarted" : ""})return;d.__marklessRouterLinkResumerStarted=true;`}${intentSource || hashClickSource ? `
+	const linkAttr = ${JSON.stringify(LINK_ATTRIBUTE)};` : ""}${intentSource ? `
+	const prefetchAttr = ${JSON.stringify(PREFETCH_ATTRIBUTE)};` : ""}${hashClickSource ? `
+	const replaceAttr = ${JSON.stringify(REPLACE_ATTRIBUTE)};
+	const scrollAttr = ${JSON.stringify(SCROLL_ATTRIBUTE)};` : ""}${intentSource}
+if(location.hash&&location.hash.startsWith('#/'))import(${JSON.stringify(resumeEntryPath)}).catch(()=>{});${hashClickSource}${debugRegistration}`;
+}
+function debugDefined() {
+	return typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__;
+}
+function linkBridgeModules(base, resumeEntryPath, linkIntent, documentLoads, fragment, debug) {
+	const runSource = fragment && `export default ${boundFragmentRun(fragment, documentLoads)};`;
+	const run = runSource ? {
+		path: linkBridgeModulePath(base, contentHash(runSource)),
+		source: runSource
+	} : void 0;
+	const variant = (hashLinks) => {
+		const source = `export default(r,p,q)=>{const d=document;${linkBridgeBody(resumeEntryPath, linkIntent, documentLoads, fragment, {
+			module: true,
+			hashLinks,
+			runPath: run?.path
+		}, debug)}\n};`;
+		return {
+			path: linkBridgeModulePath(base, contentHash(source)),
+			source
+		};
+	};
+	const withoutHashLinks = variant(false);
+	const pages = [withoutHashLinks, fragment ? variant(true) : withoutHashLinks];
+	return run ? [...pages, run] : pages;
+}
+function contentHash(text) {
+	let hash = 2166136261;
+	for (let at = 0; at < text.length; at++) hash = Math.imul(hash ^ text.charCodeAt(at), 16777619);
+	return (hash >>> 0).toString(36);
+}
+function renderLinkBridgeScript(resumeEntryPath, intentPreloads, documentLoads = false, fragment, hashLinks = false, modulePaths) {
+	const debugBootstrap = typeof __MARKLESS_DEBUG_ENABLED__ !== "undefined" && __MARKLESS_DEBUG_ENABLED__ ? `<script data-markless-router-debug-bootstrap>${escapeInlineScript(`(() => {
+	const d = document;
+	const s = d.currentScript;
+	const r = s && s.closest('[data-async-container]');
+	if (!r) return;
+	try { globalThis[Symbol.for('markless.debug.channel.v1.bootstrap')] = ${__marklessDebugBootstrapSource()}(r, 'ssr-inline', false); } catch {}
+})();`)}<\/script>` : "";
+	const modulePath = modulePaths?.[hashLinks ? 1 : 0];
+	if (modulePath) {
+		const indexed = !fragment && intentPreloads ? indexedPreloads(intentPreloads) : void 0;
+		const args = fragment ? [escapeScriptJson(intentPreloads ?? {})] : indexed ? [
+			"0",
+			escapeScriptJson(indexed.preloads),
+			escapeScriptJson(indexed.destinations)
+		] : [];
+		return `${debugBootstrap}<script type="module" ${LINK_BRIDGE_SCRIPT_ATTRIBUTE}>${escapeInlineScript(`import b from${JSON.stringify(modulePath)};b(${args.join(",")})`)}<\/script>`;
+	}
+	const body = linkBridgeBody(resumeEntryPath, intentPreloads !== void 0, documentLoads, fragment, {
+		intentPreloads,
+		hashLinks
+	});
+	return `${debugBootstrap}<script ${LINK_BRIDGE_SCRIPT_ATTRIBUTE}>${escapeInlineScript(`(()=>{const d=document,s=d.currentScript,r=s&&s.closest('[data-async-container]');if(!r)return;${body}
+})();`)}<\/script>`;
+}
+function boundFragmentRun(fragment, documentLoads) {
+	return `(d,...a)=>(${fragment.runSource})(d,${escapeScriptJson(fragmentConfig(fragment, documentLoads))},...a)`;
+}
+function fragmentConfig(fragment, documentLoads) {
+	return {
+		entry: fragment.entry,
+		entryImports: fragment.entryImports,
+		linkAttribute: LINK_ATTRIBUTE,
+		prefetchAttribute: PREFETCH_ATTRIBUTE,
+		replaceAttribute: REPLACE_ATTRIBUTE,
+		scrollAttribute: SCROLL_ATTRIBUTE,
+		routeScriptType: ROUTE_SCRIPT_TYPE,
+		servedHtmlAttributesProperty: SERVED_HTML_ATTRIBUTES_PROPERTY,
+		retireProperty: CONTAINER_RETIRE_PROPERTY,
+		streamExecutorGlobal: STREAM_ARM_EXECUTOR_GLOBAL,
+		streamedArmSelector: STREAMED_ARM_SELECTOR,
+		requestPrefix: FRAGMENT_PATH_PREFIX,
+		regionEndMarker: FRAGMENT_REGION_END,
+		appendMarker: FRAGMENT_APPEND_END,
+		pageEndComment: PROTOCOL_CONTAINER_END_COMMENT,
+		pageStartComment: PROTOCOL_CONTAINER_START_COMMENT,
+		containerAttributes: [CONTAINER_ATTRIBUTE, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE],
+		documentLoads,
+		hoverDwellMs: 20,
+		prefetchTtlMs: FRAGMENT_PREFETCH_TTL_MS,
+		prefetchConnections: 2,
+		endpointPrefixes: [API_PATHNAME_PREFIX],
+		idleFragments: 6,
+		idleWithoutConnectionInfo: true,
+		prefetch: fragment.prefetch,
+		pages: fragment.pages
+	};
+}
+function htmlAttributes(documentModule, pageProps, written) {
+	const attributes = documentModule?.__marklessRouterHtmlAttributes?.(pageProps) ?? {
+		lang: "en",
+		...written
+	};
+	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");
+}
+const API_PATHNAME_PREFIX = "/api";
+function isNitroApiPathname(pathname) {
+	return pathname === API_PATHNAME_PREFIX || pathname.startsWith(`${API_PATHNAME_PREFIX}/`);
+}
+function insertImportMap(html, importMap) {
+	if (!importMap) return html;
+	const head = /<head(?:\s[^>]*)?>/i.exec(html);
+	if (!head) return `${importMap}${html}`;
+	const afterHead = head.index + head[0].length;
+	const headEnd = html.indexOf("</head>", afterHead);
+	const charset = /<meta\s[^>]*charset[^>]*>(?:<\/meta>)?/i.exec(html.slice(afterHead));
+	const at = charset && (headEnd === -1 || afterHead + charset.index < headEnd) ? afterHead + charset.index + charset[0].length : afterHead;
+	return `${html.slice(0, at)}${importMap}${html.slice(at)}`;
+}
+//#endregion
+export { runFragmentNavigation as a, FRAGMENT_PATH_PREFIX as i, routerLinkBridgeModules as n, startFragmentNavigation as o, LINK_BRIDGE_DIR as r, listenForLinkIntent as s, createServerEntry as t };