effect 4.0.0-beta.83 → 4.0.0-beta.85

package/src/SchemaTransformation.ts

@@ -447,7 +447,7 @@ export function trim(): Transformation<string, string> {
  * Encoding converts values such as `"myFieldName"` back to `"my_field_name"`.
  * The transformation is round-trippable for standard snake_case and camelCase.
  *
- * **Example** (Snake to camel conversion)
+ * **Example** (Converting snake case to camel case)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -722,7 +722,7 @@ export function passthrough<T>(): Transformation<T, T> {
  * Both decode and encode are no-ops and return a shared singleton
  * transformation.
  *
- * **Example** (Supertype passthrough)
+ * **Example** (Passing through supertypes)
  *
  * ```ts
  * import { SchemaTransformation } from "effect"
@@ -755,7 +755,7 @@ export function passthroughSupertype<T>(): Transformation<T, T> {
  * - Both decode and encode are no-ops (same as {@link passthrough}).
  * - Returns a shared singleton instance.
  *
- * **Example** (Subtype passthrough)
+ * **Example** (Passing through subtypes)
  *
  * ```ts
  * import { SchemaTransformation } from "effect"
@@ -790,7 +790,7 @@ export function passthroughSubtype<T>(): Transformation<T, T> {
  * result is finite; combine with `Schema.Finite` or `Schema.Int` for stricter
  * checks.
  *
- * **Example** (Number from string)
+ * **Example** (Converting a string to a number)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -826,7 +826,7 @@ export const numberFromString = new Transformation(
  * the bigint to a string like `String(n)`. Decoding fails if the string is not
  * a valid bigint representation.
  *
- * **Example** (BigInt from string)
+ * **Example** (Converting a string to a BigInt)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -861,7 +861,7 @@ export const bigintFromString = new Transformation(
  * converts the `Date` to an ISO string like `date.toISOString()`, returning
  * `"Invalid Date"` for invalid dates.
  *
- * **Example** (Date from string)
+ * **Example** (Converting a string to a Date)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -898,7 +898,7 @@ export const dateFromString: Transformation<globalThis.Date, string> = new Trans
  * producing strings such as `"2000 millis"` or `"10 nanos"` that round-trip
  * through the parser.
  *
- * **Example** (Duration from string)
+ * **Example** (Converting a string to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -942,7 +942,7 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
  * fails with `InvalidValue` if the `Duration` cannot be represented as a
  * `bigint`, such as `Duration.infinity`.
  *
- * **Example** (Duration from nanoseconds)
+ * **Example** (Converting nanoseconds to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -983,7 +983,7 @@ export const durationFromNanos: Transformation<Duration.Duration, bigint> = tran
  * Decode creates a duration from the number, and encode returns the duration
  * length in milliseconds.
  *
- * **Example** (Duration from milliseconds)
+ * **Example** (Converting milliseconds to a Duration)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1098,7 +1098,7 @@ export const defectFromJson = (options?: ErrorOptions) =>
  * `Option.some(value)`. Encoding maps `Option.none()` to `null` and
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from nullable)
+ * **Example** (Converting nullable values to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1138,7 +1138,7 @@ export function optionFromNullOr<T>(): Transformation<Option.Option<T>, T | null
  * `Option.some(value)`. Encoding maps `Option.none()` to `undefined` and
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from undefined-or)
+ * **Example** (Converting undefined-or values to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1181,7 +1181,7 @@ export function optionFromUndefinedOr<T>(): Transformation<Option.Option<T>, T |
  * `undefined` according to `options.onNoneEncoding`, and maps
  * `Option.some(value)` to `value`. The transformation is pure and synchronous.
  *
- * **Example** (Option from nullish, encoding None as null)
+ * **Example** (Converting nullish values to an Option and encoding None as null)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1227,7 +1227,7 @@ export function optionFromNullishOr<T>(
  * the key, and maps `Some(Some(v))` to `Some(v)`. This uses
  * `transformOptional` under the hood.
  *
- * **Example** (Optional key to Option)
+ * **Example** (Converting an optional key to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1272,7 +1272,7 @@ export function optionFromOptionalKey<T>(): Transformation<Option.Option<T>, T>
  * value, and maps `Some(Some(v))` to `Some(v)`. This uses
  * `transformOptional` under the hood and filters out `undefined` on decode.
  *
- * **Example** (Optional value to Option)
+ * **Example** (Converting an optional value to an Option)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1315,7 +1315,7 @@ export function optionFromOptional<T>(): Transformation<Option.Option<T>, T | un
  * Decoding calls `new URL(s)` and fails with `InvalidValue` if the string is
  * not a valid URL. Encoding returns `url.href`.
  *
- * **Example** (URL from string)
+ * **Example** (Converting a string to a URL)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1385,7 +1385,7 @@ export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string>
  * Decoding parses the Base64 string into bytes. Encoding writes the byte array
  * as a Base64 string.
  *
- * **Example** (Uint8Array from Base64)
+ * **Example** (Converting Base64 to a Uint8Array)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1420,7 +1420,7 @@ export const uint8ArrayFromBase64String: Transformation<Uint8Array<ArrayBufferLi
  * Decoding parses the Base64 string into a UTF-8 string. Encoding writes the
  * string as a Base64 string.
  *
- * **Example** (String from Base64)
+ * **Example** (Converting Base64 to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1454,7 +1454,7 @@ export const stringFromBase64String: Transformation<string, string> = new Transf
  * Decoding parses the Base64 URL string into a UTF-8 string. Encoding writes
  * the string as a Base64 URL string.
  *
- * **Example** (String from Base64Url)
+ * **Example** (Converting Base64Url to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1488,7 +1488,7 @@ export const stringFromBase64UrlString: Transformation<string, string> = new Tra
  * Decoding parses the hex string into a UTF-8 string. Encoding writes the
  * string as a hex string.
  *
- * **Example** (String from Hex)
+ * **Example** (Converting hex to a string)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"
@@ -1524,7 +1524,7 @@ export const stringFromHexString: Transformation<string, string> = new Transform
  * Decoding calls `decodeURIComponent` and fails if the input contains malformed
  * percent-encoding sequences. Encoding calls `encodeURIComponent`.
  *
- * **Example** (URI component schema)
+ * **Example** (Defining a URI component schema)
  *
  * ```ts
  * import { Schema, SchemaTransformation } from "effect"

package/src/Stream.ts

@@ -2905,7 +2905,7 @@ export const tapSink: {
  * multiple inner streams may run at the same time and their outputs are merged
  * as they arrive.
  *
- * **Example** (FlatMapping stream values)
+ * **Example** (Flat mapping stream values)
  *
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -2936,7 +2936,7 @@ export const flatMap: {
    * multiple inner streams may run at the same time and their outputs are merged
    * as they arrive.
    *
-   * **Example** (FlatMapping stream values)
+   * **Example** (Flat mapping stream values)
    *
    * ```ts
    * import { Console, Effect, Stream } from "effect"
@@ -2973,7 +2973,7 @@ export const flatMap: {
    * multiple inner streams may run at the same time and their outputs are merged
    * as they arrive.
    *
-   * **Example** (FlatMapping stream values)
+   * **Example** (Flat mapping stream values)
    *
    * ```ts
    * import { Console, Effect, Stream } from "effect"
@@ -19522,7 +19522,7 @@ export const runForEachWhile: {
           if (!b) done = true
         }
       }),
-      () => done
+      () => !done
     )
   }))
 

package/src/String.ts

@@ -102,7 +102,7 @@ export const Equivalence: Equ.Equivalence<string> = Equ.String
  *
  * Use when you need the canonical empty string value from the `String` module.
  *
- * **Example** (Using the empty string)
+ * **Example** (Referencing the empty string)
  *
  * ```ts
  * import { String } from "effect"

package/src/Struct.ts

@@ -199,7 +199,7 @@ export const get: {
  *
  * Symbol keys are excluded; only string keys are returned.
  *
- * **Example** (Typed keys)
+ * **Example** (Reading typed keys)
  *
  * ```ts
  * import { Struct } from "effect"

package/src/Types.ts

@@ -31,7 +31,7 @@ type TupleOf_<T, N extends number, R extends Array<unknown>> = `${N}` extends `-
  * - If `N` is the general `number` type (non-literal), degrades to `Array<T>`.
  * - Negative numbers produce `never`.
  *
- * **Example** (Fixed-length tuple)
+ * **Example** (Checking fixed-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -66,7 +66,7 @@ export type TupleOf<N extends number, T> = N extends N ? number extends N ? Arra
  *
  * Produces a tuple with `N` fixed positions followed by `...Array<T>`.
  *
- * **Example** (Minimum-length tuple)
+ * **Example** (Checking minimum-length tuples)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -201,7 +201,7 @@ export type ExtractTag<E, K extends string> = E extends { readonly _tag: infer T
  * - If the union members are incompatible (e.g. `string | number`), the
  *   result is `never`.
  *
- * **Example** (Union to intersection)
+ * **Example** (Converting a union to an intersection)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -264,7 +264,7 @@ export type Simplify<A> = {
  *   distinguishing between `any`, `unknown`, `never`, and other types.
  * - Resolves to `true` if `X` and `Y` are identical, `false` otherwise.
  *
- * **Example** (Type equality check)
+ * **Example** (Checking type equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -295,7 +295,7 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
  *
  * Returns `Y` when `A` and `B` are equal, `N` otherwise.
  *
- * **Example** (Conditional type based on equality)
+ * **Example** (Choosing a conditional type based on equality)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -324,7 +324,7 @@ export type EqualsWith<A, B, Y, N> = (<T>() => T extends A ? 1 : 2) extends (<T>
  * Returns `true` if at least one key from `Key` exists in `A`, `false`
  * otherwise.
  *
- * **Example** (Key presence check)
+ * **Example** (Checking key presence)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -352,7 +352,7 @@ export type Has<A, Key extends string> = (Key extends infer K ? K extends keyof
  *
  * Implemented as `MergeRight<Target, Source>`.
  *
- * **Example** (Left-biased merge)
+ * **Example** (Merging with left bias)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -423,7 +423,7 @@ export type MergeRight<Target, Source> = Simplify<
  * - `"unbounded"` — run all effects concurrently with no limit.
  * - `"inherit"` — inherit the concurrency from the surrounding context.
  *
- * **Example** (Concurrency values)
+ * **Example** (Setting concurrency values)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -451,7 +451,7 @@ export type Concurrency = number | "unbounded" | "inherit"
  *
  * Only affects the top level; nested properties remain readonly.
  *
- * **Example** (Shallow mutable conversion)
+ * **Example** (Converting shallowly to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -492,7 +492,7 @@ export type Mutable<T> = {
  * Recursion stops at primitives (`string`, `number`, `boolean`, `bigint`,
  * `symbol`) and functions.
  *
- * **Example** (Deep mutable conversion)
+ * **Example** (Converting deeply to mutable types)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -557,7 +557,7 @@ export type NoInfer<A> = [A][A extends any ? 0 : never]
  * A value of type `Invariant<A>` cannot be assigned to `Invariant<B>` unless
  * `A` and `B` are the same type.
  *
- * **Example** (Invariant phantom type)
+ * **Example** (Defining an invariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -625,7 +625,7 @@ export declare namespace Invariant {
  * `Covariant<A>` is assignable to `Covariant<B>` when `A extends B`, following
  * the subtype direction.
  *
- * **Example** (Covariant phantom type)
+ * **Example** (Defining a covariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"
@@ -693,7 +693,7 @@ export declare namespace Covariant {
  * `Contravariant<A>` is assignable to `Contravariant<B>` when `B extends A`,
  * following the supertype direction.
  *
- * **Example** (Contravariant phantom type)
+ * **Example** (Defining a contravariant phantom type)
  *
  * ```ts
  * import type { Types } from "effect"

package/src/internal/effect.ts

@@ -96,7 +96,8 @@ import {
   TracerSpanLinks,
   TracerTimingEnabled
 } from "./references.ts"
-import { addSpanStackTrace, type ErrorWithStackTraceLimit, makeStackCleaner } from "./tracer.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
+import { addSpanStackTrace, makeStackCleaner } from "./tracer.ts"
 import { version } from "./version.ts"
 
 // ----------------------------------------------------------------------------
@@ -314,9 +315,8 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
   const interrupts: Array<Cause.Interrupt> = []
   if (self.reasons.length === 0) return errors
 
-  const prevStackLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
-  ;(Error as ErrorWithStackTraceLimit)
-    .stackTraceLimit = 1
+  const prevStackLimit = getStackTraceLimit()
+  setStackTraceLimit(1)
 
   for (const failure of self.reasons) {
     if (failure._tag === "Interrupt") {
@@ -340,7 +340,7 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
     errors.push(causePrettyError(error, interrupts[0].annotations))
   }
 
-  ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevStackLimit
+  setStackTraceLimit(prevStackLimit)
   return errors
 }
 
@@ -933,6 +933,11 @@ export const succeedNone: Effect.Effect<Option.Option<never>> = succeed(
   Option.none()
 )
 
+/** @internal */
+export const transposeOption = <A = never, E = never, R = never>(
+  self: Option.Option<Effect.Effect<A, E, R>>
+): Effect.Effect<Option.Option<A>, E, R> => Option.isNone(self) ? succeedNone : map(self.value, Option.some)
+
 /** @internal */
 export const failCauseSync = <E>(
   evaluate: LazyArg<Cause.Cause<E>>
@@ -950,17 +955,24 @@ const void_: Effect.Effect<void> = succeed(void 0)
 export { void_ as void }
 
 /** @internal */
-const try_ = <A, E>(options: {
-  try: LazyArg<A>
-  catch: (error: unknown) => E
-}): Effect.Effect<A, E> =>
-  suspend(() => {
+const try_ = <A, E = Cause.UnknownError>(
+  options: {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  } | LazyArg<A>
+): Effect.Effect<A, E> => {
+  const evaluate = typeof options === "function" ? options : options.try
+  const catcher = typeof options === "function"
+    ? ((cause: unknown) => new UnknownError(cause, "An error occurred in Effect.try"))
+    : options.catch
+  return suspend(() => {
     try {
-      return succeed(internalCall(options.try))
+      return succeed(internalCall(evaluate))
     } catch (err) {
-      return fail(internalCall(() => options.catch(err)))
+      return fail(internalCall(() => catcher(err)) as E)
     }
   })
+}
 /** @internal */
 export { try_ as try }
 
@@ -987,15 +999,22 @@ export const tryPromise = <A, E = Cause.UnknownError>(
     ? ((cause: unknown) => new UnknownError(cause, "An error occurred in Effect.tryPromise"))
     : options.catch
   return callbackOptions<A, E>(function(resume, signal) {
+    const failWithCatch = (cause: unknown) => {
+      try {
+        resume(fail(internalCall(() => catcher(cause)) as E))
+      } catch (err) {
+        resume(die(err))
+      }
+    }
     try {
       internalCall(() => f(signal!)).then(
         (a) => resume(succeed(a)),
-        (e) => resume(fail(internalCall(() => catcher(e)) as E))
+        failWithCatch
       )
     } catch (err) {
-      resume(fail(internalCall(() => catcher(err)) as E))
+      failWithCatch(err)
     }
-  }, eval.length !== 0)
+  }, f.length !== 0)
 }
 
 /** @internal */
@@ -1138,10 +1157,10 @@ export const fn: typeof Effect.fn = function() {
   const name = nameFirst ? arguments[0] : "Effect.fn"
   const spanOptions = nameFirst ? arguments[1] : undefined
 
-  const prevLimit = globalThis.Error.stackTraceLimit
-  globalThis.Error.stackTraceLimit = 2
+  const prevLimit = getStackTraceLimit()
+  setStackTraceLimit(2)
   const defError = new globalThis.Error()
-  globalThis.Error.stackTraceLimit = prevLimit
+  setStackTraceLimit(prevLimit)
 
   if (nameFirst) {
     return (body: Function | { readonly self: any }, ...pipeables: Array<Function>) =>
@@ -1181,10 +1200,10 @@ const makeFn = (
     if (!isEffect(result)) {
       return result
     }
-    const prevLimit = globalThis.Error.stackTraceLimit
-    globalThis.Error.stackTraceLimit = 2
+    const prevLimit = getStackTraceLimit()
+    setStackTraceLimit(2)
     const callError = new globalThis.Error()
-    globalThis.Error.stackTraceLimit = prevLimit
+    setStackTraceLimit(prevLimit)
     return updateService(
       addSpan ?
         useSpan(name, spanOptions!, (span) => provideParentSpan(result, span)) :

package/src/internal/schema/arbitrary.ts

@@ -382,6 +382,18 @@ function oneOf<T>(fc: typeof FastCheck, arbitraries: ReadonlyArray<FastCheck.Arb
   return arbitraries.length === 0 ? undefined : arbitraries.length === 1 ? arbitraries[0] : fc.oneof(...arbitraries)
 }
 
+const finiteNumberConstraint: Constraint = {
+  noInfinity: true,
+  noNaN: true
+}
+
+function finiteNumberContext(ctx: Context): Context {
+  return {
+    ...ctx,
+    constraint: finiteNumberConstraint
+  }
+}
+
 function reportChecks(report: MutableReport, checks: SchemaAST.Checks | undefined, path: ReadonlyArray<PropertyKey>) {
   function visit(check: SchemaAST.Check<any>, covered: boolean) {
     const arbitrary = check.annotations?.arbitrary
@@ -430,6 +442,9 @@ export function collectReport(ast: SchemaAST.AST, report: MutableReport) {
       case "Union":
         ast.types.forEach((type) => visit(type, path))
         break
+      case "TemplateLiteral":
+        ast.parts.forEach((part, i) => visit(SchemaAST.toEncoded(part), [...path, i]))
+        break
       case "Suspend":
         visit(ast.thunk(), path)
         break
@@ -605,8 +620,14 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
       return same((fc) => fc.oneof(fc.object(), fc.array(fc.anything())))
     case "Enum":
       return recur(SchemaAST.enumsToLiterals(ast), path)
-    case "TemplateLiteral":
-      return same((fc) => fc.stringMatching(SchemaAST.getTemplateLiteralRegExp(ast)))
+    case "TemplateLiteral": {
+      const parts = ast.parts.map((part, i) => recur(SchemaAST.toEncoded(part), [...path, i]))
+      return same((fc, ctx, recursionStack) =>
+        fc.tuple(...parts.map((part) => part(fc, finiteNumberContext(ctx), recursionStack))).map((segments) =>
+          segments.map((segment) => globalThis.String(segment)).join("")
+        )
+      )
+    }
     case "Arrays": {
       const elements = ast.elements.map((ast, i) => ({
         ast,

package/src/internal/schema/cause.ts

@@ -0,0 +1,26 @@
+import * as Cause from "../../Cause.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
+
+/** @internal */
+export function getSchemaIssue(cause: Cause.Cause<SchemaIssue.Issue>): SchemaIssue.Issue | undefined {
+  let issue: SchemaIssue.Issue | undefined
+  for (const reason of cause.reasons) {
+    if (!Cause.isFailReason(reason) || !SchemaIssue.isIssue(reason.error)) {
+      return undefined
+    }
+    issue ??= reason.error
+  }
+  return issue
+}
+
+/** @internal */
+export function getSchemaIssueOrThrow(
+  cause: Cause.Cause<SchemaIssue.Issue>,
+  message: string
+): SchemaIssue.Issue {
+  const issue = getSchemaIssue(cause)
+  if (issue === undefined) {
+    throw new Error(message, { cause })
+  }
+  return issue
+}

package/src/internal/schema/schema.ts

@@ -1,5 +1,7 @@
+import * as Cause from "../../Cause.ts"
+import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import { flow } from "../../Function.ts"
+import * as Exit from "../../Exit.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
@@ -33,7 +35,8 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
   }
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
-  self.makeEffect = flow(SchemaParser.makeEffect(self), Effect.mapErrorEager((issue) => new SchemaError(issue)))
+  self.makeEffect = (input: S["~type.make.in"], options?: Schema.MakeOptions) =>
+    mapSchemaIssueEffect(SchemaParser.makeEffect(self)(input, options))
   self.make = SchemaParser.make(self)
   self.makeOption = SchemaParser.makeOption(self)
   return self
@@ -42,23 +45,46 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
 /** @internal */
 export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
 
-// not internal
-export class SchemaError {
-  readonly [SchemaErrorTypeId] = SchemaErrorTypeId
-  readonly _tag = "SchemaError"
-  readonly name: string = "SchemaError"
+// purposefully not internal
+export class SchemaError extends Data.TaggedError("SchemaError")<{
   readonly issue: Issue
+}> {
+  readonly [SchemaErrorTypeId]: typeof SchemaErrorTypeId = SchemaErrorTypeId
   constructor(issue: Issue) {
-    this.issue = issue
+    super({ issue })
   }
-  get message() {
+  override get message() {
     return this.issue.toString()
   }
-  toString() {
+  override toString() {
     return `SchemaError(${this.message})`
   }
 }
 
+/** @internal */
+export function mapSchemaIssueEffect<A, R>(
+  self: Effect.Effect<A, Issue, R>
+): Effect.Effect<A, SchemaError, R> {
+  return Effect.catchCause(
+    self,
+    (cause) => Effect.failCauseSync(() => Cause.map(cause, (issue) => new SchemaError(issue)))
+  )
+}
+
+/** @internal */
+export function mapSchemaErrorEffect<A, R>(
+  self: Effect.Effect<A, SchemaError, R>
+): Effect.Effect<A, Issue, R> {
+  return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause.map(cause, (error) => error.issue)))
+}
+
+/** @internal */
+export function mapSchemaIssueExit<A>(exit: Exit.Exit<A, Issue>): Exit.Exit<A, SchemaError> {
+  return Exit.isSuccess(exit)
+    ? Exit.succeed(exit.value)
+    : Exit.failCause(Cause.map(exit.cause, (issue) => new SchemaError(issue)))
+}
+
 /** @internal */
 export const jsonReorder = makeReorder(getJsonPriority)