@askrjs/askr 0.0.52 → 0.0.54

package/dist/ssr-DEARZxJ5.js

@@ -0,0 +1,1413 @@
+import { t as __CONTROL_BOUNDARY__ } from "./control-DhFRTIoE.js";
+import { t as __ERROR_BOUNDARY__ } from "./vnode-CGMJYPMB.js";
+import { v as logger } from "./access-Bg4RJNC8.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { f as getExecutionContextFrame, l as callWithContext, m as markVNodeTreeWithContextFrame, n as createComponentInstance, p as getVNodeContextFrame } from "./component-internal-D9PLuFUc.js";
+import { f as getCurrentComponentInstance, w as setCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { h as cleanupComponent, m as isPromiseLike } from "./component-lifecycle-C7lnU9Bt.js";
+import { g as evaluateShowState, h as evaluateCaseState, i as evaluateForState, o as rollbackForStateTransaction, r as commitForStateTransaction } from "./for-internal-CSz8Unkq.js";
+import { c as stopRenderPhase$1, o as startRenderPhase$1, t as configureRenderContextProvider, u as SSRDataMissingError } from "./render-context-Clw3rFiO.js";
+import { a as disposeDefaultPortalScope, t as DefaultPortal } from "./portal-C47xkwXj.js";
+import { t as getPublicAttributeName } from "./attr-names-CjhzmHOn.js";
+import { t as createDataRuntime } from "./data-runtime-SJ1BSUvk.js";
+import { c as withTelemetry, i as dehydrateDataRuntime, t as createQueryPrefetchContext } from "./query-registry-CQIT4mXr.js";
+import { a as resolveRouteFromRoutes, t as _resolveRouteMatchFromRoutes } from "./route-matching-vJpvLVbX.js";
+import { f as resolveRouteRequest, g as isPageRenderEnvelope, h as isEmptyPageRenderEnvelope, i as isDeferred, m as createPageRenderEnvelope, t as DEFERRED_BOUNDARY } from "./deferred-DklLG4qM.js";
+import { n as renderDocument, t as SSR_RENDER_DATA_ATTR } from "./ssr-CbQO5xd3.js";
+//#region src/ssr/escape.ts
+/**
+* HTML escaping utilities for SSR
+*
+* Centralizes text and attribute escaping to avoid duplication
+* between sync and streaming SSR renderers.
+*/
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const escapeCache = /* @__PURE__ */ new Map();
+const MAX_CACHE_SIZE = 256;
+const CSS_UNSAFE_RE = /[{}<>\\]/g;
+const CSS_URI_SCHEME_RE = /(?:^|[\s(,])([a-z][a-z0-9+.-]*):/i;
+const CSS_FUNCTION_NAME_RE = /([a-z-][a-z0-9-]*)\s*\(/gi;
+const CSS_ALLOWED_FUNCTIONS = /* @__PURE__ */ new Set([
+	"var",
+	"calc",
+	"min",
+	"max",
+	"clamp",
+	"rgb",
+	"rgba",
+	"hsl",
+	"hsla",
+	"lab",
+	"lch",
+	"oklab",
+	"oklch",
+	"color",
+	"color-mix",
+	"translate",
+	"translatex",
+	"translatey",
+	"translatez",
+	"scale",
+	"scalex",
+	"scaley",
+	"scalez",
+	"rotate",
+	"rotatex",
+	"rotatey",
+	"rotatez",
+	"skew",
+	"skewx",
+	"skewy",
+	"matrix",
+	"matrix3d",
+	"linear-gradient",
+	"radial-gradient",
+	"conic-gradient",
+	"repeating-linear-gradient",
+	"repeating-radial-gradient",
+	"repeating-conic-gradient",
+	"cubic-bezier",
+	"steps"
+]);
+const STYLE_PROP_CACHE = /* @__PURE__ */ new Map();
+const MAX_STYLE_PROP_CACHE_SIZE = 512;
+function toKebabCached(prop) {
+	const cached = STYLE_PROP_CACHE.get(prop);
+	if (cached !== void 0) return cached;
+	const kebab = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+	if (STYLE_PROP_CACHE.size < MAX_STYLE_PROP_CACHE_SIZE) STYLE_PROP_CACHE.set(prop, kebab);
+	return kebab;
+}
+/**
+* Clear the escape cache. Call between SSR requests in long-running servers
+* to prevent memory buildup from unique strings.
+*/
+function clearEscapeCache() {
+	escapeCache.clear();
+}
+/**
+* Fast check if a string needs text escaping.
+* Used to skip the full escape call when not needed.
+*/
+function needsEscapeText(text) {
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charCodeAt(i);
+		if (ch === 38 || ch === 60 || ch === 62) return true;
+	}
+	return false;
+}
+/**
+* Fast check if a string needs attribute escaping.
+* Checks for & " ' < > characters.
+*/
+function needsEscapeAttr(value) {
+	for (let i = 0; i < value.length; i++) {
+		const ch = value.charCodeAt(i);
+		if (ch === 38 || ch === 34 || ch === 39 || ch === 60 || ch === 62) return true;
+	}
+	return false;
+}
+/**
+* Escape HTML special characters in text content
+* Fast-path: cache first, then scan-then-escape for new strings
+*/
+function escapeText(text) {
+	const useCache = text.length <= 64;
+	if (useCache) {
+		const cached = escapeCache.get(text);
+		if (cached !== void 0) return cached;
+	}
+	if (!needsEscapeText(text)) {
+		if (useCache && escapeCache.size < MAX_CACHE_SIZE) escapeCache.set(text, text);
+		return text;
+	}
+	let escaped = "";
+	let lastIndex = 0;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charCodeAt(i);
+		let entity;
+		if (ch === 38) entity = "&amp;";
+		else if (ch === 60) entity = "&lt;";
+		else if (ch === 62) entity = "&gt;";
+		else continue;
+		escaped += text.slice(lastIndex, i) + entity;
+		lastIndex = i + 1;
+	}
+	const result = escaped + text.slice(lastIndex);
+	if (useCache && escapeCache.size < MAX_CACHE_SIZE) escapeCache.set(text, result);
+	return result;
+}
+/**
+* Escape HTML special characters in attribute values.
+* Single-pass scan: returns the original string unchanged when no special
+* characters are found, so callers can drop separate needsEscapeAttr checks.
+*/
+function escapeAttr(value) {
+	let escaped = "";
+	let lastIndex = 0;
+	for (let i = 0; i < value.length; i++) {
+		const ch = value.charCodeAt(i);
+		let entity;
+		if (ch === 38) entity = "&amp;";
+		else if (ch === 34) entity = "&quot;";
+		else if (ch === 39) entity = "&#x27;";
+		else if (ch === 60) entity = "&lt;";
+		else if (ch === 62) entity = "&gt;";
+		else continue;
+		escaped += value.slice(lastIndex, i) + entity;
+		lastIndex = i + 1;
+	}
+	return lastIndex === 0 ? value : escaped + value.slice(lastIndex);
+}
+/**
+* Escape CSS value to prevent injection attacks.
+* Removes characters that could break out of CSS context.
+*/
+function escapeCssValue(value) {
+	const str = String(value);
+	if (CSS_URI_SCHEME_RE.test(str)) return "";
+	if (str.includes("(")) {
+		for (const match of str.matchAll(CSS_FUNCTION_NAME_RE)) if (!CSS_ALLOWED_FUNCTIONS.has(match[1].toLowerCase())) return "";
+	}
+	return str.replace(CSS_UNSAFE_RE, "");
+}
+/**
+* Convert style object to CSS string with value escaping
+* Optimized to avoid Object.entries allocation
+*/
+function styleObjToCss(value) {
+	if (!value || typeof value !== "object") return null;
+	const styleObj = value;
+	let result = "";
+	for (const k in styleObj) {
+		const v = styleObj[k];
+		if (v === null || v === void 0 || v === false) continue;
+		const prop = toKebabCached(k);
+		const safeValue = escapeCssValue(String(v));
+		if (safeValue) result += `${prop}:${safeValue};`;
+	}
+	return result || null;
+}
+//#endregion
+//#region src/ssr/context.ts
+/**
+* SSR Context Management
+*
+* Provides render-context storage for server-side rendering.
+* Node SSR lazily installs AsyncLocalStorage on first use; browser builds use
+* the fallback stack.
+*/
+const FALLBACK_ASYNC_CONTEXT_ERROR = "[Askr] async SSR render context fallback is unsupported in this environment. Use synchronous SSR rendering or a runtime with AsyncLocalStorage.";
+let renderContextAccessor = null;
+let renderContextAccessorInitialized = false;
+let asyncRenderContextAccessor = null;
+let fallbackStack = null;
+function ensureRenderContextAccessor() {
+	if (renderContextAccessorInitialized) return;
+	renderContextAccessorInitialized = true;
+	if (typeof process === "undefined" || !process.versions?.node) return;
+	try {
+		const asyncHooks = new Function("return require(" + JSON.stringify("async_hooks") + ");")();
+		if (asyncHooks.AsyncLocalStorage) {
+			const asyncLocalStorage = new asyncHooks.AsyncLocalStorage();
+			renderContextAccessor = {
+				getStore() {
+					return asyncLocalStorage.getStore();
+				},
+				run(store, fn) {
+					return asyncLocalStorage.run(store, fn);
+				}
+			};
+		}
+	} catch {}
+}
+function createRenderContext(seed = 12345, opts = {}) {
+	clearEscapeCache();
+	const queryCache = /* @__PURE__ */ new Map();
+	const envelope = opts.envelope ?? createPageRenderEnvelope({
+		resources: opts.data,
+		framework: opts.framework
+	});
+	return {
+		url: opts.url ?? "",
+		seed,
+		data: opts.data,
+		params: opts.params,
+		routes: opts.routes,
+		routeAuth: opts.routeAuth,
+		signal: opts.signal,
+		dataRuntime: opts.dataRuntime ?? createDataRuntime({ queryCache }),
+		mode: opts.mode ?? "ssr",
+		queryPrefetch: opts.queryPrefetch,
+		queryCache,
+		resourceDataProvided: opts.envelope ? Object.keys(envelope.resources).some((key) => key.startsWith("r:")) : opts.data !== void 0,
+		ssrCleanupFns: [],
+		keyCounter: 0,
+		renderData: envelope,
+		hydrationData: envelope,
+		deferredBoundaries: []
+	};
+}
+/**
+* Run a function with the given render context.
+* Concurrency-safe in Node.js via AsyncLocalStorage.
+*/
+function withRenderContext(ctx, fn) {
+	ensureRenderContextAccessor();
+	if (renderContextAccessor) return renderContextAccessor.run(ctx, fn);
+	const prev = fallbackStack;
+	fallbackStack = ctx;
+	try {
+		const result = fn();
+		if (isPromiseLike(result)) throw new Error(FALLBACK_ASYNC_CONTEXT_ERROR);
+		return result;
+	} finally {
+		fallbackStack = prev;
+	}
+}
+async function getAsyncRenderContextAccessor() {
+	ensureRenderContextAccessor();
+	if (renderContextAccessor) return renderContextAccessor;
+	if (typeof process === "undefined" || !process.versions?.node) return null;
+	asyncRenderContextAccessor ??= (async () => {
+		try {
+			const module = await import(
+				/* @vite-ignore */
+				"node:async_hooks"
+);
+			if (!module.AsyncLocalStorage) return null;
+			const storage = new module.AsyncLocalStorage();
+			renderContextAccessor = {
+				getStore: () => storage.getStore(),
+				run: (store, fn) => storage.run(store, fn)
+			};
+			return renderContextAccessor;
+		} catch {
+			return null;
+		}
+	})();
+	return asyncRenderContextAccessor;
+}
+async function withRenderContextAsync(ctx, fn) {
+	const accessor = await getAsyncRenderContextAccessor();
+	if (accessor) return accessor.run(ctx, () => Promise.resolve(fn()));
+	const previous = fallbackStack;
+	fallbackStack = ctx;
+	try {
+		return await fn();
+	} finally {
+		fallbackStack = previous;
+	}
+}
+/**
+* Get the current render context.
+* Returns null if not inside a render.
+*/
+function getRenderContext() {
+	ensureRenderContextAccessor();
+	if (renderContextAccessor) return renderContextAccessor.getStore() ?? null;
+	return fallbackStack;
+}
+configureRenderContextProvider({ getRenderContext });
+/**
+* Centralized SSR enforcement helper — throws a consistent error when async
+* data is encountered during synchronous SSR.
+*/
+function throwSSRDataMissing() {
+	throw new SSRDataMissingError();
+}
+//#endregion
+//#region src/ssr/route-policy-resolution.ts
+const MAX_SSR_REDIRECTS = 20;
+function getRouteRequestResultSync(result) {
+	if (isPromiseLike(result)) throwSSRDataMissing();
+	return result;
+}
+function buildDeniedRoute(route, status) {
+	return {
+		...route,
+		handler: () => ({
+			type: "div",
+			props: { "data-route-denied": String(status) },
+			children: [String(status)]
+		})
+	};
+}
+function routeHasSSRLoader(manifest, route) {
+	const routeFallbackPrefix = route.fallbackPrefix;
+	return manifest.records.some((record) => {
+		const recordFallbackPrefix = record.fallbackPrefix;
+		return record.path === route.path && recordFallbackPrefix === routeFallbackPrefix && typeof record.options?.loader === "function";
+	});
+}
+function resolvePolicyAwareSSRRoute(opts, routeTable) {
+	const manifest = opts.registry?.manifest;
+	if (!manifest) {
+		const matched = _resolveRouteMatchFromRoutes(new URL(opts.url, "http://localhost").pathname, routeTable);
+		if (!matched) throw new Error(`SSR: no route found for url: ${opts.url}`);
+		return {
+			url: opts.url,
+			route: matched.route,
+			params: matched.params
+		};
+	}
+	let href = opts.url;
+	const visited = /* @__PURE__ */ new Set();
+	for (let redirects = 0; redirects <= MAX_SSR_REDIRECTS; redirects += 1) {
+		const matched = _resolveRouteMatchFromRoutes(new URL(href, "http://localhost").pathname, routeTable);
+		if (!matched) throw new Error(`SSR: no route found for url: ${href}`);
+		const resolved = getRouteRequestResultSync(resolveRouteRequest(href, {
+			manifest,
+			mode: "ssr"
+		}));
+		if (resolved === null) throw new Error(`SSR: no route found for url: ${href}`);
+		if (resolved.kind === "redirect") {
+			const redirectTarget = new URL(resolved.to, "http://localhost");
+			const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
+			if (redirectHref === href || visited.has(redirectHref)) throw new Error(`[Askr] SSR redirect cycle detected at ${redirectHref}.`);
+			if (redirects >= MAX_SSR_REDIRECTS) throw new Error(`[Askr] SSR redirect limit exceeded (${MAX_SSR_REDIRECTS}).`);
+			visited.add(redirectHref);
+			href = redirectHref;
+			continue;
+		}
+		if (resolved.kind === "deny") return {
+			url: href,
+			route: buildDeniedRoute(matched.route, resolved.status),
+			params: matched.params
+		};
+		return {
+			url: href,
+			route: {
+				...matched.route,
+				handler: routeHasSSRLoader(manifest, matched.route) ? resolved.handler : matched.route.handler
+			},
+			params: matched.params
+		};
+	}
+	throw new Error(`[Askr] SSR redirect limit exceeded (${MAX_SSR_REDIRECTS}).`);
+}
+//#endregion
+//#region src/ssr/sink.ts
+var StringSink = class StringSink {
+	constructor() {
+		this.chunks = [];
+		this.bufferChunks = [];
+		this.bufferLen = 0;
+	}
+	static {
+		this.FLUSH_THRESHOLD = 32 * 1024;
+	}
+	write(html) {
+		if (!html) return;
+		this.bufferChunks.push(html);
+		this.bufferLen += html.length;
+		if (this.bufferLen >= StringSink.FLUSH_THRESHOLD) {
+			this.chunks.push(this.bufferChunks.join(""));
+			this.bufferChunks.length = 0;
+			this.bufferLen = 0;
+		}
+	}
+	write2(a, b) {
+		if (a) {
+			this.bufferChunks.push(a);
+			this.bufferLen += a.length;
+		}
+		if (b) {
+			this.bufferChunks.push(b);
+			this.bufferLen += b.length;
+		}
+		if (this.bufferLen >= StringSink.FLUSH_THRESHOLD) {
+			this.chunks.push(this.bufferChunks.join(""));
+			this.bufferChunks.length = 0;
+			this.bufferLen = 0;
+		}
+	}
+	write3(a, b, c) {
+		if (a) {
+			this.bufferChunks.push(a);
+			this.bufferLen += a.length;
+		}
+		if (b) {
+			this.bufferChunks.push(b);
+			this.bufferLen += b.length;
+		}
+		if (c) {
+			this.bufferChunks.push(c);
+			this.bufferLen += c.length;
+		}
+		if (this.bufferLen >= StringSink.FLUSH_THRESHOLD) {
+			this.chunks.push(this.bufferChunks.join(""));
+			this.bufferChunks.length = 0;
+			this.bufferLen = 0;
+		}
+	}
+	end() {
+		if (this.bufferLen) {
+			this.chunks.push(this.bufferChunks.join(""));
+			this.bufferChunks.length = 0;
+			this.bufferLen = 0;
+		}
+	}
+	toString() {
+		if (this.bufferLen) {
+			this.chunks.push(this.bufferChunks.join(""));
+			this.bufferChunks.length = 0;
+			this.bufferLen = 0;
+		}
+		return this.chunks.join("");
+	}
+};
+var StreamSink = class {
+	constructor(onChunk, onComplete) {
+		this.onChunk = onChunk;
+		this.onComplete = onComplete;
+	}
+	write(html) {
+		if (html) this.onChunk(html);
+	}
+	end() {
+		this.onComplete();
+	}
+};
+//#endregion
+//#region src/ssr/route-render.ts
+async function resolveRequest(opts) {
+	const { url, auth, authContext, request, signal } = opts;
+	const manifest = opts.manifest ?? opts.registry?.manifest;
+	const routes = opts.routes ?? opts.registry?.routes;
+	if (manifest) return await resolveRouteRequest(url, {
+		manifest,
+		mode: "ssr",
+		auth,
+		authContext,
+		request,
+		signal
+	});
+	if (!routes) throw new Error("resolveRequest requires a route manifest or route table.");
+	const resolved = resolveRouteFromRoutes(new URL(url, "http://localhost").pathname, routes);
+	if (!resolved) return null;
+	return {
+		kind: "render",
+		handler: resolved.handler,
+		params: resolved.params
+	};
+}
+function resolveSSRRouteSource(source) {
+	const routes = source.routes ?? source.registry?.routes;
+	if (!routes || routes.length === 0) throw new Error("SSR requires a route registry or route table.");
+	return routes.map((route) => ({
+		...route,
+		path: route.path,
+		handler: route.handler,
+		namespace: route.namespace
+	}));
+}
+function resolveSSRRouteRender(opts) {
+	const { seed = 12345, data, document } = opts;
+	const routeTable = resolveSSRRouteSource(opts);
+	const resolvedRoute = resolvePolicyAwareSSRRoute(opts, routeTable);
+	const requestUrl = new URL(resolvedRoute.url, "http://localhost");
+	const ctx = createRenderContext(seed, {
+		url: resolvedRoute.url,
+		data,
+		params: resolvedRoute.params,
+		routes: routeTable,
+		dataRuntime: opts.dataRuntime,
+		queryPrefetch: opts.queryPrefetch,
+		envelope: opts.envelope
+	});
+	return {
+		url: resolvedRoute.url,
+		requestUrl,
+		route: resolvedRoute.route,
+		params: resolvedRoute.params,
+		seed,
+		data,
+		ctx,
+		document
+	};
+}
+function buildDocumentRenderArgs(resolved, appHtml) {
+	return {
+		appHtml,
+		context: {
+			mode: "ssr",
+			url: resolved.url,
+			pathname: resolved.requestUrl.pathname,
+			search: resolved.requestUrl.search,
+			hash: resolved.requestUrl.hash,
+			params: resolved.params,
+			data: resolved.data,
+			seed: resolved.seed,
+			route: {
+				path: resolved.route.path,
+				namespace: resolved.route.namespace
+			}
+		}
+	};
+}
+function renderResolvedRouteAppToSink(resolved, sink, host) {
+	host.renderAppToSink({
+		route: resolved.route,
+		params: resolved.params,
+		data: resolved.data,
+		ctx: resolved.ctx,
+		sink
+	});
+}
+function renderToSinkInternal(opts, host) {
+	const { sink, ...renderOptions } = opts;
+	return withTelemetry(renderOptions.telemetry?.ssrRender, {}, () => {
+		const resolved = resolveSSRRouteRender(renderOptions);
+		if (!resolved.document) {
+			renderResolvedRouteAppToSink(resolved, sink, host);
+			return;
+		}
+		const appSink = new StringSink();
+		renderResolvedRouteAppToSink(resolved, appSink, host);
+		appSink.end();
+		sink.write(renderDocument(resolved.document, buildDocumentRenderArgs(resolved, appSink.toString()), "renderToString()/renderToStream()"));
+	});
+}
+function renderRouteToString(opts, host) {
+	const sink = new StringSink();
+	renderToSinkInternal({
+		...opts,
+		sink
+	}, host);
+	sink.end();
+	return sink.toString();
+}
+function renderRouteToStream(opts, host) {
+	const sink = new StreamSink(opts.onChunk, opts.onComplete);
+	renderToSinkInternal({
+		...opts,
+		sink
+	}, host);
+	sink.end();
+}
+//#endregion
+//#region src/ssr/component-runtime.ts
+function executeComponentSync(component, props, ctx, ownerFrame = null) {
+	try {
+		const prev = getCurrentComponentInstance();
+		const temp = createComponentInstance("ssr-temp", component, props || {}, null);
+		temp.ssr = true;
+		temp.ownerFrame = ownerFrame;
+		temp.portalScope = temp;
+		ctx.ssrCleanupFns.push(() => {
+			let cleanupError = null;
+			try {
+				cleanupComponent(temp);
+			} catch (error) {
+				cleanupError = error;
+			}
+			try {
+				disposeDefaultPortalScope(temp);
+			} catch (error) {
+				if (cleanupError) throw new AggregateError([cleanupError, error], "SSR temporary owner cleanup failed");
+				throw error;
+			}
+			if (cleanupError) throw cleanupError;
+		});
+		setCurrentComponentInstance(temp);
+		try {
+			const result = callWithContext(getExecutionContextFrame(ownerFrame), component, props || {}, { ssr: ctx });
+			if (isPromiseLike(result)) throwSSRDataMissing();
+			if (typeof result === "string" || typeof result === "number" || typeof result === "boolean" || result === null || result === void 0) {
+				const inner = result === null || result === void 0 || result === false ? "" : String(result);
+				return {
+					$$typeof: ELEMENT_TYPE,
+					type: Fragment,
+					props: { children: inner ? [inner] : [] }
+				};
+			}
+			return markVNodeTreeWithContextFrame(result, ownerFrame);
+		} finally {
+			setCurrentComponentInstance(prev);
+		}
+	} finally {}
+}
+function disposeSSRTemporaryOwners(ctx) {
+	const cleanupFns = ctx.ssrCleanupFns;
+	ctx.ssrCleanupFns = [];
+	const cleanupErrors = [];
+	for (let index = cleanupFns.length - 1; index >= 0; index -= 1) try {
+		cleanupFns[index]();
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (cleanupErrors.length === 1) throw cleanupErrors[0];
+	if (cleanupErrors.length > 1) throw new AggregateError(cleanupErrors, "SSR temporary owner cleanup failed");
+}
+function wrapWithDefaultPortal(out) {
+	if (isPromiseLike(out)) throwSSRDataMissing();
+	const portalVNode = {
+		$$typeof: ELEMENT_TYPE,
+		type: DefaultPortal,
+		props: { __askrAutoDefaultPortal: true },
+		key: "__default_portal"
+	};
+	if (out == null) return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: [portalVNode] }
+	};
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: [out, portalVNode] }
+	};
+}
+function renderSyncComponentRoot(component, props, ctx) {
+	const wrapped = (p, c) => wrapWithDefaultPortal(component(p ?? {}, c));
+	return executeComponentSync(wrapped, props || {}, ctx);
+}
+//#endregion
+//#region src/ssr/boundaries.ts
+function normalizeRenderableChildren(value) {
+	if (value === null || value === void 0 || value === false) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function getRenderableChildren(node) {
+	if (Array.isArray(node.children)) return node.children;
+	if (Array.isArray(node.props?.children)) return node.props.children;
+	if (node.props?.children !== void 0 && node.props.children !== null && node.props.children !== false) return [node.props.children];
+}
+function getErrorBoundaryState(node) {
+	return node.__instance?.errorBoundaryState ?? null;
+}
+function resetErrorBoundaryState(node) {
+	const state = node.__instance?.errorBoundaryState;
+	if (state) {
+		state.error = null;
+		state.notified = false;
+	}
+}
+function createErrorBoundaryReset(node) {
+	return () => resetErrorBoundaryState(node);
+}
+function createDefaultErrorBoundaryFallbackVNode(error) {
+	const message = error instanceof Error ? error.stack || error.message || error.name : typeof error === "string" ? error : (() => {
+		try {
+			return JSON.stringify(error);
+		} catch {
+			return String(error);
+		}
+	})();
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: "div",
+		props: {
+			role: "alert",
+			"data-askr-error-boundary": "true",
+			style: {
+				boxSizing: "border-box",
+				padding: "1rem",
+				border: "1px solid currentColor",
+				borderRadius: "0.75rem",
+				display: "grid",
+				gap: "0.75rem",
+				maxWidth: "100%"
+			},
+			children: [
+				{
+					$$typeof: ELEMENT_TYPE,
+					type: "strong",
+					props: { children: ["Something went wrong while rendering this view."] }
+				},
+				{
+					$$typeof: ELEMENT_TYPE,
+					type: "p",
+					props: {
+						style: { margin: "0" },
+						children: ["The app recovered into a visible fallback so the error is not hidden in the console."]
+					}
+				},
+				{
+					$$typeof: ELEMENT_TYPE,
+					type: "details",
+					props: {
+						open: false,
+						children: [{
+							$$typeof: ELEMENT_TYPE,
+							type: "summary",
+							props: { children: ["Error details"] }
+						}, {
+							$$typeof: ELEMENT_TYPE,
+							type: "pre",
+							props: {
+								style: {
+									margin: "0",
+									whiteSpace: "pre-wrap",
+									wordBreak: "break-word"
+								},
+								children: [message]
+							}
+						}]
+					}
+				}
+			]
+		},
+		key: null
+	};
+}
+function resolveErrorBoundaryFallbackNode(fallback, error, reset) {
+	return typeof fallback === "function" ? fallback(error, reset) : fallback !== void 0 ? fallback : createDefaultErrorBoundaryFallbackVNode(error);
+}
+function getControlBoundaryState(node) {
+	const boundaryNode = node;
+	return boundaryNode._controlState ?? boundaryNode._forState ?? null;
+}
+function evaluateControlBoundaryChildren(node) {
+	if (node.type !== __CONTROL_BOUNDARY__) return;
+	const controlState = getControlBoundaryState(node);
+	if (!controlState) return [];
+	if (controlState.kind === "for") return evaluateForState(controlState);
+	if (controlState.kind === "show") return evaluateShowState(controlState);
+	return evaluateCaseState(controlState);
+}
+function withControlBoundaryChildren(node, render) {
+	const controlState = getControlBoundaryState(node);
+	if (!controlState || controlState.kind !== "for") return render(evaluateControlBoundaryChildren(node));
+	const children = evaluateForState(controlState);
+	try {
+		const result = render(children);
+		commitForStateTransaction(controlState);
+		return result;
+	} catch (error) {
+		rollbackForStateTransaction(controlState);
+		throw error;
+	}
+}
+//#endregion
+//#region src/ssr/attrs.ts
+const ESCAPED_ATTR_VALUE_CACHE_LIMIT = 512;
+const escapedAttrValueCache = /* @__PURE__ */ new Map();
+function isEventHandler(key) {
+	return key.length >= 3 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90;
+}
+function getEscapedAttrValue(value) {
+	if (value.length > 64) return escapeAttr(value);
+	const cached = escapedAttrValueCache.get(value);
+	if (cached !== void 0) return cached;
+	const escaped = escapeAttr(value);
+	if (escaped === value) return value;
+	if (escapedAttrValueCache.size >= ESCAPED_ATTR_VALUE_CACHE_LIMIT) escapedAttrValueCache.clear();
+	escapedAttrValueCache.set(value, escaped);
+	return escaped;
+}
+/**
+* Render attributes directly to a sink without intermediate string allocations.
+* This is the hot path for streaming SSR.
+*/
+function renderAttrsDirect(props, sink) {
+	if (!props || typeof props !== "object") return;
+	const propsObj = props;
+	for (const key in propsObj) {
+		const value = propsObj[key];
+		if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML") continue;
+		if (isEventHandler(key)) continue;
+		if (key.charCodeAt(0) === 95) continue;
+		const attrName = getPublicAttributeName(key);
+		if (attrName === "style") {
+			const css = typeof value === "string" ? value : styleObjToCss(value);
+			if (!css) continue;
+			sink.write(" style=\"");
+			if (needsEscapeAttr(css)) sink.write(getEscapedAttrValue(css));
+			else sink.write(css);
+			sink.write("\"");
+			continue;
+		}
+		if (value === true) {
+			sink.write(" ");
+			sink.write(attrName);
+			continue;
+		}
+		if (value === false || value === null || value === void 0) continue;
+		const strValue = String(value);
+		sink.write(" ");
+		sink.write(attrName);
+		sink.write("=\"");
+		sink.write(getEscapedAttrValue(strValue));
+		sink.write("\"");
+	}
+}
+function renderAttrs(props, opts) {
+	if (!props || typeof props !== "object") return opts?.returnDangerousHtml ? { attrs: "" } : "";
+	const attrParts = [];
+	let dangerousHtml;
+	const propsObj = props;
+	for (const key in propsObj) {
+		const value = propsObj[key];
+		if (key === "children") continue;
+		if (key === "key" || key === "ref") continue;
+		if (key === "dangerouslySetInnerHTML") {
+			if (value && typeof value === "object" && "__html" in value) dangerousHtml = String(value.__html);
+			continue;
+		}
+		if (isEventHandler(key)) continue;
+		if (key.charCodeAt(0) === 95) continue;
+		const attrName = key === "class" ? "class" : getPublicAttributeName(key);
+		if (attrName === "style") {
+			const css = typeof value === "string" ? value : styleObjToCss(value);
+			if (css === null || css === "") continue;
+			attrParts.push(` style="${getEscapedAttrValue(css)}"`);
+			continue;
+		}
+		if (value === true) attrParts.push(` ${attrName}`);
+		else if (value === false || value === null || value === void 0) continue;
+		else {
+			const strValue = String(value);
+			attrParts.push(` ${attrName}="${getEscapedAttrValue(strValue)}"`);
+		}
+	}
+	const result = attrParts.join("");
+	if (opts?.returnDangerousHtml) return {
+		attrs: result,
+		dangerousHtml
+	};
+	return result;
+}
+//#endregion
+//#region src/ssr/hydration-data.ts
+const DEFERRED_PAYLOAD = "__askr_deferred__";
+function hydrationReplacer(_key, value) {
+	if (!isDeferred(value)) return value;
+	if (value.state === "fulfilled") return {
+		[DEFERRED_PAYLOAD]: "fulfilled",
+		value: value.value
+	};
+	if (value.state === "rejected") return {
+		[DEFERRED_PAYLOAD]: "rejected",
+		error: value.error instanceof Error ? value.error.message : String(value.error)
+	};
+	return { [DEFERRED_PAYLOAD]: "pending" };
+}
+function serializeHydrationRenderData(data, runtime) {
+	const queryCache = runtime ? dehydrateDataRuntime(runtime) : void 0;
+	const current = isPageRenderEnvelope(data) ? data : createPageRenderEnvelope({ resources: data });
+	const payload = createPageRenderEnvelope({
+		resources: {
+			...current.resources,
+			...queryCache
+		},
+		route: current.route,
+		framework: current.framework
+	});
+	if (isEmptyPageRenderEnvelope(payload)) return "";
+	return `<script type="application/json" ${SSR_RENDER_DATA_ATTR}="true">${JSON.stringify(payload, hydrationReplacer).replace(/</g, "\\u003C").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}<\/script>`;
+}
+//#endregion
+//#region src/ssr/render-keys.ts
+function startRenderPhase(data) {
+	startRenderPhase$1(data === null ? null : isPageRenderEnvelope(data) ? data : createPageRenderEnvelope({ resources: data }));
+}
+function stopRenderPhase() {
+	stopRenderPhase$1();
+}
+//#endregion
+//#region src/ssr/render-sync.ts
+const RANGE_START = "<!--askr-range-start-->";
+const RANGE_END = "<!--askr-range-end-->";
+function renderDeferredBoundarySync(node, ctx) {
+	const id = String(node.props?.["id"] ?? "");
+	const pending = node.props?.["pending"];
+	return `<askr-resolve data-askr-deferred="${id}">${renderRenderableSync(pending, ctx)}</askr-resolve>`;
+}
+function isMultiRangeChild(child) {
+	if (Array.isArray(child)) return child.length !== 1;
+	if (!child || typeof child !== "object" || !("type" in child)) return false;
+	const vnode = child;
+	if (vnode.type !== Fragment) return false;
+	return (getRenderableChildren(vnode)?.length ?? 0) !== 1;
+}
+function renderControlChildrenSync(node, ctx) {
+	const controlState = node._controlState ?? node._forState;
+	return withControlBoundaryChildren(node, (children) => {
+		const values = children ?? [];
+		if (controlState?.kind === "for") return values.map((child) => {
+			const rendered = renderChildSync(child, ctx);
+			return isMultiRangeChild(child) ? `${RANGE_START}${rendered}${RANGE_END}` : rendered;
+		}).join("");
+		const rendered = renderChildrenSync(values, ctx);
+		return values.length === 1 && isMultiRangeChild(values[0]) ? `${RANGE_START}${rendered}${RANGE_END}` : values.length !== 1 ? `${RANGE_START}${rendered}${RANGE_END}` : rendered;
+	});
+}
+function inheritRenderableKey(source, result) {
+	const inheritedKey = source.key;
+	if (inheritedKey === void 0 || inheritedKey === null) return result;
+	if (!result || typeof result !== "object" || !("type" in result)) return result;
+	const resultVNode = result;
+	if (resultVNode.key === void 0 || resultVNode.key === null) resultVNode.key = inheritedKey;
+	if (typeof resultVNode.type === "string") {
+		if (!resultVNode.props) resultVNode.props = {};
+		if (resultVNode.props["data-key"] === void 0) resultVNode.props["data-key"] = String(inheritedKey);
+		if (resultVNode.props["data-askr-key-kind"] === void 0) resultVNode.props["data-askr-key-kind"] = typeof inheritedKey;
+	}
+	return result;
+}
+function renderRenderableSync(value, ctx) {
+	if (typeof value === "string") return escapeText(value);
+	if (typeof value === "number") return escapeText(String(value));
+	if (value === null || value === void 0 || value === false) return "";
+	if (Array.isArray(value)) return renderChildrenSync(value, ctx);
+	if (value && typeof value === "object" && "type" in value) return renderNodeSync(value, ctx);
+	return "";
+}
+function renderChildSync(child, ctx) {
+	return renderRenderableSync(child, ctx);
+}
+function renderRenderableSyncToSink(value, sink, ctx) {
+	if (value === null || value === void 0 || value === false) return;
+	if (typeof value === "string") {
+		sink.write(escapeText(value));
+		return;
+	}
+	if (typeof value === "number") {
+		sink.write(escapeText(String(value)));
+		return;
+	}
+	if (Array.isArray(value)) {
+		renderChildrenSyncToSink(value, sink, ctx);
+		return;
+	}
+	if (value && typeof value === "object" && "type" in value) renderNodeSyncToSink(value, sink, ctx);
+}
+function renderChildSyncToSink(child, sink, ctx) {
+	renderRenderableSyncToSink(child, sink, ctx);
+}
+function renderChildrenSync(children, ctx) {
+	if (!children || !Array.isArray(children) || children.length === 0) return "";
+	if (children.length === 1) return renderChildSync(children[0], ctx);
+	if (children.length <= 8) {
+		let result = "";
+		for (const child of children) result += renderChildSync(child, ctx);
+		return result;
+	}
+	return Array.from({ length: children.length }, (_, index) => renderChildSync(children[index], ctx)).join("");
+}
+function renderErrorBoundaryFallbackValue(fallback, error, reset, ctx) {
+	const nextValue = resolveErrorBoundaryFallbackNode(fallback, error, reset);
+	return Array.isArray(nextValue) ? renderChildrenSync(normalizeRenderableChildren(nextValue), ctx) : renderChildSync(nextValue, ctx);
+}
+function renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx) {
+	sink.write(renderErrorBoundaryFallbackValue(fallback, error, reset, ctx));
+}
+function renderChildrenSyncToSink(children, sink, ctx) {
+	if (!children || !Array.isArray(children) || children.length === 0) return;
+	if (children.length >= 32) {
+		for (let i = 0; i < children.length; i++) renderRenderableSyncToSink(children[i], sink, ctx);
+		return;
+	}
+	for (let i = 0; i < children.length; i++) renderChildSyncToSink(children[i], sink, ctx);
+}
+function sinkWrite2(sink, a, b) {
+	if (typeof sink.write2 === "function") {
+		sink.write2(a, b);
+		return;
+	}
+	sink.write(a);
+	sink.write(b);
+}
+function sinkWrite3(sink, a, b, c) {
+	if (typeof sink.write3 === "function") {
+		sink.write3(a, b, c);
+		return;
+	}
+	sink.write(a);
+	sink.write(b);
+	sink.write(c);
+}
+function renderNodeSync(node, ctx) {
+	const { type, props } = node;
+	if (typeof type === "function") return renderRenderableSync(inheritRenderableKey(node, executeComponentSync(type, props, ctx, getVNodeContextFrame(node) ?? null)), ctx);
+	if (typeof type === "symbol") {
+		if (type === Fragment) return renderChildrenSync(getRenderableChildren(node), ctx);
+		if (type === __CONTROL_BOUNDARY__) return renderControlChildrenSync(node, ctx);
+		if (type === DEFERRED_BOUNDARY) return renderDeferredBoundarySync(node, ctx);
+		if (type === __ERROR_BOUNDARY__) {
+			const boundaryState = getErrorBoundaryState(node);
+			const fallback = props?.fallback;
+			const reset = createErrorBoundaryReset(node);
+			if (boundaryState?.error != null) return renderErrorBoundaryFallbackValue(fallback, boundaryState.error, reset, ctx);
+			try {
+				return renderChildrenSync(normalizeRenderableChildren(props?.children), ctx);
+			} catch (error) {
+				if (boundaryState) {
+					boundaryState.error = error;
+					boundaryState.notified = true;
+				}
+				logger.error("[Askr] ErrorBoundary caught render error:", error);
+				return renderErrorBoundaryFallbackValue(fallback, error, reset, ctx);
+			}
+		}
+		throw new Error(`renderNodeSync: unsupported VNode symbol type: ${String(type)}`);
+	}
+	const typeStr = type;
+	if (VOID_ELEMENTS.has(typeStr)) return `<${typeStr}${renderAttrs(props)} />`;
+	const maybeDangerous = props?.dangerouslySetInnerHTML;
+	if (maybeDangerous !== void 0 && maybeDangerous !== null) {
+		const { attrs, dangerousHtml } = renderAttrs(props, { returnDangerousHtml: true });
+		if (dangerousHtml !== void 0) return `<${typeStr}${attrs}>${dangerousHtml}</${typeStr}>`;
+		return `<${typeStr}${attrs}>${renderChildrenSync(getRenderableChildren(node), ctx)}</${typeStr}>`;
+	}
+	return `<${typeStr}${renderAttrs(props)}>${renderChildrenSync(getRenderableChildren(node), ctx)}</${typeStr}>`;
+}
+function renderNodeSyncToSink(node, sink, ctx) {
+	const { type, props } = node;
+	if (typeof type === "function") {
+		renderRenderableSyncToSink(inheritRenderableKey(node, executeComponentSync(type, props, ctx, getVNodeContextFrame(node) ?? null)), sink, ctx);
+		return;
+	}
+	if (typeof type === "symbol") {
+		if (type === Fragment) {
+			renderChildrenSyncToSink(getRenderableChildren(node), sink, ctx);
+			return;
+		}
+		if (type === __CONTROL_BOUNDARY__) {
+			const rendered = renderControlChildrenSync(node, ctx);
+			sink.write(rendered);
+			return;
+		}
+		if (type === DEFERRED_BOUNDARY) {
+			sink.write(renderDeferredBoundarySync(node, ctx));
+			return;
+		}
+		if (type === __ERROR_BOUNDARY__) {
+			const boundaryState = getErrorBoundaryState(node);
+			const fallback = props?.fallback;
+			const reset = createErrorBoundaryReset(node);
+			if (boundaryState?.error != null) {
+				renderErrorBoundaryFallbackValueToSink(fallback, boundaryState.error, reset, sink, ctx);
+				return;
+			}
+			try {
+				renderChildrenSyncToSink(normalizeRenderableChildren(props?.children), sink, ctx);
+			} catch (error) {
+				if (boundaryState) {
+					boundaryState.error = error;
+					boundaryState.notified = true;
+				}
+				logger.error("[Askr] ErrorBoundary caught render error:", error);
+				renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx);
+			}
+			return;
+		}
+		throw new Error(`renderNodeSyncToSink: unsupported VNode symbol type: ${String(type)}`);
+	}
+	const typeStr = type;
+	if (VOID_ELEMENTS.has(typeStr)) {
+		sinkWrite2(sink, "<", typeStr);
+		renderAttrsDirect(props, sink);
+		sink.write(" />");
+		return;
+	}
+	const maybeDangerous = props ? props?.dangerouslySetInnerHTML : void 0;
+	if (maybeDangerous !== void 0 && maybeDangerous !== null) {
+		const dangerousHtml = typeof maybeDangerous === "object" && "__html" in maybeDangerous ? String(maybeDangerous.__html) : void 0;
+		sinkWrite2(sink, "<", typeStr);
+		renderAttrsDirect(props, sink);
+		sink.write(">");
+		if (dangerousHtml !== void 0) sink.write(dangerousHtml);
+		else renderChildrenSyncToSink(getRenderableChildren(node), sink, ctx);
+		sinkWrite3(sink, "</", typeStr, ">");
+		return;
+	}
+	const children = getRenderableChildren(node);
+	if (!children || Array.isArray(children) && children.length === 0) {
+		sinkWrite2(sink, "<", typeStr);
+		renderAttrsDirect(props, sink);
+		sink.write(">");
+		sinkWrite3(sink, "</", typeStr, ">");
+		return;
+	}
+	if (Array.isArray(children) && children.length === 1) {
+		const only = children[0];
+		if (typeof only === "string") {
+			const content = escapeText(only);
+			sinkWrite2(sink, "<", typeStr);
+			renderAttrsDirect(props, sink);
+			sink.write(">");
+			sink.write(content);
+			sinkWrite3(sink, "</", typeStr, ">");
+			return;
+		}
+		if (typeof only === "number") {
+			const content = escapeText(String(only));
+			sinkWrite2(sink, "<", typeStr);
+			renderAttrsDirect(props, sink);
+			sink.write(">");
+			sink.write(content);
+			sinkWrite3(sink, "</", typeStr, ">");
+			return;
+		}
+	}
+	sinkWrite2(sink, "<", typeStr);
+	renderAttrsDirect(props, sink);
+	sink.write(">");
+	renderChildrenSyncToSink(children, sink, ctx);
+	sinkWrite3(sink, "</", typeStr, ">");
+}
+function renderToStringSync(component, props, options) {
+	const ctx = createRenderContext(options?.seed ?? 12345, {
+		data: options?.data,
+		envelope: options?.envelope
+	});
+	return withRenderContext(ctx, () => {
+		startRenderPhase(ctx.renderData);
+		try {
+			const node = renderSyncComponentRoot(component, props || {}, ctx);
+			if (!node) throw new Error("renderToStringSync: wrapped component returned empty");
+			const sink = new StringSink();
+			renderNodeSyncToSink(node, sink, ctx);
+			sink.write(serializeHydrationRenderData(ctx.hydrationData ?? void 0, ctx.dataRuntime));
+			sink.end();
+			return sink.toString();
+		} finally {
+			try {
+				stopRenderPhase();
+			} finally {
+				disposeSSRTemporaryOwners(ctx);
+			}
+		}
+	});
+}
+function renderSSRRouteAppToSink(input) {
+	const { ctx, data, route, params, sink } = input;
+	withRenderContext(ctx, () => {
+		startRenderPhase(ctx.renderData);
+		try {
+			renderRenderableSyncToSink(executeComponentSync(route.handler, params, ctx), sink, ctx);
+			if (ctx.deferredBoundaries.length === 0) sink.write(serializeHydrationRenderData(ctx.hydrationData ?? data, ctx.dataRuntime));
+		} finally {
+			try {
+				stopRenderPhase();
+			} finally {
+				disposeSSRTemporaryOwners(ctx);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/ssr/render-resolved.ts
+function sameRouteParams(left, right) {
+	if (!left || !right) return !left && !right;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) if (left[key] !== right[key]) return false;
+	return true;
+}
+function renderResolvedToStringSync(opts) {
+	const { url, routes, handler, params, options } = opts;
+	const requestUrl = new URL(url, "http://localhost");
+	const matchedIndex = routes.findIndex((route) => {
+		const resolved = resolveRouteFromRoutes(requestUrl.pathname, [route]);
+		return resolved !== null && resolved.handler === route.handler && sameRouteParams(resolved.params, params);
+	});
+	if (matchedIndex < 0) throw new Error(`renderResolvedToStringSync: no route found for url: ${url}`);
+	return renderToString({
+		url,
+		routes: routes.map((route, index) => index === matchedIndex ? {
+			...route,
+			handler
+		} : route),
+		seed: options?.seed,
+		data: options?.data,
+		dataRuntime: options?.dataRuntime,
+		envelope: options?.envelope
+	});
+}
+//#endregion
+//#region src/ssr/route-request-render.ts
+function abortError() {
+	const error = /* @__PURE__ */ new Error("Deferred route rendering was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function settleWithSignal(promise, signal) {
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(abortError());
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", abort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+function stripHydrationPayload(html) {
+	return html.replace(/<script type="application\/json" data-askr-render-data="true">[\s\S]*?<\/script>$/, "");
+}
+function renderBoundary(boundary, state, payload, seed, data) {
+	return stripHydrationPayload(renderToStringSync(() => state === "fulfilled" ? boundary.fulfilled(payload) : boundary.rejected(payload), {}, {
+		seed,
+		envelope: data ?? void 0
+	}));
+}
+function patchChunk(id, html) {
+	const selector = `askr-resolve[data-askr-deferred=${JSON.stringify(id)}]`;
+	return `<template data-askr-deferred-patch="${id}">${html}</template><script data-askr-deferred-apply="${id}">(function(s){var t=s.previousElementSibling;var b=document.querySelector(${JSON.stringify(selector)});if(b&&t){b.replaceWith(t.content.cloneNode(true));}if(t)t.remove();s.remove();})(document.currentScript)<\/script>`;
+}
+function createDeferredRenderStream(initialHtml, boundaries, signal, seed, data, runtime) {
+	const encoder = new TextEncoder();
+	const local = new AbortController();
+	let cancelled = false;
+	let closed = false;
+	let initialPending = true;
+	let boundaryIndex = 0;
+	let controllerRef;
+	const cleanup = () => signal.removeEventListener("abort", abort);
+	const close = (controller) => {
+		if (closed) return;
+		closed = true;
+		cleanup();
+		controller.close();
+	};
+	const abort = () => {
+		local.abort(signal.reason);
+		if (controllerRef) close(controllerRef);
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	return new ReadableStream({
+		start(controller) {
+			controllerRef = controller;
+		},
+		async pull(controller) {
+			if (cancelled || closed) return;
+			if (initialPending) {
+				initialPending = false;
+				controller.enqueue(encoder.encode(stripHydrationPayload(initialHtml)));
+				return;
+			}
+			const boundary = boundaries[boundaryIndex];
+			if (boundary) {
+				boundaryIndex += 1;
+				try {
+					const value = await settleWithSignal(boundary.promise, local.signal);
+					if (!cancelled && !closed) controller.enqueue(encoder.encode(patchChunk(boundary.id, renderBoundary(boundary, "fulfilled", value, seed, data))));
+				} catch (error) {
+					if (local.signal.aborted) {
+						if (!cancelled && !closed) close(controller);
+						return;
+					}
+					if (!cancelled && !closed) controller.enqueue(encoder.encode(patchChunk(boundary.id, renderBoundary(boundary, "rejected", error, seed, data))));
+				}
+				return;
+			}
+			const hydration = serializeHydrationRenderData(data ?? void 0, runtime);
+			if (hydration) controller.enqueue(encoder.encode(hydration));
+			close(controller);
+		},
+		cancel(reason) {
+			cancelled = true;
+			local.abort(reason);
+			cleanup();
+		}
+	});
+}
+async function renderRouteRequest(options) {
+	return renderRouteRequestInternal(options);
+}
+async function renderRouteRequestToString(options) {
+	const result = await renderRouteRequestInternal(options);
+	if (result.kind !== "render" || !result.stream) return result;
+	return {
+		...result,
+		html: await new Response(result.stream).text(),
+		stream: void 0
+	};
+}
+async function renderRouteRequestInternal(options) {
+	const manifest = options.manifest ?? options.registry?.manifest;
+	if (!manifest) throw new Error("renderRouteRequestToString requires a route manifest or registry.");
+	const signal = options.signal ?? options.request?.signal ?? new AbortController().signal;
+	const request = options.request ?? new Request(new URL(options.url, "http://localhost"));
+	const runtime = options.dataRuntime ?? createDataRuntime();
+	const prefetch = options.queryPrefetch ?? createQueryPrefetchContext({
+		runtime,
+		registry: options.queryRegistry,
+		request,
+		signal,
+		mode: "ssr",
+		telemetry: options.telemetry
+	});
+	const context = createRenderContext(options.seed, {
+		url: options.url,
+		data: options.data,
+		framework: options.framework,
+		signal,
+		dataRuntime: runtime,
+		queryPrefetch: prefetch,
+		mode: "ssr"
+	});
+	return withTelemetry(options.telemetry?.ssrRender, {}, () => withRenderContextAsync(context, async () => {
+		const resolved = await resolveRouteRequest(options.url, {
+			manifest,
+			mode: "ssr",
+			auth: options.auth ?? manifest.auth,
+			authContext: options.authContext,
+			request,
+			signal,
+			telemetry: options.telemetry
+		});
+		if (!resolved) return { kind: "no-match" };
+		if (resolved.kind !== "render") return resolved;
+		const sink = new StringSink();
+		renderSSRRouteAppToSink({
+			route: {
+				path: "",
+				handler: resolved.handler
+			},
+			params: resolved.params,
+			data: options.data,
+			ctx: context,
+			sink
+		});
+		sink.end();
+		const html = sink.toString();
+		const boundaries = [...context.deferredBoundaries];
+		const result = {
+			kind: "render",
+			html,
+			...boundaries.length > 0 ? { stream: createDeferredRenderStream(html, boundaries, signal, options.seed, context.hydrationData, runtime) } : {},
+			params: resolved.params
+		};
+		if (resolved.record) Object.defineProperty(result, "record", {
+			value: resolved.record,
+			enumerable: false
+		});
+		return result;
+	}));
+}
+//#endregion
+//#region src/ssr/index-internal.ts
+const routeRenderHost = { renderAppToSink: renderSSRRouteAppToSink };
+function renderToString(arg) {
+	if (typeof arg === "function") return renderToStringSync(arg);
+	return renderRouteToString(arg, routeRenderHost);
+}
+function renderToStream(opts) {
+	renderRouteToStream(opts, routeRenderHost);
+}
+//#endregion
+export { renderResolvedToStringSync as a, createRenderContext as c, withRenderContextAsync as d, renderRouteRequestToString as i, getRenderContext as l, renderToString as n, renderToStringSync as o, renderRouteRequest as r, resolveRequest as s, renderToStream as t, withRenderContext as u };