@askrjs/askr 0.2.4 → 0.3.1

package/dist/{navigate-F4sHgWbw.d.ts → navigation.d.ts}

@@ -1,5 +1,4 @@
-import "./index-Dgjbo2gU.js";
-//#region src/router/navigation-scroll.d.ts
+import './core.js';
 /** Scroll behavior for programmatic navigations (`navigate()`). */
 type NavigationScrollBehavior = 'top' | 'preserve';
 /** Scroll behavior for browser back/forward (popstate) navigations. */
@@ -9,8 +8,6 @@ type ScrollRestorationOptions = {
   navigation?: NavigationScrollBehavior;
   history?: HistoryScrollBehavior;
 };
-//#endregion
-//#region src/router/navigation-targets.d.ts
 /** Options for {@link navigate}. */
 type NavigateOptions = {
   history?: 'push' | 'replace';
@@ -19,9 +16,12 @@ type NavigateOptions = {
   /** Entry-local browser history state. It is not serialized into the URL or sent to the server. */
   state?: unknown;
 };
-//#endregion
-//#region src/router/navigate.d.ts
 /** Navigate the client-side router to `path` using the History API. */
 declare function navigate(path: string, options?: NavigateOptions): void;
-//#endregion
-export { ScrollRestorationOptions as a, NavigationScrollBehavior as i, NavigateOptions as n, HistoryScrollBehavior as r, navigate as t };
+export {
+  ScrollRestorationOptions,
+  NavigationScrollBehavior,
+  NavigateOptions,
+  HistoryScrollBehavior,
+  navigate,
+};

package/dist/{readable-Di1fzSwm.js → notify-DxxuDPeY.js}

@@ -1,6 +1,6 @@
-import { c as markRuntimeReactivePropsDirtySource, n as enqueueRuntimeTask, s as isRuntimeSchedulerExecuting } from "./access-BucjYZcX.js";
-import { p as getCurrentInstance } from "./component-scope-4I3yEMkb.js";
-//#region src/runtime/readable.ts
+import { _ as defaultRuntimeState, d as markRuntimeReactivePropsDirtySource, n as enqueueRuntimeTask, u as isRuntimeSchedulerExecuting } from "./access-CEA2pOry.js";
+import { f as getCurrentComponentInstance } from "./scope-Cq_iYbTR.js";
+//#region src/runtime/reactivity/readable.ts
 const DEVELOPMENT_BUILD_ENABLED = false;
 function markReadableUsage(source) {
 	if (source && typeof source === "function" && ("_hasBeenRead" in source || "_readers" in source)) {
@@ -13,7 +13,7 @@ let currentDerivedSubscriber = null;
 let suppressComponentReadTrackingDepth = 0;
 let currentFineGrainedReadCollector = null;
 function scheduleReadableInstanceUpdate(instance) {
-	if (instance.hasPendingUpdate) return;
+	if (instance.owner.disposed || instance.hasPendingUpdate) return;
 	instance.hasPendingUpdate = true;
 	const task = instance._pendingFlushTask;
 	if (task) {
@@ -49,7 +49,7 @@ function recordReadableRead(source) {
 		currentDerivedSubscriber._pendingDependencySources.add(source);
 	}
 	if (suppressComponentReadTrackingDepth > 0) return;
-	const inst = getCurrentInstance();
+	const inst = getCurrentComponentInstance();
 	if (!inst || inst._currentRenderToken === void 0) return;
 	if (!inst._pendingReadSources) inst._pendingReadSources = /* @__PURE__ */ new Set();
 	inst._pendingReadSources.add(source);
@@ -74,23 +74,14 @@ function withFineGrainedReadTracking(collector, fn) {
 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, ownershipGeneration = instance._ownershipGeneration) {
-	if (token === void 0 || instance._ownershipGeneration !== ownershipGeneration || !instance.mounted && instance.notifyUpdate === null) return;
-	const oldSet = instance._lastReadSources;
+function finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pendingReadSourceVersions = instance._pendingReadSourceVersions, ownershipGeneration = instance.owner.identity) {
+	if (instance.owner.disposed || token === void 0 || instance.owner.identity !== ownershipGeneration || !instance.owner.mounted && instance.notifyUpdate === null) return;
+	const oldSet = instance.owner.reads;
 	const pendingVersions = pendingReadSourceVersions;
 	let needsFollowUpUpdate = false;
 	if (oldSet) {
 		for (const source of oldSet) if (!newSet?.has(source)) {
-			if ((source._readers?.get(instance))?.generation === instance._ownershipGeneration) {
+			if ((source._readers?.get(instance))?.generation === instance.owner.identity) {
 				if (source._readers?.delete(instance) && DEVELOPMENT_BUILD_ENABLED);
 			}
 		}
@@ -110,24 +101,12 @@ function finalizeReadableSubscriptionsFromSnapshot(instance, token, newSet, pend
 		readers.has(instance);
 		readers.set(instance, {
 			token: instance.lastRenderToken ?? 0,
-			generation: instance._ownershipGeneration
+			generation: instance.owner.identity
 		});
 	}
-	instance._lastReadSources = newSet?.size ? newSet : void 0;
+	instance.owner.reads = newSet?.size ? newSet : void 0;
 	if (needsFollowUpUpdate) scheduleReadableInstanceUpdate(instance);
 }
-function cleanupReadableSubscriptions(instance, generation = instance._ownershipGeneration) {
-	const sources = instance._lastReadSources;
-	if (!sources || sources.size === 0) {
-		instance._pendingReadSources = void 0;
-		instance._pendingReadSourceVersions = void 0;
-		return;
-	}
-	cleanupReadableSubscriptionSources(instance, sources, generation);
-	instance._lastReadSources = void 0;
-	instance._pendingReadSources = void 0;
-	instance._pendingReadSourceVersions = void 0;
-}
 /** @internal Detach an exact committed read set without mutating another live generation. */
 function cleanupReadableSubscriptionSources(instance, sources, generation) {
 	if (!sources) return;
@@ -193,7 +172,7 @@ function notifyReadableReaders(source, skipInstance, skipOwnedBy) {
 			}
 			if (isOwned) continue;
 		}
-		if (instance._ownershipGeneration !== reader.generation || instance.lastRenderToken !== reader.token) continue;
+		if (instance.owner.identity !== reader.generation || instance.lastRenderToken !== reader.token) continue;
 		if (instance.hasPendingUpdate) continue;
 		scheduleReadableInstanceUpdate(instance);
 		didScheduleUpdate = true;
@@ -201,4 +180,87 @@ function notifyReadableReaders(source, skipInstance, skipOwnedBy) {
 	return didScheduleUpdate;
 }
 //#endregion
-export { finalizeReadableSubscriptionsFromSnapshot as a, markReadableUsage as c, shouldCoalesceFineGrainedItemReads as d, syncDerivedDependencySubscriptions as f, finalizeReadableSubscriptions as i, notifyReadableReaders as l, withFineGrainedReadTracking as m, cleanupReadableSubscriptions as n, markReactivePropsDirtySource as o, withDerivedReadTracking as p, clearDerivedDependencySubscriptions as r, markReadableDerivedSubscribersDirty as s, cleanupReadableSubscriptionSources as t, recordReadableRead as u };
+//#region src/runtime/transactions/access.ts
+/**
+* Resolved per call rather than captured at import time.
+*
+* Binding the coordinator once when this module is first evaluated meant these
+* helpers could never follow a runtime whose state was replaced afterwards —
+* the import order of an unrelated module decided which coordinator they used.
+*/
+function commitCoordinator() {
+	return defaultRuntimeState.commits;
+}
+function beginCommitTransaction() {
+	return commitCoordinator().begin();
+}
+function getCurrentCommitTransaction() {
+	const transaction = commitCoordinator().current;
+	return transaction?.active ? transaction : null;
+}
+function deferCommitNotification(key, notify) {
+	return commitCoordinator().deferCompletion(key, notify);
+}
+function commitTransaction(transaction) {
+	commitCoordinator().commit(transaction);
+}
+function discardTransaction(transaction) {
+	commitCoordinator().discard(transaction);
+}
+function suspendTransaction(transaction) {
+	commitCoordinator().suspend(transaction);
+}
+function applyTransaction(transaction, operation) {
+	return commitCoordinator().apply(transaction, operation);
+}
+function registerCommitParticipant(participant) {
+	return commitCoordinator().register(participant);
+}
+function registerCommitEffect(key, settle, rollback, merge) {
+	return registerCommitParticipant({
+		key,
+		settle,
+		rollback,
+		merge
+	});
+}
+function registerCommitRollback(rollback) {
+	return registerCommitParticipant({ rollback });
+}
+function runCommitTransaction(operation) {
+	const transaction = beginCommitTransaction();
+	try {
+		const result = applyTransaction(transaction, operation);
+		commitTransaction(transaction);
+		return result;
+	} catch (error) {
+		discardTransaction(transaction);
+		throw error;
+	} finally {
+		suspendTransaction(transaction);
+	}
+}
+/** Operation boundaries reuse their enclosing transaction, or own its lifetime. */
+function runCommitOperation(operation) {
+	return getCurrentCommitTransaction() ? operation() : runCommitTransaction(operation);
+}
+//#endregion
+//#region src/runtime/reactivity/notify.ts
+/**
+* Publish a change to everything subscribed to `source`.
+*
+* A readable source has four kinds of subscriber — derived values, reactive
+* props (and, through them, fine-grained effects), and component readers — and
+* every one of them has to be told, in this order. That sequence was written
+* out by hand at nine call sites across the reactivity core, portals, control
+* flow, the router and the data layer, and had already drifted into four
+* variants; the only named copy lived in `data/`, which the runtime cannot
+* import. It belongs here, beside the three primitives it drives.
+*/
+function notifyReadableSource(source, options) {
+	markReadableDerivedSubscribersDirty(source, options?.skipCurrentDerivedSubscriber);
+	markReactivePropsDirtySource(source);
+	notifyReadableReaders(source, options?.skipInstance, options?.skipOwnedBy);
+}
+//#endregion
+export { withFineGrainedReadTracking as S, markReadableUsage as _, deferCommitNotification as a, syncDerivedDependencySubscriptions as b, registerCommitEffect as c, runCommitOperation as d, runCommitTransaction as f, finalizeReadableSubscriptionsFromSnapshot as g, clearDerivedDependencySubscriptions as h, commitTransaction as i, registerCommitParticipant as l, cleanupReadableSubscriptionSources as m, applyTransaction as n, discardTransaction as o, suspendTransaction as p, beginCommitTransaction as r, getCurrentCommitTransaction as s, notifyReadableSource as t, registerCommitRollback as u, recordReadableRead as v, withDerivedReadTracking as x, shouldCoalesceFineGrainedItemReads as y };

package/dist/{query-registry-Bua3cDyb.js → query-registry-LrYpQsDJ.js}

@@ -1,4 +1,4 @@
-import { i as getDefaultDataRuntime, t as createDataRuntime } from "./data-runtime-7t_Y0iv3.js";
+import { i as getDefaultDataRuntime, t as createDataRuntime } from "./data-runtime-CxoY98lX.js";
 //#region src/common/telemetry.ts
 function withTelemetry(span, fields, work) {
 	return span ? span(fields, work) : work();

package/dist/{compose-ref-DOJHoW5X.d.ts → refs.d.ts}

@@ -1,4 +1,3 @@
-//#region src/foundations/utilities/compose-ref.d.ts
 /**
  * Ref composition utilities
  *
@@ -18,12 +17,17 @@
  *    All refs are called even if one fails.
  */
 /** A callback ref, an object ref, or a nullish value (no-op). */
-type Ref<T> = ((value: T | null) => void) | {
-  current: T | null;
-} | null | undefined;
+type Ref<T> =
+  | ((value: T | null) => void)
+  | {
+      current: T | null;
+    }
+  | null
+  | undefined;
 /** Write `value` to a {@link Ref}, ignoring failures on readonly object refs. */
 declare function setRef<T>(ref: Ref<T>, value: T | null): void;
 /** Combine multiple refs into one callback ref that writes to all of them. */
-declare function composeRefs<T>(...refs: Array<Ref<T>>): (value: T | null) => void;
-//#endregion
-export { composeRefs as n, setRef as r, Ref as t };
+declare function composeRefs<T>(
+  ...refs: Array<Ref<T>>
+): (value: T | null) => void;
+export { composeRefs, setRef, Ref };