@effect-app/infra 3.0.13 → 3.0.15

package/src/api/routing.ts

@@ -3,7 +3,7 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Rpc, RpcGroup, type RpcSerialization, RpcServer } from "@effect/rpc"
-import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
+import { Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
 import { type HttpHeaders } from "effect-app/http"
 import { type GetEffectContext, type GetEffectError, type RpcContextMap } from "effect-app/rpc/RpcContextMap"
 import { type TypeTestId } from "effect-app/TypeTest"
@@ -67,7 +67,7 @@ interface HandlerBase<Action extends AnyRequestModule, RT extends RequestType, A
   new(): {}
   _tag: RT
   stack: string
-  handler: (req: S.Schema.Type<Action>, headers: HttpHeaders.Headers) => Effect<A, E, R>
+  handler: (req: S.Schema.Type<Action>, headers: HttpHeaders.Headers) => Effect.Effect<A, E, R>
 }
 
 export interface Handler<Action extends AnyRequestModule, RT extends RequestType, R> extends
@@ -93,10 +93,10 @@ type FilterRequestModules<T> = {
 }
 
 type RpcRouteR<
-  T extends [any, (req: any, headers: HttpHeaders.Headers) => Effect<any, any, any>]
+  T extends [any, (req: any, headers: HttpHeaders.Headers) => Effect.Effect<any, any, any>]
 > = T extends [
   any,
-  (...args: any[]) => Effect<any, any, infer R>
+  (...args: any[]) => Effect.Effect<any, any, infer R>
 ] ? R
   : never
 
@@ -108,7 +108,7 @@ type Match<
 > = {
   // note: the defaults of = never prevent the whole router to error (??)
   <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
-    f: Effect<A, E, R2>
+    f: Effect.Effect<A, E, R2>
   ): Handler<
     Resource[Key],
     RT,
@@ -119,7 +119,7 @@ type Match<
   >
 
   <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
-    f: (req: S.Schema.Type<Resource[Key]>) => Effect<A, E, R2>
+    f: (req: S.Schema.Type<Resource[Key]>) => Effect.Effect<A, E, R2>
   ): Handler<
     Resource[Key],
     RT,
@@ -185,7 +185,7 @@ export const makeRouter = <
       req: S.Schema.Type<Action>
     ) => Generator<
       YieldWrap<
-        Effect<
+        Effect.Effect<
           any,
           S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
           // the actual implementation of the handler may just require the dynamic context provided by the middleware
@@ -202,7 +202,7 @@ export const makeRouter = <
       RT extends RequestType
     > = (
       req: S.Schema.Type<Action>
-    ) => Effect<
+    ) => Effect.Effect<
       GetSuccessShape<Action, RT>,
       S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
       // the actual implementation of the handler may just require the dynamic context provided by the middleware
@@ -213,7 +213,7 @@ export const makeRouter = <
     type HandlerEff<
       Action extends AnyRequestModule,
       RT extends RequestType
-    > = Effect<
+    > = Effect.Effect<
       GetSuccessShape<Action, RT>,
       S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
       // the actual implementation of the handler may just require the dynamic context provided by the middleware
@@ -307,18 +307,19 @@ export const makeRouter = <
         Exclude<
           Exclude<
             // retrieves context R from the actual implementation of the handler
-            Impl[K] extends { raw: any } ? Impl[K]["raw"] extends (...args: any[]) => Effect<any, any, infer R> ? R
-              : Impl[K]["raw"] extends Effect<any, any, infer R> ? R
+            Impl[K] extends { raw: any }
+              ? Impl[K]["raw"] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
+              : Impl[K]["raw"] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends (...args: any[]) => Generator<
-                YieldWrap<Effect<any, any, infer R>>,
+                YieldWrap<Effect.Effect<any, any, infer R>>,
                 any,
                 any
               > ? R
               : never
-              : Impl[K] extends (...args: any[]) => Effect<any, any, infer R> ? R
-              : Impl[K] extends Effect<any, any, infer R> ? R
+              : Impl[K] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
+              : Impl[K] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends (...args: any[]) => Generator<
-                YieldWrap<Effect<any, any, infer R>>,
+                YieldWrap<Effect.Effect<any, any, infer R>>,
                 any,
                 any
               > ? R
@@ -347,7 +348,9 @@ export const makeRouter = <
       dependencies: MakeDependencies,
       make: (
         match: any
-      ) => Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
+      ) =>
+        | Effect.Effect<THandlers, MakeE, MakeR>
+        | Generator<YieldWrap<Effect.Effect<any, MakeE, MakeR>>, THandlers, any>
     ) => {
       const dependenciesL = (dependencies ? Layer.mergeAll(...dependencies as any) : Layer.empty) as Layer.Layer<
         LayerUtils.GetLayersSuccess<MakeDependencies>,
@@ -359,7 +362,7 @@ export const makeRouter = <
         .gen(function*() {
           const finalMake = ((make as any)[Symbol.toStringTag] === "GeneratorFunction"
             ? Effect.fnUntraced(make as any)(router3) as any
-            : make(router3) as any) as Effect<THandlers, MakeE, MakeR>
+            : make(router3) as any) as Effect.Effect<THandlers, MakeE, MakeR>
 
           const controllers = yield* finalMake
 
@@ -384,7 +387,7 @@ export const makeRouter = <
                 } as any
                 : resource,
               (payload: any, headers: any) =>
-                (handler.handler(payload, headers) as Effect<unknown, unknown, unknown>).pipe(
+                (handler.handler(payload, headers) as Effect.Effect<unknown, unknown, unknown>).pipe(
                   Effect.withSpan(`Request.${meta.moduleName}.${resource._tag}`, {
                     captureStackTrace: () => handler.stack // capturing the handler stack is the main reason why we are doing the span here
                   })
@@ -398,11 +401,11 @@ export const makeRouter = <
                 req: any,
                 headers: HttpHeaders.Headers
               ) => Effect.Effect<
-                Effect.Success<ReturnType<THandlers[K]["handler"]>>,
-                | Effect.Error<ReturnType<THandlers[K]["handler"]>>
+                Effect.Effect.Success<ReturnType<THandlers[K]["handler"]>>,
+                | Effect.Effect.Error<ReturnType<THandlers[K]["handler"]>>
                 | GetEffectError<RequestContextMap, Resource[K]["config"]>,
                 Exclude<
-                  Effect.Context<ReturnType<THandlers[K]["handler"]>>,
+                  Effect.Effect.Context<ReturnType<THandlers[K]["handler"]>>,
                   ContextProviderA | GetEffectContext<RequestContextMap, Resource[K]["config"]>
                 >
               >
@@ -426,7 +429,7 @@ export const makeRouter = <
                 acc[`${meta.moduleName}.${resource._tag}`] = handler
                 return acc
               }, {} as Record<string, any>) as any // TODO
-            })) as unknown as Layer<
+            })) as unknown as Layer.Layer<
               { [K in keyof RequestModules]: Rpc.Handler<K> },
               MakeE,
               RpcRouteR<typeof mapped[keyof typeof mapped]>
@@ -457,10 +460,10 @@ export const makeRouter = <
       // Multiple times duplicated the "good" overload, so that errors will only mention the last overload when failing
       <
         const Make extends {
-          dependencies?: Array<Layer.Layer.Any>
+          dependencies?: ReadonlyArray<Layer.Layer.Any>
           effect: (match: typeof router3) => Generator<
             YieldWrap<
-              Effect<
+              Effect.Effect<
                 any,
                 any,
                 any
@@ -479,9 +482,9 @@ export const makeRouter = <
           never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
-          | Layer.Error<typeof middleware.Default>,
+          | Layer.Layer.Error<typeof middleware.Default>,
           | Service.MakeDepsIn<Make>
-          | Layer.Context<typeof middleware.Default>
+          | Layer.Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
             MakeDepsOut<Make>
@@ -494,10 +497,10 @@ export const makeRouter = <
         }
       <
         const Make extends {
-          dependencies?: Array<Layer.Layer.Any>
+          dependencies?: ReadonlyArray<Layer.Layer.Any>
           effect: (match: typeof router3) => Generator<
             YieldWrap<
-              Effect<
+              Effect.Effect<
                 any,
                 any,
                 any
@@ -514,9 +517,9 @@ export const makeRouter = <
           never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
-          | Layer.Error<typeof middleware.Default>,
+          | Layer.Layer.Error<typeof middleware.Default>,
           | Service.MakeDepsIn<Make>
-          | Layer.Context<typeof middleware.Default>
+          | Layer.Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
             MakeDepsOut<Make>
@@ -560,22 +563,22 @@ export type MakeDeps<Make> = Make extends { readonly dependencies: ReadonlyArray
   ? Make["dependencies"][number]
   : never
 
-export type MakeErrors<Make> = /*Make extends { readonly effect: (_: any) => Effect<any, infer E, any> } ? E
-  : Make extends { readonly effect: (_: any) => Effect<any, never, any> } ? never
+export type MakeErrors<Make> = /*Make extends { readonly effect: (_: any) => Effect.Effect<any, infer E, any> } ? E
+  : Make extends { readonly effect: (_: any) => Effect.Effect<any, never, any> } ? never
   : */
-  Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, never, any>>, any, any> } ? never
-    : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, infer E, any>>, any, any> } ? E
+  Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect.Effect<any, never, any>>, any, any> } ? never
+    : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect.Effect<any, infer E, any>>, any, any> } ? E
     : never
 
-export type MakeContext<Make> = /*Make extends { readonly effect: (_: any) => Effect<any, any, infer R> } ? R
-  : Make extends { readonly effect: (_: any) => Effect<any, any, never> } ? never
+export type MakeContext<Make> = /*Make extends { readonly effect: (_: any) => Effect.Effect<any, any, infer R> } ? R
+  : Make extends { readonly effect: (_: any) => Effect.Effect<any, any, never> } ? never
   : */
-  Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, any, never>>, any, any> } ? never
-    : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, any, infer R>>, any, any> } ? R
+  Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect.Effect<any, any, never>>, any, any> } ? never
+    : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect.Effect<any, any, infer R>>, any, any> } ? R
     : never
 
 export type MakeHandlers<Make, _Handlers extends Record<string, any>> = /*Make extends
-  { readonly effect: (_: any) => Effect<{ [K in keyof Handlers]: AnyHandler<Handlers[K]> }, any, any> }
+  { readonly effect: (_: any) => Effect.Effect<{ [K in keyof Handlers]: AnyHandler<Handlers[K]> }, any, any> }
   ? Effect.Success<ReturnType<Make["effect"]>>
   : */
   Make extends { readonly effect: (_: any) => Generator<YieldWrap<any>, infer S, any> } ? S

package/src/api/setupRequest.ts

@@ -26,7 +26,7 @@ export const getRC = Effect.all({
   namespace: storeId
 })
 
-const withRequestSpan = (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(f: Effect<A, E, R>) =>
+const withRequestSpan = (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(f: Effect.Effect<A, E, R>) =>
   Effect.andThen(
     getRC,
     (ctx) =>
@@ -43,7 +43,7 @@ const withRequestSpan = (name = "request", options?: Tracer.SpanOptions) => <R,
   )
 
 export const setupRequestContextFromCurrent =
-  (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(self: Effect<A, E, R>) =>
+  (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
     self
       .pipe(
         withRequestSpan(name, options),
@@ -51,7 +51,7 @@ export const setupRequestContextFromCurrent =
       )
 
 // TODO: consider integrating Effect.withParentSpan
-export function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext) {
+export function setupRequestContext<R, E, A>(self: Effect.Effect<A, E, R>, requestContext: RequestContext) {
   const layer = Layer.mergeAll(
     ContextMapContainer.layer,
     Layer.succeed(LocaleRef, requestContext.locale),
@@ -65,7 +65,7 @@ export function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestConte
 }
 
 export function setupRequestContextWithCustomSpan<R, E, A>(
-  self: Effect<A, E, R>,
+  self: Effect.Effect<A, E, R>,
   requestContext: RequestContext,
   name: string,
   options?: Tracer.SpanOptions

package/src/errorReporter.ts

@@ -5,7 +5,7 @@ import { getRC } from "./api/setupRequest.js"
 import { CauseException, tryToJson, tryToReport } from "./errors.js"
 import { InfraLogger } from "./logger.js"
 
-const tryCauseException = <E>(cause: Cause<E>, name: string): CauseException<E> => {
+const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseException<E> => {
   try {
     return new CauseException(cause, name)
   } catch {
@@ -17,7 +17,7 @@ export function reportError(
   name: string
 ) {
   return (
-    cause: Cause<unknown>,
+    cause: Cause.Cause<unknown>,
     extras?: Record<string, unknown>,
     level: LogLevel.LogLevel = LogLevel.Error
   ) =>
@@ -75,7 +75,7 @@ function reportSentry(
 export function logError<E>(
   name: string
 ) {
-  return (cause: Cause<E>, extras?: Record<string, unknown>) =>
+  return (cause: Cause.Cause<E>, extras?: Record<string, unknown>) =>
     Effect
       .gen(function*() {
         if (Cause.isInterruptedOnly(cause)) {

package/src/rateLimit.ts

@@ -5,7 +5,7 @@
 //  * failure, or interruption.
 //  */
 // export function withPermitsDuration(permits: number, duration: Duration) {
-//   return (self: TSemaphore): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A> => {
+//   return (self: TSemaphore): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> => {
 //     return effect =>
 //       Effect.uninterruptibleMask(
 //         restore =>
@@ -29,8 +29,8 @@ import type { Semaphore } from "effect-app/Effect"
  * delayed by duration after the effect completes execution, whether by success,
  * failure, or interruption.
  */
-export function SEM_withPermitsDuration(permits: number, duration: Duration) {
-  return (self: Semaphore): <R, E, A>(effect: Effect<A, E, R>) => Effect<A, E, R> => {
+export function SEM_withPermitsDuration(permits: number, duration: Duration.Duration) {
+  return (self: Semaphore): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> => {
     return (effect) =>
       Effect.uninterruptibleMask(
         (restore) =>
@@ -47,8 +47,8 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration) {
 
 export function batchPar<R, E, A, R2, E2, A2, T>(
   n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
+  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
     Effect.forEach(
@@ -63,8 +63,8 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
 
 export function batch<R, E, A, R2, E2, A2, T>(
   n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
+  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
     Effect.forEach(
@@ -82,8 +82,8 @@ export function batch<R, E, A, R2, E2, A2, T>(
 // ) {
 //   return <T>(items: Iterable<T>) =>
 //     <R, E, A, R2, E2, A2>(
-//       forEachItem: (i: T) => Effect<R, E, A>,
-//       forEachBatch: (a: Chunk<A>) => Effect<R2, E2, A2>
+//       forEachItem: (i: T) => Effect.Effect<R, E, A>,
+//       forEachBatch: (a: Chunk<A>) => Effect.Effect<R2, E2, A2>
 //     ) =>
 //       Stream.fromCollection(items)
 //         .rechunk(n)
@@ -94,11 +94,11 @@ export function batch<R, E, A, R2, E2, A2, T>(
 
 export function naiveRateLimit(
   n: number,
-  d: Duration
+  d: Duration.Duration
 ) {
   return <T>(items: Iterable<T>) => (<R, E, A, R2, E2, A2>(
-    forEachItem: (i: T) => Effect<A, E, R>,
-    forEachBatch: (a: A[]) => Effect<A2, E2, R2>
+    forEachItem: (i: T) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: A[]) => Effect.Effect<A2, E2, R2>
   ) =>
     Effect.forEach(
       Array.chunk_(items, n),

package/test/controller.test.ts

@@ -205,12 +205,7 @@ export const middleware3 = MiddlewareMaker
   .middleware(Test)
   .middleware(BogusMiddleware)
 
-export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)<{
-  /** Disable authentication requirement */
-  allowAnonymous?: true
-  /** Control the roles that are required to access the resource */
-  allowRoles?: readonly string[]
-}>()
+export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
 
 export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
 export class Gen extends Req<Gen>()("Gen", {}, { success: S.Void }) {}
@@ -352,7 +347,7 @@ it("sorts based on requirements", () => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
-expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<
+expectTypeOf({} as Layer.Layer.Context<typeof matched>).toEqualTypeOf<
   RpcSerialization.RpcSerialization | SomeService | "str"
 >()
 
@@ -410,7 +405,7 @@ const router2 = r2.Router(Something)({
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched2 = matchAll({ router: router2 })
-expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<
+expectTypeOf({} as Layer.Layer.Context<typeof matched2>).toEqualTypeOf<
   RpcSerialization.RpcSerialization | SomeService | "str"
 >()
 

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAC7F,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAoC,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAKtC,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAqB,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cA0E/G,QAAQ;;AADzE,cAAM,kBACJ,SAAQ,uBAA0F;IAElG,MAAM,CAAC,OAAO,uDAUZ;CACH;;;;;AAMD,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,6CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;AAEtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;qGAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEd,CAAA"}

package/test/dist/fixtures.d.ts

@@ -63,7 +63,7 @@ declare const SomeElse_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         b: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, SomeElse | R_3> : Effect.Effect<X, never, SomeElse>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeElse> : Effect.Effect<X, never, SomeElse>;
 };
 export declare class SomeElse extends SomeElse_base {
 }

package/test/requires.test.ts

@@ -70,7 +70,7 @@ const testSuite = (_mw: typeof middleware3) =>
           payload: { _tag: "Test" },
           clientId: 0,
           rpc: { ...Rpc.fromTaggedRequest(TestRequest), annotations: Context.make(_mw.requestContext, {}) },
-          next: Effect.void as unknown as Effect<SuccessValue, never, any>
+          next: Effect.void as unknown as Effect.Effect<SuccessValue, never, any>
         }
         const layer = _mw.layer.pipe(
           Layer.provide([