@askrjs/askr 0.0.99 → 0.2.0

package/README.md

@@ -91,8 +91,9 @@ Query and mutation helpers live in `@askrjs/askr/data`.
 ### Developer error boundaries
 
 `ErrorBoundary` is the opt-in boundary primitive for render-time failures. It
-renders a visible fallback in development, still logs the underlying error, and
-can reset when your app state changes. The boundary protects both initial mount
+renders a visible fallback in every environment (with error details expanded
+by default in development), still logs the underlying error, and can reset via
+a `resetKey` tied to your app state. The boundary protects both initial mount
 and scheduled post-mount updates. Portal content follows its logical writer
 boundary and can also recover through a boundary around its host.
 

package/dist/benchmark.js

@@ -1,10 +1,10 @@
 import { r as flushRuntimeScheduler } from "./access-d_DCdwqn.js";
 import { t as state } from "./state-DmkGM_LN.js";
 import { t as selector } from "./selector-CyK-sDwB.js";
-import { t as installRendererBridge } from "./renderer-tXX_xj86.js";
+import { t as installRendererBridge } from "./renderer-Cg92QKOm.js";
 import { i as For } from "./control-C0klPV7Q.js";
 import { jsx, jsxs } from "./jsx-runtime.js";
-import { t as createIsland } from "./boot-DE-JutXH.js";
+import { t as createIsland } from "./boot-BjldNXqF.js";
 //#region src/bench/components/benchmark-row.tsx
 function BenchmarkRow({ item, isSelected, onSelect, onRemove }) {
 	return /* @__PURE__ */ jsxs("tr", {
@@ -63,8 +63,8 @@ function BenchmarkTable({ rows, isSelected, onSelect, onRemove }) {
 installRendererBridge();
 const benchmarkMetadata = {
 	packageName: "@askrjs/askr",
-	packageVersion: "0.0.99",
-	buildLabel: "0.0.99-local"
+	packageVersion: "0.2.0",
+	buildLabel: "0.2.0-local"
 };
 function getBenchmarkMetadata() {
 	return { ...benchmarkMetadata };

package/dist/boot/index.js

@@ -1,2 +1,2 @@
-import { a as cleanupApp, i as hydrateSPA, n as createIslands, o as hasApp, r as createSPA, t as createIsland } from "../boot-DE-JutXH.js";
+import { a as cleanupApp, i as hydrateSPA, n as createIslands, o as hasApp, r as createSPA, t as createIsland } from "../boot-BjldNXqF.js";
 export { cleanupApp, createIsland, createIslands, createSPA, hasApp, hydrateSPA };

package/dist/{boot-DE-JutXH.js → boot-BjldNXqF.js}

@@ -6,7 +6,7 @@ import { p as isPromiseLike } from "./lifecycle-batch-BH0fax4F.js";
 import { _ as teardownNodeSubtree, d as removeAllListeners } from "./cleanup-D7uN-Z1s.js";
 import { r as assertExecutionModel, t as _applyManifest } from "./manifest-D6rfj_jC.js";
 import { d as stopHydrationRenderPhase, l as startHydrationRenderPhase, y as pageRenderEnvelope } from "./render-context-B7ohlh6t.js";
-import { a as setStaticChildSlotsCacheEnabled, c as endHydrationDirectListenerMode, d as discardHydrationListenerTransaction, i as registerDeferredHydrationBoundary, l as beginHydrationListenerTransaction, n as activateHydrationBoundary$1, o as withIntrinsicHydrationAdoption, r as clearDeferredHydrationBoundaries, s as beginHydrationDirectListenerMode, t as installRendererBridge, u as commitHydrationListenerTransaction } from "./renderer-tXX_xj86.js";
+import { a as setStaticChildSlotsCacheEnabled, c as endHydrationDirectListenerMode, d as discardHydrationListenerTransaction, i as registerDeferredHydrationBoundary, l as beginHydrationListenerTransaction, n as activateHydrationBoundary$1, o as withIntrinsicHydrationAdoption, r as clearDeferredHydrationBoundaries, s as beginHydrationDirectListenerMode, t as installRendererBridge, u as commitHydrationListenerTransaction } from "./renderer-Cg92QKOm.js";
 import { r as validateCspNonce, t as CspNonceScope } from "./csp-nonce-BVybpV1v.js";
 import { i as getDefaultDataRuntime } from "./data-runtime-7t_Y0iv3.js";
 import { a as hydrateDataRuntime } from "./query-registry-Bua3cDyb.js";
@@ -108,7 +108,7 @@ function shouldVerifyHydrationMarkup(config) {
 	if (typeof explicit === "boolean") return explicit;
 	return !isProductionEnvironment();
 }
-async function applySelectiveHydration(rootElement, resolved, path, cleanupStrict, hydrateOptions, source, hooks) {
+async function applySelectiveHydration(rootElement, resolved, path, cleanupStrict, hydrateOptions, source, hooks, interactionReplay) {
 	const hasPermanentSkips = (hydrateOptions.skipSelectors?.length ?? 0) > 0;
 	const hasBelowFoldDeferral = !!hydrateOptions.deferBelowFold;
 	const hasSelectiveBoundaries = hasPermanentSkips || hasBelowFoldDeferral;
@@ -126,6 +126,7 @@ async function applySelectiveHydration(rootElement, resolved, path, cleanupStric
 		staticChildSlotsCacheSuspended = true;
 		const foldY = hydrateOptions.foldThreshold ?? window.innerHeight;
 		deferredBoundaries = collectDeferredBelowFoldBoundaries(rootElement, foldY);
+		interactionReplay.registerDeferredBoundaries(deferredBoundaries);
 		let selectiveHydrationResourcesReleased = false;
 		let unregisterRootCleanupCallback = () => {};
 		function handleScroll() {
@@ -139,7 +140,9 @@ async function applySelectiveHydration(rootElement, resolved, path, cleanupStric
 			unregisterRootCleanupCallback();
 			window.removeEventListener("scroll", handleScroll);
 			restoreStaticChildSlotsCache();
+			interactionReplay.clearDeferredBoundaries();
 		};
+		interactionReplay.setOnDeferredBoundariesDrained(releaseSelectiveHydrationResources);
 		unregisterRootCleanupCallback = hooks.registerRootCleanupCallback(rootElement, releaseSelectiveHydrationResources);
 		window.addEventListener("scroll", handleScroll, { passive: true });
 	}
@@ -440,6 +443,175 @@ async function resolveInitialRoute(auth, source) {
 	throw new Error(`[Askr] Route redirect limit exceeded (${MAX_INITIAL_ROUTE_REDIRECTS}).`);
 }
 //#endregion
+//#region src/boot/hydration-interaction-replay.ts
+const HYDRATION_INTERACTION_TYPES = [
+	"click",
+	"dblclick",
+	"pointerdown",
+	"pointerup",
+	"keydown",
+	"keyup",
+	"input",
+	"change",
+	"submit"
+];
+function cloneInteractionEvent(event) {
+	const EventConstructor = event.constructor;
+	const eventWithDetails = event;
+	const init = {
+		bubbles: event.bubbles,
+		cancelable: event.cancelable,
+		composed: event.composed,
+		detail: eventWithDetails.detail,
+		view: eventWithDetails.view,
+		key: eventWithDetails.key,
+		code: eventWithDetails.code,
+		location: eventWithDetails.location,
+		repeat: eventWithDetails.repeat,
+		isComposing: eventWithDetails.isComposing,
+		ctrlKey: eventWithDetails.ctrlKey,
+		shiftKey: eventWithDetails.shiftKey,
+		altKey: eventWithDetails.altKey,
+		metaKey: eventWithDetails.metaKey,
+		button: eventWithDetails.button,
+		buttons: eventWithDetails.buttons,
+		clientX: eventWithDetails.clientX,
+		clientY: eventWithDetails.clientY,
+		screenX: eventWithDetails.screenX,
+		screenY: eventWithDetails.screenY,
+		pointerId: eventWithDetails.pointerId,
+		pointerType: eventWithDetails.pointerType,
+		isPrimary: eventWithDetails.isPrimary,
+		data: eventWithDetails.data,
+		inputType: eventWithDetails.inputType
+	};
+	try {
+		return new EventConstructor(event.type, init);
+	} catch {
+		return new Event(event.type, {
+			bubbles: event.bubbles,
+			cancelable: event.cancelable,
+			composed: event.composed
+		});
+	}
+}
+/**
+* Capture discrete interactions before hydrated handlers exist, then replay
+* them after the listener transaction commits. Deferred boundaries remain
+* interaction-activatable until they are revealed or the root is cleaned up.
+*/
+function beginHydrationInteractionReplay(root, activateBoundary, permanentSkipSelectors = []) {
+	const queued = [];
+	const deferredBoundaries = /* @__PURE__ */ new Set();
+	let active = true;
+	let hydratingRoot = true;
+	let replaying = false;
+	let hadDeferredBoundaries = false;
+	let onDeferredBoundariesDrained;
+	function isPermanentlySkipped(target) {
+		const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
+		if (!element) return false;
+		return permanentSkipSelectors.some((selector) => {
+			try {
+				return element.closest(selector) !== null;
+			} catch {
+				return false;
+			}
+		});
+	}
+	function findDeferredBoundary(target) {
+		if (!(target instanceof Node)) return;
+		for (const boundary of deferredBoundaries) if (boundary.hasAttribute("data-skip-hydrate") && boundary.contains(target)) return boundary;
+	}
+	function removeCaptureListeners() {
+		if (!active) return;
+		active = false;
+		for (const type of HYDRATION_INTERACTION_TYPES) root.removeEventListener(type, captureInteraction, true);
+	}
+	function releaseIfFinished() {
+		if (!hydratingRoot && deferredBoundaries.size === 0) removeCaptureListeners();
+	}
+	function notifyIfDeferredBoundariesDrained() {
+		if (hadDeferredBoundaries && deferredBoundaries.size === 0) onDeferredBoundariesDrained?.();
+	}
+	function replayInteraction(interaction) {
+		if (!(interaction.target instanceof Node) || !root.contains(interaction.target)) return;
+		const boundary = findDeferredBoundary(interaction.target);
+		if (boundary) {
+			try {
+				if (!activateBoundary(boundary)) return;
+			} catch {
+				return;
+			}
+			deferredBoundaries.delete(boundary);
+			notifyIfDeferredBoundariesDrained();
+		}
+		replaying = true;
+		try {
+			interaction.target.dispatchEvent(interaction.event);
+		} finally {
+			replaying = false;
+		}
+		releaseIfFinished();
+	}
+	function captureInteraction(event) {
+		if (!active || replaying) return;
+		const target = event.target;
+		if (!target || isPermanentlySkipped(target)) return;
+		const boundary = findDeferredBoundary(target);
+		if (!hydratingRoot && !boundary) return;
+		event.preventDefault();
+		event.stopImmediatePropagation();
+		const interaction = {
+			target,
+			event: cloneInteractionEvent(event)
+		};
+		if (hydratingRoot) {
+			queued.push(interaction);
+			return;
+		}
+		replayInteraction(interaction);
+	}
+	const installedTypes = [];
+	try {
+		for (const type of HYDRATION_INTERACTION_TYPES) {
+			root.addEventListener(type, captureInteraction, true);
+			installedTypes.push(type);
+		}
+	} catch (error) {
+		active = false;
+		for (const type of installedTypes) root.removeEventListener(type, captureInteraction, true);
+		throw error;
+	}
+	return {
+		registerDeferredBoundaries(boundaries) {
+			for (const boundary of boundaries) deferredBoundaries.add(boundary);
+			hadDeferredBoundaries ||= boundaries.length > 0;
+		},
+		setOnDeferredBoundariesDrained(callback) {
+			onDeferredBoundariesDrained = callback;
+		},
+		clearDeferredBoundaries() {
+			deferredBoundaries.clear();
+			releaseIfFinished();
+		},
+		complete() {
+			if (!active || !hydratingRoot) return;
+			hydratingRoot = false;
+			const pending = queued.splice(0);
+			for (const interaction of pending) replayInteraction(interaction);
+			releaseIfFinished();
+		},
+		abort() {
+			queued.length = 0;
+			deferredBoundaries.clear();
+			onDeferredBoundariesDrained = void 0;
+			hydratingRoot = false;
+			removeCaptureListeners();
+		}
+	};
+}
+//#endregion
 //#region src/boot/index.ts
 /**
 * App bootstrap and mount
@@ -570,97 +742,105 @@ async function hydrateSPA(config) {
 	if (manifest.records.length === 0) throw new Error("hydrateSPA requires a route registry with at least one route. If you are enhancing existing HTML, use createIsland instead.");
 	const rootElement = resolveRootElement(config.root);
 	if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
-	applyDeferredStreamPatches(rootElement);
-	const hydrationRenderData = takeHydrationRenderData(rootElement);
-	const hydrationQueryCache = hydrationRenderData?.resources;
-	if (hydrationQueryCache) hydrateDataRuntime(config.dataRuntime ?? getDefaultDataRuntime(), hydrationQueryCache);
-	const hydrationRenderDataForApp = hydrationRenderData;
-	configureScrollRestoration(config.scrollRestoration);
-	clearRouteState();
-	_applyManifest(manifest);
-	const routeAuth = config.auth ?? manifest.auth;
-	const appRouteSource = {
-		registry: config.registry,
-		auth: routeAuth,
-		runtime: createAppRenderRuntime({
-			framework: hydrationRenderData?.framework,
-			route: hydrationRenderData?.route,
-			hasRoute: hydrationRenderData !== null,
-			routeRegistry: config.registry,
-			routeAuth
-		})
-	};
-	_setActiveRouteAuthOptions(routeAuth);
-	const { path, href: currentUrl, resolved } = await resolveInitialRoute(routeAuth, {
-		registry: config.registry,
-		load: false
-	});
-	setServerLocation(currentUrl);
-	if (isProductionEnvironment()) lockRouteRegistration();
-	if (!resolved) throw new Error(`hydrateSPA: no route found for current path (${path}).`);
-	if (resolved.kind === "redirect") throw new Error(`hydrateSPA: unresolved redirect for current path (${path}).`);
-	await reconcileInitialRouteMetadata(resolved);
-	const hydrationResolved = resolved.kind === "deny" ? {
-		handler: bindDeniedRouteHandler(resolved.status),
-		params: {}
-	} : {
-		handler: resolved.handler,
-		params: resolved.params
-	};
-	const mountHydratedRoot = (...args) => withIntrinsicHydrationAdoption(() => mountOrUpdate(args[0], args[1], {
-		...args[2],
-		cspNonce: config.cspNonce
-	}));
-	if (shouldVerifyHydrationMarkup(config)) {
-		const { verifyHydrationSyncForUrl } = await import("./verify-hydration-Bo5_tpen.js");
-		if (!verifyHydrationSyncForUrl({
-			root: rootElement,
-			url: currentUrl,
+	const interactionReplay = beginHydrationInteractionReplay(rootElement, (boundary) => activateHydrationBoundary(rootElement, boundary), config.hydrate?.skipSelectors);
+	try {
+		applyDeferredStreamPatches(rootElement);
+		const hydrationRenderData = takeHydrationRenderData(rootElement);
+		const hydrationQueryCache = hydrationRenderData?.resources;
+		if (hydrationQueryCache) hydrateDataRuntime(config.dataRuntime ?? getDefaultDataRuntime(), hydrationQueryCache);
+		const hydrationRenderDataForApp = hydrationRenderData;
+		configureScrollRestoration(config.scrollRestoration);
+		clearRouteState();
+		_applyManifest(manifest);
+		const routeAuth = config.auth ?? manifest.auth;
+		const appRouteSource = {
 			registry: config.registry,
-			resolved: hydrationResolved,
-			options: {
-				data: hydrationRenderDataForApp?.resources,
-				dataRuntime: config.dataRuntime ?? getDefaultDataRuntime(),
-				envelope: hydrationRenderDataForApp ?? void 0,
-				cspNonce: config.cspNonce
-			}
-		})) throw new Error("[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output.");
-	}
-	const hydrateOptions = config.hydrate;
-	if (hydrateOptions) {
-		if (hydrateOptions.deferUntilIdle || hydrateOptions.deferBelowFold) {
-			if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
-			try {
-				await applySelectiveHydration(rootElement, hydrationResolved, path, config.cleanupStrict, hydrateOptions, appRouteSource, {
-					mountOrUpdate: mountHydratedRoot,
-					registerAppNavigation,
-					registerRootCleanupCallback,
-					activateHydrationBoundary
-				});
-			} finally {
-				if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+			auth: routeAuth,
+			runtime: createAppRenderRuntime({
+				framework: hydrationRenderData?.framework,
+				route: hydrationRenderData?.route,
+				hasRoute: hydrationRenderData !== null,
+				routeRegistry: config.registry,
+				routeAuth
+			})
+		};
+		_setActiveRouteAuthOptions(routeAuth);
+		const { path, href: currentUrl, resolved } = await resolveInitialRoute(routeAuth, {
+			registry: config.registry,
+			load: false
+		});
+		setServerLocation(currentUrl);
+		if (isProductionEnvironment()) lockRouteRegistration();
+		if (!resolved) throw new Error(`hydrateSPA: no route found for current path (${path}).`);
+		if (resolved.kind === "redirect") throw new Error(`hydrateSPA: unresolved redirect for current path (${path}).`);
+		await reconcileInitialRouteMetadata(resolved);
+		const hydrationResolved = resolved.kind === "deny" ? {
+			handler: bindDeniedRouteHandler(resolved.status),
+			params: {}
+		} : {
+			handler: resolved.handler,
+			params: resolved.params
+		};
+		const mountHydratedRoot = (...args) => withIntrinsicHydrationAdoption(() => mountOrUpdate(args[0], args[1], {
+			...args[2],
+			cspNonce: config.cspNonce
+		}));
+		if (shouldVerifyHydrationMarkup(config)) {
+			const { verifyHydrationSyncForUrl } = await import("./verify-hydration-Bo5_tpen.js");
+			if (!verifyHydrationSyncForUrl({
+				root: rootElement,
+				url: currentUrl,
+				registry: config.registry,
+				resolved: hydrationResolved,
+				options: {
+					data: hydrationRenderDataForApp?.resources,
+					dataRuntime: config.dataRuntime ?? getDefaultDataRuntime(),
+					envelope: hydrationRenderDataForApp ?? void 0,
+					cspNonce: config.cspNonce
+				}
+			})) throw new Error("[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output.");
+		}
+		const hydrateOptions = config.hydrate;
+		if (hydrateOptions) {
+			if (hydrateOptions.deferUntilIdle || hydrateOptions.deferBelowFold) {
+				if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+				try {
+					await applySelectiveHydration(rootElement, hydrationResolved, path, config.cleanupStrict, hydrateOptions, appRouteSource, {
+						mountOrUpdate: mountHydratedRoot,
+						registerAppNavigation,
+						registerRootCleanupCallback,
+						activateHydrationBoundary
+					}, interactionReplay);
+				} finally {
+					if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+				}
+				interactionReplay.complete();
+				return;
 			}
-			return;
+			if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
 		}
-		if (hydrateOptions.skipSelectors?.length) markSkippedElements(rootElement, hydrateOptions.skipSelectors);
-	}
-	if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
-	const listenerTransaction = beginHydrationListenerTransaction();
-	beginHydrationDirectListenerMode();
-	try {
-		mountHydratedRoot(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler(hydrationResolved), {
-			cleanupStrict: config.cleanupStrict,
-			appRuntime: appRouteSource.runtime
-		});
-		commitHydrationListenerTransaction(listenerTransaction);
+		if (hydrationRenderDataForApp) startHydrationRenderPhase(hydrationRenderDataForApp);
+		const listenerTransaction = beginHydrationListenerTransaction();
+		beginHydrationDirectListenerMode();
+		try {
+			mountHydratedRoot(rootElement, resolved.kind === "deny" ? bindDeniedStatus(resolved.status) : bindResolvedRouteHandler(hydrationResolved), {
+				cleanupStrict: config.cleanupStrict,
+				appRuntime: appRouteSource.runtime
+			});
+			commitHydrationListenerTransaction(listenerTransaction);
+			interactionReplay.complete();
+		} catch (error) {
+			discardHydrationListenerTransaction(listenerTransaction);
+			throw error;
+		} finally {
+			endHydrationDirectListenerMode();
+			if (hydrationRenderDataForApp) stopHydrationRenderPhase();
+		}
+		await registerAppNavigation(rootElement, path, { ...appRouteSource });
 	} catch (error) {
-		discardHydrationListenerTransaction(listenerTransaction);
+		interactionReplay.abort();
 		throw error;
-	} finally {
-		endHydrationDirectListenerMode();
-		if (hydrationRenderDataForApp) stopHydrationRenderPhase();
 	}
-	await registerAppNavigation(rootElement, path, { ...appRouteSource });
 }
 //#endregion
 export { cleanupApp as a, hydrateSPA as i, createIslands as n, hasApp as o, createSPA as r, createIsland as t };

package/dist/foundations/interactions/index.d.ts

@@ -73,6 +73,7 @@ declare function pressable({ disabled, onPress, isNativeButton }: PressableOptio
  * - Returns standard event handler props (onKeyDown, onPointerDownCapture)
  * - Composable via mergeProps with other foundations
  * - Caller provides the protected node reference for outside detection
+ * - Portaled descendants are registered explicitly as additional inside nodes
  * - Returned capture props must be attached to a surface that can observe both
  *   the protected subtree and the outside interaction path (for example, an
  *   overlay or wrapper around the protected node)
@@ -87,6 +88,7 @@ declare function pressable({ disabled, onPress, isNativeButton }: PressableOptio
  * USAGE:
  *   const props = dismissable({
  *     node: elementRef,
+ *     additionalInsideNodes: [dropdownPortalRef],
  *     disabled: false,
  *     onDismiss: () => close()
  *   });
@@ -107,6 +109,11 @@ interface DismissableOptions {
    * returned capture props to a surface that encloses this node.
    */
   node?: Node | null;
+  /**
+   * Additional roots that are logically inside the protected surface even
+   * when a portal places them outside `node` in the DOM tree.
+   */
+  additionalInsideNodes?: readonly (Node | null | undefined)[];
   /**
    * Whether dismiss is disabled
    */
@@ -117,7 +124,7 @@ interface DismissableOptions {
   onDismiss?: (trigger: 'escape' | 'outside') => void;
 }
 /** Produce keydown/outside-click props that invoke `onDismiss` on Escape or an outside click. */
-declare function dismissable({ node, disabled, onDismiss }: DismissableOptions): {
+declare function dismissable({ node, additionalInsideNodes, disabled, onDismiss }: DismissableOptions): {
   onKeyDown: (e: KeyboardLikeEvent) => void;
   onPointerDownCapture: (e: PointerLikeEvent) => void;
 };

package/dist/foundations/interactions/index.js

@@ -1,2 +1,2 @@
-import { a as focusable, i as hoverable, n as mergeInteractionProps, o as dismissable, r as rovingFocus, s as pressable, t as applyInteractionPolicy } from "../../interactions-B4XaFxt1.js";
+import { a as focusable, i as hoverable, n as mergeInteractionProps, o as dismissable, r as rovingFocus, s as pressable, t as applyInteractionPolicy } from "../../interactions-B-7vkBgx.js";
 export { applyInteractionPolicy, dismissable, focusable, hoverable, mergeInteractionProps, pressable, rovingFocus };

package/dist/fx/index.js

@@ -24,20 +24,20 @@ function debounce(fn, ms, options) {
 	const { leading = false, trailing = true } = options || {};
 	let lastArgs = null;
 	let lastThis = null;
-	let lastCallTime = 0;
+	let trailingPending = false;
 	const debounced = function(...args) {
-		const callTime = Date.now();
+		const windowActive = timeoutId !== null;
 		lastArgs = args;
 		lastThis = this;
 		if (timeoutId !== null) clearTimeout(timeoutId);
-		if (leading && callTime - lastCallTime >= ms) {
+		if (leading && !windowActive) {
 			callable.apply(this, args);
-			lastCallTime = callTime;
-		}
-		if (trailing) timeoutId = setTimeout(() => {
-			callable.apply(lastThis, lastArgs);
+			trailingPending = false;
+		} else if (trailing) trailingPending = true;
+		timeoutId = setTimeout(() => {
+			if (trailingPending) callable.apply(lastThis, lastArgs);
 			timeoutId = null;
-			lastCallTime = Date.now();
+			trailingPending = false;
 		}, ms);
 	};
 	debounced.cancel = () => {
@@ -45,6 +45,7 @@ function debounce(fn, ms, options) {
 			clearTimeout(timeoutId);
 			timeoutId = null;
 		}
+		trailingPending = false;
 	};
 	return debounced;
 }
@@ -121,13 +122,13 @@ function once(fn) {
 	const callable = fn;
 	let called = false;
 	let result;
-	return ((...args) => {
+	return function(...args) {
 		if (!called) {
 			called = true;
-			result = callable(...args);
+			result = callable.apply(this, args);
 		}
 		return result;
-	});
+	};
 }
 /**
 * Defer — schedule on microtask queue

package/dist/index.js

@@ -7,7 +7,7 @@ import { n as isSnapshotSource } from "./snapshot-source-BB42xgwb.js";
 import { c as registerSSRStyle } from "./render-context-B7ohlh6t.js";
 import { t as state } from "./state-DmkGM_LN.js";
 import { t as selector } from "./selector-CyK-sDwB.js";
-import { t as installRendererBridge } from "./renderer-tXX_xj86.js";
+import { t as installRendererBridge } from "./renderer-Cg92QKOm.js";
 import { n as cspNonce, t as CspNonceScope } from "./csp-nonce-BVybpV1v.js";
 import { i as For, n as Match, r as Show, t as Case } from "./control-C0klPV7Q.js";
 import { jsx, jsxs } from "./jsx-runtime.js";

package/dist/{interactions-B4XaFxt1.js → interactions-B-7vkBgx.js}

@@ -49,7 +49,7 @@ function pressable({ disabled, onPress, isNativeButton = false }) {
 //#endregion
 //#region src/foundations/interactions/dismissable.ts
 /** Produce keydown/outside-click props that invoke `onDismiss` on Escape or an outside click. */
-function dismissable({ node, disabled, onDismiss }) {
+function dismissable({ node, additionalInsideNodes, disabled, onDismiss }) {
 	function handleKeyDown(e) {
 		if (disabled) return;
 		if (e.key === "Escape") {
@@ -63,7 +63,8 @@ function dismissable({ node, disabled, onDismiss }) {
 		const target = e.target;
 		if (!(target instanceof Node)) return;
 		if (!node) return;
-		if (!node.contains(target)) onDismiss?.("outside");
+		const insideAdditionalNode = additionalInsideNodes?.some((insideNode) => insideNode?.contains(target));
+		if (!node.contains(target) && !insideAdditionalNode) onDismiss?.("outside");
 	}
 	return {
 		onKeyDown: handleKeyDown,

package/dist/{renderer-tXX_xj86.js → renderer-Cg92QKOm.js}

@@ -5918,6 +5918,9 @@ function materializeComponentResultNode(childInstance, result, parentNamespace)
 	} finally {
 		restoreDomCommitScope(previousInstance);
 	}
+	return materializeResolvedComponentResultNode(childInstance, result, dom);
+}
+function materializeResolvedComponentResultNode(childInstance, result, dom) {
 	if (dom instanceof Element) {
 		mountInstanceInline(childInstance, dom);
 		return dom;
@@ -5961,6 +5964,20 @@ function materializeComponentResultNode(childInstance, result, parentNamespace)
 	return materialized.fragment ?? host;
 }
 //#endregion
+//#region src/renderer/component-chain-depth.ts
+const MAX_COMPONENT_CHAIN_DEPTH = 1e5;
+const COMPONENT_CHAIN_ERROR_CONTEXT = 8;
+function assertComponentChainDepth(depth, instance) {
+	if (depth < MAX_COMPONENT_CHAIN_DEPTH) return;
+	const names = [];
+	let current = instance;
+	while (current && names.length < COMPONENT_CHAIN_ERROR_CONTEXT) {
+		names.push(current.fn.name || "<anonymous>");
+		current = current.parentInstance;
+	}
+	throw new Error(`[Askr] Component chain exceeded ${MAX_COMPONENT_CHAIN_DEPTH.toLocaleString("en-US")} wrappers. This usually means component output recurses without terminating. Recent chain: ${names.reverse().join(" -> ")}`);
+}
+//#endregion
 //#region src/renderer/component-host-nested-results.ts
 function getNestedComponentVNode(result) {
 	if (_isDOMElement(result) && typeof result.type === "function") return result;
@@ -5972,8 +5989,10 @@ function getNestedComponentVNode(result) {
 function resolveNestedComponentResult(result, snapshot, parentInstance) {
 	let currentResult = result;
 	let activeSnapshot = snapshot;
+	let diagnosticParent = parentInstance;
 	let depth = 0;
-	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function") {
+		assertComponentChainDepth(depth, diagnosticParent);
 		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
 		const nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, currentResult.props ?? {}, null);
 		nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
@@ -5990,6 +6009,7 @@ function resolveNestedComponentResult(result, snapshot, parentInstance) {
 			throw error;
 		}
 		cleanupComponent(nestedInstance);
+		diagnosticParent = nestedInstance;
 		activeSnapshot = nestedSnapshot ?? null;
 		currentResult = nextResult;
 		depth += 1;
@@ -6005,7 +6025,8 @@ function resolveHostNestedComponentResult(host, retainedInstance, result, snapsh
 	const createdVNodeOwners = [];
 	try {
 		let nestedVNode = getNestedComponentVNode(currentResult);
-		while (nestedVNode && depth < 16) {
+		while (nestedVNode) {
+			assertComponentChainDepth(depth, activeParent);
 			const nestedSnapshot = getVNodeContextFrame(nestedVNode) ?? activeSnapshot;
 			let nestedInstance = findHostInstanceByType(host, nestedVNode.type, nestedVNode, activeParent, depth);
 			const hadNestedInstance = !!nestedInstance;
@@ -6063,7 +6084,8 @@ function resolveWrapperHostResult(host, retainedInstance, result, snapshot, reta
 	let activeParent = retainedInstance;
 	let depth = 0;
 	let nestedVNode = getNestedComponentVNode(currentResult);
-	while (nestedVNode && depth < 16) {
+	while (nestedVNode) {
+		assertComponentChainDepth(depth, activeParent);
 		const nestedSnapshot = getVNodeContextFrame(nestedVNode) ?? activeSnapshot;
 		const nestedInstance = findHostInstanceByType(host, nestedVNode.type, nestedVNode, activeParent, depth);
 		if (!nestedInstance) break;
@@ -6090,6 +6112,81 @@ function resolveWrapperHostResult(host, retainedInstance, result, snapshot, reta
 	};
 }
 //#endregion
+//#region src/renderer/component-host-fresh-chain.ts
+function getFreshNestedComponentVNode(result) {
+	if (_isDOMElement(result) && typeof result.type === "function") return result;
+	if (!Array.isArray(result) && !isFragmentVNode(result)) return null;
+	const children = normalizeComponentChildren(result);
+	const child = children.length === 1 ? children[0] : void 0;
+	return _isDOMElement(child) && typeof child.type === "function" ? child : null;
+}
+function prepareFreshNestedComponentResultDom(result, dom) {
+	if (!Array.isArray(result) && !isFragmentVNode(result)) return dom;
+	const fragment = document.createDocumentFragment();
+	fragment.appendChild(dom);
+	return fragment;
+}
+function rollbackFreshNestedComponentResolution(resolution) {
+	for (let index = resolution.vnodeOwners.length - 1; index >= 0; index -= 1) {
+		const owner = resolution.vnodeOwners[index];
+		restoreVNodeComponentInstance(owner.node, owner.previous);
+	}
+	cleanupProvisionalComponentInstances(resolution.createdInstances);
+}
+function resolveFreshNestedComponentResult(result, snapshot, parentInstance) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let activeParent = parentInstance;
+	let depth = 0;
+	const resolution = {
+		entries: [],
+		createdInstances: [],
+		vnodeOwners: []
+	};
+	try {
+		let nestedVNode = getFreshNestedComponentVNode(currentResult);
+		while (nestedVNode) {
+			assertComponentChainDepth(depth, activeParent);
+			const nestedSnapshot = getVNodeContextFrame(nestedVNode) ?? activeSnapshot;
+			const componentFn = nestedVNode.type;
+			const previous = getVNodeComponentInstance(nestedVNode);
+			let nestedInstance = previous && hasComponentOwnershipIdentity(previous, componentFn, nestedVNode, activeParent, 0) ? previous : void 0;
+			if (!nestedInstance) {
+				nestedInstance = createComponentInstance(nextComponentInstanceId(), componentFn, nestedVNode.props ?? {}, null);
+				resolution.vnodeOwners.push({
+					node: nestedVNode,
+					previous
+				});
+				registerVNodeComponentInstanceRollback(nestedVNode, previous, nestedInstance);
+				setVNodeComponentInstance(nestedVNode, nestedInstance);
+				resolution.createdInstances.push(nestedInstance);
+			} else captureInlineRenderSnapshot(nestedInstance);
+			setComponentOwnershipIdentity(nestedInstance, nestedVNode, activeParent, 0);
+			nestedInstance.isRoot = isRouteRootComponentVNode(nestedVNode);
+			nestedInstance.parentInstance = activeParent;
+			nestedInstance.portalScope = activeParent.portalScope ?? nestedInstance.portalScope;
+			nestedInstance.cleanupStrict = activeParent.cleanupStrict;
+			nestedInstance.props = (nestedVNode.props ?? {}) || {};
+			if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+			const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+			if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+			activeParent = nestedInstance;
+			activeSnapshot = nestedSnapshot ?? null;
+			currentResult = markVNodeTreeWithContextFrame(nextResult, activeSnapshot);
+			resolution.entries.push({
+				instance: nestedInstance,
+				result: currentResult
+			});
+			depth += 1;
+			nestedVNode = getFreshNestedComponentVNode(currentResult);
+		}
+		return resolution;
+	} catch (error) {
+		rollbackFreshNestedComponentResolution(resolution);
+		throw error;
+	}
+}
+//#endregion
 //#region src/renderer/component-host-creation.ts
 function createComponentElement(node, type, props, parentNamespace) {
 	const snapshot = getVNodeContextFrame(node) || getCurrentContextFrame();
@@ -6099,6 +6196,7 @@ function createComponentElement(node, type, props, parentNamespace) {
 	const currentParent = getCurrentInstance();
 	let childInstance = previousVNodeInstance && hasComponentOwnershipIdentity(previousVNodeInstance, componentFn, node, currentParent, 0) ? previousVNodeInstance : void 0;
 	const hadChildInstance = !!childInstance;
+	let nestedResolution = null;
 	if (!childInstance) {
 		childInstance = createComponentInstance(nextComponentInstanceId(), componentFn, props || {}, null);
 		registerVNodeComponentInstanceRollback(node, previousVNodeInstance, childInstance);
@@ -6116,10 +6214,20 @@ function createComponentElement(node, type, props, parentNamespace) {
 		const result = snapshot ? withContext(snapshot, () => renderComponentInline(childInstance)) : renderComponentInline(childInstance);
 		if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must return synchronously.");
 		const scopedResult = markVNodeTreeWithContextFrame(result, snapshot ?? null);
-		const dom = snapshot ? withContext(snapshot, () => materializeComponentResultNode(childInstance, scopedResult, parentNamespace)) : materializeComponentResultNode(childInstance, scopedResult, parentNamespace);
+		nestedResolution = resolveFreshNestedComponentResult(scopedResult, snapshot ?? null, childInstance);
+		const deepestEntry = nestedResolution.entries[nestedResolution.entries.length - 1];
+		let dom = snapshot ? withContext(snapshot, () => materializeComponentResultNode(deepestEntry?.instance ?? childInstance, deepestEntry?.result ?? scopedResult, parentNamespace)) : materializeComponentResultNode(deepestEntry?.instance ?? childInstance, deepestEntry?.result ?? scopedResult, parentNamespace);
+		if (deepestEntry) {
+			for (let index = nestedResolution.entries.length - 2; index >= 0; index -= 1) {
+				const entry = nestedResolution.entries[index];
+				dom = materializeResolvedComponentResultNode(entry.instance, entry.result, prepareFreshNestedComponentResultDom(entry.result, dom));
+			}
+			dom = materializeResolvedComponentResultNode(childInstance, scopedResult, prepareFreshNestedComponentResultDom(scopedResult, dom));
+		}
 		if (dom instanceof Element) materializeFreshKey(dom, node, props);
 		return dom;
 	} catch (error) {
+		if (nestedResolution) rollbackFreshNestedComponentResolution(nestedResolution);
 		if (!hadChildInstance) {
 			restoreVNodeComponentInstance(node, previousVNodeInstance);
 			cleanupProvisionalComponentInstance(childInstance);

package/dist/router/index.js

@@ -7,7 +7,7 @@ import { S as RouteDataLoadError, a as resolveRouteRequest, b as lazy, f as defe
 import { n as onRouteChange, t as currentRoute } from "../activity-d4t3CdzK.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-Cix_Q9ym.js";
 import { o as mergeProps } from "../compose-ref-1Fhs7mbF.js";
-import { t as applyInteractionPolicy } from "../interactions-B4XaFxt1.js";
+import { t as applyInteractionPolicy } from "../interactions-B-7vkBgx.js";
 //#region src/router/route-query.ts
 function getRouteQueryHistoryMode(options) {
 	if (options.history) return options.history;

package/dist/testing/index.js

@@ -3,7 +3,7 @@ import { u as recordReadableRead } from "../readable-BsdGWsDE.js";
 import { l as addInvalidationListener, t as createDataRuntime } from "../data-runtime-7t_Y0iv3.js";
 import { a as notifySource, i as normalizeAsyncDataError, r as createReadableSource } from "../data-CnQwUS76.js";
 import { r as computeRouteActivityMatches } from "../route-matching-Bo6UqG-5.js";
-import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-DE-JutXH.js";
+import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-BjldNXqF.js";
 //#region src/testing/render.ts
 const renderStates = /* @__PURE__ */ new WeakMap();
 const eventConstructorNames = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/askr",
-  "version": "0.0.99",
+  "version": "0.2.0",
   "description": "Actor-backed deterministic UI framework",
   "keywords": [
     "askr",
@@ -148,8 +148,8 @@
     "prepublishOnly": "npm run check"
   },
   "dependencies": {
-    "@askrjs/auth": ">=0.0.8 <0.1.0",
-    "@askrjs/schema": ">=0.0.5 <0.1.0"
+    "@askrjs/auth": ">=0.2.0 <0.3.0",
+    "@askrjs/schema": ">=0.2.0 <0.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",