@askrjs/askr 0.2.4 → 0.3.0

package/dist/ssr/index.d.ts

@@ -1,7 +1,27 @@
-import { An as SSRStyleRegistrationValidation, D as SSRPortalState, Dn as DocumentRenderer, E as DeferredBoundaryRegistration, En as DocumentRenderContext, Et as RouteAuthOptions, Kt as RouteRegistry, Mt as RouteHandler, On as SSRData, Tn as DocumentRenderArgs, Tt as Route, Ut as RouteRecord, Xt as RouteRequestResult, c as ServerQueryRegistry, en as CoreTelemetry, gt as AccessDenyDecision, hn as QueryPrefetchContext, kn as SSRStyleRegistration, tn as DataRuntime, vt as AccessRedirectDecision } from "../index-Dgjbo2gU.js";
-import { r as JSXElement, s as Props } from "../types-DWVrKn9N.js";
-import { AuthContext } from "@askrjs/auth";
-//#region src/common/page-render-envelope.d.ts
+import {
+  SSRStyleRegistrationValidation,
+  SSRPortalState,
+  DocumentRenderer,
+  DeferredBoundaryRegistration,
+  DocumentRenderContext,
+  RouteAuthOptions,
+  RouteRegistry,
+  RouteHandler,
+  SSRData,
+  DocumentRenderArgs,
+  Route,
+  RouteRecord,
+  RouteRequestResult,
+  ServerQueryRegistry,
+  CoreTelemetry,
+  AccessDenyDecision,
+  QueryPrefetchContext,
+  SSRStyleRegistration,
+  DataRuntime,
+  AccessRedirectDecision,
+} from '../core.js';
+import { JSXElement, Props } from '../elements.js';
+import { AuthContext } from '@askrjs/auth';
 declare const PAGE_RENDER_ENVELOPE_VERSION: 1;
 interface PageRenderEnvelope {
   readonly version: typeof PAGE_RENDER_ENVELOPE_VERSION;
@@ -9,17 +29,13 @@ interface PageRenderEnvelope {
   readonly route: unknown;
   readonly framework: Readonly<Record<string, unknown>>;
 }
-//#endregion
-//#region src/common/ssr-errors.d.ts
 /**
  * Common call contracts: SSR error types
  */
 declare class SSRDataMissingError extends Error {
-  readonly code = "SSR_DATA_MISSING";
+  readonly code = 'SSR_DATA_MISSING';
   constructor(message?: string);
 }
-//#endregion
-//#region src/ssr/context.d.ts
 interface RenderContext {
   url: string;
   seed: number;
@@ -45,36 +61,40 @@ interface RenderContext {
   cspNonce?: string;
 }
 /** Build a fresh SSR render context (data cache, routes, seed) for a render pass. */
-declare function createRenderContext(seed?: number, opts?: {
-  url?: string;
-  data?: SSRData;
-  params?: Record<string, string>;
-  routes?: readonly Route[];
-  routeAuth?: RouteAuthOptions;
-  authContext?: AuthContext;
-  basePath?: string;
-  signal?: AbortSignal;
-  dataRuntime?: unknown;
-  mode?: 'ssr' | 'spa';
-  queryPrefetch?: QueryPrefetchContext;
-  framework?: Readonly<Record<string, unknown>>;
-  envelope?: PageRenderEnvelope;
-  cspNonce?: string;
-}): RenderContext;
+declare function createRenderContext(
+  seed?: number,
+  opts?: {
+    url?: string;
+    data?: SSRData;
+    params?: Record<string, string>;
+    routes?: readonly Route[];
+    routeAuth?: RouteAuthOptions;
+    authContext?: AuthContext;
+    basePath?: string;
+    signal?: AbortSignal;
+    dataRuntime?: unknown;
+    mode?: 'ssr' | 'spa';
+    queryPrefetch?: QueryPrefetchContext;
+    framework?: Readonly<Record<string, unknown>>;
+    envelope?: PageRenderEnvelope;
+    cspNonce?: string;
+  }
+): RenderContext;
 /**
  * Run a function with the given render context.
  * Concurrency-safe in Node.js via AsyncLocalStorage.
  */
 declare function withRenderContext<T>(ctx: RenderContext, fn: () => T): T;
 /** Run `fn` with `ctx` as the active SSR render context, using async-local storage. */
-declare function withRenderContextAsync<T>(ctx: RenderContext, fn: () => T | PromiseLike<T>): Promise<T>;
+declare function withRenderContextAsync<T>(
+  ctx: RenderContext,
+  fn: () => T | PromiseLike<T>
+): Promise<T>;
 /**
  * Get the current render context.
  * Returns null if not inside a render.
  */
 declare function getRenderContext(): RenderContext | null;
-//#endregion
-//#region src/ssr/route-render.d.ts
 /** A single path-to-handler route binding accepted by low-level SSR route rendering. */
 type SSRRoute = {
   path: string;
@@ -115,8 +135,6 @@ declare function resolveRequest(opts: {
   request?: Request;
   signal?: AbortSignal;
 }): Promise<RouteRequestResult>;
-//#endregion
-//#region src/ssr/types.d.ts
 /** VNode representation for SSR rendering */
 type VNode = {
   type: string | SSRComponent | symbol;
@@ -128,26 +146,31 @@ type VNode = {
  * Component function signature for SSR.
  * Components receive props and an optional context with signal and SSR context.
  */
-type SSRComponent = (props: Props, context?: {
-  signal?: AbortSignal;
-  ssr?: RenderContext;
-}) => VNode | JSXElement | string | number | boolean | null | undefined;
-//#endregion
-//#region src/ssr/render-sync.d.ts
+type SSRComponent = (
+  props: Props,
+  context?: {
+    signal?: AbortSignal;
+    ssr?: RenderContext;
+  }
+) => VNode | JSXElement | string | number | boolean | null | undefined;
 /** Synchronously render a component to an HTML string, without route resolution. */
-declare function renderToStringSync(component: (props?: Record<string, unknown>) => VNode | JSXElement | string | number | boolean | null | undefined, props?: Record<string, unknown>, options?: {
-  seed?: number;
-  data?: SSRData;
-  /** @internal A composed page render envelope. */
-  envelope?: PageRenderEnvelope;
-  cspNonce?: string;
-  /** @internal Request-local authentication for deferred SSR passes. */
-  authContext?: import('@askrjs/auth').AuthContext;
-  /** @internal Capture request-local registrations produced by this pass. */
-  onContext?: (ctx: RenderContext) => void;
-}): string;
-//#endregion
-//#region src/ssr/render-resolved.d.ts
+declare function renderToStringSync(
+  component: (
+    props?: Record<string, unknown>
+  ) => VNode | JSXElement | string | number | boolean | null | undefined,
+  props?: Record<string, unknown>,
+  options?: {
+    seed?: number;
+    data?: SSRData;
+    /** @internal A composed page render envelope. */
+    envelope?: PageRenderEnvelope;
+    cspNonce?: string;
+    /** @internal Request-local authentication for deferred SSR passes. */
+    authContext?: import('@askrjs/auth').AuthContext;
+    /** @internal Capture request-local registrations produced by this pass. */
+    onContext?: (ctx: RenderContext) => void;
+  }
+): string;
 /** Synchronously render an already-resolved route handler to an HTML string. */
 declare function renderResolvedToStringSync(opts: {
   url: string;
@@ -162,8 +185,6 @@ declare function renderResolvedToStringSync(opts: {
     cspNonce?: string;
   };
 }): string;
-//#endregion
-//#region src/ssr/route-request-render.d.ts
 /** Options for {@link renderRouteRequest} and {@link renderRouteRequestToString}. */
 interface RenderRouteRequestOptions {
   url: string;
@@ -183,28 +204,60 @@ interface RenderRouteRequestOptions {
   cspNonce?: string;
 }
 /** Outcome of rendering a route request for SSR: a render, redirect, deny, or no-match. */
-type RenderRouteRequestResult = {
-  kind: 'render';
-  html: string;
-  stream?: ReadableStream<Uint8Array>;
-  styles: readonly SSRStyleRegistration[];
-  params: Record<string, string>;
-  record?: RouteRecord;
-} | AccessRedirectDecision | AccessDenyDecision | {
-  kind: 'no-match';
-};
+type RenderRouteRequestResult =
+  | {
+      kind: 'render';
+      html: string;
+      stream?: ReadableStream<Uint8Array>;
+      styles: readonly SSRStyleRegistration[];
+      params: Record<string, string>;
+      record?: RouteRecord;
+    }
+  | AccessRedirectDecision
+  | AccessDenyDecision
+  | {
+      kind: 'no-match';
+    };
 /** Resolve and render a route request for SSR, streaming the body when possible. */
-declare function renderRouteRequest(options: RenderRouteRequestOptions): Promise<RenderRouteRequestResult>;
+declare function renderRouteRequest(
+  options: RenderRouteRequestOptions
+): Promise<RenderRouteRequestResult>;
 /** Resolve and render a route request for SSR, always fully buffering the HTML. */
-declare function renderRouteRequestToString(options: RenderRouteRequestOptions): Promise<RenderRouteRequestResult>;
-//#endregion
-//#region src/ssr/index-internal.d.ts
+declare function renderRouteRequestToString(
+  options: RenderRouteRequestOptions
+): Promise<RenderRouteRequestResult>;
 /**
  * Render a component or route request to a complete HTML string, synchronously.
  */
-declare function renderToString(component: (props?: Record<string, unknown>) => VNode | JSXElement | string | number | null): string;
+declare function renderToString(
+  component: (
+    props?: Record<string, unknown>
+  ) => VNode | JSXElement | string | number | null
+): string;
 declare function renderToString(opts: RouteRenderOptions): string;
 /** Stream a route request's rendered HTML to the response sink described by `opts`. */
 declare function renderToStream(opts: RouteStreamOptions): void;
-//#endregion
-export { type DocumentRenderArgs, type DocumentRenderContext, type DocumentRenderer, type RenderRouteRequestOptions, type RenderRouteRequestResult, type SSRComponent, SSRDataMissingError, type SSRRoute, type SSRStyleRegistration, type SSRStyleRegistrationValidation, type VNode, createRenderContext, getRenderContext, renderResolvedToStringSync, renderRouteRequest, renderRouteRequestToString, renderToStream, renderToString, renderToStringSync, resolveRequest, withRenderContext, withRenderContextAsync };
+export {
+  type DocumentRenderArgs,
+  type DocumentRenderContext,
+  type DocumentRenderer,
+  type RenderRouteRequestOptions,
+  type RenderRouteRequestResult,
+  type SSRComponent,
+  SSRDataMissingError,
+  type SSRRoute,
+  type SSRStyleRegistration,
+  type SSRStyleRegistrationValidation,
+  type VNode,
+  createRenderContext,
+  getRenderContext,
+  renderResolvedToStringSync,
+  renderRouteRequest,
+  renderRouteRequestToString,
+  renderToStream,
+  renderToString,
+  renderToStringSync,
+  resolveRequest,
+  withRenderContext,
+  withRenderContextAsync,
+};

package/dist/ssr/index.js

@@ -1,3 +1,4 @@
 import { C as SSRDataMissingError } from "../render-context-B7ohlh6t.js";
-import { a as renderResolvedToStringSync, c as createRenderContext, d as withRenderContextAsync, i as renderRouteRequestToString, l as getRenderContext, n as renderToString, o as renderToStringSync, r as renderRouteRequest, s as resolveRequest, t as renderToStream, u as withRenderContext } from "../ssr-Doog-AfJ.js";
+import { c as createRenderContext, d as withRenderContext, f as withRenderContextAsync, i as renderToStringSync, l as getRenderContext, n as renderResolvedToStringSync } from "../render-resolved-BC0W7_5b.js";
+import { a as resolveRequest, i as renderRouteRequestToString, n as renderToString, r as renderRouteRequest, t as renderToStream } from "../ssr-CiNm6Vzl.js";
 export { SSRDataMissingError, createRenderContext, getRenderContext, renderResolvedToStringSync, renderRouteRequest, renderRouteRequestToString, renderToStream, renderToString, renderToStringSync, resolveRequest, withRenderContext, withRenderContextAsync };

package/dist/ssr-CiNm6Vzl.js

@@ -0,0 +1,393 @@
+import { P as isPromiseLike } from "./instance-VAFYVJOa.js";
+import { r as validateCspNonce } from "./csp-nonce-BfFWcd0w.js";
+import { t as createDataRuntime } from "./data-runtime-CxoY98lX.js";
+import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-LrYpQsDJ.js";
+import { a as resolveRouteRequest, n as getRouteRenderContext, o as resolvedRouteHasLoader } from "./resolution-3DskUkjG.js";
+import { c as removeRouteBasePath, s as normalizeRouteBasePath, t as _resolveRouteMatchFromRoutes } from "./route-matching-CUzZ31gT.js";
+import { n as renderDocument } from "./ssr-EPjwJH5R.js";
+import { a as serializeHydrationRenderData, c as createRenderContext, f as withRenderContextAsync, i as renderToStringSync, o as StreamSink, r as renderSSRRouteAppToSink, s as StringSink, u as throwSSRDataMissing } from "./render-resolved-BC0W7_5b.js";
+//#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 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: resolvedRouteHasLoader(resolved) ? 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/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/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, 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);
+		},
+		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
+	});
+	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);
+}
+/** Stream a route request's rendered HTML to the response sink described by `opts`. */
+function renderToStream(opts) {
+	renderRouteToStream(opts, routeRenderHost);
+}
+//#endregion
+export { resolveRequest as a, renderRouteRequestToString as i, renderToString as n, renderRouteRequest as r, renderToStream as t };

package/dist/{ssr-DSHd_Q9K.js → ssr-EPjwJH5R.js}

@@ -1,4 +1,8 @@
+import { P as isPromiseLike } from "./instance-VAFYVJOa.js";
 //#region src/common/ssr.ts
+/**
+* Common call contracts: SSR types
+*/
 function escapedStyleRawText(value) {
 	return value.replace(/<\//gi, "<\\/");
 }
@@ -14,7 +18,7 @@ function validateDocumentStyleRegistrations(html, styles, apiName, validation) {
 function renderDocument(document, args, apiName, styleRegistrationValidation = "warn") {
 	const html = document(args);
 	if (typeof html !== "string") {
-		const received = typeof html === "object" && html !== null && "then" in html && typeof html.then === "function" ? "a Promise-like value" : html === null ? "null" : Array.isArray(html) ? "an array" : typeof html;
+		const received = isPromiseLike(html) ? "a Promise-like value" : html === null ? "null" : Array.isArray(html) ? "an array" : typeof html;
 		throw new Error(`${apiName} document() must synchronously return a string; received ${received}.`);
 	}
 	validateDocumentStyleRegistrations(html, args.context.styles, apiName, styleRegistrationValidation);