effect-app 3.16.0 → 4.0.0-beta.1

package/src/client/apiClientFactory.ts

@@ -1,45 +1,46 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "@effect/rpc"
 import * as Config from "effect/Config"
 import { flow } from "effect/Function"
-import * as HashMap from "effect/HashMap"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
 import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
 import * as Struct from "effect/Struct"
-import * as Context from "../Context.js"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientRequest } from "../http.js"
 import * as Option from "../Option.js"
 import type * as S from "../Schema.js"
+import * as ServiceMap from "../ServiceMap.js"
 import { typedKeysOf, typedValuesOf } from "../utils.js"
 import type { Client, ClientForOptions, Requests, RequestsAny } from "./clientFor.js"
 
 export interface ApiConfig {
   url: string
-  headers: Option.Option<HashMap.HashMap<string, string>>
+  headers: Option.Option<Record<string, string>>
 }
 
 export const DefaultApiConfig = Config.all({
   url: Config.string("apiUrl").pipe(Config.withDefault("/api")),
   headers: Config
-    .hashMap(
-      Config.string(),
+    .schema(
+      Config.Record(Schema.String, Schema.String),
       "headers"
     )
     .pipe(Config.option)
 })
 
-export type Req = S.Schema.All & {
+export type Req = S.Top & {
   new(...args: any[]): any
   _tag: string
   fields: S.Struct.Fields
-  success: S.Schema.All
-  failure: S.Schema.All
+  success: S.Top
+  error: S.Top
   config?: Record<string, any>
+  readonly "~decodingServices"?: unknown
 }
 
-class RequestName extends Context.Reference<RequestName>()("RequestName", {
+class RequestName extends ServiceMap.Reference("RequestName", {
   defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
 }) {}
 
@@ -49,29 +50,28 @@ export const HttpClientLayer = (config: ApiConfig) =>
     Effect
       .gen(function*() {
         const baseClient = yield* HttpClient.HttpClient
+        const ctx = yield* RequestName
         const client = baseClient.pipe(
           HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
           HttpClient.mapRequest(
-            HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => HashMap.empty())))
+            HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
-          HttpClient.mapRequestEffect((req) =>
-            RequestName.pipe(
-              Effect.map((ctx) =>
-                flow(
-                  HttpClientRequest.appendUrlParam("action", ctx.requestName),
-                  HttpClientRequest.appendUrl("/" + ctx.moduleName)
-                )(req)
-              )
-            )
+          HttpClient.mapRequest((req) =>
+            flow(
+              HttpClientRequest.appendUrlParam("action", ctx.requestName),
+              HttpClientRequest.appendUrl("/" + ctx.moduleName)
+            )(req)
           )
         )
         return client
       })
   )
 
-export const HttpClientFromConfigLayer = DefaultApiConfig.pipe(
-  Effect.map(HttpClientLayer),
-  Layer.unwrapEffect
+export const HttpClientFromConfigLayer = Layer.unwrap(
+  Effect.gen(function*() {
+    const config = yield* DefaultApiConfig
+    return HttpClientLayer(config)
+  })
 )
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
@@ -81,7 +81,7 @@ export const RpcSerializationLayer = (config: ApiConfig) =>
   )
 
 type RpcHandlers<M extends RequestsAny> = {
-  [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["failure"]>
+  [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["error"]>
 }
 
 const getFiltered = <M extends Requests>(resource: M) => {
@@ -94,7 +94,7 @@ const getFiltered = <M extends Requests>(resource: M) => {
       Predicate.isObject(resource[cur])
       && (resource[cur].success)
     ) {
-      acc[cur as keyof Filtered] = resource[cur]
+      acc[cur as keyof Filtered] = resource[cur] as any
     }
     return acc
   }, {} as Record<keyof Filtered, Req>)
@@ -117,7 +117,7 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const
   const rpcs = RpcGroup
     .make(
       ...typedValuesOf(filtered).map((_) => {
-        return Rpc.fromTaggedRequest(_ as any)
+        return Rpc.make((_ as any)._tag, { payload: _ as any, success: (_ as any).success, error: (_ as any).error })
       })
     )
     .prefix(`${moduleName}.`) as unknown as RpcGroup.RpcGroup<
@@ -137,23 +137,26 @@ const makeRpcTag = <M extends Requests>(resource: M) => {
   const meta = getMeta(resource)
   const rpcs = makeRpcGroupFromRequestsAndModuleName(resource, meta.moduleName)
 
-  return class TheClient extends Context.Tag(`RpcClient.${meta.moduleName}`)<
-    TheClient,
+  // Use Object.assign instead of class extension to avoid TS2509 with complex generic return types.
+  // The first type arg is `any` because this is a dynamically created tag — its identity is the string key.
+  const TheClient = ServiceMap.Opaque<
+    any,
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
-  >() {
-    static layer = Layer.scoped(
-      TheClient,
-      Effect.map(
-        RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName }),
-        (cl) => (cl as any)[meta.moduleName]
-      )
+  >()(`RpcClient.${meta.moduleName}`)
+  // Use Layer.effect directly (not TheClient.toLayer) so TypeScript properly excludes Scope
+  const layer = Layer.effect(
+    TheClient,
+    Effect.map(
+      RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName }),
+      (cl) => (cl as any)[meta.moduleName]
     )
-  }
+  )
+  return Object.assign(TheClient, { layer })
 }
 
 const makeApiClientFactory = Effect
   .gen(function*() {
-    const ctx = yield* Effect.context<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
+    const ctx = yield* Effect.services<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
     const makeClientFor = <M extends Requests>(
       resource: M,
       requestLevelLayers = Layer.empty,
@@ -176,7 +179,7 @@ const makeApiClientFactory = Effect
                 url: "" // why not here set meta.moduleName as root?
               })
               .pipe(
-                Layer.provideMerge(Layer.succeedContext(ctx))
+                Layer.provideMerge(Layer.succeedServices(ctx))
               )
           )
         )
@@ -207,28 +210,36 @@ const makeApiClientFactory = Effect
 
               const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
 
-              const fields = Struct.omit(Request.fields, "_tag")
+              const fields = Struct.omit(Request.fields, ["_tag"] as const)
               const requestAttr = h._tag
               // @ts-expect-error doc
               prev[cur] = Object.keys(fields).length === 0
                 ? {
-                  handler: TheClient.pipe(
-                    Effect.flatMap((client) =>
-                      (client as any)[requestAttr]!(new Request()) as Effect.Effect<any, any, never>
-                    ),
-                    Effect.provide(layers),
-                    Effect.provide(mr)
+                  handler: mr.servicesEffect.pipe(
+                    Effect.flatMap((svcs) =>
+                      TheClient
+                        .use((client) => (client as any)[requestAttr]!(new Request()) as Effect.Effect<any, any, never>)
+                        .pipe(
+                          Effect.provide(layers),
+                          Effect.provide(svcs)
+                        )
+                    )
                   ),
                   ...requestMeta
                 }
                 : {
                   handler: (req: any) =>
-                    TheClient.pipe(
-                      Effect.flatMap((client) =>
-                        (client as any)[requestAttr]!(new Request(req)) as Effect.Effect<any, any, never>
-                      ),
-                      Effect.provide(layers),
-                      Effect.provide(mr)
+                    mr.servicesEffect.pipe(
+                      Effect.flatMap((svcs) =>
+                        TheClient
+                          .use((client) =>
+                            (client as any)[requestAttr]!(new Request(req)) as Effect.Effect<any, any, never>
+                          )
+                          .pipe(
+                            Effect.provide(layers),
+                            Effect.provide(svcs)
+                          )
+                      )
                     ),
 
                   ...requestMeta
@@ -273,20 +284,24 @@ const makeApiClientFactory = Effect
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends Context.TagId("ApiClientFactory")<ApiClientFactory, Effect.Effect.Success<typeof makeApiClientFactory>>()
+  extends ServiceMap.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
 {
   static readonly layer = (config: ApiConfig) =>
-    this.toLayerScoped(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))
-  static readonly layerFromConfig = DefaultApiConfig.pipe(Effect.map(this.layer), Layer.unwrapEffect)
+    ApiClientFactory.toLayer(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))
+  static readonly layerFromConfig = Layer.unwrap(
+    Effect.gen(function*() {
+      const config = yield* DefaultApiConfig
+      return ApiClientFactory.layer(config)
+    })
+  )
 
   static readonly makeFor =
     (requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) =>
     <M extends Requests>(
       resource: M
     ) =>
-      this
-        .use((apiClientFactory) => apiClientFactory(requestLevelLayers, options))
-        .pipe(
-          Effect.flatMap((f) => f(resource))
-        ) // don't rename f to clientFor or integration in vue project linked fucks up
+      ApiClientFactory.use((apiClientFactory) => {
+        const f = apiClientFactory(requestLevelLayers, options)
+        return f(resource)
+      })
 }

package/src/client/clientFor.ts

@@ -58,18 +58,19 @@ export type Client<M extends RequestsAny, ModuleName extends string> = RequestHa
   ModuleName
 >
 
-export type ExtractResponse<T> = T extends S.Schema<any, any, any> ? S.Schema.Type<T>
+export type ExtractResponse<T> = T extends S.Schema<any> ? S.Schema.Type<T>
   : T extends unknown ? void
   : never
 
-export type ExtractEResponse<T> = T extends S.Schema<any, any, any> ? S.Schema.Encoded<T>
+export type ExtractEResponse<T> = T extends S.Schema<any> ? S.Codec.Encoded<T>
   : T extends unknown ? void
   : never
 
 type IsEmpty<T> = keyof T extends never ? true
   : false
 
-type Cruft = "_tag" | Request.RequestTypeId | typeof S.symbolSerializable | typeof S.symbolWithResult
+// v4: Request.RequestTypeId, S.symbolSerializable, S.symbolWithResult removed — use keyof Request to filter internal props
+type Cruft = "_tag" | keyof Request.Request<any, any, any>
 
 export interface ClientForOptions {
   readonly skipQueryKey?: readonly string[]
@@ -90,20 +91,22 @@ export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id ext
 }
 
 // make sure this is exported or d.ts of apiClientFactory breaks?!
+type ReqDecodingServices<M> = M extends { readonly "~decodingServices": infer DS } ? DS : never
+
 export type RequestHandlers<R, E, M extends RequestsAny, ModuleName extends string> = {
   [K in keyof M as M[K] extends Req ? K : never]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true
     ? RequestHandler<
       S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["failure"]> | E,
-      R | S.Schema.Context<M[K]["success"]> | S.Schema.Context<M[K]["failure"]>,
+      S.Schema.Type<M[K]["error"]> | E,
+      R | ReqDecodingServices<M[K]>,
       M[K],
       `${ModuleName}.${K & string}`
     >
     : RequestHandlerWithInput<
       Omit<S.Schema.Type<M[K]>, Cruft>,
       S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["failure"]> | E,
-      R | S.Schema.Context<M[K]["success"]> | S.Schema.Context<M[K]["failure"]>,
+      S.Schema.Type<M[K]["error"]> | E,
+      R | ReqDecodingServices<M[K]>,
       M[K],
       `${ModuleName}.${K & string}`
     >

package/src/client/errors.ts

@@ -1,7 +1,6 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
 import { TaggedError } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
-import { makeFiberFailure } from "effect/Runtime"
 import * as S from "../Schema.js"
 
 export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
@@ -27,13 +26,13 @@ export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<
   id: S.Unknown
 }) {
   constructor(
-    props: S.Struct.Constructor<typeof NotFoundError.fields> & { cause?: unknown },
+    props: { type: string; id: unknown; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props, disableValidation)
+    super(props as any, disableValidation as any)
   }
   override get message() {
-    return `Didn't find ${this.type}#${JSON.stringify(this.id)}`
+    return `Didn't find ${(this as any).type}#${JSON.stringify((this as any).id)}`
   }
 }
 
@@ -44,7 +43,7 @@ export class InvalidStateError extends TaggedError<InvalidStateError>()("Invalid
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
   }
 }
 
@@ -52,7 +51,7 @@ export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
   }
 }
 
@@ -60,13 +59,13 @@ export class ValidationError extends TaggedError<ValidationError>()("ValidationE
   errors: S.Array(S.Unknown)
 }) {
   constructor(
-    props: S.Struct.Constructor<typeof ValidationError.fields> & { cause?: unknown },
+    props: { errors: ReadonlyArray<unknown>; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props, disableValidation)
+    super(props as any, disableValidation as any)
   }
   override get message() {
-    return `Validation failed: ${this.errors.map((e) => JSON.stringify(e, undefined, 2)).join(",\n")}`
+    return `Validation failed: ${(this as any).errors.map((e: any) => JSON.stringify(e, undefined, 2)).join(",\n")}`
   }
 }
 
@@ -74,7 +73,7 @@ export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLogged
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject), disableValidation)
+    super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
 }
 
@@ -85,7 +84,7 @@ export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject), disableValidation)
+    super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
 }
 
@@ -93,7 +92,7 @@ export class UnauthorizedError extends TaggedError<UnauthorizedError>()("Unautho
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject), disableValidation)
+    super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
 }
 
@@ -114,10 +113,10 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
   constructor(
     args:
       | OptimisticConcurrencyDetails
-      | (S.Struct.Constructor<typeof OptimisticConcurrencyException.fields> & { cause?: unknown; raw?: unknown }),
+      | ({ message: string; cause?: unknown; raw?: unknown }),
     disableValidation?: boolean
   ) {
-    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` }, disableValidation)
+    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any, disableValidation as any)
     if (!("message" in args)) {
       this.details = args
     }
@@ -138,10 +137,10 @@ const GeneralErrors = [
   ServiceUnavailableError
 ] as const
 
-export const SupportedErrors = S.Union(
+export const SupportedErrors = S.Union([
   ...MutationOnlyErrors,
   ...GeneralErrors
-)
+])
 // .pipe(named("SupportedErrors"))
 // .pipe(withDefaultMake)
 export type SupportedErrors = S.Schema.Type<typeof SupportedErrors>
@@ -175,11 +174,18 @@ export class CauseException<E> extends Error {
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
-    const ff = makeFiberFailure(originalCause)
-    this.name = ff.name
-    this.message = ff.message
-    if (ff.stack) {
-      this.stack = ff.stack
+    // v4: makeFiberFailure removed — use Cause.prettyErrors instead
+    const errors = Cause.prettyErrors(originalCause)
+    const first = errors[0]
+    if (first) {
+      this.name = first.name
+      this.message = first.message
+      if (first.stack) {
+        this.stack = first.stack
+      }
+    } else {
+      this.name = "CauseException"
+      this.message = Cause.pretty(originalCause)
     }
   }
   toReport() {
@@ -203,7 +209,7 @@ export class CauseException<E> extends Error {
     return this.toJSON()
   }
   override toString() {
-    return `[${this._tag}] ` + Cause.pretty(this.originalCause, { renderErrorCause: true })
+    return `[${this._tag}] ` + Cause.pretty(this.originalCause)
   }
 }
 

package/src/client/makeClient.ts

@@ -1,144 +1,119 @@
-import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
+import { type GetContextConfig, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
 
-// TODO: Fix error types... (?)
-type JoinSchema<T> = T extends ReadonlyArray<S.Schema.All> ? S.Union<T> : typeof S.Never
-
 const merge = (a: any, b: Array<any>) =>
-  a !== undefined && b.length ? S.Union(a, ...b) : a !== undefined ? a : b.length ? S.Union(...b) : S.Never
-
-/**
- * Converts struct fields to TypeLiteral schema, or returns existing schema.
- *
- * @example
- * ```typescript
- * type Fields = { name: S.String; age: S.Number }
- * type Schema = SchemaOrFields<Fields>
- * // Result: S.TypeLiteral<Fields, []>
- *
- * type Existing = S.String
- * type Same = SchemaOrFields<Existing>
- * // Result: S.String
- * ```
- */
-type SchemaOrFields<T> = T extends S.Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never
+  a !== undefined && b.length ? S.Union([a, ...b]) : a !== undefined ? a : b.length ? S.Union(b) : S.Never
 
 /**
  * Whatever the input, we will only decode or encode to void
  */
-const ForceVoid: S.Schema<void> = S.transform(S.Any, S.Void, { decode: () => void 0, encode: () => void 0 })
+const ForceVoid: S.Schema<void> = S.Void as any
+
+type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
+
+type TaggedRequestResult<
+  Tag extends string,
+  Payload extends S.Struct.Fields,
+  Success extends S.Top,
+  Error extends S.Top,
+  Config = Record<string, never>
+> =
+  & S.TaggedStruct<Tag, Payload>
+  & {
+    new(...args: any[]): any
+    readonly _tag: Tag
+    readonly fields: { readonly _tag: S.tag<Tag> } & Payload
+    readonly success: Success
+    readonly error: Error
+    readonly config: Config
+    readonly "~decodingServices": S.Codec.DecodingServices<Success> | S.Codec.DecodingServices<Error>
+  }
 
 export const makeRpcClient = <
   RequestContextMap extends RequestContextMapTagAny,
-  GeneralErrors extends S.Schema.All = never
+  GeneralErrors extends S.Top = never
 >(rcs: RequestContextMap, generalErrors?: GeneralErrors) => {
-  // Long way around Context/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
-  type Context = {
-    success: S.Schema.Any | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
-    failure: S.Schema.Any | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
+  // Long way around ServiceMap/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
+  type ServiceMap = {
+    success: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
+    error: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
   }
 
   type RequestConfig = GetContextConfig<RequestContextMap["config"]>
 
-  function TaggedRequest<Self>(): {
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Context>(
+  type MergeError<E> = [GeneralErrors] extends [never] ? SchemaOrFields<E> : S.Union<[SchemaOrFields<E>, GeneralErrors]>
+  type ErrorResult<C> = C extends { error: infer E } ? MergeError<E>
+    : [GeneralErrors] extends [never] ? S.Void
+    : GeneralErrors
+
+  function TaggedRequest<_Self>(): {
+    <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
       tag: Tag,
       fields: Payload,
       config: RequestConfig & C
-    ):
-      & S.TaggedRequestClass<
-        Self,
-        Tag,
-        { readonly _tag: S.tag<Tag> } & Payload,
-        SchemaOrFields<typeof config["success"]>,
-        JoinSchema<
-          [SchemaOrFields<typeof config["failure"]> | GetEffectError<RequestContextMap["config"], C> | GeneralErrors]
-        >
-      >
-      & { config: Omit<C, "success" | "failure"> }
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<Context, "success">>(
+    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
+    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "success">>(
       tag: Tag,
       fields: Payload,
       config: RequestConfig & C
-    ):
-      & S.TaggedRequestClass<
-        Self,
-        Tag,
-        { readonly _tag: S.tag<Tag> } & Payload,
-        SchemaOrFields<typeof config["success"]>,
-        JoinSchema<[GetEffectError<RequestContextMap["config"], C> | GeneralErrors]>
-      >
-      & { config: Omit<C, "success" | "failure"> }
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<Context, "failure">>(
+    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
+    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "error">>(
       tag: Tag,
       fields: Payload,
       config: RequestConfig & C
-    ):
-      & S.TaggedRequestClass<
-        Self,
-        Tag,
-        { readonly _tag: S.tag<Tag> } & Payload,
-        typeof S.Void,
-        JoinSchema<
-          [SchemaOrFields<typeof config["failure"]> | GetEffectError<RequestContextMap["config"], C> | GeneralErrors]
-        >
-      >
-      & { config: Omit<C, "success" | "failure"> }
+    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<C>, Omit<C, "success" | "error">>
     <Tag extends string, Payload extends S.Struct.Fields, C extends Record<string, any>>(
       tag: Tag,
       fields: Payload,
       config: C & RequestConfig
-    ):
-      & S.TaggedRequestClass<
-        Self,
-        Tag,
-        { readonly _tag: S.tag<Tag> } & Payload,
-        typeof S.Void,
-        JoinSchema<[GetEffectError<RequestContextMap["config"], C> | GeneralErrors]>
-      >
-      & { config: Omit<C, "success" | "failure"> }
+    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<C>, Omit<C, "success" | "error">>
     <Tag extends string, Payload extends S.Struct.Fields>(
       tag: Tag,
       fields: Payload
-    ):
-      & S.TaggedRequestClass<
-        Self,
-        Tag,
-        { readonly _tag: S.tag<Tag> } & Payload,
-        typeof S.Void,
-        GeneralErrors extends never ? typeof S.Never : GeneralErrors
-      >
-      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      & { config: {} }
+    ): TaggedRequestResult<Tag, Payload, S.Schema<void>, ErrorResult<never>, Record<string, never>>
   } {
     // TODO: filter errors based on config + take care of inversion
     const errorSchemas = Object.values(rcs.config).map((_) => _.error)
-    return (<Tag extends string, Fields extends S.Struct.Fields, C extends Context>(
+    return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
       tag: Tag,
       fields: Fields,
       config?: C
     ) => {
-      // S.TaggedRequest is a factory function that creates a TaggedRequest class
-      const req = S.TaggedRequest<Self>()(tag, {
-        payload: fields,
-        // ensure both failure and success are schemas
-        failure: merge(
-          config?.failure ? S.isSchema(config.failure) ? config.failure : S.Struct(config.failure) : undefined,
-          [...errorSchemas, generalErrors].filter(Boolean)
-        ),
-        success: config?.success
-          ? S.isSchema(config.success)
-            ? AST.isVoidKeyword(config.success.ast) ? ForceVoid : config.success
-            : S.Struct(config.success)
-          : ForceVoid
-      })
-      return class extends (Object.assign(req, { config }) as any) {
-        constructor(payload: any, disableValidation: any = true) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          super(payload, disableValidation)
+      // TODO: S.TaggedRequest removed in v4 — needs rework to use Rpc.make or Request.TaggedClass
+      // For now, creating a simple tagged struct class with success/failure properties
+      const failureSchema = merge(
+        config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
+        [...errorSchemas, generalErrors].filter(Boolean)
+      )
+      const successSchema = config?.success
+        ? S.isSchema(config.success)
+          ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
+          : S.Struct(config.success)
+        : ForceVoid
+
+      const payloadSchema = S.Struct({ _tag: S.tag(tag), ...fields })
+
+      const taggedFields = { _tag: S.tag(tag), ...fields }
+
+      const RequestClass = class {
+        constructor(payload?: any) {
+          if (payload) {
+            Object.assign(this, payload)
+          }
+          ;(this as any)._tag = tag
         }
       }
+
+      Object.assign(RequestClass, payloadSchema, {
+        _tag: tag,
+        fields: taggedFields,
+        success: successSchema,
+        error: failureSchema,
+        config
+      })
+
+      return RequestClass
     }) as any
   }