effect 4.0.0-beta.75 → 4.0.0-beta.76

package/src/Schema.ts

@@ -31,7 +31,7 @@
  * - Type guard: {@link is}
  * - Assertion: {@link asserts}
  * - Add constraints: `.check(...)` with filters like {@link isMinLength},
- *   {@link isGreaterThan}, {@link isPattern}, {@link isUUID}
+ *   {@link isGreaterThan}, {@link isPattern}, {@link isUUID}, {@link isGUID}
  * - Transform between schemas: {@link decodeTo}, {@link encodeTo}
  * - Add a default for missing keys: {@link withDecodingDefault}, {@link withDecodingDefaultKey}
  * - Create branded types: {@link brand}
@@ -6235,7 +6235,7 @@ export const isStringBigInt: (annotations?: Annotations.Filter) => SchemaAST.Fil
 export const isStringSymbol: (annotations?: Annotations.Filter) => SchemaAST.Filter<string> = SchemaAST.isStringSymbol
 
 /**
- * Returns a RegExp for validating an RFC 4122 UUID.
+ * Returns a RegExp for validating an RFC 9562 / RFC 4122 UUID.
  *
  * Optionally specify a version 1-8. If no version is specified (`undefined`), all versions are supported.
  */
@@ -6245,16 +6245,25 @@ const getUUIDRegExp = (version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8): globalThis.RegE
       `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`
     )
   }
-  return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+  return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$/;
 }
 
 /**
- * Validates that a string is a valid Universally Unique Identifier (UUID).
- * Optionally specify a version (1-8) to validate against a specific UUID version.
- * If no version is specified (`undefined`), all versions are supported.
+ * Validates that a string is a strict Universally Unique Identifier (UUID).
+ *
+ * **When to use**
+ *
+ * Use when you need UUID semantics, including version and RFC variant bits,
+ * rather than only the dashed hexadecimal shape.
  *
  * **Details**
  *
+ * Without a version argument, this accepts UUID versions 1 through 8, the nil
+ * UUID (`00000000-0000-0000-0000-000000000000`), and the max UUID
+ * (`ffffffff-ffff-ffff-ffff-ffffffffffff`). With a version argument, this
+ * accepts only UUIDs with that version and RFC variant bits; nil and max UUIDs
+ * are not versioned UUIDs and do not match version-specific checks.
+ *
  * JSON Schema:
  *
  * This check corresponds to a `pattern` constraint in JSON Schema that matches
@@ -6265,6 +6274,7 @@ const getUUIDRegExp = (version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8): globalThis.RegE
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the UUID pattern.
  *
+ * @see {@link isGUID} for shape-only GUID validation.
  * @category String checks
  * @since 4.0.0
  */
@@ -6284,6 +6294,46 @@ export function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: An
   )
 }
 
+const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/
+
+/**
+ * Validates that a string has the GUID / UUID textual shape.
+ *
+ * **When to use**
+ *
+ * Use when you need to accept dashed hexadecimal identifiers without enforcing
+ * UUID version or variant bits.
+ *
+ * **Details**
+ *
+ * This check accepts strings in the `8-4-4-4-12` hexadecimal form. JSON Schema
+ * output includes the corresponding `pattern` constraint and intentionally does
+ * not include `format: "uuid"` because GUID validation is looser than UUID
+ * validation.
+ *
+ * Arbitrary:
+ *
+ * When generating test data with fast-check, this applies a `patterns`
+ * constraint to ensure generated strings match the GUID pattern.
+ *
+ * @see {@link isUUID} for strict UUID validation.
+ * @category String checks
+ * @since 4.0.0
+ */
+export function isGUID(annotations?: Annotations.Filter) {
+  return isPattern(
+    GUID_REGEXP,
+    {
+      expected: "a GUID",
+      meta: {
+        _tag: "isGUID",
+        regExp: GUID_REGEXP
+      },
+      ...annotations
+    }
+  )
+}
+
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
@@ -8979,69 +9029,87 @@ export interface Error extends instanceOf<globalThis.Error> {
   readonly "Rebuild": Error
 }
 
-const ErrorJsonEncoded = Struct({
-  message: String,
-  name: optionalKey(String),
-  stack: optionalKey(String)
-})
-
 /**
- * Schema for JavaScript `Error` objects.
- *
- * **Details**
- *
- * Default JSON serializer:
- * Encodes an `Error` as an object with `message` and optional `name` properties,
- * and decodes that object back into an `Error`. The stack trace is omitted from
- * the encoded form for security.
+ * Options for {@link Error} and {@link Defect}.
  *
- * @category schemas
+ * @category options
  * @since 4.0.0
  */
-export const Error: Error = instanceOf(globalThis.Error, {
-  typeConstructor: {
-    _tag: "Error"
-  },
-  generation: {
-    runtime: `Schema.Error`,
-    Type: `globalThis.Error`
-  },
-  expected: "Error",
-  toCodecJson: () => link<globalThis.Error>()(ErrorJsonEncoded, SchemaTransformation.errorFromErrorJsonEncoded()),
-  toArbitrary: () => (fc) => fc.string().map((message) => new globalThis.Error(message))
-})
+export interface ErrorOptions {
+  /**
+   * Includes string stack traces in encoded `Error` values when set to `true`.
+   *
+   * @default false
+   */
+  readonly includeStack?: boolean | undefined
+  /**
+   * Excludes `Error.cause` values from encoded `Error` values when set to
+   * `true`.
+   *
+   * @default false
+   */
+  readonly excludeCause?: boolean | undefined
+}
+
+type ErrorOptionsKey = 0 | 1 | 2 | 3
+
+const getErrorOptionsKey = (options?: ErrorOptions): ErrorOptionsKey =>
+  ((options?.includeStack === true ? 1 : 0) |
+    (options?.excludeCause === true ? 2 : 0)) as ErrorOptionsKey
+
+const getErrorOptions = (key: ErrorOptionsKey): ErrorOptions | undefined => {
+  switch (key) {
+    case 0:
+      return undefined
+    case 1:
+      return { includeStack: true }
+    case 2:
+      return { excludeCause: true }
+    case 3:
+      return { includeStack: true, excludeCause: true }
+  }
+}
+
+const errorSchemaCache: Array<Error | undefined> = []
 
 /**
- * Schema for JavaScript `Error` objects that preserves stack traces in the JSON
- * encoded form.
+ * Schema for JavaScript `Error` objects.
  *
  * **Details**
  *
  * Default JSON serializer:
+ *
  * Encodes an `Error` as an object with `message`, optional `name`, and optional
- * `stack` properties, and decodes that object back into an `Error`.
+ * `cause` properties, and decodes that object back into an `Error`. Stack
+ * traces are omitted by default for security. Pass `{ includeStack: true }` to
+ * include stack traces, or `{ excludeCause: true }` to omit causes.
  *
- * @category schemas
+ * @category constructors
  * @since 4.0.0
  */
-export const ErrorWithStack: Error = instanceOf(globalThis.Error, {
-  typeConstructor: {
-    _tag: "ErrorWithStack"
-  },
-  generation: {
-    runtime: `Schema.ErrorWithStack`,
-    Type: `globalThis.Error`
-  },
-  expected: "Error",
-  toCodecJson: () =>
-    link<globalThis.Error>()(
-      ErrorJsonEncoded,
-      SchemaTransformation.errorFromErrorJsonEncoded({
-        includeStack: true
-      })
-    ),
-  toArbitrary: () => (fc) => fc.string().map((message) => new globalThis.Error(message))
-})
+export function Error(options?: ErrorOptions): Error {
+  const key = getErrorOptionsKey(options)
+  const cached = errorSchemaCache[key]
+  if (cached !== undefined) {
+    return cached
+  }
+  const normalizedOptions = getErrorOptions(key)
+  const schema = instanceOf(globalThis.Error, {
+    typeConstructor: {
+      _tag: "Error",
+      ...(normalizedOptions === undefined ? {} : { options: normalizedOptions })
+    },
+    generation: {
+      runtime: normalizedOptions !== undefined ? `Schema.Error(${format(normalizedOptions)})` : `Schema.Error()`,
+      Type: `globalThis.Error`
+    },
+    expected: "Error",
+    toCodecJson: () => link<globalThis.Error>()(JsonError, SchemaTransformation.errorFromJsonError(normalizedOptions)),
+    toArbitrary: () => (fc) => fc.string().map((message) => new globalThis.Error(message))
+  })
+  errorSchemaCache[key] = schema
+  return schema
+}
 
 /**
  * Type-level representation of {@link Defect}.
@@ -9049,80 +9117,63 @@ export const ErrorWithStack: Error = instanceOf(globalThis.Error, {
  * @category Defect
  * @since 3.10.0
  */
-export interface Defect extends
-  Union<
-    readonly [
-      decodeTo<
-        Error,
-        Struct<{
-          readonly message: String
-          readonly name: optionalKey<String>
-          readonly stack: optionalKey<String>
-        }>
-      >,
-      decodeTo<Unknown, Any>
-    ]
-  >
-{
+export interface Defect extends decodeTo<Unknown, typeof Json> {
   readonly "Rebuild": Defect
 }
 
-const defectTransformation = new SchemaTransformation.Transformation(
-  SchemaGetter.passthrough(),
-  SchemaGetter.transform((u) => {
-    try {
-      return JSON.parse(JSON.stringify(u))
-    } catch {
-      return format(u)
-    }
-  })
-)
+const defectSchemaCache: Array<Defect | undefined> = []
 
 /**
- * Schema for defect values, accepting either JavaScript `Error` values encoded
- * with `message` and optional `name`, or arbitrary unknown defect values.
+ * Schema for unexpected defect values represented as `unknown` with a JSON
+ * encoded form.
+ *
+ * **When to use**
+ *
+ * Use when you need a schema for `Cause` defects or other unexpected failures
+ * whose runtime value may be any value.
  *
  * **Details**
  *
- * Default JSON serializer:
- * Unknown defects are serialized with `JSON.stringify` when possible and fall
- * back to Effect's formatted representation when JSON serialization fails.
+ * The encoded side is {@link Json}. During decoding, JSON objects with a string
+ * `message` property are decoded into JavaScript `Error` values, preserving a
+ * non-default `name` and any string `stack`. Other JSON values decode
+ * unchanged.
  *
- * @category constructors
- * @since 3.10.0
- */
-export const Defect: Defect = Union([
-  ErrorJsonEncoded.pipe(decodeTo(Error, SchemaTransformation.errorFromErrorJsonEncoded())),
-  Any.pipe(decodeTo(
-    Unknown.annotate({
-      toCodecJson: () => link<unknown>()(Any, defectTransformation),
-      toArbitrary: () => (fc) => fc.json()
-    }),
-    defectTransformation
-  ))
-])
-
-/**
- * Schema for defects that also includes stack traces in the encoded form.
+ * During encoding, JavaScript `Error` values encode to JSON objects with
+ * `name`, `message`, and optional `cause` properties. Pass
+ * `{ includeStack: true }` to include string stack traces in encoded `Error`
+ * defects, or `{ excludeCause: true }` to omit causes. Other values are
+ * serialized through Effect's JSON formatter and then parsed back into JSON
+ * when possible.
  *
- * @category Defect
+ * **Gotchas**
+ *
+ * This schema is for carrying defects across JSON boundaries, not for
+ * preserving every JavaScript value exactly. Some values cannot round-trip
+ * unchanged:
+ *
+ * - A non-`Error` object such as `{ message: "boom" }` encodes as an
+ *   error-shaped JSON object and decodes back as an `Error`.
+ * - JSON serialization normalizes unsupported values. For example,
+ *   `undefined` array elements encode as `null`, unsupported object properties
+ *   are omitted, and circular references are dropped.
+ * - Values that cannot be represented as JSON fall back to Effect's formatted
+ *   string representation.
+ *
+ * @see {@link Error} for a schema that only accepts JavaScript `Error` values.
+ * @category constructors
  * @since 4.0.0
  */
-export const DefectWithStack: Defect = Union([
-  ErrorJsonEncoded.pipe(decodeTo(
-    ErrorWithStack,
-    SchemaTransformation.errorFromErrorJsonEncoded({
-      includeStack: true
-    })
-  )),
-  Any.pipe(decodeTo(
-    Unknown.annotate({
-      toCodecJson: () => link<unknown>()(Any, defectTransformation),
-      toArbitrary: () => (fc) => fc.json()
-    }),
-    defectTransformation
-  ))
-])
+export function Defect(options?: ErrorOptions): Defect {
+  const key = getErrorOptionsKey(options)
+  const cached = defectSchemaCache[key]
+  if (cached !== undefined) {
+    return cached
+  }
+  const schema = Json.pipe(decodeTo(Unknown, SchemaTransformation.defectFromJson(getErrorOptions(key))))
+  defectSchemaCache[key] = schema
+  return schema
+}
 
 /**
  * Type-level representation returned by {@link Exit}.
@@ -13730,6 +13781,13 @@ export interface JsonObject {
  */
 export const Json: Codec<Json> = make(SchemaAST.Json)
 
+const JsonError = Struct({
+  message: String,
+  name: optionalKey(String),
+  stack: optionalKey(String),
+  cause: optionalKey(Json)
+})
+
 /**
  * Recursive TypeScript type for mutable JSON values: `null`, `number`,
  * `boolean`, `string`, mutable arrays, or mutable string-keyed records.
@@ -14312,6 +14370,10 @@ export declare namespace Annotations {
       readonly regExp: globalThis.RegExp
       readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined
     }
+    readonly isGUID: {
+      readonly _tag: "isGUID"
+      readonly regExp: globalThis.RegExp
+    }
     readonly isULID: {
       readonly _tag: "isULID"
       readonly regExp: globalThis.RegExp

package/src/SchemaAST.ts

@@ -93,6 +93,7 @@ import * as SchemaGetter from "./SchemaGetter.ts"
 import * as SchemaIssue from "./SchemaIssue.ts"
 import type * as SchemaParser from "./SchemaParser.ts"
 import * as SchemaTransformation from "./SchemaTransformation.ts"
+import type * as FastCheck from "./testing/FastCheck.ts"
 
 /**
  * Discriminated union of all AST node types.
@@ -3790,7 +3791,8 @@ export const Json = new Declaration(
       Type: `Schema.Json`
     },
     expected: "JSON value",
-    toCodecJson: () => new Link(unknown, SchemaTransformation.passthrough())
+    toCodecJson: () => new Link(unknown, SchemaTransformation.passthrough()),
+    toArbitrary: () => (fc: typeof FastCheck) => fc.jsonValue()
   }
 )
 

package/src/SchemaRepresentation.ts

@@ -612,6 +612,7 @@ export type StringMeta = Schema.Annotations.BuiltInMetaDefinitions[
   | "isLengthBetween"
   | "isTrimmed"
   | "isUUID"
+  | "isGUID"
   | "isULID"
   | "isBase64"
   | "isBase64Url"
@@ -973,6 +974,11 @@ const $IsUUID = Schema.Struct({
   version: Schema.UndefinedOr(Schema.Literals([1, 2, 3, 4, 5, 6, 7, 8]))
 }).annotate({ identifier: "IsUUID" })
 
+const $IsGUID = Schema.Struct({
+  _tag: Schema.tag("isGUID"),
+  regExp: Schema.RegExp
+}).annotate({ identifier: "IsGUID" })
+
 const $IsULID = Schema.Struct({
   _tag: Schema.tag("isULID"),
   regExp: Schema.RegExp
@@ -1061,6 +1067,7 @@ export const $StringMeta = Schema.Union([
   $IsStringSymbol,
   $IsTrimmed,
   $IsUUID,
+  $IsGUID,
   $IsULID,
   $IsBase64,
   $IsBase64Url,
@@ -1832,9 +1839,7 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
       case "Date":
         return Schema.Date
       case "Error":
-        return Schema.Error
-      case "ErrorWithStack":
-        return Schema.ErrorWithStack
+        return Schema.Error(typeConstructor.options as Schema.ErrorOptions | undefined)
       case "File":
         return Schema.File
       case "FormData":
@@ -2148,6 +2153,8 @@ export function toSchema<S extends Schema.Top = Schema.Top>(document: Document,
         return Schema.isTrimmed(a)
       case "isUUID":
         return Schema.isUUID(filter.meta.version, a)
+      case "isGUID":
+        return Schema.isGUID(a)
       case "isULID":
         return Schema.isULID(a)
       case "isBase64":
@@ -2779,6 +2786,7 @@ export function toCodeDocument(multiDocument: MultiDocument, options?: {
     const ca = a === "" ? "" : `, ${a}`
     switch (filter.meta._tag) {
       case "isTrimmed":
+      case "isGUID":
       case "isULID":
       case "isBase64":
       case "isBase64Url":
@@ -2790,7 +2798,7 @@ export function toCodeDocument(multiDocument: MultiDocument, options?: {
       case "isInt":
       case "isUnique":
       case "isDateValid":
-        return `Schema.${filter.meta._tag}(${ca})`
+        return `Schema.${filter.meta._tag}(${a})`
 
       case "isStringFinite":
       case "isStringBigInt":

package/src/SchemaTransformation.ts

@@ -89,9 +89,10 @@ import * as BigDecimal from "./BigDecimal.ts"
 import * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
-import { formatDate } from "./Formatter.ts"
+import { format, formatDate, formatJson } from "./Formatter.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
+import type { ErrorOptions, Json } from "./Schema.ts"
 import type * as SchemaAST from "./SchemaAST.ts"
 import * as SchemaGetter from "./SchemaGetter.ts"
 import * as SchemaIssue from "./SchemaIssue.ts"
@@ -1075,35 +1076,84 @@ export const durationFromMillis: Transformation<Duration.Duration, number> = tra
   encode: (a) => Duration.toMillis(a)
 })
 
-/** @internal */
-export const errorFromErrorJsonEncoded = (options?: {
-  readonly includeStack?: boolean | undefined
-}): Transformation<Error, {
+type JsonError = {
   message: string
   name?: string
   stack?: string
-}> =>
-  transform({
-    decode: (i) => {
-      const err = new Error(i.message)
-      if (typeof i.name === "string" && i.name !== "Error") err.name = i.name
-      if (typeof i.stack === "string") err.stack = i.stack
-      return err
-    },
-    encode: (a) => {
-      const e: {
-        message: string
-        name?: string
-        stack?: string
-      } = {
-        name: a.name,
-        message: a.message
-      }
-      if (options?.includeStack && typeof a.stack === "string") {
-        e.stack = a.stack
+  cause?: Json
+}
+
+const isJsonError = (input: unknown): input is JsonError =>
+  Predicate.isObject(input) && typeof input["message"] === "string"
+
+const decodeJsonError = (input: JsonError): Error => {
+  const hasCause = Object.hasOwn(input, "cause")
+  const err = hasCause
+    ? new Error(input.message, { cause: decodeDefect(input.cause as Json) })
+    : new Error(input.message)
+  if (typeof input.name === "string" && input.name !== "Error") err.name = input.name
+  if (typeof input.stack === "string") err.stack = input.stack
+  return err
+}
+
+const encodeUnknownAsJson = (input: unknown): Json => {
+  try {
+    const json = formatJson(input)
+    return json === undefined ? format(input) : JSON.parse(json)
+  } catch {
+    return format(input)
+  }
+}
+
+const encodeJsonError = (
+  input: Error,
+  options: ErrorOptions | undefined,
+  encodeDefect: (input: unknown) => Json
+): JsonError => {
+  const encoded: JsonError = {
+    name: input.name,
+    message: input.message
+  }
+  if (options?.includeStack && typeof input.stack === "string") {
+    encoded.stack = input.stack
+  }
+  if (!options?.excludeCause && input.cause !== undefined) {
+    encoded.cause = encodeDefect(input.cause)
+  }
+  return encoded
+}
+
+const makeEncodeDefect = (options?: ErrorOptions): (input: unknown) => Json => {
+  const seen = new WeakSet<object>()
+  const encode = (input: unknown): Json => {
+    if (Predicate.isError(input)) {
+      if (seen.has(input)) {
+        return "[Circular]"
       }
-      return e
+      seen.add(input)
+      const encoded = encodeJsonError(input, options, encode)
+      seen.delete(input)
+      return encoded
     }
+    return encodeUnknownAsJson(input)
+  }
+  return encode
+}
+
+const decodeDefect = (input: Json): unknown => isJsonError(input) ? decodeJsonError(input) : input
+
+/** @internal */
+export const errorFromJsonError = (options?: ErrorOptions): Transformation<Error, JsonError> =>
+  transform({
+    decode: decodeJsonError,
+    encode: (input) => makeEncodeDefect(options)(input) as JsonError
+  })
+
+/** @internal */
+export const defectFromJson = (options?: ErrorOptions) =>
+  transform({
+    decode: decodeDefect,
+    encode: makeEncodeDefect(options)
   })
 
 /**

package/src/internal/schema/representation.ts

@@ -660,6 +660,7 @@ export function toJsonSchemaMultiDocument(
             ? { allOf: [{ minItems: meta.minimum }, { maxItems: meta.maximum }] }
             : { allOf: [{ minLength: meta.minimum }, { maxLength: meta.maximum }] }
         case "isPattern":
+        case "isGUID":
         case "isULID":
         case "isBase64":
         case "isBase64Url":

package/src/unstable/ai/McpSchema.ts

@@ -2161,7 +2161,7 @@ export class ElicitationDeclined
   extends Schema.ErrorClass<ElicitationDeclined>("@effect/ai/McpSchema/ElicitationDeclined")({
     _tag: Schema.tag("ElicitationDeclined"),
     request: Elicit.payloadSchema,
-    cause: optional(Schema.Defect)
+    cause: optional(Schema.Defect())
   })
 {}
 

package/src/unstable/cli/CliError.ts

@@ -481,7 +481,7 @@ export class UnknownSubcommand extends Schema.ErrorClass<UnknownSubcommand>(`${T
  */
 export class UserError extends Schema.ErrorClass<UserError>(`${TypeId}/UserError`)({
   _tag: Schema.tag("UserError"),
-  cause: Schema.Defect
+  cause: Schema.Defect()
 }) {
   /**
    * Marks this value as a user handler error for runtime guards.

package/src/unstable/cluster/ClusterError.ts

@@ -97,7 +97,7 @@ export class EntityNotAssignedToRunner
  */
 export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${TypeId}/MalformedMessage`)({
   _tag: Schema.tag("MalformedMessage"),
-  cause: Schema.Defect
+  cause: Schema.Defect()
 }) {
   /**
    * Marks this value as a cluster error for runtime guards.
@@ -136,7 +136,7 @@ export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${Typ
  */
 export class PersistenceError extends Schema.ErrorClass<PersistenceError>(`${TypeId}/PersistenceError`)({
   _tag: Schema.tag("PersistenceError"),
-  cause: Schema.Defect
+  cause: Schema.Defect()
 }) {
   /**
    * Marks this value as a cluster error for runtime guards.

package/src/unstable/cluster/Reply.ts

@@ -111,7 +111,7 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
       reply: new WithExit({
         requestId: options.requestId,
         id: options.id,
-        exit: Exit.die(Schema.encodeSync(Schema.Defect)(options.defect))
+        exit: Exit.die(Schema.encodeSync(Schema.Defect())(options.defect))
       }),
       context: Context.empty() as any,
       rpc: neverRpc

package/src/unstable/devtools/DevToolsSchema.ts

@@ -64,7 +64,7 @@ export const SpanStatusEnded = Schema.Struct({
   _tag: Schema.tag("Ended"),
   startTime: Schema.BigInt,
   endTime: Schema.BigInt,
-  exit: Schema.Exit(Schema.Void, Schema.DefectWithStack, Schema.DefectWithStack).pipe(
+  exit: Schema.Exit(Schema.Void, Schema.Defect({ includeStack: true }), Schema.Defect({ includeStack: true })).pipe(
     Schema.decodeTo(
       Schema.Exit(Schema.Unknown, Schema.Unknown, Schema.Unknown),
       SchemaTransformation.transform({

package/src/unstable/http/HttpClientError.ts

@@ -331,7 +331,7 @@ export class HttpClientErrorSchema extends Schema.ErrorClass<HttpClientErrorSche
       "EmptyBodyError"
     ] satisfies ReadonlyArray<HttpClientErrorReason["_tag"]>
   ),
-  cause: Schema.optional(Schema.Defect)
+  cause: Schema.optional(Schema.Defect())
 }) {
   /**
    * Builds the serializable schema representation for an HTTP client error.