effect-app 4.0.0-beta.2 → 4.0.0-beta.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.21",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -22,10 +22,10 @@
     "fast-check": "~4.5.3",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
-    "@effect-app/eslint-shared-config": "0.5.7-beta.1"
+    "@effect-app/eslint-shared-config": "0.5.7-beta.2"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.25"
+    "effect": "^4.0.0-beta.36"
   },
   "typesVersions": {
     "*": {
@@ -139,10 +139,6 @@
       "types": "./dist/Set.d.ts",
       "default": "./dist/Set.js"
     },
-    "./Struct": {
-      "types": "./dist/Struct.d.ts",
-      "default": "./dist/Struct.js"
-    },
     "./TypeTest": {
       "types": "./dist/TypeTest.d.ts",
       "default": "./dist/TypeTest.js"

package/src/Pure.ts

@@ -202,7 +202,7 @@ export function modify<S2, A, S3>(
     const [s, a] = mod(_.env.state)
     _.env.state = s as any
     return a
-  }) as any
+  })
 }
 
 export function modifyM<W, R, E, A, S2, S3>(
@@ -213,7 +213,7 @@ export function modifyM<W, R, E, A, S2, S3>(
     (castTag<W, S3, S2>() as any).use((_: any) => _),
     (_: any) =>
       Effect.map(mod(_.env.state), ([s, a]: any) => {
-        _.env.state = s as any
+        _.env.state = s
         return a
       })
   ) as any

package/src/Schema/brand.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import type { Option } from "effect"
 import * as B from "effect/Brand"
-import type * as Brand from "effect/Brand"
 import type * as Result from "effect/Result"
 import * as S from "effect/Schema"
 
@@ -21,7 +20,7 @@ export interface Constructor<in out A extends B.Brand<any>> {
    * Constructs a branded type from a value of type `A`, returning `Result.succeed`
    * if the provided `A` is valid, `Result.fail` otherwise.
    */
-  result(args: Unbranded<A>): Result.Result<A, Brand.BrandError>
+  result(args: Unbranded<A>): Result.Result<A, B.BrandError>
   /**
    * Attempts to refine the provided value of type `A`, returning `true` if
    * the provided `A` is valid, `false` otherwise.
@@ -29,19 +28,26 @@ export interface Constructor<in out A extends B.Brand<any>> {
   is(a: Unbranded<A>): a is Unbranded<A> & A
 }
 
-export const fromBrand = <C extends Brand.Brand<string>>(
+type BrandAnnotations<C extends B.Brand<any>> =
+  & S.Annotations.Filter
+  & (
+    C extends string ? { readonly toArbitrary?: S.Annotations.ToArbitrary.Declaration<C, readonly []> }
+      : {}
+  )
+
+export const fromBrand = <C extends B.Brand<any>>(
   constructor: Constructor<C>,
-  options?: S.Annotations.Filter
+  options?: BrandAnnotations<C>
 ) =>
-<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], Brand.Brand.Keys<C>> => {
+<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], B.Brand.Keys<C>> => {
   const branded = S.fromBrand(options?.identifier ?? "Brand", constructor as any)(self as any)
   return options ? (branded as any).pipe(S.annotate(options)) : branded as any
 }
 
-export type Brands<P> = P extends B.Brand<any> ? Brand.Brand.Brands<P>
+export type Brands<P> = P extends B.Brand<any> ? B.Brand.Brands<P>
   : never
 
-export type Unbranded<P> = P extends B.Brand<any> ? Brand.Brand.Unbranded<P> : P
+export type Unbranded<P> = P extends B.Brand<any> ? B.Brand.Unbranded<P> : P
 
 export const nominal: <A extends B.Brand<any>>() => Constructor<A> = <
   A extends B.Brand<any>

package/src/Schema/email.ts

@@ -16,7 +16,9 @@ export const Email = S
       identifier: "Email",
       title: "Email",
       description: "an email according to RFC 5322",
-      jsonSchema: { format: "email", minLength: 3, /* a@b */ maxLength: 998 },
-      arbitrary: () => (fc: any) => fc.emailAddress().map((_: any) => _ as Email)
+      jsonSchema: { format: "email", minLength: 3, /* a@b */ maxLength: 998 }
+    }),
+    S.annotate({
+      toArbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)
     })
   )

package/src/Schema/ext.ts

@@ -1,11 +1,18 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { Effect, Option, pipe, Schema, type SchemaAST, SchemaGetter, SchemaIssue, SchemaParser, SchemaTransformation, type ServiceMap } from "effect"
+import { Effect, Option, pipe, Schema, type SchemaAST, SchemaGetter, SchemaIssue, SchemaTransformation, ServiceMap } from "effect"
 import * as S from "effect/Schema"
 import { type NonEmptyReadonlyArray } from "../Array.js"
 import { extendM, typedKeysOf } from "../utils.js"
 import { type AST } from "./schema.js"
 
+type ProvidedCodec<Self extends S.Top, R> = S.Codec<
+  Self["Type"],
+  Self["Encoded"],
+  Exclude<Self["DecodingServices"], R>,
+  Exclude<Self["EncodingServices"], R>
+>
+
 // TODO: v4 migration — withConstructorDefault signature changed, propertySignature removed
 // Constraint relaxed from `Self extends S.Top & S.WithoutConstructorDefault` to `Self extends S.Top`
 // because `.pipe()` widens the schema type to `Top` which doesn't satisfy `WithoutConstructorDefault`.
@@ -69,7 +76,7 @@ export const Literal = <Literals extends NonEmptyReadonlyArray<AST.LiteralValue>
 /**
  * Like the default Schema `Array` but with `withDefault` => []
  */
-export function Array<Value extends S.Top>(value: Value) {
+export function Array<ValueSchema extends S.Top>(value: ValueSchema) {
   return pipe(
     S.Array(value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => [])) })
@@ -79,7 +86,7 @@ export function Array<Value extends S.Top>(value: Value) {
 /**
  * Like the default Schema `Map` but with `withDefault` => []
  */
-function Map_<Key extends S.Top, Value extends S.Top>(input: { key: Key; value: Value }) {
+function Map_<KeySchema extends S.Top, ValueSchema extends S.Top>(input: { key: KeySchema; value: ValueSchema }) {
   return pipe(
     S.ReadonlyMap(input.key, input.value),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new global.Map())) })
@@ -91,18 +98,19 @@ export { Map_ as Map }
 /**
  * Like the default Schema `ReadonlySet` but with `withDefault` => new Set()
  */
-export const ReadonlySet = <Value extends S.Top>(value: Value) =>
+export const ReadonlySet = <ValueSchema extends S.Top>(value: ValueSchema) =>
   pipe(
     S.ReadonlySet(value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Set<S.Schema.Type<Value>>())) })
+    (s) =>
+      Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Set<S.Schema.Type<ValueSchema>>())) })
   )
 
 /**
  * Like the default Schema `ReadonlyMap` but with `withDefault` => new Map()
  */
-export const ReadonlyMap = <K extends S.Top, V extends S.Top>(pair: {
-  readonly key: K
-  readonly value: V
+export const ReadonlyMap = <KeySchema extends S.Top, ValueSchema extends S.Top>(pair: {
+  readonly key: KeySchema
+  readonly value: ValueSchema
 }) =>
   pipe(
     S.ReadonlyMap(pair.key, pair.value),
@@ -112,25 +120,24 @@ export const ReadonlyMap = <K extends S.Top, V extends S.Top>(pair: {
 /**
  * Like the default Schema `NullOr` but with `withDefault` => null
  */
-export const NullOr = <S extends S.Top>(self: S) =>
+export const NullOr = <Schema extends S.Top>(self: Schema) =>
   pipe(
     S.NullOr(self),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => null)) })
   )
 
-export const defaultDate = (s: S.Top) => s.pipe(withDefaultConstructor(() => new global.Date()))
+export const defaultDate = <Schema extends S.Top>(schema: Schema) =>
+  schema.pipe(withDefaultConstructor(() => new global.Date()))
 
-export const defaultBool = (s: S.Top) => s.pipe(withDefaultConstructor(() => false))
+export const defaultBool = <Schema extends S.Top>(schema: Schema) => schema.pipe(withDefaultConstructor(() => false))
 
-export const defaultNullable = (
-  s: S.Top
-) => s.pipe(withDefaultConstructor(() => null))
+export const defaultNullable = <Schema extends S.Top>(schema: Schema) => schema.pipe(withDefaultConstructor(() => null))
 
-export const defaultArray = (s: S.Top) => s.pipe(withDefaultConstructor(() => []))
+export const defaultArray = <Schema extends S.Top>(schema: Schema) => schema.pipe(withDefaultConstructor(() => []))
 
-export const defaultMap = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Map()))
+export const defaultMap = <Schema extends S.Top>(schema: Schema) => schema.pipe(withDefaultConstructor(() => new Map()))
 
-export const defaultSet = (s: S.Top) => s.pipe(withDefaultConstructor(() => new Set()))
+export const defaultSet = <Schema extends S.Top>(schema: Schema) => schema.pipe(withDefaultConstructor(() => new Set()))
 
 export const withDefaultMake = <Self extends S.Top>(s: Self) => {
   const a = Object.assign(S.decodeSync(s as any) as WithDefaults<Self>, s)
@@ -240,29 +247,30 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
     )
   )
 
-// TODO: v4 migration — S.declare API changed (no [self] + decode/encode pattern)
-// Need to find v4 equivalent for contextual schema wrapping
 export const provide = <Self extends S.Top, R>(
   self: Self,
   context: ServiceMap.ServiceMap<R>
-): any => {
+): ProvidedCodec<Self, R> => {
   const prov = Effect.provide(context)
-  return S
-    .declare((_u: unknown): _u is unknown => true) // placeholder — needs proper v4 declare
-    .pipe(
-      S.decodeTo(
-        self,
-        SchemaTransformation.transformOrFail({
-          decode: (n: any) => prov(SchemaParser.decodeUnknownEffect(self)(n)),
-          encode: (n: any) => prov(SchemaParser.encodeUnknownEffect(self)(n))
-        }) as any
-      ) as any
-    )
-}
-// TODO: v4 migration — ServiceMap.pick and S.declare pattern removed
-export const contextFromServices = <Self extends S.Top, Tags extends readonly any[]>(
-  _self: Self,
-  ..._services: Tags
-): any => {
-  throw new Error("contextFromServices: not yet migrated to v4")
+  return self.pipe(
+    S.middlewareDecoding((effect) => prov(effect)),
+    S.middlewareEncoding((effect) => prov(effect))
+  ) as ProvidedCodec<Self, R>
 }
+export const contextFromServices = <
+  Self extends S.Top,
+  Tags extends ReadonlyArray<ServiceMap.Key<any, any>>
+>(
+  self: Self,
+  ...services: Tags
+): Effect.Effect<
+  ProvidedCodec<Self, ServiceMap.Service.Identifier<Tags[number]>>,
+  never,
+  ServiceMap.Service.Identifier<Tags[number]>
+> =>
+  Effect.gen(function*() {
+    const context: ServiceMap.ServiceMap<ServiceMap.Service.Identifier<Tags[number]>> = ServiceMap.pick(...services)(
+      yield* Effect.services<ServiceMap.Service.Identifier<Tags[number]>>()
+    )
+    return provide(self, context)
+  })

package/src/Schema/moreStrings.ts

@@ -140,11 +140,10 @@ const minLength = 6
 const maxLength = 50
 const size = 21
 const length = 10 * size
-const StringIdArb = (): any => (fc: any) =>
+const StringIdArb = (): S.LazyArbitrary<StringId> => (fc) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
-    .map((_: any) => customRandom(urlAlphabet, size, (size: number) => _.subarray(0, size))())
-
+    .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))() as StringId)
 /**
  * A string that is at least 6 characters long and a maximum of 50.
  */
@@ -155,7 +154,7 @@ export const StringId = extendM(
     fromBrand(nominal<StringId>(), {
       identifier: "StringId",
       title: "StringId",
-      arbitrary: StringIdArb,
+      toArbitrary: () => (fc) => StringIdArb()(fc),
       jsonSchema: {}
     })
   ),
@@ -178,19 +177,21 @@ export function prefixedStringId<Brand extends StringId>() {
   ) => {
     type FullPrefix = `${Prefix}${Separator}`
     const pref = `${prefix}${separator ?? "-"}` as FullPrefix
-    const arb = (): any => (fc: any) =>
+    const arb = (): S.LazyArbitrary<string & Brand> => (fc) =>
       StringIdArb()(fc).map(
-        (x: any) => (pref + x.substring(0, 50 - pref.length)) as Brand
+        (x) => (pref + x.substring(0, 50 - pref.length)) as Brand
       )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const s: S.Codec<string & Brand, string> = StringId
       .pipe(
         S.refine((x: string): x is string & Brand => x.startsWith(pref), {
-          arbitrary: arb,
           identifier: name,
           title: name
+        }),
+        S.annotate({
+          toArbitrary: () => (fc) => arb()(fc)
         })
-      ) as any
+      ) as S.Codec<string & Brand, string>
     const schema = s.pipe(withDefaultMake)
     const make = () => (pref + StringId.make().substring(0, 50 - pref.length)) as Brand
 
@@ -217,10 +218,10 @@ export const brandedStringId = <
   Brand extends StringIdBrand
 >() =>
   withDefaultMake(
-    Object.assign(Object.create(StringId), StringId) as S.Codec<string & Brand> & {
+    Object.assign(Object.create(StringId), StringId) as S.Codec<string & Brand, string> & {
       make: () => string & Brand
-      withDefault: any
-    } & WithDefaults<S.Codec<string & Brand>>
+      withDefault: S.withConstructorDefault<S.Codec<string & Brand, string> & S.WithoutConstructorDefault>
+    } & WithDefaults<S.Codec<string & Brand, string>>
   )
 
 export interface PrefixedStringUtils<
@@ -232,7 +233,7 @@ export interface PrefixedStringUtils<
   readonly unsafeFrom: (str: string) => Brand
   prefixSafe: <REST extends string>(str: `${Prefix}${Separator}${REST}`) => Brand
   readonly prefix: Prefix
-  readonly withDefault: any
+  readonly withDefault: S.withConstructorDefault<S.Codec<Brand, string> & S.WithoutConstructorDefault>
 }
 
 export interface UrlBrand extends Simplify<B.Brand<"Url"> & NonEmptyStringBrand> {}
@@ -247,10 +248,12 @@ export const Url = S
   .String
   .pipe(
     S.refine(isUrl, {
-      arbitrary: (): any => (fc: any) => fc.webUrl().map((_: any) => _ as Url),
       identifier: "Url",
       title: "Url",
       jsonSchema: { format: "uri" }
     }),
+    S.annotate({
+      toArbitrary: () => (fc) => fc.webUrl().map((_) => _ as Url)
+    }),
     withDefaultMake
   )

package/src/Schema/phoneNumber.ts

@@ -17,8 +17,10 @@ export const PhoneNumber = S
       identifier: "PhoneNumber",
       title: "PhoneNumber",
       description: "a phone number with at least 7 digits",
-      arbitrary: () => (fc: any) => Numbers(7, 10)(fc).map((_: any) => _ as PhoneNumber),
       jsonSchema: { format: "phone" }
     }),
+    S.annotate({
+      toArbitrary: () => (fc) => Numbers(7, 10)(fc).map((_) => _ as PhoneNumber)
+    }),
     withDefaultMake
   )

package/src/Schema.ts

@@ -1,11 +1,10 @@
-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"
@@ -40,127 +39,77 @@ 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)
+const getTagLiteral = <Tag extends string>(schema: S.tag<Tag>): Tag => {
+  if (!SchemaAST.isLiteral(schema.ast)) {
+    throw new Error("Unsupported _tag schema: expected a literal AST")
   }
-  throw new Error("Unsupported")
-}
-
-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>>
+  return schema.ast.literal as Tag
 }
 
-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> } })>
 >(
   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((key) => getTagLiteral(key.fields._tag)) as {
+      [Index in keyof Members]: S.Schema.Type<Members[Index]["fields"]["_tag"]>
+    }
+  ) as S.Literals<
+    {
+      [Index in keyof Members]: S.Schema.Type<Members[Index]["fields"]["_tag"]>
+    }
+  >
+
+type TaggedUnionMembers = NonEmptyReadonlyArray<
+  S.Top & { readonly Type: { readonly _tag: string }; fields: { _tag: S.tag<string> } }
+>
+
+type TaggedUnionTags<Members extends TaggedUnionMembers> = S.Literals<
+  {
+    [Index in keyof Members]: S.Schema.Type<Members[Index]["fields"]["_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/ServiceMap.ts

@@ -7,13 +7,14 @@
 
 import { type Effect, Layer, type Scope, type Types } from "effect"
 import * as ServiceMap from "effect/ServiceMap"
-import { Yieldable } from "./Effect.js"
+import { type Yieldable } from "./Effect.js"
 
 export * from "effect/ServiceMap"
 
-export interface Opaque<Self extends object, in out Shape extends object> extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self> {
-  // temp while sorting out https://github.com/Effect-TS/effect-smol/pull/1534
-  of(self: Shape): Self
+export interface Opaque<Self extends object, in out Shape extends object>
+  extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self>
+{
+  of(this: void, self: Shape): Self
   serviceMap(self: Shape): ServiceMap.ServiceMap<Self>
   // a version that leverages the Shape -> Self conversion
   toLayer: <E, R>(
@@ -151,7 +152,7 @@ export const Opaque: {
     id: Identifier,
     options?: {
       readonly make: ((...args: Args) => Effect.Effect<Shape, E, R>) | Effect.Effect<Shape, E, R> | undefined
-    } | undefined
+    }
   ) =>
     & OpaqueClass<Self, Identifier, Shape>
     & ([Types.unassigned] extends [R] ? unknown
@@ -181,7 +182,7 @@ export const Opaque: {
   const svc = ServiceMap.Service()(id, options) as any
   return Object.assign(svc, {
     toLayer: (eff: Effect.Effect<any, any, any>) => {
-      return Layer.effect(svc as any, eff)
+      return Layer.effect(svc, eff)
     }
   })
 }

package/src/client/apiClientFactory.ts

@@ -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)
   )
 
@@ -91,7 +91,7 @@ const getFiltered = <M extends Requests>(resource: M) => {
   // TODO: Record.filter
   const filtered = typedKeysOf(resource).reduce((acc, cur) => {
     if (
-      Predicate.isObject(resource[cur])
+      Predicate.isObjectKeyword(resource[cur])
       && (resource[cur].success)
     ) {
       acc[cur as keyof Filtered] = resource[cur] as any
@@ -146,10 +146,7 @@ const makeRpcTag = <M extends Requests>(resource: M) => {
   // 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"]>)
         }
       })