@askrjs/askr 0.2.4 → 0.3.0

package/dist/{component-internal-C4hKKQBF.js → instance-VAFYVJOa.js}

@@ -1,51 +1,386 @@
+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 { S as isProductionEnvironment, n as enqueueRuntimeTask, o as getRuntimeRenderer, x as isDevelopmentEnvironment, y as logger } from "./access-BucjYZcX.js";
-import { i as tryRuntimeFastLaneSync, n as isBulkCommitActive } from "./fastlane-BKZduiBQ.js";
-import { C as restoreRenderScopedComponent, S as restoreInlineRenderTracking, _ as getSignalForInstance, b as restoreDomCommitScope, c as enterDomCommitScope, f as getCurrentComponentInstance, l as enterRenderScopedComponent, m as getCurrentPortalScope, n as captureInlineComponentScope, o as clearRenderTracking, p as getCurrentInstance, r as captureInlineRenderTracking, s as enterComponentExecutionScope, t as beginRenderTracking, u as exitComponentExecutionScope, v as resetRenderState, x as restoreInlineComponentScope } from "./component-scope-4I3yEMkb.js";
 import { r as STATIC_CHILDREN, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-import { i as finalizeReadableSubscriptions } from "./readable-Di1fzSwm.js";
-import { a as enqueueLifecycleCommitForInstance, d as discardCommitOperations, f as executeCommittedLifecycleOperations, n as captureInlineRenderSnapshot$1, o as finalizeInlineReadSubscriptions, p as isPromiseLike, r as discardLifecycleCommitBatch, s as flushLifecycleCommitBatch, t as beginLifecycleCommitBatch } from "./lifecycle-batch-63aXFf2S.js";
-//#region src/runtime/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;
+//#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;
 		}
-		leftFrame = leftFrame.parent;
-		rightFrame = rightFrame.parent;
+		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);
 	}
-}
-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
+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()
 		};
-		executionFramesByParent.set(parent, frame);
+		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);
 	}
-	return frame;
+	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) {
@@ -161,6 +496,48 @@ function rebaseVNodeTreeWithContextFrame(node, ownerFrame, previousOwnerFrame =
 	}
 	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;
 /**
@@ -318,7 +695,7 @@ function getCurrentContextFrame() {
 	return currentContextFrame;
 }
 //#endregion
-//#region src/runtime/render-diagnostics.ts
+//#region src/runtime/diagnostics/render-diagnostics.ts
 let renderDiagnostics = {
 	slowRenderWarnings: true,
 	slowRenderThresholdMs: 5
@@ -347,26 +724,20 @@ function shouldWarnSlowRender(renderTimeMs) {
 	return renderDiagnostics.slowRenderWarnings && renderTimeMs > renderDiagnostics.slowRenderThresholdMs;
 }
 //#endregion
-//#region src/runtime/component-lifecycle.ts
+//#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);
-	}
+	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;
-	executeCommittedLifecycleOperations(instance, wasFirstMount);
+	runCommitTransaction(() => enqueueLifecycleCommitForInstance(instance, wasFirstMount));
 }
 function commitRenderedComponent$1(instance) {
-	if (instance.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
+	if (instance.owner.mounted && (instance.commitOperations?.length ?? 0) > 0) commitLifecycleForInstance(instance, false);
 }
 //#endregion
-//#region src/runtime/error-boundary.ts
+//#region src/runtime/component/error-boundary.ts
 function createBoundaryReset(instance) {
 	return () => {
 		const boundaryState = instance.errorBoundaryState;
@@ -394,7 +765,7 @@ function reportBoundaryError(instance, error, onError) {
 }
 function getLivePortalErrorParent(instance) {
 	const parent = instance._portalErrorParent;
-	if (!parent || parent._ownershipGeneration !== instance._portalErrorParentGeneration || parent.notifyUpdate === null) return null;
+	if (!parent || parent.owner.identity !== instance._portalErrorParentGeneration || parent.notifyUpdate === null) return null;
 	return parent;
 }
 function findLiveErrorBoundary(failedInstance) {
@@ -417,189 +788,65 @@ function routeComponentErrorToBoundary(failedInstance, error) {
 	return true;
 }
 //#endregion
-//#region src/runtime/component-commit.ts
-function runScheduledComponent(instance, host) {
-	const ownershipGeneration = instance._ownershipGeneration;
+//#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 = host.execute(instance);
-	} catch (err) {
-		discardCommitOperations(instance);
-		if (routeComponentErrorToBoundary(instance, err)) return;
-		throw err;
-	}
-	if (isPromiseLike(result)) {
-		const error = /* @__PURE__ */ new Error("Async components are not supported. Components must be synchronous.");
-		discardCommitOperations(instance);
-		if (routeComponentErrorToBoundary(instance, error)) return;
-		throw error;
-	}
-	try {
-		if (tryRuntimeFastLaneSync(instance, result)) return;
-	} catch (err) {
-		if (routeComponentErrorToBoundary(instance, err)) return;
-		if (isDevelopmentEnvironment()) throw err;
-	}
-	enqueueRuntimeTask(() => {
-		try {
-			if (instance._ownershipGeneration !== ownershipGeneration || instance.evaluationGeneration !== evaluationGeneration) return;
-			if (!instance.target && instance._placeholder) {
-				commitPlaceholderReplacement(instance, result, host);
-				return;
-			}
-			if (instance.target) commitToTarget(instance, result, host);
-		} catch (err) {
-			if (!routeComponentErrorToBoundary(instance, err)) throw err;
-		}
-	});
-}
-function commitPlaceholderReplacement(instance, result, host) {
-	if (result === null || result === void 0) {
-		const placeholder = instance._placeholder;
-		if (placeholder) {
-			const replacement = getRuntimeRenderer().replaceComponentRange(instance, result, placeholder);
-			if (replacement) {
-				instance.target = replacement instanceof Element ? replacement : null;
-				instance._placeholder = replacement instanceof Comment ? replacement : void 0;
-			}
-		}
-		host.finalizeReadSubscriptions(instance);
-		host.commitRenderedComponent(instance);
-		return;
-	}
-	const placeholder = instance._placeholder;
-	const parent = placeholder.parentNode;
-	if (!parent) {
-		logger.warn("[Askr] placeholder no longer in DOM, cannot render component");
+		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;
-	}
-	const renderer = getRuntimeRenderer();
-	const rangeReplacement = renderer.replaceComponentRange(instance, result, placeholder);
-	if (rangeReplacement) {
-		if (rangeReplacement instanceof Element) {
-			instance.target = rangeReplacement;
-			instance._placeholder = void 0;
-		} else {
-			instance.target = null;
-			instance._placeholder = rangeReplacement;
-		}
-		host.finalizeReadSubscriptions(instance);
-		host.commitRenderedComponent(instance);
-		return;
-	}
-	const hostElement = document.createElement("div");
-	const executionFrame = getExecutionContextFrame(instance.ownerFrame);
-	const oldInstance = enterDomCommitScope(instance);
-	const lifecycleBatch = beginLifecycleCommitBatch();
-	try {
-		try {
-			withContext(executionFrame, () => {
-				renderer.evaluate(result, hostElement);
-			});
-			const onlyChild = hostElement.childNodes.length === 1 ? hostElement.firstChild : null;
-			const replacement = onlyChild instanceof Element || onlyChild instanceof Comment ? onlyChild : hostElement;
-			if (replacement === hostElement) hostElement.__ASKR_WRAPPER_HOST = true;
-			parent.replaceChild(replacement, placeholder);
-			instance.target = replacement instanceof Element ? replacement : null;
-			instance._placeholder = replacement instanceof Comment ? replacement : void 0;
-			const instanceHost = replacement;
-			const instances = instanceHost.__ASKR_INSTANCES ?? [];
-			if (!instances.includes(instance)) instances.push(instance);
-			instanceHost.__ASKR_INSTANCES = instances;
-			instanceHost.__ASKR_INSTANCE = instances[0] ?? instance;
-		} catch (err) {
-			discardLifecycleCommitBatch(lifecycleBatch);
-			throw err;
-		}
-		host.finalizeReadSubscriptions(instance);
-		host.commitRenderedComponent(instance);
-		flushLifecycleCommitBatch(lifecycleBatch);
 	} finally {
-		restoreDomCommitScope(oldInstance);
+		clearRenderTracking(instance);
+		suspendTransaction(transaction);
 	}
-}
-function commitToTarget(instance, result, host) {
-	const renderer = getRuntimeRenderer();
-	const target = instance.target;
-	let oldChildren = [];
-	let restoredOldChildren = false;
-	try {
-		const wasFirstMount = !instance.mounted;
-		const oldInstance = enterDomCommitScope(instance);
-		const executionFrame = getExecutionContextFrame(instance.ownerFrame);
-		oldChildren = Array.from(target.childNodes);
-		const lifecycleBatch = beginLifecycleCommitBatch();
-		try {
-			try {
-				withContext(executionFrame, () => {
-					if (!renderer.replaceComponentRange(instance, result, target)) renderer.evaluate(result, target, void 0, instance);
-				});
-			} catch (err) {
-				discardLifecycleCommitBatch(lifecycleBatch);
-				throw err;
-			}
-		} catch (err) {
-			cleanupFailedCommitChildren(renderer, target, oldChildren);
-			try {
-				(/* @__PURE__ */ new Error()).stack;
-			} catch (devErr) {}
-			target.replaceChildren(...oldChildren);
-			restoredOldChildren = true;
-			throw err;
-		} finally {
-			restoreDomCommitScope(oldInstance);
+	const apply = () => {
+		if (owner.disposed || instance.owner !== owner || owner.identity !== ownershipGeneration || instance.evaluationGeneration !== evaluationGeneration || instance.renderRevision !== renderRevision) {
+			discardTransaction(transaction);
+			return;
 		}
-		host.finalizeReadSubscriptions(instance);
-		instance.mounted = true;
-		commitLifecycleForInstance(instance, wasFirstMount);
-		flushLifecycleCommitBatch(lifecycleBatch);
-	} catch (renderError) {
-		discardCommitOperations(instance);
-		cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);
-		const rollbackErrors = [];
 		try {
-			(/* @__PURE__ */ new Error()).stack;
-			target.replaceChildren(...oldChildren);
-		} catch (rollbackError) {
-			rollbackErrors.push(rollbackError);
-		}
-		if (rollbackErrors.length > 0) logger.error("[Askr] component rollback failed after render error:", new AggregateError(rollbackErrors, "Component rollback failed"));
-		throw renderError;
-	}
-}
-function cleanupFailedCommitChildren(renderer, target, oldChildren) {
-	try {
-		const newChildren = Array.from(target.childNodes);
-		const preservedChildren = new Set(oldChildren);
-		for (const node of newChildren) {
-			if (preservedChildren.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up failed commit children:", err);
-			}
-		}
-	} catch (err) {}
-}
-function cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren) {
-	try {
-		const currentChildren = Array.from(target.childNodes);
-		const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;
-		for (const node of currentChildren) {
-			if (preservedChildren?.has(node)) continue;
-			try {
-				renderer.cleanupInstancesUnder(node);
-			} catch (err) {
-				logger.warn("[Askr] error cleaning up partial children during rollback:", err);
-			}
+			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);
 		}
-	} catch (err) {}
+	};
+	if (fast) runRuntimeWithSyncProgress(apply);
+	else enqueueRuntimeTask(apply);
 }
 //#endregion
-//#region src/runtime/component-internal.ts
+//#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;
@@ -608,42 +855,41 @@ function ensurePendingRunTask(instance) {
 		if (!instance.hasPendingUpdate) return;
 		instance.hasPendingUpdate = false;
 		if (instance.notifyUpdate === null) return;
-		runScheduledComponent(instance, {
-			execute: executeComponentSync,
-			finalizeReadSubscriptions,
-			commitRenderedComponent
-		});
+		runScheduledComponent(instance, executeComponentSync);
 	};
 	instance._pendingRunTask = task;
 	if (!instance._pendingFlushTask) instance._pendingFlushTask = task;
 	return task;
 }
 function enqueueComponentRun() {
-	if (this.hasPendingUpdate) return;
+	if (this.owner.disposed || this.hasPendingUpdate) return;
 	this.hasPendingUpdate = true;
 	enqueueRuntimeTask(ensurePendingRunTask(this));
 }
 var ComponentExecutionContext = class {
-	constructor(instance) {
-		this.instance = instance;
+	constructor(owner) {
+		this.owner = owner;
 	}
 	get signal() {
-		return getSignalForInstance(this.instance);
+		return getOwnershipSignal(this.owner);
 	}
 };
-function createComponentInstance(id, fn, props, target) {
-	const parentInstance = getCurrentInstance();
+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: parentInstance?.portalScope ?? getCurrentPortalScope() ?? null,
-		mounted: false,
-		abortController: null,
+		portalScope: portalScope ?? null,
+		owner: new OwnershipRecord(),
 		stateValues: void 0,
 		evaluationGeneration: 0,
+		renderRevision: 0,
 		notifyUpdate: null,
 		_pendingFlushTask: void 0,
 		_pendingRunTask: void 0,
@@ -659,18 +905,18 @@ function createComponentInstance(id, fn, props, target) {
 		ownerFrame: null,
 		ssr: false,
 		cleanupStrict: false,
-		_ownershipGeneration: {},
 		isRoot: false,
 		_currentRenderToken: void 0,
 		lastRenderToken: 0,
 		_pendingReadSources: void 0,
 		_pendingReadSourceVersions: void 0,
-		_lastReadSources: 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;
 }
 /**
@@ -687,34 +933,10 @@ function commitRenderedComponent(instance) {
 	commitRenderedComponent$1(instance);
 }
 function mountInstanceInline(instance, target) {
-	instance.target = target;
-	try {
-		if (typeof Element !== "undefined" && target instanceof Element) {
-			const host = target;
-			const instances = host.__ASKR_INSTANCES;
-			if (!instances) {
-				host.__ASKR_INSTANCES = [instance];
-				host.__ASKR_INSTANCE = instance;
-			} else if (instances[instances.length - 1] !== instance) {
-				const nextInstances = instances.indexOf(instance) === -1 ? instances.slice() : instances.filter((entry) => entry !== instance);
-				nextInstances.push(instance);
-				host.__ASKR_INSTANCES = nextInstances;
-				host.__ASKR_INSTANCE = nextInstances[0] ?? instance;
-			}
-		}
-	} catch (err) {
-		if (isDevelopmentEnvironment()) {
-			const componentName = instance.fn.name || instance.id;
-			let hostName = "unknown";
-			try {
-				hostName = target?.tagName?.toLowerCase() || hostName;
-			} catch {}
-			logger.warn(`[askr] Failed to record DOM ownership for ${componentName} on <${hostName}>.`, err);
-		}
-	}
+	getRuntimeEvaluation().recordInlineComponentHost(instance, target);
 	instance.notifyUpdate = instance._enqueueRun;
-	const wasFirstMount = !instance.mounted;
-	instance.mounted = true;
+	const wasFirstMount = !instance.owner.mounted;
+	instance.owner.mounted = true;
 	commitLifecycleForInstance(instance, wasFirstMount);
 }
 /**
@@ -735,8 +957,9 @@ function renderScopedComponent(instance, startStateIndex, render) {
 		didComplete = true;
 		return result;
 	} finally {
+		sealInlineRenderSnapshot(instance);
 		if (!didComplete) clearRenderTracking(instance);
-		restoreRenderScopedComponent(savedScope);
+		endComponentScope(savedScope);
 	}
 }
 /**
@@ -758,7 +981,7 @@ function renderComponentInline(instance) {
 		return result;
 	} finally {
 		restoreInlineRenderTracking(instance, trackingSnapshot);
-		restoreInlineComponentScope(scopeSnapshot);
+		endComponentScope(scopeSnapshot);
 	}
 }
 function executeComponentSync(instance) {
@@ -768,7 +991,7 @@ function executeComponentSync(instance) {
 	try {
 		const trackRenderTime = !PRODUCTION_BUILD_ENABLED && isDevelopmentEnvironment();
 		const renderStartTime = trackRenderTime ? Date.now() : 0;
-		const context = new ComponentExecutionContext(instance);
+		const context = new ComponentExecutionContext(instance.owner);
 		const result = callWithContext(getExecutionContextFrame(instance.ownerFrame), instance.fn, instance.props, context);
 		if (trackRenderTime) {
 			const renderTime = Date.now() - renderStartTime;
@@ -778,8 +1001,9 @@ function executeComponentSync(instance) {
 		didComplete = true;
 		return result;
 	} finally {
+		sealInlineRenderSnapshot(instance);
 		if (!didComplete) discardCommitOperations(instance);
-		exitComponentExecutionScope(savedPortalScope);
+		endComponentScope(savedPortalScope);
 	}
 }
 /**
@@ -788,22 +1012,10 @@ function executeComponentSync(instance) {
 * Single entry point to avoid lifecycle divergence.
 */
 function executeComponent(instance) {
-	instance.abortController = null;
 	instance.notifyUpdate = instance._enqueueRun;
 	instance.hasPendingUpdate = true;
 	enqueueRuntimeTask(ensurePendingRunTask(instance));
 }
-/**
-* 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 warnInstanceOnce(instance, key, message) {
 	if (isProductionEnvironment()) return;
 	const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
@@ -812,4 +1024,4 @@ function warnInstanceOnce(instance, key, message) {
 	logger.warn(message);
 }
 //#endregion
-export { withContext as C, withAsyncResourceContext as S, getVNodeContextFrame as _, registerCommitOperation as a, readScope as b, createBoundaryReset as c, registerCommitOperationForInstance as d, configureRenderDiagnostics as f, getExecutionContextFrame as g, getCurrentContextFrame as h, mountInstanceInline as i, 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, haveEquivalentContextFrames as v, rebaseVNodeTreeWithContextFrame as x, markVNodeTreeWithContextFrame as y };
+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 };