effect-app 3.15.1 → 4.0.0-beta.0

package/src/http/Request.ts

@@ -1,6 +1,5 @@
-import type { HttpClientResponse } from "@effect/platform/HttpClientResponse"
+import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
 import * as Effect from "../Effect.js"
-import * as Option from "../Option.js"
 import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
 
 export interface ResponseWithBody<A> extends Pick<HttpClientResponse, "headers" | "status" | "remoteAddress"> {
@@ -25,18 +24,16 @@ export const demandJson = (client: HttpClient.HttpClient) =>
     .mapRequest(client, (_) => HttpClientRequest.acceptJson(_))
     .pipe(HttpClient.transform((r, request) =>
       Effect.tap(r, (response) =>
-        Option
-            .getOrUndefined(HttpHeaders
-              .get(response.headers, "Content-Type"))
+        HttpHeaders
+            .get(response.headers, "Content-Type")
             ?.startsWith("application/json")
           ? Effect.void
           : Effect.fail(
-            new HttpClientError.ResponseError({
+            new HttpClientError.DecodeError({
               request,
               response,
-              reason: "Decode",
               description: "not json response: "
-                + Option.getOrUndefined(HttpHeaders.get(response.headers, "Content-Type"))
+                + HttpHeaders.get(response.headers, "Content-Type")
             })
           ))
     ))

package/src/http/internal/lib.ts

@@ -1,13 +1,13 @@
-export * as HttpHeaders from "@effect/platform/Headers"
-export * as HttpBody from "@effect/platform/HttpBody"
-export * as HttpClient from "@effect/platform/HttpClient"
-export * as HttpClientError from "@effect/platform/HttpClientError"
-export * as HttpClientRequest from "@effect/platform/HttpClientRequest"
-export * as HttpClientResponse from "@effect/platform/HttpClientResponse"
-export * as HttpLayerRouter from "@effect/platform/HttpLayerRouter"
-export * as HttpMiddleware from "@effect/platform/HttpMiddleware"
-export * as HttpRouter from "@effect/platform/HttpRouter"
-export * as HttpServer from "@effect/platform/HttpServer"
-export * as HttpServerError from "@effect/platform/HttpServerError"
-export * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-export * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+export * as HttpHeaders from "effect/unstable/http/Headers"
+export * as HttpBody from "effect/unstable/http/HttpBody"
+export * as HttpClient from "effect/unstable/http/HttpClient"
+export * as HttpClientError from "effect/unstable/http/HttpClientError"
+export * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+export * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+// HttpLayerRouter removed in v4 — use HttpRouter instead
+export * as HttpMiddleware from "effect/unstable/http/HttpMiddleware"
+export * as HttpRouter from "effect/unstable/http/HttpRouter"
+export * as HttpServer from "effect/unstable/http/HttpServer"
+export * as HttpServerError from "effect/unstable/http/HttpServerError"
+export * as HttpServerRequest from "effect/unstable/http/HttpServerRequest"
+export * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"

package/src/ids.ts

@@ -12,7 +12,7 @@ export type RequestId = NonEmptyString255
 // a request id may be made from a span id, which does not comply with StringId schema.
 export const RequestId = extendM(
   Object
-    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as Schema<NonEmptyString255, string>),
+    .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as unknown as Schema<NonEmptyString255>),
   (s) => {
     const make = StringId.make as () => NonEmptyString255
     return ({

package/src/index.ts

@@ -1,15 +1,24 @@
 import "./builtin.js"
 
+import * as ServiceMap from "./ServiceMap.js"
+
 export * as Fnc from "./Function.js"
 export * as Utils from "./utils.js"
 
 export * as Array from "./Array.js"
-export * as Context from "./Context.js"
 export * as Effect from "./Effect.js"
 export * as Layer from "./Layer.js"
 export * as NonEmptySet from "./NonEmptySet.js"
+export * as ServiceMap from "./ServiceMap.js"
 export * as Set from "./Set.js"
 
+export {
+  /**
+   * @deprecated use ServiceMap directly instead
+   */
+  ServiceMap as Context
+}
+
 export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.js"
 
 export * from "effect"

package/src/middleware.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context } from "effect-app"
+import { ServiceMap } from "effect-app"
 import { RpcX } from "./rpc.js"
 
-export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
+export class DevMode extends ServiceMap.Reference("DevMode", { defaultValue: () => false }) {}
 
 export class RequestCacheMiddleware
   extends RpcX.RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware")

package/src/rpc/MiddlewareMaker.ts

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Rpc, type RpcGroup, type RpcMiddleware, type RpcSchema } from "@effect/rpc"
-import { type HandlersFrom } from "@effect/rpc/RpcGroup"
-import { Context, Effect, Layer, type Schema, Schema as S, type Scope } from "effect"
+import { Effect, Layer, type Schema, Schema as S, type Scope, ServiceMap } from "effect"
 import { type NonEmptyArray, type NonEmptyReadonlyArray } from "effect/Array"
 import { type Simplify } from "effect/Types"
+import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
+import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
+import { type RequestId } from "effect/unstable/rpc/RpcMessage"
+import { type HttpHeaders } from "../http.js"
 import { PreludeLogger } from "../logger.js"
 import { type TypeTestId } from "../TypeTest.js"
 import { typedValuesOf } from "../utils.js"
@@ -11,8 +13,8 @@ import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap
 import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type RpcMiddlewareV4, type TagClassAny } from "./RpcMiddleware.js"
 import * as RpcMiddlewareX from "./RpcMiddleware.js"
 
-// adapter for effect/rpc v3 middleware provides. (in effect-smol (v4), it's wrap only, and just a Service Identifier, no tags.)
-type MakeTags<A> = Context.Tag<A, A>
+// adapter for effect/rpc v3 middleware provides. (in effect-smol (v4), it's just a Service Identifier, no tags.)
+type MakeTags<A> = ServiceMap.Service<A, A>
 
 export interface MiddlewareMaker<
   Self,
@@ -20,11 +22,10 @@ export interface MiddlewareMaker<
   RequestContextMap extends Record<string, RpcContextMap.Any>,
   MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
 > extends
-  RpcMiddleware.TagClass<
+  RpcMiddlewareX.TagClass<
     Self,
     Id,
     Simplify<
-      & { readonly wrap: true }
       & (Exclude<
         MiddlewareMaker.ManyRequired<MiddlewareProviders>,
         MiddlewareMaker.ManyProvided<MiddlewareProviders>
@@ -38,20 +39,34 @@ export interface MiddlewareMaker<
       })
       & (MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? {}
         : {
-          readonly failure: S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
+          readonly error: S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
         })
       & (MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? {}
         : { readonly provides: MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>> })
-    >
+    >,
+    {
+      provides: MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never
+        : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>
+      requires: Exclude<
+        MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+        MiddlewareMaker.ManyProvided<MiddlewareProviders>
+      > extends never ? never
+        : MakeTags<
+          Exclude<
+            MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+            MiddlewareMaker.ManyProvided<MiddlewareProviders>
+          >
+        >
+    }
   >
 {
-  readonly layer: Layer.Layer<Self, never, Context.Tag.Identifier<MiddlewareProviders[number]>>
+  readonly layer: Layer.Layer<Self, never, ServiceMap.Service.Identifier<MiddlewareProviders[number]>>
   readonly requestContext: RequestContextTag<RequestContextMap>
   readonly requestContextMap: RequestContextMap
 }
 
 export interface RequestContextTag<RequestContextMap extends Record<string, RpcContextMap.Any>>
-  extends Context.Tag<"RequestContextConfig", GetContextConfig<RequestContextMap>>
+  extends ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>
 {}
 
 export namespace MiddlewareMaker {
@@ -77,7 +92,7 @@ export namespace MiddlewareMaker {
     : never
     : never
 
-  export type Errors<T> = T extends TagClassAny ? T extends { failure: S.Schema.Any } ? S.Schema.Type<T["failure"]>
+  export type Errors<T> = T extends TagClassAny ? T extends { error: S.Top } ? S.Schema.Type<T["error"]>
     : never
     : never
 
@@ -153,9 +168,9 @@ export interface BuildingMiddleware<
 > {
   rpc: <
     const Tag extends string,
-    Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
-    Success extends Schema.Schema.Any = typeof Schema.Void,
-    Error extends Schema.Schema.All = typeof Schema.Never,
+    Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
+    Success extends Schema.Top = typeof Schema.Void,
+    Error extends Schema.Top = typeof Schema.Never,
     const Stream extends boolean = false,
     Config extends GetContextConfig<RequestContextMap> = {}
   >(tag: Tag, options?: {
@@ -164,8 +179,9 @@ export interface BuildingMiddleware<
     readonly error?: Error
     readonly stream?: Stream
     readonly config?: Config
-    readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
-      ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+    readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
+        payload: Payload extends Schema.Struct.Fields ? Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+      ) => string)
       : never
   }) =>
     & Rpc.Rpc<
@@ -258,29 +274,31 @@ const middlewareMaker = <
   middlewares = middlewares.toReversed() as any
 
   return Effect.gen(function*() {
-    const context = yield* Effect.context()
+    const context = yield* Effect.services()
 
     // returns a Effect/RpcMiddlewareV4 with Scope.Scope in requirements
+    // v4: wrap middleware takes (effect, options) as two params instead of a single options bag
     return (
-      _options: Parameters<
-        RpcMiddleware.RpcMiddlewareWrap<
-          MiddlewareMaker.ManyProvided<MiddlewareProviders>,
-          never
-        >
-      >[0]
+      next: Effect.Effect<any, any, any>,
+      options: {
+        readonly clientId: number
+        readonly requestId: RequestId
+        readonly rpc: Rpc.AnyWithProps
+        readonly payload: unknown
+        readonly headers: HttpHeaders.Headers
+      }
     ) => {
-      const { next, ...options } = _options
       // we start with the actual handler
       let handler = next
 
       // inspired from Effect/RpcMiddleware
       for (const tag of middlewares) {
         // use the tag to get the middleware from context
-        const middleware = Context.unsafeGet(context, tag)
+        const middleware = ServiceMap.getUnsafe(context, tag)
 
         // wrap the current handler, allowing the middleware to run before and after it
         handler = PreludeLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
-          Effect.zipRight(middleware(handler, options))
+          Effect.andThen(middleware(handler, options))
         ) as any
       }
       return handler
@@ -302,15 +320,17 @@ const makeMiddlewareBasic = <Self>() =>
   // reverse middlewares and wrap one after the other
   const middleware = middlewareMaker(make)
 
-  const failures = make.map((_) => _.failure).filter(Boolean)
+  const failures = make.map((_) => _.error).filter(Boolean)
   const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides])
   const requires = make
     .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
     .filter((_) => !provides.includes(_))
 
+  const [firstFailure, ...restFailures] = failures
+
   const MiddlewareMaker = RpcMiddlewareX.Tag<Self>()(id, {
-    failure: (failures.length > 0
-      ? S.Union(...failures)
+    error: (firstFailure
+      ? S.Union([firstFailure, ...restFailures])
       : S.Never) as unknown as MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? never
         : S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>,
     requires: (requires.length > 0
@@ -329,17 +349,16 @@ const makeMiddlewareBasic = <Self>() =>
     provides: (provides.length > 0
       ? provides
       : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never
-        : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>,
-    wrap: true
+        : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>
   })
 
   const layer = Layer
-    .scoped(
+    .effect(
       MiddlewareMaker,
       middleware as Effect.Effect<
-        any, // TODO: why ?
-        Effect.Effect.Error<typeof middleware>,
-        Effect.Effect.Context<typeof middleware>
+        any,
+        Effect.Error<typeof middleware>,
+        Effect.Services<typeof middleware>
       >
     )
 
@@ -347,7 +366,7 @@ const makeMiddlewareBasic = <Self>() =>
   return Object.assign(MiddlewareMaker, {
     layer,
     // tag to be used to retrieve the RequestContextConfig from Rpc annotations
-    requestContext: Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+    requestContext: ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
       "RequestContextConfig"
     ),
     requestContextMap: rcm
@@ -360,7 +379,7 @@ export const Tag = <Self>() =>
   RequestContextMap extends RequestContextMapTagAny
 >(id: Id, rcm: RequestContextMap): MiddlewaresBuilder<Self, Id, RequestContextMap["config"]> => {
   let allMiddleware: MiddlewareMaker.Any[] = []
-  const requestContext = Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
+  const requestContext = ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
     "RequestContextConfig"
   )
   const it = {
@@ -368,9 +387,9 @@ export const Tag = <Self>() =>
     // rpc with config
     rpc: <
       const Tag extends string,
-      Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
-      Success extends Schema.Schema.Any = typeof Schema.Void,
-      Error extends Schema.Schema.All = typeof Schema.Never,
+      Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
+      Success extends Schema.Top = typeof Schema.Void,
+      Error extends Schema.Top = typeof Schema.Never,
       const Stream extends boolean = false,
       Config extends GetContextConfig<RequestContextMap["config"]> = {}
     >(tag: Tag, options?: {
@@ -379,8 +398,9 @@ export const Tag = <Self>() =>
       readonly error?: Error
       readonly stream?: Stream
       readonly config?: Config
-      readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
-        ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+      readonly primaryKey?: [Payload] extends [Schema.Struct.Fields] ? ((
+          payload: Payload extends Schema.Struct.Fields ? Simplify<Schema.Struct<Payload>["Type"]> : Payload["Type"]
+        ) => string)
         : never
     }):
       & Rpc.Rpc<
@@ -398,9 +418,18 @@ export const Tag = <Self>() =>
       // TODO: we should only include errors that are relevant based on the middleware config.ks
       const error = options?.error
       const errors = typedValuesOf(rcm.config).map((_) => _.error).filter((_) => _ && _ !== S.Never) // TODO: only the errors relevant based on config
-      const newError = error ? S.Union(error, ...errors) : S.Union(...errors)
-
-      const rpc = Rpc.make(tag, { ...options, error: newError }) as any
+      const allErrors = error ? [error, ...errors] : errors
+      const [firstError, ...restErrors] = allErrors
+      const newError = firstError ? S.Union([firstError, ...restErrors]) : S.Never
+
+      // @ts-expect-error — TypeScript can't prove Simplify<T> ≡ { [K in keyof T]: T[K] } for unresolved generics (primaryKey)
+      const rpc = Rpc.make(tag, {
+        ...options?.payload !== undefined ? { payload: options.payload } : {},
+        ...options?.success !== undefined ? { success: options.success } : {},
+        error: newError,
+        ...options?.stream !== undefined ? { stream: options.stream } : {},
+        ...options?.primaryKey !== undefined ? { primaryKey: options.primaryKey } : {}
+      }) as any
 
       return Object.assign(rpc.annotate(requestContext, config), { config })
     },
@@ -422,7 +451,7 @@ export const Tag = <Self>() =>
 // alternatively consider group.serverMiddleware? hmmm
 export const middlewareGroup = <
   RequestContextMap extends Record<string, RpcContextMap.Any>,
-  Middleware extends RpcMiddleware.TagClassAny & {
+  Middleware extends RpcMiddlewareX.TagClassAny & {
     readonly requestContext: RequestContextTag<RequestContextMap>
     readonly requestContextMap: RequestContextMap
   }

package/src/rpc/RpcContextMap.ts

@@ -2,14 +2,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type AnyWithProps } from "@effect/rpc/Rpc"
-import { Context, type Schema as S } from "effect"
+import { type Schema as S, ServiceMap } from "effect"
+import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
 import { type RpcDynamic } from "./RpcMiddleware.js"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 
 /**
- * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect Context.
+ * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect ServiceMap.
  * Unless explicitly configured as `true`.
  */
 export type RpcContextMap<Service, E> = {
@@ -22,7 +22,7 @@ export type RpcContextMap<Service, E> = {
 
 export declare namespace RpcContextMap {
   /**
-   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect Context.
+   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect ServiceMap.
    * Unless explicitly omitted.
    */
   export type Inverted<Service, E> = {
@@ -41,7 +41,7 @@ export declare namespace RpcContextMap {
 
   export type Any = {
     service: any
-    error: S.Schema.All
+    error: S.Top
     contextActivation: any
     inverted: boolean
   }
@@ -97,7 +97,7 @@ export type GetEffectError<RequestContextMap extends Record<string, RpcContextMa
   }
 >
 
-const tag = Context.GenericTag("RequestContextConfig")
+const tag = ServiceMap.Service("RequestContextConfig")
 
 export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(config: Config) => {
   const cls = class {
@@ -109,7 +109,7 @@ export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(
   return Object.assign(cls, {
     config, /** Retrieves RequestContextConfig out of the Rpc annotations */
     getConfig: (rpc: AnyWithProps): GetContextConfig<Config> => {
-      return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
+      return ServiceMap.getOrElse(rpc.annotations, tag as any, () => ({}))
     },
     /** Adapter used when setting the dynamic prop on a middleware implementation */
     get: <

package/src/rpc/RpcMiddleware.ts

@@ -1,28 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Rpc, RpcMiddleware } from "@effect/rpc"
-import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
-import { type Context, type Effect, type Schema, type Schema as S, type Scope, type Stream, Unify } from "effect"
-import { type HttpHeaders } from "effect-app/http"
+import { type Effect, type Schema, type Schema as S, type Scope, type ServiceMap, type Stream } from "effect"
 import { type NonEmptyReadonlyArray } from "effect/Array"
-import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
-import { type ReadonlyMailbox } from "effect/Mailbox"
+import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
+import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
 import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
 
-// updated to support Scope.Scope and follow V4: Provides/Requires as Identifiers instead of Tag, wrap is default
-export interface RpcMiddlewareV4<Provides, E, Requires> {
-  (effect: Effect.Effect<SuccessValue, E, Provides | Scope.Scope | Requires>, options: {
-    readonly clientId: number
-    readonly rpc: Rpc.AnyWithProps
-    readonly payload: unknown
-    readonly headers: HttpHeaders.Headers
-  }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
-}
+export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
 
 export type RpcOptionsOriginal = {
   readonly optional?: boolean
-  readonly failure?: Schema.Schema.All
+  readonly error?: Schema.Top
   readonly requiredForClient?: boolean
 }
 
@@ -44,27 +33,13 @@ export interface RpcOptionsDynamic<Key extends string, A extends RpcContextMap.A
 
 export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
 
-export interface RpcMiddlewareDynamic<E, R, _Config> {
-  (effect: Effect.Effect<SuccessValue, E, Scope.Scope | R>, options: {
-    readonly clientId: number
-    readonly rpc: Rpc.AnyWithProps
-    readonly payload: unknown
-    readonly headers: HttpHeaders.Headers
-  }): Effect.Effect<
-    SuccessValue,
-    E,
-    Scope.Scope | R
-  >
-}
+export interface RpcMiddlewareDynamic<E, R, _Config> extends RpcMiddleware.RpcMiddleware<never, E, R> {}
 
-export interface TagClassAny extends Context.Tag<any, any> {
-  readonly [TypeId]: TypeId
+export interface TagClassAny extends RpcMiddleware.AnyService {
   readonly optional: boolean
   readonly provides: any
   readonly requires: any
-  readonly failure: Schema.Schema.All
-  readonly requiredForClient: boolean
-  readonly wrap: true
+  readonly error: Schema.Top
   readonly dynamic?: RpcDynamic<any, any> | undefined
   readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
@@ -74,8 +49,8 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureSchema<Options> = Options extends
-    { readonly failure: Schema.Schema.All; readonly optional?: false } ? Options["failure"]
+  export type FailureSchema<Options> = Options extends { readonly error: Schema.Top; readonly optional?: false }
+    ? Options["error"]
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     // : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
     : typeof Schema.Never
@@ -84,8 +59,8 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type Failure<Options> = Options extends
-    { readonly failure: Schema.Schema<infer _A, infer _I, infer _R>; readonly optional?: false } ? _A
+  export type Failure<Options> = Options extends { readonly error: Schema.Schema<infer _A>; readonly optional?: false }
+    ? _A
     // actually not, the Failure depends on Dynamic Middleware Configuration!
     : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
     : never
@@ -94,7 +69,7 @@ export declare namespace TagClass {
    * @since 1.0.0
    * @category models
    */
-  export type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>
+  export type FailureContext<Options> = Schema.Codec.DecodingServices<FailureSchema<Options>>
 
   /**
    * @since 1.0.0
@@ -127,18 +102,18 @@ export declare namespace TagClass {
       requires?: any
       provides?: any
     }
-  > extends Context.Tag<Self, Service> {
-    new(_: never): Context.TagClassShape<Name, Service>
+  > extends ServiceMap.Service<Self, Service> {
+    new(_: never): ServiceMap.ServiceClass.Shape<Name, Service>
     readonly [TypeId]: TypeId
     readonly optional: Optional<Options>
-    readonly failure: FailureSchema<Options>
+    readonly error: FailureSchema<Options>
+    readonly "~ClientError": Options extends { readonly clientError: infer CE } ? CE : never
     readonly provides: "provides" extends keyof Config ? Config["provides"] : never
     readonly requires: "requires" extends keyof Config ? Config["requires"] : never
     readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
       : undefined
     readonly dependsOn: Options extends DependsOn ? Options["dependsOn"] : undefined
     readonly requiredForClient: RequiredForClient<Options>
-    readonly wrap: true
   }
 }
 
@@ -183,18 +158,15 @@ export const Tag = <
   id: Name,
   options?: Options
 ): TagClass<Self, Name, Options, Config> =>
-  class extends RpcMiddleware.Tag<Self>()(id, options) {
+  class extends RpcMiddleware.Service<Self>()(id, options as any) {
     static readonly requires: "requires" extends keyof Config ? Config["requires"] : never
-    static override readonly provides: "provides" extends keyof Config ? Config["provides"] : never
+    static readonly provides: "provides" extends keyof Config ? Config["provides"] : never
     static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
     static readonly dependsOn = options && "dependsOn" in options ? options.dependsOn : undefined
-    static override [Unify.typeSymbol]?: unknown
-    static override [Unify.unifySymbol]?: TagUnify<typeof this>
-    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
   } as any
 
 // not needed if there's official support in Rpc.Rpc.
-export type AddMiddleware<R extends Rpc.Any, Middleware extends RpcMiddleware.TagClassAny> = R extends Rpc.Rpc<
+export type AddMiddleware<R extends Rpc.Any, Middleware extends RpcMiddleware.AnyServiceWithProps> = R extends Rpc.Rpc<
   infer _Tag,
   infer _Payload,
   infer _Success,
@@ -221,13 +193,13 @@ export type HandlerContext<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler
     | Stream.Stream<infer _A, infer _E, infer _R>
     | Rpc.Wrapper<Stream.Stream<infer _A, infer _E, infer _R>>
     | Effect.Effect<
-      ReadonlyMailbox<infer _A, infer _E>,
+      infer _A,
       infer _EX,
       infer _R
     >
     | Rpc.Wrapper<
       Effect.Effect<
-        ReadonlyMailbox<infer _A, infer _E>,
+        infer _A,
         infer _EX,
         infer _R
       >
@@ -241,7 +213,7 @@ export type HandlerContext<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler
 
 // new
 export type ExtractDynamicallyProvides<R extends Rpc.Any, Tag extends string> = R extends
-  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
     readonly requestContextMap: infer _RC
   } ? _RC extends Record<string, RpcContextMap.Any> // ? GetEffectContext<_RC, { allowAnonymous: false }>
       ? R extends { readonly config: infer _C } ? GetEffectContext<_RC, _C>
@@ -251,9 +223,11 @@ export type ExtractDynamicallyProvides<R extends Rpc.Any, Tag extends string> =
   : never
 
 export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
-  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
-    readonly provides: Context.Tag<infer _I, infer _S>
-  } ? _I
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
+    readonly provides: infer _P
+  } ? [_P] extends [never] ? never
+    : _P extends ServiceMap.Service<infer _I, infer _S> ? _I
+    : never
   : never
   : never
 

package/src/utils/effectify.ts

@@ -245,7 +245,7 @@ export const effectify: {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
   (...args: Array<any>) =>
-    Effect.async<A, Error>((resume) => {
+    Effect.callback<A, Error>((resume) => {
       try {
         fn(...args, (err: Error | null, result: A) => {
           if (err) {

package/src/utils/gen.ts

@@ -1,22 +1,24 @@
-import { type Effect } from "effect/Effect"
-import { type YieldWrap } from "effect/Utils"
+import { type Effect, type Yieldable } from "effect/Effect"
 
 export namespace EffectGenUtils {
   export type Success<EG> = EG extends Effect<infer A, infer _E, infer _R> ? A
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer A, infer _2> ? A
-    : EG extends (..._: infer _3) => Generator<YieldWrap<Effect<infer _, infer _E, infer _R>>, infer A, infer _2> ? A
+    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
+    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer _R>, infer A, infer _2> ? A
     : never
 
   export type Error<EG> = EG extends Effect<infer _A, infer E, infer _R> ? E
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    : EG extends (..._: infer _3) => Generator<YieldWrap<Effect<infer _, infer E, infer _R>>, infer _A, infer _2> ? E
+    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
+    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer E, infer _R>, infer _A, infer _2> ? E
     : never
 
-  export type Context<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
+  export type ServiceMap<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
-    : EG extends (..._: infer _3) => Generator<YieldWrap<Effect<infer _, infer _E, infer R>>, infer _A, infer _2> ? R
+    // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()
+    : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer _E, infer R>, infer _A, infer _2> ? R
     : never
 }