@askrjs/askr 0.0.51 → 0.0.53

package/dist/component-lifecycle-CO4hXlP4.js

@@ -0,0 +1,357 @@
+import { b as isDevelopmentEnvironment, v as logger } from "./access-Bg4RJNC8.js";
+import { a as cleanupReadableSubscriptions, c as finalizeReadableSubscriptionsFromSnapshot, i as cleanupReadableSubscriptionSources, t as isBulkCommitActive } from "./fastlane-Dw8SOBr9.js";
+import { a as clearCurrentComponentScope, y as restoreCurrentComponentScope } from "./component-scope-CC3cojX9.js";
+//#region src/runtime/component-cleanup.ts
+/**
+* Component cleanup and owned child-scope bookkeeping.
+*/
+/**
+* Dispose an inactive ownership generation without swapping it back onto the
+* component instance that now represents a different live route.
+*/
+function cleanupComponentGeneration(instance, generation) {
+	const savedScope = clearCurrentComponentScope();
+	try {
+		const cleanupErrors = instance.cleanupStrict ? [] : void 0;
+		const recordCleanupError = (message, err) => {
+			if (cleanupErrors) cleanupErrors.push(err);
+			else if (isDevelopmentEnvironment()) logger.warn(message, err);
+		};
+		const ownedChildScopes = generation.ownedChildScopes;
+		if (ownedChildScopes && ownedChildScopes.size > 0) {
+			for (const scope of ownedChildScopes) try {
+				scope.dispose();
+			} catch (err) {
+				recordCleanupError("[Askr] child scope cleanup threw:", err);
+			}
+			ownedChildScopes.clear();
+		}
+		try {
+			cleanupReadableSubscriptionSources(instance, generation.readSources, generation.ownershipGeneration);
+		} catch (err) {
+			recordCleanupError("[Askr] readable subscription cleanup threw:", err);
+		}
+		const cleanupFns = generation.cleanupFns;
+		generation.cleanupFns = void 0;
+		if (cleanupFns) for (const cleanup of cleanupFns) try {
+			cleanup();
+		} catch (err) {
+			recordCleanupError("[Askr] cleanup function threw:", err);
+		}
+		try {
+			if (generation.abortController && !generation.abortController.signal.aborted) generation.abortController.abort();
+		} catch (err) {
+			recordCleanupError("[Askr] abort controller cleanup threw:", err);
+		}
+		generation.abortController = null;
+		if (cleanupErrors && cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, `Cleanup failed for component ${instance.id}`);
+	} finally {
+		restoreCurrentComponentScope(savedScope);
+	}
+}
+/**
+* Clean up component resources on unmount or route changes.
+*/
+function cleanupComponent(instance) {
+	const savedScope = clearCurrentComponentScope();
+	try {
+		const cleanupErrors = instance.cleanupStrict ? [] : void 0;
+		const recordCleanupError = (message, err) => {
+			if (cleanupErrors) cleanupErrors.push(err);
+			else if (isDevelopmentEnvironment()) logger.warn(message, err);
+		};
+		const ownedChildScopes = instance._ownedChildScopes;
+		if (ownedChildScopes && ownedChildScopes.size > 0) {
+			instance._ownedChildScopes = /* @__PURE__ */ new Set();
+			for (const scope of ownedChildScopes) try {
+				scope.dispose();
+			} catch (err) {
+				recordCleanupError("[Askr] child scope cleanup threw:", err);
+			}
+		}
+		const cleanupFns = instance.cleanupFns;
+		instance.cleanupFns = void 0;
+		if (cleanupFns) for (const cleanup of cleanupFns) try {
+			cleanup();
+		} catch (err) {
+			recordCleanupError("[Askr] cleanup function threw:", err);
+		}
+		try {
+			cleanupReadableSubscriptions(instance);
+		} catch (err) {
+			recordCleanupError("[Askr] readable subscription cleanup threw:", err);
+		}
+		try {
+			if (instance.abortController && !instance.abortController.signal.aborted) instance.abortController.abort();
+		} catch (err) {
+			recordCleanupError("[Askr] abort controller cleanup threw:", err);
+		}
+		instance.abortController = null;
+		instance.lifecycleGeneration++;
+		instance.evaluationGeneration++;
+		instance.mountOperations = void 0;
+		instance.commitOperations = void 0;
+		instance.lifecycleSlots = void 0;
+		instance.hasPendingUpdate = false;
+		instance.notifyUpdate = null;
+		instance._placeholder = void 0;
+		instance.mounted = false;
+		if (cleanupErrors && cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, `Cleanup failed for component ${instance.id}`);
+	} finally {
+		restoreCurrentComponentScope(savedScope);
+	}
+}
+function registerOwnedChildScope(instance, scope) {
+	(instance._ownedChildScopes ??= /* @__PURE__ */ new Set()).add(scope);
+}
+function unregisterOwnedChildScope(instance, scope) {
+	instance._ownedChildScopes?.delete(scope);
+}
+//#endregion
+//#region src/common/promise.ts
+function isPromiseLike(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+//#endregion
+//#region src/runtime/lifecycle-operation-settlement.ts
+function settleLifecycleOperationResult(instance, lifecycleGeneration, result) {
+	if (isPromiseLike(result)) Promise.resolve(result).then((cleanup) => {
+		if (typeof cleanup === "function") {
+			if (instance.lifecycleGeneration === lifecycleGeneration && instance.mounted) {
+				(instance.cleanupFns ??= []).push(cleanup);
+				return;
+			}
+			try {
+				cleanup();
+			} catch (err) {
+				logger.error("[Askr] async mount cleanup failed:", err);
+			}
+		}
+	}, (err) => {
+		logger.error("[Askr] async mount operation failed:", err);
+	});
+	else if (typeof result === "function") (instance.cleanupFns ??= []).push(result);
+}
+function executeOperations(instance, operations) {
+	if (operations.length === 0) return [];
+	const lifecycleGeneration = instance.lifecycleGeneration;
+	const errors = [];
+	for (const operation of operations) try {
+		settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
+	} catch (error) {
+		errors.push(error);
+	}
+	return errors;
+}
+function discardCommitOperations(instance) {
+	instance.commitOperations = void 0;
+}
+function executeCommittedLifecycleOperations(instance, wasFirstMount) {
+	const errors = [];
+	if (wasFirstMount && (instance.mountOperations?.length ?? 0) > 0) {
+		const operations = instance.mountOperations;
+		instance.mountOperations = void 0;
+		errors.push(...executeOperations(instance, operations));
+	}
+	if ((instance.commitOperations?.length ?? 0) > 0) {
+		const operations = instance.commitOperations;
+		instance.commitOperations = void 0;
+		errors.push(...executeOperations(instance, operations));
+	}
+	if (errors.length > 0) throw new AggregateError(errors, `Committed lifecycle operations failed for ${instance.id}`);
+}
+//#endregion
+//#region src/runtime/lifecycle-batch.ts
+let currentLifecycleCommitBatch = null;
+const pendingLifecycleCommitErrors = [];
+/** @internal Drain commit-time cleanup errors for transaction owners such as the router. */
+function drainLifecycleCommitErrors() {
+	if (pendingLifecycleCommitErrors.length === 0) return [];
+	return pendingLifecycleCommitErrors.splice(0);
+}
+function beginLifecycleCommitBatch() {
+	const batch = {
+		parent: currentLifecycleCommitBatch,
+		entries: [],
+		entriesByInstance: /* @__PURE__ */ new Map(),
+		readCommits: [],
+		readCommitsByInstance: /* @__PURE__ */ new Map(),
+		renderSnapshots: [],
+		renderSnapshotsByInstance: /* @__PURE__ */ new Map(),
+		transactions: [],
+		transactionsByKey: /* @__PURE__ */ new Map(),
+		retainedElementSnapshots: /* @__PURE__ */ new Map(),
+		active: true
+	};
+	currentLifecycleCommitBatch = batch;
+	return batch;
+}
+function getCurrentLifecycleCommitBatch() {
+	return currentLifecycleCommitBatch?.active ? currentLifecycleCommitBatch : null;
+}
+function enqueueLifecycleTransaction(batch, transaction) {
+	if (batch.transactionsByKey.has(transaction.key)) return;
+	batch.transactionsByKey.set(transaction.key, transaction);
+	batch.transactions.push(transaction);
+}
+function registerLifecycleTransaction(key, commit, rollback, merge) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	enqueueLifecycleTransaction(currentLifecycleCommitBatch, {
+		key,
+		commit,
+		rollback,
+		merge
+	});
+	return true;
+}
+function registerLifecycleRollback(rollback) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	currentLifecycleCommitBatch.transactions.push(rollback);
+	return true;
+}
+function closeLifecycleCommitBatch(batch) {
+	if (!batch.active) return false;
+	batch.active = false;
+	currentLifecycleCommitBatch = batch.parent;
+	return true;
+}
+function enqueueLifecycleCommit(batch, instance, wasFirstMount) {
+	const existing = batch.entriesByInstance.get(instance);
+	if (existing) {
+		existing.wasFirstMount = existing.wasFirstMount || wasFirstMount;
+		return;
+	}
+	const entry = {
+		instance,
+		wasFirstMount
+	};
+	batch.entriesByInstance.set(instance, entry);
+	batch.entries.push(entry);
+}
+function enqueueLifecycleCommitForInstance(instance, wasFirstMount) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	enqueueLifecycleCommit(currentLifecycleCommitBatch, instance, wasFirstMount);
+	return true;
+}
+function enqueueReadSubscriptionCommit(batch, instance, token, pendingReadSources, pendingReadSourceVersions) {
+	const existing = batch.readCommitsByInstance.get(instance);
+	const commit = existing ?? {
+		instance,
+		token,
+		pendingReadSources,
+		pendingReadSourceVersions
+	};
+	commit.token = token;
+	commit.pendingReadSources = pendingReadSources ? new Set(pendingReadSources) : void 0;
+	commit.pendingReadSourceVersions = pendingReadSourceVersions ? new Map(pendingReadSourceVersions) : void 0;
+	if (!existing) {
+		batch.readCommitsByInstance.set(instance, commit);
+		batch.readCommits.push(commit);
+	}
+}
+function enqueueInlineRenderSnapshot(batch, snapshot) {
+	if (batch.renderSnapshotsByInstance.has(snapshot.instance)) return;
+	batch.renderSnapshotsByInstance.set(snapshot.instance, snapshot);
+	batch.renderSnapshots.push(snapshot);
+}
+function captureInlineRenderSnapshot(instance) {
+	if (!currentLifecycleCommitBatch?.active) return;
+	enqueueInlineRenderSnapshot(currentLifecycleCommitBatch, {
+		instance,
+		props: instance.props,
+		ownerFrame: instance.ownerFrame,
+		portalScope: instance.portalScope,
+		parentInstance: instance.parentInstance,
+		isRoot: instance.isRoot
+	});
+}
+function finalizeInlineReadSubscriptions(instance, token, pendingReadSources, pendingReadSourceVersions) {
+	if ((!pendingReadSources || pendingReadSources.size === 0) && (!instance._lastReadSources || instance._lastReadSources.size === 0)) return;
+	if (currentLifecycleCommitBatch?.active) {
+		enqueueReadSubscriptionCommit(currentLifecycleCommitBatch, instance, token, pendingReadSources, pendingReadSourceVersions);
+		return;
+	}
+	finalizeReadableSubscriptionsFromSnapshot(instance, token, pendingReadSources, pendingReadSourceVersions);
+}
+function flushLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	if (batch.parent?.active) {
+		for (const [element, snapshot] of batch.retainedElementSnapshots) if (!batch.parent.retainedElementSnapshots.has(element)) batch.parent.retainedElementSnapshots.set(element, snapshot);
+		for (const entry of batch.transactions) if (typeof entry === "function") batch.parent.transactions.push(entry);
+		else {
+			const existing = batch.parent.transactionsByKey.get(entry.key);
+			if (existing && entry.merge) entry.merge(existing);
+			else enqueueLifecycleTransaction(batch.parent, entry);
+		}
+		for (const snapshot of batch.renderSnapshots) enqueueInlineRenderSnapshot(batch.parent, snapshot);
+		for (const commit of batch.readCommits) enqueueReadSubscriptionCommit(batch.parent, commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+		for (const entry of batch.entries) enqueueLifecycleCommit(batch.parent, entry.instance, entry.wasFirstMount);
+		return;
+	}
+	const commitErrors = [];
+	for (const commit of batch.readCommits) try {
+		finalizeReadableSubscriptionsFromSnapshot(commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+	} catch (error) {
+		commitErrors.push(error);
+	}
+	for (const transaction of batch.transactions) {
+		if (typeof transaction === "function") continue;
+		try {
+			transaction.commit();
+		} catch (error) {
+			commitErrors.push(error);
+		}
+	}
+	for (const entry of batch.entries) try {
+		executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);
+	} catch (error) {
+		commitErrors.push(error);
+	}
+	if (commitErrors.length > 0) {
+		pendingLifecycleCommitErrors.push(...commitErrors);
+		logger.error("[Askr] committed lifecycle work failed:", new AggregateError(commitErrors, "Committed lifecycle work failed"));
+	}
+}
+function discardLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	for (let index = batch.transactions.length - 1; index >= 0; index -= 1) try {
+		const transaction = batch.transactions[index];
+		if (typeof transaction === "function") transaction();
+		else transaction.rollback();
+	} catch (error) {
+		logger.error("[Askr] transaction rollback failed:", error);
+	}
+	for (let index = batch.renderSnapshots.length - 1; index >= 0; index -= 1) {
+		const snapshot = batch.renderSnapshots[index];
+		snapshot.instance.props = snapshot.props;
+		snapshot.instance.ownerFrame = snapshot.ownerFrame;
+		snapshot.instance.portalScope = snapshot.portalScope;
+		snapshot.instance.parentInstance = snapshot.parentInstance;
+		snapshot.instance.isRoot = snapshot.isRoot;
+	}
+	for (const entry of batch.entries) {
+		if (entry.wasFirstMount) entry.instance.mountOperations = void 0;
+		discardCommitOperations(entry.instance);
+	}
+}
+//#endregion
+//#region src/runtime/component-lifecycle.ts
+function registerCommitOperationForInstance(instance, operation) {
+	if (instance) {
+		if (isBulkCommitActive()) {
+			if (isDevelopmentEnvironment()) throw new Error("registerCommitOperation called during bulk commit fast-lane");
+			return;
+		}
+		(instance.commitOperations ??= []).push(operation);
+	}
+}
+function commitLifecycleForInstance(instance, wasFirstMount) {
+	if ((instance.mountOperations?.length ?? 0) === 0 && (instance.commitOperations?.length ?? 0) === 0) return;
+	if (enqueueLifecycleCommitForInstance(instance, wasFirstMount)) return;
+	executeCommittedLifecycleOperations(instance, wasFirstMount);
+}
+function commitRenderedComponent(instance) {
+	if (instance.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
+}
+//#endregion
+export { registerOwnedChildScope as _, captureInlineRenderSnapshot as a, finalizeInlineReadSubscriptions as c, registerLifecycleRollback as d, registerLifecycleTransaction as f, cleanupComponentGeneration as g, cleanupComponent as h, beginLifecycleCommitBatch as i, flushLifecycleCommitBatch as l, isPromiseLike as m, commitRenderedComponent as n, discardLifecycleCommitBatch as o, discardCommitOperations as p, registerCommitOperationForInstance as r, drainLifecycleCommitErrors as s, commitLifecycleForInstance as t, getCurrentLifecycleCommitBatch as u, unregisterOwnedChildScope as v };

package/dist/{runtime/component-scope.js → component-scope-CC3cojX9.js}

@@ -3,6 +3,10 @@ let currentInstance = null;
 let currentPortalScope = null;
 let stateIndex = 0;
 let globalRenderCounter = 0;
+let renderScopedDepth = 0;
+let outerRenderScopedInstance = null;
+let outerRenderScopedPortalScope = null;
+let outerRenderScopedStateIndex = 0;
 function ensureAbortController(instance) {
 	let controller = instance.abortController;
 	if (!controller || controller.signal.aborted) {
@@ -38,6 +42,13 @@ function getCurrentComponentInstance() {
 function getCurrentInstance() {
 	return currentInstance;
 }
+function getCurrentAppRenderRuntime() {
+	let instance = currentInstance;
+	while (instance) {
+		if (instance._appRenderRuntime) return instance._appRenderRuntime;
+		instance = instance.parentInstance;
+	}
+}
 function setCurrentComponentInstance(instance) {
 	currentInstance = instance;
 	currentPortalScope = instance?.portalScope ?? null;
@@ -62,7 +73,7 @@ function getSignal() {
 }
 function resetRenderState(instance) {
 	instance.stateIndexCheck = -1;
-	for (const state of instance.stateValues) if (state) state._hasBeenRead = false;
+	for (const state of instance.stateValues ?? []) if (state) state._hasBeenRead = false;
 	instance._pendingReadSources = void 0;
 	instance._pendingReadSourceVersions = void 0;
 }
@@ -89,14 +100,30 @@ function restoreInlineRenderTracking(instance, snapshot) {
 	instance._pendingReadSourceVersions = snapshot.pendingReadSourceVersions;
 }
 function enterRenderScopedComponent(instance, startStateIndex) {
-	const savedScope = captureScope();
+	let savedScope = null;
+	if (renderScopedDepth === 0) {
+		outerRenderScopedInstance = currentInstance;
+		outerRenderScopedPortalScope = currentPortalScope;
+		outerRenderScopedStateIndex = stateIndex;
+	} else savedScope = captureScope();
+	renderScopedDepth += 1;
 	currentInstance = instance;
-	currentPortalScope = instance.portalScope ?? savedScope.portalScope;
+	currentPortalScope = instance.portalScope ?? (savedScope ? savedScope.portalScope : outerRenderScopedPortalScope);
 	stateIndex = startStateIndex;
 	return savedScope;
 }
 function restoreRenderScopedComponent(snapshot) {
-	restoreScope(snapshot);
+	renderScopedDepth -= 1;
+	if (snapshot) {
+		restoreScope(snapshot);
+		return;
+	}
+	currentInstance = outerRenderScopedInstance;
+	currentPortalScope = outerRenderScopedPortalScope;
+	stateIndex = outerRenderScopedStateIndex;
+	outerRenderScopedInstance = null;
+	outerRenderScopedPortalScope = null;
+	outerRenderScopedStateIndex = 0;
 }
 function captureInlineComponentScope() {
 	return captureInstancePortalScope();
@@ -140,15 +167,14 @@ function claimHookIndex(instance, hookName) {
 	const index = getNextStateIndex();
 	if (index < instance.stateIndexCheck) throw new Error(`Hook index violation: ${hookName}() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when render-scoped hooks are called conditionally (inside if/for/etc). Move all ${hookName}() calls to the top level of your component function, before any conditionals.`);
 	instance.stateIndexCheck = index;
+	const expectedStateIndices = instance.expectedStateIndices ??= [];
 	if (instance.firstRenderComplete) {
-		if (instance.expectedStateIndices[index] !== index) throw new Error(`Hook order violation: ${hookName}() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means ${hookName}() is inside a conditional or loop. Move all render-scoped hooks to the top level of your component function.`);
-	} else instance.expectedStateIndices.push(index);
+		if (expectedStateIndices[index] !== index) throw new Error(`Hook order violation: ${hookName}() called at index ${index}, but this index was not in the first render's sequence [${expectedStateIndices.join(", ")}]. This usually means ${hookName}() is inside a conditional or loop. Move all render-scoped hooks to the top level of your component function.`);
+	} else expectedStateIndices.push(index);
 	return index;
 }
 function getCurrentStateIndex() {
 	return stateIndex;
 }
 //#endregion
-export { beginRenderTracking, captureInlineComponentScope, captureInlineRenderTracking, claimHookIndex, clearCurrentComponentScope, clearRenderTracking, enterComponentExecutionScope, enterDomCommitScope, enterRenderScopedComponent, exitComponentExecutionScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getNextStateIndex, getSignal, getSignalForInstance, resetRenderState, restoreCurrentComponentScope, restoreDomCommitScope, restoreInlineComponentScope, restoreInlineRenderTracking, restoreRenderScopedComponent, setCurrentComponentInstance };
-
-//# sourceMappingURL=component-scope.js.map
+export { restoreRenderScopedComponent as C, restoreInlineRenderTracking as S, getSignalForInstance as _, clearCurrentComponentScope as a, restoreDomCommitScope as b, enterDomCommitScope as c, getCurrentAppRenderRuntime as d, getCurrentComponentInstance as f, getSignal as g, getCurrentStateIndex as h, claimHookIndex as i, enterRenderScopedComponent as l, getCurrentPortalScope as m, captureInlineComponentScope as n, clearRenderTracking as o, getCurrentInstance as p, captureInlineRenderTracking as r, enterComponentExecutionScope as s, beginRenderTracking as t, exitComponentExecutionScope as u, resetRenderState as v, setCurrentComponentInstance as w, restoreInlineComponentScope as x, restoreCurrentComponentScope as y };

package/dist/component-scope-CvPba6O6.d.ts

@@ -0,0 +1,12 @@
+//#region src/runtime/component-scope.d.ts
+/**
+ * Get the abort signal for the current component.
+ *
+ * The signal is guaranteed to be aborted when:
+ * - Component unmounts
+ * - Navigation occurs (different route)
+ * - Parent is destroyed
+ */
+declare function getSignal(): AbortSignal;
+//#endregion
+export { getSignal as t };

package/dist/components/index.d.ts

@@ -1,3 +1,18 @@
-import { ErrorBoundaryFallbackRender, ErrorBoundaryProps } from "../common/error-boundary.js";
-import { ErrorBoundary } from "./error-boundary.js";
+import { l as VNode } from "../control-BQvNVfAd.js";
+import { r as JSXElement, s as Props } from "../jsx-CP0gmYwJ.js";
+
+//#region src/common/error-boundary.d.ts
+type ErrorBoundaryContent = VNode | readonly VNode[];
+type ErrorBoundaryFallbackValue = ErrorBoundaryContent | Node;
+type ErrorBoundaryFallbackRender = (error: unknown, reset: () => void) => ErrorBoundaryFallbackValue;
+interface ErrorBoundaryProps extends Props {
+  children?: ErrorBoundaryContent;
+  fallback?: ErrorBoundaryFallbackValue | ErrorBoundaryFallbackRender;
+  onError?: (error: unknown) => void;
+  resetKey?: unknown;
+}
+//#endregion
+//#region src/components/error-boundary.d.ts
+declare function ErrorBoundary(props: ErrorBoundaryProps): JSXElement;
+//#endregion
 export { ErrorBoundary, type ErrorBoundaryFallbackRender, type ErrorBoundaryProps };

package/dist/components/index.js

@@ -1,2 +1,40 @@
-import { ErrorBoundary } from "./error-boundary.js";
+import { t as __ERROR_BOUNDARY__ } from "../vnode-CGMJYPMB.js";
+import { t as ELEMENT_TYPE } from "../jsx-CUpRxrLH.js";
+import { f as getCurrentComponentInstance } from "../component-scope-CC3cojX9.js";
+//#region src/components/error-boundary.tsx
+function ensureBoundaryState(instance, resetKey) {
+	const boundaryState = instance.errorBoundaryState ?? (instance.errorBoundaryState = {
+		error: null,
+		resetKey,
+		notified: false
+	});
+	if (!Object.is(boundaryState.resetKey, resetKey)) {
+		boundaryState.error = null;
+		boundaryState.resetKey = resetKey;
+		boundaryState.notified = false;
+	}
+	return boundaryState;
+}
+function createBoundaryVNode(instance, props) {
+	const key = typeof props.key === "symbol" ? null : props.key ?? null;
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: __ERROR_BOUNDARY__,
+		props: {
+			children: props.children,
+			fallback: props.fallback,
+			onError: props.onError,
+			resetKey: props.resetKey
+		},
+		key,
+		__instance: instance
+	};
+}
+function ErrorBoundary(props) {
+	const instance = getCurrentComponentInstance();
+	if (!instance) throw new Error("[Askr] ErrorBoundary() can only be used during component render execution.");
+	ensureBoundaryState(instance, props.resetKey);
+	return createBoundaryVNode(instance, props);
+}
+//#endregion
 export { ErrorBoundary };

package/dist/compose-ref-Cc_YkUpM.js

@@ -0,0 +1,92 @@
+//#region src/foundations/utilities/compose-handlers.ts
+function isDefaultPrevented(value) {
+	return typeof value === "object" && value !== null && "defaultPrevented" in value && value.defaultPrevented === true;
+}
+function composeHandlers(first, second, options) {
+	if (!first && !second) return noop;
+	if (!first) return second;
+	if (!second) return first;
+	const checkDefaultPrevented = options?.checkDefaultPrevented !== false;
+	return function composed(...args) {
+		first(...args);
+		if (checkDefaultPrevented && isDefaultPrevented(args[0])) return;
+		second(...args);
+	};
+}
+function noop() {}
+//#endregion
+//#region src/foundations/utilities/merge-props.ts
+/**
+* mergeProps
+*
+* Deterministic props merging.
+* - For non-handlers: `base` overwrites `injected`.
+* - For handlers present in both: handlers are composed with `injected` running
+*   first; it may call `preventDefault()` to suppress the `base` handler.
+*
+* POLICY DECISIONS (LOCKED):
+*
+* 1. Merge Strategy
+*    Base props overwrite injected props (base wins).
+*    Exception: Event handlers are composed, not overwritten.
+*
+* 2. Event Handler Detection
+*    Keys starting with "on" are treated as event handlers.
+*    This matches JSX conventions.
+*
+* 3. Handler Composition Order
+*    Injected handler runs first, base handler second.
+*    This allows injected handlers to prevent default.
+*
+* 4. Return Type
+*    Returns intersection type (TInjected & TBase) for type safety.
+*/
+function isEventHandlerKey(key) {
+	return key.startsWith("on");
+}
+function mergeProps(base, injected) {
+	const baseKeys = Object.keys(base);
+	if (baseKeys.length === 0) return injected;
+	const out = { ...injected };
+	for (const key of baseKeys) {
+		const baseValue = base[key];
+		const injectedValue = injected[key];
+		if (isEventHandlerKey(key) && typeof baseValue === "function" && typeof injectedValue === "function") {
+			out[key] = composeHandlers(injectedValue, baseValue);
+			continue;
+		}
+		out[key] = baseValue;
+	}
+	return out;
+}
+//#endregion
+//#region src/foundations/utilities/aria.ts
+/**
+* Tiny aria helpers
+*/
+function ariaDisabled(disabled) {
+	return disabled ? { "aria-disabled": "true" } : {};
+}
+function ariaExpanded(expanded) {
+	return expanded === void 0 ? {} : { "aria-expanded": String(expanded) };
+}
+function ariaSelected(selected) {
+	return selected === void 0 ? {} : { "aria-selected": String(selected) };
+}
+//#endregion
+//#region src/foundations/utilities/compose-ref.ts
+function setRef(ref, value) {
+	if (!ref) return;
+	if (typeof ref === "function") {
+		ref(value);
+		return;
+	}
+	if (Object.isExtensible(ref)) ref.current = value;
+}
+function composeRefs(...refs) {
+	return (value) => {
+		for (const ref of refs) setRef(ref, value);
+	};
+}
+//#endregion
+export { ariaSelected as a, ariaExpanded as i, setRef as n, mergeProps as o, ariaDisabled as r, composeHandlers as s, composeRefs as t };

package/dist/{foundations/utilities/compose-ref.d.ts → compose-ref-Cizq72-x.d.ts}

@@ -23,5 +23,4 @@ type Ref<T> = ((value: T | null) => void) | {
 declare function setRef<T>(ref: Ref<T>, value: T | null): void;
 declare function composeRefs<T>(...refs: Array<Ref<T>>): (value: T | null) => void;
 //#endregion
-export { Ref, composeRefs, setRef };
-//# sourceMappingURL=compose-ref.d.ts.map
+export { composeRefs as n, setRef as r, Ref as t };

package/dist/control/index.d.ts

@@ -1,4 +1,2 @@
-import { For, ForProps } from "./for.js";
-import { Show, ShowProps } from "./show.js";
-import { Case, CaseProps, Match, MatchProps } from "./case.js";
+import { a as Show, c as ForProps, i as MatchProps, n as CaseProps, o as ShowProps, r as Match, s as For, t as Case } from "../index-D73jgYx1.js";
 export { Case, type CaseProps, For, type ForProps, Match, type MatchProps, Show, type ShowProps };

package/dist/control/index.js

@@ -1,4 +1,2 @@
-import { For } from "./for.js";
-import { Show } from "./show.js";
-import { Case, Match } from "./case.js";
+import { i as For, n as Match, r as Show, t as Case } from "../control-BYyLTFyw.js";
 export { Case, For, Match, Show };