@markless/router 0.3.3 → 0.5.0

package/dist/debug-channel-CewnC9fH.js

@@ -0,0 +1,2 @@
+import { a as __marklessDebugInvalidateElement, c as __marklessDebugRegisterDelegatedEvents, d as __marklessDebugSetBoundaries, f as __marklessDebugStartContainer, i as __marklessDebugDisposeContainer, l as __marklessDebugRegisterRouter, n as __marklessDebugBootstrapSource, o as __marklessDebugRecordInteraction, r as __marklessDebugChannelForTest, s as __marklessDebugRecordViolation, t as __marklessDebugActivateContainer, u as __marklessDebugResetForTest } from "./debug-channel-Di6SppZv.js";
+export { __marklessDebugActivateContainer, __marklessDebugBootstrapSource, __marklessDebugChannelForTest, __marklessDebugDisposeContainer, __marklessDebugInvalidateElement, __marklessDebugRecordInteraction, __marklessDebugRecordViolation, __marklessDebugRegisterDelegatedEvents, __marklessDebugRegisterRouter, __marklessDebugResetForTest, __marklessDebugSetBoundaries, __marklessDebugStartContainer };

package/dist/{debug-channel-CSzo-Zj8.js → debug-channel-Di6SppZv.js}

@@ -1,20 +1,4 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
 //#region ../web/src/debug-channel.ts
-var debug_channel_exports = /* @__PURE__ */ __exportAll({
-	__marklessDebugBootstrapSource: () => __marklessDebugBootstrapSource,
-	__marklessDebugRegisterRouter: () => __marklessDebugRegisterRouter
-});
 function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
 	const global = globalThis;
 	const previous = global.__MARKLESS_DEBUG__?.version === 1 ? global.__MARKLESS_DEBUG__ : void 0;
@@ -247,9 +231,33 @@ function safely(run) {
 		return;
 	}
 }
+function __marklessDebugRegisterDelegatedEvents(root, eventNames) {
+	safely(() => moduleRoots.get(root)?.delegated(eventNames));
+}
 function __marklessDebugBootstrapSource() {
 	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),delegated:(eventNames)=>controls.delegated(eventNames),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
 }
+function __marklessDebugChannelForTest() {
+	return globalThis.__MARKLESS_DEBUG__;
+}
+function __marklessDebugStartContainer(root, phase, active = true) {
+	return safely(() => controlsFor(root, phase, active).start(phase, active)) ?? "";
+}
+function __marklessDebugActivateContainer(root) {
+	safely(() => controlsFor(root, "ssr-resume").activate());
+}
+function __marklessDebugDisposeContainer(root) {
+	safely(() => moduleRoots.get(root)?.dispose());
+}
+function __marklessDebugInvalidateElement(root, element) {
+	safely(() => moduleRoots.get(root)?.invalidate(element));
+}
+function __marklessDebugRecordInteraction(root, element, eventName, input) {
+	safely(() => (moduleRoots.get(root) ?? controlsFor(root, "csr")).record(element, eventName, input));
+}
+function __marklessDebugRecordViolation(input) {
+	safely(() => latestControls?.violation(input));
+}
 function __marklessDebugRegisterRouter(root, source) {
 	if (root) safely(() => (moduleRoots.get(root) ?? controlsFor(root, "ssr-resume")).router(source));
 	else safely(() => {
@@ -258,5 +266,16 @@ function __marklessDebugRegisterRouter(root, source) {
 		(latestControls ?? inlineControls)?.router(source);
 	});
 }
+function __marklessDebugSetBoundaries(root, boundaries) {
+	safely(() => moduleRoots.get(root)?.boundaries(boundaries));
+}
+function __marklessDebugResetForTest() {
+	const global = globalThis;
+	moduleRoots = /* @__PURE__ */ new WeakMap();
+	latestControls = void 0;
+	delete global.__MARKLESS_DEBUG__;
+	delete global[Symbol.for("markless.debug.channel.v1.bootstrap")];
+	delete global[Symbol.for("markless.debug.channel.v1.router-sources")];
+}
 //#endregion
-export { debug_channel_exports as n, __exportAll as r, __marklessDebugBootstrapSource as t };
+export { __marklessDebugInvalidateElement as a, __marklessDebugRegisterDelegatedEvents as c, __marklessDebugSetBoundaries as d, __marklessDebugStartContainer as f, __marklessDebugDisposeContainer as i, __marklessDebugRegisterRouter as l, __marklessDebugBootstrapSource as n, __marklessDebugRecordInteraction as o, __marklessDebugChannelForTest as r, __marklessDebugRecordViolation as s, __marklessDebugActivateContainer as t, __marklessDebugResetForTest as u };

package/dist/fragment-navigation-CIiNnFFc.js

@@ -0,0 +1,323 @@
+//#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, configOf, routes, importModule) {
+	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();
+	let traverse;
+	const wake = () => traverse ??= start();
+	const listen = (event) => {
+		const target = event.composedPath()[0] ?? event.target;
+		if (event.type === "scroll") {
+			if (target !== d) scrolled.add(target);
+		} else if (event.type === "popstate") wake()(event);
+		else if (!traverse && target.closest?.("a[href]")) wake();
+	};
+	for (const type of [
+		"scroll",
+		"pointerover",
+		"pointerdown",
+		"touchstart",
+		"focusin",
+		"click",
+		"popstate"
+	]) w.addEventListener(type, listen, {
+		capture: true,
+		passive: true
+	});
+	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 });
+	}
+	const start = () => {
+		delete host.__marklessFragmentWake;
+		const config = configOf();
+		const location = w.location;
+		const connection = w.navigator.connection;
+		const pageKey = (url) => url.pathname + url.search;
+		let module;
+		const load = () => {
+			module ??= importModule(config.entry);
+			module.catch(() => module = void 0);
+			return module;
+		};
+		const pages = config.pages.map((page) => page.split("/").filter(Boolean));
+		const isPage = (pathname) => {
+			if (config.endpointPrefixes.some((prefix) => (pathname + "/").startsWith(prefix + "/"))) return false;
+			const parts = pathname.split("/").filter(Boolean);
+			return pages.some((page) => {
+				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, ...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)) 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";
+				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 request = (url, speculative) => {
+			const controller = new AbortController();
+			const read = async () => {
+				const response = await w.fetch(url.href, {
+					credentials: "same-origin",
+					headers: speculative ? {
+						[config.requestHeader]: "1",
+						purpose: "prefetch"
+					} : { [config.requestHeader]: "1" },
+					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 || url.href);
+				if (finalUrl.origin !== location.origin) throw new Error("MARKLESS_ROUTER_FRAGMENT_OFF_ORIGIN");
+				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: reader
+					};
+					const chunk = await reader.read();
+					if (chunk.done) {
+						entry.open = false;
+						return parse(finalUrl.href, text + decoder.decode());
+					}
+					text += decoder.decode(chunk.value, { stream: true });
+				}
+			};
+			const entry = {
+				at: w.performance.now(),
+				result: read(),
+				open: true,
+				abort: () => {
+					entry.open = false;
+					controller.abort();
+				}
+			};
+			entry.result.catch(() => entry.open = false);
+			return entry;
+		};
+		const prefetch = (url) => {
+			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;
+			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);
+			state.prefetches.set(key, entry);
+			w.setTimeout(() => {
+				if (state.prefetches.get(key) !== entry) return;
+				state.prefetches.delete(key);
+				entry.abort();
+			}, config.prefetchTtlMs);
+			preloadCode(url, true);
+		};
+		let scanning = false;
+		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);
+				}
+				const fragments = visible.size <= config.idleFragments * 2 ? config.idleFragments : 0;
+				let fetched = 0;
+				for (const [key, url] of visible) {
+					preloadCode(url, true);
+					if (fetched >= fragments || state.prefetches.has(key)) continue;
+					fetched += 1;
+					state.prefetch(url);
+				}
+			};
+			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
+		};
+		host.__marklessFragmentNav = state;
+		let restTimer = 0;
+		let previous;
+		d.addEventListener("pointermove", (event) => {
+			const pointer = event;
+			if (pointer.pointerType !== "mouse") return;
+			const point = {
+				x: pointer.clientX,
+				y: pointer.clientY,
+				t: pointer.timeStamp
+			};
+			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));
+		}, { passive: true });
+		d.addEventListener("pointerout", () => w.clearTimeout(restTimer), { passive: true });
+		for (const type of [
+			"pointerdown",
+			"touchstart",
+			"focusin"
+		]) d.addEventListener(type, (event) => {
+			w.clearTimeout(restTimer);
+			const url = eligible(anchorOf(event));
+			if (url) prefetch(url);
+		}, { passive: 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;
+			const url = eligible(anchor, true);
+			if (!url) return;
+			const current = new URL(location.href);
+			w.clearTimeout(restTimer);
+			event.preventDefault();
+			const replace = anchor.hasAttribute(config.replaceAttribute) || url.href === current.href;
+			const manual = anchor.getAttribute(config.scrollAttribute) === "manual";
+			load().then((entry) => entry.navigate(d, url, replace ? "replace" : "push", manual ? "manual" : "reset"), () => location.assign(url.href));
+		};
+		d.addEventListener("click", follow(true), true);
+		d.addEventListener("click", follow(false));
+		rescan();
+		return (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 FRAGMENT_REQUEST_HEADER = "x-markless-fragment";
+const FRAGMENT_REGION_END = "<!--markless:region-end-->";
+const FRAGMENT_APPEND_END = "<!--markless:append-end-->";
+const FRAGMENT_PREFETCH_TTL_MS = 3e4;
+//#endregion
+export { startFragmentNavigation as a, FRAGMENT_REQUEST_HEADER as i, FRAGMENT_PREFETCH_TTL_MS as n, appendModulePreloads as o, FRAGMENT_REGION_END as r, listenForLinkIntent as s, FRAGMENT_APPEND_END as t };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { createExternalDelegateStructureTokens, createExternalDelegateView } from "@markless/web/fns/external-delegate";
-
+//#region src/route-dom.d.ts
+declare const HTML_ATTRIBUTES_SLOT = "__marklessRouterHtmlAttributes";
+//#endregion
 //#region src/route-manifest.d.ts
 interface RouteManifestRoute {
   readonly pathname: string;
@@ -23,10 +25,10 @@ interface RouteManifestMatch {
   readonly route: RouteManifestRoute;
   readonly params: Readonly<Record<string, string>>;
 }
-declare function buildRouteManifestFromFileIds(fileIds: readonly string[]): RouteManifest;
-declare function normalizeRequestPathname(pathname: string): string;
-declare function normalizeRouteFileId(fileId: string): string;
-declare function matchRouteManifest(pathname: string, manifest: RouteManifest): RouteManifestMatch | undefined;
+export declare function buildRouteManifestFromFileIds(fileIds: readonly string[]): RouteManifest;
+export declare function normalizeRequestPathname(pathname: string): string;
+export declare function normalizeRouteFileId(fileId: string): string;
+export declare function matchRouteManifest(pathname: string, manifest: RouteManifest): RouteManifestMatch | undefined;
 //#endregion
 //#region src/request-files.d.ts
 type RequestFileDiagnosticCode = 'http-method-export' | 'invalid-cache-metadata' | 'missing-default-function';
@@ -74,12 +76,12 @@ type RequestFileParseResult = {
   readonly file: string;
   readonly kind: 'middleware';
 };
-declare function parseRequestFile(fileId: string, sourceText: string): RequestFileParseResult;
-declare function normalizeRequestFileId(fileId: string): string;
-declare function transformRequestFileSource(fileId: string, sourceText: string): RequestFileTransformResult | undefined;
+export declare function parseRequestFile(fileId: string, sourceText: string): RequestFileParseResult;
+export declare function normalizeRequestFileId(fileId: string): string;
+export declare function transformRequestFileSource(fileId: string, sourceText: string): RequestFileTransformResult | undefined;
 //#endregion
 //#region src/route-renderer.d.ts
-declare function startRouteUpdateRenderer(document?: Document): void;
+export declare function startRouteUpdateRenderer(document?: Document): void;
 //#endregion
 //#region src/spa-navigation.d.ts
 type MarklessRouterNavigationRuntime = Pick<Navigation, 'addEventListener' | 'navigate'>;
@@ -97,17 +99,19 @@ interface MarklessRouterNavigationPolyfillModule {
 }
 interface StartSpaNavigationOptions {
   readonly documentModuleLoader?: () => Promise<unknown>;
+  readonly documentNavigation?: 'client' | 'document';
   readonly loadPolyfill?: () => Promise<MarklessRouterNavigationPolyfillModule>;
   readonly pageModuleLoaders: Record<string, () => Promise<unknown>>;
   readonly preloadRouteModule?: (file: string) => unknown;
   readonly routeFileIds: readonly string[];
   readonly window?: MarklessRouterNavigationWindow;
 }
-declare function __marklessRouterStartSpaNavigation(options: StartSpaNavigationOptions): Promise<void>;
-declare function ensureNavigationRuntime(runtimeWindow?: MarklessRouterNavigationWindow, loadPolyfill?: () => Promise<MarklessRouterNavigationPolyfillModule>): Promise<MarklessRouterNavigationRuntime>;
+export declare function __marklessRouterStartSpaNavigation(options: StartSpaNavigationOptions): Promise<void>;
+export declare function ensureNavigationRuntime(runtimeWindow?: MarklessRouterNavigationWindow, loadPolyfill?: () => Promise<MarklessRouterNavigationPolyfillModule>): Promise<MarklessRouterNavigationRuntime>;
 //#endregion
 //#region src/route-state.d.ts
-declare const MARKLESS_ROUTER_ROUTE_EVENT = "marklessrouternavigate";
+export declare const MARKLESS_ROUTER_ROUTE_EVENT = "marklessrouternavigate";
+export declare const MARKLESS_ROUTER_RENDERED_EVENT = "marklessrouterrendered";
 interface RouteState {
   readonly file: string;
   readonly params: Readonly<Record<string, string>>;
@@ -127,11 +131,18 @@ interface RouteUpdate {
   readonly signal?: AbortSignal;
   readonly onRendered?: () => void;
 }
-declare function routePageProps(route: RouteState): PageProps;
-declare function dispatchRouteUpdate(document: Document, update: RouteUpdate): void;
+export declare function routePageProps(route: RouteState): Omit<PageProps, 'http'>;
+export declare function dispatchRouteUpdate(document: Document, update: RouteUpdate): void;
 //#endregion
 //#region src/index.d.ts
-interface PageProps<Params extends object = Readonly<Record<string, string>>> {
+export interface PageProps<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals> {
+  /**
+   * The request and the response being written, the same object API routes and middleware get.
+   * It exists only while the page renders on the server: the compiler refuses any read of it from
+   * code that runs in the browser. Set `http.response.status` and `http.response.headers` before the
+   * first byte is sent; a later write that changes them throws `MARKLESS_ROUTER_RESPONSE_COMMITTED`.
+   */
+  readonly http: HttpContext<Locals>;
   readonly params: Readonly<Params>;
   readonly url: {
     readonly href: string;
@@ -140,52 +151,62 @@ interface PageProps<Params extends object = Readonly<Record<string, string>>> {
   };
   readonly status: number;
 }
-interface MarklessRouterGeneratedRoutes {}
-interface LinkNavigationProps {
-  readonly prefetch?: boolean | 'intent' | 'viewport';
+export interface MarklessRouterGeneratedRoutes {}
+export interface LinkNavigationProps {
+  /**
+   * `false`: nothing for this link downloads before it is clicked. Only page routes are ever
+   * prefetched (with a `Purpose: prefetch` header), never `/api` endpoints; set `false` on a link to
+   * a page whose GET has side effects (a one-time token, a counter) so only the click requests it.
+   */
+  readonly prefetch?: boolean;
   readonly replace?: boolean;
   readonly scroll?: boolean;
 }
-type DefaultLinkProps = {
+export type DefaultLinkProps = {
   readonly href?: string;
-  readonly children?: unknown;
+  readonly children?: __MarklessTypeService.Child;
   readonly class?: string;
   readonly id?: string;
   readonly target?: string;
   readonly rel?: string;
   readonly [prop: string]: unknown;
 } & LinkNavigationProps;
-type LinkProps = MarklessRouterGeneratedRoutes extends {
+export type LinkProps = MarklessRouterGeneratedRoutes extends {
   readonly link: infer Props;
-} ? Props : DefaultLinkProps;
-interface AppLocals {}
-interface HttpResponse {
+} ? Props & Pick<DefaultLinkProps, 'children' | 'class' | 'id' | 'target' | 'rel'> & {
+  readonly [prop: string]: unknown;
+} : DefaultLinkProps;
+export interface AppLocals {}
+export interface HttpResponse {
   readonly headers: Headers;
   status?: number;
   statusText?: string;
 }
-interface HttpContext<Locals extends object = AppLocals> {
+export interface HttpContext<Locals extends object = AppLocals> {
   readonly locals: Locals;
   readonly request: Request;
   readonly response: HttpResponse;
   readonly url: URL;
 }
-interface EndpointHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals> extends HttpContext<Locals> {
+export interface EndpointHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals> extends HttpContext<Locals> {
   readonly params: Readonly<Params>;
 }
-interface MiddlewareHttpContext<Locals extends object = AppLocals> extends HttpContext<Locals> {}
+export interface MiddlewareHttpContext<Locals extends object = AppLocals> extends HttpContext<Locals> {}
 type RuntimeHttpEvent = {
   readonly context?: Record<string, unknown>;
   readonly req?: Request;
   readonly res?: HttpResponse;
   readonly url?: URL;
 };
-declare function __marklessCreateHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals>(event: RuntimeHttpEvent): EndpointHttpContext<Params, Locals>;
-declare const Html: ((props: {
-  readonly children?: unknown;
+export declare function __marklessCreateHttpContext<Params extends object = Readonly<Record<string, string>>, Locals extends object = AppLocals>(event: RuntimeHttpEvent): EndpointHttpContext<Params, Locals>;
+export declare const Html: ((props: {
+  readonly children?: __MarklessTypeService.Child;
 }) => unknown) & {
   renderSsr(props?: {
-    readonly children?: unknown;
+    readonly children?: __MarklessTypeService.Child;
+    readonly [name: string]: unknown;
+  }, renderContext?: {
+    readonly [HTML_ATTRIBUTES_SLOT]?: Record<string, unknown>;
   }): {
     html: string;
     elementCount: number;
@@ -207,6 +228,6 @@ type LinkComponent = {
     view: ReturnType<typeof createExternalDelegateView>;
   };
 };
-declare const Link: LinkComponent;
+export declare const Link: LinkComponent;
 //#endregion
-export { type ApiRequestFileCache, type ApiRequestFileMethod, type ApiRequestFileRoute, AppLocals, DefaultLinkProps, EndpointHttpContext, Html, HttpContext, HttpResponse, Link, LinkNavigationProps, LinkProps, MARKLESS_ROUTER_ROUTE_EVENT, MarklessRouterGeneratedRoutes, MiddlewareHttpContext, PageProps, type RequestFileDefaultExport, type RequestFileDiagnostic, type RequestFileDiagnosticCode, type RequestFileParam, type RequestFileParseResult, type RequestFileTransformResult, type RouteDocumentModule, type RouteManifest, type RouteManifestMatch, type RouteManifestParam, type RouteManifestRoute, type RouteManifestStatusPages, type RoutePageModule, type RouteState, type RouteUpdate, __marklessCreateHttpContext, __marklessRouterStartSpaNavigation, buildRouteManifestFromFileIds, dispatchRouteUpdate, ensureNavigationRuntime, matchRouteManifest, normalizeRequestFileId, normalizeRequestPathname, normalizeRouteFileId, parseRequestFile, routePageProps, startRouteUpdateRenderer, transformRequestFileSource };
+export type { ApiRequestFileCache, ApiRequestFileMethod, ApiRequestFileRoute, RequestFileDefaultExport, RequestFileDiagnostic, RequestFileDiagnosticCode, RequestFileParam, RequestFileParseResult, RequestFileTransformResult, RouteDocumentModule, RouteManifest, RouteManifestMatch, RouteManifestParam, RouteManifestRoute, RouteManifestStatusPages, RoutePageModule, RouteState, RouteUpdate };