effect 4.0.0-beta.104 → 4.0.0-beta.105

package/src/SchemaParser.ts

@@ -94,6 +94,9 @@ export function makeOption<S extends Schema.Constraint>(schema: S) {
  *
  * The returned function constructs a value from constructor input and throws an
  * `Error` with the `SchemaIssue.Issue` in its `cause` when construction fails.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -115,7 +118,7 @@ export function make<S extends Schema.Constraint>(schema: S) {
       exit.cause,
       "Constructor adapter can only throw schema issues"
     )
-    throw new Error(issue.toString(), { cause: issue })
+    throw new Error("Schema validation failed", { cause: issue })
   }
 }
 
@@ -184,6 +187,9 @@ export function _issue<T>(ast: SchemaAST.AST) {
  * The assertion returns normally when validation succeeds. When the input does
  * not satisfy the schema with a schema-only failure, it throws an `Error` with
  * the `SchemaIssue.Issue` in its `cause`.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -202,7 +208,7 @@ export function asserts<S extends Schema.Constraint, I>(schema: S, input: I): as
       exit.cause,
       "Assertion adapter can only throw schema issues"
     )
-    throw new Error(issue.toString(), { cause: issue })
+    throw new Error("Schema validation failed", { cause: issue })
   }
 }
 
@@ -282,6 +288,9 @@ export const decodeEffect: <S extends Schema.Constraint>(
  *
  * The returned function resolves with the decoded `Type` on success and rejects
  * with an `Error` whose cause is a `SchemaIssue.Issue` on decoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -314,6 +323,9 @@ export function decodeUnknownPromise<S extends Schema.ConstraintDecoder<unknown>
  *
  * The returned function resolves with the decoded `Type` on success and rejects
  * with an `Error` whose cause is a `SchemaIssue.Issue` on decoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -492,6 +504,9 @@ export const decodeResult: <S extends Schema.ConstraintDecoder<unknown>>(
  *
  * The returned function returns the decoded `Type` on success and throws an
  * `Error` with the `SchemaIssue.Issue` in its `cause` on decoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -526,6 +541,9 @@ export function decodeUnknownSync<S extends Schema.ConstraintDecoder<unknown>>(
  *
  * The returned function returns the decoded `Type` on success and throws an
  * `Error` with the `SchemaIssue.Issue` in its `cause` on decoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -620,6 +638,9 @@ export const encodeEffect: <S extends Schema.Constraint>(
  *
  * The returned function resolves with the schema's `Encoded` value on success and
  * rejects with an `Error` whose cause is a `SchemaIssue.Issue` on encoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -651,6 +672,9 @@ export const encodeUnknownPromise = <S extends Schema.ConstraintEncoder<unknown>
  *
  * The returned function resolves with the schema's `Encoded` value on success and
  * rejects with an `Error` whose cause is a `SchemaIssue.Issue` on encoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -826,6 +850,9 @@ export const encodeResult: <S extends Schema.ConstraintEncoder<unknown>>(
  *
  * The returned function returns the schema's `Encoded` value on success and throws
  * an `Error` with the `SchemaIssue.Issue` in its `cause` on encoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -859,6 +886,9 @@ export function encodeUnknownSync<S extends Schema.ConstraintEncoder<unknown>>(
  *
  * The returned function returns the schema's `Encoded` value on success and throws
  * an `Error` with the `SchemaIssue.Issue` in its `cause` on encoding failure.
+ * Schema validation failures use the generic message `"Schema validation failed"`.
+ * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
+ * human-readable details are needed.
  *
  * **Gotchas**
  *
@@ -927,7 +957,7 @@ function asPromise<T, E>(
         exit.cause,
         "Promise adapter can only reject schema issues"
       )
-      throw new Error(issue.toString(), { cause: issue })
+      throw new Error("Schema validation failed", { cause: issue })
     })
 }
 
@@ -977,7 +1007,7 @@ function asSync<T, E>(
       return exit.value
     }
     const issue = InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, "Sync adapter can only throw schema issues")
-    throw new Error(issue.toString(), { cause: issue })
+    throw new Error("Schema validation failed", { cause: issue })
   }
 }
 
@@ -1086,9 +1116,7 @@ function makeParser(
           if (input !== InternalParser.missing && output !== InternalParser.missing) {
             const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
             if (issues) {
-              result = Effect.fail(
-                new SchemaIssue.Composite(ast, issues)
-              )
+              result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
             }
           }
         }
@@ -1097,9 +1125,7 @@ function makeParser(
           if (input !== InternalParser.missing && value !== InternalParser.missing) {
             const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options)
             if (issues) {
-              return Effect.fail(
-                new SchemaIssue.Composite(ast, issues)
-              )
+              return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options))
             }
           }
           return Effect.succeed(value)
@@ -1116,9 +1142,7 @@ function makeParser(
           if (value === InternalParser.missing) return result
           const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
           if (issues) {
-            result = Effect.fail(
-              new SchemaIssue.Composite(ast, issues)
-            )
+            result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
           }
         }
       } else {
@@ -1126,9 +1150,7 @@ function makeParser(
           if (value !== InternalParser.missing) {
             const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options)
             if (issues) {
-              return Effect.fail(
-                new SchemaIssue.Composite(ast, issues)
-              )
+              return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options))
             }
           }
           return Effect.succeed(value)
@@ -1175,7 +1197,19 @@ function makeParser(
     }
     result = Effect.catchCause(
       result,
-      (cause) => Effect.failCauseSync(() => Cause.map(cause, (issue) => new SchemaIssue.Encoding(ast, issue)))
+      (cause) =>
+        Effect.failCauseSync(() =>
+          Cause.map(
+            cause,
+            (issue) =>
+              new SchemaIssue.Encoding(
+                ast,
+                issue,
+                input,
+                options
+              )
+          )
+        )
     )
     return Effect.flatMapEager(result, (value) => {
       const local = parseLocal(value, options)

package/src/SchemaTransformation.ts

@@ -263,10 +263,10 @@ export const make = <T, E, RD = never, RE = never>(options: {
  *   Schema.decodeTo(
  *     Schema.Date,
  *     SchemaTransformation.transformOrFail({
- *       decode: (s) => {
+ *       decode: (s, options) => {
  *         const d = new Date(s)
  *         return isNaN(d.getTime())
- *           ? Effect.fail(new SchemaIssue.InvalidValue({ message: "Invalid date" }))
+ *           ? Effect.fail(new SchemaIssue.InvalidValue({ message: "Invalid date" }, s, options))
  *           : Effect.succeed(d)
  *       },
  *       encode: (d) => Effect.succeed(d.toISOString())
@@ -974,9 +974,16 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
   Duration.Duration,
   string
 >({
-  decode: (s) =>
+  decode: (s, options) =>
     Option.match(Duration.fromInput(s as Duration.Input), {
-      onNone: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid Duration string" })),
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid Duration string" },
+            s,
+            options
+          )
+        ),
       onSome: Effect.succeed
     }),
   encode: (duration) => Effect.succeed(globalThis.String(duration))
@@ -1015,11 +1022,15 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
  */
 export const durationFromNanos: Transformation<Duration.Duration, bigint> = transformOrFail({
   decode: (i) => Effect.succeed(Duration.nanos(i)),
-  encode: (a) =>
+  encode: (a, options) =>
     Option.match(Duration.toNanos(a), {
       onNone: () =>
         Effect.fail(
-          new SchemaIssue.InvalidValue({ message: "Expected a Duration representable as a bigint" })
+          new SchemaIssue.InvalidValue(
+            { expected: "a Duration representable as a bigint" },
+            a,
+            options
+          )
         ),
       onSome: (nanos) => Effect.succeed(nanos)
     })
@@ -1395,10 +1406,16 @@ export function optionFromOptional<T>(): Transformation<Option.Option<T>, T | un
  * @since 4.0.0
  */
 export const urlFromString: Transformation<URL, string> = transformOrFail<URL, string>({
-  decode: (s) =>
+  decode: (s, options) =>
     URL.canParse(s)
       ? Effect.succeed(new URL(s))
-      : Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid URL string" })),
+      : Effect.fail(
+        new SchemaIssue.InvalidValue(
+          { expected: "a valid URL string" },
+          s,
+          options
+        )
+      ),
   encode: (url) => Effect.succeed(url.href)
 })
 
@@ -1424,10 +1441,16 @@ export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string>
   BigDecimal.BigDecimal,
   string
 >({
-  decode: (s) => {
+  decode: (s, options) => {
     const result = BigDecimal.fromString(s)
     return Option.isNone(result)
-      ? Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid BigDecimal string" }))
+      ? Effect.fail(
+        new SchemaIssue.InvalidValue(
+          { expected: "a valid BigDecimal string" },
+          s,
+          options
+        )
+      )
       : Effect.succeed(result.value)
   },
   encode: (bd) => Effect.succeed(BigDecimal.format(bd))
@@ -1784,9 +1807,16 @@ export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, st
   DateTime.TimeZone.Named,
   string
 >({
-  decode: (s) => {
+  decode: (s, options) => {
     return Option.match(DateTime.zoneMakeNamed(s), {
-      onNone: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid IANA time zone" })),
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid IANA time zone" },
+            s,
+            options
+          )
+        ),
       onSome: Effect.succeed
     })
   },
@@ -1818,9 +1848,16 @@ export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = tra
   DateTime.TimeZone,
   string
 >({
-  decode: (s) => {
+  decode: (s, options) => {
     return Option.match(DateTime.zoneFromString(s), {
-      onNone: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid time zone" })),
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid time zone" },
+            s,
+            options
+          )
+        ),
       onSome: Effect.succeed
     })
   },
@@ -1852,9 +1889,16 @@ export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = trans
   DateTime.Utc,
   string
 >({
-  decode: (s) => {
+  decode: (s, options) => {
     return Option.match(DateTime.make(s), {
-      onNone: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid UTC DateTime string" })),
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid UTC DateTime string" },
+            s,
+            options
+          )
+        ),
       onSome: (result) => Effect.succeed(DateTime.toUtc(result))
     })
   },
@@ -1885,11 +1929,15 @@ export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = t
   DateTime.Zoned,
   string
 >({
-  decode: (s) => {
+  decode: (s, options) => {
     return Option.match(DateTime.makeZonedFromString(s), {
       onNone: () =>
         Effect.fail(
-          new SchemaIssue.InvalidValue({ message: "Expected a valid Zoned DateTime string" })
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid Zoned DateTime string" },
+            s,
+            options
+          )
         ),
       onSome: Effect.succeed
     })

package/src/Stdio.ts

@@ -63,6 +63,18 @@ export const TypeId: TypeId = "~effect/Stdio"
 export interface Stdio {
   readonly [TypeId]: TypeId
   readonly args: Effect.Effect<ReadonlyArray<string>>
+  /**
+   * Whether standard input is attached to a terminal.
+   *
+   * @since 4.0.0
+   */
+  readonly stdinIsTerminal: Effect.Effect<boolean>
+  /**
+   * Whether standard output is attached to a terminal.
+   *
+   * @since 4.0.0
+   */
+  readonly stdoutIsTerminal: Effect.Effect<boolean>
   stdout(options?: {
     readonly endOnDone?: boolean | undefined
   }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
@@ -98,16 +110,23 @@ export const Stdio: Context.Service<Stdio, Stdio> = Context.Service<Stdio>(TypeI
  *
  * **Details**
  *
- * The returned service reuses the supplied fields unchanged and only adds the
- * `Stdio` type identifier; it does not create a `Layer` or provide defaults.
+ * The returned service reuses the supplied fields unchanged and adds the
+ * `Stdio` type identifier. Omitted terminal-detection fields default to
+ * effects that succeed with `false`.
  *
  * @see {@link layerTest} for a test layer with default fields that can be overridden
  *
  * @category constructors
  * @since 4.0.0
  */
-export const make = (options: Omit<Stdio, TypeId>): Stdio => ({
+export const make = (
+  options:
+    & Omit<Stdio, TypeId | "stdinIsTerminal" | "stdoutIsTerminal">
+    & Partial<Pick<Stdio, "stdinIsTerminal" | "stdoutIsTerminal">>
+): Stdio => ({
   [TypeId]: TypeId,
+  stdinIsTerminal: Effect.succeed(false),
+  stdoutIsTerminal: Effect.succeed(false),
   ...options
 })
 
@@ -123,7 +142,7 @@ export const make = (options: Omit<Stdio, TypeId>): Stdio => ({
  *
  * Any provided fields override defaults. By default, arguments are empty,
  * standard output and error are draining sinks, and standard input is an empty
- * stream.
+ * stream, and terminal-detection effects succeed with `false`.
  *
  * @see {@link make} for constructing a `Stdio` service directly without a `Layer` or defaults
  *

package/src/internal/schema/schema.ts

@@ -1,10 +1,6 @@
-import * as Cause from "../../Cause.ts"
-import * as Effect from "../../Effect.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
-import { SchemaError } from "../../SchemaError.ts"
-import type { Issue } from "../../SchemaIssue.ts"
 import * as SchemaParser from "../../SchemaParser.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 
@@ -75,20 +71,8 @@ export function make<S extends Schema.Constraint>(ast: S["ast"], options?: objec
   )
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
-  const makeEffect = SchemaParser.makeEffect(self)
-  self.makeEffect = (input: S["~type.make.in"], options?: Schema.MakeOptions) =>
-    fromIssueEffect(makeEffect(input, options))
+  self.makeEffect = SchemaParser.makeEffect(self)
   self.make = SchemaParser.make(self)
   self.makeOption = SchemaParser.makeOption(self)
   return self
 }
-
-/** @internal */
-export function fromIssueEffect<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)))
-  )
-}

package/src/testing/TestSchema.ts

@@ -17,7 +17,7 @@ import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaAST from "../SchemaAST.ts"
-import type * as SchemaIssue from "../SchemaIssue.ts"
+import * as SchemaIssue from "../SchemaIssue.ts"
 import * as SchemaParser from "../SchemaParser.ts"
 import * as FastCheck from "../testing/FastCheck.ts"
 
@@ -123,7 +123,7 @@ export class Asserts<S extends Schema.Constraint> {
     async function succeed(input: S["~type.make.in"], expected?: S["Type"]) {
       const r = await Effect.runPromise(
         makeEffect(input, options).pipe(
-          Effect.mapErrorEager((issue) => issue.toString()),
+          Effect.mapErrorEager(SchemaIssue.defaultFormatter),
           Effect.result
         )
       )
@@ -135,7 +135,7 @@ export class Asserts<S extends Schema.Constraint> {
       async fail(input: unknown, message: string) {
         const r = await Effect.runPromise(
           makeEffect(input, options).pipe(
-            Effect.mapErrorEager((issue) => issue.toString()),
+            Effect.mapErrorEager(SchemaIssue.defaultFormatter),
             Effect.result
           )
         )
@@ -178,7 +178,7 @@ export class Asserts<S extends Schema.Constraint> {
         const r = await Effect.runPromise(
           encodeEffect(t).pipe(
             Effect.flatMapEager((e) => decodeUnknownEffect(e)),
-            Effect.mapErrorEager((issue) => issue.toString()),
+            Effect.mapErrorEager(SchemaIssue.defaultFormatter),
             Effect.result
           )
         )
@@ -367,7 +367,7 @@ export class Decoding<S extends Schema.Constraint> {
   ) {
     const r = await Effect.runPromise(
       this.decodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager((issue) => issue.toString()),
+        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
         Effect.result
       )
     )
@@ -401,7 +401,7 @@ export class Decoding<S extends Schema.Constraint> {
   ) {
     const r = await Effect.runPromise(
       this.decodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager((issue) => issue.toString()),
+        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
         Effect.result
       )
     )
@@ -507,7 +507,7 @@ export class Encoding<S extends Schema.Constraint> {
   ) {
     const r = await Effect.runPromise(
       this.encodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager((issue) => issue.toString()),
+        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
         Effect.result
       )
     )
@@ -541,7 +541,7 @@ export class Encoding<S extends Schema.Constraint> {
   ) {
     const r = await Effect.runPromise(
       this.encodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager((issue) => issue.toString()),
+        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
         Effect.result
       )
     )

package/src/unstable/ai/Prompt.ts

@@ -1840,20 +1840,30 @@ export const Prompt: Schema.Codec<Prompt, PromptEncoded> = Schema.Struct({
   Schema.decodeTo(
     $Prompt,
     SchemaTransformation.transformOrFail({
-      decode: (input) =>
+      decode: (input, options) =>
         Effect.mapBothEager(
           SchemaParser.decodeEffect(Schema.Array(Message))(input.content),
           {
             onSuccess: makePrompt,
-            onFailure: () => new SchemaIssue.InvalidValue({ message: "Invalid Prompt messages" })
+            onFailure: () =>
+              new SchemaIssue.InvalidValue(
+                { message: "Invalid Prompt messages" },
+                input.content,
+                options
+              )
           }
         ),
-      encode: (prompt) =>
+      encode: (prompt, options) =>
         Effect.mapBothEager(
           SchemaParser.encodeEffect(Schema.Array(Message))(prompt.content),
           {
             onSuccess: (messages) => ({ content: messages }),
-            onFailure: () => new SchemaIssue.InvalidValue({ message: "Invalid Prompt messages" })
+            onFailure: () =>
+              new SchemaIssue.InvalidValue(
+                { message: "Invalid Prompt messages" },
+                prompt.content,
+                options
+              )
           }
         )
     })

package/src/unstable/cluster/Reply.ts

@@ -242,10 +242,10 @@ export class Chunk<R extends Rpc.Any> extends Data.TaggedClass("Chunk")<{
       [success],
       ([success]) => (input, ast, options) => {
         if (!isReply(input) || input._tag !== "Chunk") {
-          return Effect.fail(new SchemaIssue.InvalidType(ast))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
         }
         return Effect.mapBothEager(SchemaParser.decodeEffect(Schema.NonEmptyArray(success))(input.values, options), {
-          onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["values"], issue)]),
+          onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "values", issue, input, options),
           onSuccess: (values) => new Chunk({ ...input, values } as any)
         })
       },
@@ -351,10 +351,10 @@ export class WithExit<R extends Rpc.Any> extends Data.TaggedClass("WithExit")<{
       [exitSchema],
       ([exit]) => (input, ast, options) => {
         if (!isReply(input) || input._tag !== "WithExit") {
-          return Effect.fail(new SchemaIssue.InvalidType(ast))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
         }
         return Effect.mapBothEager(SchemaParser.decodeEffect(exit)(input.exit, options), {
-          onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["exit"], issue)]),
+          onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "exit", issue, input, options),
           onSuccess: (exit) => new WithExit({ ...input, exit: exit as any })
         })
       },

package/src/unstable/encoding/Msgpack.ts

@@ -387,25 +387,29 @@ export const transformation: SchemaTransformation.Transformation<
   unknown,
   Uint8Array<ArrayBuffer>
 > = SchemaTransformation.transformOrFail({
-  decode(e, _options) {
+  decode(e, options) {
     try {
       return Effect.succeed(Msgpackr.decode(e))
     } catch {
       return Effect.fail(
-        new SchemaIssue.InvalidValue({
-          message: "Expected valid MessagePack bytes"
-        })
+        new SchemaIssue.InvalidValue(
+          { expected: "valid MessagePack bytes" },
+          e,
+          options
+        )
       )
     }
   },
-  encode(t, _options) {
+  encode(t, options) {
     try {
       return Effect.succeed(Msgpackr.encode(t) as Uint8Array<ArrayBuffer>)
     } catch {
       return Effect.fail(
-        new SchemaIssue.InvalidValue({
-          message: "Expected a MessagePack-serializable value"
-        })
+        new SchemaIssue.InvalidValue(
+          { expected: "a MessagePack-serializable value" },
+          t,
+          options
+        )
       )
     }
   }