@askrjs/askr 0.0.84 → 0.0.86

package/dist/{deferred-oqtAJ4iH.js → resolution-YHwi4Bav.js}

@@ -1,23 +1,10 @@
 import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-C3IECePB.js";
-import { g as readScope, u as defineScope } from "./component-internal-Bw4Mf9fd.js";
-import { d as getCurrentAppRenderRuntime } from "./component-scope-DzJEbYGE.js";
-import { p as isPromiseLike } from "./lifecycle-batch-CFI4NKpJ.js";
-import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-D-DFk2WN.js";
-import { A as insertRecordSorted, D as getRouteRecords, E as getRouteList, F as snapshotRouteState, N as restoreRouteState, P as setDefaultRouteAuthOptions, T as getDefaultRouteAuthOptions, f as addRouteToStores, h as getActiveRouteAuthOptions, i as getMatchingRouteRecord, m as clearRouteState, o as buildRouteContext, s as buildRouteContextBase, z as resource } from "./route-matching-IfQZmqkN.js";
-import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-ZTlD_EnK.js";
-import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-BL6rjGsO.js";
-//#region src/runtime/execution-model.ts
-const EXECUTION_MODEL_KEY = Symbol.for("__ASKR_EXECUTION_MODEL__");
-function getExecutionModel() {
-	return globalThis[EXECUTION_MODEL_KEY];
-}
-function assertExecutionModel(model) {
-	const g = globalThis;
-	const cur = g[EXECUTION_MODEL_KEY];
-	if (cur && cur !== model) throw new Error(`[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`);
-	if (!cur) g[EXECUTION_MODEL_KEY] = model;
-}
-//#endregion
+import { g as readScope, u as defineScope } from "./component-internal-DcrLymUJ.js";
+import { p as isPromiseLike } from "./lifecycle-batch-Dfpid9-A.js";
+import { b as withPageFramework, n as getActiveRenderContext, y as replacePageRoute } from "./render-context-D0Hoj9dW.js";
+import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-Bc52OIVc.js";
+import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-CPW_6nwF.js";
+import { c as removeRouteBasePath, i as getMatchingRouteRecord, l as buildRouteContext, o as addRouteBasePath, s as normalizeRouteBasePath, u as buildRouteContextBase, v as getActiveRouteAuthOptions } from "./route-matching-DqULzZtC.js";
 //#region src/router/lazy.ts
 const pendingLazy = /* @__PURE__ */ new Set();
 const lazyStates = /* @__PURE__ */ new WeakMap();
@@ -140,41 +127,210 @@ function setCurrentAuth(context) {
 	if (render) render.authContext = context;
 }
 //#endregion
-//#region src/common/page-render-envelope.ts
-const PAGE_RENDER_ENVELOPE_VERSION = 1;
-function ownedRecord(value) {
-	return Object.freeze({ ...value });
-}
-function createPageRenderEnvelope(input = {}) {
-	return Object.freeze({
-		version: PAGE_RENDER_ENVELOPE_VERSION,
-		resources: ownedRecord(input.resources),
-		route: input.route,
-		framework: ownedRecord(input.framework)
+//#region src/common/deferred-value.ts
+const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
+const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
+function defer(promise) {
+	let state = "pending";
+	let value;
+	let error;
+	const normalized = Promise.resolve(promise);
+	normalized.then((resolved) => {
+		state = "fulfilled";
+		value = resolved;
+	}, (reason) => {
+		state = "rejected";
+		error = reason;
 	});
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			get: () => state
+		},
+		value: {
+			enumerable: true,
+			get: () => value
+		},
+		error: {
+			enumerable: true,
+			get: () => error
+		},
+		promise: { value: normalized },
+		[DEFERRED_VALUE]: { value: true }
+	}));
 }
-function isPageRenderEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const candidate = value;
-	return candidate.version === PAGE_RENDER_ENVELOPE_VERSION && Boolean(candidate.resources && typeof candidate.resources === "object" && !Array.isArray(candidate.resources)) && Boolean(candidate.framework && typeof candidate.framework === "object" && !Array.isArray(candidate.framework));
+function isDeferred(value) {
+	if (!value || typeof value !== "object") return false;
+	const marker = Object.getOwnPropertyDescriptor(value, DEFERRED_VALUE);
+	return Boolean(marker && "value" in marker && marker.value === true);
 }
-function pageRenderEnvelope(value, fallback = {}) {
-	if (isPageRenderEnvelope(value)) return value;
-	return createPageRenderEnvelope({
-		...fallback,
-		route: value ?? fallback.route
-	});
+/** @internal Reconstruct settled server data without importing deferred rendering. */
+function reviveDeferredValue(state, value, error) {
+	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
+	if (state === "rejected") promise.catch(() => void 0);
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			value: state
+		},
+		value: {
+			enumerable: true,
+			value
+		},
+		error: {
+			enumerable: true,
+			value: error
+		},
+		promise: { value: promise },
+		[DEFERRED_VALUE]: { value: true }
+	}));
 }
-function replacePageRoute(value, route) {
-	const current = pageRenderEnvelope(value);
-	return createPageRenderEnvelope({
-		resources: current.resources,
-		route,
-		framework: current.framework
-	});
+//#endregion
+//#region src/router/route-hydration.ts
+function isDeferredHydrationValue(value) {
+	return isDeferred(value);
+}
+const omissionGuards = /* @__PURE__ */ new WeakMap();
+function propertyPath(parent, key) {
+	if (/^(?:0|[1-9]\d*)$/.test(key)) return `${parent}[${key}]`;
+	if (/^[A-Za-z_$][\w$]*$/.test(key)) return `${parent}.${key}`;
+	return `${parent}[${JSON.stringify(key)}]`;
+}
+function invalid(route, path, reason) {
+	throw new TypeError(`[Askr] Route hydration data for "${route}" at "${path}" is not JSON transport-safe: ${reason}. Return JSON-compatible data or use route(..., { dehydrate(data) { ... } }) to omit server-only values.`);
+}
+function objectLabel(value) {
+	if (value instanceof Date) return "Date";
+	if (value instanceof Map) return "Map";
+	if (value instanceof Set) return "Set";
+	const constructor = value.constructor;
+	return typeof constructor === "function" && constructor.name ? constructor.name : "class instance";
+}
+/** Validate the exact value that will enter the route hydration envelope. */
+function validateRouteHydrationData(value, route, path = "$", ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) invalid(route, path, "non-finite numbers are not supported");
+		return;
+	}
+	if (typeof value === "undefined") invalid(route, path, "undefined is not supported");
+	if (typeof value === "bigint") invalid(route, path, "bigint is not supported");
+	if (typeof value === "symbol") invalid(route, path, "symbols are not supported");
+	if (typeof value === "function") invalid(route, path, "functions are not supported");
+	const object = value;
+	if (isDeferredHydrationValue(object)) {
+		if (object.state === "fulfilled") validateRouteHydrationData(object.value, route, `${path}.value`, ancestors);
+		return;
+	}
+	if (ancestors.has(object)) invalid(route, path, "cyclic references are not supported");
+	ancestors.add(object);
+	try {
+		if (Array.isArray(object)) {
+			for (let index = 0; index < object.length; index += 1) if (!Object.prototype.hasOwnProperty.call(object, index)) invalid(route, `${path}[${index}]`, "sparse arrays are not supported");
+			for (const key of Reflect.ownKeys(object)) {
+				if (key === "length") continue;
+				if (typeof key === "symbol") invalid(route, path, "symbol-keyed properties are not supported");
+				const descriptor = Object.getOwnPropertyDescriptor(object, key);
+				if (!descriptor.enumerable) invalid(route, propertyPath(path, key), "non-enumerable properties are not supported");
+				if (!("value" in descriptor)) invalid(route, propertyPath(path, key), "accessors are not supported");
+				if (!/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= object.length) invalid(route, propertyPath(path, key), "named array properties are not supported");
+				validateRouteHydrationData(descriptor.value, route, propertyPath(path, key), ancestors);
+			}
+			return;
+		}
+		const prototype = Object.getPrototypeOf(object);
+		if (prototype !== Object.prototype && prototype !== null) invalid(route, path, `${objectLabel(object)} instances are not supported; use a plain object`);
+		for (const key of Reflect.ownKeys(object)) {
+			if (typeof key === "symbol") invalid(route, path, "symbol-keyed properties are not supported");
+			const descriptor = Object.getOwnPropertyDescriptor(object, key);
+			const childPath = propertyPath(path, key);
+			if (!descriptor.enumerable) invalid(route, childPath, "non-enumerable properties are not supported");
+			if (!("value" in descriptor)) invalid(route, childPath, "accessors are not supported");
+			validateRouteHydrationData(descriptor.value, route, childPath, ancestors);
+		}
+	} finally {
+		ancestors.delete(object);
+	}
 }
-function isEmptyPageRenderEnvelope(value) {
-	return value.route === void 0 && Object.keys(value.resources).length === 0 && Object.keys(value.framework).length === 0;
+function omissionMap(complete, selected, ancestors = /* @__PURE__ */ new Set()) {
+	if (!complete || typeof complete !== "object" || isDeferredHydrationValue(complete)) return void 0;
+	if (ancestors.has(complete)) return void 0;
+	ancestors.add(complete);
+	const selectedObject = selected && typeof selected === "object" ? selected : void 0;
+	const output = Object.create(null);
+	try {
+		for (const key of Object.keys(complete)) {
+			if (!selectedObject || !Object.prototype.hasOwnProperty.call(selectedObject, key)) {
+				output[key] = 1;
+				continue;
+			}
+			const completeDescriptor = Object.getOwnPropertyDescriptor(complete, key);
+			const selectedDescriptor = Object.getOwnPropertyDescriptor(selectedObject, key);
+			if (!completeDescriptor || !selectedDescriptor) continue;
+			if (!("value" in completeDescriptor) || !("value" in selectedDescriptor)) continue;
+			const nested = omissionMap(completeDescriptor.value, selectedDescriptor.value, ancestors);
+			if (nested) output[key] = nested;
+		}
+	} finally {
+		ancestors.delete(complete);
+	}
+	return Object.keys(output).length > 0 ? Object.freeze(output) : void 0;
+}
+function prepareRouteHydrationData(complete, dehydrate, context, route = context.href || context.pathname) {
+	const selected = dehydrate ? dehydrate(complete, context) : complete;
+	if (isPromiseLike(selected)) throw new TypeError(`[Askr] Route dehydrate() for "${route}" returned a Promise. dehydrate(data, context) must be synchronous.`);
+	validateRouteHydrationData(selected, route);
+	return {
+		data: selected,
+		metadata: Object.freeze({
+			r: route,
+			...dehydrate ? { o: omissionMap(complete, selected) } : {}
+		})
+	};
+}
+function readMetadata(framework) {
+	const value = framework["rh"];
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const metadata = value;
+	return typeof metadata.r === "string" ? metadata : void 0;
+}
+function omittedRead(route, path) {
+	throw new Error(`[Askr] routeData() read "${path}" on the initial hydration of "${route}", but that branch was intentionally omitted by dehydrate(). Keep initial hydrated rendering within the selected data, or wait for a client navigation that reruns the loader with the complete result.`);
+}
+function guardOmissions(value, omissions, route, path = "$") {
+	if (!omissions || !value || typeof value !== "object" || isDeferredHydrationValue(value)) return value;
+	let guards = omissionGuards.get(value);
+	if (!guards) {
+		guards = /* @__PURE__ */ new WeakMap();
+		omissionGuards.set(value, guards);
+	}
+	const cached = guards.get(omissions);
+	if (cached) return cached;
+	const guarded = new Proxy(value, { get(target, property, receiver) {
+		if (typeof property === "string") {
+			const omitted = omissions[property];
+			if (omitted && !Object.prototype.hasOwnProperty.call(target, property)) omittedRead(route, propertyPath(path, property));
+			const child = Reflect.get(target, property, receiver);
+			return omitted === 1 ? child : guardOmissions(child, omitted, route, propertyPath(path, property));
+		}
+		return Reflect.get(target, property, receiver);
+	} });
+	guards.set(omissions, guarded);
+	return guarded;
+}
+function guardHydratedRouteData(value, framework) {
+	const metadata = readMetadata(framework);
+	return metadata ? guardOmissions(value, metadata.o, metadata.r) : value;
+}
+function getRouteHydrationMetadata(framework) {
+	return readMetadata(framework);
+}
+/** @internal Remove initial-only omission guards after a client loader reruns. */
+function withoutRouteHydrationMetadata(framework) {
+	if (!framework || !("rh" in framework)) return framework;
+	const next = { ...framework };
+	delete next["rh"];
+	return next;
 }
 //#endregion
 //#region src/router/resolution.ts
@@ -208,14 +364,21 @@ function createRouteRenderResult(record, params, context, handler) {
 function getDefaultRouteMode() {
 	return typeof window !== "undefined" ? "spa" : "ssr";
 }
+function withoutInitialRouteHydrationMetadata(envelope) {
+	return withPageFramework(envelope, withoutRouteHydrationMetadata(envelope.framework) ?? {});
+}
 /** @internal Bind resolved loader output to one route subtree and its hydration envelope. */
-function bindResolvedRouteData(handler, data) {
+function bindResolvedRouteData(handler, data, hydration) {
 	return (params, context) => {
 		const renderContext = getActiveRenderContext();
 		if (renderContext) {
 			const envelope = replacePageRoute(renderContext.renderData, data);
-			renderContext.renderData = envelope;
-			renderContext.hydrationData = envelope;
+			renderContext.renderData = hydration ? envelope : withoutInitialRouteHydrationMetadata(envelope);
+			const hydrationEnvelope = replacePageRoute(renderContext.hydrationData, hydration?.data ?? data);
+			renderContext.hydrationData = hydration ? withPageFramework(hydrationEnvelope, {
+				...hydrationEnvelope.framework,
+				["rh"]: hydration.metadata
+			}) : withoutInitialRouteHydrationMetadata(hydrationEnvelope);
 		}
 		return handler(params, context);
 	};
@@ -254,7 +417,12 @@ function buildLoadedRenderResult(record, params, context, request, telemetry, lo
 		}));
 		const loaded = runPreload ? runPreload.then(load) : load();
 		const finalize = (data) => {
-			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data));
+			const hydration = context.mode === "ssr" ? prepareRouteHydrationData(data, record.options?.dehydrate, {
+				...context,
+				params,
+				request
+			}, context.href || context.pathname || record.path) : void 0;
+			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data, hydration));
 			routeRenderData.set(result, data);
 			return result;
 		};
@@ -308,24 +476,33 @@ function resolveMatchedRoute(record, params, context, authOptions, request, tele
 }
 function resolveRouteRequest(target, options) {
 	if (!options?.registry) throw new TypeError("resolveRouteRequest requires options.registry.");
+	const basePath = normalizeRouteBasePath(options.registry.manifest.basePath);
+	const logicalTarget = removeRouteBasePath(target, basePath);
+	if (logicalTarget === void 0) return null;
 	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
 		const records = options.registry.manifest.records;
-		const match = getMatchingRouteRecord(target, records);
+		const match = getMatchingRouteRecord(logicalTarget, records);
 		if (!match) return null;
 		const mode = options.mode ?? getDefaultRouteMode();
 		const signal = options.signal ?? getActiveRenderContext()?.signal ?? new AbortController().signal;
 		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.registry.manifest.auth);
-		const base = buildRouteContextBase(target, match.params, {
+		const base = buildRouteContextBase(logicalTarget, match.params, {
 			mode,
 			signal
 		});
+		const exposeRedirect = (result) => result?.kind === "redirect" ? {
+			...result,
+			to: addRouteBasePath(result.to, basePath)
+		} : result;
 		const finalize = (authContext) => {
 			setCurrentAuth(authContext);
-			return resolveMatchedRoute(match.record, match.params, buildRouteContext(target, match.params, {
+			const result = resolveMatchedRoute(match.record, match.params, buildRouteContext(logicalTarget, match.params, {
 				mode,
 				signal,
 				authContext
 			}), authOptions, options.request, options.telemetry, options.load !== false);
+			if (!basePath) return result;
+			return isPromiseLike(result) ? Promise.resolve(result).then(exposeRedirect) : exposeRedirect(result);
 		};
 		if (options.authContext) return finalize(options.authContext);
 		if (!authOptions?.resolve) return finalize(anonymous());
@@ -334,169 +511,4 @@ function resolveRouteRequest(target, options) {
 	});
 }
 //#endregion
-//#region src/router/manifest.ts
-function createRouteManifest() {
-	const auth = getDefaultRouteAuthOptions();
-	return {
-		records: [...getRouteRecords()],
-		...auth ? { auth } : {}
-	};
-}
-function _applyManifest(manifest) {
-	setDefaultRouteAuthOptions(manifest.auth);
-	for (const record of manifest.records) {
-		insertRecordSorted(record);
-		addRouteToStores({
-			path: record.path,
-			handler: record.handler,
-			namespace: record.options.namespace,
-			..."fallbackPrefix" in record && typeof record.fallbackPrefix === "string" ? { fallbackPrefix: record.fallbackPrefix } : {}
-		});
-	}
-}
-function createRouteRegistry(definition, options = {}) {
-	const previous = snapshotRouteState();
-	clearRouteState();
-	try {
-		setDefaultRouteAuthOptions(options.auth);
-		definition();
-		const manifest = createRouteManifest();
-		return Object.freeze({
-			manifest,
-			routes: getRouteList()
-		});
-	} finally {
-		restoreRouteState(previous);
-	}
-}
-//#endregion
-//#region src/router/deferred.tsx
-const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
-const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
-function defer(promise) {
-	let state = "pending";
-	let value;
-	let error;
-	const normalized = Promise.resolve(promise);
-	normalized.then((resolved) => {
-		state = "fulfilled";
-		value = resolved;
-	}, (reason) => {
-		state = "rejected";
-		error = reason;
-	});
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			get: () => state
-		},
-		value: {
-			enumerable: true,
-			get: () => value
-		},
-		error: {
-			enumerable: true,
-			get: () => error
-		},
-		promise: { value: normalized },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-function isDeferred(value) {
-	return Boolean(value && typeof value === "object" && value[DEFERRED_VALUE] === true);
-}
-/** @internal Reconstruct settled server data without starting loader work. */
-function reviveDeferredValue(state, value, error) {
-	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
-	if (state === "rejected") promise.catch(() => void 0);
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			value: state
-		},
-		value: {
-			enumerable: true,
-			value
-		},
-		error: {
-			enumerable: true,
-			value: error
-		},
-		promise: { value: promise },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-function abortError() {
-	const error = /* @__PURE__ */ new Error("Deferred route data was aborted.");
-	error.name = "AbortError";
-	return error;
-}
-function awaitWithSignal(promise, signal) {
-	if (!signal) return promise;
-	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);
-		});
-	});
-}
-async function resolveDeferredValues(input, signal) {
-	const seen = /* @__PURE__ */ new Set();
-	const visit = async (value) => {
-		if (!value || typeof value !== "object") return;
-		if (isDeferred(value)) {
-			const resolved = await awaitWithSignal(value.promise, signal);
-			await visit(resolved);
-			return;
-		}
-		if (seen.has(value)) return;
-		seen.add(value);
-		const children = Array.isArray(value) ? value : Object.values(value);
-		await Promise.all(children.map(visit));
-	};
-	await visit(input);
-	return input;
-}
-function routeData() {
-	const envelope = getCurrentRenderData();
-	if (envelope) return envelope.route;
-	const runtime = getCurrentAppRenderRuntime();
-	if (!runtime?.hasRoute) throw new Error("routeData() can only be read while rendering a route with loader data.");
-	return runtime.route;
-}
-function rejectedChild(props, error) {
-	return typeof props.rejected === "function" ? props.rejected(error) : props.rejected ?? null;
-}
-function Resolve(props) {
-	if (props.value.state === "fulfilled") return props.children(props.value.value);
-	if (props.value.state === "rejected") return rejectedChild(props, props.value.error);
-	const renderContext = getActiveRenderContext();
-	if (renderContext) {
-		const id = `d:${renderContext.deferredBoundaries.length}`;
-		renderContext.deferredBoundaries.push({
-			id,
-			promise: props.value.promise,
-			fulfilled: (value) => props.children(value),
-			rejected: (error) => rejectedChild(props, error)
-		});
-		return {
-			type: DEFERRED_BOUNDARY,
-			props: {
-				id,
-				pending: props.pending ?? null
-			}
-		};
-	}
-	const result = resource(() => props.value.promise, [props.value]);
-	if (result.error) return rejectedChild(props, result.error);
-	if (result.pending || result.value === null) return props.pending ?? null;
-	return props.children(result.value);
-}
-//#endregion
-export { _preloadRouteHandler as C, getExecutionModel as E, getRenderHandler as S, assertExecutionModel as T, isPageRenderEnvelope as _, resolveDeferredValues as a, Outlet as b, _applyManifest as c, getRouteRenderContext as d, getRouteRenderData as f, isEmptyPageRenderEnvelope as g, createPageRenderEnvelope as h, isDeferred as i, createRouteRegistry as l, resolveRouteRequest as m, Resolve as n, reviveDeferredValue as o, hasRouteRenderData as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, bindResolvedRouteData as u, pageRenderEnvelope as v, lazy as w, createRouteHandler as x, currentAuth as y };
+export { createRouteHandler as _, resolveRouteRequest as a, lazy as b, prepareRouteHydrationData as c, DEFERRED_BOUNDARY as d, defer as f, Outlet as g, currentAuth as h, hasRouteRenderData as i, validateRouteHydrationData as l, reviveDeferredValue as m, getRouteRenderContext as n, getRouteHydrationMetadata as o, isDeferred as p, getRouteRenderData as r, guardHydratedRouteData as s, bindResolvedRouteData as t, withoutRouteHydrationMetadata as u, getRenderHandler as v, _preloadRouteHandler as y };