@effect-app/infra 4.0.0-beta.25 → 4.0.0-beta.251

package/test/rpc-e2e-invalidation.test.ts

@@ -0,0 +1,256 @@
+/**
+ * E2E tests for the invalidation key flow exercised end-to-end via the
+ * production wrap/unwrap path:
+ *
+ *   server: routing.ts wraps command success with `CommandResponseWithMetaData`
+ *           and handler-thrown failure with `CommandFailureWithMetaData`;
+ *           routing wraps stream values into `{_tag:"value"|"metadata"|"done"}`
+ *           chunks. `InvalidationSet.use(...)` inside a handler accumulates keys.
+ *   client: apiClientFactory unwraps both envelopes and forwards keys to
+ *           `InvalidationKeysFromServer`.
+ *
+ * Transport is real HTTP (NodeHttpServer on a loopback port) so the wire
+ * encoding is exercised too.
+ */
+import { NodeHttpServer } from "@effect/platform-node"
+import { expect, it } from "@effect/vitest"
+import { ApiClientFactory, InvalidationKeysFromServer, makeInvalidationKeysService, makeRpcClient } from "effect-app/client"
+import { HttpRouter, HttpServer } from "effect-app/http"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { Invalidation, MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+import { FetchHttpClient } from "effect/unstable/http"
+import { RpcSerialization } from "effect/unstable/rpc"
+import { createServer } from "http"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
+
+// ---------------------------------------------------------------------------
+// Middleware (mirrors AppMiddleware shape — same composite as other e2e tests).
+// ---------------------------------------------------------------------------
+
+class AppMiddleware extends MiddlewareMaker
+  .Tag<AppMiddleware>()("AppMiddleware", RequestContextMap)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(SomeElseMiddleware)
+  .middleware(...DefaultGenericMiddlewares)
+{
+  static Default = this.layer.pipe(
+    Layer.provide(
+      [
+        RequireRolesLive.pipe(Layer.provide(SomeService.Default)),
+        AllowAnonymousLive,
+        TestLive,
+        SomeElseMiddlewareLive,
+        DefaultGenericMiddlewaresLive
+      ] as const
+    )
+  )
+}
+
+const { Router, matchAll } = makeRouter(AppMiddleware.Default)
+
+// ---------------------------------------------------------------------------
+// Resources
+// ---------------------------------------------------------------------------
+
+const DynamicKey: Invalidation.InvalidationKey = ["dynamic", "key"]
+const ExtraKey: Invalidation.InvalidationKey = ["extra", "key"]
+const StreamKey: Invalidation.InvalidationKey = ["stream", "key"]
+
+const { TaggedRequestFor } = makeRpcClient(AppMiddleware)
+const Req = TaggedRequestFor("Inv")
+
+class CmdBoom extends TaggedErrorClass<CmdBoom>()("CmdBoom", { reason: S.String }) {}
+
+class DoNothing extends Req.Command<DoNothing>()("DoNothing", {}, {
+  allowAnonymous: true,
+  success: S.Void
+}) {}
+
+class DoWithDynamicKey extends Req.Command<DoWithDynamicKey>()("DoWithDynamicKey", {}, {
+  allowAnonymous: true,
+  success: S.String
+}) {}
+
+class DoWithBothKeys extends Req.Command<DoWithBothKeys>()("DoWithBothKeys", {}, {
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class DoAndFail extends Req.Command<DoAndFail>()("DoAndFail", {}, {
+  allowAnonymous: true,
+  success: S.Void,
+  error: CmdBoom
+}) {}
+
+class StreamWithKey extends Req.Command<StreamWithKey>()("StreamWithKey", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+const InvRsc = { DoNothing, DoWithDynamicKey, DoWithBothKeys, DoAndFail, StreamWithKey }
+
+// ---------------------------------------------------------------------------
+// Controllers / router
+// ---------------------------------------------------------------------------
+
+const router = Router(InvRsc)({
+  *effect(match) {
+    return match({
+      DoNothing: () => Effect.void,
+      DoWithDynamicKey: Effect.fnUntraced(function*() {
+        yield* Invalidation.InvalidationSet.use((_) => _.add(DynamicKey))
+        return "done"
+      }),
+      DoWithBothKeys: Effect.fnUntraced(function*() {
+        yield* Invalidation.InvalidationSet.use((_) => _.add(DynamicKey))
+        yield* Invalidation.InvalidationSet.use((_) => _.add(ExtraKey))
+        return 99
+      }),
+      DoAndFail: Effect.fnUntraced(function*() {
+        yield* Invalidation.InvalidationSet.use((_) => _.add(DynamicKey))
+        return yield* Effect.fail(new CmdBoom({ reason: "intentional failure" }))
+      }),
+      StreamWithKey: () =>
+        Stream.fromIterable([1, 2, 3]).pipe(
+          Stream.tap(() => Invalidation.InvalidationSet.use((_) => _.add(StreamKey)))
+        )
+    })
+  }
+})
+
+const RpcRouterLayer = matchAll({ router })
+
+// ---------------------------------------------------------------------------
+// HTTP wiring — fresh server on loopback per `it.live`.
+// ---------------------------------------------------------------------------
+
+const NodeServerLayer = NodeHttpServer.layer(() => createServer(), { port: 0 })
+
+const ServerLayer = HttpRouter
+  .serve(RpcRouterLayer)
+  .pipe(
+    Layer.provide(NodeServerLayer),
+    Layer.provide(RpcSerialization.layerNdjson)
+  )
+
+const ClientLayer = Layer
+  .unwrap(
+    Effect.gen(function*() {
+      const server = yield* HttpServer.HttpServer
+      const addr = server.address
+      if (addr._tag !== "TcpAddress") return yield* Effect.die(new Error("expected TcpAddress"))
+      const host = addr.hostname === "0.0.0.0" ? "127.0.0.1" : addr.hostname
+      const url = `http://${host}:${addr.port}`
+      return ApiClientFactory
+        .layer({ url, headers: Option.none() })
+        .pipe(Layer.provide(FetchHttpClient.layer))
+    })
+  )
+  .pipe(Layer.provide(NodeServerLayer))
+
+const TestLayer = Layer.mergeAll(ServerLayer, ClientLayer)
+
+// Helper: provide a fresh `InvalidationKeysFromServer` and capture forwarded keys.
+const withCapture = <A, E, R>(eff: Effect.Effect<A, E, R>) =>
+  Effect.gen(function*() {
+    const ref = yield* Ref.make<ReadonlyArray<Invalidation.InvalidationKey>>([])
+    const svc = makeInvalidationKeysService(ref)
+    const result = yield* eff.pipe(Effect.provideService(InvalidationKeysFromServer, svc), Effect.exit)
+    return { result, keys: yield* Ref.get(ref) }
+  })
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+it.live(
+  "command with no invalidation keys: caller sees raw payload, no keys forwarded",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const { result, keys } = yield* withCapture(client.DoNothing.handler())
+    expect(Exit.isSuccess(result)).toBe(true)
+    expect(keys).toStrictEqual([])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "command with dynamic InvalidationSet.use: payload + key forwarded",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const { result, keys } = yield* withCapture(client.DoWithDynamicKey.handler())
+    expect(Exit.isSuccess(result) && result.value).toBe("done")
+    expect(keys).toStrictEqual([DynamicKey])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "command accumulating multiple dynamic keys: all keys forwarded in order",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const { result, keys } = yield* withCapture(client.DoWithBothKeys.handler())
+    expect(Exit.isSuccess(result) && result.value).toBe(99)
+    expect(keys).toStrictEqual([DynamicKey, ExtraKey])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "per-request isolation: each command call starts with a fresh InvalidationSet",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const r1 = yield* withCapture(client.DoWithDynamicKey.handler())
+    const r2 = yield* withCapture(client.DoWithDynamicKey.handler())
+    // Each call must have exactly one key — no accumulation across calls
+    expect(r1.keys).toStrictEqual([DynamicKey])
+    expect(r2.keys).toStrictEqual([DynamicKey])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "command failure (V2): keys accumulated before fail still reach the client; original error re-thrown",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const { result, keys } = yield* withCapture(client.DoAndFail.handler())
+    expect(Exit.isFailure(result)).toBe(true)
+    if (Exit.isFailure(result)) {
+      const failures = (result.cause as any).reasons as ReadonlyArray<{ _tag: "Fail"; error: any }>
+      expect(failures[0]?.error?._tag).toBe("CmdBoom")
+      expect(failures[0]?.error?.reason).toBe("intentional failure")
+    }
+    expect(keys).toStrictEqual([DynamicKey])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "stream: per-chunk metadata drains keys mid-stream",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const ref = yield* Ref.make<ReadonlyArray<Invalidation.InvalidationKey>>([])
+    const svc = makeInvalidationKeysService(ref)
+    const values = yield* Stream.runCollect(client.StreamWithKey.handler()).pipe(
+      Effect.provideService(InvalidationKeysFromServer, svc)
+    )
+    const keys = yield* Ref.get(ref)
+    expect(values).toStrictEqual([1, 2, 3])
+    // Handler taps `InvalidationSet.use` once per emitted value; routing's V3 mid-stream
+    // metadata drain forwards each batch as it arrives.
+    expect(keys).toStrictEqual([StreamKey, StreamKey, StreamKey])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)

package/test/rpc-multi-middleware.test.ts

@@ -1,19 +1,24 @@
 import { NodeHttpServer } from "@effect/platform-node"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Console, Effect, Layer, Result } from "effect"
-import { S } from "effect-app"
 import { NotLoggedInError } from "effect-app/client"
+import * as Context from "effect-app/Context"
 import { HttpRouter } from "effect-app/http"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
-import { MiddlewareMaker } from "effect-app/rpc"
-import { middlewareGroup } from "effect-app/rpc/MiddlewareMaker"
+import * as RpcX from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import * as Result from "effect/Result"
 import { FetchHttpClient } from "effect/unstable/http"
-import { RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
 import { createServer } from "http"
-import { DefaultGenericMiddlewaresLive } from "../src/api/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
 
-const incomplete = MiddlewareMaker
+const incomplete = RpcX
+  .MiddlewareMaker
   .Tag<middleware>()("MiddlewareMaker", RequestContextMap)
   .middleware(RequireRoles)
   .middleware(AllowAnonymous, Test)
@@ -21,7 +26,8 @@ const incomplete = MiddlewareMaker
 // this extension is allowed otherwise the error is quite obscure
 export class incompleteMiddleware extends incomplete {}
 
-class middleware extends MiddlewareMaker
+class middleware extends RpcX
+  .MiddlewareMaker
   .Tag<middleware>()("MiddlewareMaker", RequestContextMap)
   .middleware(RequireRoles)
   .middleware(AllowAnonymous, Test)
@@ -29,7 +35,7 @@ class middleware extends MiddlewareMaker
   .middleware(...DefaultGenericMiddlewares)
 {}
 
-const UserRpcs = middlewareGroup(middleware)(
+const UserRpcs = RpcX.MiddlewareMaker.middlewareGroup(middleware)(
   RpcGroup.make(
     middleware.rpc("getUser", {
       success: S.Literal("awesome")
@@ -56,7 +62,7 @@ const impl = UserRpcs
 
 expectTypeOf<Layer.Services<typeof impl>>().toEqualTypeOf<never>()
 
-const UserRpcsBad = middlewareGroup(middleware)(
+const UserRpcsBad = RpcX.MiddlewareMaker.middlewareGroup(middleware)(
   RpcGroup.make(
     middleware.rpc("doSomethingElse", {
       success: S.Literal("also-awesome2"),
@@ -136,3 +142,72 @@ it.live(
     Effect.provide(RpcTestLayer)
   )
 )
+
+// Per-request service isolation test
+
+class PerRequestCounter extends Context.Service<PerRequestCounter>()(
+  "PerRequestCounter",
+  { make: Effect.sync(() => ({ a: 0 })) }
+) {
+  static Default = Layer.effect(this, this.make)
+}
+
+class GlobalCounter extends Context.Service<GlobalCounter, {
+  readonly ref: Ref.Ref<number>
+}>()("GlobalCounter") {}
+
+const CounterRpcs = RpcGroup.make(
+  Rpc.make("incrementA", {
+    success: S.Number
+  }),
+  Rpc.make("incrementB", {
+    success: S.Number
+  })
+)
+
+const counterImpl = CounterRpcs
+  .toLayer({
+    incrementA: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default)),
+    incrementB: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default))
+  })
+
+const GlobalCounterLive = Layer.effect(
+  GlobalCounter,
+  Ref.make(0).pipe(Effect.map((ref) => ({ ref })))
+)
+
+const CounterTestLayer = counterImpl.pipe(Layer.provideMerge(GlobalCounterLive))
+
+it.live(
+  "per-request service isolation with shared global counter",
+  Effect.fnUntraced(
+    function*() {
+      const client = yield* RpcTest.makeClient(CounterRpcs)
+      const global = yield* GlobalCounter
+
+      const r1 = yield* client.incrementA()
+      const r2 = yield* client.incrementB()
+
+      // per-request counter is fresh each time → both return 1
+      expect(r1).toBe(1)
+      expect(r2).toBe(1)
+
+      // global counter is shared across requests → accumulates to 2
+      const globalCount = yield* Ref.get(global.ref)
+      expect(globalCount).toBe(2)
+    },
+    Effect.provide(CounterTestLayer)
+  )
+)

package/test/rpc-stream-fullstack.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Full-stack stream test exercising the entire wrapper:
+ *   resources (TaggedRequestFor)
+ *   → controllers (Router(...)({ effect }))
+ *   → router (makeRouter / matchAll)
+ *   → api ClientFactory (ApiClientFactory.makeFor)
+ *
+ * Server runs over real HTTP (NodeHttpServer on a loopback port). Client uses
+ * FetchHttpClient through ApiClientFactory. This covers the wrapper-level
+ * `Stream` request constructor end-to-end.
+ */
+import { NodeHttpServer } from "@effect/platform-node"
+import { expect, it } from "@effect/vitest"
+import { ApiClientFactory, makeRpcClient } from "effect-app/client"
+import { HttpRouter, HttpServer } from "effect-app/http"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
+import { FetchHttpClient } from "effect/unstable/http"
+import { RpcSerialization } from "effect/unstable/rpc"
+import { createServer } from "http"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
+
+// ---------------------------------------------------------------------------
+// Middleware (mirrors the boilerplate AppMiddleware shape).
+// ---------------------------------------------------------------------------
+
+class AppMiddleware extends MiddlewareMaker
+  .Tag<AppMiddleware>()("AppMiddleware", RequestContextMap)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(SomeElseMiddleware)
+  .middleware(...DefaultGenericMiddlewares)
+{
+  static Default = this.layer.pipe(
+    Layer.provide(
+      [
+        RequireRolesLive.pipe(Layer.provide(SomeService.Default)),
+        AllowAnonymousLive,
+        TestLive,
+        SomeElseMiddlewareLive,
+        DefaultGenericMiddlewaresLive
+      ] as const
+    )
+  )
+}
+
+const { Router, matchAll } = makeRouter(AppMiddleware.Default)
+
+// ---------------------------------------------------------------------------
+// Resources — Stream with and without payload.
+// ---------------------------------------------------------------------------
+
+const { TaggedRequestFor } = makeRpcClient(AppMiddleware)
+const Req = TaggedRequestFor("Streamy")
+
+class StreamTicks extends Req.Command<StreamTicks>()("StreamTicks", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class StreamCountTo extends Req.Command<StreamCountTo>()("StreamCountTo", {
+  to: S.Number
+}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class StreamRealtime extends Req.Command<StreamRealtime>()("StreamRealtime", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class StreamBoom extends TaggedErrorClass<StreamBoom>()("StreamBoom", { reason: S.String }) {}
+
+class StreamFailStream extends Req.Command<StreamFailStream>()("StreamFailStream", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number,
+  error: StreamBoom
+}) {}
+
+class StreamNoSuccess extends Req.Command<StreamNoSuccess>()("StreamNoSuccess", {}, {
+  stream: true,
+  allowAnonymous: true
+}) {}
+
+// Defaults to allowAnonymous: false → AllowAnonymous middleware fails with NotLoggedInError
+// when the request lacks the `x-user` header.
+class StreamRequiresAuth extends Req.Command<StreamRequiresAuth>()("StreamRequiresAuth", {}, {
+  stream: true,
+  success: S.Number
+}) {}
+
+class CommandRequiresAuth extends Req.Command<CommandRequiresAuth>()("CommandRequiresAuth", {}, {
+  success: S.Number
+}) {}
+
+class QueryRequiresAuth extends Req.Query<QueryRequiresAuth>()("QueryRequiresAuth", {}, {
+  success: S.Number
+}) {}
+
+const StreamyRsc = {
+  StreamTicks,
+  StreamCountTo,
+  StreamRealtime,
+  StreamFailStream,
+  StreamNoSuccess,
+  StreamRequiresAuth,
+  CommandRequiresAuth,
+  QueryRequiresAuth
+}
+
+// ---------------------------------------------------------------------------
+// Controllers / router — Stream impls returned from the match callback.
+// ---------------------------------------------------------------------------
+
+const router = Router(StreamyRsc)({
+  *effect(match) {
+    return match({
+      StreamTicks: () => Stream.fromIterable([10, 20, 30]),
+      StreamCountTo: ({ to }: { readonly to: number }) =>
+        Effect
+          .gen(function*() {
+            return Stream.range(1, to)
+          })
+          .pipe(Stream.unwrap),
+      // emits 3 values 100ms apart so the test can prove element-by-element
+      // delivery rather than a single batched response
+      StreamRealtime: () =>
+        Stream.fromIterable([1, 2, 3]).pipe(
+          Stream.mapEffect((n) => Effect.sleep("100 millis").pipe(Effect.as(n)))
+        ),
+      StreamFailStream: () => Stream.fail(new StreamBoom({ reason: "from-stream" })),
+      StreamNoSuccess: () => Stream.empty,
+      // handlers below are unreachable when middleware-auth fails; bodies exist
+      // only so the resource type-checks
+      StreamRequiresAuth: () => Stream.fromIterable([1, 2, 3]),
+      CommandRequiresAuth: () => Effect.succeed(1),
+      QueryRequiresAuth: () => Effect.succeed(1)
+    })
+  }
+})
+
+const RpcRouterLayer = matchAll({ router })
+
+// ---------------------------------------------------------------------------
+// HTTP wiring — real server on a loopback port + FetchHttpClient on the client.
+// ---------------------------------------------------------------------------
+
+// Server binds an ephemeral port (port: 0). The actual URL is read from the
+// `HttpServer` service after binding, then fed into `ApiClientFactory.layer` so
+// each `it.live` scope gets a fresh server without colliding on a fixed port.
+const NodeServerLayer = NodeHttpServer.layer(() => createServer(), { port: 0 })
+
+const ServerLayer = HttpRouter
+  .serve(RpcRouterLayer)
+  .pipe(
+    Layer.provide(NodeServerLayer),
+    Layer.provide(RpcSerialization.layerNdjson)
+  )
+
+const ClientLayer = Layer
+  .unwrap(
+    Effect.gen(function*() {
+      const server = yield* HttpServer.HttpServer
+      const addr = server.address
+      if (addr._tag !== "TcpAddress") return yield* Effect.die(new Error("expected TcpAddress"))
+      const host = addr.hostname === "0.0.0.0" ? "127.0.0.1" : addr.hostname
+      const url = `http://${host}:${addr.port}`
+      return ApiClientFactory
+        .layer({ url, headers: Option.none() })
+        .pipe(Layer.provide(FetchHttpClient.layer))
+    })
+  )
+  .pipe(Layer.provide(NodeServerLayer))
+
+const TestLayer = Layer.mergeAll(ServerLayer, ClientLayer)
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+it.live(
+  "stream resource without input: ApiClientFactory client emits all values",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const values = yield* Stream.runCollect(client.StreamTicks.handler())
+    expect(values).toStrictEqual([10, 20, 30])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "stream resource with input: payload drives the emitted values",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const values = yield* Stream.runCollect(client.StreamCountTo.handler({ to: 4 }))
+    expect(values).toStrictEqual([1, 2, 3, 4])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "stream resource is delivered element-by-element in real time (not batched)",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const start = Date.now()
+    const arrivals = yield* Stream.runCollect(
+      client.StreamRealtime.handler().pipe(
+        Stream.map((n) => ({ n, at: Date.now() - start }))
+      )
+    )
+    expect(arrivals.map((_) => _.n)).toStrictEqual([1, 2, 3])
+    // server emits each value 100ms after the previous one. If the response
+    // were batched, deltas would be ~0ms. Allow generous slack for CI jitter
+    // but require clear separation between consecutive arrivals.
+    const delta1 = arrivals[1]!.at - arrivals[0]!.at
+    const delta2 = arrivals[2]!.at - arrivals[1]!.at
+    expect(delta1).toBeGreaterThan(50)
+    expect(delta2).toBeGreaterThan(50)
+    // first element should not be withheld until the whole stream completes
+    expect(arrivals[0]!.at).toBeLessThan(arrivals[2]!.at - 50)
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "stream handler returning Stream.fail surfaces as failing stream on client",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const exit = yield* Stream.runCollect(client.StreamFailStream.handler()).pipe(Effect.exit)
+    expect(Exit.isFailure(exit)).toBe(true)
+    if (Exit.isFailure(exit)) {
+      const failures = (exit.cause as any).reasons as ReadonlyArray<{ _tag: "Fail"; error: StreamBoom }>
+      expect(failures.length).toBeGreaterThan(0)
+      expect(failures[0]!.error._tag).toBe("StreamBoom")
+      expect(failures[0]!.error.reason).toBe("from-stream")
+    }
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "stream resource without `success` exposes handler as a Stream on the client",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const exit = yield* Stream.runCollect(client.StreamNoSuccess.handler()).pipe(Effect.exit)
+    expect(Exit.isSuccess(exit)).toBe(true)
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+const expectNotLoggedIn = (exit: Exit.Exit<unknown, unknown>) => {
+  expect(Exit.isFailure(exit)).toBe(true)
+  if (!Exit.isFailure(exit)) return
+  const failures = (exit.cause as any).reasons as ReadonlyArray<{ _tag: "Fail"; error: any }>
+  expect(failures.length).toBeGreaterThan(0)
+  // The bug surfaces here as a SchemaError ("Expected never | { _tag: 'error', ... }")
+  // because the middleware-thrown NotLoggedInError doesn't match the
+  // wire StreamFailureChunk / CommandFailureWithMetaData wrapping.
+  expect(failures[0]!.error?._tag).toBe("NotLoggedInError")
+}
+
+it.live(
+  "stream resource: middleware-emitted NotLoggedInError surfaces cleanly on the client",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const exit = yield* Stream.runCollect(client.StreamRequiresAuth.handler()).pipe(Effect.exit)
+    expectNotLoggedIn(exit)
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "command resource: middleware-emitted NotLoggedInError surfaces cleanly on the client",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const exit = yield* client.CommandRequiresAuth.handler().pipe(Effect.exit)
+    expectNotLoggedIn(exit)
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "query resource: middleware-emitted NotLoggedInError surfaces cleanly on the client",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(StreamyRsc)
+    const exit = yield* client.QueryRequiresAuth.handler().pipe(Effect.exit)
+    expectNotLoggedIn(exit)
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)