@askrjs/askr 0.3.0 → 0.4.0

package/dist/render-sync-IC5lMFpq.js

@@ -0,0 +1,1240 @@
+import { A as untrack, F as logger, j as Owner, t as ComponentInstance } from "./instance-BAnfmXOR.js";
+import { n as readValue } from "./readable-DFWOsTac.js";
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { v as clarifyRenderOverflow } from "./hooks-BimKStr4.js";
+import { r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-DwGw1A6Q.js";
+import { C as withHydrationRenderUrl, T as SSRDataMissingError, _ as createPageRenderEnvelope, b as isPageRenderEnvelope, f as startRenderPhase$1, m as stopRenderPhase$1, r as getCurrentRenderData, t as configureRenderContextProvider, w as withPageFramework, y as isEmptyPageRenderEnvelope } from "./render-context-DGHnEveC.js";
+import { o as functionChildOutput, s as normalizeChildren } from "./error-boundary-Bpwofwps.js";
+import { n as isPromiseLike } from "./promise-Dz8iIHAm.js";
+import { d as DEFERRED_BOUNDARY, i as dehydrateDataRuntime, p as isDeferred } from "./query-registry-WMCN0BJL.js";
+import { ft as getRouteHydrationMetadata, ht as validateRouteHydrationData } from "./resolution-Cx82-xjW.js";
+import { a as SSR_PORTAL_HOST, n as Portal, o as comparePortalWriterOrder, s as createSSRPortalAnchorToken, t as DefaultPortal } from "./portal-DuOKfnLa.js";
+import { t as createDataRuntime } from "./data-runtime-C1bFAlba.js";
+import { d as isCustomElementName, o as isUnsafeUrlAttribute, s as rejectUnsafeUrlAttribute, u as getPublicAttributeName } from "./url-CnbfpX0K.js";
+import { d as booleanAttributeValue, f as isSkippedProp, h as styleValueText, l as isPropertyOnlyProp, m as normalizeStylePropertyName, p as keepsFalseValue, r as sanitizeCssValue, t as SSR_RENDER_DATA_ATTR } from "./ssr-DoV-vJ-5.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 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 = normalizeStylePropertyName(prop);
+	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;
+}
+/** Return the raw text element kind for a lower-case HTML tag name. */
+function getRawTextElement(tag) {
+	return tag === "script" || tag === "style" ? tag : null;
+}
+const SCRIPT_RAW_TEXT_RE = /<(\/|!--|script)/gi;
+/**
+* Make text safe to emit verbatim inside an HTML raw text element.
+*
+* `<style>`: every `<` becomes the CSS escape `\3c ` (the space ends the
+* escape and is consumed), so no markup can form whatever context the parser
+* reads the text in. Inside CSS strings, `url()` and comments this denotes the
+* original `<`; elsewhere (custom property values, range media queries) it
+* reads back as an escaped identifier, since no escape can represent a bare
+* `<` there.
+*
+* `<script>`: every `</` becomes `<\/`, so no end tag of this element or of
+* any ancestor can form, and the `<` of `<!--` and `<script` is written as
+* `\u003C`, which keeps the parser out of the script data (double) escaped
+* states. Inside JS string, template and regex literals, and inside JSON
+* strings (`application/json`, `importmap`, `application/ld+json`), each
+* rewrite denotes the original characters; outside literals these sequences
+* cannot be represented and may change meaning or fail to parse.
+*
+* Matching is case-insensitive. The whole text must be escaped at once: a
+* sequence split across children only forms once they are concatenated.
+*/
+function escapeRawText(text, element) {
+	if (!text.includes("<")) return text;
+	if (element === "style") return text.replaceAll("<", "\\3c ");
+	return text.replace(SCRIPT_RAW_TEXT_RE, (_match, rest) => rest === "/" ? "<\\/" : `\\u003C${rest}`);
+}
+/**
+* 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 a string for interpolation into a hand-written HTML document template,
+* either as text content or inside a quoted attribute value. Replaces `&`, `<`,
+* `>`, `"` and `'` with character references. Use it for every request-derived
+* value a `document` renderer interpolates, such as `context.pathname`,
+* `context.params` or loader data. Do not use it for `appHtml`, which is
+* already rendered markup, or inside `<script>`/`<style>` raw text.
+* `null` and `undefined` render as an empty string; other values are
+* converted with `String()`.
+*/
+function escapeHtml(value) {
+	return value == null ? "" : escapeAttr(String(value));
+}
+/**
+* Convert a style object to a CSS string, omitting unsafe values.
+* 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 = sanitizeCssValue(styleValueText(prop, 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.
+* The first render installs AsyncLocalStorage from `globalThis` or, on Node and
+* Node-compatible runtimes (Deno, Bun, Workers with `nodejs_compat`), from
+* `process.getBuiltinModule('node:async_hooks')`. Neither is a static import,
+* so browser bundles never pull in the Node builtin. Runtimes without either
+* use a synchronous fallback stack and reject async render contexts.
+*/
+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 (globalThis.AsyncLocalStorage or process.getBuiltinModule('node:async_hooks')).";
+let renderContextAccessor = null;
+let renderContextAccessorInitialized = false;
+let fallbackStack = null;
+function resolveAsyncLocalStorage() {
+	const host = globalThis;
+	return host.AsyncLocalStorage ?? host.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage;
+}
+function ensureRenderContextAccessor() {
+	if (renderContextAccessorInitialized) return;
+	renderContextAccessorInitialized = true;
+	const AsyncLocalStorage = resolveAsyncLocalStorage();
+	if (AsyncLocalStorage) renderContextAccessor = new AsyncLocalStorage();
+}
+function createRenderContext(seed = 12345, opts = {}) {
+	clearEscapeCache();
+	const queryCache = /* @__PURE__ */ new Map();
+	const envelope = opts.envelope ?? createPageRenderEnvelope({
+		resources: opts.data,
+		framework: opts.framework
+	});
+	const hydrationEnvelope = opts.url ? withHydrationRenderUrl(envelope, opts.url) : envelope;
+	return {
+		url: opts.url ?? "",
+		seed,
+		data: opts.data,
+		params: opts.params,
+		routes: opts.routes,
+		routeAuth: opts.routeAuth,
+		authContext: opts.authContext,
+		basePath: opts.basePath,
+		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: hydrationEnvelope,
+		deferredBoundaries: [],
+		ssrStyles: /* @__PURE__ */ new Map(),
+		ssrPortals: {
+			slots: /* @__PURE__ */ new Map(),
+			nextHostId: 0,
+			nextWriteOrder: 0
+		},
+		cspNonce: opts.cspNonce
+	};
+}
+/**
+* Run a function with the given render context.
+* Concurrency-safe on runtimes with AsyncLocalStorage (Node.js, Deno, Bun,
+* Workers with `nodejs_compat`); elsewhere only synchronous work is accepted.
+*/
+function withRenderContext(ctx, fn) {
+	ensureRenderContextProvider();
+	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;
+	}
+}
+/** Run `fn` with `ctx` as the active SSR render context, using async-local storage. */
+async function withRenderContextAsync(ctx, fn) {
+	ensureRenderContextProvider();
+	ensureRenderContextAccessor();
+	if (renderContextAccessor) return renderContextAccessor.run(ctx, () => Promise.resolve(fn()));
+	throw new Error(FALLBACK_ASYNC_CONTEXT_ERROR);
+}
+/**
+* Get the current render context.
+* Returns null if not inside a render.
+*/
+function getRenderContext() {
+	ensureRenderContextAccessor();
+	if (renderContextAccessor) return renderContextAccessor.getStore() ?? null;
+	return fallbackStack;
+}
+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.
+*/
+function throwSSRDataMissing() {
+	throw new SSRDataMissingError();
+}
+//#endregion
+//#region src/ssr/hydration-data.ts
+const DEFERRED_PAYLOAD = "__askr_deferred__";
+/** Client-visible reason for a rejected deferred value that did not opt in to exposure. */
+const REDACTED_DEFERRED_ERROR = "Deferred value rejected.";
+/**
+* Rejection reasons reach the page only when the error opts in with
+* `expose: true`. Anything else can carry server internals (connection
+* strings, hosts, SQL) into public HTML.
+*/
+function exposedDeferredError(error) {
+	return error instanceof Error && error.expose === true ? error.message : REDACTED_DEFERRED_ERROR;
+}
+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: exposedDeferredError(value.error)
+	};
+	return { [DEFERRED_PAYLOAD]: "pending" };
+}
+/**
+* Add the app's opted-in identity projection to a hydration envelope. Without
+* `auth.dehydrate`, nothing about the identity reaches the page. The session is
+* never sent; `authenticated`, `principal`, `tenant`, and `scopes` are sent
+* verbatim.
+*/
+function withHydratedAuth(envelope, options, context) {
+	if (!options?.dehydrate || !context) return envelope;
+	const { authenticated, principal, tenant, scopes } = options.dehydrate(context);
+	return withPageFramework(envelope, {
+		...envelope.framework,
+		["au"]: {
+			authenticated,
+			principal,
+			tenant,
+			...scopes ? { scopes } : {}
+		}
+	});
+}
+function serializeHydrationRenderData(data, runtime) {
+	const queryCache = runtime ? dehydrateDataRuntime(runtime) : void 0;
+	const current = isPageRenderEnvelope(data) ? data : createPageRenderEnvelope({ resources: data });
+	const queries = {
+		...current.queries,
+		...queryCache
+	};
+	const payload = createPageRenderEnvelope({
+		resources: current.resources,
+		queries: Object.keys(queries).length > 0 ? queries : void 0,
+		route: current.route,
+		framework: current.framework
+	});
+	const routeHydration = getRouteHydrationMetadata(payload.framework);
+	if (routeHydration) validateRouteHydrationData(payload.route, routeHydration.r);
+	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/sink.ts
+var StringSink = class StringSink {
+	constructor() {
+		this.chunks = [];
+		this.bufferChunks = [];
+		this.bufferLen = 0;
+	}
+	static {
+		this.FLUSH_THRESHOLD = 32768;
+	}
+	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/attrs.ts
+const ESCAPED_ATTR_VALUE_CACHE_LIMIT = 512;
+const escapedAttrValueCache = /* @__PURE__ */ new Map();
+function isEventHandler(key) {
+	return key.length >= 2 && key.slice(0, 2).toLowerCase() === "on";
+}
+/**
+* A function or readable prop is reactive on the client; the server renders
+* its current value once, without subscribing to it. A function that returns
+* a readable renders the readable's value, as on the client.
+*/
+function resolvePropValue(value) {
+	return typeof value === "function" ? untrack(() => readValue(value)) : value;
+}
+/**
+* `props` with every function or readable attribute value read once, for an
+* element whose attributes are inspected before they are written. Returns
+* `props` itself when nothing needs reading.
+*/
+function resolveReactiveAttributeProps(props) {
+	if (!props || typeof props !== "object") return props;
+	let resolved = null;
+	const propsObj = props;
+	for (const key in propsObj) {
+		const value = propsObj[key];
+		if (typeof value !== "function" || isSkippedProp(key) || isEventHandler(key)) continue;
+		resolved ??= { ...propsObj };
+		resolved[key] = resolvePropValue(value);
+	}
+	return resolved ?? props;
+}
+function assertAttributeName(name) {
+	if (!/^[A-Za-z_:][A-Za-z0-9_.:-]*$/.test(name)) throw new TypeError(`Invalid SSR attribute name: ${JSON.stringify(name)}`);
+}
+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.
+*
+* Props the DOM renderer writes only as properties (`prop:*`, `indeterminate`,
+* object values on custom elements) have no markup and are left out; the
+* client applies them when it hydrates.
+*/
+function renderAttrsDirect(props, sink, tagName = "") {
+	if (!props || typeof props !== "object") return;
+	const customElement = isCustomElementName(tagName);
+	const propsObj = props;
+	for (const key in propsObj) {
+		if (isSkippedProp(key) || key === "dangerouslySetInnerHTML") continue;
+		if (isEventHandler(key)) continue;
+		if (key.charCodeAt(0) === 95) continue;
+		const value = resolvePropValue(propsObj[key]);
+		if (isPropertyOnlyProp(tagName, key, value)) continue;
+		if (value !== null && typeof value === "object" && key.startsWith("attr:")) continue;
+		const attrName = getPublicAttributeName(key, customElement);
+		if (attrName !== key && isEventHandler(attrName)) continue;
+		assertAttributeName(attrName);
+		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);
+			const booleanValue = booleanAttributeValue(attrName);
+			if (booleanValue) {
+				sink.write("=\"");
+				sink.write(booleanValue);
+				sink.write("\"");
+			}
+			continue;
+		}
+		if (value === null || value === void 0 || value === false && !keepsFalseValue(attrName)) continue;
+		const strValue = String(value);
+		if (rejectUnsafeUrlAttribute(attrName, strValue)) continue;
+		sink.write(" ");
+		sink.write(attrName);
+		sink.write("=\"");
+		sink.write(getEscapedAttrValue(strValue));
+		sink.write("\"");
+	}
+}
+/**
+* The value the HTML parser sees for attribute `name` (lower-case) on an
+* element whose attributes `renderAttrsDirect` writes, or `null` when it is
+* not written. Mirrors the emitted attributes: names compare
+* case-insensitively and the first written occurrence wins, as the parser
+* drops later duplicates.
+*/
+function getRenderedAttributeValue(props, name) {
+	if (!props || typeof props !== "object") return null;
+	const propsObj = props;
+	for (const key in propsObj) {
+		if (isSkippedProp(key) || key === "dangerouslySetInnerHTML") continue;
+		if (isEventHandler(key)) continue;
+		if (key.charCodeAt(0) === 95) continue;
+		const attrName = getPublicAttributeName(key);
+		if (attrName.toLowerCase() !== name) continue;
+		const value = resolvePropValue(propsObj[key]);
+		if (attrName === "style") {
+			const css = typeof value === "string" ? value : styleObjToCss(value);
+			if (!css) continue;
+			return css;
+		}
+		if (value === true) return booleanAttributeValue(attrName);
+		if (value === null || value === void 0 || value === false && !keepsFalseValue(attrName)) continue;
+		const strValue = String(value);
+		if (isUnsafeUrlAttribute(attrName, strValue)) continue;
+		return strValue;
+	}
+	return null;
+}
+//#endregion
+//#region src/ssr/namespace.ts
+/** HTML elements whose content the parser reads as text, not markup. */
+const TEXT_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"plaintext",
+	"script",
+	"style",
+	"textarea",
+	"title",
+	"xmp"
+]);
+/** The namespace an element with lower-case tag `tag` gets in `context`. */
+function getElementNamespace(context, tag) {
+	switch (context) {
+		case "text": return "text";
+		case "svg": return "svg";
+		case "math": return "math";
+		case "math-annotation": return tag === "svg" ? "svg" : "math";
+		case "math-text": if (tag === "mglyph" || tag === "malignmark") return "math";
+	}
+	if (tag === "svg") return "svg";
+	if (tag === "math") return "math";
+	return "html";
+}
+/**
+* The context the children of an element in `namespace`, itself written in
+* `context`, are parsed in.
+*/
+function getChildNamespace(context, namespace, tag, props) {
+	if (namespace === "text") return "text";
+	if (namespace === "html") {
+		if (TEXT_CONTENT_ELEMENTS.has(tag)) return "text";
+		if (tag === "template") return "html";
+		return tag === "select" || context === "select" ? "select" : "html";
+	}
+	if (namespace === "svg") return tag === "foreignobject" || tag === "desc" || tag === "title" ? "html" : "svg";
+	switch (tag) {
+		case "mi":
+		case "mo":
+		case "mn":
+		case "ms":
+		case "mtext": return "math-text";
+		case "annotation-xml": return isHtmlAnnotationEncoding(getRenderedAttributeValue(props, "encoding")) ? "html" : "math-annotation";
+		default: return "math";
+	}
+}
+/**
+* Whether an element with lower-case tag `tag`, in `namespace` and written in
+* `context`, is parsed as an HTML raw text element whose text may be written
+* verbatim.
+*/
+function getRawTextElementInContext(context, namespace, tag) {
+	if (namespace !== "html") return null;
+	const element = getRawTextElement(tag);
+	return element === "style" && context === "select" ? null : element;
+}
+function isHtmlAnnotationEncoding(encoding) {
+	if (encoding === null) return false;
+	const value = encoding.toLowerCase();
+	return value === "text/html" || value === "application/xhtml+xml";
+}
+//#endregion
+//#region src/ssr/render-keys.ts
+/**
+* SSR Data Management
+*
+* Manages render-phase keying for deterministic SSR data lookup.
+* All state is stored in the per-render context for concurrency safety.
+*/
+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
+/**
+* Synchronous server rendering.
+*
+* Components run on the same execution path as in the browser (a component
+* instance per element, positional hooks, scopes through the owner tree) and
+* their output is interpreted with the same child descriptors as the DOM
+* renderer. The server reads function children and props once, never
+* subscribes, and ends every lifetime when the render finishes.
+*
+* The output is plain HTML apart from private hydration markers when the
+* render contains preloaded resource slots. Portal hosts write tokens that
+* are replaced with their final content once the render root completes.
+*/
+/**
+* Collects writes so they can be published or dropped. An ErrorBoundary's
+* subtree renders into one first, so markup from a subtree that then throws
+* never reaches the response.
+*/
+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
+		});
+	}
+	/** The buffered markup, without portal host tokens. */
+	html() {
+		let html = "";
+		for (const operation of this.operations) if (!operation.portalHost) html += operation.text;
+		return html;
+	}
+	publishTo(sink) {
+		for (const operation of this.operations) if (operation.portalHost && sink.writePortalHost) sink.writePortalHost(operation.text);
+		else sink.write(operation.text);
+	}
+};
+/** Buffers output once a portal host appears so tokens can be resolved. */
+var PortalSink = class {
+	constructor(sink) {
+		this.sink = sink;
+		this.buffered = null;
+	}
+	write(html) {
+		if (!html) return;
+		if (this.buffered) this.buffered.push(html);
+		else this.sink.write(html);
+	}
+	writePortalHost(token) {
+		(this.buffered ??= []).push(token);
+	}
+	flush(ctx) {
+		if (this.buffered) this.sink.write(resolvePortals(this.buffered.join(""), ctx));
+	}
+};
+let current = null;
+function state() {
+	if (!current) throw new Error("[Askr] No server render is active.");
+	return current;
+}
+function withOwner(owner, fn) {
+	const render = state();
+	const previous = render.owner;
+	render.owner = owner;
+	try {
+		return fn();
+	} finally {
+		render.owner = previous;
+	}
+}
+function withNamespace(namespace, fn) {
+	const render = state();
+	const previous = render.namespace;
+	render.namespace = namespace;
+	try {
+		return fn();
+	} finally {
+		render.namespace = previous;
+	}
+}
+function runComponent(instance) {
+	try {
+		const output = instance.render();
+		if (isPromiseLike(output)) throwSSRDataMissing();
+		return output;
+	} finally {}
+}
+function componentOutput(value) {
+	return typeof value === "function" ? null : value;
+}
+function renderComponent(fn, props, sink) {
+	const render = state();
+	let owner = render.owner;
+	for (;;) {
+		const instance = new ComponentInstance(owner, fn, props);
+		instance.server = true;
+		instance.serverContext = render.ctx;
+		const output = runComponent(instance);
+		const resources = getCurrentRenderData()?.resources;
+		if (instance.serverResourceKeys.length && resources && Object.keys(resources).some((key) => /^r:\d+$/.test(key))) sink.write(`<!--askr-resource:${instance.serverResourceKeys.join(",")}-->`);
+		if (fn === Portal) sink.write(createSSRPortalAnchorToken(render.ctx.ssrPortals.nextHostId++));
+		const next = instance.hooks.length === 0 && !instance.boundary ? selfComponentChild(output, fn) : null;
+		if (next) {
+			owner = instance;
+			fn = next.fn;
+			props = next.props;
+			continue;
+		}
+		if (!instance.boundary) {
+			withOwner(instance, () => renderValue(componentOutput(output), sink));
+			return;
+		}
+		const buffer = new BufferedSink();
+		const restorePortals = capturePortalWrites(render.ctx);
+		try {
+			withOwner(instance, () => renderValue(componentOutput(output), buffer));
+		} catch (caught) {
+			const error = clarifyRenderOverflow(caught);
+			restorePortals();
+			const cleanupErrors = disposeFailedSubtree(instance);
+			try {
+				if (!instance.boundary(error)) throw error;
+				const fallback = runComponent(instance);
+				withOwner(instance, () => renderValue(componentOutput(fallback), sink));
+			} finally {
+				reportBoundaryCleanupErrors(cleanupErrors);
+			}
+			return;
+		}
+		buffer.publishTo(sink);
+		return;
+	}
+}
+/**
+* End the lifetimes a failed boundary subtree started, newest first as in
+* `Owner.dispose()`, keeping the boundary's own render computation.
+*/
+function disposeFailedSubtree(instance) {
+	const errors = [];
+	const owned = instance.owned ? [...instance.owned] : [];
+	for (let index = owned.length - 1; index >= 0; index--) {
+		const child = owned[index];
+		if (child && child !== instance.computation) errors.push(...child.dispose());
+	}
+	return errors;
+}
+function reportBoundaryCleanupErrors(errors) {
+	if (errors.length === 0) return;
+	const failure = errors.length === 1 ? errors[0] : new AggregateError(errors, "SSR ErrorBoundary cleanup failed");
+	logger.error("[Askr] SSR ErrorBoundary cleanup failed:", failure);
+}
+function selfComponentChild(output, fn) {
+	if (!output || typeof output !== "object" || Array.isArray(output) || output.type !== fn) return null;
+	const children = normalizeChildren(output);
+	return children.length === 1 && children[0].kind === 2 ? children[0] : null;
+}
+function capturePortalWrites(ctx) {
+	const saved = /* @__PURE__ */ new Map();
+	for (const [key, slot] of ctx.ssrPortals.slots) saved.set(key, new Map(slot.writers));
+	return () => {
+		for (const [key, slot] of ctx.ssrPortals.slots) {
+			slot.writers = new Map(saved.get(key) ?? []);
+			const ordered = [...slot.writers.values()].sort((left, right) => comparePortalWriterOrder(left.owner, right.owner, left.order, right.order));
+			const latest = ordered[ordered.length - 1];
+			slot.hasValue = latest !== void 0;
+			slot.value = latest?.value;
+			slot.owner = latest?.owner;
+		}
+	};
+}
+function isVNodeOf(value, type) {
+	return typeof value === "object" && value !== null && value.type === type;
+}
+/** Render any renderable value. */
+function renderValue(value, sink) {
+	if (Array.isArray(value)) {
+		for (const item of value) renderValue(item, sink);
+		return;
+	}
+	if (isVNodeOf(value, SSR_PORTAL_HOST)) {
+		const token = String(value.props?.token ?? "");
+		state().portalNamespaces.set(token, state().namespace);
+		if (sink.writePortalHost) sink.writePortalHost(token);
+		else sink.write(token);
+		return;
+	}
+	if (isVNodeOf(value, DEFERRED_BOUNDARY)) {
+		const id = String(value.props?.id ?? "");
+		sink.write(`<askr-resolve data-askr-deferred="${id}">`);
+		renderValue(value.props?.pending, sink);
+		sink.write("</askr-resolve>");
+		return;
+	}
+	for (const child of normalizeChildren(value)) renderChild(child, sink);
+}
+function renderChild(child, sink) {
+	switch (child.kind) {
+		case 1:
+			sink.write(escapeText(child.text));
+			return;
+		case 0:
+			renderElement(child.tag, child.props, sink);
+			return;
+		case 2:
+			renderComponent(child.fn, child.props, sink);
+			return;
+		case 3: {
+			const owner = child.owner;
+			if (owner) withOwner(owner, () => renderValue(child.children, sink));
+			else renderValue(child.children, sink);
+			return;
+		}
+		case 4:
+			renderComponent(() => functionChildOutput(readValue(child.fn)), {}, sink);
+			return;
+		case 7: return;
+	}
+}
+function assertElementName(name) {
+	if (!/^[A-Za-z][A-Za-z0-9._:-]*$/.test(name)) throw new TypeError(`Invalid SSR element name: ${JSON.stringify(name)}`);
+}
+function renderElement(tag, props, sink) {
+	assertElementName(tag);
+	if (VOID_ELEMENTS.has(tag)) {
+		sink.write("<" + tag);
+		renderAttrsDirect(props, sink, tag);
+		sink.write(" />");
+		return;
+	}
+	const render = state();
+	const parentNamespace = render.namespace;
+	const lower = tag.toLowerCase();
+	const namespace = getElementNamespace(parentNamespace, lower);
+	let elementProps = lower === "annotation-xml" || namespace === "html" && (lower === "select" || lower === "option" && parentNamespace === "select") ? resolveReactiveAttributeProps(props) ?? props : props;
+	const selection = render.selectSelections[render.selectSelections.length - 1];
+	let renderedChildren = null;
+	if (lower === "option" && parentNamespace === "select" && selection) {
+		let value;
+		const own = elementProps.value;
+		if (own === void 0 || own === null || own === false) {
+			const buffer = new BufferedSink();
+			const props = elementProps;
+			withNamespace(getChildNamespace(parentNamespace, namespace, lower, props), () => writeContent(props, null, buffer));
+			renderedChildren = buffer;
+			value = optionTextValue(buffer.html());
+		} else value = String(own);
+		const selected = selection.values.has(value) && (selection.multiple || !selection.matched);
+		if (selected) selection.matched = true;
+		elementProps = {
+			...elementProps,
+			selected
+		};
+	}
+	if (renderedChildren) {
+		sink.write("<" + tag);
+		renderAttrsDirect(elementProps, sink, tag);
+		sink.write(">");
+		renderedChildren.publishTo(sink);
+		sink.write("</" + tag + ">");
+		return;
+	}
+	let nextSelection = null;
+	if (lower === "select" && namespace === "html" && elementProps.value != null) {
+		const multiple = Boolean(elementProps.multiple);
+		const value = elementProps.value;
+		nextSelection = {
+			values: new Set(multiple && Array.isArray(value) ? value.map(String) : [String(value)]),
+			multiple,
+			matched: false
+		};
+		render.selectSelections.push(nextSelection);
+	}
+	const rawText = getRawTextElementInContext(parentNamespace, namespace, lower);
+	try {
+		withNamespace(getChildNamespace(parentNamespace, namespace, lower, elementProps), () => writeElement(tag, elementProps, rawText, sink));
+	} finally {
+		if (nextSelection) render.selectSelections.pop();
+	}
+}
+const NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0"
+};
+/** Decode the entity starting at `start` (`&...;`), or null if unknown. */
+function decodeEntity(html, start) {
+	const end = html.indexOf(";", start + 1);
+	if (end < 0 || end - start > 12) return null;
+	const name = html.slice(start + 1, end);
+	if (name.startsWith("#")) {
+		const hex = name[1] === "x" || name[1] === "X";
+		const code = Number.parseInt(name.slice(hex ? 2 : 1), hex ? 16 : 10);
+		if (!Number.isFinite(code) || code < 0 || code > 1114111) return null;
+		return {
+			text: String.fromCodePoint(code),
+			end
+		};
+	}
+	const text = NAMED_ENTITIES[name];
+	return text === void 0 ? null : {
+		text,
+		end
+	};
+}
+function isAsciiWhitespace(code) {
+	return code === 32 || code === 9 || code === 10 || code === 12 || code === 13;
+}
+/**
+* The value a browser gives a value-less `<option>` rendered as `html`: its
+* text content with ASCII whitespace stripped and collapsed. The markup is
+* this renderer's own output, so tags, comments, and the three entities the
+* text escaper emits are all there is to undo.
+*/
+function optionTextValue(html) {
+	let text = "";
+	let pendingSpace = false;
+	let i = 0;
+	while (i < html.length) {
+		const ch = html[i];
+		if (ch === "<") {
+			if (html.startsWith("<!--", i)) {
+				const end = html.indexOf("-->", i + 4);
+				i = end < 0 ? html.length : end + 3;
+				continue;
+			}
+			const end = html.indexOf(">", i + 1);
+			if (end < 0) break;
+			if (html.slice(i + 1, i + 7).toLowerCase() === "script") {
+				const close = html.toLowerCase().indexOf("<\/script", end);
+				const closeEnd = close < 0 ? -1 : html.indexOf(">", close);
+				i = closeEnd < 0 ? html.length : closeEnd + 1;
+				continue;
+			}
+			i = end + 1;
+			continue;
+		}
+		let decoded = ch;
+		if (ch === "&") {
+			const entity = decodeEntity(html, i);
+			if (entity) {
+				decoded = entity.text;
+				i = entity.end;
+			}
+		}
+		i++;
+		for (const part of decoded) {
+			if (isAsciiWhitespace(part.charCodeAt(0))) {
+				pendingSpace = text.length > 0;
+				continue;
+			}
+			if (pendingSpace) text += " ";
+			pendingSpace = false;
+			text += part;
+		}
+	}
+	return text;
+}
+function writeElement(tag, props, rawText, sink) {
+	sink.write("<" + tag);
+	renderAttrsDirect(props, sink, rawText === null ? tag : void 0);
+	sink.write(">");
+	writeContent(props, rawText, sink);
+	sink.write("</" + tag + ">");
+}
+/** An element's content: raw HTML, raw text, or rendered children. */
+function writeContent(props, rawText, sink) {
+	const dangerous = props.dangerouslySetInnerHTML;
+	if (dangerous !== void 0 && dangerous !== null) {
+		if (typeof dangerous === "object" && "__html" in dangerous) {
+			const html = dangerous.__html;
+			if (html !== null && html !== void 0) sink.write(String(html));
+		} else renderValue(props.children, sink);
+	} else if (rawText !== null) sink.write(escapeRawText(collectRawText(props.children, rawText), rawText));
+	else if (!props.imperativeChildren) renderValue(props.children, sink);
+}
+/**
+* The text of a `<script>` or `<style>`: collected unescaped and neutralized
+* as a whole. Element children are rejected rather than serialized as markup
+* the parser would read back as literal text.
+*/
+function collectRawText(value, element) {
+	return flattenText(value, element).join("");
+}
+function flattenText(value, element) {
+	const out = [];
+	const visit = (item) => {
+		if (Array.isArray(item)) {
+			for (const entry of item) visit(entry);
+			return;
+		}
+		for (const child of normalizeChildren(item)) switch (child.kind) {
+			case 1:
+				out.push(child.text);
+				break;
+			case 3:
+				visit(child.children);
+				break;
+			case 4:
+				visit(functionChildOutput(untrack(() => readValue(child.fn))));
+				break;
+			case 2: {
+				const render = state();
+				const instance = new ComponentInstance(render.owner, child.fn, child.props);
+				instance.server = true;
+				instance.serverContext = render.ctx;
+				const output = runComponent(instance);
+				if (!instance.boundary) {
+					withOwner(instance, () => visit(componentOutput(output)));
+					break;
+				}
+				const start = out.length;
+				const restorePortals = capturePortalWrites(render.ctx);
+				try {
+					withOwner(instance, () => visit(componentOutput(output)));
+				} catch (caught) {
+					const error = clarifyRenderOverflow(caught);
+					out.length = start;
+					restorePortals();
+					const cleanupErrors = disposeFailedSubtree(instance);
+					try {
+						if (!instance.boundary(error)) throw error;
+						const fallback = runComponent(instance);
+						withOwner(instance, () => visit(componentOutput(fallback)));
+					} finally {
+						reportBoundaryCleanupErrors(cleanupErrors);
+					}
+				}
+				break;
+			}
+			case 0: throw new Error(`SSR: <${element}> children must be text, but received an element <${child.tag}>.`);
+			default: throw new Error(`SSR: <${element}> children must be text, but received a non-text node.`);
+		}
+	};
+	visit(value);
+	return out;
+}
+function renderToString(value, namespace) {
+	const sink = new StringSink();
+	withNamespace(namespace, () => renderValue(value, sink));
+	sink.end();
+	return sink.toString();
+}
+/** Replace portal host tokens with their portal's final content. */
+function resolvePortals(html, ctx) {
+	let resolved = html;
+	const rendered = /* @__PURE__ */ new Set();
+	for (;;) {
+		let found = false;
+		for (const slot of ctx.ssrPortals.slots.values()) {
+			const explicit = slot.hosts.filter((host) => !host.automatic);
+			for (const host of slot.hosts) {
+				if (rendered.has(host.token)) continue;
+				found = true;
+				rendered.add(host.token);
+				const active = host.automatic ? explicit.length === 0 : true;
+				const content = active ? [...slot.writers.values()].sort((left, right) => comparePortalWriterOrder(left.owner, right.owner, left.order, right.order)).map((write) => withOwner(write.owner ?? state().owner, () => renderToString(write.value, state().portalNamespaces.get(host.token) ?? "html"))).join("") : "";
+				const hostContent = host.automatic && (!active || !slot.hasValue) ? "" : host.automatic && content === "" ? host.token : host.defaultPortal && active && slot.hasValue ? `<!--askr-range-start-->${content}<!--askr-range-end-->` : content;
+				resolved = resolved.replace(host.token, () => hostContent);
+			}
+		}
+		if (!found) return resolved;
+	}
+}
+function withServerRender(ctx, fn) {
+	const previous = current;
+	const owner = new Owner(null);
+	current = {
+		ctx,
+		owner,
+		namespace: "html",
+		portalNamespaces: /* @__PURE__ */ new Map(),
+		selectSelections: []
+	};
+	let result;
+	try {
+		result = fn();
+	} catch (error) {
+		current = previous;
+		const cleanupErrors = owner.dispose();
+		const failure = clarifyRenderOverflow(error);
+		if (cleanupErrors.length > 0) throw new AggregateError([failure, ...cleanupErrors], "SSR render failed and temporary owner cleanup also failed");
+		throw failure;
+	}
+	current = previous;
+	const errors = owner.dispose();
+	if (errors.length === 1) throw errors[0];
+	if (errors.length > 1) throw new AggregateError(errors, "SSR temporary owner cleanup failed");
+	return result;
+}
+const AUTO_PORTAL = {
+	$$typeof: ELEMENT_TYPE,
+	type: DefaultPortal,
+	props: { __askrAutoDefaultPortal: true },
+	key: "__default_portal"
+};
+/** A root's output followed by the automatic default portal host. */
+function withDefaultPortal(output) {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: output == null ? [AUTO_PORTAL] : [output, AUTO_PORTAL] },
+		key: null
+	};
+}
+function rootElement(component, props, nonce) {
+	const Root = (_props, context) => {
+		const output = component(props, context);
+		if (isPromiseLike(output)) throwSSRDataMissing();
+		return withDefaultPortal(output);
+	};
+	Object.defineProperty(Root, "name", { value: component.name || "Component" });
+	const element = {
+		$$typeof: ELEMENT_TYPE,
+		type: Root,
+		props: {},
+		key: null
+	};
+	return nonce === void 0 ? element : CspNonceScope({
+		value: nonce,
+		children: element
+	});
+}
+/** Synchronously render a component to an HTML string, without route resolution. */
+function renderToStringSync(component, props, options) {
+	const nonce = validateCspNonce(options?.cspNonce);
+	const ctx = createRenderContext(options?.seed ?? 12345, {
+		data: options?.data,
+		envelope: options?.envelope,
+		cspNonce: nonce,
+		authContext: options?.authContext,
+		...options?.route
+	});
+	return withRenderContext(ctx, () => {
+		startRenderPhase(ctx.renderData);
+		try {
+			return withServerRender(ctx, () => {
+				const sink = new StringSink();
+				renderValue(rootElement(component, props ?? {}, nonce), sink);
+				sink.end();
+				const html = resolvePortals(sink.toString(), ctx);
+				options?.onContext?.(ctx);
+				return html + serializeHydrationRenderData(ctx.hydrationData ?? void 0, ctx.dataRuntime);
+			});
+		} finally {
+			stopRenderPhase();
+		}
+	});
+}
+function renderSSRRouteAppToSink(input) {
+	const { ctx, data, route, params, sink } = input;
+	withRenderContext(ctx, () => {
+		startRenderPhase(ctx.renderData);
+		try {
+			withServerRender(ctx, () => {
+				const appSink = new PortalSink(sink);
+				renderValue(rootElement(((routeParams) => route.handler(routeParams)), params, ctx.cspNonce), appSink);
+				appSink.flush(ctx);
+			});
+			if (ctx.deferredBoundaries.length === 0) sink.write(serializeHydrationRenderData(ctx.hydrationData ?? data, ctx.dataRuntime));
+		} finally {
+			stopRenderPhase();
+		}
+	});
+}
+//#endregion
+export { serializeHydrationRenderData as a, getRenderContext as c, escapeHtml as d, StringSink as i, withRenderContext as l, renderToStringSync as n, withHydratedAuth as o, StreamSink as r, createRenderContext as s, renderSSRRouteAppToSink as t, withRenderContextAsync as u };