@askrjs/askr 0.0.50 → 0.0.52

package/dist/runtime/child-scope.js

@@ -1,10 +1,77 @@
 import { _isDOMElement } from "../common/vnode.js";
 import { isDevelopmentEnvironment } from "../common/env.js";
-import { getCurrentStateIndex } from "./component-scope.js";
+import { clearRenderTracking, getCurrentInstance, getCurrentStateIndex } from "./component-scope.js";
 import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { createComponentInstance, finalizeReadSubscriptions, renderScopedComponent } from "./component-internal.js";
+import { finalizeInlineReadSubscriptions } from "./lifecycle-batch.js";
+import "./component-lifecycle.js";
+import { createComponentInstance, renderScopedComponent } from "./component-internal.js";
 import "./component.js";
-//#region src/runtime/child-scope.ts
+const EMPTY_CHILD_SCOPE_PROPS = {};
+const childScopesByInstance = /* @__PURE__ */ new WeakMap();
+function executeChildScopeComponent() {
+	const instance = getCurrentInstance();
+	const scope = instance ? childScopesByInstance.get(instance) : void 0;
+	if (!scope?._renderFn) return null;
+	return scope._renderFn();
+}
+function ensureChildScopeFlushTask(scope) {
+	const instance = scope.componentInstance;
+	if (instance._pendingFlushTask) return;
+	instance._pendingFlushTask = () => {
+		instance.hasPendingUpdate = false;
+		if (instance.notifyUpdate === null || scope._disposed) return;
+		renderScope(scope);
+		scope._onDirty?.();
+	};
+}
+var ChildScopeImpl = class {
+	constructor(parent, key, onDirty) {
+		this.previousVnode = void 0;
+		this.vnode = void 0;
+		this.dom = void 0;
+		this.range = void 0;
+		this.needsDomUpdate = true;
+		this.hydrationPending = true;
+		this.blueprintOwner = void 0;
+		this._renderFn = void 0;
+		this._disposed = false;
+		this.key = key;
+		this._parent = parent;
+		this._onDirty = onDirty;
+		this._startStateIndex = getCurrentStateIndex();
+		this.componentInstance = createComponentInstance("child-scope", executeChildScopeComponent, EMPTY_CHILD_SCOPE_PROPS, null);
+		childScopesByInstance.set(this.componentInstance, this);
+		if (parent) {
+			this.componentInstance.parentInstance = parent;
+			this.componentInstance.ownerFrame = parent.ownerFrame;
+			this.componentInstance.portalScope = parent.portalScope;
+			registerOwnedChildScope(parent, this);
+		}
+	}
+	markDirty() {
+		this.needsDomUpdate = true;
+	}
+	render(renderFn) {
+		this._renderFn = renderFn;
+		return renderScope(this);
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		if (this._parent) unregisterOwnedChildScope(this._parent, this);
+		childScopesByInstance.delete(this.componentInstance);
+		cleanupComponent(this.componentInstance);
+		this._renderFn = void 0;
+		this.previousVnode = void 0;
+		this.vnode = void 0;
+		this.dom = void 0;
+		this.range = void 0;
+		this.needsDomUpdate = false;
+		this.hydrationPending = false;
+		this.blueprintOwner = void 0;
+		this.componentInstance.hasPendingUpdate = false;
+	}
+};
 function renderScope(scope) {
 	if (scope._disposed) {
 		if (isDevelopmentEnvironment()) throw new Error(`[askr] Attempted to render disposed child scope ${String(scope.key)}.`);
@@ -19,7 +86,9 @@ function renderScope(scope) {
 		scope.previousVnode = previousVNode;
 		scope.vnode = nextVNode;
 		scope.markDirty();
-		finalizeReadSubscriptions(componentInstance);
+		if ((componentInstance._pendingReadSources?.size ?? 0) > 0) ensureChildScopeFlushTask(scope);
+		finalizeInlineReadSubscriptions(componentInstance, componentInstance._currentRenderToken, componentInstance._pendingReadSources, componentInstance._pendingReadSourceVersions);
+		clearRenderTracking(componentInstance);
 		return scope.vnode;
 	} catch (error) {
 		componentInstance.hasPendingUpdate = false;
@@ -29,59 +98,37 @@ function renderScope(scope) {
 function rerenderChildScope(scope) {
 	return renderScope(scope);
 }
+/** @internal */
+function captureChildScopeTransactionSnapshot(scope) {
+	const mutableScope = scope;
+	return {
+		previousVnode: scope.previousVnode,
+		vnode: scope.vnode,
+		dom: scope.dom,
+		range: scope.range,
+		domTextData: scope.dom?.nodeType === 3 ? scope.dom.data : void 0,
+		needsDomUpdate: scope.needsDomUpdate,
+		hydrationPending: scope.hydrationPending,
+		renderFn: mutableScope._renderFn
+	};
+}
+/** @internal */
+function restoreChildScopeTransactionSnapshot(scope, snapshot) {
+	const mutableScope = scope;
+	scope.previousVnode = snapshot.previousVnode;
+	scope.vnode = snapshot.vnode;
+	scope.dom = snapshot.dom;
+	scope.range = snapshot.range;
+	if (snapshot.domTextData !== void 0 && snapshot.dom?.nodeType === 3) snapshot.dom.data = snapshot.domTextData;
+	scope.needsDomUpdate = snapshot.needsDomUpdate;
+	scope.hydrationPending = snapshot.hydrationPending;
+	mutableScope._renderFn = snapshot.renderFn;
+}
 function disposeChildScope(scope) {
 	scope.dispose();
 }
 function createChildScope(parent, key, onDirty) {
-	const scope = {};
-	const componentInstance = createComponentInstance(`child-scope-${String(key)}`, () => scope._renderFn?.() ?? null, {}, null);
-	if (parent) {
-		componentInstance.parentInstance = parent;
-		componentInstance.ownerFrame = parent.ownerFrame;
-		componentInstance.portalScope = parent.portalScope;
-	}
-	scope.key = key;
-	scope.componentInstance = componentInstance;
-	scope.previousVnode = void 0;
-	scope.vnode = void 0;
-	scope.dom = void 0;
-	scope.needsDomUpdate = true;
-	scope.hydrationPending = true;
-	scope._startStateIndex = getCurrentStateIndex();
-	scope._renderFn = void 0;
-	scope._onDirty = onDirty;
-	scope._parent = parent;
-	scope._disposed = false;
-	scope.markDirty = () => {
-		scope.needsDomUpdate = true;
-	};
-	scope.render = (renderFn) => {
-		scope._renderFn = renderFn;
-		return renderScope(scope);
-	};
-	scope.dispose = () => {
-		if (scope._disposed) return;
-		scope._disposed = true;
-		if (scope._parent) unregisterOwnedChildScope(scope._parent, scope);
-		cleanupComponent(componentInstance);
-		scope._renderFn = void 0;
-		scope.previousVnode = void 0;
-		scope.vnode = void 0;
-		scope.dom = void 0;
-		scope.needsDomUpdate = false;
-		scope.hydrationPending = false;
-		componentInstance.hasPendingUpdate = false;
-	};
-	componentInstance._pendingFlushTask = () => {
-		componentInstance.hasPendingUpdate = false;
-		if (componentInstance.notifyUpdate === null || scope._disposed) return;
-		renderScope(scope);
-		scope._onDirty?.();
-	};
-	if (parent) registerOwnedChildScope(parent, scope);
-	return scope;
+	return new ChildScopeImpl(parent, key, onDirty);
 }
 //#endregion
-export { createChildScope, disposeChildScope, rerenderChildScope };
-
-//# sourceMappingURL=child-scope.js.map
+export { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope, rerenderChildScope, restoreChildScopeTransactionSnapshot };

package/dist/runtime/component-cleanup.d.ts

@@ -12,5 +12,4 @@ declare function cleanupComponent(instance: ComponentInstance): void;
 declare function registerOwnedChildScope(instance: ComponentInstance, scope: OwnedChildScope): void;
 declare function unregisterOwnedChildScope(instance: ComponentInstance, scope: OwnedChildScope): void;
 //#endregion
-export { OwnedChildScope, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };
-//# sourceMappingURL=component-cleanup.d.ts.map
+export { OwnedChildScope, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };

package/dist/runtime/component-cleanup.js

@@ -1,5 +1,5 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { cleanupReadableSubscriptions } from "./readable.js";
 import { clearCurrentComponentScope, restoreCurrentComponentScope } from "./component-scope.js";
 //#region src/runtime/component-cleanup.ts
@@ -26,7 +26,7 @@ function cleanupComponent(instance) {
 				recordCleanupError("[Askr] child scope cleanup threw:", err);
 			}
 		}
-		const cleanupFns = instance.cleanupFns;
+		const cleanupFns = instance.cleanupFns ?? [];
 		instance.cleanupFns = [];
 		for (const cleanup of cleanupFns) try {
 			cleanup();
@@ -48,7 +48,7 @@ function cleanupComponent(instance) {
 		instance.evaluationGeneration++;
 		instance.mountOperations = [];
 		instance.commitOperations = [];
-		instance.lifecycleSlots = [];
+		instance.lifecycleSlots = void 0;
 		instance.hasPendingUpdate = false;
 		instance.notifyUpdate = null;
 		instance._placeholder = void 0;
@@ -66,5 +66,3 @@ function unregisterOwnedChildScope(instance, scope) {
 }
 //#endregion
 export { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };
-
-//# sourceMappingURL=component-cleanup.js.map

package/dist/runtime/component-commit.js

@@ -1,17 +1,18 @@
 import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { enqueueRuntimeTask, getRuntimeRenderer } from "./access.js";
-import { withContext } from "./context.js";
+import { getExecutionContextFrame, withContext } from "./context.js";
 import { incDevCounter, setDevValue } from "./dev-namespace.js";
 import { beginRenderTracking, enterDomCommitScope, restoreDomCommitScope } from "./component-scope.js";
 import { isPromiseLike } from "../common/promise.js";
 import { tryRuntimeFastLaneSync } from "./fastlane.js";
-import { beginLifecycleCommitBatch, discardCommitOperations, discardLifecycleCommitBatch, executeCommittedLifecycleOperations, flushLifecycleCommitBatch } from "./component-lifecycle.js";
+import { discardCommitOperations } from "./lifecycle-operation-settlement.js";
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch } from "./lifecycle-batch.js";
+import { commitLifecycleForInstance } from "./component-lifecycle.js";
 //#region src/runtime/component-commit.ts
 function runScheduledComponent(instance, host) {
 	instance.notifyUpdate = instance._enqueueRun;
 	beginRenderTracking(instance);
-	const domSnapshot = instance.target ? instance.target.innerHTML : "";
 	let result;
 	try {
 		result = host.execute(instance);
@@ -33,7 +34,7 @@ function runScheduledComponent(instance, host) {
 			commitPlaceholderReplacement(instance, result, host);
 			return;
 		}
-		if (instance.target) commitToTarget(instance, result, domSnapshot, host);
+		if (instance.target) commitToTarget(instance, result, host);
 	});
 }
 function commitPlaceholderReplacement(instance, result, host) {
@@ -51,10 +52,7 @@ function commitPlaceholderReplacement(instance, result, host) {
 	}
 	const renderer = getRuntimeRenderer();
 	const hostElement = document.createElement("div");
-	const executionFrame = {
-		parent: instance.ownerFrame,
-		values: null
-	};
+	const executionFrame = getExecutionContextFrame(instance.ownerFrame);
 	const oldInstance = enterDomCommitScope(instance);
 	const lifecycleBatch = beginLifecycleCommitBatch();
 	try {
@@ -62,23 +60,30 @@ function commitPlaceholderReplacement(instance, result, host) {
 			withContext(executionFrame, () => {
 				renderer.evaluate(result, hostElement);
 			});
-			parent.replaceChild(hostElement, placeholder);
+			const onlyChild = hostElement.childNodes.length === 1 ? hostElement.firstChild : null;
+			const replacement = onlyChild instanceof Element ? onlyChild : hostElement;
+			if (replacement === hostElement) hostElement.__ASKR_WRAPPER_HOST = true;
+			parent.replaceChild(replacement, placeholder);
+			instance.target = replacement;
+			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;
 		}
-		instance.target = hostElement;
 		instance._placeholder = void 0;
-		hostElement.__ASKR_INSTANCE = instance;
-		flushLifecycleCommitBatch(lifecycleBatch);
 		host.finalizeReadSubscriptions(instance);
 		host.warnUnusedStateReads(instance);
 		host.commitRenderedComponent(instance);
+		flushLifecycleCommitBatch(lifecycleBatch);
 	} finally {
 		restoreDomCommitScope(oldInstance);
 	}
 }
-function commitToTarget(instance, result, domSnapshot, host) {
+function commitToTarget(instance, result, host) {
 	const renderer = getRuntimeRenderer();
 	const target = instance.target;
 	let oldChildren = [];
@@ -86,10 +91,7 @@ function commitToTarget(instance, result, domSnapshot, host) {
 	try {
 		const wasFirstMount = !instance.mounted;
 		const oldInstance = enterDomCommitScope(instance);
-		const executionFrame = {
-			parent: instance.ownerFrame,
-			values: null
-		};
+		const executionFrame = getExecutionContextFrame(instance.ownerFrame);
 		oldChildren = Array.from(target.childNodes);
 		const lifecycleBatch = beginLifecycleCommitBatch();
 		try {
@@ -113,21 +115,23 @@ function commitToTarget(instance, result, domSnapshot, host) {
 		} finally {
 			restoreDomCommitScope(oldInstance);
 		}
-		flushLifecycleCommitBatch(lifecycleBatch);
 		host.finalizeReadSubscriptions(instance);
 		host.warnUnusedStateReads(instance);
 		instance.mounted = true;
-		executeCommittedLifecycleOperations(instance, wasFirstMount);
+		commitLifecycleForInstance(instance, wasFirstMount);
+		flushLifecycleCommitBatch(lifecycleBatch);
 	} catch (renderError) {
 		discardCommitOperations(instance);
 		cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);
+		const rollbackErrors = [];
 		try {
 			incDevCounter("__DOM_REPLACE_COUNT");
 			setDevValue("__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK", (/* @__PURE__ */ new Error()).stack);
 			target.replaceChildren(...oldChildren);
-		} catch {
-			target.innerHTML = domSnapshot;
+		} 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;
 	}
 }
@@ -161,5 +165,3 @@ function cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChild
 }
 //#endregion
 export { runScheduledComponent };
-
-//# sourceMappingURL=component-commit.js.map

package/dist/runtime/component-facade.js

@@ -1,4 +1,6 @@
-import { claimHookIndex, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, setCurrentComponentInstance } from "./component-scope.js";
+import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, 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";
-export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, finalizeReadSubscriptions, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };
+import { getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
+import "./component-lifecycle.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
+export { captureInlineRenderSnapshot, claimHookIndex, cleanupComponent, createComponentInstance, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getSignal, mountComponent, mountInstanceInline, registerCommitOperation, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, renderComponentInline, renderScopedComponent, restoreDomCommitScope, setCurrentComponentInstance, unregisterOwnedChildScope, warnUnusedStateReads };

package/dist/runtime/component-internal.d.ts

@@ -1,9 +1,9 @@
 import { Props } from "../common/props.js";
-import { ReadableSource } from "./readable.js";
 import { State } from "./state.js";
 import { ContextFrame } from "./context.js";
 import { OwnedChildScope, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { LifecycleOperation } from "./component-lifecycle.js";
+import { LifecycleOperation } from "./lifecycle-batch.js";
+import { ReadableSource } from "./readable.js";
 import { ComponentFunction } from "../common/component.js";
 
 //#region src/runtime/component-internal.d.ts
@@ -18,23 +18,29 @@ interface ComponentInstance {
   abortController: AbortController | null;
   ssr?: boolean;
   cleanupStrict?: boolean;
-  stateValues: State<unknown>[];
+  stateValues?: State<unknown>[];
   evaluationGeneration: number;
   notifyUpdate: (() => void) | null;
   _pendingFlushTask?: () => void;
   _pendingRunTask?: () => void;
   _enqueueRun?: () => void;
   stateIndexCheck: number;
-  expectedStateIndices: number[];
+  expectedStateIndices?: number[];
   firstRenderComplete: boolean;
   mountOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
   commitOperations: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
   cleanupFns: Array<() => void>;
-  lifecycleSlots: unknown[];
+  lifecycleSlots?: unknown[];
   lifecycleGeneration: number;
   hasPendingUpdate: boolean;
   ownerFrame: ContextFrame | null;
   isRoot?: boolean;
+  _rootComponentFn?: ComponentFunction;
+  _vnodeOwner?: object;
+  _vnodeParent?: ComponentInstance | null;
+  _vnodeKey?: string | number;
+  _vnodePosition?: number;
+  _wrapperDepth?: number;
   _currentRenderToken?: number;
   lastRenderToken?: number;
   _pendingReadSources?: Set<ReadableSource<unknown>>;
@@ -96,5 +102,4 @@ declare function finalizeReadSubscriptions(instance: ComponentInstance): void;
  */
 declare function mountComponent(instance: ComponentInstance): void;
 //#endregion
-export { type ComponentFunction, ComponentInstance, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };
-//# sourceMappingURL=component-internal.d.ts.map
+export { type ComponentFunction, ComponentInstance, cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };

package/dist/runtime/component-internal.js

@@ -1,14 +1,47 @@
 import { isDevelopmentEnvironment, isProductionEnvironment } from "../common/env.js";
-import { logger } from "../dev/logger.js";
+import { logger } from "../common/logger.js";
 import { enqueueRuntimeTask } from "./access.js";
-import { withContext } from "./context.js";
+import { callWithContext, getExecutionContextFrame, withContext } from "./context.js";
 import { finalizeReadableSubscriptions } from "./readable.js";
 import { incDevCounter } from "./dev-namespace.js";
 import { beginRenderTracking, captureInlineComponentScope, captureInlineRenderTracking, clearRenderTracking, enterComponentExecutionScope, enterRenderScopedComponent, exitComponentExecutionScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getSignalForInstance, resetRenderState, restoreInlineComponentScope, restoreInlineRenderTracking, restoreRenderScopedComponent } from "./component-scope.js";
 import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
-import { captureInlineRenderSnapshot as captureInlineRenderSnapshot$1, commitLifecycleForInstance, commitRenderedComponent as commitRenderedComponent$1, discardCommitOperations, finalizeInlineReadSubscriptions, registerCommitOperationForInstance } from "./component-lifecycle.js";
+import { discardCommitOperations } from "./lifecycle-operation-settlement.js";
+import { captureInlineRenderSnapshot as captureInlineRenderSnapshot$1, finalizeInlineReadSubscriptions } from "./lifecycle-batch.js";
+import { commitLifecycleForInstance, commitRenderedComponent as commitRenderedComponent$1, registerCommitOperationForInstance } from "./component-lifecycle.js";
 import { runScheduledComponent } from "./component-commit.js";
 //#region src/runtime/component-internal.ts
+const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
+function ensurePendingRunTask(instance) {
+	const existing = instance._pendingRunTask;
+	if (existing) return existing;
+	const task = () => {
+		instance.hasPendingUpdate = false;
+		if (instance.notifyUpdate === null) return;
+		runScheduledComponent(instance, {
+			execute: executeComponentSync,
+			finalizeReadSubscriptions,
+			warnUnusedStateReads,
+			commitRenderedComponent
+		});
+	};
+	instance._pendingRunTask = task;
+	if (!instance._pendingFlushTask) instance._pendingFlushTask = task;
+	return task;
+}
+function enqueueComponentRun() {
+	if (this.hasPendingUpdate) return;
+	this.hasPendingUpdate = true;
+	enqueueRuntimeTask(ensurePendingRunTask(this));
+}
+var ComponentExecutionContext = class {
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get signal() {
+		return getSignalForInstance(this.instance);
+	}
+};
 function createComponentInstance(id, fn, props, target) {
 	const parentInstance = getCurrentInstance();
 	const instance = {
@@ -20,19 +53,19 @@ function createComponentInstance(id, fn, props, target) {
 		portalScope: parentInstance?.portalScope ?? getCurrentPortalScope() ?? null,
 		mounted: false,
 		abortController: null,
-		stateValues: [],
+		stateValues: void 0,
 		evaluationGeneration: 0,
 		notifyUpdate: null,
 		_pendingFlushTask: void 0,
 		_pendingRunTask: void 0,
 		_enqueueRun: void 0,
 		stateIndexCheck: -1,
-		expectedStateIndices: [],
+		expectedStateIndices: void 0,
 		firstRenderComplete: false,
 		mountOperations: [],
 		commitOperations: [],
 		cleanupFns: [],
-		lifecycleSlots: [],
+		lifecycleSlots: void 0,
 		lifecycleGeneration: 0,
 		hasPendingUpdate: false,
 		ownerFrame: null,
@@ -46,23 +79,7 @@ function createComponentInstance(id, fn, props, target) {
 		_lastReadSources: void 0,
 		devWarningsEmitted: void 0
 	};
-	instance._pendingRunTask = () => {
-		instance.hasPendingUpdate = false;
-		if (instance.notifyUpdate === null) return;
-		runScheduledComponent(instance, {
-			execute: executeComponentSync,
-			finalizeReadSubscriptions,
-			warnUnusedStateReads,
-			commitRenderedComponent
-		});
-	};
-	instance._enqueueRun = () => {
-		if (!instance.hasPendingUpdate) {
-			instance.hasPendingUpdate = true;
-			enqueueRuntimeTask(instance._pendingRunTask);
-		}
-	};
-	instance._pendingFlushTask = instance._pendingRunTask;
+	instance._enqueueRun = enqueueComponentRun;
 	return instance;
 }
 /**
@@ -83,10 +100,16 @@ function mountInstanceInline(instance, 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;
+			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) {}
 	instance.notifyUpdate = instance._enqueueRun;
@@ -108,10 +131,7 @@ function renderScopedComponent(instance, startStateIndex, render) {
 	const savedScope = enterRenderScopedComponent(instance, startStateIndex);
 	let didComplete = false;
 	try {
-		const result = withContext({
-			parent: instance.ownerFrame,
-			values: null
-		}, render);
+		const result = withContext(getExecutionContextFrame(instance.ownerFrame), render);
 		didComplete = true;
 		return result;
 	} finally {
@@ -141,8 +161,10 @@ function renderComponentInline(instance) {
 	}
 }
 function warnUnusedStateReads(instance) {
-	for (let i = 0; i < instance.stateValues.length; i++) {
-		const state = instance.stateValues[i];
+	const stateValues = instance.stateValues;
+	if (!stateValues) return;
+	for (let i = 0; i < stateValues.length; i++) {
+		const state = 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>";
@@ -159,16 +181,14 @@ function executeComponentSync(instance) {
 	const savedPortalScope = enterComponentExecutionScope(instance);
 	let didComplete = false;
 	try {
-		const renderStartTime = isDevelopmentEnvironment() ? Date.now() : 0;
-		const context = { get signal() {
-			return getSignalForInstance(instance);
-		} };
-		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.`);
+		const trackRenderTime = !PRODUCTION_BUILD_ENABLED && isDevelopmentEnvironment();
+		const renderStartTime = trackRenderTime ? Date.now() : 0;
+		const context = new ComponentExecutionContext(instance);
+		const result = callWithContext(getExecutionContextFrame(instance.ownerFrame), instance.fn, instance.props, context);
+		if (trackRenderTime) {
+			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;
@@ -185,7 +205,7 @@ function executeComponentSync(instance) {
 function executeComponent(instance) {
 	instance.abortController = null;
 	instance.notifyUpdate = instance._enqueueRun;
-	enqueueRuntimeTask(instance._pendingRunTask);
+	enqueueRuntimeTask(ensurePendingRunTask(instance));
 }
 /**
 * Finalize read subscriptions for an instance after a successful commit.
@@ -215,5 +235,3 @@ function warnInstanceOnce(instance, key, message) {
 }
 //#endregion
 export { captureInlineRenderSnapshot, cleanupComponent, commitRenderedComponent, createComponentInstance, executeComponent, finalizeReadSubscriptions, mountComponent, mountInstanceInline, registerCommitOperation, registerOwnedChildScope, renderComponentInline, renderScopedComponent, unregisterOwnedChildScope, warnUnusedStateReads };
-
-//# sourceMappingURL=component-internal.js.map

package/dist/runtime/component-lifecycle.d.ts

@@ -1,49 +1,10 @@
-import { Props } from "../common/props.js";
-import { ReadableSource } from "./readable.js";
-import { ContextFrame } from "./context.js";
+import { LifecycleCommitBatch, LifecycleOperation, LifecycleTransaction } from "./lifecycle-batch.js";
 import { ComponentInstance } from "./component-internal.js";
 
 //#region src/runtime/component-lifecycle.d.ts
-type LifecycleOperation = () => void | (() => void) | PromiseLike<void | (() => void)>;
-type LifecycleCommitBatchEntry = {
-  instance: ComponentInstance;
-  wasFirstMount: boolean;
-};
-type ReadSubscriptionCommit = {
-  instance: ComponentInstance;
-  token: number;
-  pendingReadSources: Set<ReadableSource<unknown>> | undefined;
-  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;
-};
-type InlineRenderSnapshot = {
-  instance: ComponentInstance;
-  props: Props;
-  ownerFrame: ContextFrame | null;
-  portalScope: object | null;
-  parentInstance: ComponentInstance | null;
-  isRoot: boolean | undefined;
-};
-type LifecycleCommitBatch = {
-  parent: LifecycleCommitBatch | null;
-  entries: LifecycleCommitBatchEntry[];
-  entriesByInstance: Map<ComponentInstance, LifecycleCommitBatchEntry>;
-  readCommits: ReadSubscriptionCommit[];
-  readCommitsByInstance: Map<ComponentInstance, ReadSubscriptionCommit>;
-  renderSnapshots: InlineRenderSnapshot[];
-  renderSnapshotsByInstance: Map<ComponentInstance, InlineRenderSnapshot>;
-  active: boolean;
-};
-declare function beginLifecycleCommitBatch(): LifecycleCommitBatch;
-declare function captureInlineRenderSnapshot(instance: ComponentInstance): void;
-declare function finalizeInlineReadSubscriptions(instance: ComponentInstance, token: number, pendingReadSources: Set<ReadableSource<unknown>> | undefined, pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined): void;
-declare function flushLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
-declare function discardLifecycleCommitBatch(batch: LifecycleCommitBatch): void;
 declare function registerMountOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
 declare function registerCommitOperationForInstance(instance: ComponentInstance | null, operation: LifecycleOperation): void;
-declare function discardCommitOperations(instance: ComponentInstance): void;
-declare function executeCommittedLifecycleOperations(instance: ComponentInstance, wasFirstMount: boolean): void;
 declare function commitLifecycleForInstance(instance: ComponentInstance, wasFirstMount: boolean): void;
 declare function commitRenderedComponent(instance: ComponentInstance): void;
 //#endregion
-export { LifecycleCommitBatch, LifecycleOperation };
-//# sourceMappingURL=component-lifecycle.d.ts.map
+export type { LifecycleOperation };