effect-app 4.0.0-beta.6 → 4.0.0-beta.60

package/src/Schema.ts

@@ -1,22 +1,19 @@
-import { Array, Option, pipe, SchemaAST, type Tracer } from "effect"
+import { SchemaAST, type Tracer } from "effect"
 import * as S from "effect/Schema"
 import type { NonEmptyReadonlyArray } from "./Array.js"
 import { fakerArb } from "./faker.js"
-import { Email as EmailT } from "./Schema/email.js"
+import { Email as EmailT, type Email as EmailType } from "./Schema/email.js"
 import { withDefaultMake } from "./Schema/ext.js"
-import { PhoneNumber as PhoneNumberT } from "./Schema/phoneNumber.js"
-import type { AST } from "./Schema/schema.js"
+import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.js"
 import { extendM } from "./utils.js"
 
 export * from "effect/Schema"
-// v4: TaggedError renamed to TaggedErrorClass
-export { TaggedErrorClass as TaggedError } from "effect/Schema"
 
 export * from "./Schema/Class.js"
 export { Class, TaggedClass } from "./Schema/Class.js"
 
 export { fromBrand, nominal } from "./Schema/brand.js"
-export { Array, Boolean, Date, Literal, Map, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
+export { Array, Boolean, Date, DateValid, Finite, Literal, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
 export { Int, NonNegativeInt } from "./Schema/numbers.js"
 
 export * from "./Schema/email.js"
@@ -25,6 +22,8 @@ export * from "./Schema/moreStrings.js"
 export * from "./Schema/numbers.js"
 export * from "./Schema/phoneNumber.js"
 export * from "./Schema/schema.js"
+export * from "./Schema/SpecialJsonSchema.js"
+export * from "./Schema/SpecialOpenApi.js"
 export * from "./Schema/strings.js"
 export { NonEmptyString } from "./Schema/strings.js"
 
@@ -40,127 +39,104 @@ export interface WithOptionalSpan {
   [SpanId]?: Tracer.Span
 }
 
+const makeEmail = S.decodeSync(EmailT as any) as (value: string) => EmailType
+const makePhoneNumber = S.decodeSync(PhoneNumberT as any) as (value: string) => PhoneNumberType
+
 export const Email = EmailT
   .pipe(
     S.annotate({
       // eslint-disable-next-line @typescript-eslint/unbound-method
-      arbitrary: (): any => (fc: any) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(Email)
+      toArbitrary: () => (fc) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(makeEmail)
     }),
     withDefaultMake
   )
 
-export type Email = EmailT
+export type Email = EmailType
 
 export const PhoneNumber = PhoneNumberT
   .pipe(
     S.annotate({
-      arbitrary: (): any => (fc: any) =>
+      toArbitrary: () => (fc) =>
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        fakerArb((faker) => faker.phone.number)(fc).map(PhoneNumber)
+        fakerArb((faker) => faker.phone.number)(fc).map(makePhoneNumber)
     }),
     withDefaultMake
   )
 
-export const makeIs = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) => {
-  // In v4, transformations are stored as encoding on nodes, not as wrapper nodes.
-  // Union member ASTs are directly Objects (TypeLiteral equivalent).
-  if (SchemaAST.isUnion(schema.ast)) {
-    return schema.ast.types.reduce((acc: any, t: AST.AST) => {
-      if (!SchemaAST.isObjects(t)) return acc
-      const tag = Array.findFirst(t.propertySignatures, (_: any) => {
-        if (_.name === "_tag" && SchemaAST.isLiteral(_.type)) {
-          return Option.some(_.type)
-        }
-        return Option.none()
-      })
-      const ast = Option.getOrUndefined(tag)
-      if (!ast) {
-        return acc
-      }
-      return {
-        ...acc,
-        [String((ast as SchemaAST.Literal).literal)]: (x: { _tag: string }) =>
-          x._tag === (ast as SchemaAST.Literal).literal
-      }
-    }, {} as Is<A>)
-  }
-  throw new Error("Unsupported")
-}
+export type PhoneNumber = PhoneNumberType
 
-export const makeIsAnyOf = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-): IsAny<A> => {
-  if (SchemaAST.isUnion(schema.ast)) {
-    return <Keys extends A["_tag"][]>(...keys: Keys) => (a: A): a is ExtractUnion<A, ElemType<Keys>> =>
-      keys.includes(a._tag)
-  }
-  throw new Error("Unsupported")
+// Copied from SchemaAST.collectSentinels (marked @internal in effect).
+// Returns all { key, literal } pairs that can discriminate a union member.
+const getTagFromAST = (schema: S.Top): string => {
+  const sentinels = collectSentinelsFromAST(schema.ast)
+  const sentinel = sentinels.find((s) => s.key === "_tag")
+  if (sentinel !== undefined && typeof sentinel.literal === "string") return sentinel.literal
+  throw new Error("No _tag literal found on schema member")
 }
 
-export type ExtractUnion<A extends { _tag: string }, Tags extends A["_tag"]> = Extract<A, Record<"_tag", Tags>>
-export type Is<A extends { _tag: string }> = { [K in A as K["_tag"]]: (a: A) => a is K }
-export type ElemType<A> = A extends Array<infer E> ? E : never
-export interface IsAny<A extends { _tag: string }> {
-  <Keys extends A["_tag"][]>(...keys: Keys): (a: A) => a is ExtractUnion<A, ElemType<Keys>>
+function collectSentinelsFromAST(
+  ast: SchemaAST.AST
+): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> {
+  switch (ast._tag) {
+    case "Declaration": {
+      const s = ast.annotations?.["~sentinels"]
+      return Array.isArray(s) ? s : []
+    }
+    case "Objects":
+      return ast.propertySignatures.flatMap(
+        (ps): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> => {
+          const type = ps.type
+          if (!SchemaAST.isOptional(type)) {
+            if (SchemaAST.isLiteral(type)) return [{ key: ps.name, literal: type.literal }]
+            if (SchemaAST.isUniqueSymbol(type)) return [{ key: ps.name, literal: type.symbol }]
+          }
+          return []
+        }
+      )
+    case "Suspend":
+      return collectSentinelsFromAST(ast.thunk())
+    default:
+      return []
+  }
 }
 
-export const taggedUnionMap = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<string> } })[]
->(
-  self: Members
-) =>
-  self.reduce((acc, key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal as string // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-    ;(acc as any)[tag] = key as any
-    return acc
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  }, {} as any)
-
 export const tags = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends NonEmptyReadonlyArray<(S.Top & { fields: { _tag: S.tag<string> } })>
+  Members extends NonEmptyReadonlyArray<(S.Top & { readonly Type: { readonly _tag: string } })>
 >(
   self: Members
 ) =>
-  S.Literals(self.map((key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal
-    return tag
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  })) as any
-
-export const ExtendTaggedUnion = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) =>
-  extendM(
-    schema,
-    (_) => ({
-      is: S.is(schema as any),
-      isA: makeIs(_ as any),
-      isAnyOf: makeIsAnyOf(_ as any) /*, map: taggedUnionMap(a) */
-    })
-  )
+  S.Literals(
+    self.map(getTagFromAST) as {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  ) as S.Literals<
+    {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  >
+
+type TaggedUnionMembers = NonEmptyReadonlyArray<
+  S.Top & { readonly Type: { readonly _tag: string } }
+>
+
+type TaggedUnionTags<Members extends TaggedUnionMembers> = S.Literals<
+  {
+    [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+  }
+>
 
-export const TaggedUnion = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<any> } })[]
->(...a: Members) =>
-  pipe(
-    S.Union(a),
-    (_) =>
-      extendM(_, (_) => ({
-        is: S.is(_ as any),
-        isA: makeIs(_ as any),
-        isAnyOf: makeIsAnyOf(_ as any),
-        tagMap: taggedUnionMap(a),
-        tags: tags(a as any)
-      }))
-  )
+type TaggedUnionWithTags<Members extends TaggedUnionMembers> = S.toTaggedUnion<"_tag", Members> & {
+  readonly tags: TaggedUnionTags<Members>
+}
+
+const extendTaggedUnionWithTags = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> => extendM(schema.pipe(S.toTaggedUnion("_tag")), () => ({ tags: tags(schema.members) }))
 
-export type PhoneNumber = PhoneNumberT
+export const ExtendTaggedUnion = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(schema)
+
+export const TaggedUnion = <
+  Members extends TaggedUnionMembers
+>(...a: Members): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(S.Union(a))

package/src/client/apiClientFactory.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Config from "effect/Config"
 import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
@@ -7,11 +6,12 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
+import * as Config from "../Config.js"
+import * as Context from "../Context.js"
 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"
 
@@ -40,7 +40,7 @@ export type Req = S.Top & {
   readonly "~decodingServices"?: unknown
 }
 
-class RequestName extends ServiceMap.Reference("RequestName", {
+class RequestName extends Context.Reference("RequestName", {
   defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
 }) {}
 
@@ -50,17 +50,17 @@ 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(() => ({}))))
           ),
-          HttpClient.mapRequest((req) =>
-            flow(
-              HttpClientRequest.appendUrlParam("action", ctx.requestName),
-              HttpClientRequest.appendUrl("/" + ctx.moduleName)
-            )(req)
+          HttpClient.mapRequestEffect((req) =>
+            Effect.map(RequestName.asEffect(), (ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req))
           )
         )
         return client
@@ -76,7 +76,7 @@ export const HttpClientFromConfigLayer = Layer.unwrap(
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
   Layer.mergeAll(
-    RpcSerialization.layerJson,
+    RpcSerialization.layerNdjson,
     HttpClientLayer(config)
   )
 
@@ -139,17 +139,14 @@ const makeRpcTag = <M extends Requests>(resource: M) => {
 
   // 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<
+  const TheClient = Context.Opaque<
     any,
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
   >()(`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]
-    )
+    RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName })
   )
   return Object.assign(TheClient, { layer })
 }
@@ -188,7 +185,7 @@ const makeApiClientFactory = Effect
         const filtered = getFiltered(resource)
         return {
           mr,
-          client: (typedKeysOf(filtered)
+          client: typedKeysOf(filtered)
             .reduce((prev, cur) => {
               const h = filtered[cur]!
 
@@ -211,7 +208,7 @@ const makeApiClientFactory = Effect
               const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
 
               const fields = Struct.omit(Request.fields, ["_tag"] as const)
-              const requestAttr = h._tag
+              const requestAttr = `${meta.moduleName}.${h._tag}`
               // @ts-expect-error doc
               prev[cur] = Object.keys(fields).length === 0
                 ? {
@@ -246,7 +243,7 @@ const makeApiClientFactory = Effect
                 }
 
               return prev
-            }, {} as Client<M, M["meta"]["moduleName"]>))
+            }, {} as Client<M, M["meta"]["moduleName"]>)
         }
       })
 
@@ -284,7 +281,7 @@ const makeApiClientFactory = Effect
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends ServiceMap.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
+  extends Context.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
 {
   static readonly layer = (config: ApiConfig) =>
     ApiClientFactory.toLayer(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))

package/src/client/errors.ts

@@ -1,5 +1,5 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
-import { TaggedError } from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
 import * as S from "../Schema.js"
 
@@ -21,7 +21,7 @@ export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 // @ts-expect-error type not used
-export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<ItemType>>()("NotFoundError", {
+export class NotFoundError<ItemType = string> extends TaggedErrorClass<NotFoundError<ItemType>>()("NotFoundError", {
   type: S.String,
   id: S.Unknown
 }) {
@@ -34,28 +34,43 @@ export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<
   override get message() {
     return `Didn't find ${(this as any).type}#${JSON.stringify((this as any).id)}`
   }
+  override toString() {
+    return `NotFoundError: ${this.message}`
+  }
 }
 
 const messageFallback = (messageOrObject?: string | { message: string }) =>
   typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject ?? "" }
 
-export class InvalidStateError extends TaggedError<InvalidStateError>()("InvalidStateError", {
+export class InvalidStateError extends TaggedErrorClass<InvalidStateError>()("InvalidStateError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `InvalidStateError: ${this.message}`
   }
 }
 
-export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError>()("ServiceUnavailableError", {
+export class ServiceUnavailableError extends TaggedErrorClass<ServiceUnavailableError>()("ServiceUnavailableError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `ServiceUnavailableError: ${this.message}`
   }
 }
 
-export class ValidationError extends TaggedError<ValidationError>()("ValidationError", {
+export class ValidationError extends TaggedErrorClass<ValidationError>()("ValidationError", {
   errors: S.Array(S.Unknown)
 }) {
   constructor(
@@ -67,33 +82,45 @@ export class ValidationError extends TaggedError<ValidationError>()("ValidationE
   override get message() {
     return `Validation failed: ${(this as any).errors.map((e: any) => JSON.stringify(e, undefined, 2)).join(",\n")}`
   }
+  override toString() {
+    return `ValidationError: ${this.message}`
+  }
 }
 
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
+export class NotLoggedInError extends TaggedErrorClass<NotLoggedInError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
+  override toString() {
+    return `NotLoggedInError: ${this.message}`
+  }
 }
 
 /**
  * The user carries a valid Userprofile, but there is a problem with the login none the less.
  */
-export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
+export class LoginError extends TaggedErrorClass<LoginError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
+  override toString() {
+    return `LoginError: ${this.message}`
+  }
 }
 
-export class UnauthorizedError extends TaggedError<UnauthorizedError>()("UnauthorizedError", {
+export class UnauthorizedError extends TaggedErrorClass<UnauthorizedError>()("UnauthorizedError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(messageFallback(messageOrObject) as any, disableValidation as any)
   }
+  override toString() {
+    return `UnauthorizedError: ${this.message}`
+  }
 }
 
 type OptimisticConcurrencyDetails = {
@@ -104,7 +131,7 @@ type OptimisticConcurrencyDetails = {
   readonly found?: string | undefined
 }
 
-export class OptimisticConcurrencyException extends TaggedError<OptimisticConcurrencyException>()(
+export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticConcurrencyException>()(
   "OptimisticConcurrencyException",
   { message: S.String }
 ) {
@@ -116,11 +143,17 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
       | ({ message: string; cause?: unknown; raw?: unknown }),
     disableValidation?: boolean
   ) {
-    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any, disableValidation as any)
+    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
     }
   }
+  override toString() {
+    return `OptimisticConcurrencyException: ${this.message}`
+  }
 }
 
 const MutationOnlyErrors = [
@@ -174,6 +207,7 @@ export class CauseException<E> extends Error {
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)
     const first = errors[0]

package/src/client/makeClient.ts

@@ -1,4 +1,5 @@
-import { GetEffectError, type GetContextConfig, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
+import { SchemaTransformation } from "effect"
+import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
 
@@ -8,33 +9,38 @@ const merge = (a: any, b: Array<any>) =>
 /**
  * Whatever the input, we will only decode or encode to void
  */
-const ForceVoid: S.Codec<void> = S.Void as any
+export const ForceVoid = S
+  .declare((_: unknown): _ is unknown => true)
+  .pipe(
+    S.decodeTo(S.Any, SchemaTransformation.transform<unknown, unknown>({ decode: () => void 0, encode: () => void 0 }))
+  )
 
 type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
 
 type TaggedRequestResult<
+  Self,
   Tag extends string,
   Payload extends S.Struct.Fields,
   Success extends S.Top,
   Error extends S.Top,
   Config = Record<string, never>
 > =
-  & S.TaggedStruct<Tag, Payload>
+  & S.EnhancedClass<Self, 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
+    // TODO: these two are wrong. Anything using this request's success/error, should however derive the Decoding/Encoding services from them..
     readonly "~decodingServices": S.Codec.DecodingServices<Success> | S.Codec.DecodingServices<Error>
+    readonly "~encodingServices": S.Codec.EncodingServices<Success> | S.Codec.EncodingServices<Error>
   }
 
 export const makeRpcClient = <
   RequestContextMap extends RequestContextMapTagAny,
   GeneralErrors extends S.Top = never
 >(rcs: RequestContextMap, generalErrors?: GeneralErrors) => {
-  // Long way around ServiceMap/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
+  // Long way around Context/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
@@ -47,31 +53,45 @@ export const makeRpcClient = <
     : [GeneralErrors] extends [never] ? GetEffectError<RequestContextMap["config"], C>
     : MergeError<GetEffectError<RequestContextMap["config"], C>>
 
-  function TaggedRequest<_Self>(): {
+  function TaggedRequest<Self>(): {
     <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
       tag: Tag,
       fields: Payload,
       config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<
+      Self,
+      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
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<
+      Self,
+      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
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<Self, Tag, Payload, typeof ForceVoid, 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
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
+    ): TaggedRequestResult<Self, Tag, Payload, typeof ForceVoid, ErrorResult<C>, Omit<C, "success" | "error">>
     <Tag extends string, Payload extends S.Struct.Fields>(
       tag: Tag,
       fields: Payload
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<never>, Record<string, never>>
+    ): TaggedRequestResult<Self, Tag, Payload, typeof ForceVoid, ErrorResult<{}>, Record<string, never>>
   } {
     // TODO: filter errors based on config + take care of inversion
     const errorSchemas = Object.values(rcs.config).map((_) => _.error)

package/src/http/Request.ts

@@ -1,3 +1,4 @@
+import { Option } from "effect"
 import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
@@ -24,16 +25,18 @@ export const demandJson = (client: HttpClient.HttpClient) =>
     .mapRequest(client, (_) => HttpClientRequest.acceptJson(_))
     .pipe(HttpClient.transform((r, request) =>
       Effect.tap(r, (response) =>
-        HttpHeaders
-            .get(response.headers, "Content-Type")
-            ?.startsWith("application/json")
+        Option
+            .exists(
+              HttpHeaders.get(response.headers, "Content-Type"),
+              (_) => _.startsWith("application/json")
+            )
           ? Effect.void
           : Effect.fail(
             new HttpClientError.DecodeError({
               request,
               response,
               description: "not json response: "
-                + HttpHeaders.get(response.headers, "Content-Type")
+                + Option.getOrElse(HttpHeaders.get(response.headers, "Content-Type"), () => "<missing>")
             })
           ))
     ))

package/src/ids.ts

@@ -1,4 +1,4 @@
-import { brandedStringId, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake, Codec } from "effect-app/Schema"
+import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
 import type { Simplify } from "effect/Types"
 import { S } from "./index.js"