@askrjs/askr 0.0.51 → 0.0.52

package/dist/runtime/lifecycle-operation-settlement.js

@@ -0,0 +1,51 @@
+import { logger } from "../common/logger.js";
+import { isPromiseLike } from "../common/promise.js";
+//#region src/runtime/lifecycle-operation-settlement.ts
+function settleLifecycleOperationResult(instance, lifecycleGeneration, result) {
+	if (isPromiseLike(result)) Promise.resolve(result).then((cleanup) => {
+		if (typeof cleanup === "function") {
+			if (instance.lifecycleGeneration === lifecycleGeneration && instance.mounted) {
+				(instance.cleanupFns ??= []).push(cleanup);
+				return;
+			}
+			try {
+				cleanup();
+			} catch (err) {
+				logger.error("[Askr] async mount cleanup failed:", err);
+			}
+		}
+	}, (err) => {
+		logger.error("[Askr] async mount operation failed:", err);
+	});
+	else if (typeof result === "function") (instance.cleanupFns ??= []).push(result);
+}
+function executeOperations(instance, operations) {
+	if (operations.length === 0) return [];
+	const lifecycleGeneration = instance.lifecycleGeneration;
+	const errors = [];
+	for (const operation of operations) try {
+		settleLifecycleOperationResult(instance, lifecycleGeneration, operation());
+	} catch (error) {
+		errors.push(error);
+	}
+	return errors;
+}
+function discardCommitOperations(instance) {
+	instance.commitOperations = [];
+}
+function executeCommittedLifecycleOperations(instance, wasFirstMount) {
+	const errors = [];
+	if (wasFirstMount && (instance.mountOperations?.length ?? 0) > 0) {
+		const operations = instance.mountOperations;
+		instance.mountOperations = [];
+		errors.push(...executeOperations(instance, operations));
+	}
+	if ((instance.commitOperations?.length ?? 0) > 0) {
+		const operations = instance.commitOperations;
+		instance.commitOperations = [];
+		errors.push(...executeOperations(instance, operations));
+	}
+	if (errors.length > 0) throw new AggregateError(errors, `Committed lifecycle operations failed for ${instance.id}`);
+}
+//#endregion
+export { discardCommitOperations, executeCommittedLifecycleOperations };

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

@@ -27,5 +27,4 @@ declare function task(fn: () => void | (() => void) | PromiseLike<void | (() =>
  */
 declare function capture<T>(fn: () => T): () => T;
 //#endregion
-export { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused };
-//# sourceMappingURL=lifecycle-operations.d.ts.map
+export { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused };

package/dist/runtime/lifecycle-operations.js

@@ -12,14 +12,15 @@ function allPredicatesPass(predicates) {
 	return true;
 }
 function getLifecycleSlot(instance, index, kind, create) {
-	const existing = instance.lifecycleSlots[index];
+	const lifecycleSlots = instance.lifecycleSlots ??= [];
+	const existing = lifecycleSlots[index];
 	if (existing) {
 		const slot = existing;
 		if (slot.kind !== kind) throw new Error(`${kind}() lifecycle order violation: slot ${index} already belongs to ${slot.kind}(). Keep lifecycle primitives in a stable top-level order.`);
 		return existing;
 	}
 	const slot = create();
-	instance.lifecycleSlots[index] = slot;
+	lifecycleSlots[index] = slot;
 	return slot;
 }
 function routeActive(pathOrPaths) {
@@ -63,7 +64,7 @@ function commitListenerSlot(instance, slot) {
 	}
 	if (!slot.cleanupRegistered) {
 		slot.cleanupRegistered = true;
-		instance.cleanupFns.push(() => {
+		(instance.cleanupFns ??= []).push(() => {
 			detachListenerSlot(slot);
 			slot.cleanupRegistered = false;
 		});
@@ -122,7 +123,7 @@ function commitTimerSlot(instance, slot) {
 	}
 	if (!slot.cleanupRegistered) {
 		slot.cleanupRegistered = true;
-		instance.cleanupFns.push(() => {
+		(instance.cleanupFns ??= []).push(() => {
 			stopTimerSlot(slot);
 			slot.cleanupRegistered = false;
 		});
@@ -191,5 +192,3 @@ function capture(fn) {
 }
 //#endregion
 export { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused };
-
-//# sourceMappingURL=lifecycle-operations.js.map

package/dist/runtime/perf-metrics.d.ts

@@ -17,10 +17,11 @@ type PerfMetrics = {
   ssgWorkerRenderTimeMs: number;
   ssgWriteTimeMs: number;
 };
-declare function getPerfMetricsStore(): PerfMetrics | null;
-declare function incrementPerfMetric(key: 'selectorInvalidations' | 'selectorCandidateReads' | 'reactivePropReevaluations' | 'skippedDomPropWrites' | 'classListPatchOps' | 'delegatedAncestorHops' | 'hydrationBoundaryActivations' | 'ssrTagCacheHits' | 'ssgWorkerCount', delta?: number): void;
-declare function addPerfDuration(key: 'ssgRenderTimeMs' | 'ssgWorkerRenderTimeMs' | 'ssgWriteTimeMs', deltaMs: number): void;
-declare function recordSchedulerFlushTaskCount(taskCount: number): void;
-declare function getPerfMetrics(): Readonly<PerfMetrics> | undefined;
-declare function resetPerfMetrics(): void;
-//# sourceMappingURL=perf-metrics.d.ts.map
+type IncrementPerfMetric = (key: 'selectorInvalidations' | 'selectorCandidateReads' | 'reactivePropReevaluations' | 'skippedDomPropWrites' | 'classListPatchOps' | 'delegatedAncestorHops' | 'hydrationBoundaryActivations' | 'ssrTagCacheHits' | 'ssgWorkerCount', delta?: number) => void;
+type AddPerfDuration = (key: 'ssgRenderTimeMs' | 'ssgWorkerRenderTimeMs' | 'ssgWriteTimeMs', deltaMs: number) => void;
+declare const getPerfMetricsStore: () => PerfMetrics | null;
+declare const incrementPerfMetric: IncrementPerfMetric;
+declare const addPerfDuration: AddPerfDuration;
+declare const recordSchedulerFlushTaskCount: (taskCount: number) => void;
+declare const getPerfMetrics: () => Readonly<PerfMetrics> | undefined;
+declare const resetPerfMetrics: () => void;

package/dist/runtime/perf-metrics.js

@@ -1,70 +1,6 @@
-import { isDevelopmentEnvironment, isRuntimeEnvFlagEnabled } from "../common/env.js";
-//#region src/runtime/perf-metrics.ts
-const BENCH_BUILD_ENABLED = isRuntimeEnvFlagEnabled("ASKR_BENCH");
-let cachedPerfStore;
-function createInitialPerfMetrics() {
-	return {
-		selectorInvalidations: 0,
-		selectorCandidateReads: 0,
-		reactivePropReevaluations: 0,
-		skippedDomPropWrites: 0,
-		classListPatchOps: 0,
-		delegatedAncestorHops: 0,
-		hydrationBoundaryActivations: 0,
-		ssrTagCacheHits: 0,
-		lastSchedulerTaskCountPerFlush: 0,
-		maxSchedulerTaskCountPerFlush: 0,
-		schedulerFlushCount: 0,
-		schedulerTaskExecutions: 0,
-		ssgWorkerCount: 0,
-		ssgRenderTimeMs: 0,
-		ssgWorkerRenderTimeMs: 0,
-		ssgWriteTimeMs: 0
-	};
-}
-function shouldCollectPerfMetrics() {
-	if (isDevelopmentEnvironment()) return true;
-	if (!BENCH_BUILD_ENABLED) return false;
-	try {
-		return !!globalThis.__ASKR_BENCH__;
-	} catch {
-		return false;
-	}
-}
-function getPerfStore() {
-	if (cachedPerfStore) return cachedPerfStore;
-	if (!shouldCollectPerfMetrics()) return null;
-	try {
-		const g = globalThis;
-		if (!g.__ASKR_PERF__) g.__ASKR_PERF__ = createInitialPerfMetrics();
-		cachedPerfStore = g.__ASKR_PERF__;
-		return cachedPerfStore;
-	} catch {
-		return null;
-	}
-}
-function getPerfMetricsStore() {
-	return getPerfStore();
-}
-function incrementPerfMetric(key, delta = 1) {
-	const store = getPerfStore();
-	if (!store) return;
-	store[key] += delta;
-}
-function addPerfDuration(key, deltaMs) {
-	const store = getPerfStore();
-	if (!store) return;
-	store[key] += deltaMs;
-}
-function recordSchedulerFlushTaskCount(taskCount) {
-	const store = getPerfStore();
-	if (!store) return;
-	store.lastSchedulerTaskCountPerFlush = taskCount;
-	store.maxSchedulerTaskCountPerFlush = Math.max(store.maxSchedulerTaskCountPerFlush, taskCount);
-	store.schedulerFlushCount += 1;
-	store.schedulerTaskExecutions += taskCount;
-}
+const getPerfMetricsStore = () => null;
+const incrementPerfMetric = () => {};
+const addPerfDuration = () => {};
+const recordSchedulerFlushTaskCount = () => {};
 //#endregion
 export { addPerfDuration, getPerfMetricsStore, incrementPerfMetric, recordSchedulerFlushTaskCount };
-
-//# sourceMappingURL=perf-metrics.js.map

package/dist/runtime/portal.d.ts

@@ -18,5 +18,4 @@ declare function clearDefaultPortalForInstance(instance: ComponentInstance): voi
 declare const DefaultPortal: Portal<RenderableChild>;
 declare function Portal(props: PortalProps): null;
 //#endregion
-export { DefaultPortal, Portal, PortalProps, definePortal };
-//# sourceMappingURL=portal.d.ts.map
+export { DefaultPortal, Portal, PortalProps, definePortal };

package/dist/runtime/portal.js

@@ -1,6 +1,9 @@
-import { enqueueRuntimeTask } from "./access.js";
+import { enqueueRuntimeTask, getRuntimeRenderer } from "./access.js";
 import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "./readable.js";
 import { getCurrentComponentInstance, getCurrentPortalScope } from "./component-scope.js";
+import { cleanupComponent } from "./component-cleanup.js";
+import { getCurrentLifecycleCommitBatch, registerLifecycleTransaction } from "./lifecycle-batch.js";
+import "./component-lifecycle.js";
 import "./component.js";
 //#region src/runtime/portal.ts
 function createPortalSlot() {
@@ -50,6 +53,8 @@ function definePortal() {
 let _defaultPortalStates = /* @__PURE__ */ new Map();
 let _hasPendingDefaultPortalValue = false;
 let _pendingDefaultPortalValue = void 0;
+let _pendingDefaultPortalWrites = /* @__PURE__ */ new WeakMap();
+const _batchPortalWrites = /* @__PURE__ */ new WeakMap();
 function createExplicitHostSource(readCount) {
 	let source = (() => {
 		recordReadableRead(source);
@@ -69,6 +74,7 @@ function createDefaultPortalState() {
 	const state = {
 		portal: definePortal(),
 		owner: null,
+		host: null,
 		cleanupOwners: /* @__PURE__ */ new WeakSet(),
 		explicitHostOwners: /* @__PURE__ */ new Set(),
 		explicitHostCleanupOwners: /* @__PURE__ */ new WeakSet(),
@@ -91,6 +97,35 @@ function disposeDefaultPortalScope(scope) {
 function isComponentPortalScope(scope) {
 	return Array.isArray(scope.cleanupFns);
 }
+function isEmptyPortalValue(value) {
+	return value === null || value === void 0 || value === false;
+}
+function detachDefaultPortalHostOutput(state) {
+	const host = state.host;
+	const target = host?.target;
+	const parent = target?.parentNode;
+	if (!host || !target || !parent) return;
+	const portalHost = target;
+	const hostedInstances = new Set(portalHost.__ASKR_INSTANCES ?? []);
+	if (portalHost.__ASKR_INSTANCE) hostedInstances.add(portalHost.__ASKR_INSTANCE);
+	for (const instance of hostedInstances) if (instance !== host) cleanupComponent(instance);
+	try {
+		delete portalHost.__ASKR_INSTANCE;
+		delete portalHost.__ASKR_INSTANCES;
+		delete portalHost.__ASKR_WRAPPER_HOST;
+	} catch {}
+	getRuntimeRenderer().teardownNodeSubtree(target);
+	const placeholder = document.createComment("");
+	placeholder.__ASKR_INSTANCE = host;
+	parent.replaceChild(placeholder, target);
+	host.target = null;
+	host._placeholder = placeholder;
+}
+function applyDefaultPortalWrite(state, children, owner) {
+	state.portal.render({ children });
+	state.owner = owner;
+	if (isEmptyPortalValue(children)) detachDefaultPortalHostOutput(state);
+}
 function isStaleDefaultPortalScope(scope) {
 	if (!isComponentPortalScope(scope)) return false;
 	if (scope.target && scope.target.isConnected === false) return true;
@@ -125,10 +160,70 @@ function writeDefaultPortal(props, owner) {
 		return;
 	}
 	const state = getDefaultPortalState(scope);
+	const batch = getCurrentLifecycleCommitBatch();
+	if (batch) {
+		let writes = _batchPortalWrites.get(batch);
+		if (!writes) {
+			writes = /* @__PURE__ */ new Map();
+			_batchPortalWrites.set(batch, writes);
+		}
+		const existing = writes.get(state);
+		if (existing) {
+			existing.owner = owner;
+			existing.children = props.children;
+			return;
+		}
+		const transaction = {
+			state,
+			owner,
+			children: props.children,
+			batch
+		};
+		if (registerLifecycleTransaction(state, () => {
+			if (_batchPortalWrites.get(batch)?.get(state) !== transaction) return;
+			_batchPortalWrites.get(batch)?.delete(state);
+			applyDefaultPortalWrite(state, transaction.children, transaction.owner);
+		}, () => {
+			if (_batchPortalWrites.get(batch)?.get(state) === transaction) _batchPortalWrites.get(batch)?.delete(state);
+		}, () => {
+			const parentBatch = batch.parent;
+			const parentWrite = parentBatch ? _batchPortalWrites.get(parentBatch)?.get(state) : void 0;
+			if (parentWrite) {
+				parentWrite.owner = transaction.owner;
+				parentWrite.children = transaction.children;
+			}
+			_batchPortalWrites.get(batch)?.delete(state);
+		})) {
+			writes.set(state, transaction);
+			return;
+		}
+	}
+	const pending = _pendingDefaultPortalWrites.get(state);
+	if (pending) {
+		pending.owner = owner;
+		pending.children = props.children;
+		return;
+	}
+	const transaction = {
+		state,
+		owner,
+		children: props.children
+	};
+	if (registerLifecycleTransaction(transaction, () => {
+		if (_pendingDefaultPortalWrites.get(state) !== transaction) return;
+		_pendingDefaultPortalWrites.delete(state);
+		_hasPendingDefaultPortalValue = false;
+		_pendingDefaultPortalValue = void 0;
+		applyDefaultPortalWrite(state, transaction.children, transaction.owner);
+	}, () => {
+		if (_pendingDefaultPortalWrites.get(state) === transaction) _pendingDefaultPortalWrites.delete(state);
+	})) {
+		_pendingDefaultPortalWrites.set(state, transaction);
+		return;
+	}
 	_hasPendingDefaultPortalValue = false;
 	_pendingDefaultPortalValue = void 0;
-	state.portal.render(props);
-	state.owner = owner;
+	applyDefaultPortalWrite(state, props.children, owner);
 }
 function applyPendingDefaultPortalValue(scope) {
 	if (!_hasPendingDefaultPortalValue) return;
@@ -144,13 +239,10 @@ function registerDefaultPortalOwner(owner) {
 	const state = getDefaultPortalState(scope);
 	if (state.cleanupOwners.has(owner)) return;
 	state.cleanupOwners.add(owner);
-	owner.cleanupFns.push(() => {
+	(owner.cleanupFns ??= []).push(() => {
 		const currentState = _defaultPortalStates.get(scope);
 		if (!currentState) return;
-		if (currentState.owner === owner) {
-			currentState.portal.render({ children: void 0 });
-			currentState.owner = null;
-		}
+		if (currentState.owner === owner) applyDefaultPortalWrite(currentState, void 0, null);
 		currentState.cleanupOwners.delete(owner);
 	});
 }
@@ -162,7 +254,7 @@ function registerExplicitDefaultPortalHost(scope, state, owner) {
 	}
 	if (!state.explicitHostCleanupOwners.has(owner)) {
 		state.explicitHostCleanupOwners.add(owner);
-		owner.cleanupFns.push(() => {
+		(owner.cleanupFns ??= []).push(() => {
 			if (_defaultPortalStates.get(scope) !== state) return;
 			state.explicitHostCleanupOwners.delete(owner);
 			enqueueRuntimeTask(() => {
@@ -182,6 +274,7 @@ function clearDefaultPortalForInstance(instance) {
 	_pendingDefaultPortalValue = void 0;
 	state.portal.render({ children: void 0 });
 	state.owner = null;
+	detachDefaultPortalHostOutput(state);
 }
 const DefaultPortal = (() => {
 	function Host(props) {
@@ -189,6 +282,7 @@ const DefaultPortal = (() => {
 		const scope = resolveDefaultPortalScope(owner);
 		if (!scope) return null;
 		const state = getDefaultPortalState(scope);
+		state.host = owner;
 		if (!(props?.__askrAutoDefaultPortal === true)) registerExplicitDefaultPortalHost(scope, state, owner);
 		else if (readExplicitDefaultPortalHosts(state) > 0) return null;
 		applyPendingDefaultPortalValue(scope);
@@ -209,5 +303,3 @@ function Portal(props) {
 }
 //#endregion
 export { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope };
-
-//# sourceMappingURL=portal.js.map

package/dist/runtime/readable.d.ts

@@ -12,9 +12,15 @@ interface ReadableSource<T = unknown> {
   _derivedSubscribers?: Set<DerivedSubscriber>;
   _version?: number;
 }
+interface FineGrainedReadCollector {
+  _pendingFineGrainedReadSource: ReadableSource<unknown> | null;
+  _pendingFineGrainedReadSources: ReadableSource<unknown> | ReadableSource<unknown>[] | Set<ReadableSource<unknown>> | null;
+}
 declare function markReadableUsage(source: unknown): void;
 declare function recordReadableRead(source: ReadableSource<unknown>): void;
-declare function withFineGrainedReadTracking<T>(pendingSources: Set<ReadableSource<unknown>>, fn: () => T): T;
+declare function withFineGrainedReadTracking<T>(collector: FineGrainedReadCollector, fn: () => T): T;
+/** @internal Whether the active grouped effect coalesces item-property reads. */
+declare function shouldCoalesceFineGrainedItemReads(): boolean;
 declare function finalizeReadableSubscriptions(instance: ComponentInstance): void;
 declare function finalizeReadableSubscriptionsFromSnapshot(instance: ComponentInstance, token: number | undefined, newSet: Set<ReadableSource<unknown>> | undefined, pendingReadSourceVersions?: Map<ReadableSource<unknown>, number> | undefined): void;
 declare function cleanupReadableSubscriptions(instance: ComponentInstance): void;
@@ -23,7 +29,6 @@ declare function syncDerivedDependencySubscriptions(subscriber: DerivedSubscribe
 declare function clearDerivedDependencySubscriptions(subscriber: DerivedSubscriber, sources: Set<ReadableSource<unknown>>): void;
 declare function markReadableDerivedSubscribersDirty(source: ReadableSource<unknown>): void;
 declare function markReactivePropsDirtySource(source: ReadableSource<unknown>): void;
-declare function notifyReadableReaders(source: ReadableSource<unknown>, skipInstance?: ComponentInstance | null): boolean;
+declare function notifyReadableReaders(source: ReadableSource<unknown>, skipInstance?: ComponentInstance | null, skipOwnedBy?: ComponentInstance | null): boolean;
 //#endregion
-export { DerivedSubscriber, ReadableSource };
-//# sourceMappingURL=readable.d.ts.map
+export { DerivedSubscriber, FineGrainedReadCollector, ReadableSource };

package/dist/runtime/readable.js

@@ -1,17 +1,15 @@
 import { enqueueRuntimeTask, markRuntimeReactivePropsDirtySource } from "./access.js";
 import { getCurrentInstance } from "./component-scope.js";
 import "./component.js";
-//#region src/runtime/readable.ts
 function markReadableUsage(source) {
 	if (source && typeof source === "function" && ("_hasBeenRead" in source || "_readers" in source)) {
 		const readable = source;
 		readable._hasBeenRead = true;
-		readable._hasEverBeenRead = true;
 	}
 }
 let currentDerivedSubscriber = null;
 let suppressComponentReadTrackingDepth = 0;
-let currentFineGrainedReadSources = null;
+let currentFineGrainedReadCollector = null;
 function scheduleReadableInstanceUpdate(instance) {
 	if (instance.hasPendingUpdate) return;
 	instance.hasPendingUpdate = true;
@@ -26,9 +24,21 @@ function scheduleReadableInstanceUpdate(instance) {
 	});
 }
 function recordReadableRead(source) {
-	source._hasEverBeenRead = true;
-	if (currentFineGrainedReadSources) {
-		currentFineGrainedReadSources.add(source);
+	if (currentFineGrainedReadCollector) {
+		const first = currentFineGrainedReadCollector._pendingFineGrainedReadSource;
+		if (!first) currentFineGrainedReadCollector._pendingFineGrainedReadSource = source;
+		else if (first !== source) {
+			let sources = currentFineGrainedReadCollector._pendingFineGrainedReadSources;
+			if (!sources) currentFineGrainedReadCollector._pendingFineGrainedReadSources = source;
+			else if (Array.isArray(sources)) {
+				if (!sources.includes(source)) sources.push(source);
+			} else if (sources instanceof Set) sources.add(source);
+			else if (sources !== source) currentFineGrainedReadCollector._pendingFineGrainedReadSources = [
+				first,
+				sources,
+				source
+			];
+		}
 		return;
 	}
 	if (currentDerivedSubscriber) {
@@ -48,15 +58,19 @@ function recordReadableRead(source) {
 	}
 	pendingVersions.set(source, sourceVersion);
 }
-function withFineGrainedReadTracking(pendingSources, fn) {
-	const previousPendingSources = currentFineGrainedReadSources;
-	currentFineGrainedReadSources = pendingSources;
+function withFineGrainedReadTracking(collector, fn) {
+	const previousCollector = currentFineGrainedReadCollector;
+	currentFineGrainedReadCollector = collector;
 	try {
-		return fn();
+		return fn.call(collector);
 	} finally {
-		currentFineGrainedReadSources = previousPendingSources;
+		currentFineGrainedReadCollector = previousCollector;
 	}
 }
+/** @internal Whether the active grouped effect coalesces item-property reads. */
+function shouldCoalesceFineGrainedItemReads() {
+	return (currentFineGrainedReadCollector?._owner)?._coalesceForItemReads === true;
+}
 function finalizeReadableSubscriptions(instance) {
 	const newSet = instance._pendingReadSources;
 	const token = instance._currentRenderToken;
@@ -88,7 +102,7 @@ function finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pend
 		}
 		readers.set(instance, instance.lastRenderToken ?? 0);
 	}
-	instance._lastReadSources = newSet ?? /* @__PURE__ */ new Set();
+	instance._lastReadSources = newSet?.size ? newSet : void 0;
 	if (needsFollowUpUpdate) scheduleReadableInstanceUpdate(instance);
 }
 function cleanupReadableSubscriptions(instance) {
@@ -99,7 +113,7 @@ function cleanupReadableSubscriptions(instance) {
 		return;
 	}
 	for (const source of sources) source._readers?.delete(instance);
-	instance._lastReadSources = /* @__PURE__ */ new Set();
+	instance._lastReadSources = void 0;
 	instance._pendingReadSources = void 0;
 	instance._pendingReadSourceVersions = void 0;
 }
@@ -139,13 +153,25 @@ function markReactivePropsDirtySource(source) {
 		markRuntimeReactivePropsDirtySource(source);
 	} catch {}
 }
-function notifyReadableReaders(source, skipInstance) {
+function notifyReadableReaders(source, skipInstance, skipOwnedBy) {
 	source._version = (source._version ?? 0) + 1;
 	const readers = source._readers;
 	let didScheduleUpdate = false;
 	if (!readers || readers.size === 0) return false;
 	for (const [instance, token] of readers) {
 		if (skipInstance && instance === skipInstance) continue;
+		if (skipOwnedBy) {
+			let owner = instance;
+			let isOwned = false;
+			while (owner) {
+				if (owner === skipOwnedBy) {
+					isOwned = true;
+					break;
+				}
+				owner = owner.parentInstance;
+			}
+			if (isOwned) continue;
+		}
 		if (instance.lastRenderToken !== token) continue;
 		if (instance.hasPendingUpdate) continue;
 		scheduleReadableInstanceUpdate(instance);
@@ -154,6 +180,4 @@ function notifyReadableReaders(source, skipInstance) {
 	return didScheduleUpdate;
 }
 //#endregion
-export { cleanupReadableSubscriptions, clearDerivedDependencySubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, syncDerivedDependencySubscriptions, withDerivedReadTracking, withFineGrainedReadTracking };
-
-//# sourceMappingURL=readable.js.map
+export { cleanupReadableSubscriptions, clearDerivedDependencySubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads, syncDerivedDependencySubscriptions, withDerivedReadTracking, withFineGrainedReadTracking };

package/dist/runtime/resource-cell.js

@@ -59,7 +59,7 @@ var ResourceCell = class {
 			result = withAsyncResourceContext(this.resourceFrame, () => this.fn({ signal: controller.signal }));
 		} catch (err) {
 			this.pending = false;
-			this.error = err;
+			this.error = err instanceof Error ? err : new Error(String(err));
 			if (notify) this.notifySubscribers();
 			return;
 		}
@@ -84,7 +84,7 @@ var ResourceCell = class {
 			if (this.controller !== controller) return;
 			if (controller.signal.aborted || err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError") return;
 			this.pending = false;
-			this.error = err;
+			this.error = err instanceof Error ? err : new Error(String(err));
 			try {
 				if (this.ownerName) logger.error(`[Askr] Async resource error in ${this.ownerName}:`, err);
 				else logger.error("[Askr] Async resource error:", err);
@@ -110,5 +110,3 @@ var ResourceCell = class {
 };
 //#endregion
 export { ResourceCell };
-
-//# sourceMappingURL=resource-cell.js.map

package/dist/runtime/resource-operation.d.ts

@@ -9,5 +9,4 @@ declare function resource<T, const TDeps extends readonly unknown[]>(fn: (opts:
   signal: AbortSignal;
 }) => PromiseLike<T> | T, deps: TDeps): ResourceResult<T>;
 //#endregion
-export { ResourceResult, resource };
-//# sourceMappingURL=resource-operation.d.ts.map
+export { ResourceResult, resource };

package/dist/runtime/resource-operation.js

@@ -1,6 +1,7 @@
 import { enqueueRuntimeLane } from "./access.js";
 import { getCurrentContextFrame } from "./context.js";
 import { getCurrentComponentInstance } from "./component-scope.js";
+import { registerCommitOperationForInstance } from "./component-lifecycle.js";
 import "./component.js";
 import { brandSnapshotSource } from "./snapshot-source.js";
 import { SSRDataMissingError } from "../common/ssr-errors.js";
@@ -95,27 +96,29 @@ function resource(fn, deps = []) {
 			}
 		} else {
 			const scheduledGeneration = cell.generation;
-			enqueueRuntimeLane("post", () => {
-				if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
-				try {
-					cell.start(false, false);
-				} catch (err) {
-					const cur = holder();
-					cur.snapshot.value = cell.value;
-					cur.snapshot.pending = cell.pending;
-					cur.snapshot.error = err ?? null;
-					holder.set(cur);
-					inst.notifyUpdate?.();
-					return;
-				}
-				if (!cell.pending) {
-					const cur = holder();
-					cur.snapshot.value = cell.value;
-					cur.snapshot.pending = cell.pending;
-					cur.snapshot.error = cell.error;
-					holder.set(cur);
-					inst.notifyUpdate?.();
-				}
+			registerCommitOperationForInstance(inst, () => {
+				enqueueRuntimeLane("post", () => {
+					if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+					try {
+						cell.start(false, false);
+					} catch (err) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = err ?? null;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+						return;
+					}
+					if (!cell.pending) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = cell.error;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+					}
+				});
 			});
 		}
 	}
@@ -139,17 +142,19 @@ function resource(fn, deps = []) {
 				}
 			} else {
 				const scheduledGeneration = cell.generation;
-				enqueueRuntimeLane("post", () => {
-					if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
-					cell.start(false, false);
-					if (!cell.pending) {
-						const cur = holder();
-						cur.snapshot.value = cell.value;
-						cur.snapshot.pending = cell.pending;
-						cur.snapshot.error = cell.error;
-						holder.set(cur);
-						inst.notifyUpdate?.();
-					}
+				registerCommitOperationForInstance(inst, () => {
+					enqueueRuntimeLane("post", () => {
+						if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+						cell.start(false, false);
+						if (!cell.pending) {
+							const cur = holder();
+							cur.snapshot.value = cell.value;
+							cur.snapshot.pending = cell.pending;
+							cur.snapshot.error = cell.error;
+							holder.set(cur);
+							inst.notifyUpdate?.();
+						}
+					});
 				});
 			}
 		} catch (err) {
@@ -166,5 +171,3 @@ function resource(fn, deps = []) {
 }
 //#endregion
 export { resource };
-
-//# sourceMappingURL=resource-operation.js.map