effect-app 3.16.0 → 4.0.0-beta.1

package/src/Schema.ts

@@ -5,10 +5,12 @@ import { fakerArb } from "./faker.js"
 import { Email as EmailT } from "./Schema/email.js"
 import { withDefaultMake } from "./Schema/ext.js"
 import { PhoneNumber as PhoneNumberT } from "./Schema/phoneNumber.js"
-import type { A, AST } from "./Schema/schema.js"
+import type { AST } from "./Schema/schema.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"
@@ -26,7 +28,8 @@ export * from "./Schema/schema.js"
 export * from "./Schema/strings.js"
 export { NonEmptyString } from "./Schema/strings.js"
 
-export * as ParseResult from "effect/ParseResult"
+export * as SchemaIssue from "effect/SchemaIssue"
+export * as SchemaParser from "effect/SchemaParser"
 
 export { Void as Void_ } from "effect/Schema"
 
@@ -39,9 +42,9 @@ export interface WithOptionalSpan {
 
 export const Email = EmailT
   .pipe(
-    S.annotations({
+    S.annotate({
       // eslint-disable-next-line @typescript-eslint/unbound-method
-      arbitrary: (): A.LazyArbitrary<Email> => (fc) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(Email)
+      arbitrary: (): any => (fc: any) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(Email)
     }),
     withDefaultMake
   )
@@ -50,31 +53,23 @@ export type Email = EmailT
 
 export const PhoneNumber = PhoneNumberT
   .pipe(
-    S.annotations({
-      arbitrary: (): A.LazyArbitrary<PhoneNumber> => (fc) =>
+    S.annotate({
+      arbitrary: (): any => (fc: any) =>
         // eslint-disable-next-line @typescript-eslint/unbound-method
         fakerArb((faker) => faker.phone.number)(fc).map(PhoneNumber)
     }),
     withDefaultMake
   )
 
-export const makeIs = <A extends { _tag: string }, I, R>(
-  schema: S.Schema<A, I, R>
+export const makeIs = <A extends { _tag: string }>(
+  schema: S.Schema<A>
 ) => {
-  const getToBottom = (ast: AST.AST) => {
-    if (SchemaAST.isTransformation(ast)) {
-      if (SchemaAST.isDeclaration(ast.to)) {
-        return getToBottom(ast.from)
-      }
-      return getToBottom(ast.to)
-    }
-    return ast
-  }
+  // 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, t) => {
-      t = getToBottom(t)
-      if (!SchemaAST.isTypeLiteral(t)) return acc
-      const tag = Array.findFirst(t.propertySignatures, (_) => {
+    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)
         }
@@ -86,15 +81,16 @@ export const makeIs = <A extends { _tag: string }, I, R>(
       }
       return {
         ...acc,
-        [String(ast.literal)]: (x: { _tag: string }) => x._tag === ast.literal
+        [String((ast as SchemaAST.Literal).literal)]: (x: { _tag: string }) =>
+          x._tag === (ast as SchemaAST.Literal).literal
       }
     }, {} as Is<A>)
   }
   throw new Error("Unsupported")
 }
 
-export const makeIsAnyOf = <A extends { _tag: string }, I, R>(
-  schema: S.Schema<A, I, R>
+export const makeIsAnyOf = <A extends { _tag: string }>(
+  schema: S.Schema<A>
 ): IsAny<A> => {
   if (SchemaAST.isUnion(schema.ast)) {
     return <Keys extends A["_tag"][]>(...keys: Keys) => (a: A): a is ExtractUnion<A, ElemType<Keys>> =>
@@ -112,52 +108,58 @@ export interface IsAny<A extends { _tag: string }> {
 
 export const taggedUnionMap = <
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Schema<{ _tag: string }, any, any> & { fields: { _tag: S.tag<string> } })[]
+  Members extends readonly (S.Top & { fields: { _tag: S.tag<string> } })[]
 >(
   self: Members
 ) =>
   self.reduce((acc, key) => {
-    // TODO: check upstream what's going on with literals of _tag
-    const ast = key.fields._tag.ast as S.PropertySignatureDeclaration
-    const tag = (ast.type 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
+    // 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
-  }, {} as { [Key in Members[number] as ReturnType<Key["fields"]["_tag"][S.TypeId]["_A"]>]: Key })
+    // 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.Schema<{ _tag: string }, any, any> & { fields: { _tag: S.tag<string> } })>
+  Members extends NonEmptyReadonlyArray<(S.Top & { fields: { _tag: S.tag<string> } })>
 >(
   self: Members
 ) =>
-  S.Literal(...self.map((key) => {
-    const ast = key.fields._tag.ast as S.PropertySignatureDeclaration
-    const tag = (ast.type as SchemaAST.Literal).literal
+  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 as S.Literal<
-    {
-      [Index in keyof Members]: S.Schema.Type<Members[Index]["fields"]["_tag"]>
-    }
-  >
-export const ExtendTaggedUnion = <A extends { _tag: string }, I, R>(
-  schema: S.Schema<A, I, R>
+  })) as any
+
+export const ExtendTaggedUnion = <A extends { _tag: string }>(
+  schema: S.Schema<A>
 ) =>
-  extendM(schema, (_) => ({ is: S.is(schema), isA: makeIs(_), isAnyOf: makeIsAnyOf(_) /*, map: taggedUnionMap(a) */ }))
+  extendM(
+    schema,
+    (_) => ({
+      is: S.is(schema as any),
+      isA: makeIs(_ as any),
+      isAnyOf: makeIsAnyOf(_ as any) /*, map: taggedUnionMap(a) */
+    })
+  )
 
 export const TaggedUnion = <
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends SchemaAST.Members<S.Schema.Any & { fields: { _tag: S.tag<any> } }>
+  Members extends readonly (S.Top & { fields: { _tag: S.tag<any> } })[]
 >(...a: Members) =>
   pipe(
-    S.Union(...a),
+    S.Union(a),
     (_) =>
       extendM(_, (_) => ({
-        is: S.is(_),
-        isA: makeIs(_),
-        isAnyOf: makeIsAnyOf(_),
+        is: S.is(_ as any),
+        isA: makeIs(_ as any),
+        isAnyOf: makeIsAnyOf(_ as any),
         tagMap: taggedUnionMap(a),
-        tags: tags(a)
+        tags: tags(a as any)
       }))
   )
 

package/src/ServiceMap.ts

@@ -0,0 +1,187 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * We're doing the long way around here with assignTag, TagBase & TagBaseTagged,
+ * because there's a typescript compiler issue where it will complain about Equal.symbol, and Hash.symbol not being accessible.
+ * https://github.com/microsoft/TypeScript/issues/52644
+ */
+
+import { type Effect, Layer, type Scope, type Types } from "effect"
+import * as ServiceMap from "effect/ServiceMap"
+import { 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
+  serviceMap(self: Shape): ServiceMap.ServiceMap<Self>
+  // a version that leverages the Shape -> Self conversion
+  toLayer: <E, R>(
+    eff: Effect.Effect<Shape, E, R>
+  ) => Layer.Layer<Self, E, Exclude<R, Scope.Scope>>
+  use<A, E, R>(f: (service: Shape) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R | Self>
+  useSync<A>(f: (service: Shape) => A): Effect.Effect<A, never, Self>
+}
+
+// export interface OpaqueMake<Self extends object, in out Shape extends object, E, R>
+//   extends ServiceMap.Service<Self, Self>
+// {
+//   // temp while sorting out https://github.com/Effect-TS/effect-smol/pull/1534
+//   of(self: Shape): Self
+//   serviceMap2(self: Shape): ServiceMap.ServiceMap<Self>
+//   // a version that leverages the Shape -> Self conversion
+//   toLayer: {
+//     <E, R>(
+//       eff: Effect.Effect<Shape, E, R>
+//     ): Layer.Layer<Self, E, Exclude<R, Scope.Scope>>
+//     (): Layer.Layer<Self, E, Exclude<R, Scope.Scope>>
+//   }
+// }
+
+export function assignTag<Identifier extends object, Shape extends object = Identifier>(
+  key: string,
+  creationError?: Error
+) {
+  return <S extends object>(cls: S): S & Opaque<Identifier, Shape> => {
+    const tag = ServiceMap.Service<Identifier, Shape>(key)
+    let fields = tag
+    if (Reflect.ownKeys(cls).includes("key")) {
+      const { key, ...rest } = tag
+      fields = rest as any
+    }
+    const t = Object.assign(cls, Object.getPrototypeOf(tag), fields)
+    if (!creationError) {
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      creationError = new Error()
+      Error.stackTraceLimit = limit
+    }
+    // the stack is used to get the location of the tag definition, if a service is not found in the registry
+    Object.defineProperty(t, "stack", {
+      get() {
+        return creationError!.stack
+      }
+    })
+    return t
+  }
+}
+
+export type ServiceAcessorShape<Self, Type> = Type extends Record<PropertyKey, any> ? {
+    [
+      k in keyof Type as Type[k] extends ((...args: [...infer Args]) => infer Ret)
+        ? ((...args: Readonly<Args>) => Ret) extends Type[k] ? k : never
+        : k
+    ]: Type[k] extends (...args: [...infer Args]) => Effect.Effect<infer A, infer E, infer R>
+      ? (...args: Readonly<Args>) => Effect.Effect<A, E, Self | R>
+      : Type[k] extends (...args: [...infer Args]) => infer A
+        ? (...args: Readonly<Args>) => Effect.Effect<A, never, Self>
+      : Type[k] extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, Self | R>
+      : Effect.Effect<Type[k], never, Self>
+  }
+  : {}
+
+/**
+ * Only use this in very specific cases where using dependencies directly is prefered, like inside command handlers.
+ */
+export const proxify = <T extends object>(Tag: T) =>
+<Self, Shape>():
+  & T
+  & ServiceAcessorShape<Self, Shape> =>
+{
+  const cache = new Map()
+  const done = new Proxy(Tag, {
+    get(_target: any, prop: any, _receiver) {
+      if (prop === "use") {
+        // @ts-expect-error abc
+        return (body) => (Tag as any).use(body)
+      }
+      if (prop in Tag) {
+        return (Tag as any)[prop]
+      }
+      if (cache.has(prop)) {
+        return cache.get(prop)
+      }
+      const fn = (...args: Array<any>) => (Tag as any).use((s: any) => s[prop](...args))
+      const cn = (Tag as any).use((s: any) => s[prop])
+      // @effect-diagnostics effect/floatingEffect:off
+      Object.assign(fn, cn)
+      Object.setPrototypeOf(fn, Object.getPrototypeOf(cn))
+      cache.set(prop, fn)
+      return fn
+    }
+  })
+  return done
+}
+
+export const TypeId = "~ServiceMap.Opaque"
+
+// export function Opaque<const Key extends string>(key: Key) {
+//   return <Identifier extends object, Shape extends object>() => {
+//     const limit = Error.stackTraceLimit
+//     Error.stackTraceLimit = 2
+//     const creationError = new Error()
+//     Error.stackTraceLimit = limit
+//     const c: abstract new(_: never) => Shape & { readonly [TypeId]: Key } = class {} as any
+
+//     return assignTag<Identifier, Shape>(key, creationError)(c)
+//   }
+// }
+
+export interface OpaqueClass<Self extends object, in out Identifier extends string, Shape extends object>
+  extends Opaque<Self, Shape>
+{
+  new(_: never): Shape & { readonly [TypeId]: Identifier }
+  readonly key: Identifier
+}
+
+// export interface OpaqueClassMake<Self extends object, in out Identifier extends string, Shape extends object, E, R>
+//   extends OpaqueMake<Self, Shape, E, R>
+// {
+//   new(_: never): Shape & { readonly [TypeId]: Identifier }
+//   readonly key: Identifier
+// }
+
+export const Opaque: {
+  <Self extends object, Shape extends object>(): <
+    const Identifier extends string,
+    E,
+    R = Types.unassigned,
+    Args extends ReadonlyArray<any> = never
+  >(
+    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
+      : {
+        readonly make: [Args] extends [never] ? Effect.Effect<Shape, E, R>
+          : (...args: Args) => Effect.Effect<Shape, E, R>
+      })
+  <Self extends object>(): <
+    const Identifier extends string,
+    Make extends Effect.Effect<any, any, any> | ((...args: any) => Effect.Effect<any, any, any>)
+  >(
+    id: Identifier,
+    options: {
+      readonly make: Make
+    }
+  ) =>
+    & OpaqueClass<
+      Self,
+      Identifier,
+      Make extends
+        | Effect.Effect<infer _A, infer _E, infer _R>
+        | ((...args: infer _Args) => Effect.Effect<infer _A, infer _E, infer _R>) ? _A
+        : never
+    >
+    & { readonly make: Make }
+} = () => (id: string, options: any) => {
+  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)
+    }
+  })
+}

package/src/Set.ts

@@ -1,6 +1,6 @@
 // ets_tracing: off
 
-import { Array, type Either, type Equivalence, Option, type Order } from "effect"
+import { Array, type Equivalence, Option, type Order, type Result } from "effect"
 import { not } from "effect/Predicate"
 import { identity, pipe, type Predicate, type Refinement, tuple } from "./Function.js"
 
@@ -19,7 +19,7 @@ export function findFirst_<A, B extends A>(
 ): Option.Option<B>
 export function findFirst_<A>(set: ReadonlySet<A>, predicate: Predicate<A>): Option.Option<A>
 export function findFirst_<A>(set: ReadonlySet<A>, predicate: Predicate<A>): Option.Option<A> {
-  return Option.fromNullable([...set].find(predicate))
+  return Option.fromNullishOr([...set].find(predicate))
 }
 
 export function findFirstMap_<A, B>(
@@ -337,9 +337,9 @@ export function elem<A>(E: Equivalence.Equivalence<A>): (a: A) => (set: Set<A>)
 export function partitionMap<B, C>(
   EB: Equivalence.Equivalence<B>,
   EC: Equivalence.Equivalence<C>
-): <A>(f: (a: A) => Either.Either<C, B>) => (set: Set<A>) => readonly [Set<B>, Set<C>] {
+): <A>(f: (a: A) => Result.Result<C, B>) => (set: Set<A>) => readonly [Set<B>, Set<C>] {
   const pm = partitionMap_(EB, EC)
-  return <A>(f: (a: A) => Either.Either<C, B>) => (set: Set<A>) => pm(set, f)
+  return <A>(f: (a: A) => Result.Result<C, B>) => (set: Set<A>) => pm(set, f)
 }
 
 /**
@@ -348,8 +348,8 @@ export function partitionMap<B, C>(
 export function partitionMap_<B, C>(
   EB: Equivalence.Equivalence<B>,
   EC: Equivalence.Equivalence<C>
-): <A>(set: Set<A>, f: (a: A) => Either.Either<C, B>) => readonly [Set<B>, Set<C>] {
-  return <A>(set: Set<A>, f: (a: A) => Either.Either<C, B>) => {
+): <A>(set: Set<A>, f: (a: A) => Result.Result<C, B>) => readonly [Set<B>, Set<C>] {
+  return <A>(set: Set<A>, f: (a: A) => Result.Result<C, B>) => {
     const values = set.values()
     let e: Next<A>
     const left = new Set<B>()
@@ -359,14 +359,14 @@ export function partitionMap_<B, C>(
     while (!(e = values.next() as any).done) {
       const v = f(e.value)
       switch (v._tag) {
-        case "Left":
-          if (!hasB(left, v.left)) {
-            left.add(v.left)
+        case "Failure":
+          if (!hasB(left, v.failure)) {
+            left.add(v.failure)
           }
           break
-        case "Right":
-          if (!hasC(right, v.right)) {
-            right.add(v.right)
+        case "Success":
+          if (!hasC(right, v.success)) {
+            right.add(v.success)
           }
           break
       }
@@ -528,7 +528,7 @@ export function compact<A>(E: Equivalence.Equivalence<A>): (fa: Set<Option.Optio
 export function separate<E, A>(
   EE: Equivalence.Equivalence<E>,
   EA: Equivalence.Equivalence<A>
-): (fa: Set<Either.Either<A, E>>) => readonly [Set<E>, Set<A>] {
+): (fa: Set<Result.Result<A, E>>) => readonly [Set<E>, Set<A>] {
   return (fa) => {
     const elemEE = elem_(EE)
     const elemEA = elem_(EA)
@@ -536,14 +536,14 @@ export function separate<E, A>(
     const right: MutableSet<A> = new Set()
     fa.forEach((e) => {
       switch (e._tag) {
-        case "Left":
-          if (!elemEE(left, e.left)) {
-            left.add(e.left)
+        case "Failure":
+          if (!elemEE(left, e.failure)) {
+            left.add(e.failure)
           }
           break
-        case "Right":
-          if (!elemEA(right, e.right)) {
-            right.add(e.right)
+        case "Success":
+          if (!elemEA(right, e.success)) {
+            right.add(e.success)
           }
           break
       }

package/src/Struct.ts

@@ -18,13 +18,13 @@ export * from "effect/Struct"
  */
 export const pick: {
   <Keys extends Array<PropertyKey>>(
-    ...keys: Keys
+    keys: Keys
   ): <S extends { [K in Keys[number]]?: any }>(
     s: S
   ) => Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
   <S extends object, Keys extends Array<keyof S>>(
     s: S,
-    ...keys: Keys
+    keys: Keys
   ): Types.MatchRecord<S, { [K in Keys[number]]?: S[K] }, Pick<S, Keys[number]>>
 } = Struct.pick
 
@@ -45,10 +45,10 @@ export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K
  */
 export const omit: {
   <Keys extends Array<PropertyKey>>(
-    ...keys: Keys
+    keys: Keys
   ): <S extends { [K in Keys[number]]?: any }>(s: S) => DistributiveOmit<S, Keys[number]>
   <S extends object, Keys extends Array<keyof S>>(
     s: S,
-    ...keys: Keys
+    keys: Keys
   ): DistributiveOmit<S, Keys[number]>
 } = Struct.omit as any

package/src/_ext/Array.ts

@@ -7,12 +7,11 @@ function getFirstBy<A, Type extends string>(
   id: A[typeof idKey],
   type: Type
 ) {
-  return Chunk
-    .fromIterable(a)
-    .pipe(
-      Chunk.findFirst((_) => Equal.equals(_[idKey], id)),
-      Effect.mapError(() => new NotFoundError<Type>({ type, id }))
+  return Effect
+    .fromOption(
+      Chunk.fromIterable(a).pipe(Chunk.findFirst((_) => Equal.equals(_[idKey], id)))
     )
+    .pipe(Effect.mapError(() => new NotFoundError<Type>({ type, id })))
 }
 
 export function makeGetFirstBy<A>() {

package/src/_ext/misc.ts

@@ -1,4 +1,4 @@
-import { Effect, Either, Option, type Scope } from "effect"
+import { Effect, Option, Result, type Scope } from "effect"
 import type { LazyArg } from "effect-app/Function"
 
 export type _R<T extends Effect.Effect<any, any, any>> = [T] extends [
@@ -21,8 +21,8 @@ export function encaseMaybeInEffect_<E, A>(
 export function encaseMaybeEither_<E, A>(
   o: Option.Option<A>,
   onError: LazyArg<E>
-): Either.Either<A, E> {
-  return Option.match(o, { onNone: () => Either.left(onError()), onSome: Either.right })
+): Result.Result<A, E> {
+  return Option.match(o, { onNone: () => Result.fail(onError()), onSome: Result.succeed })
 }
 
 export function toNullable<R, E, A>(
@@ -35,7 +35,7 @@ export function scope<R, E, A, R2, E2, A2>(
   scopedEffect: Effect.Effect<A, E, R | Scope.Scope>,
   effect: Effect.Effect<A2, E2, R2>
 ): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>> {
-  return Effect.zipRight(scopedEffect, effect).pipe(Effect.scoped)
+  return Effect.andThen(scopedEffect, effect).pipe(Effect.scoped)
 }
 
 export function flatMapScoped<R, E, A, R2, E2, A2>(

package/src/_ext/ord.ext.ts

@@ -13,7 +13,7 @@ export function uniq<A>(E: Equivalence.Equivalence<A>) {
   return (self: Chunk.Chunk<A>): Chunk.Chunk<A> => {
     let out = Chunk.fromIterable<A>([])
     for (let i = 0; i < self.length; i++) {
-      const a = Chunk.unsafeGet(self, i)
+      const a = Chunk.getUnsafe(self, i)
       if (!elem(E, a)(out)) {
         out = Chunk.append(out, a)
       }
@@ -30,7 +30,7 @@ export function uniq<A>(E: Equivalence.Equivalence<A>) {
 export function elem<A>(E: Equivalence.Equivalence<A>, value: A) {
   return (self: Chunk.Chunk<A>): boolean => {
     for (let i = 0; i < self.length; i++) {
-      if (E(Chunk.unsafeGet(self, i), value)) {
+      if (E(Chunk.getUnsafe(self, i), value)) {
         return true
       }
     }

package/src/builtin.ts

@@ -54,11 +54,5 @@ declare module "effect/Option" {
   }
 }
 
-declare module "effect/Either" {
-  export interface Left<E, A> {
-    get right(): A | undefined
-  }
-  export interface Right<E, A> {
-    get left(): E | undefined
-  }
-}
+// TODO: v4 migration — Either module augmentation removed (Either → Result)
+// Previously added .right to Left and .left to Right for convenience access