@askrjs/askr 0.0.52 → 0.0.54

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

@@ -1,59 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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;

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

@@ -1,51 +0,0 @@
-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

@@ -1,30 +0,0 @@
-//#region src/runtime/lifecycle-operations.d.ts
-type ActivityPredicate = () => boolean;
-interface TimerOptions {
-  when?: ActivityPredicate | readonly ActivityPredicate[];
-}
-declare function routeActive(pathOrPaths: string | readonly string[]): ActivityPredicate;
-declare function documentVisible(): ActivityPredicate;
-declare function windowFocused(): ActivityPredicate;
-type ListenerOptions = boolean | AddEventListenerOptions | undefined;
-declare function on(target: EventTarget, event: string, handler: EventListener, options?: ListenerOptions): void;
-declare function timer(intervalMs: number, fn: () => void, options?: TimerOptions): void;
-declare function stream<T>(_source: unknown, _options?: Record<string, unknown>): {
-  value: T | null;
-  pending: boolean;
-  error: Error | null;
-};
-declare function task(fn: () => void | (() => void) | PromiseLike<void | (() => void)>): void;
-/**
- * Capture the result of a synchronous expression at call time and return a
- * thunk that returns the captured value later. This is a low-level helper for
- * cases where async continuations need to observe a snapshot of values at the
- * moment scheduling occurred.
- *
- * Usage (public API):
- * const snapshot = capture(() => someState());
- * Promise.resolve().then(() => { use(snapshot()); });
- */
-declare function capture<T>(fn: () => T): () => T;
-//#endregion
-export { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused };

package/dist/runtime/operations.d.ts

@@ -1,3 +0,0 @@
-import { ResourceResult, resource } from "./resource-operation.js";
-import { ActivityPredicate, TimerOptions, capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
-export { type ActivityPredicate, type ResourceResult, type TimerOptions, capture, documentVisible, on, resource, routeActive, stream, task, timer, windowFocused };

package/dist/runtime/operations.js

@@ -1,3 +0,0 @@
-import { resource } from "./resource-operation.js";
-import { capture, documentVisible, on, routeActive, stream, task, timer, windowFocused } from "./lifecycle-operations.js";
-export { capture, documentVisible, on, resource, routeActive, stream, task, timer, windowFocused };

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

@@ -1,27 +0,0 @@
-//#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,6 +0,0 @@
-const getPerfMetricsStore = () => null;
-const incrementPerfMetric = () => {};
-const addPerfDuration = () => {};
-const recordSchedulerFlushTaskCount = () => {};
-//#endregion
-export { addPerfDuration, getPerfMetricsStore, incrementPerfMetric, recordSchedulerFlushTaskCount };

package/dist/runtime/portal.d.ts

@@ -1,21 +0,0 @@
-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/readable.d.ts

@@ -1,34 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-//#region src/runtime/readable.d.ts
-interface DerivedSubscriber {
-  _markDirty(): void;
-  _pendingDependencySources?: Set<ReadableSource<unknown>>;
-}
-interface ReadableSource<T = unknown> {
-  (): T;
-  _hasBeenRead?: boolean;
-  _hasEverBeenRead?: boolean;
-  _readers?: Map<ComponentInstance, number>;
-  _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>(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;
-declare function withDerivedReadTracking<T>(subscriber: DerivedSubscriber, fn: () => T): T;
-declare function syncDerivedDependencySubscriptions(subscriber: DerivedSubscriber, prevSources: Set<ReadableSource<unknown>>, nextSources: Set<ReadableSource<unknown>>): void;
-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, skipOwnedBy?: ComponentInstance | null): boolean;
-//#endregion
-export { DerivedSubscriber, FineGrainedReadCollector, ReadableSource };

package/dist/runtime/readable.js

@@ -1,183 +0,0 @@
-import { enqueueRuntimeTask, markRuntimeReactivePropsDirtySource } from "./access.js";
-import { getCurrentInstance } from "./component-scope.js";
-import "./component.js";
-function markReadableUsage(source) {
-	if (source && typeof source === "function" && ("_hasBeenRead" in source || "_readers" in source)) {
-		const readable = source;
-		readable._hasBeenRead = true;
-	}
-}
-let currentDerivedSubscriber = null;
-let suppressComponentReadTrackingDepth = 0;
-let currentFineGrainedReadCollector = null;
-function scheduleReadableInstanceUpdate(instance) {
-	if (instance.hasPendingUpdate) return;
-	instance.hasPendingUpdate = true;
-	const task = instance._pendingFlushTask;
-	if (task) {
-		enqueueRuntimeTask(task);
-		return;
-	}
-	enqueueRuntimeTask(() => {
-		instance.hasPendingUpdate = false;
-		instance.notifyUpdate?.();
-	});
-}
-function recordReadableRead(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) {
-		if (!currentDerivedSubscriber._pendingDependencySources) currentDerivedSubscriber._pendingDependencySources = /* @__PURE__ */ new Set();
-		currentDerivedSubscriber._pendingDependencySources.add(source);
-	}
-	if (suppressComponentReadTrackingDepth > 0) return;
-	const inst = getCurrentInstance();
-	if (!inst || inst._currentRenderToken === void 0) return;
-	if (!inst._pendingReadSources) inst._pendingReadSources = /* @__PURE__ */ new Set();
-	inst._pendingReadSources.add(source);
-	const sourceVersion = source._version ?? 0;
-	let pendingVersions = inst._pendingReadSourceVersions;
-	if (!pendingVersions) {
-		pendingVersions = /* @__PURE__ */ new Map();
-		inst._pendingReadSourceVersions = pendingVersions;
-	}
-	pendingVersions.set(source, sourceVersion);
-}
-function withFineGrainedReadTracking(collector, fn) {
-	const previousCollector = currentFineGrainedReadCollector;
-	currentFineGrainedReadCollector = collector;
-	try {
-		return fn.call(collector);
-	} finally {
-		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;
-	const pendingVersions = instance._pendingReadSourceVersions;
-	finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pendingVersions);
-	instance._pendingReadSources = void 0;
-	instance._currentRenderToken = void 0;
-	instance._pendingReadSourceVersions = void 0;
-}
-function finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pendingReadSourceVersions = instance._pendingReadSourceVersions) {
-	if (token === void 0) return;
-	const oldSet = instance._lastReadSources;
-	const pendingVersions = pendingReadSourceVersions;
-	let needsFollowUpUpdate = false;
-	if (oldSet) {
-		for (const source of oldSet) if (!newSet?.has(source)) source._readers?.delete(instance);
-	}
-	instance.lastRenderToken = token;
-	if (newSet) for (const source of newSet) {
-		if (pendingVersions && (!oldSet || oldSet.has(source))) {
-			const sourceVersion = source._version ?? 0;
-			const readVersion = pendingVersions.get(source);
-			if (readVersion !== void 0 && sourceVersion !== readVersion) needsFollowUpUpdate = true;
-		}
-		let readers = source._readers;
-		if (!readers) {
-			readers = /* @__PURE__ */ new Map();
-			source._readers = readers;
-		}
-		readers.set(instance, instance.lastRenderToken ?? 0);
-	}
-	instance._lastReadSources = newSet?.size ? newSet : void 0;
-	if (needsFollowUpUpdate) scheduleReadableInstanceUpdate(instance);
-}
-function cleanupReadableSubscriptions(instance) {
-	const sources = instance._lastReadSources;
-	if (!sources || sources.size === 0) {
-		instance._pendingReadSources = void 0;
-		instance._pendingReadSourceVersions = void 0;
-		return;
-	}
-	for (const source of sources) source._readers?.delete(instance);
-	instance._lastReadSources = void 0;
-	instance._pendingReadSources = void 0;
-	instance._pendingReadSourceVersions = void 0;
-}
-function withDerivedReadTracking(subscriber, fn) {
-	const prevDerivedSubscriber = currentDerivedSubscriber;
-	currentDerivedSubscriber = subscriber;
-	suppressComponentReadTrackingDepth += 1;
-	try {
-		return fn();
-	} finally {
-		suppressComponentReadTrackingDepth -= 1;
-		currentDerivedSubscriber = prevDerivedSubscriber;
-	}
-}
-function syncDerivedDependencySubscriptions(subscriber, prevSources, nextSources) {
-	for (const source of prevSources) if (!nextSources.has(source)) source._derivedSubscribers?.delete(subscriber);
-	for (const source of nextSources) {
-		let subscribers = source._derivedSubscribers;
-		if (!subscribers) {
-			subscribers = /* @__PURE__ */ new Set();
-			source._derivedSubscribers = subscribers;
-		}
-		subscribers.add(subscriber);
-	}
-}
-function clearDerivedDependencySubscriptions(subscriber, sources) {
-	for (const source of sources) source._derivedSubscribers?.delete(subscriber);
-	sources.clear();
-}
-function markReadableDerivedSubscribersDirty(source) {
-	const subscribers = source._derivedSubscribers;
-	if (!subscribers || subscribers.size === 0) return;
-	for (const subscriber of subscribers) subscriber._markDirty();
-}
-function markReactivePropsDirtySource(source) {
-	try {
-		markRuntimeReactivePropsDirtySource(source);
-	} catch {}
-}
-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);
-		didScheduleUpdate = true;
-	}
-	return didScheduleUpdate;
-}
-//#endregion
-export { cleanupReadableSubscriptions, clearDerivedDependencySubscriptions, finalizeReadableSubscriptions, finalizeReadableSubscriptionsFromSnapshot, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, shouldCoalesceFineGrainedItemReads, syncDerivedDependencySubscriptions, withDerivedReadTracking, withFineGrainedReadTracking };