@effect-app/vue 4.0.0-beta.181 → 4.0.0-beta.183

package/src/makeClient.ts

@@ -7,16 +7,19 @@ import type { ExtractModuleName, RequestHandler, RequestHandlers, RequestHandler
 import type { InvalidationCallback } from "effect-app/client/makeClient"
 import type * as ExitResult from "effect/Exit"
 import { type Fiber } from "effect/Fiber"
+import * as Stream from "effect/Stream"
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, onBeforeUnmount, ref, type WatchSource } from "vue"
 import { type Commander, CommanderStatic, type Progress } from "./commander.js"
 import { type I18n } from "./intl.js"
 import { type CommanderResolved, makeUseCommand } from "./makeUseCommand.js"
-import { makeMutation, makeStreamMutation, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
-import { type CustomUndefinedInitialQueryOptions, makeQuery } from "./query.js"
+import { makeMutation, makeStreamMutation, makeStreamMutation2, type MutationOptionsBase, useMakeMutation } from "./mutate.js"
+import { type CustomUndefinedInitialQueryOptions, makeQuery, makeStreamQuery } from "./query.js"
 import { makeRunPromise } from "./runtime.js"
 import { type Toast } from "./toast.js"
 
+export type { Progress }
+
 const mapHandler = <A, E, R, I = void, A2 = A, E2 = E, R2 = R>(
   handler: Effect.Effect<A, E, R> | ((i: I) => Effect.Effect<A, E, R>),
   map: (self: Effect.Effect<A, E, R>, i: I) => Effect.Effect<A2, E2, R2>
@@ -237,33 +240,36 @@ export type MutateStreamCallOptions<A, E> = {
 
 /**
  * The `mutateStream` factory for a stream-type request handler. Always invoke
- * (optionally with `{ progress }`) to get a fresh `[resultRef, execute]` tuple —
- * each call produces a new `ComputedRef` + execute pair so independent invocations
- * don't share state. `execute` updates the ref live with each emitted value.
- * When the request declares a `final` schema, `execute` resolves with the last
- * emitted value typed as `Final`; otherwise it resolves with the success type.
- * The factory itself carries the request `id` so it can be passed to
- * `Command.fn` / `Command.wrapStream` directly.
+ * (optionally with `{ progress }`) to get a fresh callable `execute` — each call
+ * produces a new state + execute pair so independent invocations don't share
+ * state. The callable updates its underlying ref live with each emitted value
+ * and carries `id`, plus `running` and `progress` when the factory was called
+ * with a `progress` formatter. When the request declares a `final` schema,
+ * the callable resolves with the last emitted value typed as `Final`; otherwise
+ * it resolves with the success type. The factory itself carries the request
+ * `id` so it can be passed to `Command.fn` / `Command.wrapStream` directly.
  */
 export type StreamMutationWithExtensions<Req> = Req extends
   RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id, infer Final> ?
     & ((options?: MutateStreamCallOptions<A, E>) =>
-      & readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (input: I) => Effect.Effect<Final, never, R>]
+      & ((input: I) => Effect.Effect<Final, E, R>)
       & {
         readonly id: Id
+        readonly _streamCallable: true
         readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
         readonly progress?: ComputedRef<Progress | undefined>
       })
-    & { readonly id: Id }
+    & { readonly id: Id; readonly _streamFactory: true }
   : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer Final> ?
       & ((options?: MutateStreamCallOptions<A, E>) =>
-        & readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<Final, never, R>]
+        & Effect.Effect<Final, E, R>
         & {
           readonly id: Id
+          readonly _streamCallable: true
           readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
           readonly progress?: ComputedRef<Progress | undefined>
         })
-      & { readonly id: Id }
+      & { readonly id: Id; readonly _streamFactory: true }
   : never
 
 /**
@@ -289,11 +295,42 @@ export type StreamFnExtension<RT, Req> = Req extends
     ? Commander.CommanderFn<RT, Id, Id, undefined>
   : 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>
+  ? Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+  : Req extends RequestStreamHandler<infer _A, infer _E, infer _R, infer _Request, infer Id, infer _Final>
+    ? Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+  : never
+
+/**
+ * `mutateStream2` factory — like `mutateStream` but returns `Effect<Stream>` per invocation
+ * for use with `streamFn` combinators. Handles invalidation via `Stream.ensuring`.
+ */
+export type StreamMutation2WithExtensions<RT, Req> = Req extends
+  RequestStreamHandlerWithInput<infer I, infer A, infer E, infer R, infer _Request, infer Id, infer _Final> ?
+    & ((input: I) => Effect.Effect<Stream.Stream<A, E, R>>)
+    & {
+      readonly id: Id
+      readonly wrapStream: Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+    }
+  : Req extends RequestStreamHandler<infer A, infer E, infer R, infer _Request, infer Id, infer _Final> ?
+      & Effect.Effect<Stream.Stream<A, E, R>>
+      & {
+        readonly id: Id
+        readonly wrapStream: Commander.StreamGen<RT, Id, Id, undefined> & Commander.NonGenStream<RT, Id, Id, undefined>
+      }
+  : never
+
 // we don't really care about the RT, as we are in charge of ensuring runtime safety anyway
 // eslint-disable-next-line unused-imports/no-unused-vars
 declare const useQuery_: QueryImpl<any>["useQuery"]
 // eslint-disable-next-line unused-imports/no-unused-vars
 declare const useSuspenseQuery_: QueryImpl<any>["useSuspenseQuery"]
+// eslint-disable-next-line unused-imports/no-unused-vars
+declare const useStreamQuery_: QueryImpl<any>["useStreamQuery"]
 
 export interface ProjectResult<RT, I, B, E, R, Request extends Req, Id extends string> {
   request: (i: I) => Effect.Effect<B, E, R>
@@ -384,6 +421,32 @@ export type Queries<RT, Req> = Req extends
     : never
   : never
 
+export interface StreamQueriesWithInput<Request extends Req, Id extends string, I, A, E> {
+  /**
+   * Stream helper for stream requests.
+   * Runs as a tracked Vue Query and returns reactive state with accumulated chunks.
+   * Data is an array of all chunks received so far.
+   */
+  streamQuery: ReturnType<typeof useStreamQuery_<I, E, A, Request, Id>>
+}
+export interface StreamQueriesWithoutInput<Request extends Req, Id extends string, A, E> {
+  /**
+   * Stream helper for stream requests.
+   * Runs as a tracked Vue Query and returns reactive state with accumulated chunks.
+   * Data is an array of all chunks received so far.
+   */
+  streamQuery: ReturnType<typeof useStreamQuery_<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 ? StreamQueriesWithInput<Request, Id, I, A, E>
+  : { streamQuery: MissingDependencies<RT, R> & {} }
+  : HandlerReq extends RequestStreamHandler<infer A, infer E, infer R, infer Request, infer Id, infer _Final>
+    ? Exclude<R, RT> extends never ? StreamQueriesWithoutInput<Request, Id, A, E>
+    : { streamQuery: MissingDependencies<RT, R> & {} }
+  : never
+
 const _useMutation = makeMutation()
 
 const wrapWithSpan = (self: { id: string; handler: any }, mut: any) => {
@@ -442,6 +505,7 @@ export type ClientFrom<M extends RequestsAny> = RequestHandlers<never, never, M,
 export class QueryImpl<R> {
   constructor(readonly getRuntime: () => Context.Context<R>) {
     this.useQuery = makeQuery(this.getRuntime)
+    this.useStreamQuery = makeStreamQuery(this.getRuntime)
   }
   /**
    * Effect results are passed to the caller, including errors.
@@ -449,6 +513,12 @@ export class QueryImpl<R> {
    */
   readonly useQuery: ReturnType<typeof makeQuery<R>>
 
+  /**
+   * Stream results are accumulated as an array of chunks and returned as reactive state.
+   * @deprecated use client helpers instead (.streamQuery())
+   */
+  readonly useStreamQuery: ReturnType<typeof makeStreamQuery<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.
@@ -646,9 +716,13 @@ export const makeClient = <RT_, RTHooks>(
   let sm: ReturnType<typeof makeStreamMutation>
   const useStreamMutation = () => sm ??= makeStreamMutation()
 
+  let sm2: ReturnType<typeof makeStreamMutation2>
+  const useStreamMutation2 = () => sm2 ??= makeStreamMutation2()
+
   const query = new QueryImpl(getBaseRt)
   const useQuery = query.useQuery
   const useSuspenseQuery = query.useSuspenseQuery
+  const useStreamQuery = query.useStreamQuery
 
   const mergeInvalidation = (
     a?: MutationOptionsBase["queryInvalidation"],
@@ -692,15 +766,19 @@ export const makeClient = <RT_, RTHooks>(
   ) => {
     const queries = Struct.keys(client).reduce(
       (acc, key) => {
-        if (client[key].Request.type !== "query") {
-          return acc
+        const requestType = client[key].Request.type
+        if (requestType === "query") {
+          ;(acc as any)[camelCase(key) + "Query"] = Object.assign(useQuery(client[key] as any), {
+            id: client[key].id
+          })
+          ;(acc as any)[camelCase(key) + "SuspenseQuery"] = Object.assign(useSuspenseQuery(client[key] as any), {
+            id: client[key].id
+          })
+        } else if (requestType === "stream") {
+          ;(acc as any)[camelCase(key) + "StreamQuery"] = Object.assign(useStreamQuery(client[key] as any), {
+            id: client[key].id
+          })
         }
-        ;(acc as any)[camelCase(key) + "Query"] = Object.assign(useQuery(client[key] as any), {
-          id: client[key].id
-        })
-        ;(acc as any)[camelCase(key) + "SuspenseQuery"] = Object.assign(useSuspenseQuery(client[key] as any), {
-          id: client[key].id
-        })
         return acc
       },
       {} as
@@ -722,6 +800,12 @@ export const makeClient = <RT_, RTHooks>(
             QueryHandler<typeof client[Key]>
           >["suspense"]
         }
+        & {
+          [
+            Key in keyof typeof client as StreamHandler<typeof client[Key]> extends never ? never
+              : `${ToCamel<string & Key>}StreamQuery`
+          ]: StreamQueries<RT, StreamHandler<typeof client[Key]>>["streamQuery"]
+        }
     )
     return queries
   }
@@ -841,20 +925,21 @@ export const makeClient = <RT_, RTHooks>(
         const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
         const smFactory = Object.assign(
           (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-            const tuple = streamMutation(client[key] as any, mergedInvalidation)
+            const [resultRef, execute] = streamMutation(client[key] as any, mergedInvalidation)
             const extras: {
               id: string
+              _streamCallable: true
               running?: ComputedRef<AsyncResult.AsyncResult<any, any>>
               progress?: ComputedRef<Progress | undefined>
-            } = { id: client[key].id }
+            } = { id: client[key].id, _streamCallable: true }
             if (opts?.progress) {
               const fmt = opts.progress
-              extras.running = tuple[0]
-              extras.progress = computed(() => fmt(tuple[0].value))
+              extras.running = resultRef
+              extras.progress = computed(() => fmt(resultRef.value))
             }
-            return Object.assign(tuple, extras)
+            return Object.assign(execute, extras)
           },
-          { id: client[key].id }
+          { id: client[key].id, _streamFactory: true as const }
         )
         ;(acc as any)[camelCase(key) + "Stream"] = Object.assign(smFactory, {
           fn: Command.fn(client[key].id)
@@ -938,27 +1023,44 @@ export const makeClient = <RT_, RTHooks>(
               const mergedInvalidation = mergeInvalidation(fromRequest, invalidation?.[key])
               const streamMutFactory = Object.assign(
                 (opts?: { progress?: (result: AsyncResult.AsyncResult<any, any>) => Progress | undefined }) => {
-                  const tuple = streamMutation(client[key] as any, mergedInvalidation)
+                  const [resultRef, execute] = streamMutation(client[key] as any, mergedInvalidation)
                   const extras: {
                     id: string
+                    _streamCallable: true
                     running?: ComputedRef<AsyncResult.AsyncResult<any, any>>
                     progress?: ComputedRef<Progress | undefined>
-                  } = { id: client[key].id }
+                  } = { id: client[key].id, _streamCallable: true }
                   if (opts?.progress) {
                     const fmt = opts.progress
-                    extras.running = tuple[0]
-                    extras.progress = computed(() => fmt(tuple[0].value))
+                    extras.running = resultRef
+                    extras.progress = computed(() => fmt(resultRef.value))
                   }
-                  return Object.assign(tuple, extras)
+                  return Object.assign(execute, extras)
                 },
-                { id: client[key].id }
+                { id: client[key].id, _streamFactory: true as const }
               )
               return {
                 ...client[key],
                 request: h_,
+                streamQuery: useStreamQuery(client[key] as any),
                 mutateStream: streamMutFactory,
                 wrapStream: Command.wrapStream(streamMutFactory),
-                fn: Command.fn(client[key].id)
+                fn: Command.fn(client[key].id),
+                streamFn: useCommand().streamFn(client[key].id as any) as any,
+                mutateStream2: (() => {
+                  const sm2Act = useStreamMutation2()(client[key] as any, mergedInvalidation)
+                  const originalHandler = (client[key] as any).handler
+                  const sm2Handler = Stream.isStream(originalHandler)
+                    ? (_input: any, _ctx: any) => sm2Act
+                    : (input: any, _ctx: any) => (sm2Act as (i: any) => any)(input)
+                  return Object.assign(sm2Act, {
+                    id: client[key].id,
+                    wrapStream: (...combinators: any[]) => {
+                      const sfn = useCommand().streamFn(client[key].id as any) as any
+                      return sfn(sm2Handler, ...combinators)
+                    }
+                  })
+                })()
               }
             })()
             : {
@@ -1015,6 +1117,8 @@ export const makeClient = <RT_, RTHooks>(
               & QueryRequestWithExtensions<QueryHandler<typeof client[Key]>>
               & Queries<RT, QueryHandler<typeof client[Key]>>
               & QueryProjection<RT, QueryHandler<typeof client[Key]>>)
+          & (StreamHandler<typeof client[Key]> extends never ? {}
+            : StreamQueries<RT, StreamHandler<typeof client[Key]>>)
           & (CommandHandler<typeof client[Key]> extends never ? {}
             : CommandRequestWithExtensions<RT | RTHooks, CommandHandler<typeof client[Key]>>)
           & (CommandHandler<typeof client[Key]> extends never ? {}
@@ -1024,6 +1128,8 @@ export const makeClient = <RT_, RTHooks>(
               mutateStream: StreamMutationWithExtensions<StreamHandler<typeof client[Key]>>
               wrapStream: StreamCommandWithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
               fn: StreamFnExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
+              streamFn: StreamFnStreamExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
+              mutateStream2: StreamMutation2WithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
             })
           & { Input: typeof client[Key] extends RequestHandlerWithInput<infer I, any, any, any, any, any> ? I : never }
       }
@@ -1086,6 +1192,7 @@ export const makeClient = <RT_, RTHooks>(
       fn: (...args: [any]) => useCommand().fn(...args),
       wrap: (...args: [any]) => useCommand().wrap(...args),
       wrapStream: (...args: [any]) => useCommand().wrapStream(...args),
+      streamFn: (...args: [any]) => useCommand().streamFn(...args),
       alt: (...args: [any]) => useCommand().alt(...args),
       alt2: (...args: [any]) => useCommand().alt2(...args)
     } as ReturnType<typeof useCommand>,
@@ -1125,6 +1232,8 @@ export interface CommandBase<I = void, A = void> {
   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<any, any>
 }
 
 export interface EffectCommand<I = void, A = unknown, E = unknown> extends CommandBase<I, Fiber<A, E>> {}

package/src/makeUseCommand.ts

@@ -5,7 +5,9 @@ type X<X> = X
 
 // helps retain JSDoc
 export interface CommanderResolved<RT, RTHooks>
-  extends X<typeof CommanderStatic>, Pick<CommanderImpl<RT, RTHooks>, "fn" | "wrap" | "wrapStream" | "alt" | "alt2">
+  extends
+    X<typeof CommanderStatic>,
+    Pick<CommanderImpl<RT, RTHooks>, "fn" | "wrap" | "wrapStream" | "streamFn" | "alt" | "alt2">
 {
 }
 

package/src/mutate.ts

@@ -414,16 +414,56 @@ export const useMakeMutation = () => {
 }
 
 /**
- * Like `makeMutation`, but for stream-type request handlers.
- * Returns a `[ref, execute]` tuple where `ref` is a reactive `AsyncResult` updated per
- * stream element. Queries are invalidated once when the stream finishes, regardless of
- * success or failure.
+ * Like `makeStreamMutation`, but returns an `Effect<Stream>` per invocation instead of a
+ * `[ref, execute]` tuple. The outer Effect sets up per-invocation invalidation scaffolding
+ * and returns a stream that triggers query invalidation via `Stream.ensuring` when it completes.
  *
- * When the request declares a `final` schema, `execute` resolves with the last emitted value
- * typed as `Final`; otherwise it resolves with the last emitted value typed as the success type.
+ * Use this with `streamFn` / `Command.streamFn(id)(mutateStream2Handler, ...combinators)` so that
+ * the command manages its own reactive state internally. Unlike `makeStreamMutation`, no external
+ * reactive result ref is created.
  *
  * Must be called inside a Vue setup context (uses `useQueryClient` internally).
  */
+export const makeStreamMutation2 = () => {
+  const queryClient = useQueryClient()
+
+  return (
+    self: {
+      id: string
+      options?: ClientForOptions
+      handler: Stream.Stream<any, any, any> | ((i: any) => Stream.Stream<any, any, any>)
+    },
+    mergedInvalidation?: MutationOptionsBase["queryInvalidation"]
+  ) => {
+    const invCache = buildInvalidateCache(queryClient, self, mergedInvalidation)
+
+    const makeInvocationEffect = (input: unknown, source: Stream.Stream<any, any, any>) =>
+      Effect.gen(function*() {
+        const keysRef = yield* Ref.make<ReadonlyArray<InvalidationKey>>([])
+        const invKeys = makeInvalidationKeysService(keysRef, (key) => invCache(input, Exit.succeed(undefined), [key]))
+        const lastRef = yield* Ref.make<any>(undefined)
+        return source.pipe(
+          Stream.provideService(InvalidationKeysFromServer, invKeys),
+          Stream.tap((v) => Ref.set(lastRef, v)),
+          Stream.ensuring(
+            Effect.gen(function*() {
+              const lastValue = yield* Ref.get(lastRef)
+              const serverKeys = yield* Ref.get(keysRef)
+              yield* invCache(input, Exit.succeed(lastValue), serverKeys)
+            })
+          )
+        )
+      })
+
+    const handler = self.handler
+    const act = Stream.isStream(handler)
+      ? makeInvocationEffect(undefined, handler)
+      : (i: any) => makeInvocationEffect(i, (handler as (i: any) => Stream.Stream<any, any, any>)(i))
+
+    return act
+  }
+}
+
 export const makeStreamMutation = () => {
   const queryClient = useQueryClient()
 
@@ -437,7 +477,7 @@ export const makeStreamMutation = () => {
   ) => {
     const state = shallowRef<AsyncResult.AsyncResult<any, any>>(AsyncResult.initial())
 
-    const runStream = (stream: Stream.Stream<any, any, any>, input?: unknown): Effect.Effect<any, never, any> => {
+    const runStream = (stream: Stream.Stream<any, any, any>, input?: unknown): Effect.Effect<any, any, any> => {
       const invCache = buildInvalidateCache(queryClient, self, mergedInvalidation)
       const keysRef = Ref.makeUnsafe<ReadonlyArray<InvalidationKey>>([])
       // V3: pass onAdded so each mid-stream metadata chunk triggers query
@@ -476,11 +516,14 @@ export const makeStreamMutation = () => {
                 const lastValue = AsyncResult.isSuccess(current) ? current.value : undefined
                 const invExit = exit._tag === "Success" ? Exit.succeed(lastValue) : exit
                 const serverKeys = Ref.getUnsafe(keysRef)
-                // Note: when the stream fails, `lastValue` is undefined. The failure is
-                // communicated via the reactive `state` ref (AsyncResult.failure). The
-                // execute effect always resolves successfully; callers should inspect the
-                // ref to distinguish success from failure.
-                return invCache(input, invExit, serverKeys).pipe(Effect.as(lastValue))
+                // Stream failures bubble through the execute effect's typed error
+                // channel. The reactive `state` ref still mirrors the failure as
+                // `AsyncResult.failure` for live progress UI.
+                return invCache(input, invExit, serverKeys).pipe(
+                  Effect.flatMap(() =>
+                    exit._tag === "Success" ? Effect.succeed(lastValue) : Effect.failCause(exit.cause)
+                  )
+                )
               })
             )
           )

package/src/query.ts

@@ -2,11 +2,16 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
-import { Array, Cause, type Context, Effect, Option, S } from "effect-app"
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { type DefaultError, type Enabled, experimental_streamedQuery as streamedQuery, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
+import { Array, Cause, type Context, Effect, Exit, Option, S } from "effect-app"
 import { makeQueryKey, type Req } from "effect-app/client"
-import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
+import type { RequestHandler, RequestHandlerWithInput, RequestStreamHandler, RequestStreamHandlerWithInput } from "effect-app/client/clientFor"
 import { CauseException, ServiceUnavailableError } from "effect-app/client/errors"
+import * as Channel from "effect/Channel"
+import * as Pull from "effect/Pull"
+import * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import { type Span } from "effect/Tracer"
 import { isHttpClientError } from "effect/unstable/http/HttpClientError"
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
@@ -75,6 +80,64 @@ export interface CustomDefinedPlaceholderQueryOptions<
     | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>
 }
 
+function swrToQuery<E, A>(r: {
+  error: CauseException<E> | undefined
+  data: A | undefined
+  isValidating: boolean
+}): AsyncResult.AsyncResult<A, E> {
+  if (r.error !== undefined) {
+    return AsyncResult.failureWithPrevious(
+      r.error.originalCause,
+      {
+        previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
+        waiting: r.isValidating
+      }
+    )
+  }
+  if (r.data !== undefined) {
+    return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
+  }
+
+  return AsyncResult.initial(r.isValidating)
+}
+
+function streamToAsyncIterableWithCauseException<A, E, R>(
+  self: Stream.Stream<A, E, R>,
+  context: Context.Context<R>,
+  id: string
+): AsyncIterable<A> {
+  return {
+    [Symbol.asyncIterator]() {
+      const runPromise = Effect.runPromiseWith(context)
+      const runPromiseExit = Effect.runPromiseExitWith(context)
+      const scope = Scope.makeUnsafe()
+      let pull: any
+      let currentIter: Iterator<A> | undefined
+      return {
+        async next(): Promise<IteratorResult<A>> {
+          if (currentIter) {
+            const next = currentIter.next()
+            if (!next.done) return next
+            currentIter = undefined
+          }
+          pull ??= await runPromise(Channel.toPullScoped((self as any).channel, scope))
+          const exit = await runPromiseExit(pull)
+          if (Exit.isSuccess(exit)) {
+            currentIter = (exit.value as any)[Symbol.iterator]()
+            return currentIter!.next()
+          } else if (Pull.isDoneCause((exit as any).cause)) {
+            return { done: true, value: undefined }
+          }
+          throw new CauseException((exit as any).cause, id)
+        },
+        return(_) {
+          return runPromise(Effect.as(Scope.close(scope, Exit.void), { done: true, value: undefined }) as any)
+        }
+      }
+    }
+  }
+}
+
 export const makeQuery = <R>(getRuntime: () => Context.Context<R>) => {
   const useQuery_: {
     <I, A, E, Request extends Req, Name extends string>(
@@ -228,27 +291,6 @@ export const makeQuery = <R>(getRuntime: () => Context.Context<R>) => {
     ] as any
   }
 
-  function swrToQuery<E, A>(r: {
-    error: CauseException<E> | undefined
-    data: A | undefined
-    isValidating: boolean
-  }): AsyncResult.AsyncResult<A, E> {
-    if (r.error !== undefined) {
-      return AsyncResult.failureWithPrevious(
-        r.error.originalCause,
-        {
-          previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
-          waiting: r.isValidating
-        }
-      )
-    }
-    if (r.data !== undefined) {
-      return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
-    }
-
-    return AsyncResult.initial(r.isValidating)
-  }
-
   const useQuery: {
     /**
      * Effect results are passed to the caller, including errors.
@@ -351,6 +393,88 @@ export const makeQuery = <R>(getRuntime: () => Context.Context<R>) => {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {}
 
+type StreamQueryResult<A, E> = readonly [
+  ComputedRef<AsyncResult.AsyncResult<A[], E>>,
+  ComputedRef<A[] | undefined>,
+  (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<A[], CauseException<E>>, never, never>,
+  UseQueryReturnType<any, any>
+]
+
+export const makeStreamQuery = <R>(getRuntime: () => Context.Context<R>) => {
+  const streamQuery_: {
+    <E, A, Request extends Req, Name extends string>(
+      q: RequestStreamHandler<A, E, R, Request, Name>
+    ): () => StreamQueryResult<A, E>
+    <Arg, E, A, Request extends Req, Name extends string>(
+      q: RequestStreamHandlerWithInput<Arg, A, E, R, Request, Name>
+    ): (arg: Arg | WatchSource<Arg>) => StreamQueryResult<A, E>
+  } = (q: any) => (arg?: any) => {
+    const context = getRuntime()
+    const arr = arg
+    const req: { value: any } = !arg
+      ? undefined as any
+      : typeof arr === "function"
+      ? ({
+        get value() {
+          return arr()
+        }
+      })
+      : ref(arg)
+    const queryKey = makeQueryKey(q)
+    const handler = q.handler
+    const isWithInput = typeof handler === "function"
+
+    const r = useTanstackQuery<any[], CauseException<any>, any[]>(
+      {
+        throwOnError: false,
+        retry: (retryCount: number, error: unknown) => {
+          if (error instanceof CauseException) {
+            if (!isHttpClientError(error.cause) && !S.is(ServiceUnavailableError)(error.cause)) {
+              return false
+            }
+          }
+          return retryCount < 5
+        },
+        queryKey: isWithInput ? [...queryKey, req] : queryKey,
+        queryFn: streamedQuery({
+          streamFn: () => {
+            const stream = isWithInput
+              ? handler(req.value)
+              : handler
+            return streamToAsyncIterableWithCauseException(stream, context, q.id)
+          }
+        })
+      }
+    )
+
+    const latestSuccess = shallowRef<any[]>()
+    const result = computed((): AsyncResult.AsyncResult<any[], any> =>
+      swrToQuery({
+        error: r.error.value ?? undefined,
+        data: r.data.value === undefined ? latestSuccess.value : r.data.value,
+        isValidating: r.isFetching.value
+      })
+    )
+    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true })
+
+    return [
+      result,
+      computed(() => latestSuccess.value),
+      (options?: RefetchOptions) =>
+        Effect.currentSpan.pipe(
+          Effect.orElseSucceed(() => null),
+          Effect.flatMap((span) => Effect.promise(() => r.refetch({ ...options, updateMeta: { span } })))
+        ),
+      r
+    ] as any
+  }
+
+  return streamQuery_
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeStreamQuery2<R> extends ReturnType<typeof makeStreamQuery<R>> {}
+
 function orPrevious<E, A>(result: AsyncResult.AsyncResult<A, E>) {
   return AsyncResult.isFailure(result) && Option.isSome(result.previousSuccess)
     ? AsyncResult.success(result.previousSuccess.value, { waiting: result.waiting })