@effect-app/vue 4.0.0-beta.99 → 4.0.0

package/dist/atomQuery.d.ts

@@ -0,0 +1,120 @@
+import type { ClientForOptions } from "effect-app/client/clientFor";
+import * as Effect from "effect-app/Effect";
+import * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import type * as Layer from "effect/Layer";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import * as Stream from "effect/Stream";
+import { type QueryInvalidationMode } from "./dependencyMetadata.js";
+import { type LiveQueryOptions } from "./liveQueryInvalidation.js";
+/** Refresh observed query atoms without making the triggering mutation await them. */
+export declare const invalidateSoft: (keys: ReadonlyArray<unknown>) => Effect.Effect<void>;
+/**
+ * Invalidate the given keys and AWAIT the result. `keyAtoms` resolves all matching hierarchical
+ * keys to a deduplicated set of query atoms. Refresh that set directly: sending the whole key set
+ * through `Reactivity.invalidate` invokes one atom's registered callback once per matching key,
+ * repeatedly superseding the same fetch when a mutation carries many row/prefix keys.
+ *
+ * Resolves once every **observed** matching query has settled, so a mutation can
+ * `yield*` this and know the on-screen data is fresh. Idle (observers === 0)
+ * matches are only marked stale — they do not block the mutation. Soft
+ * invalidation (`invalidateSoft`) still fires without awaiting.
+ */
+export declare const invalidateAndAwait: (keys: ReadonlyArray<unknown>) => Effect.Effect<void>;
+/**
+ * Structural sharing (tanstack `replaceEqualDeep`): walk `next` against `prev` and reuse `prev`'s
+ * reference for any unchanged array/object sub-tree, so unchanged data keeps referential identity
+ * (Vue skips re-rendering it). Leaves — including decoded Schema CLASS INSTANCES — are compared with
+ * Effect `Equal.equals` (structural), which reuses equal instances that tanstack's `===` could not.
+ */
+export declare const replaceEqualDeep: (prev: any, next: any) => any;
+export interface AtomClientRuntime {
+    readonly runtime: Atom.AtomRuntime<any, never>;
+    readonly factory: Atom.RuntimeFactory;
+}
+/**
+ * Build one AtomRuntime (and its factory) from an already-built app context.
+ * Shares the ManagedRuntime's `memoMap` so layers are not built twice, and so
+ * query-registration and mutation-invalidation resolve the SAME `Reactivity`.
+ */
+export declare const makeAtomClientRuntime: <R>(getContext: () => Layer.Layer<R, never, never>, memoMap: Layer.MemoMap) => AtomClientRuntime;
+export interface AtomQueryOptions {
+    /** background-refresh threshold (TanStack staleTime; default 5s) */
+    readonly staleTime?: Duration.Input;
+    /** dispose-when-idle (TanStack gcTime; default 5min). "infinity" => keepAlive */
+    readonly gcTime?: Duration.Input | "infinity";
+    readonly invalidation?: QueryInvalidationMode;
+    /**
+     * Revalidate a stale query on window focus AND on network reconnect (default on, matching
+     * tanstack refetchOnWindowFocus + refetchOnReconnect).
+     */
+    readonly revalidateOnFocus?: boolean;
+    /**
+     * Reuse references of unchanged sub-trees across refetches (default on, matching tanstack
+     * structuralSharing). Uses Effect `Equal` so decoded Schema instances share too — more effective
+     * than tanstack's `===`, but a deep compare per refetch (O(rows·fields)). Set `false` for very
+     * large or mostly-changing result sets where the compare costs more than the saved re-renders.
+     */
+    readonly structuralSharing?: boolean;
+    /** poll: re-fetch every N ms (tanstack refetchInterval). */
+    readonly refetchInterval?: number;
+    /** Refresh when writes intersect the dependencies recorded by this query. */
+    readonly live?: boolean | LiveQueryOptions;
+}
+export interface AtomQueryMetadata {
+    readonly staleTimeMs: number;
+}
+export declare const queryKeyForAtom: <A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => ReadonlyArray<unknown> | undefined;
+export declare const captureAtomQueryParentSpan: <A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => Effect.Effect<void>;
+export declare const refreshAtomWithCurrentSpan: <A, E>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => Effect.Effect<void>;
+export declare const getAtomQueryMetadata: <A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => AtomQueryMetadata | undefined;
+/** Exported so the vue hook can do refetch-on-mount-per-observer with the same rule as swr. */
+export declare const isStaleResult: (r: AsyncResult.AsyncResult<any, any>, staleTimeMs: number) => boolean;
+export declare const staleTimeMsOf: (opts: AtomQueryOptions) => number;
+export interface QueryFetchState {
+    inFlight: number;
+    recovering: boolean;
+}
+export declare const queryFetchStates: WeakMap<Atom.Atom<any>, QueryFetchState>;
+export declare const withQueryOptions: <A, E>(self: Atom.Atom<AsyncResult.AsyncResult<A, E>>, opts?: AtomQueryOptions, liveKey?: ReadonlyArray<unknown>) => Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+/** Constant atom for disabled / `mode:"optional"`-None queries: stays Initial, never fetches. */
+export declare const disabledQueryAtom: Atom.Atom<AsyncResult.AsyncResult<any, any>>;
+/**
+ * Build the per-input atom family for a request handler — the query CACHE IDENTITY.
+ *
+ * This is the TanStack `queryKey = [handler, input]` equivalent and the piece that makes
+ * caching cross-component: `Atom.family` memoizes one atom per structurally-distinct input
+ * (v4 hashes the input via Hash/Equal), so every component querying the same handler+input
+ * reads the SAME atom instance => one fetch, one shared result in the global registry,
+ * ref-counted and GC'd on idle ttl. (The registry + ttl give lifetime; reactivity keys give
+ * invalidation; the family gives identity/sharing — all three are needed.)
+ *
+ * The family is created once per handler (see query.ts's per-handler cache), so it is shared
+ * process-wide via the registry.
+ *
+ * Invalidation is hierarchical: each atom registers under EVERY prefix of its full key
+ * `[...makeQueryKey(self), input]`. Since reactivity matches keys by exact hash, registering
+ * all prefixes means `invalidate(P)` refreshes every atom whose key starts with `P` — e.g.
+ * `["$X"]` refreshes all inputs, `["$X","$List",input]` only that input. (`makeQueryKey`'s
+ * collapsed form `getQueryKey` — what mutations invalidate by default — is one of the prefixes.)
+ */
+export declare const buildQueryFamily: <I, A, E>(rt: AtomClientRuntime, self: {
+    readonly id: string;
+    readonly handler: (i: I) => Effect.Effect<A, E, any>;
+    readonly options?: ClientForOptions;
+    readonly queryKeyProjectionHash?: string;
+}) => (arg: I) => Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+export declare const buildStreamQueryFamily: <I, A, E>(rt: AtomClientRuntime, self: {
+    readonly id: string;
+    readonly handler: (i: I) => Stream.Stream<A, E, any>;
+    readonly options?: ClientForOptions;
+    readonly queryKeyProjectionHash?: string;
+}) => (arg: I) => Atom.Atom<AsyncResult.AsyncResult<{
+    readonly done: boolean;
+    readonly items: [A, ...A[]];
+}, E | Cause.NoSuchElementError>>;
+/** Await the first resolved (non-Waiting) result of an atom. Failing query results fail the Effect. */
+export declare const awaitAtomResult: <A, E>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => Effect.Effect<A, E, never>;
+//# sourceMappingURL=atomQuery.d.ts.map

package/dist/atomQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomQuery.d.ts","sourceRoot":"","sources":["../src/atomQuery.ts"],"names":[],"mappings":"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"}

package/dist/atomQuery.js

@@ -0,0 +1,434 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Shared atom core for the query/mutation engine (used by query.ts + mutate.ts).
+ *
+ * Replaces the @tanstack/vue-query engine with Effect `Atom`, keeping the public
+ * `.query()/.suspense()/.mutate()` contract unchanged:
+ *   - cache identity   = the atom reference (one per [handler, input], via Atom.family)
+ *   - invalidation key = reactivity keys (= the app's existing namespace query keys)
+ *   - SWR + focus      = Atom.swr (+ windowFocusSignal)
+ *   - gcTime           = Atom.setIdleTTL / Atom.keepAlive
+ *   - retry            = Effect.retry inside the atom effect
+ *
+ * Built over the app's RPC client through the existing `RequestHandlerWithInput`
+ * abstraction (mirrors AtomRpc's recipe; see docs/atom-query-plan.md).
+ */
+import { defaultRegistry } from "@effect/atom-vue";
+import { DataDependencies, makeQueryKey } from "effect-app/client";
+import { ServiceUnavailableError } from "effect-app/client/errors";
+import * as Effect from "effect-app/Effect";
+import * as Option from "effect-app/Option";
+import * as S from "effect-app/Schema";
+import * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { isHttpClientError } from "effect/http/HttpClientError";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
+import { clearQueryReadDependencies, getQueryReadDependencies, registerQueryInvalidationMode, setQueryReadDependencies } from "./dependencyMetadata.js";
+import { reportRuntimeError } from "./lib.js";
+import { beginLiveQueryFetch, endLiveQueryFetch, registerLiveQuery } from "./liveQueryInvalidation.js";
+import { atomsToRefetch, observeQueryAtom } from "./queryLifetime.js";
+/** All non-empty prefixes of a key, longest last. `[a,b,c]` -> `[[a],[a,b],[a,b,c]]`. */
+const prefixesOf = (key) => key.map((_, i) => key.slice(0, i + 1));
+const uniqueKeys = (keys) => {
+    const out = [];
+    const seen = new Set();
+    for (const key of keys) {
+        const hash = Hash.hash(key);
+        if (seen.has(hash))
+            continue;
+        seen.add(hash);
+        out.push(key);
+    }
+    return out;
+};
+// --- awaitable invalidation -------------------------------------------------------------------
+// keyHash -> query atoms registered under that key. A query atom stays in the map while it is
+// alive in the registry (mounted OR cached within idle-ttl). Invalidation *marks* every matching
+// atom stale; it only *refetches* atoms that currently have observers (TanStack refetchType:
+// "active"). Idle cache entries refetch on the next mount.
+const keyAtoms = new Map();
+const trackByKeys = (keys) => (atom) => Atom.transform(atom, (get) => {
+    for (const key of keys) {
+        const h = Hash.hash(key);
+        let set = keyAtoms.get(h);
+        if (!set)
+            keyAtoms.set(h, set = new Set());
+        set.add(atom);
+        get.addFinalizer(() => {
+            set.delete(atom);
+            if (set.size === 0)
+                keyAtoms.delete(h);
+        });
+    }
+    return get(atom);
+}, { initialValueTarget: atom });
+const trackWritableByKeys = (keys) => (atom) => {
+    const tracked = trackByKeys(keys)(atom);
+    return Atom.writable((get) => get(tracked), (ctx, value) => ctx.set(atom, value), (refresh) => refresh(tracked));
+};
+/**
+ * Keep a query's recorded read-dependencies registered for as long as it is alive, and drop them when
+ * its atom is GC'd (mirrors `trackByKeys`).
+ *
+ * `recordReads` only stores the deps on an actual fetch. A query that unmounts and later remounts from
+ * cache (within idle-ttl) does NOT re-run the handler, so its registry entry — cleared by the previous
+ * teardown's finalizer — would never be restored, and a subsequent mutation could not derive it as an
+ * invalidation target. Re-asserting the last-known reads on every (re)subscribe closes that gap, so the
+ * registry mirrors the live query even across cache-hit remounts.
+ */
+const trackReadDependencies = (key, getReads) => (atom) => Atom.transform(atom, (get) => {
+    const reads = getReads();
+    if (DataDependencies.isNonEmpty(reads))
+        setQueryReadDependencies(key, reads);
+    get.addFinalizer(() => clearQueryReadDependencies(key));
+    return get(atom);
+}, { initialValueTarget: atom });
+const atomsForKeys = (keys) => {
+    const atoms = new Set();
+    for (const key of keys) {
+        const set = keyAtoms.get(Hash.hash(key));
+        if (set) {
+            for (const a of set)
+                atoms.add(a);
+        }
+    }
+    return [...atoms];
+};
+/** Refresh observed query atoms without making the triggering mutation await them. */
+export const invalidateSoft = (keys) => Effect
+    .gen(function* () {
+    const atoms = atomsToRefetch(atomsForKeys(keys));
+    yield* Effect.forEach(atoms, captureAtomQueryParentSpan, { discard: true, concurrency: "unbounded" });
+    if (atoms.length === 0)
+        return;
+    yield* Effect.forEach(atoms, (atom) => Effect.sync(() => defaultRegistry.refresh(atom)), {
+        discard: true
+    });
+})
+    .pipe(Effect.orDie);
+/**
+ * Invalidate the given keys and AWAIT the result. `keyAtoms` resolves all matching hierarchical
+ * keys to a deduplicated set of query atoms. Refresh that set directly: sending the whole key set
+ * through `Reactivity.invalidate` invokes one atom's registered callback once per matching key,
+ * repeatedly superseding the same fetch when a mutation carries many row/prefix keys.
+ *
+ * Resolves once every **observed** matching query has settled, so a mutation can
+ * `yield*` this and know the on-screen data is fresh. Idle (observers === 0)
+ * matches are only marked stale — they do not block the mutation. Soft
+ * invalidation (`invalidateSoft`) still fires without awaiting.
+ */
+export const invalidateAndAwait = (keys) => Effect
+    .gen(function* () {
+    const atoms = atomsToRefetch(atomsForKeys(keys));
+    yield* Effect.forEach(atoms, captureAtomQueryParentSpan, { discard: true, concurrency: "unbounded" });
+    if (atoms.length === 0)
+        return;
+    yield* Effect.forEach(atoms, (atom) => Effect.sync(() => defaultRegistry.refresh(atom)), {
+        discard: true
+    });
+    // Contract: observers > 0 ⇒ wait for this refresh to finish.
+    yield* Effect.forEach(atoms, (a) => awaitAtomResult(defaultRegistry, a).pipe(Effect.exit));
+})
+    .pipe(Effect.orDie);
+const isPlainObject = (o) => {
+    if (typeof o !== "object" || o === null)
+        return false;
+    const proto = Object.getPrototypeOf(o);
+    return proto === Object.prototype || proto === null;
+};
+/**
+ * Structural sharing (tanstack `replaceEqualDeep`): walk `next` against `prev` and reuse `prev`'s
+ * reference for any unchanged array/object sub-tree, so unchanged data keeps referential identity
+ * (Vue skips re-rendering it). Leaves — including decoded Schema CLASS INSTANCES — are compared with
+ * Effect `Equal.equals` (structural), which reuses equal instances that tanstack's `===` could not.
+ */
+export const replaceEqualDeep = (prev, next) => {
+    if (prev === next)
+        return prev;
+    const bothArrays = Array.isArray(prev) && Array.isArray(next);
+    if (bothArrays || (isPlainObject(prev) && isPlainObject(next))) {
+        const a = prev;
+        const b = next;
+        const copy = bothArrays ? [] : {};
+        const nextKeys = bothArrays ? b.map((_, i) => i) : Object.keys(b);
+        const nextSize = nextKeys.length;
+        const prevSize = bothArrays ? a.length : Object.keys(a).length;
+        let equalItems = 0;
+        for (let i = 0; i < nextSize; i++) {
+            const key = nextKeys[i];
+            copy[key] = replaceEqualDeep(a[key], b[key]);
+            if (copy[key] === a[key] && a[key] !== undefined)
+                equalItems++;
+        }
+        return prevSize === nextSize && equalItems === prevSize ? prev : copy;
+    }
+    return Equal.equals(prev, next) ? prev : next;
+};
+/** Atom combinator: share each new `Success` value structurally against the previous one. */
+const structuralShare = (self) => Atom.transform(self, (get) => {
+    const next = get(self);
+    if (next._tag !== "Success")
+        return next;
+    const prev = Option.flatMap(get.self(), AsyncResult.value);
+    if (Option.isNone(prev))
+        return next;
+    const shared = replaceEqualDeep(prev.value, next.value);
+    return shared === next.value
+        ? next
+        : AsyncResult.success(shared, { waiting: next.waiting, timestamp: next.timestamp });
+}, { initialValueTarget: self });
+/**
+ * Build one AtomRuntime (and its factory) from an already-built app context.
+ * Shares the ManagedRuntime's `memoMap` so layers are not built twice, and so
+ * query-registration and mutation-invalidation resolve the SAME `Reactivity`.
+ */
+export const makeAtomClientRuntime = (getContext, memoMap) => {
+    const factory = Atom.context({ memoMap });
+    const runtime = factory((_get) => getContext());
+    return { runtime, factory };
+};
+const isRetryable = (e) => isHttpClientError(e)
+    || S.is(ServiceUnavailableError)(e)
+    || (typeof e === "object" && e !== null && e._tag === "RpcClientError");
+const defaults = { staleTime: Duration.seconds(5), gcTime: Duration.minutes(5) };
+const atomQueryMetadata = new WeakMap();
+const atomQueryParentSpans = new WeakMap();
+const atomQueryKeys = new WeakMap();
+export const queryKeyForAtom = (atom) => atomQueryKeys.get(atom);
+const atomSpanTarget = (atom) => {
+    let target = atom;
+    while (target.initialValueTarget !== undefined) {
+        target = target.initialValueTarget;
+    }
+    return target;
+};
+const takeAtomQueryParentSpan = (atom) => {
+    const target = atomSpanTarget(atom);
+    const span = atomQueryParentSpans.get(target);
+    if (span !== undefined)
+        atomQueryParentSpans.delete(target);
+    return span;
+};
+const setAtomQueryParentSpan = (atom, span) => {
+    atomQueryParentSpans.set(atomSpanTarget(atom), span);
+};
+export const captureAtomQueryParentSpan = (atom) => Effect.currentParentSpan.pipe(Effect.tap((span) => Effect.sync(() => setAtomQueryParentSpan(atom, span))), Effect.ignore);
+export const refreshAtomWithCurrentSpan = (registry, atom) => captureAtomQueryParentSpan(atom).pipe(Effect.andThen(Effect.sync(() => registry.refresh(atom))));
+const setAtomQueryMetadata = (atom, opts = {}) => {
+    const staleTimeMs = staleTimeMsOf(opts);
+    const previous = atomQueryMetadata.get(atom);
+    atomQueryMetadata.set(atom, {
+        staleTimeMs: previous === undefined ? staleTimeMs : Math.min(previous.staleTimeMs, staleTimeMs)
+    });
+    return atom;
+};
+export const getAtomQueryMetadata = (atom) => atomQueryMetadata.get(atom);
+/** Exported so the vue hook can do refetch-on-mount-per-observer with the same rule as swr. */
+export const isStaleResult = (r, staleTimeMs) => {
+    if (r.waiting)
+        return false;
+    const ts = r._tag === "Success"
+        ? r.timestamp
+        : r._tag === "Failure"
+            ? Option.getOrUndefined(Option.map(r.previousSuccess, (s) => s.timestamp))
+            : undefined;
+    if (ts === undefined)
+        return r._tag !== "Initial";
+    return Date.now() - ts >= staleTimeMs;
+};
+export const staleTimeMsOf = (opts) => Duration.toMillis(Duration.fromInputUnsafe(opts.staleTime ?? defaults.staleTime));
+export const queryFetchStates = new WeakMap();
+const recoverStuckWaitingOnMount = (familyAtom) => (wrapped) => Atom.transform(wrapped, (get) => {
+    const current = get.once(wrapped);
+    get.subscribe(wrapped, (value) => get.setSelf(value));
+    const state = queryFetchStates.get(familyAtom);
+    const waiting = current?.waiting === true;
+    // Stuck: the result says `waiting` yet nothing is in-flight — an interrupt was hidden and left
+    // `waiting` dangling. Treat it as not-yet-fetched and refetch; a live fetch (`inFlight > 0`) is
+    // joined, not superseded. `recovering` prevents concurrent mounts from issuing more than one
+    // recovery fetch (cleared once a fetch is actually running again).
+    if (state && waiting && state.inFlight === 0 && !state.recovering) {
+        state.recovering = true;
+        get.refresh(familyAtom);
+    }
+    return current;
+}, { initialValueTarget: wrapped });
+export const withQueryOptions = (self, opts = {}, liveKey) => {
+    setAtomQueryMetadata(self, opts);
+    const staleTime = opts.staleTime ?? defaults.staleTime;
+    let atom = self;
+    if (liveKey !== undefined) {
+        atom = Atom.transform(atom, (get) => {
+            const unregister = registerQueryInvalidationMode(liveKey, opts.invalidation ?? "await");
+            get.addFinalizer(unregister);
+            return get(self);
+        }, { initialValueTarget: self });
+    }
+    if (opts.live && liveKey !== undefined) {
+        const liveOptions = opts.live === true ? {} : opts.live;
+        atom = Atom.transform(atom, (get) => {
+            const unregister = registerLiveQuery(liveKey, () => getQueryReadDependencies(liveKey), liveOptions);
+            get.addFinalizer(unregister);
+            return get(self);
+        }, { initialValueTarget: self });
+    }
+    const revalidateOnFocus = opts.revalidateOnFocus ?? true;
+    atom = Atom.swr({
+        staleTime,
+        revalidateOnFocus,
+        focusSignal: revalidateOnFocus ? focusOrReconnectSignal : undefined
+    })(atom);
+    atom = recoverStuckWaitingOnMount(self)(atom);
+    if (opts.refetchInterval)
+        atom = Atom.withRefresh(Duration.millis(opts.refetchInterval))(atom);
+    if (opts.structuralSharing ?? true)
+        atom = structuralShare(atom);
+    return atom;
+};
+/** Constant atom for disabled / `mode:"optional"`-None queries: stays Initial, never fetches. */
+export const disabledQueryAtom = Atom.readable(() => AsyncResult.initial(false));
+/**
+ * Bumps when the browser regains connectivity (the `online` event) — the tanstack
+ * `refetchOnReconnect` trigger. One shared listener (module-level). SSR-guarded.
+ */
+const onlineSignal = Atom.readable((get) => {
+    let count = 0;
+    if (typeof window === "undefined")
+        return count;
+    const update = () => {
+        if (navigator.onLine)
+            get.setSelf(++count);
+    };
+    window.addEventListener("online", update);
+    get.addFinalizer(() => window.removeEventListener("online", update));
+    return count;
+});
+/**
+ * Focus OR reconnect, as a single signal for `swr` — both should stale-revalidate a query.
+ * swr takes one `focusSignal`, so we fold window-focus + reconnect into one derived atom;
+ * a bump from either triggers swr's stale check.
+ */
+const focusOrReconnectSignal = Atom.make((get) => get(Atom.windowFocusSignal) + get(onlineSignal));
+/**
+ * Build the per-input atom family for a request handler — the query CACHE IDENTITY.
+ *
+ * This is the TanStack `queryKey = [handler, input]` equivalent and the piece that makes
+ * caching cross-component: `Atom.family` memoizes one atom per structurally-distinct input
+ * (v4 hashes the input via Hash/Equal), so every component querying the same handler+input
+ * reads the SAME atom instance => one fetch, one shared result in the global registry,
+ * ref-counted and GC'd on idle ttl. (The registry + ttl give lifetime; reactivity keys give
+ * invalidation; the family gives identity/sharing — all three are needed.)
+ *
+ * The family is created once per handler (see query.ts's per-handler cache), so it is shared
+ * process-wide via the registry.
+ *
+ * Invalidation is hierarchical: each atom registers under EVERY prefix of its full key
+ * `[...makeQueryKey(self), input]`. Since reactivity matches keys by exact hash, registering
+ * all prefixes means `invalidate(P)` refreshes every atom whose key starts with `P` — e.g.
+ * `["$X"]` refreshes all inputs, `["$X","$List",input]` only that input. (`makeQueryKey`'s
+ * collapsed form `getQueryKey` — what mutations invalidate by default — is one of the prefixes.)
+ */
+export const buildQueryFamily = (rt, self) => {
+    const baseKey = makeQueryKey(self); // hierarchical, input-independent
+    return Atom.family((input) => {
+        const fullKey = [...baseKey, input];
+        // Record the repository/server read-dependencies seen while fetching, keyed by `fullKey`, so a
+        // later mutation whose writes intersect them can derive this query as an invalidation target.
+        // The last recorded reads are retained on the (memoized) family atom so `trackReadDependencies`
+        // can re-assert them on a cache-hit remount that never re-runs the handler.
+        let lastReads = DataDependencies.empty();
+        // Fetch bookkeeping read by `recoverStuckWaitingOnMount`. `inFlight` counts live computes, so a
+        // `waiting` result with `inFlight === 0` is a stuck/hidden interrupt. `recovering` guards the
+        // recovery refresh against concurrent mounts; a running fetch clears it.
+        const fetchState = { inFlight: 0, recovering: false };
+        let atom;
+        atom = rt.runtime.atom(Effect.suspend(() => {
+            // A fetch is now running: the atom is not stuck, and any pending recovery is fulfilled.
+            fetchState.recovering = false;
+            fetchState.inFlight++;
+            const recordReads = Effect
+                .gen(function* () {
+                const readsRef = yield* Ref.make(DataDependencies.empty());
+                const writesRef = yield* Ref.make(DataDependencies.empty());
+                const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef);
+                const result = yield* self
+                    .handler(input)
+                    .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder));
+                lastReads = yield* Ref.get(readsRef);
+                setQueryReadDependencies(fullKey, lastReads);
+                return result;
+            });
+            let liveFetch = false;
+            const effect = Effect
+                .gen(function* () {
+                liveFetch = yield* Effect.promise(() => beginLiveQueryFetch(fullKey));
+                return yield* recordReads.pipe(Effect.retry({ times: 5, while: isRetryable }));
+            })
+                .pipe(Effect.ensuring(Effect.sync(() => endLiveQueryFetch(liveFetch))), Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)), 
+            // On exit, the compute is no longer in-flight. An interrupt (subscriber lost interest / a
+            // superseding refresh) may leave the result at `waiting`; with `inFlight` back at 0 that
+            // reads as "stuck", so the next mount recovers it (`recoverStuckWaitingOnMount`). We do not
+            // re-fire here — the interrupt was intentional; recovery is driven by a genuine (re)mount.
+            Effect.onExit(() => Effect.sync(() => {
+                fetchState.inFlight = Math.max(0, fetchState.inFlight - 1);
+            })), Effect.withSpan(`query ${self.id}`, {}, { captureStackTrace: false }));
+            const parentSpan = takeAtomQueryParentSpan(atom);
+            return parentSpan === undefined
+                ? effect
+                : effect.pipe(Effect.withParentSpan(parentSpan, { captureStackTrace: false }));
+        }));
+        // Register under every prefix of the full key => hierarchical (prefix) invalidation. Two roles:
+        //   - withReactivity: `Reactivity.invalidate(key)` refreshes this atom (the actual refetch).
+        //   - trackByKeys:    records the atom in `keyAtoms` so the mutation can AWAIT its settle.
+        const projectedFullKey = self.queryKeyProjectionHash === undefined
+            ? fullKey
+            : [...baseKey, self.queryKeyProjectionHash, input];
+        const reactivityKeys = uniqueKeys([...prefixesOf(fullKey), ...prefixesOf(projectedFullKey)]);
+        atom = rt.factory.withReactivity(reactivityKeys)(atom);
+        atom = trackByKeys(reactivityKeys)(atom);
+        atom = trackReadDependencies(fullKey, () => lastReads)(atom);
+        // gcTime LAST so the whole chain (incl. the registration + tracking) stays alive through the
+        // idle window. Invalidation still finds the cached atom and marks it stale; it does not
+        // refetch until an observer remounts (TanStack refetchType: "active").
+        atom = Atom.setIdleTTL(atom, defaults.gcTime);
+        const registered = setAtomQueryMetadata(Atom.withLabel(`query:${self.id}`)(atom));
+        const writable = Atom.writable((get) => {
+            const current = get.once(registered);
+            get.subscribe(registered, (value) => get.setSelf(value));
+            return current;
+        }, (ctx, value) => ctx.setSelf(value), (refresh) => refresh(registered));
+        const writableWithTarget = Object.assign(writable, { initialValueTarget: registered });
+        const result = setAtomQueryMetadata(Atom.withLabel(`query-cache:${self.id}`)(writableWithTarget));
+        // Key the fetch state by the atom `withQueryOptions` receives, so its mount hook can find it.
+        const observed = observeQueryAtom(result);
+        queryFetchStates.set(result, fetchState);
+        queryFetchStates.set(observed, fetchState);
+        atomQueryKeys.set(result, fullKey);
+        atomQueryKeys.set(observed, fullKey);
+        return observed;
+    });
+};
+export const buildStreamQueryFamily = (rt, self) => {
+    const baseKey = makeQueryKey(self);
+    return Atom.family((input) => {
+        let atom = rt.runtime.pull(self.handler(input).pipe(Stream.tapCause((cause) => Cause.hasDies(cause) ? reportRuntimeError(cause) : Effect.void)));
+        const fullKey = [...baseKey, input];
+        const projectedFullKey = self.queryKeyProjectionHash === undefined
+            ? fullKey
+            : [...baseKey, self.queryKeyProjectionHash, input];
+        const reactivityKeys = uniqueKeys([...prefixesOf(fullKey), ...prefixesOf(projectedFullKey)]);
+        atom = rt.factory.withReactivity(reactivityKeys)(atom);
+        atom = trackWritableByKeys(reactivityKeys)(atom);
+        atom = Atom.setIdleTTL(atom, defaults.gcTime);
+        return observeQueryAtom(setAtomQueryMetadata(Atom.withLabel(`stream-query:${self.id}`)(atom)));
+    });
+};
+/** Await the first resolved (non-Waiting) result of an atom. Failing query results fail the Effect. */
+export const awaitAtomResult = (registry, atom) => AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"atomQuery.js","sourceRoot":"","sources":["../src/atomQuery.ts"],"names":[],"mappings":"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"}