effect 3.12.4 → 3.12.6

package/dist/esm/Schema.js

@@ -2179,22 +2179,21 @@ export const split = separator => transform(String$.annotations({
   decode: string_.split(separator),
   encode: array_.join(separator)
 });
-const JsonString = /*#__PURE__*/String$.annotations({
-  [AST.IdentifierAnnotationId]: "JsonString",
-  [AST.TitleAnnotationId]: "JsonString",
-  [AST.DescriptionAnnotationId]: "a string that will be parsed as JSON"
-});
-const getParseJsonTransformation = options => transformOrFail(JsonString, Unknown, {
+const getErrorMessage = e => e instanceof Error ? e.message : String(e);
+const getParseJsonTransformation = options => transformOrFail(String$.annotations({
+  [AST.DescriptionAnnotationId]: "a string to be decoded into JSON"
+}), Unknown, {
   strict: true,
   decode: (s, _, ast) => ParseResult.try({
     try: () => JSON.parse(s, options?.reviver),
-    catch: e => new ParseResult.Type(ast, s, e.message)
+    catch: e => new ParseResult.Type(ast, s, getErrorMessage(e))
   }),
   encode: (u, _, ast) => ParseResult.try({
     try: () => JSON.stringify(u, options?.replacer, options?.space),
-    catch: e => new ParseResult.Type(ast, u, e.message)
+    catch: e => new ParseResult.Type(ast, u, getErrorMessage(e))
   })
 }).annotations({
+  title: "parseJson",
   schemaId: AST.ParseJsonSchemaId
 });
 /**
@@ -2282,12 +2281,12 @@ export class URLFromSelf extends /*#__PURE__*/instanceOf(URL, {
 }) {}
 /** @ignore */
 class URL$ extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a URL"
+  description: "a string to be decoded into a URL"
 }), URLFromSelf, {
   strict: true,
-  decode: (str, _, ast) => ParseResult.try({
-    try: () => new URL(str),
-    catch: () => new ParseResult.Type(ast, str)
+  decode: (s, _, ast) => ParseResult.try({
+    try: () => new URL(s),
+    catch: e => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a URL. ${getErrorMessage(e)}`)
   }),
   encode: url => ParseResult.succeed(url.toString())
 }).annotations({
@@ -2538,7 +2537,7 @@ export const clamp = (minimum, maximum) => self => transform(self, self.pipe(typ
  */
 export const parseNumber = self => transformOrFail(self, Number$, {
   strict: false,
-  decode: (s, _, ast) => ParseResult.fromOption(number_.parse(s), () => new ParseResult.Type(ast, s)),
+  decode: (s, _, ast) => ParseResult.fromOption(number_.parse(s), () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a number`)),
   encode: n => ParseResult.succeed(String(n))
 });
 /**
@@ -2552,7 +2551,7 @@ export const parseNumber = self => transformOrFail(self, Number$, {
  * @since 3.10.0
  */
 export class NumberFromString extends /*#__PURE__*/parseNumber(String$.annotations({
-  description: "a string that will be parsed into a number"
+  description: "a string to be decoded into a number"
 })).annotations({
   identifier: "NumberFromString"
 }) {}
@@ -2645,24 +2644,43 @@ export class Not extends /*#__PURE__*/transform( /*#__PURE__*/Boolean$.annotatio
   decode: boolean_.not,
   encode: boolean_.not
 }) {}
+const encodeSymbol = (sym, _, ast) => {
+  const key = Symbol.keyFor(sym);
+  return key === undefined ? ParseResult.fail(new ParseResult.Type(ast, sym, `Unable to encode a unique symbol ${String(sym)} into a string`)) : ParseResult.succeed(key);
+};
+const decodeSymbol = s => ParseResult.succeed(Symbol.for(s));
 /** @ignore */
-class Symbol$ extends /*#__PURE__*/transform(String$.annotations({
-  description: "a string that will be converted to a symbol"
+class Symbol$ extends /*#__PURE__*/transformOrFail(String$.annotations({
+  description: "a string to be decoded into a globally shared symbol"
 }), SymbolFromSelf, {
   strict: false,
-  decode: s => Symbol.for(s),
-  encode: sym => sym.description
+  decode: decodeSymbol,
+  encode: encodeSymbol
 }).annotations({
-  identifier: "symbol"
+  identifier: "Symbol"
 }) {}
 export {
 /**
- * This schema transforms a `string` into a `symbol`.
+ * Converts a string key into a globally shared symbol.
  *
  * @category symbol transformations
  * @since 3.10.0
  */
 Symbol$ as Symbol };
+const SymbolStruct = /*#__PURE__*/TaggedStruct("symbol", {
+  key: String$
+}).annotations({
+  description: "an object to be decoded into a globally shared symbol"
+});
+const SymbolFromStruct = /*#__PURE__*/transformOrFail(SymbolStruct, SymbolFromSelf, {
+  strict: true,
+  decode: ({
+    key
+  }) => decodeSymbol(key),
+  encode: (sym, _, ast) => ParseResult.map(encodeSymbol(sym, _, ast), key => SymbolStruct.make({
+    key
+  }))
+});
 /**
  * @category schema id
  * @since 3.10.0
@@ -2802,13 +2820,13 @@ export const clampBigInt = (minimum, maximum) => self => transform(self, self.pi
 });
 /** @ignore */
 class BigInt$ extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a bigint"
+  description: "a string to be decoded into a bigint"
 }), BigIntFromSelf, {
   strict: true,
-  decode: (s, _, ast) => ParseResult.fromOption(bigInt_.fromString(s), () => new ParseResult.Type(ast, s)),
+  decode: (s, _, ast) => ParseResult.fromOption(bigInt_.fromString(s), () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a bigint`)),
   encode: n => ParseResult.succeed(String(n))
 }).annotations({
-  identifier: "bigint"
+  identifier: "BigInt"
 }) {}
 export {
 /**
@@ -2885,13 +2903,13 @@ export const NonNegativeBigInt = /*#__PURE__*/BigInt$.pipe( /*#__PURE__*/nonNega
  * @since 3.10.0
  */
 export class BigIntFromNumber extends /*#__PURE__*/transformOrFail(Number$.annotations({
-  description: "a number that will be parsed into a bigint"
-}), BigIntFromSelf, {
+  description: "a number to be decoded into a bigint"
+}), BigIntFromSelf.pipe(betweenBigInt(BigInt(Number.MIN_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))), {
   strict: true,
-  decode: (n, _, ast) => ParseResult.fromOption(bigInt_.fromNumber(n), () => new ParseResult.Type(ast, n)),
-  encode: (b, _, ast) => ParseResult.fromOption(bigInt_.toNumber(b), () => new ParseResult.Type(ast, b))
+  decode: (n, _, ast) => ParseResult.fromOption(bigInt_.fromNumber(n), () => new ParseResult.Type(ast, n, `Unable to decode ${n} into a bigint`)),
+  encode: (b, _, ast) => ParseResult.fromOption(bigInt_.toNumber(b), () => new ParseResult.Type(ast, b, `Unable to encode ${b}n into a number`))
 }).annotations({
-  identifier: "BigintFromNumber"
+  identifier: "BigIntFromNumber"
 }) {}
 const redactedArbitrary = value => fc => value(fc).map(redacted_.make);
 const toComposite = (eff, onSuccess, ast, actual) => ParseResult.mapBoth(eff, {
@@ -2932,70 +2950,83 @@ export const Redacted = value => {
 export class DurationFromSelf extends /*#__PURE__*/declare(duration_.isDuration, {
   identifier: "DurationFromSelf",
   pretty: () => String,
-  arbitrary: () => fc => fc.oneof(fc.constant(duration_.infinity), fc.bigUint().map(_ => duration_.nanos(_)), fc.bigUint().map(_ => duration_.micros(_)), fc.maxSafeNat().map(_ => duration_.millis(_)), fc.maxSafeNat().map(_ => duration_.seconds(_)), fc.maxSafeNat().map(_ => duration_.minutes(_)), fc.maxSafeNat().map(_ => duration_.hours(_)), fc.maxSafeNat().map(_ => duration_.days(_)), fc.maxSafeNat().map(_ => duration_.weeks(_))),
+  arbitrary: () => fc => fc.oneof(fc.constant(duration_.infinity), fc.bigInt({
+    min: 0n
+  }).map(_ => duration_.nanos(_)), fc.maxSafeNat().map(_ => duration_.millis(_))),
   equivalence: () => duration_.Equivalence
 }) {}
 /**
- * A schema that transforms a `bigint` tuple into a `Duration`.
- * Treats the value as the number of nanoseconds.
+ * A schema that transforms a non negative `bigint` into a `Duration`. Treats
+ * the value as the number of nanoseconds.
  *
  * @category Duration transformations
  * @since 3.10.0
  */
-export class DurationFromNanos extends /*#__PURE__*/transformOrFail(BigIntFromSelf.annotations({
-  description: "a bigint that will be parsed into a Duration"
-}), DurationFromSelf, {
+export class DurationFromNanos extends /*#__PURE__*/transformOrFail(NonNegativeBigIntFromSelf.annotations({
+  description: "a bigint to be decoded into a Duration"
+}), DurationFromSelf.pipe(filter(duration => duration_.isFinite(duration), {
+  description: "a finite duration"
+})), {
   strict: true,
   decode: nanos => ParseResult.succeed(duration_.nanos(nanos)),
   encode: (duration, _, ast) => option_.match(duration_.toNanos(duration), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, duration)),
-    onSome: val => ParseResult.succeed(val)
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, duration, `Unable to encode ${duration} into a bigint`)),
+    onSome: nanos => ParseResult.succeed(nanos)
   })
 }).annotations({
   identifier: "DurationFromNanos"
 }) {}
 /**
- * A schema that transforms a `number` tuple into a `Duration`.
- * Treats the value as the number of milliseconds.
+ * A non-negative integer. +Infinity is excluded.
+ *
+ * @category number constructors
+ * @since 3.11.10
+ */
+export const NonNegativeInt = /*#__PURE__*/NonNegative.pipe(int()).annotations({
+  identifier: "NonNegativeInt"
+});
+/**
+ * A schema that transforms a (possibly Infinite) non negative number into a
+ * `Duration`. Treats the value as the number of milliseconds.
  *
  * @category Duration transformations
  * @since 3.10.0
  */
-export class DurationFromMillis extends /*#__PURE__*/transform(Number$.annotations({
-  description: "a number that will be parsed into a Duration"
+export class DurationFromMillis extends /*#__PURE__*/transform(NonNegative.annotations({
+  description: "a non-negative number to be decoded into a Duration"
 }), DurationFromSelf, {
   strict: true,
   decode: ms => duration_.millis(ms),
-  encode: n => duration_.toMillis(n)
+  encode: duration => duration_.toMillis(duration)
 }).annotations({
   identifier: "DurationFromMillis"
 }) {}
-/**
- * @category number constructors
- * @since 3.11.10
- */
-export const NonNegativeInt = /*#__PURE__*/NonNegative.pipe(int()).annotations({
-  identifier: "NonNegativeInt"
-});
-const HRTime = /*#__PURE__*/Tuple(element(NonNegativeInt).annotations({
+const FiniteHRTime = /*#__PURE__*/Tuple(element(NonNegativeInt).annotations({
   title: "seconds"
 }), element(NonNegativeInt).annotations({
   title: "nanos"
 })).annotations({
-  identifier: "HRTime"
+  identifier: "FiniteHRTime"
+});
+const InfiniteHRTime = /*#__PURE__*/Tuple(Literal(-1), Literal(0)).annotations({
+  identifier: "InfiniteHRTime"
+});
+const HRTime = /*#__PURE__*/Union(FiniteHRTime, InfiniteHRTime).annotations({
+  identifier: "HRTime",
+  description: "a tuple of seconds and nanos to be decoded into a Duration"
 });
 /**
  * A schema that transforms a `[number, number]` tuple into a `Duration`.
  *
+ * Infinite durations are encoded as `[-1, 0]`.
+ *
  * @category Duration transformations
  * @since 3.10.0
  */
-export class Duration extends /*#__PURE__*/transform(HRTime.annotations({
-  description: "a tuple of seconds and nanos that will be parsed into a Duration"
-}), DurationFromSelf, {
+export class Duration extends /*#__PURE__*/transform(HRTime, DurationFromSelf, {
   strict: true,
-  decode: ([seconds, nanos]) => duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos)),
-  encode: duration => duration_.toHrTime(duration)
+  decode: ([seconds, nanos]) => seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos)),
+  encode: duration => duration.value._tag === "Infinity" ? [-1, 0] : duration_.toHrTime(duration)
 }).annotations({
   identifier: "Duration"
 }) {}
@@ -3126,7 +3157,7 @@ export const Uint8 = /*#__PURE__*/Number$.pipe( /*#__PURE__*/between(0, 255, {
   description: "a 8-bit unsigned integer"
 }));
 const Uint8Array$ = /*#__PURE__*/transform(Array$(Uint8).annotations({
-  description: "an array of 8-bit unsigned integers that will be parsed into a Uint8Array"
+  description: "an array of 8-bit unsigned integers to be decoded into a Uint8Array"
 }), Uint8ArrayFromSelf, {
   strict: true,
   decode: numbers => Uint8Array.from(numbers),
@@ -3143,7 +3174,7 @@ export {
  */
 Uint8Array$ as Uint8Array };
 const makeUint8ArrayTransformation = (id, decode, encode) => transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a Uint8Array"
+  description: "a string to be decoded into a Uint8Array"
 }), Uint8ArrayFromSelf, {
   strict: true,
   decode: (s, _, ast) => either_.mapLeft(decode(s), decodeException => new ParseResult.Type(ast, s, decodeException.message)),
@@ -3267,16 +3298,22 @@ export const MaxItemsSchemaId = schemaId_.MaxItemsSchemaId;
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export const maxItems = (n, annotations) => self => self.pipe(filter(a => a.length <= n, {
-  schemaId: MaxItemsSchemaId,
-  title: `maxItems(${n})`,
-  description: `an array of at most ${n} item(s)`,
-  jsonSchema: {
-    maxItems: n
-  },
-  [AST.StableFilterAnnotationId]: true,
-  ...annotations
-}));
+export const maxItems = (n, annotations) => self => {
+  const maxItems = Math.floor(n);
+  if (maxItems < 1) {
+    throw new Error(errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 1, actual ${n}`));
+  }
+  return self.pipe(filter(a => a.length <= maxItems, {
+    schemaId: MaxItemsSchemaId,
+    title: `maxItems(${maxItems})`,
+    description: `an array of at most ${maxItems} item(s)`,
+    jsonSchema: {
+      maxItems
+    },
+    [AST.StableFilterAnnotationId]: true,
+    ...annotations
+  }));
+};
 /**
  * @category schema id
  * @since 3.10.0
@@ -3286,17 +3323,23 @@ export const ItemsCountSchemaId = schemaId_.ItemsCountSchemaId;
  * @category ReadonlyArray filters
  * @since 3.10.0
  */
-export const itemsCount = (n, annotations) => self => self.pipe(filter(a => a.length === n, {
-  schemaId: ItemsCountSchemaId,
-  title: `itemsCount(${n})`,
-  description: `an array of exactly ${n} item(s)`,
-  jsonSchema: {
-    minItems: n,
-    maxItems: n
-  },
-  [AST.StableFilterAnnotationId]: true,
-  ...annotations
-}));
+export const itemsCount = (n, annotations) => self => {
+  const itemsCount = Math.floor(n);
+  if (itemsCount < 1) {
+    throw new Error(errors_.getInvalidArgumentErrorMessage(`Expected an integer greater than or equal to 1, actual ${n}`));
+  }
+  return self.pipe(filter(a => a.length === itemsCount, {
+    schemaId: ItemsCountSchemaId,
+    title: `itemsCount(${itemsCount})`,
+    description: `an array of exactly ${itemsCount} item(s)`,
+    jsonSchema: {
+      minItems: itemsCount,
+      maxItems: itemsCount
+    },
+    [AST.StableFilterAnnotationId]: true,
+    ...annotations
+  }));
+};
 /**
  * @category ReadonlyArray transformations
  * @since 3.10.0
@@ -3337,7 +3380,7 @@ export const headNonEmpty = self => transform(self, getNumberIndexedAccess(typeS
  */
 export const headOrElse = /*#__PURE__*/dual(args => isSchema(args[0]), (self, fallback) => transformOrFail(self, getNumberIndexedAccess(typeSchema(self)), {
   strict: true,
-  decode: (as, _, ast) => as.length > 0 ? ParseResult.succeed(as[0]) : fallback ? ParseResult.succeed(fallback()) : ParseResult.fail(new ParseResult.Type(ast, as)),
+  decode: (as, _, ast) => as.length > 0 ? ParseResult.succeed(as[0]) : fallback ? ParseResult.succeed(fallback()) : ParseResult.fail(new ParseResult.Type(ast, as, "Unable to retrieve the first element of an empty array")),
   encode: a => ParseResult.succeed(array_.of(a))
 }));
 /**
@@ -3503,7 +3546,7 @@ export class ValidDateFromSelf extends /*#__PURE__*/DateFromSelf.pipe( /*#__PURE
  * @since 3.10.0
  */
 export class DateFromString extends /*#__PURE__*/transform(String$.annotations({
-  description: "a string that will be parsed into a Date"
+  description: "a string to be decoded into a Date"
 }), DateFromSelf, {
   strict: true,
   decode: s => new Date(s),
@@ -3537,7 +3580,7 @@ Date$ as Date };
  * @since 3.10.0
  */
 export class DateFromNumber extends /*#__PURE__*/transform(Number$.annotations({
-  description: "a number that will be parsed into a Date"
+  description: "a number to be decoded into a Date"
 }), DateFromSelf, {
   strict: true,
   decode: n => new Date(n),
@@ -3555,12 +3598,14 @@ export class DateTimeUtcFromSelf extends /*#__PURE__*/declare(u => dateTime.isDa
   identifier: "DateTimeUtcFromSelf",
   description: "a DateTime.Utc instance",
   pretty: () => dateTime => dateTime.toString(),
-  arbitrary: () => fc => fc.date().map(date => dateTime.unsafeFromDate(date)),
+  arbitrary: () => fc => fc.date({
+    noInvalidDate: true
+  }).map(date => dateTime.unsafeFromDate(date)),
   equivalence: () => dateTime.Equivalence
 }) {}
-const decodeDateTime = (input, _, ast) => ParseResult.try({
+const decodeDateTimeUtc = (input, _, ast) => ParseResult.try({
   try: () => dateTime.unsafeMake(input),
-  catch: () => new ParseResult.Type(ast, input)
+  catch: () => new ParseResult.Type(ast, input, `Unable to decode ${util_.formatUnknown(input)} into a DateTime.Utc`)
 });
 /**
  * Defines a schema that attempts to convert a `number` to a `DateTime.Utc` instance using the `DateTime.unsafeMake` constructor.
@@ -3569,10 +3614,10 @@ const decodeDateTime = (input, _, ast) => ParseResult.try({
  * @since 3.10.0
  */
 export class DateTimeUtcFromNumber extends /*#__PURE__*/transformOrFail(Number$.annotations({
-  description: "a number that will be parsed into a DateTime.Utc"
+  description: "a number to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTime,
+  decode: decodeDateTimeUtc,
   encode: dt => ParseResult.succeed(dateTime.toEpochMillis(dt))
 }).annotations({
   identifier: "DateTimeUtcFromNumber"
@@ -3584,10 +3629,10 @@ export class DateTimeUtcFromNumber extends /*#__PURE__*/transformOrFail(Number$.
  * @since 3.12.0
  */
 export class DateTimeUtcFromDate extends /*#__PURE__*/transformOrFail(DateFromSelf.annotations({
-  description: "a Date that will be parsed into a DateTime.Utc"
+  description: "a Date to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTime,
+  decode: decodeDateTimeUtc,
   encode: dt => ParseResult.succeed(dateTime.toDateUtc(dt))
 }).annotations({
   identifier: "DateTimeUtcFromDate"
@@ -3599,17 +3644,17 @@ export class DateTimeUtcFromDate extends /*#__PURE__*/transformOrFail(DateFromSe
  * @since 3.10.0
  */
 export class DateTimeUtc extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a DateTime.Utc"
+  description: "a string to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTime,
+  decode: decodeDateTimeUtc,
   encode: dt => ParseResult.succeed(dateTime.formatIso(dt))
 }).annotations({
   identifier: "DateTimeUtc"
 }) {}
 const timeZoneOffsetArbitrary = () => fc => fc.integer({
   min: -12 * 60 * 60 * 1000,
-  max: 12 * 60 * 60 * 1000
+  max: 14 * 60 * 60 * 1000
 }).map(dateTime.zoneMakeOffset);
 /**
  * Describes a schema that represents a `TimeZone.Offset` instance.
@@ -3630,7 +3675,7 @@ export class TimeZoneOffsetFromSelf extends /*#__PURE__*/declare(dateTime.isTime
  * @since 3.10.0
  */
 export class TimeZoneOffset extends /*#__PURE__*/transform(Number$.annotations({
-  description: "a number that will be parsed into a TimeZone.Offset"
+  description: "a number to be decoded into a TimeZone.Offset"
 }), TimeZoneOffsetFromSelf, {
   strict: true,
   decode: dateTime.zoneMakeOffset,
@@ -3658,12 +3703,12 @@ export class TimeZoneNamedFromSelf extends /*#__PURE__*/declare(dateTime.isTimeZ
  * @since 3.10.0
  */
 export class TimeZoneNamed extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a TimeZone.Named"
+  description: "a string to be decoded into a TimeZone.Named"
 }), TimeZoneNamedFromSelf, {
   strict: true,
   decode: (s, _, ast) => ParseResult.try({
     try: () => dateTime.zoneUnsafeMakeNamed(s),
-    catch: () => new ParseResult.Type(ast, s)
+    catch: () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone.Named`)
   }),
   encode: tz => ParseResult.succeed(tz.id)
 }).annotations({
@@ -3673,7 +3718,7 @@ export class TimeZoneNamed extends /*#__PURE__*/transformOrFail(String$.annotati
  * @category TimeZone constructors
  * @since 3.10.0
  */
-export const TimeZoneFromSelf = /*#__PURE__*/Union(TimeZoneOffsetFromSelf, TimeZoneNamedFromSelf);
+export class TimeZoneFromSelf extends /*#__PURE__*/Union(TimeZoneOffsetFromSelf, TimeZoneNamedFromSelf) {}
 /**
  * Defines a schema that attempts to convert a `string` to a `TimeZone` using the `DateTime.zoneFromString` constructor.
  *
@@ -3681,11 +3726,11 @@ export const TimeZoneFromSelf = /*#__PURE__*/Union(TimeZoneOffsetFromSelf, TimeZ
  * @since 3.10.0
  */
 export class TimeZone extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a TimeZone"
+  description: "a string to be decoded into a TimeZone"
 }), TimeZoneFromSelf, {
   strict: true,
   decode: (s, _, ast) => option_.match(dateTime.zoneFromString(s), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s)),
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone`)),
     onSome: ParseResult.succeed
   }),
   encode: tz => ParseResult.succeed(dateTime.zoneToString(tz))
@@ -3703,9 +3748,13 @@ export class DateTimeZonedFromSelf extends /*#__PURE__*/declare(u => dateTime.is
   identifier: "DateTimeZonedFromSelf",
   description: "a DateTime.Zoned instance",
   pretty: () => dateTime => dateTime.toString(),
-  arbitrary: () => fc => fc.date().chain(date => timeZoneArbitrary(fc).map(timeZone => dateTime.unsafeMakeZoned(date, {
+  arbitrary: () => fc => fc.tuple(fc.integer({
+    // time zone db supports +/- 1000 years or so
+    min: -31536000000000,
+    max: 31536000000000
+  }), timeZoneArbitrary(fc)).map(([millis, timeZone]) => dateTime.unsafeMakeZoned(millis, {
     timeZone
-  }))),
+  })),
   equivalence: () => dateTime.Equivalence
 }) {}
 /**
@@ -3715,11 +3764,11 @@ export class DateTimeZonedFromSelf extends /*#__PURE__*/declare(u => dateTime.is
  * @since 3.10.0
  */
 export class DateTimeZoned extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a DateTime.Zoned"
+  description: "a string to be decoded into a DateTime.Zoned"
 }), DateTimeZonedFromSelf, {
   strict: true,
   decode: (s, _, ast) => option_.match(dateTime.makeZonedFromString(s), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s)),
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a DateTime.Zoned`)),
     onSome: ParseResult.succeed
   }),
   encode: dt => ParseResult.succeed(dateTime.formatIsoZoned(dt))
@@ -4059,7 +4108,7 @@ export const ReadonlyMapFromRecord = ({
   key: encodedBoundSchema(key),
   value
 }).annotations({
-  description: "a record that will be parsed into a ReadonlyMap"
+  description: "a record to be decoded into a ReadonlyMap"
 }), ReadonlyMapFromSelf({
   key,
   value: typeSchema(value)
@@ -4079,7 +4128,7 @@ export const MapFromRecord = ({
   key: encodedBoundSchema(key),
   value
 }).annotations({
-  description: "a record that will be parsed into a Map"
+  description: "a record to be decoded into a Map"
 }), MapFromSelf({
   key,
   value: typeSchema(value)
@@ -4163,11 +4212,11 @@ export class BigDecimalFromSelf extends /*#__PURE__*/declare(bigDecimal_.isBigDe
  * @since 3.10.0
  */
 export class BigDecimal extends /*#__PURE__*/transformOrFail(String$.annotations({
-  description: "a string that will be parsed into a BigDecimal"
+  description: "a string to be decoded into a BigDecimal"
 }), BigDecimalFromSelf, {
   strict: true,
-  decode: (num, _, ast) => bigDecimal_.fromString(num).pipe(option_.match({
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, num)),
+  decode: (s, _, ast) => bigDecimal_.fromString(s).pipe(option_.match({
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a BigDecimal`)),
     onSome: val => ParseResult.succeed(bigDecimal_.normalize(val))
   })),
   encode: val => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(val)))
@@ -4181,12 +4230,12 @@ export class BigDecimal extends /*#__PURE__*/transformOrFail(String$.annotations
  * @category BigDecimal transformations
  * @since 3.10.0
  */
-export class BigDecimalFromNumber extends /*#__PURE__*/transformOrFail(Number$.annotations({
-  description: "a number that will be parsed into a BigDecimal"
+export class BigDecimalFromNumber extends /*#__PURE__*/transform(Number$.annotations({
+  description: "a number to be decoded into a BigDecimal"
 }), BigDecimalFromSelf, {
   strict: true,
-  decode: num => ParseResult.succeed(bigDecimal_.unsafeFromNumber(num)),
-  encode: val => ParseResult.succeed(bigDecimal_.unsafeToNumber(val))
+  decode: bigDecimal_.unsafeFromNumber,
+  encode: bigDecimal_.unsafeToNumber
 }).annotations({
   identifier: "BigDecimalFromNumber"
 }) {}
@@ -5695,4 +5744,31 @@ const go = (ast, path) => {
       }
   }
 };
+/** @ignore */
+class PropertyKey$ extends /*#__PURE__*/Union(String$, Number$, SymbolFromStruct).annotations({
+  identifier: "PropertyKey"
+}) {}
+export {
+/**
+ * @since 3.12.5
+ */
+PropertyKey$ as PropertyKey };
+/**
+ * @category ArrayFormatter
+ * @since 3.12.5
+ */
+export class ArrayFormatterIssue extends /*#__PURE__*/Struct({
+  _tag: propertySignature(Literal("Pointer", "Unexpected", "Missing", "Composite", "Refinement", "Transformation", "Type", "Forbidden")).annotations({
+    description: "The tag identifying the type of parse issue"
+  }),
+  path: propertySignature(Array$(PropertyKey$)).annotations({
+    description: "The path to the property where the issue occurred"
+  }),
+  message: propertySignature(String$).annotations({
+    description: "A descriptive message explaining the issue"
+  })
+}).annotations({
+  identifier: "ArrayFormatterIssue",
+  description: "Represents an issue returned by the ArrayFormatter formatter"
+}) {}
 //# sourceMappingURL=Schema.js.map