@askrjs/askr 0.2.4 → 0.3.1

package/dist/{ssr-Doog-AfJ.js → render-resolved-BC0W7_5b.js}

@@ -1,22 +1,20 @@
+import { v as logger } from "./access-CEA2pOry.js";
+import { P as isPromiseLike, S as markVNodeTreeWithContextFrame, T as cleanupComponent, g as getExecutionContextFrame, n as createComponentInstance, p as callWithContext, x as getVNodeContextFrame } from "./instance-VAFYVJOa.js";
+import { s as endComponentScope, u as enterRenderScopedComponent } from "./scope-Cq_iYbTR.js";
 import { t as __CONTROL_BOUNDARY__ } from "./control-C-ApnFs1.js";
 import { t as __ERROR_BOUNDARY__ } from "./vnode-D24p6IW2.js";
-import { y as logger } from "./access-BucjYZcX.js";
-import { f as getCurrentComponentInstance, w as setCurrentComponentInstance } from "./component-scope-4I3yEMkb.js";
 import { i as isFragmentType, n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-import { _ as getVNodeContextFrame, g as getExecutionContextFrame, n as createComponentInstance, p as callWithContext, y as markVNodeTreeWithContextFrame } from "./component-internal-C4hKKQBF.js";
-import { t as cleanupComponent } from "./component-cleanup-jdbgjkT1.js";
-import { p as isPromiseLike } from "./lifecycle-batch-63aXFf2S.js";
-import { _ as setControlBoundaryContextFrame, g as evaluateShowState, h as evaluateCaseState, i as evaluateForState, o as rollbackForStateTransaction, r as commitForStateTransaction } from "./for-internal-DyBHfKJA.js";
+import { _ as setControlBoundaryContextFrame, g as evaluateShowState, h as evaluateCaseState, i as evaluateForState, o as rollbackForStateTransaction, r as commitForStateTransaction } from "./for-state-BDykeOJL.js";
 import { C as SSRDataMissingError, _ as isEmptyPageRenderEnvelope, f as stopRenderPhase$1, h as createPageRenderEnvelope, t as configureRenderContextProvider, u as startRenderPhase$1, v as isPageRenderEnvelope, x as withHydrationRenderUrl } from "./render-context-B7ohlh6t.js";
-import { n as getPublicAttributeName, t as sanitizeCssValue } from "./css-BuPaTOfe.js";
-import { o as isUnsafeUrlAttribute, r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-9NFUb7hJ.js";
+import { a as booleanAttributeValue, c as normalizeStylePropertyName, i as sanitizeCssValue, l as getPublicAttributeName, o as isAriaAttribute, r as validateCspNonce, s as isSkippedProp, t as CspNonceScope } from "./csp-nonce-BfFWcd0w.js";
+import { r as isUnsafeUrlAttribute } from "./router-internal-7nuNEHfG.js";
 import { n as SSR_PORTAL_HOST, t as SSR_PORTAL_ANCHOR } from "./portal-w3oQ6oQU.js";
-import { t as createDataRuntime } from "./data-runtime-7t_Y0iv3.js";
-import { c as withTelemetry, i as dehydrateDataRuntime, t as createQueryPrefetchContext } from "./query-registry-Bua3cDyb.js";
-import { a as resolveRouteFromRoutes, c as removeRouteBasePath, s as normalizeRouteBasePath, t as _resolveRouteMatchFromRoutes } from "./route-matching-Bo6UqG-5.js";
-import { a as resolveRouteRequest, d as DEFERRED_BOUNDARY, l as validateRouteHydrationData, n as getRouteRenderContext, o as getRouteHydrationMetadata, p as isDeferred } from "./resolution-ClD-K7Lz.js";
+import { t as createDataRuntime } from "./data-runtime-CxoY98lX.js";
+import { i as dehydrateDataRuntime } from "./query-registry-LrYpQsDJ.js";
 import { n as disposeRegisteredDefaultPortalScope, r as getDefaultPortalHost } from "./default-portal-runtime-DvMvWJVp.js";
-import { n as renderDocument, t as SSR_RENDER_DATA_ATTR } from "./ssr-DSHd_Q9K.js";
+import { S as isDeferred, b as DEFERRED_BOUNDARY, h as getRouteHydrationMetadata, v as validateRouteHydrationData } from "./resolution-3DskUkjG.js";
+import { a as resolveRouteFromRoutes, c as removeRouteBasePath, s as normalizeRouteBasePath } from "./route-matching-CUzZ31gT.js";
+import { t as SSR_RENDER_DATA_ATTR } from "./ssr-EPjwJH5R.js";
 //#region src/ssr/escape.ts
 /**
 * HTML escaping utilities for SSR
@@ -47,7 +45,7 @@ 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()}`);
+	const kebab = normalizeStylePropertyName(prop);
 	if (STYLE_PROP_CACHE.size < MAX_STYLE_PROP_CACHE_SIZE) STYLE_PROP_CACHE.set(prop, kebab);
 	return kebab;
 }
@@ -224,6 +222,7 @@ function createRenderContext(seed = 12345, opts = {}) {
 * Concurrency-safe in Node.js via AsyncLocalStorage.
 */
 function withRenderContext(ctx, fn) {
+	ensureRenderContextProvider();
 	ensureRenderContextAccessor();
 	if (renderContextAccessor) return renderContextAccessor.run(ctx, fn);
 	const prev = fallbackStack;
@@ -261,6 +260,7 @@ async function getAsyncRenderContextAccessor() {
 }
 /** Run `fn` with `ctx` as the active SSR render context, using async-local storage. */
 async function withRenderContextAsync(ctx, fn) {
+	ensureRenderContextProvider();
 	const accessor = await getAsyncRenderContextAccessor();
 	if (accessor) return accessor.run(ctx, () => Promise.resolve(fn()));
 	throw new Error(FALLBACK_ASYNC_CONTEXT_ERROR);
@@ -274,7 +274,21 @@ function getRenderContext() {
 	if (renderContextAccessor) return renderContextAccessor.getStore() ?? null;
 	return fallbackStack;
 }
-configureRenderContextProvider({ getRenderContext });
+let renderContextProvided = false;
+/**
+* Publish this module's render-context accessor to `common/render-context`.
+*
+* Runtime code (resources, portals, deferred routes) asks that module for the
+* active SSR context, and it cannot import SSR. Installing the accessor at
+* module scope meant the answer depended on whether anything had imported this
+* module; entering a render context composes it instead. Consumers only ever
+* observe a context from inside one, so this covers every reader.
+*/
+function ensureRenderContextProvider() {
+	if (renderContextProvided) return;
+	renderContextProvided = true;
+	configureRenderContextProvider({ getRenderContext });
+}
 /**
 * Centralized SSR enforcement helper — throws a consistent error when async
 * data is encountered during synchronous SSR.
@@ -283,75 +297,6 @@ 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;
-	let href = opts.url;
-	const visited = /* @__PURE__ */ new Set();
-	for (let redirects = 0; redirects <= MAX_SSR_REDIRECTS; redirects += 1) {
-		const logicalHref = removeRouteBasePath(href, normalizeRouteBasePath(manifest.basePath));
-		if (logicalHref === void 0) throw new Error(`SSR: no route found for url: ${href}`);
-		const logicalUrl = new URL(logicalHref, "http://localhost");
-		const matched = _resolveRouteMatchFromRoutes(logicalUrl.pathname, routeTable);
-		if (!matched) throw new Error(`SSR: no route found for url: ${href}`);
-		const resolved = getRouteRequestResultSync(resolveRouteRequest(href, {
-			registry: opts.registry,
-			mode: "ssr",
-			auth: opts.auth,
-			authContext: opts.authContext,
-			request: opts.request,
-			signal: opts.signal
-		}));
-		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,
-			authContext: getRouteRenderContext(resolved)?.auth
-		};
-	}
-	throw new Error(`[Askr] SSR redirect limit exceeded (${MAX_SSR_REDIRECTS}).`);
-}
-//#endregion
 //#region src/ssr/sink.ts
 var StringSink = class StringSink {
 	constructor() {
@@ -435,129 +380,10 @@ var StreamSink = class {
 	}
 };
 //#endregion
-//#region src/ssr/route-render.ts
-/** Resolve a URL against a route registry for SSR, applying auth/policies before render. */
-async function resolveRequest(opts) {
-	if (!opts?.registry) throw new TypeError("resolveRequest requires opts.registry.");
-	const { url, auth, authContext, request, signal } = opts;
-	return await resolveRouteRequest(url, {
-		registry: opts.registry,
-		mode: "ssr",
-		auth,
-		authContext,
-		request,
-		signal
-	});
-}
-function resolveSSRRouteSource(source) {
-	if (source.registry.routes.length === 0) throw new Error("SSR requires a non-empty route registry.");
-	return source.registry.routes.map((route) => ({
-		...route,
-		path: route.path,
-		handler: route.handler,
-		namespace: route.namespace
-	}));
-}
-function resolveSSRRouteRender(opts) {
-	const { seed = 12345, data, document, styleRegistrationValidation = "warn" } = opts;
-	const cspNonce = validateCspNonce(opts.cspNonce);
-	const routeTable = resolveSSRRouteSource(opts);
-	const resolvedRoute = resolvePolicyAwareSSRRoute(opts, routeTable);
-	const requestUrl = new URL(resolvedRoute.url, "http://localhost");
-	const ctx = createRenderContext(seed, {
-		url: resolvedRoute.url,
-		basePath: opts.registry.manifest.basePath,
-		data,
-		params: resolvedRoute.params,
-		routes: routeTable,
-		routeAuth: opts.auth ?? opts.registry.manifest.auth,
-		signal: opts.signal ?? opts.request?.signal,
-		dataRuntime: opts.dataRuntime,
-		queryPrefetch: opts.queryPrefetch,
-		authContext: resolvedRoute.authContext,
-		envelope: opts.envelope,
-		cspNonce
-	});
-	return {
-		url: resolvedRoute.url,
-		requestUrl,
-		route: resolvedRoute.route,
-		params: resolvedRoute.params,
-		seed,
-		data,
-		ctx,
-		document,
-		cspNonce,
-		styleRegistrationValidation
-	};
-}
-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
-			},
-			cspNonce: resolved.cspNonce,
-			styles: Array.from(resolved.ctx.ssrStyles.values())
-		}
-	};
-}
-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()", resolved.styleRegistrationValidation));
-	});
-}
-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);
+		const temp = createComponentInstance("ssr-temp", component, props || {}, null, null);
 		temp.ssr = true;
 		temp.ownerFrame = ownerFrame;
 		temp.portalScope = temp;
@@ -576,7 +402,7 @@ function executeComponentSync(component, props, ctx, ownerFrame = null) {
 			}
 			if (cleanupError) throw cleanupError;
 		});
-		setCurrentComponentInstance(temp);
+		const previous = enterRenderScopedComponent(temp, 0);
 		try {
 			const executionFrame = getExecutionContextFrame(ownerFrame);
 			const result = callWithContext(executionFrame, component, props || {}, { ssr: ctx });
@@ -591,7 +417,7 @@ function executeComponentSync(component, props, ctx, ownerFrame = null) {
 			}
 			return markVNodeTreeWithContextFrame(result, ownerFrame);
 		} finally {
-			setCurrentComponentInstance(prev);
+			endComponentScope(previous);
 		}
 	} finally {}
 }
@@ -757,9 +583,6 @@ const escapedAttrValueCache = /* @__PURE__ */ new Map();
 function isEventHandler(key) {
 	return key.length >= 2 && key.slice(0, 2).toLowerCase() === "on";
 }
-function isAriaAttribute(key) {
-	return key.length > 5 && key.slice(0, 5).toLowerCase() === "aria-";
-}
 function assertAttributeName(name) {
 	if (!/^[A-Za-z_:][A-Za-z0-9_.:-]*$/.test(name)) throw new TypeError(`Invalid SSR attribute name: ${JSON.stringify(name)}`);
 }
@@ -782,7 +605,7 @@ function renderAttrsDirect(props, sink) {
 	const propsObj = props;
 	for (const key in propsObj) {
 		const value = propsObj[key];
-		if (key === "children" || key === "imperativeChildren" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML") continue;
+		if (isSkippedProp(key) || key === "dangerouslySetInnerHTML") continue;
 		if (isEventHandler(key)) continue;
 		if (key.charCodeAt(0) === 95) continue;
 		const attrName = getPublicAttributeName(key);
@@ -799,6 +622,12 @@ function renderAttrsDirect(props, sink) {
 		if (value === true) {
 			sink.write(" ");
 			sink.write(attrName);
+			const booleanValue = booleanAttributeValue(attrName);
+			if (booleanValue) {
+				sink.write("=\"");
+				sink.write(booleanValue);
+				sink.write("\"");
+			}
 			continue;
 		}
 		if (value === null || value === void 0 || value === false && !isAriaAttribute(attrName)) continue;
@@ -811,44 +640,6 @@ function renderAttrsDirect(props, sink) {
 		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" || key === "imperativeChildren") 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);
-		assertAttributeName(attrName);
-		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 === null || value === void 0 || value === false && !isAriaAttribute(attrName)) continue;
-		else {
-			const strValue = String(value);
-			if (isUnsafeUrlAttribute(attrName, strValue)) continue;
-			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__";
@@ -898,33 +689,11 @@ function stopRenderPhase() {
 //#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 true;
 	if (!child || typeof child !== "object" || !("type" in child)) return false;
 	return isFragmentType(child.type);
 }
-function renderForRangeChildSync(child, ctx) {
-	if (child && typeof child === "object" && "type" in child && typeof child.type === "function") {
-		const vnode = child;
-		return renderForRangeChildSync(inheritRenderableKey(vnode, executeComponentSync(vnode.type, vnode.props, ctx, getVNodeContextFrame(vnode) ?? null)), ctx);
-	}
-	const rendered = renderChildSync(child, ctx);
-	return isMultiRangeChild(child) ? `${RANGE_START}${rendered}${RANGE_END}` : rendered;
-}
-function renderControlChildrenSync(node, ctx) {
-	const controlState = getControlBoundaryState(node);
-	return withControlBoundaryChildren(node, (children) => {
-		const values = children ?? [];
-		if (controlState?.kind === "for") return values.map((child) => renderForRangeChildSync(child, ctx)).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;
@@ -938,13 +707,18 @@ function inheritRenderableKey(source, result) {
 	}
 	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 "";
+/**
+* Render a value to a string through the streaming renderer.
+*
+* Portal resolution splices content into the finished document by token, so it
+* genuinely needs a string — but it gets one from the same renderer everything
+* else uses rather than from a second implementation.
+*/
+function renderRenderableToString(value, ctx) {
+	const sink = new StringSink();
+	renderRenderableSyncToSink(value, sink, ctx);
+	sink.end();
+	return sink.toString();
 }
 function resolveSSRPortals(html, ctx) {
 	let resolved = html;
@@ -957,7 +731,7 @@ function resolveSSRPortals(html, ctx) {
 			for (const host of slot.hosts) {
 				if (renderedHosts.has(host.token)) continue;
 				foundHost = true;
-				const content = activeHosts.has(host.token) && slot.hasValue ? renderRenderableSync(slot.value, ctx) : "";
+				const content = activeHosts.has(host.token) && slot.hasValue ? renderRenderableToString(slot.value, ctx) : "";
 				resolved = resolved.replace(host.token, () => host.automatic && content === "" && slot.hasValue && explicitHosts.length === 0 ? host.token : content);
 				renderedHosts.add(host.token);
 			}
@@ -987,9 +761,39 @@ var SSRPortalSink = class {
 		this.sink.write(resolveSSRPortals(this.bufferedChunks.join(""), ctx));
 	}
 };
-function renderChildSync(child, ctx) {
-	return renderRenderableSync(child, ctx);
-}
+/**
+* Collects writes so they can be published to a real sink, or dropped.
+*
+* An ErrorBoundary is transactional: markup its subtree produced before a
+* descendant threw must never reach the response, or the fallback lands inside
+* a half-written element. A sink cannot take output back, so the protected
+* subtree renders into one of these first.
+*
+* Portal host writes are recorded rather than flattened, because reaching the
+* real sink through `writePortalHost` is what puts it into portal-resolving
+* mode; replaying them preserves both that signal and the original order.
+*/
+var BufferedSink = class {
+	constructor() {
+		this.operations = [];
+	}
+	write(html) {
+		if (html) this.operations.push({
+			portalHost: false,
+			text: html
+		});
+	}
+	writePortalHost(token) {
+		this.operations.push({
+			portalHost: true,
+			text: token
+		});
+	}
+	publishTo(sink) {
+		for (const operation of this.operations) if (operation.portalHost && sink.writePortalHost) sink.writePortalHost(operation.text);
+		else sink.write(operation.text);
+	}
+};
 function renderRenderableSyncToSink(value, sink, ctx) {
 	if (value === null || value === void 0 || value === false) return;
 	if (typeof value === "string") {
@@ -1009,22 +813,58 @@ function renderRenderableSyncToSink(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;
+/**
+* Write a deferred boundary's pending content inside its resolve wrapper.
+*
+* The wrapper is known from the node's props, so the children stream into the
+* sink between the two markers rather than being rendered to a string first.
+*/
+function renderDeferredBoundaryToSink(node, sink, ctx) {
+	const id = String(node.props?.["id"] ?? "");
+	sink.write(`<askr-resolve data-askr-deferred="${id}">`);
+	renderRenderableSyncToSink(node.props?.["pending"], sink, ctx);
+	sink.write("</askr-resolve>");
+}
+/** Write one `For` row, bracketing it with range markers when it spans several nodes. */
+function renderForRangeChildToSink(child, sink, ctx) {
+	if (child && typeof child === "object" && "type" in child && typeof child.type === "function") {
+		const vnode = child;
+		renderForRangeChildToSink(inheritRenderableKey(vnode, executeComponentSync(vnode.type, vnode.props, ctx, getVNodeContextFrame(vnode) ?? null)), sink, ctx);
+		return;
 	}
-	return Array.from({ length: children.length }, (_, index) => renderChildSync(children[index], ctx)).join("");
+	const spansRange = isMultiRangeChild(child);
+	if (spansRange) sink.write(RANGE_START);
+	renderChildSyncToSink(child, sink, ctx);
+	if (spansRange) sink.write(RANGE_END);
 }
-function renderErrorBoundaryFallbackValue(fallback, error, reset, ctx) {
-	const nextValue = resolveErrorBoundaryFallbackNode(fallback, error, reset);
-	return Array.isArray(nextValue) ? renderChildrenSync(normalizeRenderableChildren(nextValue), ctx) : renderChildSync(nextValue, ctx);
+/**
+* Write a control boundary's children.
+*
+* Whether the boundary needs range markers is decided from the children
+* themselves, before any of them render, so the decision costs nothing and the
+* subtree can stream out as it is produced.
+*/
+function renderControlChildrenToSink(node, sink, ctx) {
+	const controlState = getControlBoundaryState(node);
+	withControlBoundaryChildren(node, (children) => {
+		const values = children ?? [];
+		if (controlState?.kind === "for") {
+			for (let index = 0; index < values.length; index += 1) renderForRangeChildToSink(values[index], sink, ctx);
+			return;
+		}
+		const spansRange = values.length !== 1 || isMultiRangeChild(values[0]);
+		if (spansRange) sink.write(RANGE_START);
+		renderChildrenSyncToSink(values, sink, ctx);
+		if (spansRange) sink.write(RANGE_END);
+	});
 }
 function renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx) {
-	sink.write(renderErrorBoundaryFallbackValue(fallback, error, reset, ctx));
+	const nextValue = resolveErrorBoundaryFallbackNode(fallback, error, reset);
+	if (Array.isArray(nextValue)) {
+		renderChildrenSyncToSink(normalizeRenderableChildren(nextValue), sink, ctx);
+		return;
+	}
+	renderChildSyncToSink(nextValue, sink, ctx);
 }
 function renderChildrenSyncToSink(children, sink, ctx) {
 	if (!children || !Array.isArray(children) || children.length === 0) return;
@@ -1051,44 +891,6 @@ function sinkWrite3(sink, a, b, c) {
 	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 === SSR_PORTAL_HOST) return String(props?.token ?? "");
-		if (type === SSR_PORTAL_ANCHOR) return String(props?.token ?? "");
-		if (isFragmentType(type)) 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;
-	assertElementName(typeStr);
-	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") {
@@ -1112,12 +914,11 @@ function renderNodeSyncToSink(node, sink, ctx) {
 			return;
 		}
 		if (type === __CONTROL_BOUNDARY__) {
-			const rendered = renderControlChildrenSync(node, ctx);
-			sink.write(rendered);
+			renderControlChildrenToSink(node, sink, ctx);
 			return;
 		}
 		if (type === DEFERRED_BOUNDARY) {
-			sink.write(renderDeferredBoundarySync(node, ctx));
+			renderDeferredBoundaryToSink(node, sink, ctx);
 			return;
 		}
 		if (type === __ERROR_BOUNDARY__) {
@@ -1128,8 +929,9 @@ function renderNodeSyncToSink(node, sink, ctx) {
 				renderErrorBoundaryFallbackValueToSink(fallback, boundaryState.error, reset, sink, ctx);
 				return;
 			}
+			const protectedOutput = new BufferedSink();
 			try {
-				renderChildrenSyncToSink(normalizeRenderableChildren(props?.children), sink, ctx);
+				renderChildrenSyncToSink(normalizeRenderableChildren(props?.children), protectedOutput, ctx);
 			} catch (error) {
 				if (boundaryState) {
 					boundaryState.error = error;
@@ -1137,7 +939,9 @@ function renderNodeSyncToSink(node, sink, ctx) {
 				}
 				logger.error("[Askr] ErrorBoundary caught render error:", error);
 				renderErrorBoundaryFallbackValueToSink(fallback, error, reset, sink, ctx);
+				return;
 			}
+			protectedOutput.publishTo(sink);
 			return;
 		}
 		throw new Error(`renderNodeSyncToSink: unsupported VNode symbol type: ${String(type)}`);
@@ -1266,6 +1070,9 @@ function sameRouteParams(left, right) {
 }
 /** Synchronously render an already-resolved route handler to an HTML string. */
 function renderResolvedToStringSync(opts) {
+	return renderResolvedRouteToStringSync(opts);
+}
+function renderResolvedRouteToStringSync(opts, authContext) {
 	const { url, registry, handler, params, options } = opts;
 	const routes = registry.routes;
 	const requestUrl = new URL(url, "http://localhost");
@@ -1281,236 +1088,36 @@ function renderResolvedToStringSync(opts) {
 		handler
 	} : route);
 	const matchedRoute = routes[matchedIndex];
-	return renderToString({
+	const cspNonce = validateCspNonce(options?.cspNonce);
+	const ctx = createRenderContext(options?.seed, {
 		url,
-		registry: {
-			manifest: {
-				records: registry.manifest.records.map((record) => {
-					const effectiveHandler = record.path === matchedRoute.path && record.handler === matchedRoute.handler && record.options.namespace === matchedRoute.namespace ? handler : record.handler;
-					return {
-						...record,
-						component: effectiveHandler,
-						handler: effectiveHandler,
-						layoutChain: [],
-						pageChain: [],
-						options: record.options.namespace ? { namespace: record.options.namespace } : {},
-						metaChain: void 0
-					};
-				}),
-				...registry.manifest.basePath ? { basePath: registry.manifest.basePath } : {}
-			},
-			routes: effectiveRoutes
-		},
-		seed: options?.seed,
+		basePath: registry.manifest.basePath,
 		data: options?.data,
+		params,
+		routes: effectiveRoutes,
+		routeAuth: registry.manifest.auth,
+		authContext,
 		dataRuntime: options?.dataRuntime,
 		envelope: options?.envelope,
-		cspNonce: options?.cspNonce
-	});
-}
-//#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);
-		});
+		cspNonce
 	});
-}
-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, cspNonce, authContext) {
-	const styles = [];
-	return {
-		html: stripHydrationPayload(renderToStringSync(() => state === "fulfilled" ? boundary.fulfilled(payload) : boundary.rejected(payload), {}, {
-			seed,
-			envelope: data ?? void 0,
-			cspNonce,
-			authContext,
-			onContext: (context) => styles.push(...context.ssrStyles.values())
-		})),
-		styles
-	};
-}
-function escapeHtmlAttribute(value) {
-	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeStyleRawText(value) {
-	return value.replace(/<\/style/gi, "<\\/style");
-}
-function patchChunk(id, html, styles, cspNonce) {
-	const selector = `askr-resolve[data-askr-deferred=${JSON.stringify(id)}]`;
-	return `${styles.length === 0 ? "" : `<style data-askr-style-registry="true" data-askr-deferred-style="true"${cspNonce ? ` nonce="${escapeHtmlAttribute(cspNonce)}"` : ""}>${escapeStyleRawText(styles.map((style) => style.cssText).join("\n"))}\n</style>`}<template data-askr-deferred-patch="${escapeHtmlAttribute(id)}">${html}</template><script${cspNonce ? ` nonce="${escapeHtmlAttribute(cspNonce)}"` : ""} data-askr-deferred-apply="${escapeHtmlAttribute(id)}">(function(s){var t=s.previousElementSibling;var c=t&&t.previousElementSibling;var r=document.querySelector('style[data-askr-style-registry="true"]:not([data-askr-deferred-style])');if(c&&c.tagName==='STYLE'&&r&&r!==c){r.append(c.textContent||'');c.remove();}else if(c&&c.tagName==='STYLE'){c.removeAttribute('data-askr-deferred-style');}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, cspNonce, authContext) {
-	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) {
-						const rendered = renderBoundary(boundary, "fulfilled", value, seed, data, cspNonce, authContext);
-						controller.enqueue(encoder.encode(patchChunk(boundary.id, rendered.html, rendered.styles, cspNonce)));
-					}
-				} catch (error) {
-					if (local.signal.aborted) {
-						if (!cancelled && !closed) close(controller);
-						return;
-					}
-					if (!cancelled && !closed) {
-						const rendered = renderBoundary(boundary, "rejected", error, seed, data, cspNonce, authContext);
-						controller.enqueue(encoder.encode(patchChunk(boundary.id, rendered.html, rendered.styles, cspNonce)));
-					}
-				}
-				return;
-			}
-			const hydration = serializeHydrationRenderData(data ?? void 0, runtime);
-			if (hydration) controller.enqueue(encoder.encode(hydration));
-			close(controller);
+	const sink = new StringSink();
+	renderSSRRouteAppToSink({
+		route: {
+			...matchedRoute,
+			handler
 		},
-		cancel(reason) {
-			cancelled = true;
-			local.abort(reason);
-			cleanup();
-		}
-	});
-}
-/** Resolve and render a route request for SSR, streaming the body when possible. */
-async function renderRouteRequest(options) {
-	return renderRouteRequestInternal(options);
-}
-/** Resolve and render a route request for SSR, always fully buffering the HTML. */
-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) {
-	if (!options?.registry) throw new TypeError("renderRouteRequest requires options.registry.");
-	const cspNonce = validateCspNonce(options.cspNonce);
-	const manifest = options.registry.manifest;
-	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,
-		basePath: manifest.basePath,
-		routes: options.registry.routes,
-		routeAuth: options.auth ?? manifest.auth,
-		data: options.data,
-		framework: options.framework,
-		signal,
-		dataRuntime: runtime,
-		queryPrefetch: prefetch,
-		mode: "ssr",
-		cspNonce
+		params: params ?? {},
+		data: options?.data,
+		ctx,
+		sink
 	});
-	return withTelemetry(options.telemetry?.ssrRender, {}, () => withRenderContextAsync(context, async () => {
-		const resolved = await resolveRouteRequest(options.url, {
-			registry: options.registry,
-			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;
-		context.params = resolved.params;
-		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,
-			styles: Array.from(context.ssrStyles.values()),
-			...boundaries.length > 0 ? { stream: createDeferredRenderStream(html, boundaries, signal, options.seed, context.hydrationData, runtime, cspNonce, context.authContext) } : {},
-			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);
+	sink.end();
+	return sink.toString();
 }
-/** Stream a route request's rendered HTML to the response sink described by `opts`. */
-function renderToStream(opts) {
-	renderRouteToStream(opts, routeRenderHost);
+/** @internal Render the resolved hydration route with its request-local auth context. */
+function renderResolvedForHydrationSync(opts, authContext) {
+	return renderResolvedRouteToStringSync(opts, authContext);
 }
 //#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 };
+export { serializeHydrationRenderData as a, createRenderContext as c, withRenderContext as d, withRenderContextAsync as f, renderToStringSync as i, getRenderContext as l, renderResolvedToStringSync as n, StreamSink as o, renderSSRRouteAppToSink as r, StringSink as s, renderResolvedForHydrationSync as t, throwSSRDataMissing as u };