effect-app 4.0.0-beta.2 → 4.0.0-beta.200

package/src/client/apiClientFactory.ts

@@ -1,19 +1,22 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Config from "effect/Config"
-import { flow } from "effect/Function"
+import { constant, flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
+import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
 import * as Struct from "effect/Struct"
-import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
+import { Rpc, RpcClient, RpcGroup, RpcMiddleware, RpcSerialization } from "effect/unstable/rpc"
+import * as Config from "../Config.js"
+import * as Context from "../Context.js"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientRequest } from "../http.js"
-import * as Option from "../Option.js"
+import { Invalidation } from "../rpc.js"
 import type * as S from "../Schema.js"
-import * as ServiceMap from "../ServiceMap.js"
 import { typedKeysOf, typedValuesOf } from "../utils.js"
-import type { Client, ClientForOptions, Requests, RequestsAny } from "./clientFor.js"
+import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.js"
+import { InvalidationKeysFromServer } from "./InvalidationKeys.js"
 
 export interface ApiConfig {
   url: string
@@ -31,16 +34,21 @@ export const DefaultApiConfig = Config.all({
 })
 
 export type Req = S.Top & {
-  new(...args: any[]): any
+  readonly make: (...args: any[]) => any
   _tag: string
   fields: S.Struct.Fields
   success: S.Top
   error: S.Top
+  /** Optional final-value schema for stream requests. When set, the execute effect resolves with the last stream value decoded to this type. */
+  final?: S.Top
   config?: Record<string, any>
-  readonly "~decodingServices"?: unknown
+  readonly id: string
+  readonly moduleName: string
+  readonly type: "command" | "query"
+  readonly stream: boolean
 }
 
-class RequestName extends ServiceMap.Reference("RequestName", {
+class RequestName extends Context.Reference("RequestName", {
   defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
 }) {}
 
@@ -50,17 +58,17 @@ export const HttpClientLayer = (config: ApiConfig) =>
     Effect
       .gen(function*() {
         const baseClient = yield* HttpClient.HttpClient
-        const ctx = yield* RequestName
         const client = baseClient.pipe(
           HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
           HttpClient.mapRequest(
             HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
-          HttpClient.mapRequest((req) =>
-            flow(
-              HttpClientRequest.appendUrlParam("action", ctx.requestName),
-              HttpClientRequest.appendUrl("/" + ctx.moduleName)
-            )(req)
+          HttpClient.mapRequestEffect((req) =>
+            Effect.map(RequestName.asEffect(), (ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req))
           )
         )
         return client
@@ -76,7 +84,7 @@ export const HttpClientFromConfigLayer = Layer.unwrap(
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
   Layer.mergeAll(
-    RpcSerialization.layerJson,
+    RpcSerialization.layerNdjson,
     HttpClientLayer(config)
   )
 
@@ -84,14 +92,14 @@ type RpcHandlers<M extends RequestsAny> = {
   [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["error"]>
 }
 
-const getFiltered = <M extends Requests>(resource: M) => {
+const getFiltered = <M extends RequestsAny>(resource: M) => {
   type Filtered = {
     [K in keyof M as M[K] extends Req ? K : never]: M[K] extends Req ? M[K] : never
   }
   // TODO: Record.filter
   const filtered = typedKeysOf(resource).reduce((acc, cur) => {
     if (
-      Predicate.isObject(resource[cur])
+      Predicate.isObjectKeyword(resource[cur])
       && (resource[cur].success)
     ) {
       acc[cur as keyof Filtered] = resource[cur] as any
@@ -102,13 +110,13 @@ const getFiltered = <M extends Requests>(resource: M) => {
   return filtered as unknown as Filtered
 }
 
-export const getMeta = <M extends Requests>(resource: M) => {
-  const meta = (resource as any).meta as { moduleName: string }
-  if (!meta) throw new Error("No meta defined in Resource!")
-  return meta as M["meta"]
+export const getMeta = <M extends RequestsAny>(resource: M): { moduleName: ExtractModuleName<M> } => {
+  const first = typedValuesOf(getFiltered(resource))[0]
+  if (first && "moduleName" in first) return { moduleName: first.moduleName }
+  throw new Error("No moduleName on requests!")
 }
 
-export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const ModuleName extends string>(
+export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, const ModuleName extends string>(
   resource: M,
   moduleName: ModuleName
 ) => {
@@ -117,7 +125,34 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const
   const rpcs = RpcGroup
     .make(
       ...typedValuesOf(filtered).map((_) => {
-        return Rpc.make((_ as any)._tag, { payload: _ as any, success: (_ as any).success, error: (_ as any).error })
+        const r = _ as any
+        const isStream = r.stream
+        const isCommand = r.type === "command"
+        const rpc = (isCommand
+          ? isStream
+            ? Invalidation.makeStreamRpc(r._tag, {
+              payload: r,
+              success: r.success,
+              error: r.error,
+              stream: true as const
+            })
+            : Invalidation.makeCommandRpc(r._tag, { payload: r, success: r.success, error: r.error })
+          : Rpc.make(r._tag, { payload: r, success: r.success, error: r.error, stream: isStream })) as any
+
+        // Stream rpcs force `errorSchema = Never` in effect-rpc and bury the
+        // resource error union inside `StreamFailureChunk`. Middleware-thrown
+        // errors (e.g. `NotLoggedInError` from auth) reach the Cause un-wrapped
+        // and would fail client decode. Attach a synthetic schema-only middleware
+        // tag carrying the resource error union so `Rpc.exitSchema` includes it
+        // in the failure union via the `rpc.middlewares[*].error` channel.
+        if (isStream && r.error) {
+          const ErrorBag = RpcMiddleware.Service<any>()(
+            `${moduleName}.${r._tag}.ClientErrorBag`,
+            { error: r.error }
+          )
+          return rpc.middleware(ErrorBag as any)
+        }
+        return rpc
       })
     )
     .prefix(`${moduleName}.`) as unknown as RpcGroup.RpcGroup<
@@ -126,155 +161,211 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const
   return rpcs
 }
 
-export const makeRpcGroup = <
-  M extends Requests,
-  const ModuleName extends string
->(
-  resource: M & { meta: { moduleName: ModuleName } }
-) => makeRpcGroupFromRequestsAndModuleName(resource, resource.meta.moduleName)
-
-const makeRpcTag = <M extends Requests>(resource: M) => {
+const makeRpcTag = <M extends RequestsAny>(resource: M) => {
   const meta = getMeta(resource)
   const rpcs = makeRpcGroupFromRequestsAndModuleName(resource, meta.moduleName)
 
   // Use Object.assign instead of class extension to avoid TS2509 with complex generic return types.
   // The first type arg is `any` because this is a dynamically created tag — its identity is the string key.
-  const TheClient = ServiceMap.Opaque<
+  const TheClient = Context.Opaque<
     any,
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
   >()(`RpcClient.${meta.moduleName}`)
   // Use Layer.effect directly (not TheClient.toLayer) so TypeScript properly excludes Scope
   const layer = Layer.effect(
     TheClient,
-    Effect.map(
-      RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName }),
-      (cl) => (cl as any)[meta.moduleName]
-    )
+    RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName })
   )
   return Object.assign(TheClient, { layer })
 }
 
 const makeApiClientFactory = Effect
   .gen(function*() {
-    const ctx = yield* Effect.services<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
-    const makeClientFor = <M extends Requests>(
+    const ctx = yield* Effect.context<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
+    const makeClientFor = Effect.fnUntraced(function*<M extends RequestsAny>(
       resource: M,
       requestLevelLayers = Layer.empty,
       options?: ClientForOptions
-    ) =>
-      Effect.gen(function*() {
-        const TheClient = makeRpcTag(resource)
-
-        const meta = getMeta(resource)
-
-        // TODO: somehow we need a protocol per REQUEST kind of it seems ...
-        // otherwise it locks up on the client, navigation remains empty...
-        const clientLayer = TheClient.layer.pipe(
-          // add ApiClientFactory for nested schemas
-          // eslint-disable-next-line @typescript-eslint/no-use-before-define
-          Layer.provide(Layer.succeed(ApiClientFactory, makeClientForCached as any)),
-          Layer.provide(
-            RpcClient
-              .layerProtocolHttp({
-                url: "" // why not here set meta.moduleName as root?
+    ) {
+      const TheClient = makeRpcTag(resource)
+
+      const meta = getMeta(resource)
+
+      // TODO: somehow we need a protocol per REQUEST kind of it seems ...
+      // otherwise it locks up on the client, navigation remains empty...
+      const clientLayer = TheClient.layer.pipe(
+        // add ApiClientFactory for nested schemas
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        Layer.provide(Layer.succeed(ApiClientFactory, makeClientForCached as any)),
+        Layer.provide(
+          RpcClient
+            .layerProtocolHttp({ url: "" }) // why not here set meta.moduleName as root?
+            .pipe(
+              Layer.provideMerge(Layer.succeedContext(ctx))
+            )
+        )
+      )
+      const mr = ManagedRuntime.make(clientLayer)
+
+      const filtered = getFiltered(resource)
+
+      const unwrapCommand = (eff: Effect.Effect<any, any, any>): Effect.Effect<any, any, any> =>
+        eff.pipe(
+          Effect.flatMap((result: any) =>
+            Effect.gen(function*() {
+              const keys: ReadonlyArray<Invalidation.InvalidationKey> = result?.metadata?.invalidateQueries ?? []
+              const invalidationKeys = yield* InvalidationKeysFromServer
+              yield* Effect.forEach(keys, (key) => invalidationKeys.add(key), { discard: true })
+              return result.payload
+            })
+          ),
+          // V2: unwrap CommandFailureWithMetaData failures — forward keys, re-fail with the
+          // original error so callers see the unmodified error type.
+          Effect.catch((result: any) =>
+            result?._tag === "CommandFailureWithMetaData"
+              ? Effect.gen(function*() {
+                const keys: ReadonlyArray<Invalidation.InvalidationKey> = result.metadata?.invalidateQueries ?? []
+                const invalidationKeys = yield* InvalidationKeysFromServer
+                yield* Effect.forEach(keys, (key) => invalidationKeys.add(key), { discard: true })
+                return yield* Effect.fail(result.error)
               })
-              .pipe(
-                Layer.provideMerge(Layer.succeedServices(ctx))
-              )
+              : Effect.fail(result)
           )
         )
-        const mr = ManagedRuntime.make(clientLayer)
-
-        const filtered = getFiltered(resource)
-        return {
-          mr,
-          client: (typedKeysOf(filtered)
-            .reduce((prev, cur) => {
-              const h = filtered[cur]!
 
-              const Request = h
+      return {
+        mr,
+        client: typedKeysOf(filtered)
+          .reduce((prev, cur) => {
+            const h = filtered[cur]!
+
+            const Request = h
+
+            const id = `${meta.moduleName}.${cur as string}`
+              .replaceAll(".js", "")
+
+            const requestMeta = {
+              Request,
+              id,
+              options
+            }
+
+            const requestNameLayer = Layer.succeed(RequestName, {
+              requestName: cur as string,
+              moduleName: meta.moduleName
+            })
+
+            const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
+
+            const fields = Struct.omit(Request.fields, ["_tag"] as const)
+            const requestAttr = `${meta.moduleName}.${h._tag}`
+            const isCommand = h.type === "command"
+            const isStream = h.stream
+
+            const buildEffect = (input: any) =>
+              mr.contextEffect.pipe(
+                Effect.flatMap((svcs) => {
+                  const rpcEffect = TheClient
+                    .use((client) => (client as any)[requestAttr]!(Request.make(input)) as Effect.Effect<any, any>)
+                    .pipe(
+                      Effect.provide(layers),
+                      Effect.provide(svcs)
+                    )
+                  return isCommand ? unwrapCommand(rpcEffect) : rpcEffect
+                })
+              )
 
-              const id = `${meta.moduleName}.${cur as string}`
-                .replaceAll(".js", "")
+            const buildStream = (input: any) =>
+              Stream.unwrap(
+                mr.contextEffect.pipe(
+                  Effect.flatMap((svcs) =>
+                    TheClient
+                      .useSync((client) => {
+                        const rpcStream = (client as any)[requestAttr]!(
+                          Request.make(input)
+                        ) as Stream.Stream<any, any, any>
+                        return rpcStream.pipe(
+                          // Collect server invalidation keys from the "done" chunk, then discard it.
+                          Stream.tap((item: any) =>
+                            item._tag === "done" || item._tag === "metadata"
+                              ? InvalidationKeysFromServer.use((svc) =>
+                                Effect.forEach(
+                                  (item.metadata as Invalidation.CommandMetaData).invalidateQueries,
+                                  svc.add,
+                                  { discard: true }
+                                )
+                              )
+                              : Effect.void
+                          ),
+                          Stream.filter((item: any) => item._tag === "value"),
+                          Stream.map((item: any) => item.value),
+                          // V2: unwrap StreamFailureChunk — forward keys from failures too,
+                          // then re-fail with the original error so callers see the unmodified
+                          // error type.
+                          Stream.catch((err: any) =>
+                            err?._tag === "error" && err?.metadata
+                              ? Stream.fromEffect(
+                                InvalidationKeysFromServer.use((svc) =>
+                                  Effect
+                                    .forEach(
+                                      (err.metadata as Invalidation.CommandMetaData).invalidateQueries,
+                                      svc.add,
+                                      { discard: true }
+                                    )
+                                    .pipe(Effect.flatMap(() => Effect.fail(err.error)))
+                                )
+                              )
+                              : Stream.fail(err)
+                          ),
+                          Stream.provide(layers),
+                          Stream.provide(svcs)
+                        )
+                      })
+                      .pipe(Effect.provide(svcs))
+                  )
+                )
+              )
 
-              const requestMeta = {
-                Request,
-                id,
-                options
+            // @ts-expect-error doc
+            prev[cur] = Object.keys(fields).length === 0
+              ? {
+                handler: isStream ? constant(buildStream({})) : constant(buildEffect({})),
+                ...requestMeta
+              }
+              : {
+                handler: isStream
+                  ? (req: any) => buildStream(req)
+                  : (req: any) => buildEffect(req),
+                ...requestMeta
               }
 
-              const requestNameLayer = Layer.succeed(RequestName, {
-                requestName: cur as string,
-                moduleName: meta.moduleName
-              })
-
-              const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
-
-              const fields = Struct.omit(Request.fields, ["_tag"] as const)
-              const requestAttr = h._tag
-              // @ts-expect-error doc
-              prev[cur] = Object.keys(fields).length === 0
-                ? {
-                  handler: mr.servicesEffect.pipe(
-                    Effect.flatMap((svcs) =>
-                      TheClient
-                        .use((client) => (client as any)[requestAttr]!(new Request()) as Effect.Effect<any, any, never>)
-                        .pipe(
-                          Effect.provide(layers),
-                          Effect.provide(svcs)
-                        )
-                    )
-                  ),
-                  ...requestMeta
-                }
-                : {
-                  handler: (req: any) =>
-                    mr.servicesEffect.pipe(
-                      Effect.flatMap((svcs) =>
-                        TheClient
-                          .use((client) =>
-                            (client as any)[requestAttr]!(new Request(req)) as Effect.Effect<any, any, never>
-                          )
-                          .pipe(
-                            Effect.provide(layers),
-                            Effect.provide(svcs)
-                          )
-                      )
-                    ),
-
-                  ...requestMeta
-                }
-
-              return prev
-            }, {} as Client<M, M["meta"]["moduleName"]>))
-        }
-      })
+            return prev
+          }, {} as Client<M, ExtractModuleName<M>>)
+      }
+    })
 
     const register: ManagedRuntime.ManagedRuntime<any, any>[] = []
     yield* Effect.addFinalizer(() => Effect.forEach(register, (mr) => mr.disposeEffect))
 
     const cacheL = new Map<any, Map<any, Client<any, any>>>()
 
-    function makeClientForCached(requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) {
+    function makeClientForCached(requestLevelLayers: Layer.Layer<never>, options?: ClientForOptions) {
       let cache = cacheL.get(requestLevelLayers)
       if (!cache) {
         cache = new Map<any, Client<any, any>>()
         cacheL.set(requestLevelLayers, cache)
       }
 
-      return <M extends Requests>(
-        models: M
-      ): Effect.Effect<Client<M, M["meta"]["moduleName"]>> =>
-        Effect.gen(function*() {
-          const found = cache.get(models)
-          if (found) {
-            return found
-          }
-          const m = yield* makeClientFor(models, requestLevelLayers, options)
-          cache.set(models, m.client)
-          register.push(m.mr)
-          return m.client
-        })
+      return Effect.fnUntraced(function*<M extends RequestsAny>(models: M) {
+        const found = cache.get(models) as Client<M, ExtractModuleName<M>> | undefined
+        if (found) {
+          return found
+        }
+        const m = yield* makeClientFor(models, requestLevelLayers, options)
+        cache.set(models, m.client)
+        register.push(m.mr)
+        return m.client
+      })
     }
 
     return makeClientForCached
@@ -284,7 +375,7 @@ const makeApiClientFactory = Effect
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends ServiceMap.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
+  extends Context.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
 {
   static readonly layer = (config: ApiConfig) =>
     ApiClientFactory.toLayer(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))
@@ -296,8 +387,8 @@ export class ApiClientFactory
   )
 
   static readonly makeFor =
-    (requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) =>
-    <M extends Requests>(
+    (requestLevelLayers: Layer.Layer<never>, options?: ClientForOptions) =>
+    <M extends RequestsAny>(
       resource: M
     ) =>
       ApiClientFactory.use((apiClientFactory) => {

package/src/client/clientFor.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import * as Record from "effect/Record"
-import type * as Request from "effect/Request"
+import type * as Stream from "effect/Stream"
 import type { Path } from "path-parser"
 import qs from "query-string"
 import type * as Effect from "../Effect.js"
@@ -48,9 +48,14 @@ export function makePathWithBody(
   return path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
 }
 
-export type Requests<ModuleName extends string = string> = { meta: { moduleName: ModuleName } } & RequestsAny
+export type Requests = RequestsAny
 export type RequestsAny = Record<string, any>
 
+export type ExtractModuleName<M extends RequestsAny> =
+  { [K in keyof M]: M[K] extends { moduleName: infer N extends string } ? N : never }[keyof M] extends
+    infer R extends string ? R
+    : string
+
 export type Client<M extends RequestsAny, ModuleName extends string> = RequestHandlers<
   never,
   never,
@@ -66,48 +71,100 @@ export type ExtractEResponse<T> = T extends S.Codec<any> ? S.Codec.Encoded<T>
   : T extends unknown ? void
   : never
 
-type IsEmpty<T> = keyof T extends never ? true
-  : false
-
-// v4: Request.RequestTypeId, S.symbolSerializable, S.symbolWithResult removed — use keyof Request to filter internal props
-type Cruft = "_tag" | keyof Request.Request<any, any, any>
-
 export interface ClientForOptions {
   readonly skipQueryKey?: readonly string[]
 }
 
-export interface RequestHandler<A, E, R, Request extends Req, Id extends string> {
-  handler: Effect.Effect<A, E, R>
+// $Project/$Configuration.Index
+// -> "$Project", "$Configuration", "Index"
+export const makeQueryKey = ({ id, options }: { id: string; options?: ClientForOptions }) =>
+  id
+    .split("/")
+    .filter((segment: string) => !options || !options.skipQueryKey?.includes(segment))
+    .map((segment: string) => "$" + segment)
+    .join(".")
+    .split(".")
+
+export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id extends string> {
+  handler: (i: I) => Effect.Effect<A, E, R>
   id: Id
   options?: ClientForOptions
   Request: Request
 }
 
-export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id extends string> {
-  handler: (i: I) => Effect.Effect<A, E, R>
+/** Type alias: a no-input handler is simply `RequestHandlerWithInput<void, …>`. */
+export type RequestHandler<A, E, R, Request extends Req, Id extends string> = RequestHandlerWithInput<
+  void,
+  A,
+  E,
+  R,
+  Request,
+  Id
+>
+
+export interface RequestStreamHandlerWithInput<I, A, E, R, Request extends Req, Id extends string, Final = A> {
+  handler: (i: I) => Stream.Stream<A, E, R>
   id: Id
   options?: ClientForOptions
   Request: Request
+  /**
+   * Phantom type property (never set at runtime) that carries the `Final` type to
+   * `StreamMutationWithExtensions`. The tilde prefix follows the Effect convention for
+   * phantom/virtual properties and prevents accidental runtime access.
+   * Stream failures bubble through the execute effect's typed error channel `E`;
+   * the reactive `AsyncResult` ref also mirrors the failure for live progress UI.
+   */
+  readonly "~final"?: Final
 }
 
+/** Type alias: a no-input stream handler is simply `RequestStreamHandlerWithInput<void, …>`. */
+export type RequestStreamHandler<A, E, R, Request extends Req, Id extends string, Final = A> =
+  RequestStreamHandlerWithInput<void, A, E, R, Request, Id, Final>
+
 // make sure this is exported or d.ts of apiClientFactory breaks?!
-type ReqDecodingServices<M> = M extends { readonly "~decodingServices": infer DS } ? DS : never
+export type RequestInputFromMake<I extends { readonly make: (...args: any[]) => any }> = Parameters<I["make"]> extends
+  [] ? void : Parameters<I["make"]>[0]
+
+// Has no input only when the request schema declares no payload fields (the auto-added
+// `_tag` field is ignored). Any payload fields (even all-optional) produce a function handler.
+type HasNoFields<I> = I extends { readonly fields: infer F extends S.Struct.Fields }
+  ? [Exclude<keyof F, "_tag">] extends [never] ? true : false
+  : false
+
+type RequestInput<I extends { readonly make: (...args: any[]) => any }> = Parameters<I["make"]>[0]
+
+/**
+ * Caller-facing input type for a request. `void` when the request schema has no fields;
+ * otherwise `make`'s first param type.
+ */
+export type HandlerInput<I extends { readonly make: (...args: any[]) => any }> = HasNoFields<I> extends true ? void
+  : RequestInput<I>
+
+/** Extracts the final-value type from a stream request. Defaults to the success type when no `final` schema is set. */
+type FinalTypeOf<T extends Req> = T extends { readonly final: infer F extends S.Top } ? S.Schema.Type<F>
+  : S.Schema.Type<T["success"]>
+
+type RequestHandlerFor<R, E, T extends Req, Id extends string> = T["stream"] extends true
+  ? RequestStreamHandlerWithInput<
+    HandlerInput<T>,
+    S.Schema.Type<T["success"]>,
+    S.Schema.Type<T["error"]> | E,
+    R | S.Codec.DecodingServices<T["success"]> | S.Codec.DecodingServices<T["error"]>,
+    T,
+    Id,
+    FinalTypeOf<T>
+  >
+  : RequestHandlerWithInput<
+    HandlerInput<T>,
+    S.Schema.Type<T["success"]>,
+    S.Schema.Type<T["error"]> | E,
+    R | S.Codec.DecodingServices<T["success"]> | S.Codec.DecodingServices<T["error"]>,
+    T,
+    Id
+  >
 
 export type RequestHandlers<R, E, M extends RequestsAny, ModuleName extends string> = {
-  [K in keyof M as M[K] extends Req ? K : never]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true
-    ? RequestHandler<
-      S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["error"]> | E,
-      R | ReqDecodingServices<M[K]>,
-      M[K],
-      `${ModuleName}.${K & string}`
-    >
-    : RequestHandlerWithInput<
-      Omit<S.Schema.Type<M[K]>, Cruft>,
-      S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["error"]> | E,
-      R | ReqDecodingServices<M[K]>,
-      M[K],
-      `${ModuleName}.${K & string}`
-    >
+  [K in keyof M as M[K] extends Req ? K : never]: Extract<M[K], Req> extends infer T extends Req
+    ? RequestHandlerFor<R, E, T, `${ModuleName}.${K & string}`>
+    : never
 }