effect-app 4.0.0-beta.7 → 4.0.0-beta.70

package/src/Schema/ext.ts

@@ -1,11 +1,20 @@
 /* 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, type SchemaAST, SchemaIssue, SchemaTransformation } from "effect"
 import * as S from "effect/Schema"
+import { isDateValid } from "effect/Schema"
 import { type NonEmptyReadonlyArray } from "../Array.js"
+import * as Context from "../Context.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`.
@@ -16,17 +25,38 @@ export const withDefaultConstructor = <A>(
 <Self extends S.Top>(self: Self): S.withConstructorDefault<Self & S.WithoutConstructorDefault> => {
   type Narrowed = Self & S.WithoutConstructorDefault
   return S.withConstructorDefault<Narrowed>(
-    () => Option.some(makeDefault() as Narrowed["~type.make.in"])
+    Effect.sync(() => makeDefault() as Narrowed["~type.make.in"])
   )(self as Narrowed)
 }
 
 // TODO: v4 migration - Date is no longer by default encoded to string.
-const DateFromString = Schema.Date.pipe(
-  Schema.encodeTo(Schema.String, {
-    decode: SchemaGetter.Date(),
-    encode: SchemaGetter.transform((_) => _.toISOString())
-  })
-)
+
+const DateString = S.String.annotate({
+  identifier: "Date",
+  description: "a string in ISO 8601 format that will be decoded as a Date",
+  format: "date-time"
+})
+
+/**
+ * Schema type for {@link DateFromString}.
+ *
+ * @category Schemas
+ * @since 4.0.0
+ */
+export interface DateFromString extends S.decodeTo<S.Date, S.String> {}
+
+/**
+ * A transformation schema that parses an ISO 8601 string into a `Date`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `Date`.
+ *
+ * Encoding:
+ * - A `Date` is encoded as a `string`.
+ *
+ * @since 4.0.0
+ */
+export const DateFromString: DateFromString = DateString.pipe(S.decodeTo(S.Date, SchemaTransformation.dateFromString))
 
 /**
  * Like the default Schema `Date` but from String with `withDefault` => now
@@ -35,6 +65,13 @@ export const Date = Object.assign(DateFromString, {
   withDefault: DateFromString.pipe(withDefaultConstructor(() => new global.Date()))
 })
 
+/**
+ * Like the default Schema `DateValid` but from String with `withDefault` => now
+ */
+export const DateValid = Object.assign(Date.check(isDateValid()), {
+  withDefault: DateFromString.pipe(withDefaultConstructor(() => new global.Date()))
+})
+
 /**
  * Like the default Schema `Boolean` but with `withDefault` => false
  */
@@ -43,10 +80,16 @@ export const Boolean = Object.assign(S.Boolean, {
 })
 
 /**
+ * You probably want to use `Finite` instead of this.
  * Like the default Schema `Number` but with `withDefault` => 0
  */
 export const Number = Object.assign(S.Number, { withDefault: S.Number.pipe(withDefaultConstructor(() => 0)) })
 
+/**
+ * Like the default Schema `Finite` but with `withDefault` => 0
+ */
+export const Finite = Object.assign(S.Finite, { withDefault: S.Finite.pipe(withDefaultConstructor(() => 0)) })
+
 /**
  * Like the default Schema `Literal` but with `withDefault` => literals[0]
  */
@@ -69,7 +112,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(() => [])) })
@@ -77,60 +120,107 @@ export function Array<Value extends S.Top>(value: Value) {
 }
 
 /**
- * Like the default Schema `Map` but with `withDefault` => []
+ * An annotated `S.Array` of unique items that decodes to a `ReadonlySet`.
  */
-function Map_<Key extends S.Top, Value extends S.Top>(input: { key: Key; value: Value }) {
-  return pipe(
-    S.ReadonlyMap(input.key, input.value),
-    (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new global.Map())) })
+export const ReadonlySetFromArray = <ValueSchema extends S.Top>(value: ValueSchema): S.Codec<
+  ReadonlySet<ValueSchema["Type"]>,
+  readonly ValueSchema["Encoded"][],
+  ValueSchema["DecodingServices"],
+  ValueSchema["EncodingServices"]
+> => {
+  const from = S
+    .Array(value)
+    .annotate({ expected: "an array of unique items that will be decoded as a ReadonlySet" })
+  const to = S.instanceOf(Set) as S.instanceOf<ReadonlySet<S.Schema.Type<ValueSchema>>>
+  const schema = from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transform({
+        decode: (arr) => new Set(arr) as ReadonlySet<S.Schema.Type<ValueSchema>>,
+        encode: (set) => [...set]
+      })
+    )
   )
+  return S.revealCodec(schema)
 }
 
-export { Map_ as Map }
+/**
+ * An annotated `S.Array` of key-value tuples that decodes to a `ReadonlyMap`.
+ */
+export const ReadonlyMapFromArray = <KeySchema extends S.Top, ValueSchema extends S.Top>(pair: {
+  readonly key: KeySchema
+  readonly value: ValueSchema
+}): S.Codec<
+  ReadonlyMap<KeySchema["Type"], S.Schema.Type<ValueSchema>>,
+  readonly (readonly [KeySchema["Encoded"], ValueSchema["Encoded"]])[],
+  KeySchema["DecodingServices"] | ValueSchema["DecodingServices"],
+  KeySchema["EncodingServices"] | ValueSchema["EncodingServices"]
+> => {
+  const from = S
+    .Array(S.Tuple([pair.key, pair.value]))
+    .annotate({ expected: "an array of key-value tuples that will be decoded as a ReadonlyMap" })
+  const to = S.instanceOf(Map) as S.instanceOf<
+    ReadonlyMap<S.Schema.Type<KeySchema>, S.Schema.Type<ValueSchema>>
+  >
+  const schema = from.pipe(
+    S.decodeTo(
+      to,
+      SchemaTransformation.transform({
+        decode: (
+          arr
+        ) => new Map(arr) as ReadonlyMap<S.Schema.Type<KeySchema>, S.Schema.Type<ValueSchema>>,
+        encode: (
+          map
+        ) => [...map.entries()] as any // fu
+      })
+    )
+  )
+  return S.revealCodec(schema)
+}
 
 /**
- * Like the default Schema `ReadonlySet` but with `withDefault` => new Set()
+ * Like the default Schema `ReadonlySet` but from Array 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>>())) })
+    ReadonlySetFromArray(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()
+ * Like the default Schema `ReadonlyMap` but from Array 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),
+    ReadonlyMapFromArray(pair),
     (s) => Object.assign(s, { withDefault: s.pipe(withDefaultConstructor(() => new Map())) })
   )
 
 /**
  * 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)
@@ -160,7 +250,7 @@ export type WithDefaults<Self extends S.Top> = (
 //   : never
 
 export const inputDate = extendM(
-  S.Union([S.DateValid, S.Date]),
+  S.Union([S.DateValid, Date]).pipe(S.revealCodec),
   (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => new globalThis.Date())) })
 )
 
@@ -211,7 +301,7 @@ export const transformTo = <To extends S.Top, From extends S.Top>(
               { message: "One way schema transformation, encoding is not allowed" }
             )
           )
-      }) as any
+      })
     )
   )
 
@@ -228,7 +318,7 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
     S.decodeTo(
       to,
       SchemaTransformation.transformOrFail({
-        decode: decode as any,
+        decode,
         encode: (i: any) =>
           Effect.fail(
             new SchemaIssue.Forbidden(
@@ -236,33 +326,34 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
               { message: "One way schema transformation, encoding is not allowed" }
             )
           )
-      }) as any
+      })
     )
   )
 
-// 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 => {
+  context: Context.Context<R>
+): 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<Context.Key<any, any>>
+>(
+  self: Self,
+  ...services: Tags
+): Effect.Effect<
+  ProvidedCodec<Self, Context.Service.Identifier<Tags[number]>>,
+  never,
+  Context.Service.Identifier<Tags[number]>
+> =>
+  Effect.gen(function*() {
+    const context: Context.Context<Context.Service.Identifier<Tags[number]>> = Context.pick(...services)(
+      yield* Effect.context<Context.Service.Identifier<Tags[number]>>()
+    )
+    return provide(self, context)
+  })

package/src/Schema/moreStrings.ts

@@ -140,10 +140,10 @@ const minLength = 6
 const maxLength = 50
 const size = 21
 const length = 10 * size
-const StringIdArb = (): S.LazyArbitrary<string> => (fc) =>
+const StringIdArb = (): S.LazyArbitrary<StringId> => (fc) =>
   fc
     .uint8Array({ minLength: length, maxLength: length })
-    .map((_) => customRandom(urlAlphabet, size, (size) => _.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.
  */
@@ -154,7 +154,7 @@ export const StringId = extendM(
     fromBrand(nominal<StringId>(), {
       identifier: "StringId",
       title: "StringId",
-      arbitrary: StringIdArb,
+      toArbitrary: () => (fc) => StringIdArb()(fc),
       jsonSchema: {}
     })
   ),
@@ -185,11 +185,13 @@ export function prefixedStringId<Brand extends StringId>() {
     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
 
@@ -245,11 +247,17 @@ const isUrl: Refinement<string, Url> = (s: string): s is Url => {
 export const Url = S
   .String
   .pipe(
+    S.annotate({
+      title: "Url",
+      format: "uri"
+    }),
     S.refine(isUrl, {
-      arbitrary: (): S.LazyArbitrary<Url> => (fc) => fc.webUrl().map((_) => _ as Url),
       identifier: "Url",
       title: "Url",
       jsonSchema: { format: "uri" }
     }),
+    S.annotate({
+      toArbitrary: () => (fc) => fc.webUrl().map((_) => _ as Url)
+    }),
     withDefaultMake
   )

package/src/Schema/numbers.ts

@@ -42,7 +42,7 @@ export type Int = number & IntBrand
 
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
 export const PositiveNumber = extendM(
-  S.Number.pipe(
+  S.Finite.pipe(
     S.check(S.isGreaterThan(0)),
     fromBrand(nominal<PositiveNumber>(), {
       identifier: "PositiveNumber",
@@ -58,7 +58,7 @@ export type PositiveNumber = number & PositiveNumberBrand
 export interface NonNegativeNumberBrand extends Simplify<B.Brand<"NonNegativeNumber">> {}
 export const NonNegativeNumber = extendM(
   S
-    .Number
+    .Finite
     .pipe(
       S.check(S.isGreaterThanOrEqualTo(0)),
       fromBrand(nominal<NonNegativeNumber>(), {

package/src/Schema/phoneNumber.ts

@@ -13,12 +13,19 @@ export type PhoneNumber = string & PhoneNumberBrand
 export const PhoneNumber = S
   .String
   .pipe(
+    S.annotate({
+      title: "PhoneNumber",
+      description: "a phone number with at least 7 digits",
+      format: "phone"
+    }),
     S.refine(isValidPhone as Refinement<string, PhoneNumber>, {
       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,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, DateFromString, 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))