@askrjs/askr 0.3.0 → 0.4.0

package/dist/instance-VAFYVJOa.js

@@ -1,1027 +0,0 @@
-import { T as isProductionEnvironment, a as getRuntimeEvaluation, i as getRuntimeCleanup, m as runRuntimeWithSyncProgress, n as enqueueRuntimeTask, v as logger, w as isDevelopmentEnvironment } from "./access-CEA2pOry.js";
-import { C as disposeOwnership, D as ownChild, E as getOwnershipSignal, O as ownCleanup, _ as restoreInlineRenderTracking, a as clearCurrentComponentScope, b as attachOwnership, c as enterComponentExecutionScope, f as getCurrentComponentInstance, g as resetRenderState, n as captureInlineComponentScope, o as clearRenderTracking, p as getCurrentPortalScope, r as captureInlineRenderTracking, s as endComponentScope, t as beginRenderTracking, u as enterRenderScopedComponent, x as componentRecordPrototype, y as OwnershipRecord } from "./scope-Cq_iYbTR.js";
-import { t as adoptComponentParent } from "./capabilities-Bbf0mlp9.js";
-import { f as runCommitTransaction, g as finalizeReadableSubscriptionsFromSnapshot, i as commitTransaction, l as registerCommitParticipant, m as cleanupReadableSubscriptionSources, n as applyTransaction, o as discardTransaction, p as suspendTransaction, r as beginCommitTransaction, s as getCurrentCommitTransaction } from "./notify-DxxuDPeY.js";
-import { a as markTransparentComponentResult, i as markEagerControlPrimitive } from "./control-C-ApnFs1.js";
-import { r as STATIC_CHILDREN, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-//#region src/runtime/diagnostics/dev-namespace.ts
-/**
-* Set a value in the dev namespace (no-op in production).
-*/
-const setDevValue = () => {};
-/**
-* Increment a counter in the dev namespace (no-op in production).
-* Safely handles non-number values by resetting to 1.
-*/
-const incDevCounter = () => {};
-//#endregion
-//#region src/common/dom-range.ts
-/** Native records expose one renderer-maintained range index. Extension
-* objects remain opaque and use the renderer's external index instead. */
-const DIRECT_RANGE_OWNER = Symbol("askr.directRangeOwner");
-//#endregion
-//#region src/runtime/component/state.ts
-/** Capture generation state without rewinding the monotonic render revision. */
-function captureGenerationExecution(instance) {
-	return {
-		owner: instance.owner,
-		fn: instance.fn,
-		props: instance.props,
-		expectedStateIndices: instance.expectedStateIndices,
-		firstRenderComplete: instance.firstRenderComplete,
-		stateIndexCheck: instance.stateIndexCheck,
-		errorBoundaryState: instance.errorBoundaryState,
-		target: instance.target,
-		stateValues: instance.stateValues,
-		mountOperations: instance.mountOperations,
-		commitOperations: instance.commitOperations,
-		lifecycleSlots: instance.lifecycleSlots,
-		lifecycleGeneration: instance.lifecycleGeneration,
-		evaluationGeneration: instance.evaluationGeneration,
-		hasPendingUpdate: instance.hasPendingUpdate,
-		notifyUpdate: instance.notifyUpdate,
-		_placeholder: instance._placeholder,
-		_currentRenderToken: instance._currentRenderToken,
-		lastRenderToken: instance.lastRenderToken,
-		_pendingReadSources: instance._pendingReadSources,
-		_pendingReadSourceVersions: instance._pendingReadSourceVersions,
-		_appRenderRuntime: instance._appRenderRuntime
-	};
-}
-/** Inline execution capture excludes monotonic revision and subscription identity. */
-function captureInlineExecution(instance) {
-	return {
-		props: instance.props,
-		firstRenderComplete: instance.firstRenderComplete,
-		ownerFrame: instance.ownerFrame,
-		portalScope: instance.portalScope,
-		isRoot: instance.isRoot,
-		_vnodeParentGeneration: instance._vnodeParentGeneration,
-		_vnodeOwner: instance._vnodeOwner,
-		_vnodeParent: instance._vnodeParent,
-		_vnodeKey: instance._vnodeKey,
-		_vnodePosition: instance._vnodePosition,
-		_wrapperDepth: instance._wrapperDepth,
-		cleanupStrict: instance.cleanupStrict
-	};
-}
-function restoreInlineExecution(instance, execution, hasVNodeKey) {
-	Object.assign(instance, execution);
-	if (!hasVNodeKey) delete instance._vnodeKey;
-}
-//#endregion
-//#region src/runtime/component/inline-snapshot.ts
-function createInlineRenderSnapshot(instance) {
-	return {
-		instance,
-		mounted: instance.owner.mounted,
-		parentInstance: instance.parentInstance,
-		parentLifetime: instance.owner.parent,
-		hasVNodeKey: "_vnodeKey" in instance,
-		execution: captureInlineExecution(instance)
-	};
-}
-function restoreInlineRenderSnapshot(snapshot) {
-	restoreInlineExecution(snapshot.instance, snapshot.execution, snapshot.hasVNodeKey);
-	snapshot.instance.owner.mounted = snapshot.mounted;
-	adoptComponentParent(snapshot.instance, snapshot.parentInstance, snapshot.parentLifetime ?? null);
-}
-//#endregion
-//#region src/common/promise.ts
-function isPromiseLike(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-/**
-* Components must return synchronously; async work belongs in `resource()`.
-*
-* The rule was previously enforced by ten hand-written throws carrying three
-* different messages. It is one rule, so it has one message and one guard.
-*/
-const ASYNC_COMPONENT_MESSAGE = "Async components are not supported. Use resource() for async work.";
-function assertSyncComponentResult(result) {
-	if (isPromiseLike(result)) throw new Error(ASYNC_COMPONENT_MESSAGE);
-}
-//#endregion
-//#region src/runtime/lifecycle/settlement.ts
-const LIFECYCLE_COMMIT = {};
-var LifecycleCommit = class {
-	constructor(instance, firstMount) {
-		this.kind = LIFECYCLE_COMMIT;
-		this.prepared = false;
-		this.key = instance;
-		this.owner = instance.owner;
-		this.generation = instance.owner.identity;
-		this.firstMount = firstMount;
-	}
-	merge(parent) {
-		parent.update(this.owner, this.generation, this.firstMount);
-	}
-	update(owner, generation, firstMount) {
-		this.firstMount = this.generation === generation ? this.firstMount || firstMount : firstMount;
-		this.owner = owner;
-		this.generation = generation;
-	}
-	live() {
-		return this.key.owner === this.owner && this.owner.identity === this.generation && !this.owner.disposed;
-	}
-	publish() {
-		if (!this.live()) return;
-		if (this.firstMount) {
-			this.mounts = this.key.mountOperations;
-			this.key.mountOperations = void 0;
-		}
-		this.commits = this.key.commitOperations;
-		this.key.commitOperations = void 0;
-		this.prepared = true;
-	}
-	activate() {
-		if (this.prepared && this.live()) executeOwnedLifecycleOperations(this.key.id, this.owner, this.mounts, this.commits);
-	}
-	rollback() {
-		if (!this.live()) return;
-		if (this.firstMount) this.key.mountOperations = void 0;
-		discardCommitOperations(this.key);
-	}
-};
-function enqueueLifecycleCommitForInstance(instance, firstMount) {
-	const transaction = getCurrentCommitTransaction();
-	if (!transaction) return false;
-	const previous = transaction.participant(instance, LIFECYCLE_COMMIT);
-	if (previous) previous.update(instance.owner, instance.owner.identity, firstMount);
-	else registerCommitParticipant(new LifecycleCommit(instance, firstMount));
-	return true;
-}
-function settleLifecycleOperationResult(owner, result) {
-	if (isPromiseLike(result)) Promise.resolve(result).then((cleanup) => {
-		if (typeof cleanup === "function") {
-			if (!owner.disposed && owner.mounted) {
-				ownCleanup(owner, 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") ownCleanup(owner, result);
-}
-function discardCommitOperations(instance) {
-	instance.commitOperations = void 0;
-}
-function executeOwnedLifecycleOperations(id, owner, mounts, commits) {
-	const errors = [];
-	for (const operations of [mounts, commits]) for (const operation of operations ?? []) try {
-		settleLifecycleOperationResult(owner, operation());
-	} catch (error) {
-		errors.push(error);
-	}
-	if (errors.length > 0) throw new AggregateError(errors, `Committed lifecycle operations failed for ${id}`);
-}
-//#endregion
-//#region src/runtime/transactions/render.ts
-const READ_COMMIT = {};
-const INLINE_SNAPSHOT = {};
-var ReadCommit = class {
-	constructor(instance, token, sources, versions) {
-		this.kind = READ_COMMIT;
-		this.key = instance;
-		this.update(token, sources, versions);
-	}
-	update(token, sources, versions) {
-		this.generation = this.key.owner.identity;
-		this.token = token;
-		this.sources = sources ? new Set(sources) : void 0;
-		this.versions = versions ? new Map(versions) : void 0;
-	}
-	merge(parent) {
-		const previous = parent;
-		previous.generation = this.generation;
-		previous.token = this.token;
-		previous.sources = this.sources;
-		previous.versions = this.versions;
-	}
-	publish() {
-		const instance = this.key;
-		if (instance.owner.disposed || instance.owner.identity !== this.generation) return;
-		const { readers, sources } = this.previous = {
-			sources: instance.owner.reads,
-			token: instance.lastRenderToken,
-			readers: /* @__PURE__ */ new Map()
-		};
-		for (const source of sources ?? []) readers.set(source, source._readers?.get(instance));
-		for (const source of this.sources ?? []) if (!readers.has(source)) readers.set(source, source._readers?.get(instance));
-		finalizeReadableSubscriptionsFromSnapshot(instance, this.token, this.sources, this.versions, this.generation);
-	}
-	rollback() {
-		const instance = this.key;
-		if (!this.previous || instance.owner.disposed || instance.owner.identity !== this.generation) return;
-		instance.owner.reads = this.previous.sources;
-		instance.lastRenderToken = this.previous.token;
-		const errors = [];
-		for (const [source, entry] of this.previous.readers) try {
-			source._readers?.get(instance);
-			if (entry) (source._readers ??= /* @__PURE__ */ new Map()).set(instance, entry);
-			else if (source._readers?.delete(instance) && false);
-		} catch (error) {
-			errors.push(error);
-		}
-		if (errors.length) throw new AggregateError(errors, "Read subscription restoration failed");
-	}
-};
-var InlineSnapshot = class {
-	constructor(instance) {
-		this.kind = INLINE_SNAPSHOT;
-		this.key = instance;
-		this.generation = instance.owner.identity;
-		this.snapshot = createInlineRenderSnapshot(instance);
-		this.revision = instance.renderRevision;
-	}
-	merge(parent) {
-		parent.revision = this.revision;
-	}
-	rollback() {
-		if (!this.key.owner.disposed && this.key.owner.identity === this.generation && this.key.renderRevision === this.revision) restoreInlineRenderSnapshot(this.snapshot);
-	}
-};
-function sealInlineRenderSnapshot(instance) {
-	const snapshot = getCurrentCommitTransaction()?.participant(instance, INLINE_SNAPSHOT);
-	if (snapshot) snapshot.revision = instance.renderRevision;
-}
-function captureInlineRenderSnapshot$1(instance) {
-	const transaction = getCurrentCommitTransaction();
-	if (!transaction || transaction.participant(instance, INLINE_SNAPSHOT)) return;
-	registerCommitParticipant(new InlineSnapshot(instance));
-}
-function finalizeInlineReadSubscriptions(instance, token, sources, versions) {
-	if (!sources?.size && !instance.owner.reads?.size) return;
-	const transaction = getCurrentCommitTransaction();
-	if (!transaction) {
-		runCommitTransaction(() => registerCommitParticipant(new ReadCommit(instance, token, sources, versions)));
-		return;
-	}
-	const existing = transaction.participant(instance, READ_COMMIT);
-	if (existing) existing.update(token, sources, versions);
-	else registerCommitParticipant(new ReadCommit(instance, token, sources, versions));
-}
-//#endregion
-//#region src/runtime/diagnostics/state-diagnostics.ts
-/**
-* Report state cells that were never read during a component's completed
-* lifetime. A branch that has not rendered yet is not evidence that its state
-* is unused, so this diagnostic belongs at unmount rather than every commit.
-*/
-function warnUnusedStateReads(instance) {
-	if (!instance.owner.mounted) return;
-	const stateValues = instance.stateValues;
-	if (!stateValues?.length || isProductionEnvironment()) return;
-	for (let i = 0; i < stateValues.length; i++) {
-		const state = stateValues[i];
-		const diagnosticEligible = state?._unusedStateDiagnosticEligible;
-		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
-		if (state && diagnosticEligible !== false && !state._hasEverBeenRead && !hasCommittedUsage) {
-			const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
-			const key = `unused-state:${i}`;
-			if (warnings.has(key)) continue;
-			warnings.add(key);
-			try {
-				const name = instance.fn?.name || "<anonymous>";
-				logger.warn(`[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
-			} catch {
-				logger.warn("[askr] Unused state variable detected. State should be read during render or removed.");
-			}
-		}
-	}
-}
-//#endregion
-//#region src/runtime/component/reset.ts
-/** Pending work belongs to one generation and cannot survive its retirement. */
-function resetComponentWork(instance) {
-	instance.hasPendingUpdate = false;
-	instance.notifyUpdate = null;
-	instance.mountOperations = void 0;
-	instance.commitOperations = void 0;
-	instance.lifecycleSlots = void 0;
-	instance._pendingReadSources = void 0;
-	instance._pendingReadSourceVersions = void 0;
-	instance._placeholder = void 0;
-}
-//#endregion
-//#region src/runtime/component/cleanup.ts
-function componentDisposalPhases(owner) {
-	const instance = owner.subject;
-	const active = instance.owner === owner;
-	const hadRendererHost = Boolean(instance.target || instance._placeholder);
-	let savedScope;
-	const errors = instance.cleanupStrict ? [] : void 0;
-	const retiredScopes = active ? void 0 : owner.scopedIndex;
-	const detachReads = () => {
-		retiredScopes?.clear();
-		cleanupReadableSubscriptionSources(instance, owner.reads, owner.identity);
-	};
-	const recordError = (message, error) => {
-		if (errors) errors.push(error);
-		else if (isDevelopmentEnvironment()) logger.warn(message, error);
-	};
-	return {
-		begin() {
-			savedScope = clearCurrentComponentScope();
-			if (active) {
-				instance.lifecycleGeneration++;
-				instance.evaluationGeneration++;
-				instance.hasPendingUpdate = false;
-				instance.notifyUpdate = null;
-				warnUnusedStateReads(instance);
-			}
-		},
-		beforeCleanup: active ? void 0 : detachReads,
-		afterCleanup: active ? detachReads : void 0,
-		recordError,
-		finish() {
-			try {
-				if (active && instance.owner === owner) {
-					try {
-						if (hadRendererHost) getRuntimeCleanup().releaseComponentHost(instance);
-					} catch (error) {
-						recordError("[Askr] host release failed:", error);
-					}
-					resetComponentWork(instance);
-					instance._portalErrorParent = void 0;
-					instance._portalErrorParentGeneration = void 0;
-				}
-				if (errors?.length) throw new AggregateError(errors, `Cleanup failed for component ${instance.id}`);
-			} finally {
-				endComponentScope(savedScope);
-			}
-		}
-	};
-}
-function createComponentOwnership(instance) {
-	const owner = new OwnershipRecord();
-	owner.subject = instance;
-	owner.lifecycle = componentDisposalPhases;
-	return owner;
-}
-function bindComponentOwnership(instance) {
-	instance.owner.subject = instance;
-	instance.owner.lifecycle = componentDisposalPhases;
-}
-/** Retire the captured lifetime without swapping the execution record. */
-function cleanupComponentGeneration(_instance, owner) {
-	disposeOwnership(owner);
-}
-function cleanupComponent(instance) {
-	disposeOwnership(instance.owner);
-}
-function registerOwnedChildScope(instance, scope) {
-	ownChild(instance.owner, scope);
-}
-//#endregion
-//#region src/runtime/context/vnode.ts
-const CONTEXT_FRAME_SYMBOL = Symbol("__tempoContextFrame__");
-const vnodeContextFrames = /* @__PURE__ */ new WeakMap();
-function getVNodeContextFrame(node) {
-	if (typeof node !== "object" || node === null) return;
-	const objectNode = node;
-	return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];
-}
-function markVNodeWithContextFrame(node, frame, overwrite = false) {
-	if (typeof node !== "object" || node === null) return;
-	if (!overwrite && getVNodeContextFrame(node)) return;
-	const objectNode = node;
-	if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) try {
-		objectNode[CONTEXT_FRAME_SYMBOL] = frame;
-		return;
-	} catch {}
-	if (Object.isExtensible(node)) try {
-		Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {
-			value: frame,
-			writable: true,
-			enumerable: true,
-			configurable: true
-		});
-		return;
-	} catch {}
-	vnodeContextFrames.set(node, frame);
-}
-function isVNodeLike(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const objectValue = value;
-	if (objectValue.$$typeof === ELEMENT_TYPE) return true;
-	return "type" in objectValue && ("props" in objectValue || "children" in objectValue);
-}
-function markContextPropValue(value, frame, overwrite) {
-	if (Array.isArray(value)) {
-		for (const item of value) markContextPropValue(item, frame, overwrite);
-		return;
-	}
-	if (isVNodeLike(value)) markVNodeTreeWithContextFrame(value, frame, overwrite);
-}
-function markVNodeTreeWithContextFrame(node, frame, overwrite = false) {
-	if (!frame) return node;
-	if (Array.isArray(node)) {
-		for (const child of node) markVNodeTreeWithContextFrame(child, frame, overwrite);
-		return node;
-	}
-	if (typeof node !== "object" || node === null) return node;
-	markVNodeWithContextFrame(node, frame, overwrite);
-	const objectNode = node;
-	const props = typeof objectNode.props === "object" && objectNode.props !== null ? objectNode.props : null;
-	const children = props?.children ?? objectNode.children;
-	if (Array.isArray(children)) for (const child of children) markVNodeTreeWithContextFrame(child, frame, overwrite);
-	else if (children) markVNodeTreeWithContextFrame(children, frame, overwrite);
-	if (props) {
-		for (const key in props) if (key !== "children") markContextPropValue(props[key], frame, overwrite);
-	}
-	return node;
-}
-function isContextFrameDescendantOf(frame, ancestor) {
-	let current = frame;
-	while (current) {
-		if (current === ancestor) return true;
-		current = current.parent;
-	}
-	return false;
-}
-function rebaseContextFrame(frame, previousOwnerFrame, ownerFrame) {
-	if (isContextFrameDescendantOf(frame, ownerFrame)) return frame;
-	if (!previousOwnerFrame || !isContextFrameDescendantOf(frame, previousOwnerFrame)) return ownerFrame;
-	const nestedFrames = [];
-	let current = frame;
-	while (current && current !== previousOwnerFrame) {
-		nestedFrames.push(current);
-		current = current.parent;
-	}
-	let rebasedFrame = ownerFrame;
-	for (let index = nestedFrames.length - 1; index >= 0; index -= 1) {
-		const nestedFrame = nestedFrames[index];
-		rebasedFrame = {
-			parent: rebasedFrame,
-			values: nestedFrame.values ? new Map(nestedFrame.values) : null
-		};
-	}
-	return rebasedFrame;
-}
-/**
-* Stamp a child-scope result with its current owner while retaining frames
-* introduced by providers nested beneath that owner. Frames from an unrelated
-* or previous owner are rebased so reused vnodes cannot keep stale context.
-*/
-function rebaseVNodeTreeWithContextFrame(node, ownerFrame, previousOwnerFrame = null) {
-	if (!ownerFrame) return node;
-	if (Array.isArray(node)) {
-		for (const child of node) rebaseVNodeTreeWithContextFrame(child, ownerFrame, previousOwnerFrame);
-		return node;
-	}
-	if (typeof node !== "object" || node === null) return node;
-	const existingFrame = getVNodeContextFrame(node);
-	const inheritedFrame = existingFrame ? rebaseContextFrame(existingFrame, previousOwnerFrame, ownerFrame) : ownerFrame;
-	markVNodeWithContextFrame(node, inheritedFrame, true);
-	const inheritedPreviousFrame = existingFrame ?? previousOwnerFrame;
-	const objectNode = node;
-	const props = typeof objectNode.props === "object" && objectNode.props !== null ? objectNode.props : null;
-	const children = props?.children ?? objectNode.children;
-	if (Array.isArray(children)) for (const child of children) rebaseVNodeTreeWithContextFrame(child, inheritedFrame, inheritedPreviousFrame);
-	else if (children) rebaseVNodeTreeWithContextFrame(children, inheritedFrame, inheritedPreviousFrame);
-	if (props) {
-		for (const key in props) if (key !== "children") {
-			const value = props[key];
-			if (Array.isArray(value)) {
-				for (const item of value) if (isVNodeLike(item)) rebaseVNodeTreeWithContextFrame(item, inheritedFrame, inheritedPreviousFrame);
-			} else if (isVNodeLike(value)) rebaseVNodeTreeWithContextFrame(value, inheritedFrame, inheritedPreviousFrame);
-		}
-	}
-	return node;
-}
-//#endregion
-//#region src/runtime/context/context.ts
-const TransparentContextScopeComponent = markTransparentComponentResult(ContextScopeComponent);
-let nextScopeIdentityKey = 0;
-/** @internal Compare immutable context snapshots by provider identity and value. */
-function haveEquivalentContextFrames(left, right) {
-	let leftFrame = left;
-	let rightFrame = right;
-	while (true) {
-		while (leftFrame && !leftFrame.values?.size) leftFrame = leftFrame.parent;
-		while (rightFrame && !rightFrame.values?.size) rightFrame = rightFrame.parent;
-		if (leftFrame === rightFrame) return true;
-		if (!leftFrame || !rightFrame) return false;
-		const leftValues = leftFrame.values;
-		const rightValues = rightFrame.values;
-		if (leftValues?.size !== rightValues?.size) return false;
-		if (leftValues) {
-			if (!rightValues) return false;
-			for (const [key, value] of leftValues) if (!rightValues.has(key) || !Object.is(rightValues.get(key), value)) return false;
-		}
-		leftFrame = leftFrame.parent;
-		rightFrame = rightFrame.parent;
-	}
-}
-const ROOT_EXECUTION_FRAME = {
-	parent: null,
-	values: null
-};
-const executionFramesByParent = /* @__PURE__ */ new WeakMap();
-/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
-function getExecutionContextFrame(parent) {
-	if (!parent) return ROOT_EXECUTION_FRAME;
-	let frame = executionFramesByParent.get(parent);
-	if (!frame) {
-		frame = {
-			parent,
-			values: null
-		};
-		executionFramesByParent.set(parent, frame);
-	}
-	return frame;
-}
-let currentContextFrame = null;
-let currentAsyncResourceFrame = null;
-/**
-* Execute a function within a specific context frame.
-*
-* CORE PRIMITIVE for context restoration:
-* - Saves the current context
-* - Sets the provided frame as current
-* - Executes the function
-* - Restores the previous context in finally
-*
-* This ensures no context frame remains globally active across await.
-*/
-function withContext(frame, fn) {
-	const oldFrame = currentContextFrame;
-	currentContextFrame = frame;
-	try {
-		return fn();
-	} finally {
-		currentContextFrame = oldFrame;
-	}
-}
-/** @internal Invoke a two-argument function without allocating a wrapper. */
-function callWithContext(frame, fn, args, context) {
-	const oldFrame = currentContextFrame;
-	currentContextFrame = frame;
-	try {
-		return fn(args, context);
-	} finally {
-		currentContextFrame = oldFrame;
-	}
-}
-/**
-* Execute an async resource step within its frozen context snapshot.
-*
-* CRITICAL: This wrapper is applied only to synchronous execution steps of
-* an async resource (the initial call). We intentionally DO NOT restore
-* the resource frame for post-await continuations — continuations must not
-* observe or rely on a live resource frame. This keeps semantics simple and
-* deterministic: async resources see only their creation-time snapshot.
-*/
-function withAsyncResourceContext(frame, fn) {
-	const oldFrame = currentAsyncResourceFrame;
-	currentAsyncResourceFrame = frame;
-	try {
-		return fn();
-	} finally {
-		currentAsyncResourceFrame = oldFrame;
-	}
-}
-/** Create a new lexical {@link Scope} with `defaultValue`, readable via {@link readScope}. */
-function defineScope(defaultValue) {
-	const key = Symbol("AskrContext");
-	const identityKey = nextScopeIdentityKey++;
-	const scope = markEagerControlPrimitive((props) => ({
-		$$typeof: ELEMENT_TYPE,
-		type: TransparentContextScopeComponent,
-		props: {
-			__askrIdentityKey: identityKey,
-			__scopeKey: key,
-			value: props.value,
-			children: props.children
-		},
-		key: null
-	}));
-	return Object.assign(scope, {
-		key,
-		defaultValue
-	});
-}
-function preserveStaticChildrenMarker(source, target) {
-	if (source[STATIC_CHILDREN] === true) Object.defineProperty(target, STATIC_CHILDREN, {
-		value: true,
-		enumerable: false,
-		configurable: true
-	});
-	return target;
-}
-function isPresentRenderable(value) {
-	return value !== null && value !== void 0 && value !== false;
-}
-/** Read the current value of a {@link Scope} during component render or an async resource. */
-function readScope(context) {
-	const frame = currentContextFrame || currentAsyncResourceFrame;
-	if (!frame) throw new Error("readScope() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function.");
-	let current = frame;
-	while (current) {
-		const values = current.values;
-		if (values && values.has(context.key)) return values.get(context.key);
-		current = current.parent;
-	}
-	return context.defaultValue;
-}
-/**
-* Internal component that manages context frame
-* Used by a scope component to provide a shadowed value to its children.
-*/
-function ContextScopeComponent(props) {
-	const key = props["__scopeKey"];
-	const value = props["value"];
-	const children = props["children"];
-	const instance = getCurrentComponentInstance();
-	const newFrame = {
-		parent: (() => {
-			if (currentContextFrame) return currentContextFrame;
-			if (instance && instance.ownerFrame) return instance.ownerFrame;
-			return null;
-		})(),
-		values: /* @__PURE__ */ new Map([[key, value]])
-	};
-	function createFunctionChildInvoker(fn, frame, owner) {
-		return {
-			type: ContextFunctionChildInvoker,
-			props: {
-				fn,
-				__frame: frame,
-				__owner: owner
-			}
-		};
-	}
-	if (Array.isArray(children)) return preserveStaticChildrenMarker(children, children.map((child) => {
-		if (typeof child === "function") return createFunctionChildInvoker(child, newFrame, getCurrentComponentInstance());
-		return markWithFrame(child, newFrame);
-	}));
-	else if (typeof children === "function") return createFunctionChildInvoker(children, newFrame, getCurrentComponentInstance());
-	else if (isPresentRenderable(children)) return markWithFrame(children, newFrame);
-	return null;
-}
-/**
-* Internal: Mark a vnode with a context frame
-* The renderer will restore this frame before executing component functions
-*/
-function markWithFrame(node, frame) {
-	return markVNodeTreeWithContextFrame(node, frame, true);
-}
-/**
-* Internal helper component: executes a function-child lazily inside the
-* provided frame and marks the returned subtree with that frame so later
-* component executions will restore the correct context frame.
-*
-* SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render
-* time. Any resources created during this execution will observe this frozen
-* snapshot, ensuring deterministic behavior.
-*/
-function ContextFunctionChildInvoker(props) {
-	const { fn, __frame } = props;
-	const res = withContext(__frame, () => fn());
-	if (isPresentRenderable(res)) return markWithFrame(res, __frame);
-	return null;
-}
-/**
-* Get the current context frame for inspection (used by tests/diagnostics only)
-*/
-function getCurrentContextFrame() {
-	return currentContextFrame;
-}
-//#endregion
-//#region src/runtime/diagnostics/render-diagnostics.ts
-let renderDiagnostics = {
-	slowRenderWarnings: true,
-	slowRenderThresholdMs: 5
-};
-/**
-* Configure development render diagnostics and return a function that restores
-* the previous configuration. Component counters and timing remain enabled
-* when warning output is disabled.
-*/
-function configureRenderDiagnostics(options) {
-	if (options.slowRenderThresholdMs !== void 0 && (!Number.isFinite(options.slowRenderThresholdMs) || options.slowRenderThresholdMs < 0)) throw new TypeError("configureRenderDiagnostics slowRenderThresholdMs must be a finite, non-negative number.");
-	const previous = renderDiagnostics;
-	renderDiagnostics = {
-		slowRenderWarnings: options.slowRenderWarnings ?? previous.slowRenderWarnings,
-		slowRenderThresholdMs: options.slowRenderThresholdMs ?? previous.slowRenderThresholdMs
-	};
-	let restored = false;
-	return () => {
-		if (restored) return;
-		restored = true;
-		if (renderDiagnostics === previous) return;
-		renderDiagnostics = previous;
-	};
-}
-function shouldWarnSlowRender(renderTimeMs) {
-	return renderDiagnostics.slowRenderWarnings && renderTimeMs > renderDiagnostics.slowRenderThresholdMs;
-}
-//#endregion
-//#region src/runtime/component/lifecycle.ts
-function registerCommitOperationForInstance(instance, operation) {
-	if (instance) (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;
-	runCommitTransaction(() => enqueueLifecycleCommitForInstance(instance, wasFirstMount));
-}
-function commitRenderedComponent$1(instance) {
-	if (instance.owner.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
-}
-//#endregion
-//#region src/runtime/component/error-boundary.ts
-function createBoundaryReset(instance) {
-	return () => {
-		const boundaryState = instance.errorBoundaryState;
-		if (!boundaryState) return;
-		boundaryState.error = null;
-		boundaryState.notified = false;
-		queueMicrotask(() => {
-			instance._enqueueRun?.();
-		});
-	};
-}
-function reportBoundaryError(instance, error, onError) {
-	const boundaryState = instance.errorBoundaryState;
-	if (boundaryState && Object.is(boundaryState.error, error) && boundaryState.notified) return;
-	if (boundaryState) {
-		boundaryState.error = error;
-		boundaryState.notified = true;
-	}
-	try {
-		onError?.(error);
-	} catch (hookError) {
-		logger.error("[Askr] ErrorBoundary onError handler threw:", hookError);
-	}
-	logger.error("[Askr] ErrorBoundary caught render error:", error);
-}
-function getLivePortalErrorParent(instance) {
-	const parent = instance._portalErrorParent;
-	if (!parent || parent.owner.identity !== instance._portalErrorParentGeneration || parent.notifyUpdate === null) return null;
-	return parent;
-}
-function findLiveErrorBoundary(failedInstance) {
-	const visited = /* @__PURE__ */ new Set([failedInstance]);
-	const visit = (instance) => {
-		if (!instance || visited.has(instance)) return null;
-		visited.add(instance);
-		if (instance.errorBoundaryState && instance.notifyUpdate !== null) return instance;
-		return visit(getLivePortalErrorParent(instance)) ?? visit(instance.parentInstance);
-	};
-	return visit(getLivePortalErrorParent(failedInstance)) ?? visit(failedInstance.parentInstance);
-}
-/** Route a scheduled component failure to its nearest live render boundary. */
-function routeComponentErrorToBoundary(failedInstance, error) {
-	const boundary = findLiveErrorBoundary(failedInstance);
-	if (!boundary) return false;
-	const onError = boundary.props.onError;
-	reportBoundaryError(boundary, error, typeof onError === "function" ? onError : void 0);
-	boundary._enqueueRun?.();
-	return true;
-}
-//#endregion
-//#region src/runtime/component/commit.ts
-function runScheduledComponent(instance, execute) {
-	const owner = instance.owner;
-	const ownershipGeneration = owner.identity;
-	const evaluationGeneration = instance.evaluationGeneration;
-	const transaction = beginCommitTransaction();
-	instance.notifyUpdate = instance._enqueueRun;
-	captureInlineRenderSnapshot$1(instance);
-	beginRenderTracking(instance);
-	const token = instance._currentRenderToken;
-	const renderRevision = instance.renderRevision;
-	let result;
-	let fast = false;
-	try {
-		result = execute(instance);
-		assertSyncComponentResult(result);
-		finalizeInlineReadSubscriptions(instance, token, instance._pendingReadSources, instance._pendingReadSourceVersions);
-		fast = getRuntimeEvaluation().classifyComponentUpdate(instance, result).useFastPath;
-		if (!fast) {}
-	} catch (error) {
-		discardTransaction(transaction);
-		if (!routeComponentErrorToBoundary(instance, error)) throw error;
-		return;
-	} finally {
-		clearRenderTracking(instance);
-		suspendTransaction(transaction);
-	}
-	const apply = () => {
-		if (owner.disposed || instance.owner !== owner || owner.identity !== ownershipGeneration || instance.evaluationGeneration !== evaluationGeneration || instance.renderRevision !== renderRevision) {
-			discardTransaction(transaction);
-			return;
-		}
-		try {
-			transaction.setDeferredNotifications(fast);
-			if (applyTransaction(transaction, () => {
-				const wasFirstMount = !owner.mounted;
-				if (!getRuntimeEvaluation().applyComponentResult(instance, result, fast ? "keyed-reorder" : "ordinary")) return false;
-				owner.mounted = true;
-				commitLifecycleForInstance(instance, wasFirstMount);
-				return true;
-			})) commitTransaction(transaction);
-			else discardTransaction(transaction);
-		} catch (error) {
-			discardTransaction(transaction);
-			if (!routeComponentErrorToBoundary(instance, error)) throw error;
-		} finally {
-			suspendTransaction(transaction);
-		}
-	};
-	if (fast) runRuntimeWithSyncProgress(apply);
-	else enqueueRuntimeTask(apply);
-}
-//#endregion
-//#region src/runtime/component/instance.ts
-/**
-* Component instance lifecycle management
-* Internal only — users never see this
-*/
-Object.defineProperty(componentRecordPrototype, DIRECT_RANGE_OWNER, { value: true });
-const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
-function ensurePendingRunTask(instance) {
-	const existing = instance._pendingRunTask;
-	if (existing) return existing;
-	const task = () => {
-		if (!instance.hasPendingUpdate) return;
-		instance.hasPendingUpdate = false;
-		if (instance.notifyUpdate === null) return;
-		runScheduledComponent(instance, executeComponentSync);
-	};
-	instance._pendingRunTask = task;
-	if (!instance._pendingFlushTask) instance._pendingFlushTask = task;
-	return task;
-}
-function enqueueComponentRun() {
-	if (this.owner.disposed || this.hasPendingUpdate) return;
-	this.hasPendingUpdate = true;
-	enqueueRuntimeTask(ensurePendingRunTask(this));
-}
-var ComponentExecutionContext = class {
-	constructor(owner) {
-		this.owner = owner;
-	}
-	get signal() {
-		return getOwnershipSignal(this.owner);
-	}
-};
-function createComponentInstance(id, fn, props, target, lifetimeParent) {
-	const parentInstance = getCurrentComponentInstance();
-	const portalScope = parentInstance?.portalScope ?? getCurrentPortalScope();
-	const instance = {
-		__proto__: componentRecordPrototype,
-		id,
-		fn,
-		props,
-		target,
-		range: void 0,
-		parentInstance,
-		portalScope: portalScope ?? null,
-		owner: new OwnershipRecord(),
-		stateValues: void 0,
-		evaluationGeneration: 0,
-		renderRevision: 0,
-		notifyUpdate: null,
-		_pendingFlushTask: void 0,
-		_pendingRunTask: void 0,
-		_enqueueRun: void 0,
-		stateIndexCheck: -1,
-		expectedStateIndices: void 0,
-		firstRenderComplete: false,
-		mountOperations: void 0,
-		commitOperations: void 0,
-		lifecycleSlots: void 0,
-		lifecycleGeneration: 0,
-		hasPendingUpdate: false,
-		ownerFrame: null,
-		ssr: false,
-		cleanupStrict: false,
-		isRoot: false,
-		_currentRenderToken: void 0,
-		lastRenderToken: 0,
-		_pendingReadSources: void 0,
-		_pendingReadSourceVersions: void 0,
-		devWarningsEmitted: void 0,
-		_portalErrorParent: void 0,
-		_portalErrorParentGeneration: void 0
-	};
-	instance._enqueueRun = enqueueComponentRun;
-	bindComponentOwnership(instance);
-	attachOwnership(instance.owner, lifetimeParent === null ? void 0 : lifetimeParent ?? parentInstance?.owner);
-	return instance;
-}
-/**
-* 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 captureInlineRenderSnapshot(instance) {
-	captureInlineRenderSnapshot$1(instance);
-}
-function registerCommitOperation(operation) {
-	registerCommitOperationForInstance(getCurrentComponentInstance(), operation);
-}
-function commitRenderedComponent(instance) {
-	commitRenderedComponent$1(instance);
-}
-function mountInstanceInline(instance, target) {
-	getRuntimeEvaluation().recordInlineComponentHost(instance, target);
-	instance.notifyUpdate = instance._enqueueRun;
-	const wasFirstMount = !instance.owner.mounted;
-	instance.owner.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.
-*/
-function renderScopedComponent(instance, startStateIndex, render) {
-	instance.notifyUpdate = instance._enqueueRun;
-	resetRenderState(instance);
-	beginRenderTracking(instance);
-	const savedScope = enterRenderScopedComponent(instance, startStateIndex);
-	let didComplete = false;
-	try {
-		const result = withContext(getExecutionContextFrame(instance.ownerFrame), render);
-		didComplete = true;
-		return result;
-	} finally {
-		sealInlineRenderSnapshot(instance);
-		if (!didComplete) clearRenderTracking(instance);
-		endComponentScope(savedScope);
-	}
-}
-/**
-* Execute a component's render function synchronously.
-* Returns either a vnode/promise immediately (does NOT render).
-* Rendering happens separately through the scheduled commit helper.
-*/
-function renderComponentInline(instance) {
-	instance.notifyUpdate = instance._enqueueRun;
-	const trackingSnapshot = captureInlineRenderTracking(instance);
-	const scopeSnapshot = captureInlineComponentScope();
-	const hadToken = trackingSnapshot.currentRenderToken !== void 0;
-	if (!hadToken) beginRenderTracking(instance);
-	try {
-		const result = executeComponentSync(instance);
-		if (!hadToken) instance.hasPendingUpdate = false;
-		if (!hadToken) finalizeInlineReadSubscriptions(instance, instance._currentRenderToken, instance._pendingReadSources, instance._pendingReadSourceVersions);
-		commitRenderedComponent(instance);
-		return result;
-	} finally {
-		restoreInlineRenderTracking(instance, trackingSnapshot);
-		endComponentScope(scopeSnapshot);
-	}
-}
-function executeComponentSync(instance) {
-	resetRenderState(instance);
-	const savedPortalScope = enterComponentExecutionScope(instance);
-	let didComplete = false;
-	try {
-		const trackRenderTime = !PRODUCTION_BUILD_ENABLED && isDevelopmentEnvironment();
-		const renderStartTime = trackRenderTime ? Date.now() : 0;
-		const context = new ComponentExecutionContext(instance.owner);
-		const result = callWithContext(getExecutionContextFrame(instance.ownerFrame), instance.fn, instance.props, context);
-		if (trackRenderTime) {
-			const renderTime = Date.now() - renderStartTime;
-			if (shouldWarnSlowRender(renderTime)) warnInstanceOnce(instance, "slow-render", `[askr] Slow render detected in ${instance.fn?.name || "<anonymous>"}: ${renderTime}ms. Consider optimizing component performance.`);
-		}
-		if (!instance.firstRenderComplete) instance.firstRenderComplete = true;
-		didComplete = true;
-		return result;
-	} finally {
-		sealInlineRenderSnapshot(instance);
-		if (!didComplete) discardCommitOperations(instance);
-		endComponentScope(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.notifyUpdate = instance._enqueueRun;
-	instance.hasPendingUpdate = true;
-	enqueueRuntimeTask(ensurePendingRunTask(instance));
-}
-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
-export { captureInlineRenderSnapshot$1 as A, rebaseVNodeTreeWithContextFrame as C, createComponentOwnership as D, cleanupComponentGeneration as E, captureGenerationExecution as F, DIRECT_RANGE_OWNER as I, incDevCounter as L, ASYNC_COMPONENT_MESSAGE as M, assertSyncComponentResult as N, registerOwnedChildScope as O, isPromiseLike as P, setDevValue as R, markVNodeTreeWithContextFrame as S, cleanupComponent as T, haveEquivalentContextFrames as _, registerCommitOperation as a, withContext as b, createBoundaryReset as c, registerCommitOperationForInstance as d, configureRenderDiagnostics as f, getExecutionContextFrame as g, getCurrentContextFrame as h, mountInstanceInline as i, finalizeInlineReadSubscriptions as j, resetComponentWork as k, reportBoundaryError as l, defineScope as m, createComponentInstance as n, renderComponentInline as o, callWithContext as p, executeComponent as r, renderScopedComponent as s, captureInlineRenderSnapshot as t, routeComponentErrorToBoundary as u, readScope as v, bindComponentOwnership as w, getVNodeContextFrame as x, withAsyncResourceContext as y };