@effect-app/infra 4.0.0-beta.99 → 4.0.0

package/test/repository-legacy-document.test.ts

@@ -0,0 +1,394 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { makeRepo } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
+import type { JsonRecord } from "effect-app/Store"
+import { StoreMaker } from "effect-app/Store"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as Result from "effect/Result"
+import { describe, expect, it } from "vitest"
+import { decodeStoredMany, decodeStoredOption, makeStoredDecode } from "../src/Store/jsonDocument.js"
+import { makeMemoryStoreInt } from "../src/Store/Memory.js"
+import { makeJsonLower } from "../src/Store/utils.js"
+
+/**
+ * A Memory store seeded with *raw stored documents* instead of items encoded
+ * through the schema, so that a legacy-shaped document can reach the read path -
+ * exactly what Cosmos (`fromStored`) and SQL (`parseRow`) do in production.
+ *
+ * `MemoryStoreLive` cannot be used for this: it strictly `encode`s whatever it
+ * is seeded with, so a legacy document never makes it into the store. The inner
+ * store here is therefore schemaless (it may not validate what we seed), and
+ * the real store read boundary - `defaultValues` merged, then `jitM`, then the
+ * strict JSON→Encoded decode - is applied on top via {@link makeStoredDecode}.
+ */
+const LegacyDocStoreLive = (docs: readonly Record<string, unknown>[]) =>
+  StoreMaker.toLayer(Effect.sync(() => ({
+    make: ((modelName: string, idKey: any, _seed: any, config: any) =>
+      Effect.map(
+        makeMemoryStoreInt(
+          modelName,
+          idKey,
+          "primary",
+          Effect.succeed(docs as any),
+          config?.defaultValues,
+          undefined,
+          makeJsonLower(config)
+        ),
+        (store) => {
+          const decode = makeStoredDecode<any>(config?.schema, config?.jitM)
+          return {
+            ...store,
+            all: Effect.flatMap(store.all, (rows) => Effect.fromResult(decodeStoredMany(rows, decode))),
+            find: (id: any) =>
+              Effect.flatMap(store.find(id), (doc) => Effect.fromResult(decodeStoredOption(doc, decode))),
+            filter: (f: any) =>
+              Effect.flatMap(store.filter(f), (rows: any[]) =>
+                f.select ? Effect.succeed(rows) : Effect.fromResult(decodeStoredMany(rows, decode)))
+          }
+        }
+      )) as any
+  })))
+
+class Shop extends S.Class<Shop>("LegacyDocShop")({
+  id: S.String,
+  name: S.NonEmptyString255,
+  createdAt: S.Date,
+  updatedAt: S.Date,
+  vatRate: S.Number,
+  tags: S.ReadonlySet(S.String),
+  meta: S.ReadonlyMap({ key: S.String, value: S.String })
+}) {}
+
+// `vatRate` was added later; stored documents from before that do not have it.
+const jitM = (json: JsonRecord): JsonRecord => "vatRate" in json ? json : { ...json, vatRate: 19 }
+
+/** does *not* repair `vatRate`, so `legacyDoc` cannot decode at the store boundary */
+const jitMThatDoesNotRepair = (json: JsonRecord): JsonRecord => ({
+  ...json,
+  updatedAt: json["updatedAt"] ?? "2024-06-03T00:00:00.000Z"
+})
+
+const legacyDoc = {
+  id: "shop-legacy",
+  name: "Legacy Shop",
+  createdAt: "2024-06-01T00:00:00.000Z",
+  updatedAt: "2024-06-03T00:00:00.000Z",
+  tags: ["a"],
+  meta: [["k", "v"]]
+}
+
+const currentDoc = {
+  id: "shop-current",
+  name: "Current Shop",
+  createdAt: "2024-06-02T00:00:00.000Z",
+  updatedAt: "2024-06-04T00:00:00.000Z",
+  vatRate: 7,
+  tags: ["b"],
+  meta: [["k2", "v2"]]
+}
+
+/** a legacy document that stored an explicit `null` where a Date is expected */
+const nullDoc = { ...legacyDoc, id: "shop-null", vatRate: 21, updatedAt: null }
+
+/** `vatRate` present but falsy, `updatedAt` an explicit null */
+const zeroDoc = { ...legacyDoc, id: "shop-zero", vatRate: 0, updatedAt: null }
+
+const TestLive = Layer.merge(LegacyDocStoreLive([legacyDoc, currentDoc]), RepositoryRegistryLive)
+const NullDocLive = Layer.merge(LegacyDocStoreLive([nullDoc]), RepositoryRegistryLive)
+const CurrentDocLive = Layer.merge(LegacyDocStoreLive([currentDoc]), RepositoryRegistryLive)
+const DefaultsLive = Layer.merge(LegacyDocStoreLive([legacyDoc, zeroDoc]), RepositoryRegistryLive)
+
+describe("repository reads of legacy documents", () => {
+  it("all: jitM fills the key the stored document is missing", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM })
+
+        const items = yield* repo.all
+
+        expect(items).toHaveLength(2)
+        const legacy = items.find((_) => _.id === "shop-legacy")!
+        expect(legacy).toBeInstanceOf(Shop)
+        expect(legacy.vatRate).toBe(19)
+        expect(legacy.createdAt).toBeInstanceOf(Date)
+        expect(legacy.tags).toBeInstanceOf(Set)
+        expect([...legacy.tags]).toEqual(["a"])
+        expect(items.find((_) => _.id === "shop-current")!.vatRate).toBe(7)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("find: a legacy document decodes through jitM", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM })
+
+        const found = yield* repo.find("shop-legacy")
+
+        expect(Option.isSome(found)).toBe(true)
+        const shop = Option.getOrThrow(found)
+        expect(shop.vatRate).toBe(19)
+        expect(shop.name).toBe("Legacy Shop")
+        expect(shop.createdAt).toBeInstanceOf(Date)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("validateSample: legacy documents validate because jitM runs at the store boundary", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM })
+
+        const result = yield* repo.validateSample({ percentage: 1.0 })
+
+        expect(result.total).toBe(2)
+        expect(result.sampled).toBe(2)
+        expect(result.errors).toHaveLength(0)
+        expect(result.valid).toBe(2)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("jitM repairs an explicit null, and the document decodes end-to-end", () =>
+    Effect
+      .gen(function*() {
+        // the case the store boundary exists for: `null` is not a valid
+        // `S.Date` encoding, so no schema decode could ever fix it
+        const repairNull = (json: JsonRecord): JsonRecord =>
+          json["updatedAt"] === null ? { ...json, updatedAt: "2024-06-05T00:00:00.000Z" } : json
+
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: repairNull })
+
+        const shop = Option.getOrThrow(yield* repo.find("shop-null"))
+        expect(shop.updatedAt).toBeInstanceOf(Date)
+        expect(shop.updatedAt.toISOString()).toBe("2024-06-05T00:00:00.000Z")
+
+        const all = yield* repo.all
+        expect(all).toHaveLength(1)
+        expect(all[0]!.updatedAt.toISOString()).toBe("2024-06-05T00:00:00.000Z")
+      })
+      .pipe(
+        Effect.provide(NullDocLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("jitM receives the raw JSON document, and its JSON result is what the decode consumes", () =>
+    Effect
+      .gen(function*() {
+        const seen: JsonRecord[] = []
+        const observe = (json: JsonRecord): JsonRecord => {
+          seen.push(json)
+          // returning JSON - an ISO string, not a `Date` - is what decodes
+          return { ...json, updatedAt: "2024-06-09T00:00:00.000Z" }
+        }
+
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: observe })
+
+        const shop = Option.getOrThrow(yield* repo.find("shop-current"))
+
+        expect(seen).toHaveLength(1)
+        const raw = seen[0]!
+        // a `Date` field arrives as an ISO string
+        expect(typeof raw["createdAt"]).toBe("string")
+        expect(raw["createdAt"]).toBe("2024-06-02T00:00:00.000Z")
+        // a `ReadonlySet` as an array, a `ReadonlyMap` as an array of pairs
+        expect(raw["tags"]).toEqual(["b"])
+        expect(raw["meta"]).toEqual([["k2", "v2"]])
+        // never native Encoded values
+        expect(raw["createdAt"]).not.toBeInstanceOf(Date)
+        expect(raw["meta"]).not.toBeInstanceOf(Map)
+        // `_etag` is infra metadata and is not part of the document
+        expect("_etag" in raw).toBe(false)
+
+        // the JSON the jitM returned was decoded to the native Encoded value
+        expect(shop.updatedAt).toBeInstanceOf(Date)
+        expect(shop.updatedAt.toISOString()).toBe("2024-06-09T00:00:00.000Z")
+        expect(shop.meta).toBeInstanceOf(Map)
+        expect([...shop.meta]).toEqual([["k2", "v2"]])
+      })
+      .pipe(
+        Effect.provide(CurrentDocLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("defaultValues only fill absent keys, and a stored null still reaches jitM", () =>
+    Effect
+      .gen(function*() {
+        const seen: JsonRecord[] = []
+        const repo = yield* makeRepo("LegacyDocShop", Shop, {
+          jitM: (json) => {
+            seen.push(json)
+            return json["updatedAt"] === null ? { ...json, updatedAt: "2024-06-08T00:00:00.000Z" } : json
+          },
+          config: {
+            defaultValues: {
+              vatRate: 19,
+              updatedAt: new Date("2024-01-01T00:00:00.000Z")
+            }
+          }
+        })
+
+        const items = yield* repo.all
+        expect(items).toHaveLength(2)
+
+        // absent key -> filled by defaultValues
+        const missing = items.find((_) => _.id === "shop-legacy")!
+        expect(missing.vatRate).toBe(19)
+        // present key -> the stored value wins, even when falsy
+        const present = items.find((_) => _.id === "shop-zero")!
+        expect(present.vatRate).toBe(0)
+
+        // defaultValues are merged *before* jitM runs
+        const filledSeen = seen.find((_) => _["id"] === "shop-legacy")!
+        expect(filledSeen["vatRate"]).toBe(19)
+        // ...but never overwrite a key the document has
+        expect(filledSeen["updatedAt"]).toBe("2024-06-03T00:00:00.000Z")
+
+        // a stored explicit `null` is NOT replaced by the default: it reaches jitM
+        const nullSeen = seen.find((_) => _["id"] === "shop-zero")!
+        expect(nullSeen["updatedAt"]).toBe(null)
+        expect(present.updatedAt.toISOString()).toBe("2024-06-08T00:00:00.000Z")
+      })
+      .pipe(
+        Effect.provide(DefaultsLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  /**
+   * The store boundary decode is deliberately **strict**: `jitM` is the one and
+   * only place a legacy document can be repaired, and a document it does not
+   * repair must fail rather than be read back half-decoded. This test pins that
+   * behaviour down on purpose - do not "fix" it by making the decode lenient.
+   *
+   * It fails as a *typed* `S.SchemaError` in the store's error channel (it used
+   * to throw out of `decodeSync` as a defect), which is what lets
+   * `validateSample` report the document instead of losing the whole run.
+   */
+  it("a document jitM does not repair fails as a typed SchemaError at the store boundary", () =>
+    Effect
+      .gen(function*() {
+        const { make } = yield* StoreMaker
+        // `vatRate` is still missing after this jitM ran: it only touches `updatedAt`
+        const store = yield* make<"id", any>("LegacyDocShop", "id", undefined, {
+          partitionValue: () => "primary",
+          schema: Shop,
+          jitM: jitMThatDoesNotRepair
+        })
+
+        // `Effect.result` only catches typed failures - a defect would reject here
+        const result = yield* store.all.pipe(Effect.result)
+
+        expect(Result.isFailure(result)).toBe(true)
+        if (!Result.isFailure(result)) return
+        const failure = result.failure
+        expect(S.isSchemaError(failure)).toBe(true)
+        expect((failure as S.SchemaError)._tag).toBe("SchemaError")
+        // the strict `toCodecJson(toEncoded(schema))` decode still reports the
+        // key jitM failed to add, with the path to it
+        expect((failure as S.SchemaError).message).toContain("Missing key")
+        expect((failure as S.SchemaError).message).toContain("vatRate")
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  /**
+   * ...and the *public* repository surface is unchanged: `Repository.find`/`all`
+   * declare only `DatabaseError`, so the store's `SchemaError` becomes a defect
+   * when the public members are produced.
+   */
+  it("the same document still dies on a public repository read", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: jitMThatDoesNotRepair })
+
+        const exit = yield* repo.all.pipe(Effect.exit)
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          expect(Cause.hasDies(exit.cause)).toBe(true)
+          expect(Cause.hasFails(exit.cause)).toBe(false)
+        }
+
+        // a defect is not catchable as a typed failure
+        const notCaught = yield* repo.find("shop-legacy").pipe(Effect.result, Effect.exit)
+        expect(Exit.isFailure(notCaught)).toBe(true)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("validateSample reports a document that fails at the store boundary and keeps going", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: jitMThatDoesNotRepair })
+
+        const result = yield* repo.validateSample({ percentage: 1.0 })
+
+        expect(result.total).toBe(2)
+        expect(result.sampled).toBe(2)
+        // `shop-current` decodes, `shop-legacy` does not
+        expect(result.valid).toBe(1)
+        expect(result.errors).toHaveLength(1)
+        const error = result.errors[0]!
+        expect(error.id).toBe("shop-legacy")
+        expect(S.isSchemaError(error.error)).toBe(true)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("_etag is not visible to jitM and survives the round trip", () => {
+    const seen: JsonRecord[] = []
+    const decode = makeStoredDecode<any>(
+      Shop,
+      (json) => {
+        seen.push(json)
+        return { ...json, vatRate: 19 }
+      }
+    )
+
+    const decoded = Result.getOrThrow(decode({ ...legacyDoc, _etag: "etag-1" } as any))
+
+    // jitM sees the document without the infra metadata
+    expect(seen).toHaveLength(1)
+    expect("_etag" in seen[0]!).toBe(false)
+    // ...and the etag is re-attached to the decoded Encoded document
+    expect(decoded._etag).toBe("etag-1")
+    expect(decoded.vatRate).toBe(19)
+    expect(decoded.createdAt).toBeInstanceOf(Date)
+  })
+})

package/test/requires.test.ts

@@ -1,12 +1,16 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Context, Effect, Layer, Result, S } 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 { Rpc } from "effect/unstable/rpc"
-import { type SuccessValue } from "effect/unstable/rpc/RpcMiddleware"
+import * as Result from "effect/Result"
+import { Rpc } from "effect/rpc"
+import { type SuccessValue } from "effect/rpc/RpcMiddleware"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 
 export class RequiresSomeMiddleware

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/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>>
+>()

package/test/routing-interruptibility.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "@effect/vitest"
+import { ConfigureInterruptibilityMiddleware } from "effect-app/middleware"
+import * as S from "effect-app/Schema"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import { Rpc, RpcGroup, RpcTest } from "effect/rpc"
+import { applyRequestTypeInterruptibility } from "../src/routing.js"
+import { ConfigureInterruptibilityMiddlewareLive, RequestType } from "../src/routing/middleware.js"
+
+const InterruptibilityRpcs = RpcGroup.make(
+  Rpc
+    .make("doCommand", { success: S.Void })
+    .annotate(RequestType, "command")
+    .middleware(ConfigureInterruptibilityMiddleware),
+  Rpc
+    .make("doQuery", { success: S.Void })
+    .annotate(RequestType, "query")
+    .middleware(ConfigureInterruptibilityMiddleware)
+)
+
+const makeImplLayer = (commandDone: Ref.Ref<boolean>, queryDone: Ref.Ref<boolean>) =>
+  InterruptibilityRpcs.toLayer({
+    doCommand: () =>
+      applyRequestTypeInterruptibility(
+        "command",
+        Effect.sleep("120 millis").pipe(Effect.andThen(Ref.set(commandDone, true)))
+      ),
+    doQuery: () =>
+      applyRequestTypeInterruptibility(
+        "query",
+        Effect.sleep("120 millis").pipe(Effect.andThen(Ref.set(queryDone, true)))
+      )
+  })
+
+describe("routing interruptibility", () => {
+  it.live(
+    "e2e: command continues after client interrupt, query does not",
+    () =>
+      Effect.gen(function*() {
+        const commandDone = yield* Ref.make(false)
+        const queryDone = yield* Ref.make(false)
+
+        const client = yield* RpcTest
+          .makeClient(InterruptibilityRpcs)
+          .pipe(
+            Effect.provide(
+              Layer.mergeAll(makeImplLayer(commandDone, queryDone), ConfigureInterruptibilityMiddlewareLive)
+            )
+          )
+
+        const commandFiber = yield* Effect.forkDetach(client.doCommand())
+        yield* Effect.sleep("20 millis")
+        yield* Fiber.interrupt(commandFiber)
+        yield* Effect.sleep("180 millis")
+        expect(yield* Ref.get(commandDone)).toBe(true)
+
+        const queryFiber = yield* Effect.forkDetach(client.doQuery())
+        yield* Effect.sleep("20 millis")
+        yield* Fiber.interrupt(queryFiber)
+        yield* Effect.sleep("180 millis")
+        expect(yield* Ref.get(queryDone)).toBe(false)
+      })
+  )
+})