@askrjs/askr 0.0.50 → 0.0.52

package/dist/runtime/for-signals.js

@@ -1,27 +1,35 @@
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
+import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads } from "./readable.js";
 //#region src/runtime/for-signals.ts
-function notifyForSignalReaders(source, skipInstance) {
+function peekForSignal() {
+	return this._value;
+}
+function setForValueSignal(newValue, notifyReaders = true) {
+	if (Object.is(this._value, newValue)) return;
+	this._value = newValue;
+	if (notifyReaders) notifyForSignalReaders(this);
+}
+function setForIndexValue(newValue, notifyReaders = true) {
+	const nextValue = typeof newValue === "function" ? newValue(this._value) : newValue;
+	if (nextValue === this._value) return;
+	this._value = nextValue;
+	if (notifyReaders) notifyForSignalReaders(this);
+}
+function notifyForSignalReaders(source, skipInstance, skipOwnedBy) {
 	markReadableDerivedSubscribersDirty(source);
 	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source, skipInstance);
+	notifyReadableReaders(source, skipInstance, skipOwnedBy);
 }
 function createForIndexSignal(initialIndex) {
-	let indexValue = initialIndex;
-	const readers = /* @__PURE__ */ new Map();
-	const indexSignal = (() => {
-		indexSignal._hasBeenRead = true;
-		recordReadableRead(indexSignal);
-		return indexValue;
-	});
-	indexSignal._readers = readers;
-	indexSignal.peek = () => indexValue;
-	indexSignal.set = (newValue, notifyReaders = true) => {
-		const nextValue = typeof newValue === "function" ? newValue(indexValue) : newValue;
-		if (nextValue !== indexValue) {
-			indexValue = nextValue;
-			if (notifyReaders) notifyForSignalReaders(indexSignal);
-		}
-	};
+	function readIndexSignal() {
+		const signal = readIndexSignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const indexSignal = readIndexSignal;
+	indexSignal._value = initialIndex;
+	indexSignal.peek = peekForSignal;
+	indexSignal.set = setForIndexValue;
 	indexSignal._hasBeenRead = false;
 	return indexSignal;
 }
@@ -31,38 +39,30 @@ function syncForIndexSignal(indexSignal, nextIndex) {
 	return indexSignal._hasBeenRead === true;
 }
 function createForItemSignal(initialItem) {
-	let itemValue = initialItem;
-	const readers = /* @__PURE__ */ new Map();
-	const itemSignal = (() => {
-		itemSignal._hasBeenRead = true;
-		recordReadableRead(itemSignal);
-		return itemValue;
-	});
-	itemSignal._readers = readers;
-	itemSignal.peek = () => itemValue;
-	itemSignal.set = (newValue, notifyReaders = true) => {
-		if (Object.is(itemValue, newValue)) return;
-		itemValue = newValue;
-		if (notifyReaders) notifyForSignalReaders(itemSignal);
-	};
+	function readItemSignal() {
+		const signal = readItemSignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const itemSignal = readItemSignal;
+	itemSignal._value = initialItem;
+	itemSignal.peek = peekForSignal;
+	itemSignal.set = setForValueSignal;
 	itemSignal._hasBeenRead = false;
 	return itemSignal;
 }
 function createForItemPropertySignal(initialValue) {
-	let propertyValue = initialValue;
-	const readers = /* @__PURE__ */ new Map();
-	const propertySignal = (() => {
-		propertySignal._hasBeenRead = true;
-		recordReadableRead(propertySignal);
-		return propertyValue;
-	});
-	propertySignal._readers = readers;
-	propertySignal.peek = () => propertyValue;
-	propertySignal.set = (newValue, notifyReaders = true) => {
-		if (Object.is(propertyValue, newValue)) return;
-		propertyValue = newValue;
-		if (notifyReaders) notifyForSignalReaders(propertySignal);
-	};
+	function readPropertySignal() {
+		const signal = readPropertySignal;
+		signal._hasBeenRead = true;
+		recordReadableRead(signal);
+		return signal._value;
+	}
+	const propertySignal = readPropertySignal;
+	propertySignal._value = initialValue;
+	propertySignal.peek = peekForSignal;
+	propertySignal.set = setForValueSignal;
 	propertySignal._hasBeenRead = false;
 	return propertySignal;
 }
@@ -77,6 +77,18 @@ function haveSameOwnKeys(previousItem, nextItem) {
 	return true;
 }
 function scopeReadsSource(scope, source) {
+	const readers = source._readers;
+	if (!readers || readers.size === 0) return false;
+	for (const reader of readers.keys()) {
+		let current = reader;
+		while (current) {
+			if (current === scope.componentInstance) return true;
+			current = current.parentInstance;
+		}
+	}
+	return false;
+}
+function scopeDirectlyReadsSource(scope, source) {
 	return source._readers?.has(scope.componentInstance) ?? false;
 }
 function isForParentReader(parentInstance, reader) {
@@ -92,7 +104,9 @@ function removeForParentReaders(parentInstance, source) {
 	if (!readers || readers.size === 0) return;
 	for (const reader of readers.keys()) if (isForParentReader(parentInstance, reader)) readers.delete(reader);
 }
-function getOrCreateForItemPropertySignal(item, propertySignals, prop) {
+function getOrCreateForItemPropertySignal(state, prop) {
+	const item = state.currentItem;
+	const propertySignals = state.propertySignals ?? (state.propertySignals = /* @__PURE__ */ new Map());
 	const existingSignal = propertySignals.get(prop);
 	if (existingSignal) return existingSignal;
 	const propertySignal = createForItemPropertySignal(readForItemProperty(item, prop));
@@ -100,40 +114,100 @@ function getOrCreateForItemPropertySignal(item, propertySignals, prop) {
 	return propertySignal;
 }
 function canProxyForItem(item) {
-	return typeof item === "object" && item !== null || typeof item === "function";
-}
-function createReactiveForItem(itemSignal, propertySignals) {
-	return new Proxy(Object.create(null), {
-		get(target, prop, receiver) {
-			if (Reflect.getOwnPropertyDescriptor(target, prop)) return Reflect.get(target, prop, receiver);
-			const currentItem = itemSignal.peek();
-			if (typeof prop !== "symbol") return getOrCreateForItemPropertySignal(currentItem, propertySignals, prop)();
-			recordReadableRead(itemSignal);
-			return Reflect.get(Object(currentItem), prop, receiver);
-		},
-		has(target, prop) {
-			recordReadableRead(itemSignal);
-			return prop in target || prop in Object(itemSignal.peek());
-		},
-		ownKeys(target) {
-			recordReadableRead(itemSignal);
-			const keys = new Set(Reflect.ownKeys(target));
-			for (const key of Reflect.ownKeys(Object(itemSignal.peek()))) keys.add(key);
-			return Array.from(keys);
-		},
-		getOwnPropertyDescriptor(target, prop) {
-			recordReadableRead(itemSignal);
-			const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-			if (ownDescriptor) return ownDescriptor;
-			return Object.getOwnPropertyDescriptor(Object(itemSignal.peek()), prop);
-		},
-		getPrototypeOf() {
-			recordReadableRead(itemSignal);
-			return Object.getPrototypeOf(Object(itemSignal.peek()));
-		}
-	});
+	return typeof item === "function" || typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function createReactiveForItem(item) {
+	const target = Object.create(null);
+	const state = {
+		currentItem: item,
+		itemSignal: null,
+		propertySignals: null,
+		coalescedProperties: null,
+		coalescedProperty2: null,
+		wholeItemRead: false,
+		proxy: void 0
+	};
+	target[REACTIVE_FOR_ITEM_STATE] = state;
+	state.proxy = new Proxy(target, REACTIVE_FOR_ITEM_PROXY_HANDLER);
+	return state;
 }
+const REACTIVE_FOR_ITEM_STATE = Symbol("askr.reactive-for-item-state");
+function getReactiveForItemState(target) {
+	return target[REACTIVE_FOR_ITEM_STATE];
+}
+function getWholeItemSignal(state) {
+	let signal = state.itemSignal;
+	if (!signal) {
+		signal = createForItemSignal(state.currentItem);
+		state.itemSignal = signal;
+	}
+	return signal;
+}
+const REACTIVE_FOR_ITEM_PROXY_HANDLER = {
+	get(target, prop, receiver) {
+		if (prop !== REACTIVE_FOR_ITEM_STATE && prop in target) return Reflect.get(target, prop, receiver);
+		const metadata = getReactiveForItemState(target);
+		const currentItem = metadata.currentItem;
+		if (typeof prop !== "symbol") {
+			if (shouldCoalesceFineGrainedItemReads()) {
+				const properties = metadata.coalescedProperties;
+				if (properties === null) metadata.coalescedProperties = prop;
+				else if (Array.isArray(properties)) {
+					if (!properties.includes(prop)) properties.push(prop);
+				} else if (properties !== prop && metadata.coalescedProperty2 !== prop) if (metadata.coalescedProperty2 === null) metadata.coalescedProperty2 = prop;
+				else {
+					metadata.coalescedProperties = [
+						properties,
+						metadata.coalescedProperty2,
+						prop
+					];
+					metadata.coalescedProperty2 = null;
+				}
+				let itemSignal = metadata.itemSignal;
+				if (!itemSignal) {
+					itemSignal = createForItemSignal(currentItem);
+					metadata.itemSignal = itemSignal;
+				}
+				itemSignal();
+				return readForItemProperty(currentItem, prop);
+			}
+			return getOrCreateForItemPropertySignal(metadata, prop)();
+		}
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return Reflect.get(Object(currentItem), prop, receiver);
+	},
+	has(target, prop) {
+		if (prop === REACTIVE_FOR_ITEM_STATE) return false;
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return prop in target || prop in Object(metadata.currentItem);
+	},
+	ownKeys(target) {
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		const keys = /* @__PURE__ */ new Set();
+		for (const key of Reflect.ownKeys(target)) if (key !== REACTIVE_FOR_ITEM_STATE) keys.add(key);
+		for (const key of Reflect.ownKeys(Object(metadata.currentItem))) keys.add(key);
+		return Array.from(keys);
+	},
+	getOwnPropertyDescriptor(target, prop) {
+		if (prop === REACTIVE_FOR_ITEM_STATE) return;
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		const ownDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+		if (ownDescriptor) return ownDescriptor;
+		return Object.getOwnPropertyDescriptor(Object(metadata.currentItem), prop);
+	},
+	getPrototypeOf(target) {
+		const metadata = getReactiveForItemState(target);
+		metadata.wholeItemRead = true;
+		recordReadableRead(getWholeItemSignal(metadata));
+		return Object.getPrototypeOf(Object(metadata.currentItem));
+	}
+};
 //#endregion
-export { canProxyForItem, createForIndexSignal, createForItemSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeReadsSource, syncForIndexSignal };
-
-//# sourceMappingURL=for-signals.js.map
+export { canProxyForItem, createForIndexSignal, createForItemSignal, createReactiveForItem, haveSameOwnKeys, notifyForSignalReaders, readForItemProperty, removeForParentReaders, scopeDirectlyReadsSource, scopeReadsSource, syncForIndexSignal };

package/dist/runtime/for-types.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from "../common/vnode.js";
+
+//#region src/runtime/for-types.d.ts
+type ForEachSource<T> = T[] | (() => T[]);
+type ForKeySelector<T> = (item: T, index: number) => string | number;
+type ForRenderItem<T> = (item: T, index: () => number) => VNode;
+//#endregion
+export { ForEachSource, ForKeySelector, ForRenderItem };

package/dist/runtime/for.d.ts

@@ -1,4 +1,4 @@
 import { ForItemInstance } from "./for-scopes.js";
 import { reconcileForItems } from "./for-reconcile.js";
-import { ForCommitStrategy, ForState } from "./for-internal.js";
-export { ForCommitStrategy, ForState, reconcileForItems };
+import { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction } from "./for-internal.js";
+export { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction, reconcileForItems };

package/dist/runtime/for.js

@@ -1,5 +1,5 @@
 import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
-import "./for-scopes.js";
+import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "./for-scopes.js";
 import { reconcileForItems } from "./for-reconcile.js";
-import { clearForDomUpdateState, createForState, evaluateForState, useForState } from "./for-internal.js";
-export { clearForDomUpdateState, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, useForState, withBenchMetricScope };
+import { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, registerForStateTransaction, rollbackForStateTransaction, useForState } from "./for-internal.js";
+export { beginForStateTransaction, captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, isBenchMetricScopeActive, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, registerForStateTransaction, rollbackForStateTransaction, useForState, withBenchMetricScope };

package/dist/runtime/index.d.ts

@@ -0,0 +1,24 @@
+import { State, StateSetter, StateTuple, state } from "./state.js";
+import { Context, ContextFrame, ContextKey, defineContext, readContext } from "./context.js";
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { ComponentInstance } from "./component-internal.js";
+import { getSignal } from "./component-scope.js";
+import { DerivedSubscriber, FineGrainedReadCollector, ReadableSource } from "./readable.js";
+import { Scheduler, SchedulerLane, scheduleEventHandler } from "./scheduler.js";
+import { AskrRuntime, AskrRuntimeOptions, RuntimeKeyedReorderDecision, RuntimeRendererHost, createRuntime, getDefaultRuntime } from "./runtime.js";
+import { ChildScope, ChildScopeTransactionSnapshot } from "./child-scope.js";
+import { ForItemInstance } from "./for-scopes.js";
+import { CreateFineGrainedEffectOptions, FineGrainedEffectHandle } from "./effect.js";
+import { ForEachSource, ForKeySelector, ForRenderItem } from "./for-types.js";
+import { reconcileForItems } from "./for-reconcile.js";
+import { ForCommitStrategy, ForItemTransactionSnapshot, ForState, ForTransaction } from "./for-internal.js";
+import { CaseState, ControlBoundaryState, ControlTransaction, MatchBranch, ShowState } from "./control.js";
+import { Derived, derive } from "./derive.js";
+import { DelegatedEventMap } from "./events.js";
+import { ExecutionModel } from "./execution-model.js";
+import { ResourceResult, resource } from "./resource-operation.js";
+import { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
+import { DefaultPortal, Portal, PortalProps, definePortal } from "./portal.js";
+import { Selector, selector } from "./selector.js";
+import { ComponentFunction } from "../common/component.js";
+export { type ActivityPredicate, AskrRuntime, AskrRuntimeOptions, CaseState, ChildScope, ChildScopeTransactionSnapshot, type ComponentFunction, type ComponentInstance, Context, ContextFrame, ContextKey, ControlBoundaryState, ControlTransaction, CreateFineGrainedEffectOptions, DefaultPortal, DelegatedEventMap, Derived, DerivedSubscriber, ExecutionModel, FineGrainedEffectHandle, FineGrainedReadCollector, ForCommitStrategy, type ForEachSource, ForItemTransactionSnapshot, ForState, ForTransaction, MatchBranch, Portal, PortalProps, ReadableSource, type ResourceResult, RuntimeKeyedReorderDecision, RuntimeRendererHost, Selector, ShowState, State, StateSetter, StateTuple, type TimerOptions, capture, createRuntime, defineContext, definePortal, derive, documentVisible, getDefaultRuntime, getSignal, on, readContext, reconcileForItems, resource, routeActive, scheduleEventHandler, selector, state, stream, task, timer, windowFocused };

package/dist/runtime/index.js

@@ -0,0 +1,33 @@
+import { addPerfDuration, getPerfMetricsStore, incrementPerfMetric, recordSchedulerFlushTaskCount } from "./perf-metrics.js";
+import { scheduleEventHandler } from "./scheduler.js";
+import { AskrRuntime, configureRuntimeRenderer, createRuntime, defaultRuntime, getDefaultRuntime } from "./runtime.js";
+import { enqueueRuntimeLane, enqueueRuntimeTask, flushRuntimeScheduler, getDefaultRuntimeInstance, getRuntimeFlushVersion, getRuntimeRenderer, getRuntimeScheduler, getRuntimeSchedulerState, isRuntimeSchedulerExecuting, markRuntimeReactivePropsDirtySource, runRuntimeHandlerScope, runRuntimeWithSyncProgress, setRuntimeBulkCommitProbe } from "./access.js";
+import { CONTEXT_FRAME_SYMBOL, callWithContext, defineContext, getCurrentContextFrame, getExecutionContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, readContext, withAsyncResourceContext, withContext } from "./context.js";
+import { cleanupReadableSubscriptions, clearDerivedDependencySubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads, syncDerivedDependencySubscriptions, withDerivedReadTracking, withFineGrainedReadTracking } from "./readable.js";
+import { getDevNamespace, getDevValue, incDevCounter, setDevValue } from "./dev-namespace.js";
+import { claimHookIndex, enterDomCommitScope, getCurrentComponentInstance, getCurrentInstance, getCurrentPortalScope, getCurrentStateIndex, getSignal, restoreDomCommitScope, setCurrentComponentInstance } from "./component-scope.js";
+import { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope } from "./component-cleanup.js";
+import { classifyUpdate, commitReorderOnly, enterBulkCommit, exitBulkCommit, isBulkCommitActive, markFastPathApplied, tryRuntimeFastLaneSync } from "./fastlane.js";
+import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, drainLifecycleCommitErrors, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction } from "./lifecycle-batch.js";
+import "./component-lifecycle.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountComponent, mountInstanceInline, registerCommitOperation, renderComponentInline, renderScopedComponent, warnUnusedStateReads } from "./component-internal.js";
+import "./component.js";
+import { captureChildScopeTransactionSnapshot, createChildScope, disposeChildScope, rerenderChildScope, restoreChildScopeTransactionSnapshot } from "./child-scope.js";
+import { clearCaseDomUpdateState, clearShowDomUpdateState, createCaseState, createShowState, evaluateCaseState, evaluateShowState } from "./control.js";
+import { derive } from "./derive.js";
+import { createFineGrainedEffect, createOwnedFineGrainedEffect, markFineGrainedEffectsDirtySource } from "./effect.js";
+import { createBoundaryReset, reportBoundaryError } from "./error-boundary.js";
+import { addDelegatedListener, addFreshDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener } from "./events.js";
+import { assertExecutionModel, getExecutionModel } from "./execution-model.js";
+import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "./for-bench.js";
+import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "./for-scopes.js";
+import { reconcileForItems } from "./for-reconcile.js";
+import { beginForStateTransaction, clearForDomUpdateState, commitForStateTransaction, createForState, evaluateForState, registerForStateTransaction, rollbackForStateTransaction, useForState } from "./for-internal.js";
+import "./for.js";
+import { state } from "./state.js";
+import { resource } from "./resource-operation.js";
+import { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
+import "./operations.js";
+import { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope } from "./portal.js";
+import { selector } from "./selector.js";
+export { AskrRuntime, CONTEXT_FRAME_SYMBOL, DefaultPortal, Portal, addDelegatedListener, addFreshDelegatedListener, addPerfDuration, assertExecutionModel, beginForStateTransaction, beginLifecycleCommitBatch, callWithContext, capture, captureChildScopeTransactionSnapshot, captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot, captureInlineRenderSnapshot, claimHookIndex, classifyUpdate, cleanupComponent, cleanupReadableSubscriptions, clearCaseDomUpdateState, clearDefaultPortalForInstance, clearDelegatedHandlersForElement, clearDerivedDependencySubscriptions, clearForDomUpdateState, clearShowDomUpdateState, commitForStateTransaction, commitReorderOnly, configureRuntimeRenderer, createBoundaryReset, createCaseState, createChildScope, createComponentInstance, createFineGrainedEffect, createForState, createOwnedFineGrainedEffect, createRuntime, createShowState, defaultRuntime, defineContext, definePortal, derive, discardLifecycleCommitBatch, disposeChildScope, disposeDefaultPortalScope, documentVisible, drainLifecycleCommitErrors, enqueueRuntimeLane, enqueueRuntimeTask, enterBulkCommit, enterDomCommitScope, evaluateCaseState, evaluateForState, evaluateShowState, exitBulkCommit, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, flushLifecycleCommitBatch, flushRuntimeScheduler, getCurrentComponentInstance, getCurrentContextFrame, getCurrentInstance, getCurrentLifecycleCommitBatch, getCurrentPortalScope, getCurrentStateIndex, getDefaultRuntime, getDefaultRuntimeInstance, getDelegatedHandlerForElement, getDelegatedHandlersForElement, getDevNamespace, getDevValue, getExecutionContextFrame, getExecutionModel, getPerfMetricsStore, getRuntimeFlushVersion, getRuntimeRenderer, getRuntimeScheduler, getRuntimeSchedulerState, getSignal, getVNodeContextFrame, incDevCounter, incrementPerfMetric, isBenchMetricScopeActive, isBulkCommitActive, isDelegatedEvent, isEventDelegationEnabled, isRuntimeSchedulerExecuting, markFastPathApplied, markFineGrainedEffectsDirtySource, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, markRuntimeReactivePropsDirtySource, markVNodeTreeWithContextFrame, markVNodeWithContextFrame, mountComponent, mountInstanceInline, notifyReadableReaders, on, readContext, reconcileForItems, recordBenchCounter, recordBenchEvent, recordBenchTiming, recordReadableRead, recordSchedulerFlushTaskCount, registerCommitOperation, registerForStateTransaction, registerLifecycleRollback, registerLifecycleTransaction, registerOwnedChildScope, removeDelegatedListener, renderComponentInline, renderScopedComponent, reportBoundaryError, rerenderChildScope, resource, restoreChildScopeTransactionSnapshot, restoreDomCommitScope, rollbackForStateTransaction, routeActive, runRuntimeHandlerScope, runRuntimeWithSyncProgress, scheduleEventHandler, selector, setCurrentComponentInstance, setDevValue, setRuntimeBulkCommitProbe, shouldCoalesceFineGrainedItemReads, state, stream, syncDerivedDependencySubscriptions, task, timer, tryRuntimeFastLaneSync, unregisterOwnedChildScope, updateDelegatedListener, useForState, warnUnusedStateReads, windowFocused, withAsyncResourceContext, withBenchMetricScope, withContext, withDerivedReadTracking, withFineGrainedReadTracking };

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

@@ -0,0 +1,59 @@
+import { Props } from "../common/props.js";
+import { ContextFrame } from "./context.js";
+import { ComponentInstance } from "./component-internal.js";
+import { ReadableSource } from "./readable.js";
+
+//#region src/runtime/lifecycle-batch.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 LifecycleTransaction = {
+  key: object;
+  commit(): void;
+  rollback(): void;
+  merge?(parentTransaction: LifecycleTransaction): void;
+};
+type LifecycleRollback = () => void;
+type LifecycleTransactionEntry = LifecycleTransaction | LifecycleRollback;
+type LifecycleCommitBatch = {
+  parent: LifecycleCommitBatch | null;
+  entries: LifecycleCommitBatchEntry[];
+  entriesByInstance: Map<ComponentInstance, LifecycleCommitBatchEntry>;
+  readCommits: ReadSubscriptionCommit[];
+  readCommitsByInstance: Map<ComponentInstance, ReadSubscriptionCommit>;
+  renderSnapshots: InlineRenderSnapshot[];
+  renderSnapshotsByInstance: Map<ComponentInstance, InlineRenderSnapshot>;
+  transactions: LifecycleTransactionEntry[];
+  transactionsByKey: Map<object, LifecycleTransaction>;
+  retainedElementSnapshots: Map<Element, unknown>;
+  active: boolean;
+};
+/** @internal Drain commit-time cleanup errors for transaction owners such as the router. */
+declare function drainLifecycleCommitErrors(): unknown[];
+declare function beginLifecycleCommitBatch(): LifecycleCommitBatch;
+declare function getCurrentLifecycleCommitBatch(): LifecycleCommitBatch | null;
+declare function registerLifecycleTransaction(key: object, commit: () => void, rollback: () => void, merge?: (parentTransaction: LifecycleTransaction) => void): boolean;
+declare function registerLifecycleRollback(rollback: LifecycleRollback): boolean;
+declare function enqueueLifecycleCommitForInstance(instance: ComponentInstance, wasFirstMount: boolean): boolean;
+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;
+//#endregion
+export { LifecycleCommitBatch, LifecycleOperation, LifecycleTransaction };

package/dist/runtime/lifecycle-batch.js

@@ -0,0 +1,178 @@
+import { logger } from "../common/logger.js";
+import { finalizeReadableSubscriptionsFromSnapshot } from "./readable.js";
+import { discardCommitOperations, executeCommittedLifecycleOperations } from "./lifecycle-operation-settlement.js";
+//#region src/runtime/lifecycle-batch.ts
+let currentLifecycleCommitBatch = null;
+const pendingLifecycleCommitErrors = [];
+/** @internal Drain commit-time cleanup errors for transaction owners such as the router. */
+function drainLifecycleCommitErrors() {
+	if (pendingLifecycleCommitErrors.length === 0) return [];
+	return pendingLifecycleCommitErrors.splice(0);
+}
+function beginLifecycleCommitBatch() {
+	const batch = {
+		parent: currentLifecycleCommitBatch,
+		entries: [],
+		entriesByInstance: /* @__PURE__ */ new Map(),
+		readCommits: [],
+		readCommitsByInstance: /* @__PURE__ */ new Map(),
+		renderSnapshots: [],
+		renderSnapshotsByInstance: /* @__PURE__ */ new Map(),
+		transactions: [],
+		transactionsByKey: /* @__PURE__ */ new Map(),
+		retainedElementSnapshots: /* @__PURE__ */ new Map(),
+		active: true
+	};
+	currentLifecycleCommitBatch = batch;
+	return batch;
+}
+function getCurrentLifecycleCommitBatch() {
+	return currentLifecycleCommitBatch?.active ? currentLifecycleCommitBatch : null;
+}
+function enqueueLifecycleTransaction(batch, transaction) {
+	if (batch.transactionsByKey.has(transaction.key)) return;
+	batch.transactionsByKey.set(transaction.key, transaction);
+	batch.transactions.push(transaction);
+}
+function registerLifecycleTransaction(key, commit, rollback, merge) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	enqueueLifecycleTransaction(currentLifecycleCommitBatch, {
+		key,
+		commit,
+		rollback,
+		merge
+	});
+	return true;
+}
+function registerLifecycleRollback(rollback) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	currentLifecycleCommitBatch.transactions.push(rollback);
+	return true;
+}
+function closeLifecycleCommitBatch(batch) {
+	if (!batch.active) return false;
+	batch.active = false;
+	currentLifecycleCommitBatch = batch.parent;
+	return true;
+}
+function enqueueLifecycleCommit(batch, instance, wasFirstMount) {
+	const existing = batch.entriesByInstance.get(instance);
+	if (existing) {
+		existing.wasFirstMount = existing.wasFirstMount || wasFirstMount;
+		return;
+	}
+	const entry = {
+		instance,
+		wasFirstMount
+	};
+	batch.entriesByInstance.set(instance, entry);
+	batch.entries.push(entry);
+}
+function enqueueLifecycleCommitForInstance(instance, wasFirstMount) {
+	if (!currentLifecycleCommitBatch?.active) return false;
+	enqueueLifecycleCommit(currentLifecycleCommitBatch, instance, wasFirstMount);
+	return true;
+}
+function enqueueReadSubscriptionCommit(batch, instance, token, pendingReadSources, pendingReadSourceVersions) {
+	const existing = batch.readCommitsByInstance.get(instance);
+	const commit = existing ?? {
+		instance,
+		token,
+		pendingReadSources,
+		pendingReadSourceVersions
+	};
+	commit.token = token;
+	commit.pendingReadSources = pendingReadSources ? new Set(pendingReadSources) : void 0;
+	commit.pendingReadSourceVersions = pendingReadSourceVersions ? new Map(pendingReadSourceVersions) : void 0;
+	if (!existing) {
+		batch.readCommitsByInstance.set(instance, commit);
+		batch.readCommits.push(commit);
+	}
+}
+function enqueueInlineRenderSnapshot(batch, snapshot) {
+	if (batch.renderSnapshotsByInstance.has(snapshot.instance)) return;
+	batch.renderSnapshotsByInstance.set(snapshot.instance, snapshot);
+	batch.renderSnapshots.push(snapshot);
+}
+function captureInlineRenderSnapshot(instance) {
+	if (!currentLifecycleCommitBatch?.active) return;
+	enqueueInlineRenderSnapshot(currentLifecycleCommitBatch, {
+		instance,
+		props: instance.props,
+		ownerFrame: instance.ownerFrame,
+		portalScope: instance.portalScope,
+		parentInstance: instance.parentInstance,
+		isRoot: instance.isRoot
+	});
+}
+function finalizeInlineReadSubscriptions(instance, token, pendingReadSources, pendingReadSourceVersions) {
+	if ((!pendingReadSources || pendingReadSources.size === 0) && (!instance._lastReadSources || instance._lastReadSources.size === 0)) return;
+	if (currentLifecycleCommitBatch?.active) {
+		enqueueReadSubscriptionCommit(currentLifecycleCommitBatch, instance, token, pendingReadSources, pendingReadSourceVersions);
+		return;
+	}
+	finalizeReadableSubscriptionsFromSnapshot(instance, token, pendingReadSources, pendingReadSourceVersions);
+}
+function flushLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	if (batch.parent?.active) {
+		for (const [element, snapshot] of batch.retainedElementSnapshots) if (!batch.parent.retainedElementSnapshots.has(element)) batch.parent.retainedElementSnapshots.set(element, snapshot);
+		for (const entry of batch.transactions) if (typeof entry === "function") batch.parent.transactions.push(entry);
+		else {
+			const existing = batch.parent.transactionsByKey.get(entry.key);
+			if (existing && entry.merge) entry.merge(existing);
+			else enqueueLifecycleTransaction(batch.parent, entry);
+		}
+		for (const snapshot of batch.renderSnapshots) enqueueInlineRenderSnapshot(batch.parent, snapshot);
+		for (const commit of batch.readCommits) enqueueReadSubscriptionCommit(batch.parent, commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+		for (const entry of batch.entries) enqueueLifecycleCommit(batch.parent, entry.instance, entry.wasFirstMount);
+		return;
+	}
+	const commitErrors = [];
+	for (const commit of batch.readCommits) try {
+		finalizeReadableSubscriptionsFromSnapshot(commit.instance, commit.token, commit.pendingReadSources, commit.pendingReadSourceVersions);
+	} catch (error) {
+		commitErrors.push(error);
+	}
+	for (const transaction of batch.transactions) {
+		if (typeof transaction === "function") continue;
+		try {
+			transaction.commit();
+		} catch (error) {
+			commitErrors.push(error);
+		}
+	}
+	for (const entry of batch.entries) try {
+		executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);
+	} catch (error) {
+		commitErrors.push(error);
+	}
+	if (commitErrors.length > 0) {
+		pendingLifecycleCommitErrors.push(...commitErrors);
+		logger.error("[Askr] committed lifecycle work failed:", new AggregateError(commitErrors, "Committed lifecycle work failed"));
+	}
+}
+function discardLifecycleCommitBatch(batch) {
+	if (!closeLifecycleCommitBatch(batch)) return;
+	for (let index = batch.transactions.length - 1; index >= 0; index -= 1) try {
+		const transaction = batch.transactions[index];
+		if (typeof transaction === "function") transaction();
+		else transaction.rollback();
+	} catch (error) {
+		logger.error("[Askr] transaction rollback failed:", error);
+	}
+	for (let index = batch.renderSnapshots.length - 1; index >= 0; index -= 1) {
+		const snapshot = batch.renderSnapshots[index];
+		snapshot.instance.props = snapshot.props;
+		snapshot.instance.ownerFrame = snapshot.ownerFrame;
+		snapshot.instance.portalScope = snapshot.portalScope;
+		snapshot.instance.parentInstance = snapshot.parentInstance;
+		snapshot.instance.isRoot = snapshot.isRoot;
+	}
+	for (const entry of batch.entries) {
+		if (entry.wasFirstMount) entry.instance.mountOperations = [];
+		discardCommitOperations(entry.instance);
+	}
+}
+//#endregion
+export { beginLifecycleCommitBatch, captureInlineRenderSnapshot, discardLifecycleCommitBatch, drainLifecycleCommitErrors, enqueueLifecycleCommitForInstance, finalizeInlineReadSubscriptions, flushLifecycleCommitBatch, getCurrentLifecycleCommitBatch, registerLifecycleRollback, registerLifecycleTransaction };

package/dist/runtime/lifecycle-operation-settlement.d.ts

@@ -0,0 +1,5 @@
+import { ComponentInstance } from "./component-internal.js";
+
+//#region src/runtime/lifecycle-operation-settlement.d.ts
+declare function discardCommitOperations(instance: ComponentInstance): void;
+declare function executeCommittedLifecycleOperations(instance: ComponentInstance, wasFirstMount: boolean): void;