@askrjs/askr 0.0.48 → 0.0.50

package/dist/runtime/component.js

@@ -1,693 +1,5 @@
-import { isDevelopmentEnvironment, isProductionEnvironment } from "../common/env.js";
-import { logger } from "../dev/logger.js";
-import { globalScheduler } from "./scheduler.js";
-import { withContext } from "./context.js";
-import { cleanupReadableSubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot } from "./readable.js";
-import { incDevCounter, setDevValue } from "./dev-namespace.js";
-import { isPromiseLike } from "../common/promise.js";
-import { isBulkCommitActive } from "./fastlane.js";
-import { cleanupInstancesUnder } from "../renderer/cleanup.js";
-import { evaluate } from "../renderer/evaluate.js";
-import "../renderer/index.js";
-//#region src/runtime/component.ts
-/**
-* Register a mount operation that will run after the component is mounted
-* Used by operations (task, on, timer, etc) to execute after render completes
-*/
-function createComponentInstance(id, fn, props, target) {
-	const instance = {
-		id,
-		fn,
-		props,
-		target,
-		parentInstance: currentInstance,
-		portalScope: currentInstance?.portalScope ?? currentPortalScope ?? null,
-		mounted: false,
-		abortController: null,
-		stateValues: [],
-		evaluationGeneration: 0,
-		notifyUpdate: null,
-		_pendingFlushTask: void 0,
-		_pendingRunTask: void 0,
-		_enqueueRun: void 0,
-		stateIndexCheck: -1,
-		expectedStateIndices: [],
-		firstRenderComplete: false,
-		mountOperations: [],
-		commitOperations: [],
-		cleanupFns: [],
-		lifecycleSlots: [],
-		lifecycleGeneration: 0,
-		hasPendingUpdate: false,
-		ownerFrame: null,
-		ssr: false,
-		cleanupStrict: false,
-		isRoot: false,
-		_currentRenderToken: void 0,
-		lastRenderToken: 0,
-		_pendingReadSources: void 0,
-		_pendingReadSourceVersions: void 0,
-		_lastReadSources: void 0,
-		devWarningsEmitted: void 0
-	};
-	instance._pendingRunTask = () => {
-		instance.hasPendingUpdate = false;
-		if (instance.notifyUpdate === null) return;
-		runComponent(instance);
-	};
-	instance._enqueueRun = () => {
-		if (!instance.hasPendingUpdate) {
-			instance.hasPendingUpdate = true;
-			globalScheduler.enqueue(instance._pendingRunTask);
-		}
-	};
-	instance._pendingFlushTask = instance._pendingRunTask;
-	return instance;
-}
-let currentInstance = null;
-let currentPortalScope = null;
-let stateIndex = 0;
-function ensureAbortController(instance) {
-	let controller = instance.abortController;
-	if (!controller || controller.signal.aborted) {
-		controller = new AbortController();
-		instance.abortController = controller;
-	}
-	return controller;
-}
-function getCurrentComponentInstance() {
-	return currentInstance;
-}
-function setCurrentComponentInstance(instance) {
-	currentInstance = instance;
-	currentPortalScope = instance?.portalScope ?? null;
-}
-function getCurrentPortalScope() {
-	return currentInstance?.portalScope ?? currentPortalScope;
-}
-let currentLifecycleCommitBatch = null;
-function beginLifecycleCommitBatch() {
-	const batch = {
-		parent: currentLifecycleCommitBatch,
-		entries: [],
-		entriesByInstance: /* @__PURE__ */ new Map(),
-		readCommits: [],
-		readCommitsByInstance: /* @__PURE__ */ new Map(),
-		renderSnapshots: [],
-		renderSnapshotsByInstance: /* @__PURE__ */ new Map(),
-		active: true
-	};
-	currentLifecycleCommitBatch = batch;
-	return batch;
-}
-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 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 (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 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;
-	}
-	for (const commit of batch.readCommits) finalizeReadableSubscriptionsFromSnapshot(commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
-	for (const entry of batch.entries) executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);
-}
-function discardLifecycleCommitBatch(batch) {
-	if (!closeLifecycleCommitBatch(batch)) return;
-	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 = [];
-		discardCommitOperations(entry.instance);
-	}
-}
-function registerCommitOperation(operation) {
-	const instance = getCurrentComponentInstance();
-	if (instance) {
-		if (isBulkCommitActive()) {
-			if (isDevelopmentEnvironment()) throw new Error("registerCommitOperation called during bulk commit fast-lane");
-			return;
-		}
-		instance.commitOperations.push(operation);
-	}
-}
-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);
-}
-/**
-* Execute all mount operations for a component
-* These run after the component is rendered and mounted to the DOM
-*/
-function executeMountOperations(instance) {
-	const mountOperations = instance.mountOperations;
-	if (mountOperations.length === 0) return;
-	const lifecycleGeneration = instance.lifecycleGeneration;
-	for (const operation of mountOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
-	instance.mountOperations = [];
-}
-function executeCommitOperations(instance) {
-	const commitOperations = instance.commitOperations;
-	if (commitOperations.length === 0) return;
-	instance.commitOperations = [];
-	const lifecycleGeneration = instance.lifecycleGeneration;
-	for (const operation of commitOperations) settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
-}
-function discardCommitOperations(instance) {
-	instance.commitOperations = [];
-}
-function executeCommittedLifecycleOperations(instance, wasFirstMount) {
-	if (wasFirstMount && instance.mountOperations.length > 0) executeMountOperations(instance);
-	if (instance.commitOperations.length > 0) executeCommitOperations(instance);
-}
-function commitLifecycleForInstance(instance, wasFirstMount) {
-	if (currentLifecycleCommitBatch) {
-		enqueueLifecycleCommit(currentLifecycleCommitBatch, instance, wasFirstMount);
-		return;
-	}
-	executeCommittedLifecycleOperations(instance, wasFirstMount);
-}
-function commitRenderedComponent(instance) {
-	if (instance.mounted && instance.commitOperations.length > 0) commitLifecycleForInstance(instance, false);
-}
-function mountInstanceInline(instance, target) {
-	instance.target = target;
-	try {
-		if (target instanceof Element) {
-			const host = target;
-			const nextInstances = (host.__ASKR_INSTANCES ?? []).filter((entry) => entry !== instance);
-			nextInstances.push(instance);
-			host.__ASKR_INSTANCES = nextInstances;
-			host.__ASKR_INSTANCE = nextInstances[0] ?? instance;
-		}
-	} catch (err) {}
-	instance.notifyUpdate = instance._enqueueRun;
-	const wasFirstMount = !instance.mounted;
-	instance.mounted = true;
-	commitLifecycleForInstance(instance, wasFirstMount);
-}
-/**
-* Run a component synchronously: execute function, handle result
-* This is the internal workhorse that manages async continuations and generation tracking.
-* Must always be called through the scheduler.
-*
-* ACTOR INVARIANT: This function is enqueued as a task, never called directly.
-*/
-let _globalRenderCounter = 0;
-function resetRenderState(instance) {
-	instance.stateIndexCheck = -1;
-	for (const state of instance.stateValues) if (state) state._hasBeenRead = false;
-	instance._pendingReadSources = void 0;
-	instance._pendingReadSourceVersions = void 0;
-}
-function nextRenderToken() {
-	return ++_globalRenderCounter;
-}
-function renderScopedComponent(instance, startStateIndex, render) {
-	const savedInstance = currentInstance;
-	const savedPortalScope = currentPortalScope;
-	const savedStateIndex = stateIndex;
-	instance.notifyUpdate = instance._enqueueRun;
-	resetRenderState(instance);
-	instance._currentRenderToken = nextRenderToken();
-	currentInstance = instance;
-	currentPortalScope = instance.portalScope ?? savedPortalScope;
-	stateIndex = startStateIndex;
-	let didComplete = false;
-	try {
-		const result = withContext({
-			parent: instance.ownerFrame,
-			values: null
-		}, render);
-		didComplete = true;
-		return result;
-	} finally {
-		if (!didComplete) {
-			instance._pendingReadSources = void 0;
-			instance._pendingReadSourceVersions = void 0;
-			instance._currentRenderToken = void 0;
-		}
-		currentInstance = savedInstance;
-		currentPortalScope = savedPortalScope;
-		stateIndex = savedStateIndex;
-	}
-}
-function runComponent(instance) {
-	instance.notifyUpdate = instance._enqueueRun;
-	instance._currentRenderToken = nextRenderToken();
-	instance._pendingReadSources = void 0;
-	const domSnapshot = instance.target ? instance.target.innerHTML : "";
-	let result;
-	try {
-		result = executeComponentSync(instance);
-	} catch (err) {
-		discardCommitOperations(instance);
-		throw err;
-	}
-	if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must be synchronous.");
-	else {
-		const fastlaneBridge = globalThis.__ASKR_FASTLANE;
-		try {
-			if (fastlaneBridge?.tryRuntimeFastLaneSync?.(instance, result)) {
-				warnUnusedStateReads(instance);
-				return;
-			}
-		} catch (err) {
-			if (isDevelopmentEnvironment()) throw err;
-		}
-		globalScheduler.enqueue(() => {
-			if (!instance.target && instance._placeholder) {
-				if (result === null || result === void 0) {
-					finalizeReadSubscriptions(instance);
-					warnUnusedStateReads(instance);
-					commitRenderedComponent(instance);
-					return;
-				}
-				const placeholder = instance._placeholder;
-				const parent = placeholder.parentNode;
-				if (!parent) {
-					logger.warn("[Askr] placeholder no longer in DOM, cannot render component");
-					return;
-				}
-				const host = document.createElement("div");
-				const executionFrame = {
-					parent: instance.ownerFrame,
-					values: null
-				};
-				const oldInstance = currentInstance;
-				currentInstance = instance;
-				const lifecycleBatch = beginLifecycleCommitBatch();
-				try {
-					try {
-						withContext(executionFrame, () => {
-							evaluate(result, host);
-						});
-						parent.replaceChild(host, placeholder);
-					} catch (err) {
-						discardLifecycleCommitBatch(lifecycleBatch);
-						throw err;
-					}
-					instance.target = host;
-					instance._placeholder = void 0;
-					host.__ASKR_INSTANCE = instance;
-					flushLifecycleCommitBatch(lifecycleBatch);
-					finalizeReadSubscriptions(instance);
-					warnUnusedStateReads(instance);
-					commitRenderedComponent(instance);
-				} finally {
-					currentInstance = oldInstance;
-				}
-				return;
-			}
-			if (instance.target) {
-				let oldChildren = [];
-				let restoredOldChildren = false;
-				try {
-					const wasFirstMount = !instance.mounted;
-					const oldInstance = currentInstance;
-					currentInstance = instance;
-					const executionFrame = {
-						parent: instance.ownerFrame,
-						values: null
-					};
-					oldChildren = Array.from(instance.target.childNodes);
-					const lifecycleBatch = beginLifecycleCommitBatch();
-					try {
-						try {
-							withContext(executionFrame, () => {
-								evaluate(result, instance.target, void 0, instance);
-							});
-						} catch (e) {
-							discardLifecycleCommitBatch(lifecycleBatch);
-							throw e;
-						}
-					} catch (e) {
-						try {
-							const newChildren = Array.from(instance.target.childNodes);
-							const preservedChildren = new Set(oldChildren);
-							for (const n of newChildren) {
-								if (preservedChildren.has(n)) continue;
-								try {
-									cleanupInstancesUnder(n);
-								} catch (err) {
-									logger.warn("[Askr] error cleaning up failed commit children:", err);
-								}
-							}
-						} catch (_err) {}
-						try {
-							incDevCounter("__DOM_REPLACE_COUNT");
-							setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE", (/* @__PURE__ */ new Error()).stack);
-						} catch (e) {}
-						instance.target.replaceChildren(...oldChildren);
-						restoredOldChildren = true;
-						throw e;
-					} finally {
-						currentInstance = oldInstance;
-					}
-					flushLifecycleCommitBatch(lifecycleBatch);
-					finalizeReadSubscriptions(instance);
-					warnUnusedStateReads(instance);
-					instance.mounted = true;
-					executeCommittedLifecycleOperations(instance, wasFirstMount);
-				} catch (renderError) {
-					discardCommitOperations(instance);
-					try {
-						const currentChildren = Array.from(instance.target.childNodes);
-						const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;
-						for (const n of currentChildren) {
-							if (preservedChildren?.has(n)) continue;
-							try {
-								cleanupInstancesUnder(n);
-							} catch (err) {
-								logger.warn("[Askr] error cleaning up partial children during rollback:", err);
-							}
-						}
-					} catch (_err) {}
-					try {
-						incDevCounter("__DOM_REPLACE_COUNT");
-						setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK", (/* @__PURE__ */ new Error()).stack);
-						instance.target.replaceChildren(...oldChildren);
-					} catch {
-						instance.target.innerHTML = domSnapshot;
-					}
-					throw renderError;
-				}
-			}
-		});
-	}
-}
-/**
-* Execute a component's render function synchronously.
-* Returns either a vnode/promise immediately (does NOT render).
-* Rendering happens separately through runComponent.
-*/
-function renderComponentInline(instance) {
-	instance.notifyUpdate = instance._enqueueRun;
-	const hadToken = instance._currentRenderToken !== void 0;
-	const prevToken = instance._currentRenderToken;
-	const prevPendingReads = instance._pendingReadSources;
-	const prevPendingReadVersions = instance._pendingReadSourceVersions;
-	const savedInstance = currentInstance;
-	const savedPortalScope = currentPortalScope;
-	if (!hadToken) {
-		instance._currentRenderToken = nextRenderToken();
-		instance._pendingReadSources = void 0;
-		instance._pendingReadSourceVersions = void 0;
-	}
-	try {
-		const result = executeComponentSync(instance);
-		if (!hadToken) finalizeInlineReadSubscriptions(instance, instance._currentRenderToken, instance._pendingReadSources, instance._pendingReadSourceVersions);
-		commitRenderedComponent(instance);
-		return result;
-	} finally {
-		instance._currentRenderToken = prevToken;
-		instance._pendingReadSources = prevPendingReads;
-		instance._pendingReadSourceVersions = prevPendingReadVersions;
-		currentInstance = savedInstance;
-		currentPortalScope = savedPortalScope;
-	}
-}
-function warnUnusedStateReads(instance) {
-	for (let i = 0; i < instance.stateValues.length; i++) {
-		const state = instance.stateValues[i];
-		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
-		if (state && !state._hasBeenRead && !state._hasEverBeenRead && !hasCommittedUsage) try {
-			const name = instance.fn?.name || "<anonymous>";
-			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
-		} catch {
-			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected. State should be read during render or removed.`);
-		}
-	}
-}
-function executeComponentSync(instance) {
-	resetRenderState(instance);
-	incDevCounter("componentRuns");
-	incDevCounter("componentReruns");
-	const savedPortalScope = currentPortalScope;
-	currentInstance = instance;
-	currentPortalScope = instance.portalScope ?? savedPortalScope;
-	stateIndex = 0;
-	let didComplete = false;
-	try {
-		const renderStartTime = isDevelopmentEnvironment() ? Date.now() : 0;
-		const context = { get signal() {
-			return ensureAbortController(instance).signal;
-		} };
-		const result = withContext({
-			parent: instance.ownerFrame,
-			values: null
-		}, () => instance.fn(instance.props, context));
-		const renderTime = Date.now() - renderStartTime;
-		if (renderTime > 5) warnInstanceOnce(instance, "slow-render", `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`);
-		if (!instance.firstRenderComplete) instance.firstRenderComplete = true;
-		didComplete = true;
-		return result;
-	} finally {
-		if (!didComplete) discardCommitOperations(instance);
-		currentInstance = null;
-		currentPortalScope = savedPortalScope;
-	}
-}
-/**
-* Public entry point: Execute component with full lifecycle (execute + render)
-* Handles both initial mount and re-execution. Always enqueues through scheduler.
-* Single entry point to avoid lifecycle divergence.
-*/
-function executeComponent(instance) {
-	instance.abortController = null;
-	instance.notifyUpdate = instance._enqueueRun;
-	globalScheduler.enqueue(instance._pendingRunTask);
-}
-function getCurrentInstance() {
-	return currentInstance;
-}
-/**
-* Get the abort signal for the current component
-* Used to cancel async operations on unmount/navigation
-*
-* The signal is guaranteed to be aborted when:
-* - Component unmounts
-* - Navigation occurs (different route)
-* - Parent is destroyed
-*
-* IMPORTANT: getSignal() must be called during component render execution.
-* It captures the current component instance from context.
-*
-* @returns AbortSignal that will be aborted when component unmounts
-* @throws Error if called outside component execution
-*
-* @example
-* ```ts
-* // ✅ Correct: called during render, used in async operation
-* export async function UserPage({ id }: { id: string }) {
-*   const signal = getSignal();
-*   const user = await fetch(`/api/users/${id}`, { signal });
-*   return <div>{user.name}</div>;
-* }
-*
-* // ✅ Correct: passed to event handler
-* export function Button() {
-*   const signal = getSignal();
-*   return {
-*     type: 'button',
-*     props: {
-*       onClick: async () => {
-*         const data = await fetch(url, { signal });
-*       }
-*     }
-*   };
-* }
-*
-* // ❌ Wrong: called outside component context
-* const signal = getSignal(); // Error: not in component
-* ```
-*/
-function getSignal() {
-	if (!currentInstance) throw new Error("getSignal() can only be called during component render execution. Ensure you are calling this from inside your component function.");
-	return ensureAbortController(currentInstance).signal;
-}
-/**
-* Finalize read subscriptions for an instance after a successful commit.
-* - Update per-state readers map to point to this instance's last committed token
-* - Remove this instance from states it no longer reads
-* This is deterministic and runs synchronously with commit to ensure
-* subscribers are only notified when they actually read a state in their
-* last committed render.
-*/
-function finalizeReadSubscriptions(instance) {
-	finalizeReadableSubscriptions(instance);
-}
-function getNextStateIndex() {
-	return stateIndex++;
-}
-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;
-	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);
-	return index;
-}
-function getCurrentStateIndex() {
-	return stateIndex;
-}
-/**
-* Mount a component instance.
-* This is just an alias to executeComponent() to maintain API compatibility.
-* All lifecycle logic is unified in executeComponent().
-*/
-function mountComponent(instance) {
-	executeComponent(instance);
-}
-/**
-* Clean up component — abort pending operations
-* Called on unmount or route change
-*/
-function cleanupComponent(instance) {
-	const savedInstance = currentInstance;
-	const savedPortalScope = currentPortalScope;
-	currentInstance = null;
-	currentPortalScope = null;
-	try {
-		const cleanupErrors = [];
-		const recordCleanupError = (message, err) => {
-			if (instance.cleanupStrict) 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 = [];
-		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 = [];
-		instance.commitOperations = [];
-		instance.lifecycleSlots = [];
-		instance.hasPendingUpdate = false;
-		instance.notifyUpdate = null;
-		instance._placeholder = void 0;
-		instance.mounted = false;
-		if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, `Cleanup failed for component ${instance.id}`);
-	} finally {
-		currentInstance = savedInstance;
-		currentPortalScope = savedPortalScope;
-	}
-}
-function registerOwnedChildScope(instance, scope) {
-	(instance._ownedChildScopes ??= /* @__PURE__ */ new Set()).add(scope);
-}
-function unregisterOwnedChildScope(instance, scope) {
-	instance._ownedChildScopes?.delete(scope);
-}
-function warnInstanceOnce(instance, key, message) {
-	if (isProductionEnvironment()) return;
-	const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
-	if (warnings.has(key)) return;
-	warnings.add(key);
-	logger.warn(message);
-}
-//#endregion
+import { claimHookIndex, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, setCurrentComponentInstance } from "./component-scope.js";
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { captureInlineRenderSnapshot, createComponentInstance, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
+import "./component-facade.js";
 export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, finalizeReadSubscriptions, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };
-
-//# sourceMappingURL=component.js.map

package/dist/runtime/context.d.ts

@@ -65,5 +65,5 @@ declare function getCurrentContextFrame(): ContextFrame | null;
  */
 declare function getTopContextSnapshot(): ContextFrame | null;
 //#endregion
-export { Context, ContextFrame, defineContext, readContext };
+export { Context, ContextFrame, ContextKey, defineContext, readContext };
 //# sourceMappingURL=context.d.ts.map