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

package/dist/mutate.js

@@ -1,20 +1,51 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { useQueryClient } from "@tanstack/vue-query";
-import { Effect, Option } from "effect-app";
+import { DataDependencies, InvalidationKeysFromServer, makeInvalidationKeysService, makeQueryKey } from "effect-app/client";
+import * as Effect from "effect-app/Effect";
 import { tuple } from "effect-app/Function";
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as Option from "effect-app/Option";
+import { isReadonlyArrayNonEmpty } from "effect/Array";
+import * as Exit from "effect/Exit";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
 import { computed, shallowRef } from "vue";
-import { makeQueryKey } from "./lib.js";
-export const getQueryKey = (h) => {
+import { invalidateAndAwait, invalidateSoft } from "./atomQuery.js";
+import { getDerivedInvalidationKeys, partitionInvalidationKeys } from "./dependencyMetadata.js";
+import { reportRuntimeError } from "./lib.js";
+/**
+ * Default heuristic: invalidate the parent namespace of the action.
+ * e.g. `$project/$configuration.get` -> `["$project"]`
+ * e.g. `$project/$configuration/$something.get` -> `["$project","$configuration"]`
+ */
+export const defaultGetQueryKey = (h) => {
     const key = makeQueryKey(h);
     const ns = key.filter((_) => _.startsWith("$"));
-    // we invalidate the parent namespace e.g $project/$configuration.get, we invalidate $project
-    // for $project/$configuration/$something.get, we invalidate $project/$configuration
     const k = ns.length ? ns.length > 1 ? ns.slice(0, ns.length - 1) : ns : undefined;
     if (!k)
         throw new Error("empty query key for: " + h.id);
     return k;
 };
+let activeGetQueryKey = defaultGetQueryKey;
+/**
+ * Override the default query-key heuristic used by mutations for cache
+ * invalidation. Call once at app bootstrap. Pass `undefined` to restore the
+ * built-in default.
+ *
+ * @example
+ * ```ts
+ * // invalidate the full namespace of the action (no parent collapse)
+ * setDefaultGetQueryKey((h) => {
+ *   const key = makeQueryKey(h)
+ *   const ns = key.filter((_) => _.startsWith("$"))
+ *   if (!ns.length) throw new Error("empty query key for: " + h.id)
+ *   return ns
+ * })
+ * ```
+ */
+export const setDefaultGetQueryKey = (fn) => {
+    activeGetQueryKey = fn ?? defaultGetQueryKey;
+};
+export const getQueryKey = (h) => activeGetQueryKey(h);
 export function mutationResultToVue(mutationResult) {
     switch (mutationResult._tag) {
         case "Initial": {
@@ -46,75 +77,221 @@ export function make(self) {
     const latestSuccess = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)));
     return tuple(result, latestSuccess, execute);
 }
-// TODO: more efficient invalidation, including args etc
-// return Effect.promise(() => queryClient.invalidateQueries({
-//   predicate: (_) => nses.includes(_.queryKey.filter((_) => _.startsWith("$")).join("/"))
-// }))
-/*
-            // const nses: string[] = []`
-                // for (let i = 0; i < ns.length; i++) {
-                //   nses.push(ns.slice(0, i + 1).join("/"))
-                // }
-                */
+export const atomQueryInvalidator = {
+    invalidateAndAwait,
+    invalidateSoft
+};
+export const combineQueryInvalidators = (...invalidators) => ({
+    invalidateAndAwait: (keys) => Effect.forEach(invalidators, (invalidator) => invalidator.invalidateAndAwait(keys), { discard: true, concurrency: "unbounded" }),
+    invalidateSoft: (keys) => Effect.forEach(invalidators, (invalidator) => invalidator.invalidateSoft?.(keys) ?? Effect.void, { discard: true, concurrency: "unbounded" })
+});
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isQueryKey = (entry) => Array.isArray(entry);
+const queryKeyFromFilters = (entry) => {
+    if (!("filters" in entry))
+        return undefined;
+    const filters = entry.filters;
+    if (!isRecord(filters))
+        return undefined;
+    const queryKey = filters["queryKey"];
+    return Array.isArray(queryKey) ? queryKey : undefined;
+};
 export const asResult = (handler) => {
     const state = shallowRef(AsyncResult.initial());
-    const act = Effect.isEffect(handler)
-        ? Effect
-            .sync(() => {
-            state.value = AsyncResult.initial(true);
-        })
-            .pipe(Effect.andThen(Effect.suspend(() => handler.pipe(Effect.exit, Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))))))
-        : (...args) => Effect
-            .sync(() => {
-            state.value = AsyncResult.initial(true);
-        })
-            .pipe(Effect.andThen(Effect.suspend(() => handler(...args).pipe(Effect.exit, Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))))));
+    const act = (...args) => Effect
+        .sync(() => {
+        state.value = AsyncResult.initial(true);
+    })
+        .pipe(Effect.andThen(Effect.suspend(() => handler(...args).pipe(Effect.exit, Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))))));
     return tuple(computed(() => state.value), act);
 };
-export const invalidateQueries = (queryClient, self, options) => {
-    const invalidateQueries = (filters, options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => queryClient.invalidateQueries(filters, { ...options, updateMeta: { span } }))));
-    const invalidateCache = Effect.suspend(() => {
+/**
+ * Like `asResult`, but for streams. The ref is updated with each emitted value
+ * (keeping `waiting: true`) and is finalised (with `waiting: false`) once the
+ * stream terminates successfully. Errors are surfaced as `AsyncResult.failure`.
+ */
+export const asStreamResult = (handler) => {
+    const state = shallowRef(AsyncResult.initial());
+    const runStream = (stream) => Effect
+        .sync(() => {
+        state.value = AsyncResult.initial(true);
+    })
+        .pipe(Effect.andThen(stream.pipe(Stream.runForEach((value) => Effect.sync(() => {
+        state.value = AsyncResult.success(value, { waiting: true });
+    })), Effect.exit, Effect.flatMap((exit) => Effect.sync(() => {
+        if (exit._tag === "Success") {
+            const current = state.value;
+            if (AsyncResult.isSuccess(current)) {
+                state.value = AsyncResult.success(current.value, { waiting: false });
+            }
+            else {
+                state.value = AsyncResult.initial(false);
+            }
+        }
+        else {
+            state.value = AsyncResult.failure(exit.cause);
+        }
+    })))));
+    const act = (...args) => runStream(handler(...args));
+    return tuple(computed(() => state.value), act);
+};
+const buildInvalidateCache = (self, queryInvalidation, queryInvalidator) => {
+    // Concrete reactivity keys to invalidate: a raw query key, one derived from an `{ id }`
+    // entry, or a compatibility `{ filters: { queryKey } }` entry.
+    // Predicate-only `{ filters }` entries have no exact-key reactivity equivalent and throw.
+    const getClientInvalidationKeys = (input, output) => {
         const queryKey = getQueryKey(self);
-        if (options) {
-            const opts = options(queryKey, self.id);
-            if (!opts.length) {
-                return Effect.void;
+        if (queryInvalidation) {
+            const keys = [];
+            for (const entry of queryInvalidation(queryKey, self.id, input, output)) {
+                if (isQueryKey(entry)) {
+                    keys.push(entry);
+                    continue;
+                }
+                if ("id" in entry) {
+                    keys.push(makeQueryKey(entry.options ? { id: entry.id, options: entry.options } : { id: entry.id }));
+                    continue;
+                }
+                const filterQueryKey = queryKeyFromFilters(entry);
+                if (filterQueryKey !== undefined) {
+                    keys.push(filterQueryKey);
+                    continue;
+                }
+                throw new Error("Unsupported query invalidation filter: only filters.queryKey is supported");
             }
-            return Effect
-                .andThen(Effect.annotateCurrentSpan({ queryKey, opts }), Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" }))
-                .pipe(Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }));
+            return keys;
         }
-        if (!queryKey)
+        // No manual `invalidatesQueries`: contribute nothing. Invalidation rides entirely on the
+        // repository-derived write-dependencies (plus any server-provided keys) — there is no default
+        // namespace invalidation of the command's own resource.
+        return [];
+    };
+    const invalidateCache = (input, output, serverKeys, writeDependencies = DataDependencies.empty()) => Effect.suspend(() => {
+        if (self.disableQueryInvalidation)
             return Effect.void;
+        const clientKeys = getClientInvalidationKeys(input, output);
+        // Derive extra reactivity keys from repository write-dependencies: every live query whose
+        // recorded read-dependencies intersect this mutation's writes must be refreshed.
+        const derivedKeys = getDerivedInvalidationKeys(writeDependencies);
+        // Invalidate exact reactivity keys (= the prefixes query atoms register under). Each key
+        // array is hashed structurally, matching the query-side registration.
+        const keys = [...clientKeys, ...serverKeys, ...derivedKeys];
+        if (!isReadonlyArrayNonEmpty(keys))
+            return Effect.void;
+        const { awaitKeys, softKeys } = partitionInvalidationKeys(keys);
         return Effect
-            .andThen(Effect.annotateCurrentSpan({ queryKey }), invalidateQueries({ queryKey }))
-            .pipe(Effect.tap(
-        // hand over control back to the event loop so that state can be updated..
-        // TODO: should we do this in general on any mutation, regardless of invalidation?
-        Effect.sleep(0)), Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }));
+            .andThen(Effect.annotateCurrentSpan({
+            keys,
+            awaitKeys,
+            softKeys,
+            clientKeys,
+            serverKeys,
+            derivedKeys,
+            writeDependencies: [...writeDependencies]
+        }), 
+        // refetch + AWAIT every live query registered under these keys, so by the time the
+        // mutation resolves the affected queries are fresh.
+        Effect.gen(function* () {
+            if (softKeys.length > 0) {
+                yield* (queryInvalidator.invalidateSoft?.(softKeys) ?? Effect.void).pipe(Effect.catchCause((cause) => reportRuntimeError(cause, { invalidation: "soft", keys: softKeys }).pipe(Effect.asVoid)), Effect.forkDetach({ startImmediately: true }));
+            }
+            if (awaitKeys.length > 0) {
+                yield* queryInvalidator.invalidateAndAwait(awaitKeys);
+            }
+        }))
+            .pipe(Effect.tap(Effect.sleep(0.1)), // allow for refs to update etc
+        Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }));
+    });
+    return invalidateCache;
+};
+export const invalidateQueries = (self, options, queryInvalidator) => {
+    const invalidateCache = buildInvalidateCache(self, options?.queryInvalidation, queryInvalidator);
+    const select = options?.select;
+    const handle = (eff, input) => Effect.gen(function* () {
+        const keysRef = yield* Ref.make([]);
+        const readsRef = yield* Ref.make(DataDependencies.empty());
+        const writesRef = yield* Ref.make(DataDependencies.empty());
+        const dependencyRecorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef);
+        const result = yield* eff.pipe(Effect.provideService(InvalidationKeysFromServer, makeInvalidationKeysService(keysRef)), Effect.provideService(DataDependencies.DataDependencyRecorder, dependencyRecorder), Effect.onExit((exit) => Effect.gen(function* () {
+            const serverKeys = yield* Ref.get(keysRef);
+            const writeDependencies = yield* Ref.get(writesRef);
+            yield* invalidateCache(input, exit, serverKeys, writeDependencies);
+        })));
+        if (select) {
+            return yield* select(result).pipe(Effect.onExit((exit) => Effect.gen(function* () {
+                const serverKeys = yield* Ref.get(keysRef);
+                const writeDependencies = yield* Ref.get(writesRef);
+                yield* invalidateCache(input, exit, serverKeys, writeDependencies);
+            })));
+        }
+        return result;
     });
-    const handle = (self) => Effect.ensuring(self, invalidateCache);
     return handle;
 };
-export const makeMutation = () => {
-    const useMutation = (self, options) => {
-        const queryClient = useQueryClient();
-        const handle = invalidateQueries(queryClient, self, options?.queryInvalidation);
-        const handler = self.handler;
-        const r = Effect.isEffect(handler) ? handle(handler) : (i) => handle(handler(i));
+export const makeMutation = (queryInvalidator) => {
+    /**
+     * Pass a function that returns an Effect, e.g from a client action.
+     * Executes query cache invalidation based on default rules or provided option.
+     * When `I = void` the input argument may be omitted.
+     */
+    const useMutation = (self) => {
+        const r = (i, options) => invalidateQueries(self, options, queryInvalidator)(self.handler(i), i);
         return Object.assign(r, { id: self.id });
     };
     return useMutation;
 };
-// calling hooks in the body
-export const useMakeMutation = () => {
-    const queryClient = useQueryClient();
-    const useMutation = (self, options) => {
-        const handle = invalidateQueries(queryClient, self, options?.queryInvalidation);
-        const handler = self.handler;
-        const r = Effect.isEffect(handler) ? handle(handler) : (i) => handle(handler(i));
+export const useMakeMutation = (queryInvalidator) => {
+    /**
+     * Pass a function that returns an Effect, e.g from a client action.
+     * Executes query cache invalidation based on default rules or provided option.
+     * When `I = void` the input argument may be omitted.
+     */
+    const useMutation = (self) => {
+        const r = (i, options) => invalidateQueries(self, options, queryInvalidator)(self.handler(i), i);
         return Object.assign(r, { id: self.id });
     };
     return useMutation;
 };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Returns a stream-based mutation factory for use with `streamFn`.
+ * The outer Effect sets up per-invocation invalidation scaffolding
+ * and returns a stream that triggers query invalidation via `Stream.ensuring` when it completes.
+ *
+ * Use with `streamFn` / `Command.streamFn(id)(mutateHandler, ...combinators)` so that
+ * the command manages its own reactive state internally.
+ */
+export const makeStreamMutation2 = (queryInvalidator) => {
+    return (self, mergedInvalidation) => {
+        const invCache = buildInvalidateCache(self, mergedInvalidation, queryInvalidator);
+        const makeInvocationEffect = (input, source) => Effect.gen(function* () {
+            const keysRef = yield* Ref.make([]);
+            // Server invalidation keys stay settlement-only: flushing them from `add` refetched
+            // live queries once per chunk (One-Pick List storms). Write-deps flush once when the
+            // first write arrives (job create → GetActiveJob) and again from `ensuring`.
+            const invKeys = makeInvalidationKeysService(keysRef);
+            const readsRef = yield* Ref.make(DataDependencies.empty());
+            const writesRef = yield* Ref.make(DataDependencies.empty());
+            const dependencyRecorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef);
+            const lastRef = yield* Ref.make(undefined);
+            let flushedFirstWrites = false;
+            const flushFirstWrites = Effect.gen(function* () {
+                if (flushedFirstWrites)
+                    return;
+                const writeDependencies = yield* Ref.get(writesRef);
+                if (!DataDependencies.isNonEmpty(writeDependencies))
+                    return;
+                flushedFirstWrites = true;
+                const lastValue = yield* Ref.get(lastRef);
+                yield* invCache(input, Exit.succeed(lastValue), [], writeDependencies);
+            });
+            return source.pipe(Stream.provideService(InvalidationKeysFromServer, invKeys), Stream.provideService(DataDependencies.DataDependencyRecorder, dependencyRecorder), Stream.tap((v) => Ref.set(lastRef, v)), Stream.tap(() => flushFirstWrites), Stream.ensuring(Effect.gen(function* () {
+                const lastValue = yield* Ref.get(lastRef);
+                const serverKeys = yield* Ref.get(keysRef);
+                const writeDependencies = yield* Ref.get(writesRef);
+                yield* invCache(input, Exit.succeed(lastValue), serverKeys, writeDependencies);
+            })));
+        });
+        return (i) => Stream.unwrap(makeInvocationEffect(i, self.handler(i)));
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mutate.js","sourceRoot":"","sources":["../src/mutate.ts"],"names":[],"mappings":"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"}

package/dist/query.d.ts

@@ -1,63 +1,180 @@
-import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query";
-import { type Context, Effect } from "effect-app";
+import { injectRegistry } from "@effect/atom-vue";
 import { type Req } from "effect-app/client";
-import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor";
-import { CauseException } from "effect-app/client/errors";
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import type { RequestHandlerWithInput, RequestStreamHandlerWithInput } from "effect-app/client/clientFor";
+import { type CauseException } from "effect-app/client/errors";
+import type * as Context from "effect-app/Context";
+import * as Effect from "effect-app/Effect";
+import * as Option from "effect-app/Option";
+import type * as Cause from "effect/Cause";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Atom from "effect/reactivity/Atom";
 import { type ComputedRef, type MaybeRefOrGetter, type WatchSource } from "vue";
-export interface CustomUseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, "queryKey" | "queryFn" | "initialData" | "enabled" | "placeholderData"> {
-    enabled?: MaybeRefOrGetter<boolean | undefined> | (() => Enabled<TQueryFnData, TError, TQueryData, TQueryKey>);
+import { type AtomClientRuntime } from "./atomQuery.js";
+import type { QueryInvalidationMode } from "./dependencyMetadata.js";
+import type { LiveQueryOptions } from "./liveQueryInvalidation.js";
+type DefaultError = Error;
+type QueryKey = ReadonlyArray<unknown>;
+/** Options accepted by `refetch()` — kept for source compatibility; the atom path ignores them. */
+export interface RefetchOptions {
+    readonly cancelRefetch?: boolean;
+    readonly throwOnError?: boolean;
+}
+/** The 4th tuple element: private atom/registry handle for client helpers. */
+export interface QueryHandle<A = unknown, E = unknown> {
+    readonly awaitResult: () => Effect.Effect<A, E, never>;
+    readonly refetch: () => Effect.Effect<A, E, never>;
+    readonly refresh: () => void;
+    readonly registry: ReturnType<typeof injectRegistry>;
+    readonly atom: ComputedRef<Atom.Atom<AsyncResult.AsyncResult<A, E>>>;
+}
+export interface QueryView<A, E> extends QueryHandle<A, E> {
+    readonly result: ComputedRef<AsyncResult.AsyncResult<A, E>>;
+    readonly data: ComputedRef<A | undefined>;
+}
+export interface QueryCacheUpdater {
+    readonly update: <I, A, E, R, Request extends Req, Name extends string>(registry: ReturnType<typeof injectRegistry>, query: RequestHandlerWithInput<I, A, E, R, Request, Name>, input: I, updater: (data: NoInfer<A>) => NoInfer<A>) => void;
+}
+export type UseQueryReturnType<A = any, E = any> = QueryHandle<A, E>;
+export type UseQueryDefinedReturnType<A = any, E = any> = QueryHandle<A, E>;
+export type QueryObserverResult<A = any, _E = any> = AsyncResult.AsyncResult<A, any>;
+export type SuspenseQueryTuple<A, E> = readonly [
+    ComputedRef<AsyncResult.AsyncResult<A, E>>,
+    ComputedRef<A>,
+    (options?: RefetchOptions) => Effect.Effect<A, E, never>,
+    QueryHandle<A, E>
+];
+export type SuspenseQueryView<A, E> = Omit<QueryView<A, E>, "data"> & {
+    readonly data: ComputedRef<A>;
+} & SuspenseQueryTuple<A, E>;
+export type QueryAtomFamily<I, A, E> = (input: I) => Atom.Writable<AsyncResult.AsyncResult<A, E>, AsyncResult.AsyncResult<A, E>>;
+export type StreamQueryAtomFamily<I, A, E> = (input: I) => Atom.Writable<Atom.PullResult<A, E>, void>;
+export declare const atomQueryCacheUpdater: QueryCacheUpdater;
+export declare const optionalAtomQueryCacheUpdater: QueryCacheUpdater;
+export declare const combineQueryCacheUpdaters: (first: QueryCacheUpdater, second: QueryCacheUpdater) => QueryCacheUpdater;
+export declare const setQueryCacheUpdater: (updater: QueryCacheUpdater) => void;
+export interface CustomUseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+    /** stale threshold in ms (or a Duration input) */
+    readonly staleTime?: number;
+    /** garbage-collect after idle, ms (or "infinity") */
+    readonly gcTime?: number | "infinity";
+    readonly refetchOnWindowFocus?: boolean;
+    readonly structuralSharing?: boolean;
+    /** poll: re-fetch every N ms (tanstack refetchInterval) */
+    readonly refetchInterval?: number;
+    readonly live?: boolean | LiveQueryOptions;
+    readonly invalidation?: QueryInvalidationMode;
+    readonly select?: (data: TQueryFnData) => TData;
+    /** accepted for source compatibility; not used by the atom engine */
+    readonly retry?: boolean | number;
+    readonly meta?: Record<string, unknown>;
+    readonly _phantom?: [TQueryData, TQueryKey, TError];
 }
 type NonFunctionGuard<T> = T extends Function ? never : T;
 export interface CustomUndefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CustomUseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-    initialData?: undefined | InitialDataFunction<NonUndefinedGuard<TQueryFnData>> | NonUndefinedGuard<TQueryFnData>;
-    placeholderData?: undefined | NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
+    readonly initialData?: TQueryFnData | (() => TQueryFnData) | undefined;
+    readonly placeholderData?: NonFunctionGuard<TQueryData> | ((prev: TQueryData | undefined) => TQueryData) | undefined;
 }
 export interface CustomDefinedInitialQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CustomUseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-    initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
-    placeholderData?: undefined | NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
+    readonly initialData: TQueryFnData | (() => TQueryFnData);
+    readonly placeholderData?: NonFunctionGuard<TQueryData> | ((prev: TQueryData | undefined) => TQueryData) | undefined;
 }
 export interface CustomDefinedPlaceholderQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CustomUseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-    initialData?: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>) | undefined;
-    placeholderData: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
-}
-export declare const makeQuery: <R>(getRuntime: () => Context.Context<R>) => {
-    <E, A, Request extends Req, Name extends string>(self: RequestHandler<A, E, R, Request, Name>): {
-        /**
-         * Effect results are passed to the caller, including errors.
-         */
-        <TData = A>(options: CustomDefinedInitialQueryOptions<A, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
-        <TData = A>(options: CustomDefinedPlaceholderQueryOptions<A, E, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>, never, never>, UseQueryDefinedReturnType<TData, CauseException<E>>];
-        /**
-         * Effect results are passed to the caller, including errors.
-         */
-        <TData = A>(options?: CustomUndefinedInitialQueryOptions<A, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, ComputedRef<A | undefined>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
-    };
-    <Arg, E, A_1, Request_1 extends Req, Name_1 extends string>(self: RequestHandlerWithInput<Arg, A_1, E, R, Request_1, Name_1>): {
-        /**
-         * Effect results are passed to the caller, including errors.
-         */
-        <TData = A_1>(arg: Arg | WatchSource<Arg>, options: CustomDefinedInitialQueryOptions<A_1, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
-        /**
-         * Effect results are passed to the caller, including errors.
-         */
-        <TData = A_1>(arg: Arg | WatchSource<Arg>, options: CustomDefinedPlaceholderQueryOptions<A_1, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
-        /**
-         * Effect results are passed to the caller, including errors.
-         */
-        <TData = A_1>(arg: Arg | WatchSource<Arg>, options?: CustomUndefinedInitialQueryOptions<A_1, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData | undefined>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
-    };
+    readonly initialData?: TQueryFnData | (() => TQueryFnData) | undefined;
+    readonly placeholderData: NonFunctionGuard<TQueryData> | ((prev: TQueryData | undefined) => TQueryData);
+}
+export interface AtomQueryNewOptions<TQueryFnData = unknown, TData = TQueryFnData> {
+    readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+    readonly staleTime?: number;
+    readonly idleTTL?: number | "infinity";
+    readonly gcTime?: number | "infinity";
+    readonly revalidateOnFocus?: boolean;
+    readonly refetchOnWindowFocus?: boolean;
+    readonly structuralSharing?: boolean;
+    readonly refreshEvery?: number;
+    readonly refetchInterval?: number;
+    readonly live?: boolean | LiveQueryOptions;
+    readonly invalidation?: QueryInvalidationMode;
+    readonly select?: (data: TQueryFnData) => TData;
+}
+export interface AtomStreamQueryOptions {
+    readonly staleTime?: number;
+    readonly idleTTL?: number | "infinity";
+    readonly gcTime?: number | "infinity";
+    readonly revalidateOnFocus?: boolean;
+    readonly refetchOnWindowFocus?: boolean;
+    readonly refreshEvery?: number;
+    readonly live?: boolean | LiveQueryOptions;
+    readonly refetchInterval?: number;
+}
+/**
+ * Layer TanStack `initialData` / `placeholderData` over a raw query result as a DISPLAY fallback.
+ * Only while the result is still `Initial` (pending, never settled): show `initialData` as resolved
+ * data, or `placeholderData` as provisional (`waiting: true`). Once real data exists the seed is
+ * dropped. Failures are never masked — including failures without `previousSuccess` (where
+ * `AsyncResult.value` is empty). `placeholderData` in function form receives the last seen concrete
+ * value for basic keep-previous across input changes. Returns the raw ref untouched when neither
+ * option is set. Neither value is written to the atom cache.
+ */
+export declare const withDataFallback: <A, E>(rawResult: {
+    readonly value: AsyncResult.AsyncResult<A, E>;
+}, options?: unknown) => ComputedRef<AsyncResult.AsyncResult<A, E>>;
+export declare const useAtomQuery: <A, E>(atom: () => Atom.Atom<AsyncResult.AsyncResult<A, E>>) => QueryView<A, E>;
+export declare const useAtomSuspense: <A, E>(atom: () => Atom.Atom<AsyncResult.AsyncResult<A, E>>) => Promise<SuspenseQueryView<A, E>>;
+export type StreamQueryPullValue<A> = {
+    readonly done: boolean;
+    readonly items: ReadonlyArray<A>;
+};
+export interface StreamQueryView<A, E> {
+    readonly result: ComputedRef<Atom.PullResult<A, E>>;
+    readonly items: ComputedRef<ReadonlyArray<A>>;
+    readonly latest: ComputedRef<A | undefined>;
+    readonly done: ComputedRef<boolean>;
+    readonly awaitResult: () => Effect.Effect<StreamQueryPullValue<A>, E | Cause.NoSuchElementError, never>;
+    readonly pull: () => void;
+    readonly pullAndAwait: () => Effect.Effect<StreamQueryPullValue<A>, E | Cause.NoSuchElementError, never>;
+    readonly refresh: () => void;
+    readonly registry: ReturnType<typeof injectRegistry>;
+    readonly atom: ComputedRef<Atom.Writable<Atom.PullResult<A, E>, void>>;
+}
+export declare const useAtomStreamQuery: <A, E>(atom: () => Atom.Writable<Atom.PullResult<A, E>, void>) => StreamQueryView<A, E>;
+export declare const makeQueryFamily: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestHandlerWithInput<I, A, E, R, Request, Name>) => QueryAtomFamily<I, A, E>;
+export declare const makeQueryAtom: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestHandlerWithInput<I, A, E, R, Request, Name>) => {
+    <TData = A>(arg: I, options?: Omit<AtomQueryNewOptions<A, TData>, "select">): Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+};
+export declare const makeQueryNew: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestHandlerWithInput<I, A, E, R, Request, Name>) => {
+    <TData = A>(arg: WatchSource<Option.Option<I>>, options: Omit<AtomQueryNewOptions<A, TData>, "enabled"> & {
+        mode: "optional";
+    }): QueryView<TData, E>;
+    <TData = A>(arg: I | WatchSource<I> | undefined, options?: AtomQueryNewOptions<A, TData>): QueryView<TData, E>;
+};
+export declare const makeQuery: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>) => {
+    <TData = A>(arg: WatchSource<Option.Option<I>>, options: Omit<CustomUndefinedInitialQueryOptions<A, CauseException<E>, TData>, "enabled"> & {
+        mode: "optional";
+    }): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData | undefined>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
+    <TData = A>(arg: I | WatchSource<I>, options: CustomDefinedInitialQueryOptions<A, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
+    <TData = A>(arg: I | WatchSource<I>, options: CustomDefinedPlaceholderQueryOptions<A, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
+    <TData = A>(arg: I | WatchSource<I>, options?: CustomUndefinedInitialQueryOptions<A, CauseException<E>, TData>): readonly [ComputedRef<AsyncResult.AsyncResult<TData, E>>, ComputedRef<TData | undefined>, (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, CauseException<E>>>, UseQueryReturnType<any, any>];
 };
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {
 }
+export declare const makeStreamQueryFamily: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestStreamHandlerWithInput<I, A, E, R, Request, Name>) => StreamQueryAtomFamily<I, A, E>;
+export declare const makeStreamQueryAtom: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestStreamHandlerWithInput<I, A, E, R, Request, Name>) => (arg: I, options?: AtomStreamQueryOptions) => Atom.Writable<Atom.PullResult<A, E>, void>;
+export declare const makeStreamQueryNew: <R>(_getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestStreamHandlerWithInput<I, A, E, R, Request, Name>) => (arg: MaybeRefOrGetter<I>, options?: AtomStreamQueryOptions) => StreamQueryView<A, E>;
+type StreamQueryResult<A, E> = readonly [
+    ComputedRef<AsyncResult.AsyncResult<A[], E>>,
+    ComputedRef<A[] | undefined>,
+    (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<A[], CauseException<E>>>,
+    UseQueryReturnType<any, any>
+];
+export declare const makeStreamQuery: <R>(getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime) => <I, E, A, Request extends Req, Name extends string>(q: RequestStreamHandlerWithInput<I, A, E, R, Request, Name>) => (arg: I | WatchSource<I>) => StreamQueryResult<A, E>;
+export interface MakeStreamQuery2<R> extends ReturnType<typeof makeStreamQuery<R>> {
+}
 export declare function composeQueries<R extends Record<string, AsyncResult.AsyncResult<any, any>>>(results: R, renderPreviousOnFailure?: boolean): AsyncResult.AsyncResult<{
     [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<infer A, any> ? A : never;
 }, {
     [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<any, infer E> ? E : never;
 }[keyof R]>;
-export declare const useUpdateQuery: () => {
-    <A>(query: RequestHandler<A, any, any, any, any>, updater: (data: NoInfer<A>) => NoInfer<A>): void;
-    <I, A>(query: RequestHandlerWithInput<I, A, any, any, any, any>, input: I, updater: (data: NoInfer<A>) => NoInfer<A>): void;
-};
+export declare const useUpdateQuery: () => <I, A, E, R, Request extends Req, Name extends string>(query: RequestHandlerWithInput<I, A, E, R, Request, Name>, input: I, updater: (data: NoInfer<A>) => NoInfer<A>) => void;
 export {};
 //# sourceMappingURL=query.d.ts.map