@askrjs/askr 0.0.69 → 0.0.71

package/dist/{route-matching-DLBWDeXX.js → route-matching-M-f1VQRu.js}

@@ -1,4 +1,278 @@
-import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+import { t as enqueueRuntimeLane, v as logger } from "./access-ePqdQqkV.js";
+import { c as registerCommitOperationForInstance, d as getCurrentContextFrame, g as withAsyncResourceContext } from "./component-internal-CPjM4n8M.js";
+import { f as getCurrentComponentInstance } from "./component-scope-CC3cojX9.js";
+import { p as isPromiseLike } from "./lifecycle-batch-COgl8jMS.js";
+import { t as brandSnapshotSource } from "./snapshot-source-BB42xgwb.js";
+import { i as getNextRenderKey, l as throwSSRDataMissing, n as getActiveRenderContext, r as getCurrentRenderData, u as SSRDataMissingError } from "./render-context-Clw3rFiO.js";
+import { t as state } from "./state-CVuQVjvK.js";
+//#region src/runtime/resource-cell.ts
+/**
+* Pure, component-agnostic ResourceCell state machine.
+* - Holds value/pending/error/generation/controller
+* - Exposes a stable `snapshot` object: { value, pending, error, refresh }
+* - Uses `withAsyncResourceContext` to bind the synchronous execution step
+*   to a captured frame. Continuations after await do not see the frame.
+*/
+var ResourceCell = class {
+	constructor(fn, deps, resourceFrame) {
+		this.value = null;
+		this.pending = true;
+		this.error = null;
+		this.generation = 0;
+		this.controller = null;
+		this.deps = null;
+		this.resourceFrame = null;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.disposed = false;
+		this.fn = fn;
+		this.deps = deps ? deps.slice() : null;
+		this.resourceFrame = resourceFrame;
+		this.snapshot = brandSnapshotSource({
+			value: null,
+			pending: true,
+			error: null,
+			refresh: () => this.refresh()
+		});
+	}
+	setLoader(fn) {
+		this.fn = fn;
+	}
+	subscribe(cb) {
+		this.subscribers.add(cb);
+		return () => this.subscribers.delete(cb);
+	}
+	notifySubscribers() {
+		this.snapshot.value = this.value;
+		this.snapshot.pending = this.pending;
+		this.snapshot.error = this.error;
+		for (const cb of this.subscribers) cb();
+	}
+	start(ssr = false, notify = true) {
+		if (this.disposed) return;
+		const generation = this.generation;
+		this.controller?.abort();
+		const controller = new AbortController();
+		this.controller = controller;
+		this.pending = true;
+		this.error = null;
+		if (notify) this.notifySubscribers();
+		let result;
+		try {
+			result = withAsyncResourceContext(this.resourceFrame, () => this.fn({ signal: controller.signal }));
+		} catch (err) {
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (!isPromiseLike(result)) {
+			this.value = result;
+			this.pending = false;
+			this.error = null;
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (ssr) throwSSRDataMissing();
+		Promise.resolve(result).then((val) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted) return;
+			this.value = val;
+			this.pending = false;
+			this.error = null;
+			this.notifySubscribers();
+		}).catch((err) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted || err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError") return;
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			try {
+				if (this.ownerName) logger.error(`[Askr] Async resource error in ${this.ownerName}:`, err);
+				else logger.error("[Askr] Async resource error:", err);
+			} catch {}
+			this.notifySubscribers();
+		});
+	}
+	refresh() {
+		if (this.disposed) return;
+		this.generation++;
+		this.controller?.abort();
+		this.start();
+	}
+	abort() {
+		this.controller?.abort();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.controller?.abort();
+		this.subscribers.clear();
+	}
+};
+//#endregion
+//#region src/runtime/resource-operation.ts
+/**
+* Resource primitive — simple, deterministic async primitive
+* Usage: resource(fn, deps)
+* - fn receives { signal }
+* - captures execution context once at creation (synchronous step only)
+* - executes at most once per generation; stale async results are ignored
+* - refresh() cancels in-flight execution, increments generation and re-runs
+* - exposes { value, pending, error, refresh }
+* - during SSR, async results are disallowed and will throw synchronously
+*/
+function resource(fn, deps = []) {
+	const instance = getCurrentComponentInstance();
+	const inst = instance;
+	if (!instance) {
+		const renderData = getCurrentRenderData()?.resources;
+		if (renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:")))) {
+			const key = getNextRenderKey();
+			if (!(key in renderData)) throwSSRDataMissing();
+			const val = renderData[key];
+			return brandSnapshotSource({
+				value: val,
+				pending: false,
+				error: null,
+				refresh: () => {}
+			});
+		}
+		if (getActiveRenderContext()) throwSSRDataMissing();
+		throw new Error("[Askr] resource() must be called during component render inside an app. Do not create resources at module scope or outside render.");
+	}
+	const renderData = getCurrentRenderData()?.resources;
+	if (renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:")))) {
+		const key = getNextRenderKey();
+		if (!(key in renderData)) throwSSRDataMissing();
+		const val = renderData[key];
+		const h = state({
+			cell: void 0,
+			snapshot: brandSnapshotSource({
+				value: val,
+				pending: false,
+				error: null,
+				refresh: () => {}
+			})
+		})();
+		h.snapshot.value = val;
+		h.snapshot.pending = false;
+		h.snapshot.error = null;
+		return h.snapshot;
+	}
+	const holder = state({
+		cell: void 0,
+		snapshot: brandSnapshotSource({
+			value: null,
+			pending: true,
+			error: null,
+			refresh: () => {}
+		})
+	});
+	const h = holder();
+	if (!h.cell) {
+		const cell = new ResourceCell(fn, deps, getCurrentContextFrame());
+		cell.ownerName = inst.fn?.name || "<anonymous>";
+		h.cell = cell;
+		h.snapshot = cell.snapshot;
+		const unsubscribe = cell.subscribe(() => {
+			const cur = holder();
+			cur.snapshot.value = cell.snapshot.value;
+			cur.snapshot.pending = cell.snapshot.pending;
+			cur.snapshot.error = cell.snapshot.error;
+			holder.set(cur);
+			try {
+				inst.notifyUpdate?.();
+			} catch {}
+		});
+		(inst.cleanupFns ??= []).push(() => {
+			unsubscribe();
+			cell.dispose();
+		});
+		if (inst.ssr) {
+			cell.start(true, false);
+			if (!cell.pending) {
+				const cur = holder();
+				cur.snapshot.value = cell.value;
+				cur.snapshot.pending = cell.pending;
+				cur.snapshot.error = cell.error;
+			}
+		} else {
+			const scheduledGeneration = cell.generation;
+			registerCommitOperationForInstance(inst, () => {
+				enqueueRuntimeLane("post", () => {
+					if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+					try {
+						cell.start(false, false);
+					} catch (err) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = err ?? null;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+						return;
+					}
+					if (!cell.pending) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = cell.error;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+					}
+				});
+			});
+		}
+	}
+	const cell = h.cell;
+	cell.setLoader(fn);
+	if (!cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => !Object.is(d, deps[i]))) {
+		cell.deps = deps.slice();
+		cell.generation++;
+		cell.pending = true;
+		cell.error = null;
+		h.snapshot.pending = true;
+		h.snapshot.error = null;
+		try {
+			if (inst.ssr) {
+				cell.start(true, false);
+				if (!cell.pending) {
+					const cur = holder();
+					cur.snapshot.value = cell.value;
+					cur.snapshot.pending = cell.pending;
+					cur.snapshot.error = cell.error;
+				}
+			} else {
+				const scheduledGeneration = cell.generation;
+				registerCommitOperationForInstance(inst, () => {
+					enqueueRuntimeLane("post", () => {
+						if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+						cell.start(false, false);
+						if (!cell.pending) {
+							const cur = holder();
+							cur.snapshot.value = cell.value;
+							cur.snapshot.pending = cell.pending;
+							cur.snapshot.error = cell.error;
+							holder.set(cur);
+							inst.notifyUpdate?.();
+						}
+					});
+				});
+			}
+		} catch (err) {
+			if (err instanceof SSRDataMissingError) throw err;
+			cell.error = err;
+			cell.pending = false;
+			const cur = holder();
+			cur.snapshot.value = cell.value;
+			cur.snapshot.pending = cell.pending;
+			cur.snapshot.error = cell.error;
+		}
+	}
+	return h.snapshot;
+}
+//#endregion
 //#region src/router/match.ts
 function splitPathSegments(path) {
 	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
@@ -510,4 +784,4 @@ function _resolveRouteMatchFromRoutes(pathname, routeList) {
 	return findBestResolvedRouteFromRoutes(pathname, routeList);
 }
 //#endregion
-export { insertRecordSorted as A, getCurrentPathPrefix as C, getRouteRecords as D, getRouteList as E, snapshotRouteState as F, computeRank as I, normalizeRouteSegmentName as L, pushRegistrationScope as M, restoreRouteState as N, hasActivePageScope as O, setDefaultRouteAuthOptions as P, parseSegments as R, getCurrentPageScope as S, getDefaultRouteAuthOptions as T, getCurrentInheritedAuthRequirements as _, resolveRouteFromRoutes as a, getCurrentLayoutChain as b, deepFreeze as c, _setActiveRouteAuthOptions as d, addRouteToStores as f, getActiveRoutes as g, getActiveRouteAuthOptions as h, getMatchingRouteRecord as i, lockRouteRegistration as j, hasRegisteredRoutes as k, makeQuery as l, clearRouteState as m, computeMatchesFromRoutes as n, buildRouteContext as o, assertRouteRegistrationUnlocked as p, computeRouteActivityMatches as r, buildRouteContextBase as s, _resolveRouteMatchFromRoutes as t, parseLocation as u, getCurrentInheritedMeta as v, getCurrentScopeKind as w, getCurrentPageChain as x, getCurrentInheritedPolicies as y };
+export { insertRecordSorted as A, getCurrentPathPrefix as C, getRouteRecords as D, getRouteList as E, snapshotRouteState as F, computeRank as I, normalizeRouteSegmentName as L, pushRegistrationScope as M, restoreRouteState as N, hasActivePageScope as O, setDefaultRouteAuthOptions as P, parseSegments as R, getCurrentPageScope as S, getDefaultRouteAuthOptions as T, getCurrentInheritedAuthRequirements as _, resolveRouteFromRoutes as a, getCurrentLayoutChain as b, deepFreeze as c, _setActiveRouteAuthOptions as d, addRouteToStores as f, getActiveRoutes as g, getActiveRouteAuthOptions as h, getMatchingRouteRecord as i, lockRouteRegistration as j, hasRegisteredRoutes as k, makeQuery as l, clearRouteState as m, computeMatchesFromRoutes as n, buildRouteContext as o, assertRouteRegistrationUnlocked as p, computeRouteActivityMatches as r, buildRouteContextBase as s, _resolveRouteMatchFromRoutes as t, parseLocation as u, getCurrentInheritedMeta as v, getCurrentScopeKind as w, getCurrentPageChain as x, getCurrentInheritedPolicies as y, resource as z };

package/dist/router/index.d.ts

@@ -1,8 +1,9 @@
 import { c as RenderableChild } from "../control-DO-iBEtV.js";
 import { r as JSXElement, s as Props } from "../jsx-Dvr2SGRG.js";
 import "../types-DEhT-Nrv.js";
-import { A as RouteRecord, B as RouteSnapshot, C as RouteMetaSource, D as RoutePathParams, E as RouteParams, F as RouteRenderResult, I as RouteRequestOptions, L as RouteRequestResult, M as RouteRefSearch, N as RouteRegistry, O as RoutePolicy, P as RouteRegistryOptions, R as RouteSearch, S as RouteMeta, T as RouteOptions, _ as RouteDefinition, a as AccessRedirectDecision, b as RouteManifest, c as LayoutScopeRecord, d as ParsedSegment, f as Route, g as RouteContext, h as RouteComponent, i as AccessDenyStatus, j as RouteRef, k as RouteQuery, l as PageHelperOptions, m as RouteAuthResolver, n as AccessDecision, o as AccessRedirectStatus, p as RouteAuthOptions, r as AccessDenyDecision, s as GroupHelperOptions, t as AccessAllowDecision, u as PageScopeRecord, v as RouteDestination, w as RouteMode, x as RouteMatch, y as RouteHandler, z as RouteSearchValue } from "../router-C0XQA62W.js";
-import { a as ScrollRestorationOptions, i as NavigationScrollBehavior, n as NavigateOptions, r as HistoryScrollBehavior, t as navigate } from "../navigate-CV-RDqYP.js";
+import { A as RouteRecord, B as RouteSnapshot, C as RouteMetaSource, D as RoutePathParams, E as RouteParams, F as RouteRenderResult, I as RouteRequestOptions, L as RouteRequestResult, M as RouteRefSearch, N as RouteRegistry, O as RoutePolicy, P as RouteRegistryOptions, R as RouteSearch, S as RouteMeta, T as RouteOptions, _ as RouteDefinition, a as AccessRedirectDecision, b as RouteManifest, c as LayoutScopeRecord, d as ParsedSegment, f as Route, g as RouteContext, h as RouteComponent, i as AccessDenyStatus, j as RouteRef, k as RouteQuery, l as PageHelperOptions, m as RouteAuthResolver, n as AccessDecision, o as AccessRedirectStatus, p as RouteAuthOptions, r as AccessDenyDecision, s as GroupHelperOptions, t as AccessAllowDecision, u as PageScopeRecord, v as RouteDestination, w as RouteMode, x as RouteMatch, y as RouteHandler, z as RouteSearchValue } from "../router-C3vENhUh.js";
+import { a as ScrollRestorationOptions, i as NavigationScrollBehavior, n as NavigateOptions, r as HistoryScrollBehavior, t as navigate } from "../navigate-Cbq6QHVl.js";
+import { i as onRouteChange, n as RouteChangeOptions, r as currentRoute, t as RouteChangeCleanup } from "../activity-DZ-NCYr8.js";
 import { AuthContext, AuthContext as AuthContext$1, AuthRequirement, AuthRequirement as AuthRequirement$1 } from "@askrjs/auth";
 import { ObjectSchema } from "@askrjs/schema";
 //#region src/router/route-query.d.ts
@@ -39,9 +40,6 @@ declare function fallback(Component: RouteComponent): void;
 declare function route<const TPath extends string, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
 declare function route<const TPath extends string, TComponent extends AnyRouteComponent, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
 //#endregion
-//#region src/router/activity.d.ts
-declare function currentRoute<TParams extends RouteParams = RouteParams>(): RouteSnapshot<TParams>;
-//#endregion
 //#region src/router/auth.d.ts
 /** Return the identity resolved for the route currently being rendered. */
 declare function currentAuth(): AuthContext$1;
@@ -128,6 +126,8 @@ type LinkBaseProps = Omit<Props, 'children' | 'href' | 'class' | 'rel' | 'target
    * Optional aria-label for accessibility when link text isn't descriptive enough.
    */
   'aria-label'?: string;
+  onPress?: (event: Event) => void;
+  onClick?: (event: MouseEvent) => void;
 };
 type LinkProps = LinkBaseProps & ({
   href: string;
@@ -163,6 +163,6 @@ type LinkProps = LinkBaseProps & ({
  * - Keyboard handling automatic
  * - Composable via mergeProps
  */
-declare function Link({ href: suppliedHref, to, class: className, children, rel, target, 'aria-current': ariaCurrent, 'aria-label': ariaLabel, ...rest }: LinkProps): JSXElement;
+declare function Link({ href: suppliedHref, to, class: className, children, rel, target, 'aria-current': ariaCurrent, 'aria-label': ariaLabel, onPress, onClick, ...rest }: LinkProps): JSXElement;
 //#endregion
-export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type AuthContext, type AuthRequirement, type Deferred, type DeferredState, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, type LazyRouteComponent, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteComponent, type RouteContext, type RouteDefinition, type RouteDestination, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMeta, type RouteMetaSource, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRef, type RouteRegistry, type RouteRegistryOptions, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };
+export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type AuthContext, type AuthRequirement, type Deferred, type DeferredState, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, type LazyRouteComponent, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteChangeCleanup, type RouteChangeOptions, type RouteComponent, type RouteContext, type RouteDefinition, type RouteDestination, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMeta, type RouteMetaSource, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRef, type RouteRegistry, type RouteRegistryOptions, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, onRouteChange, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };

package/dist/router/index.js

@@ -1,7 +1,9 @@
-import { C as lazy, a as resolveDeferredValues, b as Outlet, i as isDeferred, l as createRouteRegistry, m as resolveRouteRequest, n as Resolve, r as defer, s as routeData, y as currentAuth } from "../deferred-zHtUheIQ.js";
+import { C as lazy, a as resolveDeferredValues, b as Outlet, i as isDeferred, l as createRouteRegistry, m as resolveRouteRequest, n as Resolve, r as defer, s as routeData, y as currentAuth } from "../deferred-Cr58yIQD.js";
 import { jsx } from "../jsx-runtime.js";
-import { a as route, i as page, n as group, r as index, t as fallback } from "../authoring-uaJ556aG.js";
-import { _ as currentRoute, a as serializeRouteMeta, c as getCurrentHref, d as parseTargetUrl, h as syncRegisteredRouteSnapshot, i as resolveRouteMeta, l as getRegisteredAppsSnapshot, m as syncAppRegistrationLocation, n as navigate, p as setCurrentRouteLocation, r as reconcileRouteMeta, s as saveScrollPosition, u as getWindowHref } from "../navigate-DpR-cML9.js";
+import { a as isSafeHref } from "../csp-nonce-CwSRP3Jl.js";
+import { a as route, i as page, n as group, r as index, t as fallback } from "../authoring-CXmUcaCe.js";
+import { n as onRouteChange, t as currentRoute } from "../activity-C2tPn9Fr.js";
+import { a as serializeRouteMeta, c as getCurrentHref, d as parseTargetUrl, h as syncRegisteredRouteSnapshot, i as resolveRouteMeta, l as getRegisteredAppsSnapshot, m as syncAppRegistrationLocation, n as navigate, p as setCurrentRouteLocation, r as reconcileRouteMeta, s as saveScrollPosition, u as getWindowHref } from "../navigate-CuGQzS_Y.js";
 import { o as mergeProps } from "../compose-ref-Cc_YkUpM.js";
 import { t as applyInteractionPolicy } from "../interactions-w7gQN4ha.js";
 //#region src/router/route-query.ts
@@ -162,22 +164,31 @@ function isSameOriginNavigableHref(href) {
 * - Keyboard handling automatic
 * - Composable via mergeProps
 */
-function Link({ href: suppliedHref, to, class: className, children, rel, target, "aria-current": ariaCurrent, "aria-label": ariaLabel, ...rest }) {
+function Link({ href: suppliedHref, to, class: className, children, rel, target, "aria-current": ariaCurrent, "aria-label": ariaLabel, onPress, onClick, ...rest }) {
 	const href = to?.href ?? suppliedHref;
 	if (!href) throw new Error("Link requires href or to.");
+	if (!isSafeHref(href)) throw new TypeError("Link href uses an unsafe URL scheme.");
+	const handleNavigation = (e) => {
+		if (e.defaultPrevented) return;
+		const event = e;
+		if ((event.button ?? 0) !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+		if (target || !isSameOriginNavigableHref(href)) return;
+		event.preventDefault();
+		navigate(href);
+	};
+	const interaction = applyInteractionPolicy({
+		isNative: true,
+		disabled: false,
+		onPress: handleNavigation
+	});
+	const consumerActivation = (e) => {
+		onPress?.(e);
+		onClick?.(e);
+	};
 	return /* @__PURE__ */ jsx("a", {
-		...mergeProps(rest, {
-			...applyInteractionPolicy({
-				isNative: true,
-				disabled: false,
-				onPress: (e) => {
-					const event = e;
-					if ((event.button ?? 0) !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
-					if (target || !isSameOriginNavigableHref(href)) return;
-					event.preventDefault();
-					navigate(href);
-				}
-			}),
+		...mergeProps(interaction, {
+			...rest,
+			onClick: consumerActivation,
 			href,
 			class: className,
 			rel,
@@ -189,4 +200,4 @@ function Link({ href: suppliedHref, to, class: className, children, rel, target,
 	});
 }
 //#endregion
-export { Link, Outlet, Resolve, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to, unauthorized, updateRouteQuery };
+export { Link, Outlet, Resolve, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, navigate, notFound, onRouteChange, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to, unauthorized, updateRouteQuery };

package/dist/{router-C0XQA62W.d.ts → router-C3vENhUh.d.ts}

@@ -1,6 +1,6 @@
 import { c as RenderableChild } from "./control-DO-iBEtV.js";
 import { D as QueryPrefetchContext, u as CoreTelemetry } from "./index-Bki2rqcr.js";
-import { t as ActionDescriptor } from "./index-DSClfSoC.js";
+import { t as ActionDescriptor } from "./index-DxYJPVC4.js";
 import { AuthContext, AuthRequirement } from "@askrjs/auth";
 import { InferSchema, ObjectSchema } from "@askrjs/schema";
 //#region src/common/router.d.ts

package/dist/{selector-DueeR6Oz.js → selector-DEfqO1rA.js}

@@ -261,6 +261,14 @@ function getOrCreateSelectorHook(instance, hookIndex, source, equals) {
 	store.set(hookIndex, created);
 	return created;
 }
+/**
+* Creates a render-scoped predicate for keyed membership in reactive list rows.
+*
+* Use this when a `<For>` child needs to compare each stable item with a
+* changing selected value. Unlike a plain closure capture, the predicate
+* subscribes the affected rows and updates them without rebuilding the list.
+* Must be called during component render.
+*/
 function selector(source, equals = Object.is) {
 	markReadableUsage(source);
 	const instance = getCurrentInstance();

package/dist/ssg/index.d.ts

@@ -1,5 +1,5 @@
 import { d as DocumentRenderContext, f as DocumentRenderer, u as DocumentRenderArgs } from "../control-DO-iBEtV.js";
-import { D as RoutePathParams, N as RouteRegistry, O as RoutePolicy, T as RouteOptions, y as RouteHandler } from "../router-C0XQA62W.js";
+import { D as RoutePathParams, N as RouteRegistry, O as RoutePolicy, T as RouteOptions, y as RouteHandler } from "../router-C3vENhUh.js";
 import { AuthRequirement } from "@askrjs/auth";
 import "node:fs/promises";
 //#region src/ssg/types.d.ts
@@ -105,6 +105,13 @@ interface RouteRenderResult {
   written: boolean;
   /** Error message if rendering failed */
   error?: string;
+  /** Original exception preserved for programmatic diagnostics. */
+  errorCause?: unknown;
+  /** Route and phase context for the original exception. */
+  errorContext?: {
+    route: string;
+    phase: 'load' | 'render' | 'write';
+  };
 }
 /** Overall result from SSG generation */
 interface SSGResult {

package/dist/ssg/index.js

@@ -1,14 +1,18 @@
 import "../access-ePqdQqkV.js";
-import { S as getRenderHandler, a as resolveDeferredValues, l as createRouteRegistry, u as bindResolvedRouteData } from "../deferred-zHtUheIQ.js";
-import { a as route } from "../authoring-uaJ556aG.js";
+import { S as getRenderHandler, a as resolveDeferredValues, l as createRouteRegistry, u as bindResolvedRouteData } from "../deferred-Cr58yIQD.js";
+import { a as route } from "../authoring-CXmUcaCe.js";
 import { n as renderDocument } from "../ssr-CbQO5xd3.js";
-import { n as renderToString } from "../ssr-vE-KUgDV.js";
+import { n as renderToString } from "../ssr-BSUA9Y64.js";
 import * as fs from "node:fs/promises";
 import * as pathModule from "node:path";
 import * as os from "node:os";
 import * as fsSync from "node:fs";
 //#region src/ssg/route-utils.ts
+function assertSafeRoutePath(pathStr) {
+	if (!pathStr.startsWith("/") || pathStr.startsWith("//") || pathStr.includes("\\") || pathStr.includes("\0") || pathStr.split("/").some((segment) => segment === "." || segment === "..")) throw new Error(`SSG route path must be an absolute URL path without dot segments or backslashes: ${pathStr}`);
+}
 function getOutputFilePath(pathStr) {
+	assertSafeRoutePath(pathStr);
 	if (pathStr === "/") return "index.html";
 	return `${pathStr.replace(/^\/|\/$/g, "")}/index.html`;
 }
@@ -153,6 +157,7 @@ async function batchRenderRoutes(routes, options = {}) {
 		const baseData = resolvedData.hasData ? resolvedData.data : void 0;
 		const resourceCount = resolvedData.hasData && baseData ? Object.keys(baseData).length : 0;
 		const mergedHandler = route$2.handler;
+		let phase = route$2.loader ? "load" : "render";
 		try {
 			let routeData;
 			let hasRouteData = false;
@@ -182,11 +187,13 @@ async function batchRenderRoutes(routes, options = {}) {
 				hasRouteData = true;
 			}
 			const renderedHandler = hasRouteData ? bindResolvedRouteData(mergedHandler, routeData) : mergedHandler;
+			const registry = hasRouteData || !sharedRegistry ? createRouteRegistry(() => {
+				route(route$2.path, renderedHandler, { namespace: route$2.namespace });
+			}) : sharedRegistry;
+			phase = "render";
 			const html = renderToString({
 				url,
-				registry: hasRouteData || !sharedRegistry ? createRouteRegistry(() => {
-					route(route$2.path, renderedHandler, { namespace: route$2.namespace });
-				}) : sharedRegistry,
+				registry,
 				seed,
 				data: baseData,
 				document: document === void 0 ? void 0 : ({ appHtml }) => renderDocument(document, {
@@ -231,7 +238,12 @@ async function batchRenderRoutes(routes, options = {}) {
 				status: "error",
 				reason: "full",
 				written: false,
-				error: error instanceof Error ? error.message : String(error)
+				error: error instanceof Error ? error.message : String(error),
+				errorCause: error,
+				errorContext: {
+					route: url,
+					phase
+				}
 			};
 		}
 	};
@@ -247,6 +259,15 @@ async function batchRenderRoutes(routes, options = {}) {
 	return results;
 }
 //#endregion
+//#region src/ssg/output-path.ts
+function resolveSsgOutputPath(outputDir, filePath) {
+	const root = pathModule.resolve(outputDir);
+	const candidate = pathModule.resolve(root, filePath);
+	const relative = pathModule.relative(root, candidate);
+	if (!relative || relative === ".." || relative.startsWith(`..${pathModule.sep}`) || pathModule.isAbsolute(relative)) throw new Error(`SSG output path must stay inside outputDir: ${filePath}`);
+	return candidate;
+}
+//#endregion
 //#region src/ssg/write-static-files.ts
 /**
 * File I/O for Static Site Generation
@@ -262,17 +283,22 @@ async function writeStaticFiles(results, outputDir, options = {}, fileOperations
 	await fileOperations.mkdir(outputDir, { recursive: true });
 	for (const result of results) {
 		if (result.status !== "removed") continue;
-		const fullPath = pathModule.join(outputDir, result.filePath);
+		const fullPath = resolveSsgOutputPath(outputDir, result.filePath);
 		if (fsSync.existsSync(fullPath)) {
 			await fileOperations.rm(fullPath, { force: true });
 			await pruneEmptyDirs(pathModule.dirname(fullPath), outputDir, fileOperations);
 		}
 	}
 	const pendingWrites = [];
+	const reportedErrors = /* @__PURE__ */ new Set();
 	for (let index = 0; index < results.length; index += 1) {
 		const result = results[index];
 		if (result.status === "error") {
-			console.warn(`Skipping failed route: ${result.path} - ${result.error}`);
+			const diagnostic = `Skipping failed route: ${result.path} - ${result.error}`;
+			if (!reportedErrors.has(diagnostic)) {
+				reportedErrors.add(diagnostic);
+				console.warn(diagnostic);
+			}
 			continue;
 		}
 		if (result.status === "success" && result.written) pendingWrites.push(result);
@@ -280,7 +306,7 @@ async function writeStaticFiles(results, outputDir, options = {}, fileOperations
 	const directories = [];
 	const seenDirectories = /* @__PURE__ */ new Set();
 	for (const result of pendingWrites) {
-		const dir = pathModule.dirname(pathModule.join(outputDir, result.filePath));
+		const dir = pathModule.dirname(resolveSsgOutputPath(outputDir, result.filePath));
 		if (!seenDirectories.has(dir)) {
 			seenDirectories.add(dir);
 			directories.push(dir);
@@ -295,7 +321,7 @@ async function writeStaticFiles(results, outputDir, options = {}, fileOperations
 			nextIndex += 1;
 			if (current >= pendingWrites.length) return;
 			const result = pendingWrites[current];
-			const fullPath = pathModule.join(outputDir, result.filePath);
+			const fullPath = resolveSsgOutputPath(outputDir, result.filePath);
 			const tempPath = pathModule.join(pathModule.dirname(fullPath), `.${pathModule.basename(fullPath)}.askr-${process.pid}-${current}.tmp`);
 			try {
 				await fileOperations.writeFile(tempPath, result.html, "utf8");
@@ -310,11 +336,12 @@ async function writeStaticFiles(results, outputDir, options = {}, fileOperations
 async function pruneEmptyDirs(startDir, rootDir, fileOperations) {
 	let current = startDir;
 	const normalizedRoot = pathModule.resolve(rootDir);
-	while (current.startsWith(normalizedRoot)) {
+	while (pathModule.resolve(current) !== normalizedRoot) {
+		const relative = pathModule.relative(normalizedRoot, current);
+		if (relative === ".." || relative.startsWith(`..${pathModule.sep}`) || pathModule.isAbsolute(relative)) break;
 		if (!fsSync.existsSync(current)) break;
 		if ((await fileOperations.readdir(current)).length > 0) break;
 		await fileOperations.rmdir(current);
-		if (pathModule.resolve(current) === normalizedRoot) break;
 		current = pathModule.dirname(current);
 	}
 }
@@ -418,7 +445,7 @@ function hashHtml(html) {
 	return (hash >>> 0).toString(16).padStart(8, "0");
 }
 function getIncrementalManifestPath(outputDir) {
-	return pathModule.join(outputDir, MANIFEST_DIR, MANIFEST_FILE);
+	return resolveSsgOutputPath(outputDir, pathModule.join(MANIFEST_DIR, MANIFEST_FILE));
 }
 function readIncrementalManifest(outputDir, seed) {
 	const manifestPath = getIncrementalManifestPath(outputDir);
@@ -427,7 +454,7 @@ function readIncrementalManifest(outputDir, seed) {
 		const raw = fsSync.readFileSync(manifestPath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed.schemaVersion !== 1 || parsed.seed !== seed || !Array.isArray(parsed.routes)) return null;
-		const routes = parsed.routes.filter((entry) => !!entry && typeof entry.routeId === "string" && typeof entry.path === "string" && typeof entry.filePath === "string" && Array.isArray(entry.invalidationKeys) && (entry.htmlHash === null || typeof entry.htmlHash === "string") && (entry.lastStatus === "success" || entry.lastStatus === "error"));
+		const routes = parsed.routes.filter((entry) => !!entry && typeof entry.routeId === "string" && typeof entry.path === "string" && typeof entry.filePath === "string" && isContainedManifestFilePath(outputDir, entry.filePath) && Array.isArray(entry.invalidationKeys) && (entry.htmlHash === null || typeof entry.htmlHash === "string") && (entry.lastStatus === "success" || entry.lastStatus === "error"));
 		if (routes.length !== parsed.routes.length) return null;
 		return {
 			schemaVersion: 1,
@@ -439,13 +466,22 @@ function readIncrementalManifest(outputDir, seed) {
 		return null;
 	}
 }
+function isContainedManifestFilePath(outputDir, filePath) {
+	try {
+		resolveSsgOutputPath(outputDir, filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
 async function writeIncrementalManifest(manifest, outputDir) {
+	if (!manifest.routes.every((entry) => isContainedManifestFilePath(outputDir, entry.filePath))) throw new Error("SSG manifest contains a path outside outputDir.");
 	const manifestPath = getIncrementalManifestPath(outputDir);
 	await fs.mkdir(pathModule.dirname(manifestPath), { recursive: true });
 	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
 }
 function getExistingOutputFileSize(outputDir, filePath) {
-	const fullPath = pathModule.join(outputDir, filePath);
+	const fullPath = resolveSsgOutputPath(outputDir, filePath);
 	if (!fsSync.existsSync(fullPath)) return 0;
 	try {
 		return fsSync.statSync(fullPath).size;
@@ -454,7 +490,7 @@ function getExistingOutputFileSize(outputDir, filePath) {
 	}
 }
 function outputFileExists(outputDir, filePath) {
-	return fsSync.existsSync(pathModule.join(outputDir, filePath));
+	return fsSync.existsSync(resolveSsgOutputPath(outputDir, filePath));
 }
 //#endregion
 //#region src/ssg/generation-plan.ts

package/dist/ssr/index.d.ts

@@ -1,7 +1,7 @@
 import { c as RenderableChild, d as DocumentRenderContext, f as DocumentRenderer, p as SSRData, u as DocumentRenderArgs } from "../control-DO-iBEtV.js";
 import { r as JSXElement, s as Props } from "../jsx-Dvr2SGRG.js";
 import { D as QueryPrefetchContext, n as ServerQueryRegistry, u as CoreTelemetry, v as DataRuntime } from "../index-Bki2rqcr.js";
-import { A as RouteRecord, L as RouteRequestResult, N as RouteRegistry, a as AccessRedirectDecision, f as Route, p as RouteAuthOptions, r as AccessDenyDecision, y as RouteHandler } from "../router-C0XQA62W.js";
+import { A as RouteRecord, L as RouteRequestResult, N as RouteRegistry, a as AccessRedirectDecision, f as Route, p as RouteAuthOptions, r as AccessDenyDecision, y as RouteHandler } from "../router-C3vENhUh.js";
 import { AuthContext } from "@askrjs/auth";
 //#region src/common/page-render-envelope.d.ts
 declare const PAGE_RENDER_ENVELOPE_VERSION: 1;
@@ -19,6 +19,19 @@ interface DeferredBoundaryRegistration {
   fulfilled(value: unknown): RenderableChild;
   rejected(error: unknown): RenderableChild;
 }
+interface SSRPortalHostRegistration {
+  token: string;
+  automatic: boolean;
+}
+interface SSRPortalSlot {
+  hasValue: boolean;
+  value: RenderableChild | undefined;
+  hosts: SSRPortalHostRegistration[];
+}
+interface SSRPortalState {
+  slots: Map<object, SSRPortalSlot>;
+  nextHostId: number;
+}
 //#endregion
 //#region src/common/ssr-errors.d.ts
 /**
@@ -49,6 +62,7 @@ interface RenderContext {
   renderData: PageRenderEnvelope | null;
   hydrationData: PageRenderEnvelope | null;
   deferredBoundaries: DeferredBoundaryRegistration[];
+  ssrPortals: SSRPortalState;
   cspNonce?: string;
 }
 declare function createRenderContext(seed?: number, opts?: {