@effect-app/infra 4.0.0-beta.31 → 4.0.0-beta.311

package/test/repository-ext.test.ts

@@ -0,0 +1,426 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as DataDependencies from "effect-app/DataDependencies"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { Q } from "effect-app/Model"
+import { makeRepo, repositoryDependency } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
+import * as Ref from "effect/Ref"
+import * as Tracer from "effect/Tracer"
+import { MemoryStoreLive } from "../src/Store/Memory.js"
+
+class BatchItem extends S.Class<BatchItem>("BatchItem")({
+  id: S.String,
+  label: S.String
+}) {}
+
+class DependencyItem extends S.Class<DependencyItem>("DependencyItem")({
+  id: S.String,
+  label: repositoryDependency(S.StringId)
+}) {}
+
+class NestedDependencyItem extends S.Class<NestedDependencyItem>("NestedDependencyItem")({
+  id: S.String,
+  parts: S.Array(S.Struct({ id: repositoryDependency(S.String) }))
+}) {}
+
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
+const A = S.TaggedStruct("A", { id: S.String })
+const B = S.TaggedStruct("B", { id: S.String })
+const C = S.TaggedStruct("C", { id: S.String })
+
+const union = S.Union([A, B, C])
+
+const a = S.Struct({ id: S.String })
+
+const nestedSourceItem = S.TaggedStruct("source-item", {
+  id: S.StringId,
+  label: S.String
+})
+const nestedProjectedItem = S.TaggedStruct("source-item", {
+  id: S.StringId
+})
+type NestedProjectedItem = typeof nestedProjectedItem.Type
+const nestedSource = S.Struct({
+  id: S.String,
+  items: S.NonEmptyArray(nestedSourceItem),
+  label: S.String
+})
+const nestedProjection = S.Struct({
+  id: S.String,
+  items: S.NonEmptyArray(nestedProjectedItem)
+})
+
+const nestedProjectedItemsOf = (
+  items: readonly [NestedProjectedItem, ...NestedProjectedItem[]]
+) => items
+
+const nestedUnionSourceA = S.TaggedStruct("nested-a", {
+  id: S.String,
+  items: S.NonEmptyArray(nestedSourceItem),
+  label: S.String
+})
+const nestedUnionSourceB = S.TaggedStruct("nested-b", {
+  id: S.String,
+  items: S.NonEmptyArray(nestedSourceItem),
+  count: S.Number
+})
+const nestedUnionSource = S.Union([nestedUnionSourceA, nestedUnionSourceB])
+const nestedUnionProjection = S.Union([
+  nestedUnionSourceA.mapFields((fields) => ({
+    id: fields.id,
+    _tag: fields._tag,
+    items: S.NonEmptyArray(nestedProjectedItem)
+  })),
+  nestedUnionSourceB.mapFields((fields) => ({
+    id: fields.id,
+    _tag: fields._tag,
+    items: S.NonEmptyArray(nestedProjectedItem)
+  }))
+])
+
+describe("repository ext save/remove batching", () => {
+  it.effect("supports projecting full repository schema", () =>
+    Effect
+      .gen(function*() {
+        const unionRepo = yield* makeRepo("UnionItem", union, {})
+        const aRepo = yield* makeRepo("AItem", a, {})
+        const ARepo = yield* makeRepo("TaggedAItem", A, {})
+
+        expect(yield* unionRepo.query(Q.project(union))).toEqual([])
+        expect(yield* aRepo.query(Q.project(a))).toEqual([])
+        expect(yield* ARepo.query(Q.project(A))).toEqual([])
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("supports nested DTO subset projections", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("NestedProjectionItem", nestedSource, {})
+        const unionRepo = yield* makeRepo("NestedUnionProjectionItem", nestedUnionSource, {})
+        const result = yield* repo.query(Q.project(nestedProjection, "project"))
+        const unionResult = yield* unionRepo.query(Q.project(nestedUnionProjection, "project"))
+
+        result.forEach((_) => nestedProjectedItemsOf(_.items))
+        unionResult.forEach((_) => nestedProjectedItemsOf(_.items))
+        expect(result).toEqual([])
+        expect(unionResult).toEqual([])
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("supports save batching overload", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("BatchItem", BatchItem, {})
+        const items = [
+          new BatchItem({ id: "1", label: "one" }),
+          new BatchItem({ id: "2", label: "two" }),
+          new BatchItem({ id: "3", label: "three" }),
+          new BatchItem({ id: "4", label: "four" })
+        ] as const
+
+        yield* repo.save(items, { batch: 2 })
+
+        const all = yield* repo.all
+        expect(all).toHaveLength(4)
+        expect(all.map((_) => _.id).toSorted()).toEqual(["1", "2", "3", "4"])
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("supports remove batching overload", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("BatchItem", BatchItem, {})
+        const items = [
+          new BatchItem({ id: "1", label: "one" }),
+          new BatchItem({ id: "2", label: "two" }),
+          new BatchItem({ id: "3", label: "three" }),
+          new BatchItem({ id: "4", label: "four" })
+        ] as const
+
+        yield* repo.save(items)
+        yield* repo.remove([items[0], items[1], items[2]], { batch: true })
+
+        const all = yield* repo.all
+        expect(all).toHaveLength(1)
+        expect(all[0]?.id).toBe("4")
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("records repository read and write dependencies", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", BatchItem, {})
+            yield* repo.save(new BatchItem({ id: "1", label: "one" }))
+            yield* repo.all
+            yield* repo.find("1")
+            yield* repo.removeById("1")
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual(new Set([DataDependencies.repo("DependencyItem")]))
+        expect(yield* Ref.get(writesRef)).toEqual(new Set([DataDependencies.repo("DependencyItem", ["1"])]))
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("narrows direct repository reads to the requested entity", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", BatchItem, {})
+            yield* repo.find("1")
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual(new Set([DataDependencies.repo("DependencyItem", ["1"])]))
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it("matches entity dependencies by overlapping ids with a coarse fallback", () => {
+    const item1 = new Set([DataDependencies.repo("DependencyItem", ["1"])])
+    const item2 = new Set([DataDependencies.repo("DependencyItem", ["2"])])
+    const collection = new Set([DataDependencies.repo("DependencyItem")])
+
+    expect(DataDependencies.intersects(item1, item2)).toBe(false)
+    expect(DataDependencies.intersects(item1, item1)).toBe(true)
+    expect(DataDependencies.intersects(collection, item2)).toBe(true)
+  })
+
+  it("decodes repository dependencies produced before entity ids were added", () => {
+    expect(
+      S.decodeUnknownSync(DataDependencies.DataDependency)({
+        type: "repo",
+        name: "DependencyItem"
+      })
+    )
+      .toEqual(DataDependencies.repo("DependencyItem"))
+  })
+
+  it.effect("derives matching read and write scopes from a schema annotation", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", DependencyItem, {})
+            yield* repo.save(new DependencyItem({ id: "1", label: S.StringId("label-one") }))
+            yield* repo.query(Q.where("label", "label-one"))
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual(new Set([DataDependencies.repo("DependencyItem", ["label-one"])]))
+        expect(yield* Ref.get(writesRef)).toEqual(
+          new Set([DataDependencies.repo("DependencyItem", ["1", "label-one"])])
+        )
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("derives a nested annotated relationship scope from whereSome", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("NestedDependencyItem", NestedDependencyItem, {})
+            yield* repo.save(new NestedDependencyItem({ id: "root", parts: [{ id: "part-1" }] }))
+            yield* repo.query(Q.whereSome("parts", Q.where("id", "part-1")))
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual(
+          new Set([DataDependencies.repo("NestedDependencyItem", ["part-1"])])
+        )
+        expect(yield* Ref.get(writesRef)).toEqual(
+          new Set([DataDependencies.repo("NestedDependencyItem", ["root", "part-1"])])
+        )
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("records previous and next relationship aliases", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", BatchItem, {
+              dependencyIds: (item) => [item.id, `label-${item.label}`]
+            })
+            yield* repo.save(new BatchItem({ id: "1", label: "old" }))
+            yield* recorder.drainWrites
+
+            yield* repo.save(new BatchItem({ id: "1", label: "new" }))
+            expect(yield* recorder.drainWrites).toEqual(
+              new Set([DataDependencies.repo("DependencyItem", ["1", "label-new", "label-old"])])
+            )
+
+            yield* repo.removeById("1")
+            expect(yield* recorder.drainWrites).toEqual(
+              new Set([DataDependencies.repo("DependencyItem", ["1", "label-new"])])
+            )
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("records repository and affected-query write dependencies", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", BatchItem, {
+              dependencyIds: (item) => [item.id, `alias-${item.id}`],
+              additionalWriteDependencies: (item) => [
+                DataDependencies.signal("DependencyItem.List", [item.label])
+              ]
+            })
+            yield* repo.save(new BatchItem({ id: "1", label: "one" }))
+            yield* DataDependencies.read(DataDependencies.signal("DependencyItem.List", ["one"]))
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual(
+          new Set([DataDependencies.signal("DependencyItem.List", ["one"])])
+        )
+        expect(yield* Ref.get(writesRef)).toEqual(
+          new Set([
+            DataDependencies.repo("DependencyItem", ["1", "alias-1"]),
+            DataDependencies.signal("DependencyItem.List", ["one"])
+          ])
+        )
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("invalidates derived dependencies from previous saves and removeById", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make(DataDependencies.empty())
+        const writesRef = yield* Ref.make(DataDependencies.empty())
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DerivedDependencyItem", BatchItem, {
+              additionalWriteDependencies: (item) => [
+                DataDependencies.signal("DerivedDependencyItem.List", [item.label])
+              ]
+            })
+            yield* repo.save(new BatchItem({ id: "1", label: "old" }))
+            yield* recorder.drainWrites
+
+            yield* repo.save(new BatchItem({ id: "1", label: "new" }))
+            expect(yield* recorder.drainWrites).toEqual(
+              new Set([
+                DataDependencies.repo("DerivedDependencyItem", ["1"]),
+                DataDependencies.signal("DerivedDependencyItem.List", ["new", "old"])
+              ])
+            )
+
+            yield* repo.removeById("1")
+            expect(yield* recorder.drainWrites).toEqual(
+              new Set([
+                DataDependencies.repo("DerivedDependencyItem", ["1"]),
+                DataDependencies.signal("DerivedDependencyItem.List", ["new"])
+              ])
+            )
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("records schema timing on repository spans without codec child spans", () =>
+    Effect
+      .gen(function*() {
+        const spans: Tracer.NativeSpan[] = []
+        const tracer = Tracer.make({
+          span(options) {
+            const span = new Tracer.NativeSpan(options)
+            spans.push(span)
+            return span
+          }
+        })
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("TelemetryItem", BatchItem, {})
+            yield* repo.save(new BatchItem({ id: "1", label: "one" }))
+            yield* repo.all
+          })
+          .pipe(Effect.provideService(Tracer.Tracer, tracer))
+
+        expect(spans.map((_) => _.name)).not.toContain("parseMany")
+        expect(spans.map((_) => _.name)).not.toContain("encodeMany")
+
+        const saveSpan = spans.find((_) => _.name === "Repository.saveAndPublish")
+        const allSpan = spans.find((_) => _.name === "Repository.all")
+        expect(saveSpan?.attributes.get("app.schema.encode.duration_ms")).toEqual(expect.any(Number))
+        expect(saveSpan?.attributes.get("app.schema.item_count")).toBe(1)
+        expect(saveSpan?.attributes.get("db.operation.duration_ms")).toEqual(expect.any(Number))
+        expect(allSpan?.attributes.get("app.schema.decode.duration_ms")).toEqual(expect.any(Number))
+        expect(allSpan?.attributes.get("app.schema.item_count")).toBe(1)
+        expect(allSpan?.attributes.get("db.operation.duration_ms")).toEqual(expect.any(Number))
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+})

package/test/requires.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Result, S, ServiceMap } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
 import { HttpHeaders } from "effect-app/http"
+import * as Layer from "effect-app/Layer"
 import * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
 import type { unhandled } from "effect-app/Types"
+import * as Result from "effect/Result"
 import { Rpc } from "effect/unstable/rpc"
 import { type SuccessValue } from "effect/unstable/rpc/RpcMiddleware"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
@@ -63,11 +67,12 @@ const testSuite = (_mw: typeof middleware3) =>
       "works",
       Effect.fn(function*() {
         const defaultOpts = {
+          client: null as any, // TODO?
           headers: HttpHeaders.fromRecordUnsafe({}),
           payload: { _tag: "Test" },
           clientId: 0,
           requestId: "test-id" as any,
-          rpc: { ...TestRpc, annotations: ServiceMap.make(_mw.requestContext, {}) }
+          rpc: { ...TestRpc, annotations: Context.make(_mw.requestContext, {}) }
         }
         const next = Effect.void as unknown as Effect.Effect<SuccessValue, unhandled, never>
         const layer = _mw.layer.pipe(
@@ -89,7 +94,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 headers: HttpHeaders.fromRecordUnsafe({ "x-user": "test-user", "x-is-manager": "true" }),
                 rpc: {
                   ...defaultOpts.rpc,
-                  annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                  annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                 }
               })
             )
@@ -127,7 +132,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 Object.assign({ ...defaultOpts }, {
                   rpc: {
                     ...defaultOpts.rpc,
-                    annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                    annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                   }
                 })
               )
@@ -153,7 +158,7 @@ const testSuite = (_mw: typeof middleware3) =>
                   {
                     rpc: {
                       ...defaultOpts.rpc,
-                      annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                      annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                     }
                   }
                 )

package/test/router-generator.test.ts

@@ -0,0 +1,187 @@
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/routing"
+import { expectTypeOf, it } from "@effect/vitest"
+import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeAllDSL, makeOneDSL } from "effect-app/Model"
+import { type FixEnv } from "effect-app/Pure"
+import * as RpcX from "effect-app/rpc"
+import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
+import { type TypeTestId } from "effect-app/TypeTest"
+import { type ConfigError } from "effect/Config"
+import { type RpcSerialization } from "effect/unstable/rpc/RpcSerialization"
+import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/routing/middleware.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
+
+// Inline minimal context provider (provides `Some`)
+class CtxProvider extends RpcX.RpcMiddleware.Tag<CtxProvider, { provides: Some }>()("CtxProvider") {
+  static Default = Layer.make(this, {
+    *make() {
+      return Effect.fnUntraced(function*(effect) {
+        return yield* Effect.provideService(effect, Some, Some.of({ a: 1 }))
+      })
+    }
+  })
+}
+
+// Provides `SomeElse` so AllowAnonymous's requirement is met.
+class SomeElseProvider extends RpcX.RpcMiddleware.Tag<SomeElseProvider, { provides: SomeElse }>()("SomeElseProvider") {
+  static Default = Layer.make(this, {
+    *make() {
+      return Effect.fnUntraced(function*(effect) {
+        return yield* Effect.provideService(effect, SomeElse, SomeElse.of({ b: 2 }))
+      })
+    }
+  })
+}
+
+class mw extends MiddlewareMaker
+  .Tag<mw>()("mw", RequestContextMap)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(CtxProvider)
+  .middleware(...DefaultGenericMiddlewares, SomeElseProvider)
+{
+  static Default = this.layer.pipe(
+    Layer.provide([
+      RequireRolesLive,
+      TestLive,
+      AllowAnonymousLive,
+      CtxProvider.Default,
+      SomeElseProvider.Default,
+      DefaultGenericMiddlewaresLive,
+      DevModeMiddlewareLive,
+      SomeService.Default
+    ])
+  )
+}
+
+const { TaggedRequestFor } = makeRpcClient(mw)
+const Req = TaggedRequestFor("GenRouter")
+
+class GetThing extends Req.Query<GetThing>()("GetThing", { id: S.String }, {
+  success: S.String,
+  error: UnauthorizedError
+}) {}
+class DoThing extends Req.Command<DoThing>()("DoThing", { id: S.String }, { success: S.Void }) {}
+
+const Resource = { GetThing, DoThing }
+
+const { Router, matchAll } = makeRouter(mw.Default)
+
+class ThingRepo extends Context.Service<ThingRepo>()("ThingRepo", {
+  make: Effect.succeed({ get: (id: string) => Effect.succeed(id + "!") })
+}) {
+  static Default = Layer.effect(this, this.make)
+}
+
+// Case under test:
+// `match({})` is given handlers as **shorthand generator methods** (`*GetThing(req) { ... }`).
+// tsgo (>= 7 dev) infers `TNext = unknown` for these shorthand generators while TS6 infers `never`.
+// `HandlerWithInputGen` in routing.ts must accept both — see the structural fix.
+const router = Router(Resource)({
+  dependencies: [ThingRepo.Default],
+  *effect(match) {
+    const repo = yield* ThingRepo
+
+    if (Math.random() > 0.5) return yield* new InvalidStateError("nope")
+
+    return match({
+      *GetThing(req) {
+        const some = yield* Some
+        if (req.id === "boom") {
+          return yield* Effect.fail(new UnauthorizedError())
+        }
+        return yield* repo.get(req.id + String(some.a))
+      },
+      *DoThing(_req) {
+        yield* Effect.succeed(1)
+      }
+    })
+  }
+})
+
+// Same scenario but using the `raw:` variant — exercises the `raw` path of `HandlerWithInputGen`.
+const routerRaw = Router({ GetThing })({
+  *effect(match) {
+    return match({
+      GetThing: {
+        *raw(req) {
+          const some = yield* Some
+          return yield* Effect.succeed(req.id + String(some.a))
+        }
+      }
+    })
+  }
+})
+
+it("router with generator-method handlers compiles", () => {
+  expectTypeOf(router).toMatchTypeOf<
+    Layer.Layer<never, ConfigError | InvalidStateError, SomeService | RpcSerialization>
+  >()
+  expectTypeOf(routerRaw).toMatchTypeOf<Layer.Layer<never, ConfigError, SomeService | RpcSerialization>>()
+})
+
+// Type-level assertions: verify generator yields propagate to MakeErrors / MakeContext
+type Errors = MakeErrors<typeof router[TypeTestId]>
+type Ctx = MakeContext<typeof router[TypeTestId]>
+expectTypeOf<Errors>().toEqualTypeOf<InvalidStateError>()
+expectTypeOf<Ctx>().toEqualTypeOf<ThingRepo>()
+
+const matched = matchAll({ router })
+expectTypeOf(matched).toMatchTypeOf<
+  Layer.Layer<never, ConfigError | InvalidStateError, SomeService | RpcSerialization>
+>()
+
+// ---------------------------------------------------------------------------
+// DSL R-inference regression
+// ---------------------------------------------------------------------------
+// `OneDSL`/`OneDSLExt.update`/`.modify` previously annotated the callback's
+// effect R as `FixEnv<R, Evt, S1, S2>`. That deadlocked inference of `R`
+// (TS6 → `never`, tsgo → `unknown`), causing yielded effects to leak
+// `unknown` in the R slot when consumed by generator handlers.
+// The fix uses bare `R` in the callback and `FixEnv<R, …>` only on the return.
+class Item extends S.Class<Item>("Item")({ id: S.String, label: S.String }) {}
+class Dep extends Context.Service<Dep>()("Dep", { make: Effect.succeed({ tag: "dep" as const }) }) {}
+
+type Evt = { _tag: "Updated"; id: string }
+
+const Items$ = makeAllDSL<Item, Evt>()
+const Item$ = makeOneDSL<Item, Evt>()
+
+// Callback body uses generator syntax (TNext = unknown under tsgo) and yields
+// a service-dependent effect — R must be inferred as `Dep` (plus the
+// canonical PureEnvEnv contributed by FixEnv on the return).
+const oneUpdate = Item$.update((item) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return new Item({ id: item.id, label: item.label + dep.tag })
+  })
+)
+
+const allUpdate = Items$.update((items) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return items.map((_) => new Item({ id: _.id, label: _.label + dep.tag }))
+  })
+)
+
+const oneModify = Item$.modify((item, _dsl) =>
+  Effect.gen(function*() {
+    const dep = yield* Dep
+    return { ...item, tag: dep.tag }
+  })
+)
+
+// `R` should be `FixEnv<Dep, Evt, …>` — never collapsed to `unknown`/`never`.
+// The regression manifested as `unknown` here, breaking `Dep` assignability.
+expectTypeOf(oneUpdate).toMatchTypeOf<Effect.Effect<Item, never, FixEnv<Dep, Evt, Item, Item>>>()
+expectTypeOf(allUpdate).toMatchTypeOf<
+  Effect.Effect<readonly Item[], never, FixEnv<Dep, Evt, readonly Item[], readonly Item[]>>
+>()
+expectTypeOf(oneModify).toMatchTypeOf<
+  Effect.Effect<{ tag: "dep"; id: string; label: string }, never, FixEnv<Dep, Evt, Item, Item>>
+>()