@effect-app/vue 4.0.0-beta.33 → 4.0.0-beta.331

package/dist/makeClient.d.ts

@@ -1,151 +1,206 @@
-import { type InvalidateOptions, type InvalidateQueryFilters, type QueryObserverResult, type RefetchOptions, type UseQueryReturnType } from "@tanstack/vue-query";
-import { Cause, Effect, Exit, Layer, type ManagedRuntime, S, ServiceMap } from "effect-app";
 import { type ApiClientFactory, type Req } from "effect-app/client";
-import type { RequestHandler, RequestHandlers, RequestHandlerWithInput, Requests } from "effect-app/client/clientFor";
-import { ErrorSilenced, type SupportedErrors } from "effect-app/client/errors";
-import { type OperationFailure } from "effect-app/Operations";
+import type { ExtractModuleName, HandlerInput, RequestHandlers, RequestHandlerWithInput, RequestsAny, RequestStreamHandlerWithInput } from "effect-app/client/clientFor";
+import type { CauseException } from "effect-app/client/errors";
+import type { InvalidationCallback } from "effect-app/client/makeClient";
+import * as Context from "effect-app/Context";
+import * as Effect from "effect-app/Effect";
+import * as Layer from "effect-app/Layer";
+import * as S from "effect-app/Schema";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
 import { type Fiber } from "effect/Fiber";
-import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
-import { type ComputedRef, type Ref, type WatchSource } from "vue";
-import { type Commander } from "./experimental/commander.js";
-import { I18n } from "./experimental/intl.js";
-import { type CommanderResolved } from "./experimental/makeUseCommand.js";
-import { Toast } from "./experimental/toast.js";
-import { type MutationOptions, type MutationOptionsBase, type Res } from "./mutate.js";
-import { type CustomUndefinedInitialQueryOptions, makeQuery } from "./query.js";
-export interface RequestExtensions<RT, Id extends string, I, A, E, R> {
+import type * as ManagedRuntime from "effect/ManagedRuntime";
+import type * as Stream from "effect/Stream";
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import { type ComputedRef, type WatchSource } from "vue";
+import { type AtomClientRuntime } from "./atomQuery.js";
+import { type Commander, type Progress } from "./commander.js";
+import { type I18n } from "./intl.js";
+import { type CommanderResolved } from "./makeUseCommand.js";
+import { type InvalidationEntry, type MutationOptionsBase, type QueryInvalidator } from "./mutate.js";
+import { type AtomQueryNewOptions, type CustomUndefinedInitialQueryOptions, makeQuery, makeQueryAtom, makeQueryFamily, makeQueryNew, makeStreamQuery, makeStreamQueryAtom, makeStreamQueryFamily, makeStreamQueryNew, type QueryObserverResult, type RefetchOptions, type StreamQueryAtomFamily, type SuspenseQueryView, type UseQueryReturnType } from "./query.js";
+import { type Toast } from "./toast.js";
+export type { Progress };
+declare const SuspenseInterruptedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "SuspenseInterruptedError";
+} & Readonly<A>;
+/**
+ * A suspense query settled with an interrupt-only cause while its component was still MOUNTED.
+ *
+ * That combination classifies the interrupt's origin: a navigation/unmount cancel interrupts the
+ * suspense *fiber* (via the scope's AbortSignal) or is hidden by effect-core before it can settle —
+ * it never yields a still-mounted `Failure` exit. A `Failure(interrupt-only)` observed while mounted
+ * therefore came from the QUERY side — e.g. the server returned an RPC interrupt `Exit` (over a 200),
+ * or the fetch was superseded — and silencing it leaves the user staring at a blank page.
+ *
+ * Error boundaries can rely on this split: keep silencing raw interrupt-only causes (those are
+ * genuinely "user navigated away"), and render this error as "the request was interrupted — reload?".
+ */
+export declare class SuspenseInterruptedError extends SuspenseInterruptedError_base<{
+    readonly originalCause: Cause.Cause<unknown>;
+    readonly source: "suspense" | "suspenseNew";
+}> {
+    get message(): string;
+}
+/** Structural check (by `_tag`) so consumers compiled against older published types can detect it. */
+export declare const isSuspenseInterruptedError: (e: unknown) => e is SuspenseInterruptedError;
+export interface CommandRequestExtensions<RT, Id extends string, I, A, E, R> {
     /** Defines a Command based on this call, taking the `id` of the call as the `id` of the Command.
      * The Request function will be taken as the first member of the Command, the Command required input will be the Request input.
      * see Command.wrap for details */
-    wrap: Commander.CommanderWrap<RT, Id, Id, undefined, I, A, E, R>;
+    wrap: <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.CommanderWrap<RT, Id, I18nKey, State, I, A, E, R>;
     /** Defines a Command based on this call, taking the `id` of the call as the `id` of the Command.
      * see Command.fn for details */
-    fn: Commander.CommanderFn<RT, Id, Id, undefined>;
+    fn: <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.CommanderFn<RT, Id, I18nKey, State>;
 }
 /** my other doc */
-export interface RequestExtWithInput<RT, Id extends string, I, A, E, R> extends Commander.CommandContextLocal<Id, Id>, RequestExtensions<RT, Id, I, A, E, R> {
+export interface RequestExt<RT, Id extends string, I, A, E, R> extends Commander.CommandContextLocal<Id, Id>, Commander.CommanderWrap<RT, Id, Id, undefined, I, A, E, R>, CommandRequestExtensions<RT, Id, I, A, E, R> {
     /**
-     * Request the endpoint with input
+     * Send the request to the endpoint and return the raw Effect response.
+     * This does not perform query cache invalidation.
      */
-    (i: I): Effect.Effect<A, E, R>;
+    request: (i: I) => Effect.Effect<A, E, R>;
 }
-/**
- * Request the endpoint
- */
-export interface RequestExt<RT, Id extends string, A, E, R> extends Commander.CommandContextLocal<Id, Id>, Commander.CommanderWrap<RT, Id, Id, undefined, void, A, E, R>, RequestExtensions<RT, Id, void, A, E, R>, Effect.Effect<A, E, R> {
+export type CommandRequestWithExtensions<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id> ? RequestExt<RT, Id, I, A, E, R> : never;
+export interface QueryExtensions<I, A, E, R> {
+    /**
+     * Send the request to the endpoint and return the raw Effect response.
+     * This does not set up query state tracking.
+     */
+    request: (i: I) => Effect.Effect<A, E, R>;
 }
-export type RequestWithExtensions<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id> ? RequestExtWithInput<RT, Id, I, A, E, R> : Req extends RequestHandler<infer A, infer E, infer R, infer _Request, infer Id> ? RequestExt<RT, Id, A, E, R> : never;
+export type QueryRequestWithExtensions<Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer _Id> ? QueryExtensions<I, A, E, R> : never;
+type QueryHandler<Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id> ? Request["type"] extends "query" ? RequestHandlerWithInput<I, A, E, R, Request, Id> : never : never;
+type CommandHandler<Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id> ? Request["type"] extends "command" ? RequestHandlerWithInput<I, A, E, R, Request, Id> : never : never;
+type QueryStreamHandler<Req> = Req extends RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id, infer Final> ? [Request["stream"], Request["type"]] extends [true, "query"] ? RequestStreamHandlerWithInput<I, A, E, R, Request, Id, Final> : never : never;
+type CommandStreamHandler<Req> = Req extends RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id, infer Final> ? [Request["stream"], Request["type"]] extends [true, "command"] ? RequestStreamHandlerWithInput<I, A, E, R, Request, Id, Final> : never : never;
 export interface MutationExtensions<RT, Id extends string, I, A, E, R> {
     /** Defines a Command based on this mutation, taking the `id` of the mutation as the `id` of the Command.
      * The Mutation function will be taken as the first member of the Command, the Command required input will be the Mutation input.
      * see Command.wrap for details */
-    wrap: Commander.CommanderWrap<RT, Id, Id, undefined, I, A, E, R>;
-    /** Defines a Command based on this mutation, taking the `id` of the mutation as the `id` of the Command.
+    wrap: <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.CommanderWrap<RT, Id, I18nKey, State, I, A, E, R>;
+    /** Defines a Command based on this call, taking the `id` of the mutation as the `id` of the Command.
      * see Command.fn for details */
-    fn: Commander.CommanderFn<RT, Id, Id, undefined>;
-}
-/** my other doc */
-export interface MutationExtWithInput<RT, Id extends string, I, A, E, R> extends Commander.CommandContextLocal<Id, Id>, MutationExtensions<RT, Id, I, A, E, R> {
-    /**
-     * Call the endpoint with input
-     * Invalidate queries based on namespace of this mutation.
-     * Do not use for queries.
-     */
-    (i: I): Effect.Effect<A, E, R>;
+    fn: <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.CommanderFn<RT, Id, I18nKey, State>;
 }
 /**
- * Call the endpoint
- * Invalidate queries based on namespace of this mutation.
- * Do not use for queries.
+ * Send the request to the endpoint and return the raw Effect response.
+ * Also invalidates query caches using the request namespace by default.
+ * Namespace invalidation targets parent namespace keys
+ * (for example `$project/$configuration.get` invalidates `$project`).
+ * Override invalidation in client options via `queryInvalidation`.
+ *
+ * Pass `options` to attach a `select` Effect that runs after the mutation
+ * succeeds (its output is returned to the caller) and/or override the default
+ * `queryInvalidation`.
+ *
+ * When `I = void` the input argument may be omitted.
  */
-export interface MutationExt<RT, Id extends string, A, E, R> extends Commander.CommandContextLocal<Id, Id>, Commander.CommanderWrap<RT, Id, Id, undefined, void, A, E, R>, MutationExtensions<RT, Id, void, A, E, R>, Effect.Effect<A, E, R> {
+export interface MutationExt<RT, Id extends string, I, A, E, R, EA = unknown> extends MutationExtensions<RT, Id, I, A, E, R> {
+    <B = A, E2 = never, R2 = never>(input: I, options?: MutationOptionsBase<A, B, E2, R2>): Effect.Effect<B, E | E2, R | R2>;
+    project: <ProjSchema extends S.Top>(schema: EA extends ProjSchema["Encoded"] ? ProjSchema : never) => MutationExt<RT, Id, I, ProjSchema["Type"], E | S.SchemaError, R | ProjSchema["DecodingServices"], ProjSchema["Encoded"]>;
 }
-export type MutationWithExtensions<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id> ? MutationExtWithInput<RT, Id, I, A, E, R> : Req extends RequestHandler<infer A, infer E, infer R, infer _Request, infer Id> ? MutationExt<RT, Id, A, E, R> : never;
+export type MutationWithExtensions<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id> ? MutationExt<RT, Id, I, A, E, R, Request["success"]["Encoded"]> : never;
+/**
+ * The `streamFn` builder for a stream-type request handler, using the stream-specific overloads.
+ */
+export type StreamFnStreamExtension<RT, Req> = Req extends RequestStreamHandlerWithInput<infer _I, infer _A, infer _E, infer _R, infer _Request, infer Id, infer _Final> ? <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.StreamGen<RT, Id, I18nKey, State> & Commander.NonGenStream<RT, Id, I18nKey, State> : never;
+/**
+ * `mutate` factory — wraps per-invocation invalidation scaffolding
+ * into the stream itself (via `Stream.unwrap`) for use with `streamFn` combinators.
+ */
+export type StreamMutation2WithExtensions<RT, Req> = Req extends RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id, infer _Final> ? ((input: I) => Stream.Stream<A, E, R>) & {
+    readonly id: Id;
+    readonly wrap: <I18nKey extends string = Id, State extends Commander.IntlRecord | undefined = undefined>(options?: Commander.FnOptions<Id, I18nKey, State>) => Commander.StreamerWrap<RT, Id, I18nKey, State, I, A, E, R>;
+} : never;
 declare const useQuery_: QueryImpl<any>["useQuery"];
+declare const useQueryNew_: QueryImpl<any>["useQueryNew"];
+declare const useQueryAtom_: QueryImpl<any>["useQueryAtom"];
+declare const useQueryFamily_: QueryImpl<any>["useQueryFamily"];
+declare const useSuspenseQueryNew_: QueryImpl<any>["useSuspenseQueryNew"];
 declare const useSuspenseQuery_: QueryImpl<any>["useSuspenseQuery"];
-export interface QueriesWithInput<Request extends Req, Id extends string, I, A, E> {
+declare const useStreamQuery_: QueryImpl<any>["useStreamQuery"];
+declare const useStreamQueryAtom_: QueryImpl<any>["useStreamQueryAtom"];
+declare const useStreamQueryNew_: QueryImpl<any>["useStreamQueryNew"];
+export interface ProjectResult<RT, I, B, E, R, Request extends Req, Id extends string> {
+    request: (i: I) => Effect.Effect<B, E, R>;
+    family: Exclude<R, RT> extends never ? ReturnType<typeof useQueryFamily_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+    query: Exclude<R, RT> extends never ? ReturnType<typeof useQuery_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+    queryNew: Exclude<R, RT> extends never ? ReturnType<typeof useQueryNew_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+    suspense: Exclude<R, RT> extends never ? ReturnType<typeof useSuspenseQuery_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+    suspenseNew: Exclude<R, RT> extends never ? ReturnType<typeof useSuspenseQueryNew_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+    atom: Exclude<R, RT> extends never ? ReturnType<typeof useQueryAtom_<I, E, B, Request, Id>> : MissingDependencies<RT, R> & {};
+}
+export type QueryProjection<RT, HandlerReq> = HandlerReq extends RequestHandlerWithInput<infer I, infer _A, infer E, infer R, infer Request, infer Id> ? Request["type"] extends "query" ? {
+    project: <ProjSchema extends S.Top>(schema: Request["success"]["Encoded"] extends ProjSchema["Encoded"] ? ProjSchema : never) => ProjectResult<RT, I, ProjSchema["Type"], E | S.SchemaError, R | ProjSchema["DecodingServices"], Request, Id>;
+} : {} : {};
+export interface QueryResultExtensions<Request extends Req, Id extends string, I, A, E> {
     /**
-     * Effect results are passed to the caller, including errors.
+     * Read helper for query requests.
+     * Runs as a tracked Vue Query and returns reactive state.
+     * Queries read state and should not be used to mutate it.
+     * When `I = void` the input argument may be omitted.
      */
     query: ReturnType<typeof useQuery_<I, E, A, Request, Id>>;
     /**
-     * The difference with useQuery is that this function will return a Promise you can await in the Setup,
-     * which ensures that either there always is a latest value, or an error occurs on load.
-     * So that Suspense and error boundaries can be used.
+     * Atom-native query helper with object return shape.
+     * Additive migration surface; `.query()` remains the compatibility tuple API.
+     */
+    queryNew: ReturnType<typeof useQueryNew_<I, E, A, Request, Id>>;
+    /**
+     * Like `.query`, but returns a Promise for setup-time awaiting.
+     * Use this when integrating with Vue Suspense / error boundaries.
      */
     suspense: ReturnType<typeof useSuspenseQuery_<I, E, A, Request, Id>>;
-}
-export interface QueriesWithoutInput<Request extends Req, Id extends string, A, E> {
     /**
-     * Effect results are passed to the caller, including errors.
+     * Promise-based setup helper with object return shape.
+     * Additive migration surface; `.suspense()` remains the compatibility tuple API.
      */
-    query: ReturnType<typeof useQuery_<E, A, Request, Id>>;
+    suspenseNew: ReturnType<typeof useSuspenseQueryNew_<I, E, A, Request, Id>>;
     /**
-     * The difference with useQuery is that this function will return a Promise you can await in the Setup,
-     * which ensures that either there always is a latest value, or an error occurs on load.
-     * So that Suspense and error boundaries can be used.
+     * Raw query atom for composition outside Vue refs.
      */
-    suspense: ReturnType<typeof useSuspenseQuery_<E, A, Request, Id>>;
+    atom: ReturnType<typeof useQueryAtom_<I, E, A, Request, Id>>;
+    /**
+     * Raw query atom family for composing query graphs before choosing a Vue observer.
+     */
+    family: ReturnType<typeof useQueryFamily_<I, E, A, Request, Id>>;
 }
 export type MissingDependencies<RT, R> = {
     message: "Dependencies required that are not provided by the runtime";
     dependencies: Exclude<R, RT>;
 };
-export type Queries<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id> ? Exclude<R, RT> extends never ? QueriesWithInput<Request, Id, I, A, E> : {
+export type Queries<RT, Req> = Req extends RequestHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id> ? Request["type"] extends "query" ? Exclude<R, RT> extends never ? QueryResultExtensions<Request, Id, I, A, E> : {
+    atom: MissingDependencies<RT, R> & {};
+    family: MissingDependencies<RT, R> & {};
     query: MissingDependencies<RT, R> & {};
+    queryNew: MissingDependencies<RT, R> & {};
     suspense: MissingDependencies<RT, R> & {};
-} : Req extends RequestHandler<infer A, infer E, infer R, infer Request, infer Id> ? Exclude<R, RT> extends never ? QueriesWithoutInput<Request, Id, A, E> : {
+    suspenseNew: MissingDependencies<RT, R> & {};
+} : never : never;
+export interface StreamQueryExtensions<Request extends Req, Id extends string, I, A, E> {
+    atom: ReturnType<typeof useStreamQueryAtom_<I, E, A, Request, Id>>;
+    family: StreamQueryAtomFamily<I, A, E>;
+    /**
+     * Stream helper for query-stream requests.
+     * Legacy compatibility helper. Collects the whole stream into an array before
+     * publishing data.
+     * When `I = void` the input argument may be omitted.
+     */
+    query: ReturnType<typeof useStreamQuery_<I, E, A, Request, Id>>;
+    /**
+     * Atom-native stream query helper. Exposes incremental pull state and a `pull`
+     * command instead of collecting the whole stream first.
+     */
+    queryNew: ReturnType<typeof useStreamQueryNew_<I, E, A, Request, Id>>;
+}
+export type StreamQueries<RT, HandlerReq> = HandlerReq extends RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer Request, infer Id, infer _Final> ? Exclude<R, RT> extends never ? StreamQueryExtensions<Request, Id, I, A, E> : {
+    atom: MissingDependencies<RT, R> & {};
+    family: MissingDependencies<RT, R> & {};
     query: MissingDependencies<RT, R> & {};
-    suspense: MissingDependencies<RT, R> & {};
+    queryNew: MissingDependencies<RT, R> & {};
 } : never;
-declare const SuppressErrors_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-    readonly _tag: "SuppressErrors";
-} & Readonly<A>;
-/**
- * Use this after handling an error yourself, still continueing on the Error track, but the error will not be reported.
- */
-export declare class SuppressErrors extends SuppressErrors_base<{}> {
-    readonly [ErrorSilenced]: true;
-}
-export type ResponseErrors = S.SchemaError | SupportedErrors | SuppressErrors | OperationFailure;
-export interface Opts<A, E, R, I = void, A2 = A, E2 = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never> extends MutationOptions<A, E, R, A2, E2, R2, I> {
-    /** set to `undefined` to use default message */
-    successMessage?: ((a: A2, i: I) => Effect.Effect<string | undefined, ESuccess, RSuccess>) | undefined;
-    /** set to `undefined` to use default message */
-    failMessage?: ((e: E2, i: I) => Effect.Effect<string | undefined, EError, RError>) | undefined;
-    /** set to `undefined` to use default message */
-    defectMessage?: ((e: Cause.Cause<E2>, i: I) => Effect.Effect<string | undefined, EDefect, RDefect>) | undefined;
-}
-export interface LowOpts<A, E, I = void, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never> {
-    onSuccess: (a: A, i: I) => Effect.Effect<void, ESuccess, RSuccess>;
-    onFail: (e: E, i: I) => Effect.Effect<void, EError, RError>;
-    onDefect: (e: Cause.Cause<E>, i: I) => Effect.Effect<void, EDefect, RDefect>;
-}
-export interface LowOptsOptional<A, E, R, I = void, A2 = A, E2 = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never> extends MutationOptions<A, E, R, A2, E2, R2, I> {
-    onSuccess?: (a: A, i: I) => Effect.Effect<void, ESuccess, RSuccess>;
-    onFail?: (e: E, i: I) => Effect.Effect<void, EError, RError>;
-    onDefect?: (e: Cause.Cause<E>, i: I) => Effect.Effect<void, EDefect, RDefect>;
-}
-type WithAction<A> = A & {
-    action: string;
-};
-type Resp<I, A, E, R, V = ComputedRef<Res<A, E>>> = readonly [
-    V,
-    WithAction<(I: I) => Effect.Effect<Exit.Exit<A, E>, never, R>>
-];
-type ActResp<A, E, R, V = ComputedRef<Res<A, E>>> = readonly [
-    V,
-    WithAction<Effect.Effect<Exit.Exit<A, E>, never, R>>
-];
-export declare const suppressToast: import("effect/Function").LazyArg<Effect.Effect<undefined, never, never>>;
-declare const _useMutation: {
-    <I, E, A, R, Request extends Req, Id extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Id>, options?: MutationOptionsBase): ((i: I) => Effect.Effect<A, E, R>) & {
-        readonly id: Id;
-    };
-    <E, A, R, Request extends Req, Id extends string>(self: RequestHandler<A, E, R, Request, Id>, options?: MutationOptionsBase): Effect.Effect<A, E, R> & {
-        readonly id: Id;
-    };
-};
+declare const _useMutation: <I, E, A, R, Request extends Req, Id extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Id>) => import("./mutate.js").MutationFn<I, A, E, R, Id>;
 /**
  * Pass an Effect or a function that returns an Effect, e.g from a client action
  * Executes query cache invalidation based on default rules or provided option.
@@ -157,202 +212,34 @@ export declare const useMutation: typeof _useMutation;
  * Executes query cache invalidation based on default rules or provided option.
  * adds a span with the mutation id
  */
-export declare const useMutationInt: () => {
-    <I, E, A, R, Request extends Req, Id extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Id>, options?: MutationOptionsBase): ((i: I) => Effect.Effect<A, E, R>) & {
-        readonly id: Id;
-    };
-    <E, A, R, Request extends Req, Id extends string>(self: RequestHandler<A, E, R, Request, Id>, options?: MutationOptionsBase): Effect.Effect<A, E, R> & {
-        readonly id: Id;
-    };
-};
-export declare class LegacyMutationImpl<RT> {
-    private readonly getRuntime;
-    private readonly toast;
-    private readonly intl;
-    constructor(getRuntime: () => ServiceMap.ServiceMap<RT>, toast: Toast, intl: I18n);
+export declare const useMutationInt: (queryInvalidator: QueryInvalidator) => <I, E, A, R, Request extends Req, Id extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Id>) => import("./mutate.js").MutationFn<I, A, E, R, Id>;
+export type ClientFrom<M extends RequestsAny> = RequestHandlers<never, never, M, ExtractModuleName<M>>;
+export interface MakeClientOptions {
     /**
-     * Effect results are converted to Exit, so errors are ignored by default.
-     * you should use the result ref to render errors!
-     * @deprecated use `Command.fn` and friends instead
+     * Selects the engine behind legacy `.query()` / `.suspense()` helpers.
+     * Atom-native `.atom()` / `.family()` / `.queryNew()` / `.suspenseNew()` always use Atom.
      */
-    readonly useSafeMutation: {
-        /**
-         * Effect results are converted to Exit, so errors are ignored by default.
-         * you should use the result ref to render errors!
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E, A, R, Request extends Req, Name extends string, A2 = A, E2 = E, R2 = R>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, options?: MutationOptions<A, E, R, A2, E2, R2, I>): readonly [
-            ComputedRef<AsyncResult.AsyncResult<A2, E2>>,
-            (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ];
-        /**
-         * Effect results are converted to Exit, so errors are ignored by default.
-         * you should use the result ref to render errors!
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E, A, R, Request extends Req, Name extends string, A2 = A, E2 = E, R2 = R>(self: RequestHandler<A, E, R, Request, Name>, options?: MutationOptions<A, E, R, A2, E2, R2>): readonly [
-            ComputedRef<AsyncResult.AsyncResult<A2, E2>>,
-            Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ];
-    };
-    /** handles errors as toasts and reports defects
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useHandleRequestWithToast: () => <A, E extends ResponseErrors, R, I = void, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(f: Effect.Effect<Exit.Exit<A2, E2>, never, R2> | ((i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>), id: string, action: string, options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>) => (Effect.Effect<Exit.Exit<A2, E2>, ESuccess | EError | EDefect, Exclude<R2, import("effect/Tracer").ParentSpan> | Exclude<RSuccess, import("effect/Tracer").ParentSpan> | Exclude<RError, import("effect/Tracer").ParentSpan> | Exclude<RDefect, import("effect/Tracer").ParentSpan>> | ((i: any) => Effect.Effect<Exit.Exit<A2, E2>, ESuccess | EError | EDefect, Exclude<R2, import("effect/Tracer").ParentSpan> | Exclude<RSuccess, import("effect/Tracer").ParentSpan> | Exclude<RError, import("effect/Tracer").ParentSpan> | Exclude<RDefect, import("effect/Tracer").ParentSpan>>)) & {
-        action: string;
-    };
-    /**
-     * Pass a function that returns an Effect, e.g from a client action, give it a name.
-     * Returns a tuple with raw Result and execution function which reports success and errors as Toast.
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useAndHandleMutationResult: {
-        /**
-         * Pass a function that returns an Effect, e.g from a client action, give it a name.
-         * Returns a tuple with raw Result and execution function which reports success and errors as Toast.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): Resp<I, A2, E2, R2, ComputedRef<AsyncResult.AsyncResult<A2, E2>>>;
-        /**
-         * Pass a function that returns an Effect, e.g from a client action, give it a name.
-         * Returns a tuple with raw Result and execution function which reports success and errors as Toast.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandler<A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): ActResp<A2, E2, R2, ComputedRef<AsyncResult.AsyncResult<A2, E2>>>;
-    };
-    /**
-     * Pass a function that returns an Effect, e.g from a client action, give it a name.
-     * Returns a tuple with state ref and execution function which reports success and errors as Toast.
-     *
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useAndHandleMutation: {
-        /**
-         * Pass a function that returns an Effect, e.g from a client action, give it a name.
-         * Returns a tuple with state ref and execution function which reports success and errors as Toast.
-         *
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): Resp<I, A2, E2, R2>;
-        /**
-         * Pass a function that returns an Effect, e.g from a client action, give it a name.
-         * Returns a tuple with state ref and execution function which reports success and errors as Toast.
-         *
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandler<A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): ActResp<A2, E2, R2>;
-    };
-    /** @deprecated use `Command.fn` and friends instead */
-    readonly makeUseAndHandleMutation: (defaultOptions?: Opts<any, any, any, any, any, any, any, any, any>) => {
-        <I, E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): Resp<I, A2, E2, R2>;
-        <E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandler<A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): ActResp<A2, E2, R2>;
-    };
-    /**
-     * The same as @see useAndHandleMutation, but does not display any toasts by default.
-     * Messages for success, error and defect toasts can be provided in the Options.
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useAndHandleMutationSilently: {
-        /**
-         * The same as @see useAndHandleMutation, but does not display any toasts by default.
-         * Messages for success, error and defect toasts can be provided in the Options.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): Resp<I, A2, E2, R>;
-        /**
-         * The same as @see useAndHandleMutation, but does not display any toasts by default.
-         * Messages for success, error and defect toasts can be provided in the Options.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandler<A, E, R, Request, Name>, action: string, options?: Opts<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): ActResp<void, never, R>;
-    };
-    /**
-     * The same as @see useAndHandleMutation, but does not act on success, error or defect by default.
-     * Actions for success, error and defect can be provided in the Options.
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useAndHandleMutationCustom: {
-        /**
-         * The same as @see useAndHandleMutation, but does not act on success, error or defect by default.
-         * Actions for success, error and defect can be provided in the Options.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, action: string, options?: LowOptsOptional<A, E, R, I, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): Resp<I, A2, E2, R2>;
-        /**
-         * The same as @see useAndHandleMutation, but does not act on success, error or defect by default.
-         * Actions for success, error and defect can be provided in the Options.
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E extends ResponseErrors, A, R, Request extends Req, Name extends string, A2 = A, E2 extends ResponseErrors = E, R2 = R, ESuccess = never, RSuccess = never, EError = never, RError = never, EDefect = never, RDefect = never>(self: RequestHandler<A, E, R, Request, Name>, action: string, options?: LowOptsOptional<A, E, R, void, A2, E2, R2, ESuccess, RSuccess, EError, RError, EDefect, RDefect>): ActResp<A2, E2, R2>;
-    };
-    /**
-     * Effect results are converted to Exit, so errors are ignored by default.
-     * you should use the result ref to render errors!
-     * @deprecated use `Command.fn` and friends instead
-     */
-    readonly useSafeMutationWithState: {
-        /**
-         * Effect results are converted to Exit, so errors are ignored by default.
-         * you should use the result ref to render errors!
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <I, E, A, R, Request extends Req, Name extends string, A2 = A, E2 = E, R2 = R>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>, options?: MutationOptions<A, E, R, A2, E2, R2, I>): readonly [
-            ComputedRef<Res<A, E>>,
-            (i: I) => Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ];
-        /**
-         * Effect results are converted to Exit, so errors are ignored by default.
-         * you should use the result ref to render errors!
-         * @deprecated use `Command.fn` and friends instead
-         */
-        <E, A, R, Request extends Req, Name extends string, A2 = A, E2 = E, R2 = R>(self: RequestHandler<A, E, R, Request, Name>, options?: MutationOptions<A, E, R, A2, E2, R2>): readonly [
-            ComputedRef<Res<A, E>>,
-            Effect.Effect<Exit.Exit<A2, E2>, never, R2>
-        ];
-    };
-    /** @deprecated use OmegaForm */
-    readonly buildFormFromSchema: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, C extends Record<PropertyKey, any>, OnSubmitA>(s: S.Codec<To> & {
-        new (c: C): any;
-        extend: any;
-        fields: S.Struct.Fields;
-    }, state: Ref<Omit<From, "_tag">>, onSubmit: (a: To) => Effect.Effect<OnSubmitA, never, RT>) => {
-        fields: { [K in keyof To]-?: {
-            true: {
-                true: To[K] extends {
-                    _tag: string;
-                } ? import("./form.js").DiscriminatedUnionFieldInfo<{ [P in import("./form.js").DistributiveNestedFieldInfoKey<To[K]> as P["_infoTag" & keyof P] & string]: P; }> : import("./form.js").UnionFieldInfo<import("./form.js").DistributiveNestedFieldInfoKey<To[K]>[]>;
-                false: import("./form.js").NestedFieldInfoKey<To[K]>;
-            }[`${To[K] extends object ? true : false}`];
-            false: import("./form.js").NestedFieldInfoKey<To[K]>;
-        }[`${import("effect-app/utils").IsUnion<To[K]>}`]; };
-        /** optimized for Vuetify v-form submit callback */
-        submit: <T extends Promise<{
-            valid: boolean;
-        }>>(e: T) => Promise<unknown>;
-        /** optimized for Native form submit callback or general use */
-        submitFromState: Effect.Effect<any, unknown, unknown>;
-        submitFromStatePromise: () => Promise<unknown>;
-        isDirty: Ref<boolean, boolean>;
-        isValid: Ref<boolean, boolean>;
-        isLoading: Ref<boolean, boolean>;
-    };
+    readonly legacyQueryEngine?: "atom" | "tanstack";
 }
-declare const LegacyMutation_base: ServiceMap.ServiceClass<LegacyMutation, "LegacyMutation", <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => LegacyMutationImpl<R>> & {
-    readonly make: Effect.Effect<(<R>(getRuntime: () => ServiceMap.ServiceMap<R>) => LegacyMutationImpl<R>), never, I18n | Toast>;
-};
-export declare class LegacyMutation extends LegacyMutation_base {
-    static readonly DefaultWithoutDependencies: Layer.Layer<LegacyMutation, never, I18n | Toast>;
-    static readonly Default: Layer.Layer<LegacyMutation, never, I18n | Toast>;
-}
-export type ClientFrom<M extends Requests> = RequestHandlers<never, never, M, M["meta"]["moduleName"]>;
 export declare class QueryImpl<R> {
-    readonly getRuntime: () => ServiceMap.ServiceMap<R>;
-    constructor(getRuntime: () => ServiceMap.ServiceMap<R>);
+    readonly getRuntime: () => Context.Context<R>;
+    constructor(getRuntime: () => Context.Context<R>, getAtomRt: () => AtomClientRuntime, legacyUseQuery?: ReturnType<typeof makeQuery<R>>);
     /**
      * Effect results are passed to the caller, including errors.
      * @deprecated use client helpers instead (.query())
      */
     readonly useQuery: ReturnType<typeof makeQuery<R>>;
+    readonly useQueryNew: ReturnType<typeof makeQueryNew<R>>;
+    readonly useQueryAtom: ReturnType<typeof makeQueryAtom<R>>;
+    readonly useQueryFamily: ReturnType<typeof makeQueryFamily<R>>;
+    /**
+     * Stream results are accumulated as an array of chunks and returned as reactive state.
+     * @deprecated use client helpers instead (.query())
+     */
+    readonly useStreamQuery: ReturnType<typeof makeStreamQuery<R>>;
+    readonly useStreamQueryFamily: ReturnType<typeof makeStreamQueryFamily<R>>;
+    readonly useStreamQueryAtom: ReturnType<typeof makeStreamQueryAtom<R>>;
+    readonly useStreamQueryNew: ReturnType<typeof makeStreamQueryNew<R>>;
     /**
      * The difference with useQuery is that this function will return a Promise you can await in the Setup,
      * which ensures that either there always is a latest value, or an error occurs on load.
@@ -364,73 +251,86 @@ export declare class QueryImpl<R> {
          * The difference with useQuery is that this function will return a Promise you can await in the Setup,
          * which ensures that either there always is a latest value, or an error occurs on load.
          * So that Suspense and error boundaries can be used.
-         * @deprecated use client helpers instead (.suspense())
+         * When `I = void` the input argument may be omitted.
          */
-        <E, A, Request extends Req, Name extends string>(self: RequestHandler<A, E, R, Request, Name>): {
-            /**
-             * The difference with useQuery is that this function will return a Promise you can await in the Setup,
-             * which ensures that either there always is a latest value, or an error occurs on load.
-             * So that Suspense and error boundaries can be used.
-             */
-            <TData = A>(options?: CustomUndefinedInitialQueryOptions<A, E, TData>): Promise<readonly [
+        <I, E, A, Request extends Req, Name extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>): {
+            <TData = A>(arg: I | WatchSource<I>, options?: CustomUndefinedInitialQueryOptions<A, CauseException<E>, TData>): Promise<readonly [
                 ComputedRef<AsyncResult.AsyncResult<TData, E>>,
                 ComputedRef<TData>,
                 (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, E>>,
                 UseQueryReturnType<any, any>
             ]>;
         };
-        /**
-         * The difference with useQuery is that this function will return a Promise you can await in the Setup,
-         * which ensures that either there always is a latest value, or an error occurs on load.
-         * So that Suspense and error boundaries can be used.
-         */
-        <Arg, E, A, Request extends Req, Name extends string>(self: RequestHandlerWithInput<Arg, A, E, R, Request, Name>): {
-            /**
-             * The difference with useQuery is that this function will return a Promise you can await in the Setup,
-             * which ensures that either there always is a latest value, or an error occurs on load.
-             * So that Suspense and error boundaries can be used.
-             */
-            <TData = A>(arg: Arg | WatchSource<Arg>, options?: CustomUndefinedInitialQueryOptions<A, E, TData>): Promise<readonly [
-                ComputedRef<AsyncResult.AsyncResult<TData, E>>,
-                ComputedRef<TData>,
-                (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, E>>,
-                UseQueryReturnType<any, any>
-            ]>;
+    };
+    readonly useSuspenseQueryNew: {
+        <I, E, A, Request extends Req, Name extends string>(self: RequestHandlerWithInput<I, A, E, R, Request, Name>): {
+            <TData = A>(arg: I | WatchSource<I>, options?: AtomQueryNewOptions<A, TData>): Promise<SuspenseQueryView<TData, E>>;
         };
     };
 }
 type Base = I18n | Toast;
-type Mix = ApiClientFactory | Commander | LegacyMutation | Base;
-export declare const makeClient: <RT_, RTHooks>(getBaseMrt: () => ManagedRuntime.ManagedRuntime<RT_ | Mix, never>, clientFor_: ReturnType<(typeof ApiClientFactory)["makeFor"]>, rtHooks: Layer.Layer<RTHooks, never, Mix>) => {
-    Command: CommanderResolved<Mix | RT_, RTHooks>;
-    useCommand: () => CommanderResolved<Mix | RT_, RTHooks>;
-    clientFor: <M extends Requests>(m: M, queryInvalidation?: (client: ClientFrom<M>) => QueryInvalidation<M>) => { [Key in keyof RequestHandlers<never, never, M, M["meta"]["moduleName"]>]: RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key] & RequestWithExtensions<RTHooks | (Mix | RT_), RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key]> & {
-        mutate: MutationWithExtensions<RTHooks | (Mix | RT_), RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key]>;
-    } & Queries<Mix | RT_, RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key]>; } & {
-        helpers: { [Key_1 in keyof RequestHandlers<never, never, M, M["meta"]["moduleName"]> as `${ToCamel<string & Key_1>}Request`]: RequestWithExtensions<RTHooks | (Mix | RT_), RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key_1]>; } & { [Key_2 in keyof RequestHandlers<never, never, M, M["meta"]["moduleName"]> as `${ToCamel<string & Key_2>}Mutation`]: MutationWithExtensions<RTHooks | (Mix | RT_), RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key_2]>; } & { [Key_3 in keyof RequestHandlers<never, never, M, M["meta"]["moduleName"]> as `${ToCamel<string & Key_3>}Query`]: Queries<Mix | RT_, RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key_3]>["query"]; } & { [Key_4 in keyof RequestHandlers<never, never, M, M["meta"]["moduleName"]> as `${ToCamel<string & Key_4>}SuspenseQuery`]: Queries<Mix | RT_, RequestHandlers<never, never, M, M["meta"]["moduleName"]>[Key_4]>["suspense"]; };
+type Mix = ApiClientFactory | Commander | Base;
+type InvalidationResources = Record<string, Record<string, unknown>>;
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends ((arg: infer I) => void) ? I : never;
+type CommandInvalidationResources<Req> = Req extends {
+    readonly type: "command";
+    readonly "~invalidationResources"?: infer Resources;
+} ? NonNullable<Resources> extends InvalidationResources ? NonNullable<Resources> : never : Req extends {
+    readonly type: "command";
+    readonly config?: infer Config;
+} ? Config extends {
+    readonly invalidationResources?: infer LegacyResources;
+} ? NonNullable<LegacyResources> extends InvalidationResources ? NonNullable<LegacyResources> : never : Config extends {
+    readonly invalidatesQueries?: InvalidationCallback<infer LegacyResources, any, any, any>;
+} ? NonNullable<LegacyResources> extends InvalidationResources ? NonNullable<LegacyResources> : never : never : never;
+type InvalidationResourcesForUnion<M extends RequestsAny> = {
+    [K in keyof M]: CommandInvalidationResources<M[K]>;
+}[keyof M];
+type InvalidationResourcesFor<M extends RequestsAny> = [InvalidationResourcesForUnion<M>] extends [never] ? never : UnionToIntersection<InvalidationResourcesForUnion<M>> extends infer R ? R extends InvalidationResources ? R : never : never;
+type QueryInvalidationFactory<M extends RequestsAny> = (client: ClientFrom<M>) => QueryInvalidation<M>;
+type StrictResourcesArg<Shape, Actual extends Shape = Shape> = Actual & Record<Exclude<keyof Actual, keyof Shape>, never>;
+type ClientForArgs<M extends RequestsAny, Resources extends InvalidationResourcesFor<M> = InvalidationResourcesFor<M>> = [InvalidationResourcesFor<M>] extends [never] ? [
+    queryInvalidation?: QueryInvalidationFactory<M>,
+    invalidationResources?: StrictResourcesArg<InvalidationResourcesFor<M>, Resources>
+] : [
+    queryInvalidation: QueryInvalidationFactory<M> | undefined,
+    invalidationResources: StrictResourcesArg<InvalidationResourcesFor<M>, Resources>
+];
+export declare const makeClient: <RT_, RTHooks>(getBaseMrt: () => ManagedRuntime.ManagedRuntime<RT_ | Mix, never>, clientFor_: ReturnType<typeof ApiClientFactory["makeFor"]>, rtHooks: Layer.Layer<RTHooks, never, Mix>, options?: MakeClientOptions) => {
+    Command: CommanderResolved<RT_ | Mix, RTHooks>;
+    useCommand: () => CommanderResolved<RT_ | Mix, RTHooks>;
+    clientFor: <M extends RequestsAny, Resources extends InvalidationResourcesFor<M> = InvalidationResourcesFor<M>>(m: M, ...args: ClientForArgs<M, Resources>) => { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>>]: RequestHandlers<never, never, M, ExtractModuleName<M>>[Key] & (QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? {} : QueryRequestWithExtensions<QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>> & Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>> & QueryProjection<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>) & (QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? {} : StreamQueries<RT_ | Mix, QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>) & (CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? {} : CommandRequestWithExtensions<RTHooks | (RT_ | Mix), CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>) & (CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? {} : {
+        mutate: MutationWithExtensions<RTHooks | (RT_ | Mix), CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>;
+    }) & (CommandStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? {} : {
+        fn: StreamFnStreamExtension<RTHooks | (RT_ | Mix), CommandStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>;
+        mutate: StreamMutation2WithExtensions<RTHooks | (RT_ | Mix), CommandStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>;
+    }) & {
+        Input: RequestHandlers<never, never, M, ExtractModuleName<M>>[Key] extends RequestStreamHandlerWithInput<infer I, any, any, any, any, any, any> ? I : RequestHandlers<never, never, M, ExtractModuleName<M>>[Key] extends RequestHandlerWithInput<infer I_1, any, any, any, any, any> ? I_1 : never;
+    }; } & {
+        helpers: { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}Request`]: CommandRequestWithExtensions<RTHooks | (RT_ | Mix), CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}Mutation`]: MutationWithExtensions<RTHooks | (RT_ | Mix), CommandHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}QueryFamily`]: Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["family"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}Query`]: Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["query"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}QueryNew`]: Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["queryNew"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}SuspenseQuery`]: Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["suspense"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}SuspenseQueryNew`]: Queries<RT_ | Mix, QueryHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["suspenseNew"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}QueryFamily`]: StreamQueries<RT_ | Mix, QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["family"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}Query`]: StreamQueries<RT_ | Mix, QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["query"]; } & { [Key in keyof RequestHandlers<never, never, M, ExtractModuleName<M>> as QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]> extends never ? never : `${ToCamel<string & Key>}QueryNew`]: StreamQueries<RT_ | Mix, QueryStreamHandler<RequestHandlers<never, never, M, ExtractModuleName<M>>[Key]>>["queryNew"]; };
     };
-    legacy: Legacy<Mix | RT_>;
+    tanstackQueryClient: import("@tanstack/vue-query").QueryClient;
 };
-export interface Legacy<R> extends Pick<QueryImpl<R>, "useQuery" | "useSuspenseQuery">, Omit<LegacyMutationImpl<R>, "getRuntime" | "toast" | "intl"> {
-}
 export type QueryInvalidation<M> = {
-    [K in keyof M]?: (defaultKey: string[], name: string) => {
-        filters?: InvalidateQueryFilters | undefined;
-        options?: InvalidateOptions | undefined;
-    }[];
+    [K in keyof M]?: (defaultKey: string[], name: string, input?: unknown, output?: Exit.Exit<unknown, unknown>) => InvalidationEntry[];
 };
 export type ToCamel<S extends string | number | symbol> = S extends string ? S extends `${infer Head}_${infer Tail}` ? `${Uncapitalize<Head>}${Capitalize<ToCamel<Tail>>}` : Uncapitalize<S> : never;
-export interface CommandBase<I = void, A = void> {
+export interface CommandBase<I = void, A = void, RA = unknown, RE = unknown> {
     handle: (input: I) => A;
     waiting: boolean;
     blocked: boolean;
     allowed: boolean;
     action: string;
     label: string;
+    /** formatted progress info for current `running` state, when `progress` was supplied */
+    progress?: Progress | undefined;
+    /** reactive result state, available on stream-backed commands */
+    result?: AsyncResult.AsyncResult<RA, RE>;
 }
-export interface EffectCommand<I = void, A = unknown, E = unknown> extends CommandBase<I, Fiber<A, E>> {
+export interface EffectCommand<I = void, A = unknown, E = unknown> extends CommandBase<I, Fiber<A, E>, A, E> {
 }
-export interface CommandFromRequest<I extends abstract new (...args: any) => any, A = unknown, E = unknown> extends EffectCommand<ConstructorParameters<I>[0], A, E> {
+export interface CommandFromRequest<I extends {
+    readonly make: (...args: any[]) => any;
+}, A = unknown, E = unknown> extends EffectCommand<HandlerInput<I>, A, E> {
 }
-export {};
 //# sourceMappingURL=makeClient.d.ts.map