@askrjs/askr 0.0.50 → 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

@@ -0,0 +1,27 @@
+//#region src/runtime/perf-metrics.d.ts
+type PerfMetrics = {
+  selectorInvalidations: number;
+  selectorCandidateReads: number;
+  reactivePropReevaluations: number;
+  skippedDomPropWrites: number;
+  classListPatchOps: number;
+  delegatedAncestorHops: number;
+  hydrationBoundaryActivations: number;
+  ssrTagCacheHits: number;
+  lastSchedulerTaskCountPerFlush: number;
+  maxSchedulerTaskCountPerFlush: number;
+  schedulerFlushCount: number;
+  schedulerTaskExecutions: number;
+  ssgWorkerCount: number;
+  ssgRenderTimeMs: number;
+  ssgWorkerRenderTimeMs: number;
+  ssgWriteTimeMs: number;
+};
+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

@@ -0,0 +1,21 @@
+import { ComponentInstance } from "./component-internal.js";
+import { RenderableChild } from "../common/vnode.js";
+
+//#region src/runtime/portal.d.ts
+interface Portal<T extends RenderableChild = RenderableChild> {
+  (): unknown;
+  render(props: {
+    children?: T;
+  }): unknown;
+}
+interface PortalProps {
+  children?: RenderableChild;
+}
+declare function definePortal<T extends RenderableChild = RenderableChild>(): Portal<T>;
+declare function _resetDefaultPortal(): void;
+declare function disposeDefaultPortalScope(scope: object | null): void;
+declare function clearDefaultPortalForInstance(instance: ComponentInstance): void;
+declare const DefaultPortal: Portal<RenderableChild>;
+declare function Portal(props: PortalProps): null;
+//#endregion
+export { DefaultPortal, Portal, PortalProps, definePortal };

package/dist/runtime/portal.js

@@ -0,0 +1,305 @@
+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() {
+	let currentValue;
+	const source = (() => {
+		recordReadableRead(source);
+		return currentValue;
+	});
+	return {
+		read() {
+			return source();
+		},
+		write(value) {
+			if (Object.is(currentValue, value)) return;
+			currentValue = value;
+			markReadableDerivedSubscribersDirty(source);
+			markReactivePropsDirtySource(source);
+			notifyReadableReaders(source);
+		}
+	};
+}
+function definePortal() {
+	if (typeof createPortalSlot === "function") {
+		const slot = createPortalSlot();
+		function PortalHost() {
+			return slot.read();
+		}
+		PortalHost.render = function PortalRender(props) {
+			slot.write(props.children);
+			return null;
+		};
+		return PortalHost;
+	}
+	let mounted = false;
+	let value;
+	function PortalHostFallback() {
+		mounted = true;
+		return value;
+	}
+	PortalHostFallback.render = function PortalRenderFallback(props) {
+		if (!mounted) return null;
+		value = props.children;
+		return null;
+	};
+	return PortalHostFallback;
+}
+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);
+		return readCount();
+	});
+	return source;
+}
+function readExplicitDefaultPortalHosts(state) {
+	return state.explicitHostSource();
+}
+function notifyExplicitDefaultPortalHostReaders(state) {
+	markReadableDerivedSubscribersDirty(state.explicitHostSource);
+	markReactivePropsDirtySource(state.explicitHostSource);
+	notifyReadableReaders(state.explicitHostSource);
+}
+function createDefaultPortalState() {
+	const state = {
+		portal: definePortal(),
+		owner: null,
+		host: null,
+		cleanupOwners: /* @__PURE__ */ new WeakSet(),
+		explicitHostOwners: /* @__PURE__ */ new Set(),
+		explicitHostCleanupOwners: /* @__PURE__ */ new WeakSet(),
+		explicitHostSource: (() => 0)
+	};
+	state.explicitHostSource = createExplicitHostSource(() => state.explicitHostOwners.size);
+	return state;
+}
+function isExplicitHostOwnerConnected(owner) {
+	if (owner.target) return owner.target.isConnected;
+	if (owner._placeholder) return owner._placeholder.isConnected;
+	return owner.mounted;
+}
+function disposeDefaultPortalScope(scope) {
+	if (!scope) return;
+	const state = _defaultPortalStates.get(scope);
+	if (state) state.portal.render({ children: void 0 });
+	_defaultPortalStates.delete(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;
+	return scope.mounted === false;
+}
+function pruneStaleDefaultPortalScopes() {
+	if (_defaultPortalStates.size === 0) return;
+	for (const scope of Array.from(_defaultPortalStates.keys())) if (isStaleDefaultPortalScope(scope)) disposeDefaultPortalScope(scope);
+}
+function getSingleDefaultPortalScope() {
+	pruneStaleDefaultPortalScopes();
+	if (_defaultPortalStates.size !== 1) return null;
+	return _defaultPortalStates.keys().next().value ?? null;
+}
+function getDefaultPortalState(scope) {
+	let state = _defaultPortalStates.get(scope);
+	if (!state) {
+		state = createDefaultPortalState();
+		_defaultPortalStates.set(scope, state);
+	}
+	return state;
+}
+function resolveDefaultPortalScope(owner) {
+	return owner?.portalScope ?? getCurrentPortalScope() ?? getSingleDefaultPortalScope();
+}
+function writeDefaultPortal(props, owner) {
+	const scope = resolveDefaultPortalScope(owner);
+	if (!scope) {
+		if (_defaultPortalStates.size !== 0) return;
+		_hasPendingDefaultPortalValue = true;
+		_pendingDefaultPortalValue = props.children;
+		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;
+	applyDefaultPortalWrite(state, props.children, owner);
+}
+function applyPendingDefaultPortalValue(scope) {
+	if (!_hasPendingDefaultPortalValue) return;
+	const state = getDefaultPortalState(scope);
+	state.portal.render({ children: _pendingDefaultPortalValue });
+	state.owner = null;
+	_hasPendingDefaultPortalValue = false;
+	_pendingDefaultPortalValue = void 0;
+}
+function registerDefaultPortalOwner(owner) {
+	const scope = resolveDefaultPortalScope(owner);
+	if (!scope) return;
+	const state = getDefaultPortalState(scope);
+	if (state.cleanupOwners.has(owner)) return;
+	state.cleanupOwners.add(owner);
+	(owner.cleanupFns ??= []).push(() => {
+		const currentState = _defaultPortalStates.get(scope);
+		if (!currentState) return;
+		if (currentState.owner === owner) applyDefaultPortalWrite(currentState, void 0, null);
+		currentState.cleanupOwners.delete(owner);
+	});
+}
+function registerExplicitDefaultPortalHost(scope, state, owner) {
+	if (!owner) return;
+	if (!state.explicitHostOwners.has(owner)) {
+		state.explicitHostOwners.add(owner);
+		notifyExplicitDefaultPortalHostReaders(state);
+	}
+	if (!state.explicitHostCleanupOwners.has(owner)) {
+		state.explicitHostCleanupOwners.add(owner);
+		(owner.cleanupFns ??= []).push(() => {
+			if (_defaultPortalStates.get(scope) !== state) return;
+			state.explicitHostCleanupOwners.delete(owner);
+			enqueueRuntimeTask(() => {
+				if (_defaultPortalStates.get(scope) !== state) return;
+				if (isExplicitHostOwnerConnected(owner)) return;
+				if (state.explicitHostOwners.delete(owner)) notifyExplicitDefaultPortalHostReaders(state);
+			});
+		});
+	}
+}
+function clearDefaultPortalForInstance(instance) {
+	const scope = instance.portalScope;
+	if (!scope) return;
+	const state = _defaultPortalStates.get(scope);
+	if (!state) return;
+	_hasPendingDefaultPortalValue = false;
+	_pendingDefaultPortalValue = void 0;
+	state.portal.render({ children: void 0 });
+	state.owner = null;
+	detachDefaultPortalHostOutput(state);
+}
+const DefaultPortal = (() => {
+	function Host(props) {
+		const owner = getCurrentComponentInstance();
+		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);
+		const value = state.portal();
+		return value === void 0 ? null : value;
+	}
+	Host.render = function Render(props) {
+		writeDefaultPortal(props, getCurrentComponentInstance());
+		return null;
+	};
+	return Host;
+})();
+function Portal(props) {
+	const owner = getCurrentComponentInstance();
+	if (owner) registerDefaultPortalOwner(owner);
+	writeDefaultPortal(props, owner);
+	return null;
+}
+//#endregion
+export { DefaultPortal, Portal, clearDefaultPortalForInstance, definePortal, disposeDefaultPortalScope };

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 };