@stakekit/widget 0.0.287 → 0.0.288

package/dist/package/{Schema-DFoi51wt.js → Schema-CUut1r-H.js}

@@ -1,7 +1,41 @@
 "use client";
-import { At as isNotUndefined, Ct as hasProperty, Dt as isFunction, Et as isError, Ft as isString, Gt as dual, Jt as memoize, Lt as isUnknown, Mt as isObject, Nt as isObjectKeyword, Pt as isPropertyKey, Qt as pipeArguments, St as symbol, T as args, Tt as isBoolean, X as assignProperty, Yt as memoizeIdempotent, Zt as Class, _t as hash, bt as string$1, ct as formatPropertyKey, d as succeed$1, ft as equals$1, gt as combine, h as Error$2, it as format$1, jt as isNumber, kt as isNotNullish, l as mapError, mt as symbol$1, ot as formatJson, pt as makeCompareSet, qt as identity, st as formatPath, t as fail$1, tt as NodeInspectSymbol, vt as number$1, wt as isBigInt } from "./Result-Cem4lYBf.js";
-import { $t as mapEager, Ar as isFailReason, At as fail$2, Bi as isReadonlyArrayNonEmpty, Ca as isLessThanOrEqualTo$3, Dt as die, Ea as make$7, Fr as effectIsExit, Ft as flatMapEager, In as try_, Ki as Service, Mr as map$4, Mt as failCauseSync, On as succeed$3, Pt as flatMap, Qt as mapBothEager, Rr as iterateEager, Rt as fnUntracedEager, Sn as runSyncExit, Sr as IllegalArgumentError, Ti as append, Ui as map$2, Xr as setStackTraceLimit, Yr as getStackTraceLimit, br as succeed$2, bt as catchCause, da as isSome, fa as liftThrowable, ga as some, gr as failCause, ha as none, hi as millis, hr as fail$3, ki as empty$1, kn as succeedNone, kt as exit, ma as match$1, na as filter$1, pa as map$3, ri as TaggedError$1, tr as currentTimeMillis, ua as isNone, wa as make$8, xa as isGreaterThanOrEqualTo$1, xr as void_, xt as catchEager, ya as Number$4, yr as isSuccess, zi as isArrayNonEmpty, zr as map$1 } from "./wagmi-connect-result-BJ91_jis.js";
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Record.js
+import { Bt as isUnknown, Dt as isBoolean, Et as isBigInt, Ft as isObject, It as isObjectKeyword, Jt as dual, Lt as isPropertyKey, Mt as isNotNullish, Nt as isNotUndefined, Ot as isError, Pt as isNumber, Qt as memoizeIdempotent, Rt as isString, St as string$1, T as args, Tt as hasProperty, Xt as identity, Z as assignProperty, Zt as memoize, _t as array, b as PipeInspectableProto, bt as number$1, d as succeed$1, dt as formatPropertyKey, en as Class, et as getStackTraceLimit, gt as symbol$1, h as Error$2, ht as equals$1, it as NodeInspectSymbol, jt as isNever$1, kt as isFunction, l as mapError, lt as formatJson, nt as BaseProto, st as format$1, t as fail$1, tn as pipeArguments, tt as setStackTraceLimit, ut as formatPath, vt as combine, wt as symbol, yt as hash } from "./Result-BA6lrqKV.js";
+import { $t as mapEager, Ar as isFailReason, At as fail$2, Bi as isReadonlyArrayNonEmpty, Br as map$1, Ca as isLessThanOrEqualTo$3, Da as strictEqual, Dt as die, Ea as make$9, Fr as effectIsExit, Ft as flatMapEager, Gr as resolveConcurrency, Hi as makeEquivalence$2, In as try_, Ki as Service, Mr as map$4, Mt as failCauseSync, On as succeed$3, Pi as fromIterable$1, Pt as flatMap, Qt as mapBothEager, Rr as iterateConcurrent, Rt as fnUntracedEager, Sa as isLessThan$1, Sn as runSyncExit, Sr as IllegalArgumentError, Ta as Tuple$1, Ti as append, Ui as map$2, ba as isGreaterThan$1, br as succeed$2, bt as catchCause, da as isSome, fa as liftThrowable, ga as some, gr as failCause, ha as none, hi as millis, hr as fail$3, ki as empty$2, kn as succeedNone, kt as exit, ma as match$1, na as filter$1, pa as map$3, ri as TaggedError$1, tr as currentTimeMillis, ua as isNone, vi as seconds, wa as make$8, xa as isGreaterThanOrEqualTo$1, xr as void_, xt as catchEager, ya as Number$4, yr as isSuccess, zi as isArrayNonEmpty, zr as iterateEager } from "./wagmi-connect-result-Bh6qH5iI.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Tuple.js
+/**
+* Creates an `Equivalence` for tuples by comparing corresponding elements
+* using the provided per-position `Equivalence`s. Two tuples are equivalent
+* when all their corresponding elements are equivalent.
+*
+* **When to use**
+*
+* Use when you need an `Equivalence` to compare tuples element-by-element.
+*
+* **Details**
+*
+* This is an alias of `Equivalence.Tuple`.
+*
+* **Example** (Comparing tuples for equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equivalence, Tuple } from "effect"
+*
+* const eq = Tuple.makeEquivalence([
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<number>()
+* ])
+*
+* eq(["Alice", 30], ["Alice", 30]) // => true
+* eq(["Alice", 30], ["Bob", 30]) // => false
+* ```
+*
+* @see {@link makeOrder} – create an `Order` for tuples
+* @category instances
+* @since 4.0.0
+*/
+var makeEquivalence$1 = Tuple$1;
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Record.js
 /**
 * Creates a new, empty record.
 *
@@ -21,7 +55,7 @@ import { $t as mapEager, Ar as isFailReason, At as fail$2, Bi as isReadonlyArray
 * @category constructors
 * @since 2.0.0
 */
-var empty = () => ({});
+var empty$1 = () => ({});
 /**
 * Determines if a mutable record is empty.
 *
@@ -115,7 +149,7 @@ var map = /*#__PURE__*/ dual(2, (self, f) => {
 * @since 2.0.0
 */
 var filter = /*#__PURE__*/ dual(2, (self, predicate) => {
-	const out = empty();
+	const out = empty$1();
 	for (const key of keys(self)) if (predicate(self[key], key)) assignProperty(out, key, self[key]);
 	return out;
 });
@@ -183,7 +217,7 @@ var isSubrecordBy = (equivalence) => dual(2, (self, that) => {
 var union$1 = /*#__PURE__*/ dual(3, (self, that, combine) => {
 	if (isEmptyRecord(self)) return { ...that };
 	if (isEmptyRecord(that)) return { ...self };
-	const out = empty();
+	const out = empty$1();
 	for (const key of keys(self)) if (has(that, key)) assignProperty(out, key, combine(self[key], that[key]));
 	else assignProperty(out, key, self[key]);
 	for (const key of keys(that)) if (!has(out, key)) assignProperty(out, key, that[key]);
@@ -212,13 +246,13 @@ var makeEquivalence = (equivalence) => {
 	return (self, that) => is(self, that) && is(that, self);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/internal/dateTime.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
-var TypeId$6 = "~effect/time/DateTime";
+var TypeId$8 = "~effect/DateTime";
 /** @internal */
-var TimeZoneTypeId = "~effect/time/DateTime/TimeZone";
-var Proto = {
-	[TypeId$6]: TypeId$6,
+var TimeZoneTypeId = "~effect/DateTime/TimeZone";
+var Proto$2 = {
+	[TypeId$8]: TypeId$8,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -230,7 +264,7 @@ var Proto = {
 	}
 };
 var ProtoUtc = {
-	...Proto,
+	...Proto$2,
 	_tag: "Utc",
 	[symbol]() {
 		return number$1(this.epochMilliseconds);
@@ -243,7 +277,7 @@ var ProtoUtc = {
 	}
 };
 var ProtoZoned = {
-	...Proto,
+	...Proto$2,
 	_tag: "Zoned",
 	[symbol]() {
 		return combine(number$1(this.epochMilliseconds))(hash(this.zone));
@@ -305,16 +339,14 @@ var makeZonedProto = (epochMillis, zone, partsUtc) => {
 	return self;
 };
 /** @internal */
-var isDateTime$1 = (u) => hasProperty(u, TypeId$6);
+var isDateTime$1 = (u) => hasProperty(u, TypeId$8);
 var isDateTimeArgs = (args) => isDateTime$1(args[0]);
 /** @internal */
 var isTimeZone = (u) => hasProperty(u, TimeZoneTypeId);
 /** @internal */
 var isUtc$1 = (self) => self._tag === "Utc";
 /** @internal */
-var Equivalence$2 = /*#__PURE__*/ make$7((a, b) => a.epochMilliseconds === b.epochMilliseconds);
-/** @internal */
-var Order$2 = /*#__PURE__*/ make$8((self, that) => self.epochMilliseconds < that.epochMilliseconds ? -1 : self.epochMilliseconds > that.epochMilliseconds ? 1 : 0);
+var Order$1 = /*#__PURE__*/ make$8((self, that) => self.epochMilliseconds < that.epochMilliseconds ? -1 : self.epochMilliseconds > that.epochMilliseconds ? 1 : 0);
 var makeUtc = (epochMillis) => {
 	const self = Object.create(ProtoUtc);
 	self.epochMilliseconds = epochMillis;
@@ -326,22 +358,22 @@ var makeUtc = (epochMillis) => {
 	return self;
 };
 /** @internal */
-var fromDateUnsafe$1 = (date) => {
+var fromDateUnsafe = (date) => {
 	const epochMillis = date.getTime();
 	if (Number.isNaN(epochMillis)) throw new IllegalArgumentError("Invalid date");
 	return makeUtc(epochMillis);
 };
 /** @internal */
-var makeUnsafe = (input) => {
+var makeUnsafe$1 = (input) => {
 	if (isDateTime$1(input)) return input;
-	else if (input instanceof Date) return fromDateUnsafe$1(input);
+	else if (input instanceof Date) return fromDateUnsafe(input);
 	else if (typeof input === "object") {
-		if ("epochMilliseconds" in input) return fromDateUnsafe$1(new Date(input.epochMilliseconds));
+		if ("epochMilliseconds" in input) return fromDateUnsafe(new Date(input.epochMilliseconds));
 		const date = /* @__PURE__ */ new Date(0);
 		setPartsDate(date, input);
-		return fromDateUnsafe$1(date);
-	} else if (typeof input === "string" && !hasZone(input)) return fromDateUnsafe$1(/* @__PURE__ */ new Date(input + "Z"));
-	return fromDateUnsafe$1(new Date(input));
+		return fromDateUnsafe(date);
+	} else if (typeof input === "string" && !hasZone(input)) return fromDateUnsafe(/* @__PURE__ */ new Date(input + "Z"));
+	return fromDateUnsafe(new Date(input));
 };
 /**
 * Detects whether a date string already contains timezone info.
@@ -352,7 +384,7 @@ var makeUnsafe = (input) => {
 */
 var hasZone = (input) => /Z|GMT|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input);
 /** @internal */
-var make$6 = /*#__PURE__*/ liftThrowable(makeUnsafe);
+var make$7 = /*#__PURE__*/ liftThrowable(makeUnsafe$1);
 /** @internal */
 var now$1 = /*#__PURE__*/ map$1(currentTimeMillis, makeUtc);
 /** @internal */
@@ -387,7 +419,7 @@ var zoneMakeLocal$1 = () => zoneMakeIntl(new Intl.DateTimeFormat("en-US", format
 /** @internal */
 var distance$1 = /*#__PURE__*/ dual(2, (self, other) => millis(toEpochMillis$1(other) - toEpochMillis$1(self)));
 /** @internal */
-var isLessThanOrEqualTo$2 = /*#__PURE__*/ isLessThanOrEqualTo$3(Order$2);
+var isLessThanOrEqualTo$2 = /*#__PURE__*/ isLessThanOrEqualTo$3(Order$1);
 /** @internal */
 var toDateUtc$1 = (self) => new Date(self.epochMilliseconds);
 /** @internal */
@@ -444,9 +476,7 @@ var toPartsUtc = (self) => {
 	return self.partsUtc;
 };
 var setPartsDate = (date, parts) => {
-	if (parts.year !== void 0) date.setUTCFullYear(parts.year);
-	if (parts.month !== void 0) date.setUTCMonth(parts.month - 1);
-	if (parts.day !== void 0) date.setUTCDate(parts.day);
+	if (parts.year !== void 0 || parts.month !== void 0 || parts.day !== void 0) date.setUTCFullYear(parts.year ?? date.getUTCFullYear(), parts.month !== void 0 ? parts.month - 1 : date.getUTCMonth(), parts.day ?? date.getUTCDate());
 	if (parts.weekDay !== void 0) {
 		const diff = parts.weekDay - date.getUTCDay();
 		date.setUTCDate(date.getUTCDate() + diff);
@@ -550,6 +580,11 @@ var subtract$1 = /*#__PURE__*/ dual(2, (self, parts) => {
 /** @internal */
 var formatLocal$1 = /*#__PURE__*/ dual(isDateTimeArgs, (self, options) => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMilliseconds));
 /** @internal */
+var formatUtc$1 = /*#__PURE__*/ dual(isDateTimeArgs, (self, options) => new Intl.DateTimeFormat(options?.locale, {
+	...options,
+	timeZone: "UTC"
+}).format(self.epochMilliseconds));
+/** @internal */
 var formatIso$1 = (self) => toDateUtc$1(self).toISOString();
 /** @internal */
 var formatIsoOffset = (self) => {
@@ -643,7 +678,7 @@ var trim$2 = (self) => self.trim();
 */
 var startsWith = (searchString, position) => (self) => self.startsWith(searchString, position);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/BigDecimal.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/BigDecimal.js
 /**
 * Decimal numbers and arithmetic for cases where JavaScript `number` rounding
 * is not precise enough. A `BigDecimal` stores digits as a `bigint` plus a
@@ -653,9 +688,9 @@ var startsWith = (searchString, position) => (self) => self.startsWith(searchStr
 *
 * @since 2.0.0
 */
-var TypeId$5 = "~effect/BigDecimal";
+var TypeId$7 = "~effect/BigDecimal";
 var BigDecimalProto = {
-	[TypeId$5]: TypeId$5,
+	[TypeId$7]: TypeId$7,
 	[symbol]() {
 		const normalized = normalize(this);
 		return combine(hash(normalized.value), number$1(normalized.scale));
@@ -702,15 +737,19 @@ var BigDecimalProto = {
 * @category guards
 * @since 2.0.0
 */
-var isBigDecimal = (u) => hasProperty(u, TypeId$5);
+var isBigDecimal = (u) => hasProperty(u, TypeId$7);
 /**
-* Creates a `BigDecimal` from a `bigint` value and a scale.
+* Creates a `BigDecimal` from a `bigint` value and a safe integer scale.
 *
 * **When to use**
 *
 * Use to construct a decimal directly from its unscaled integer value and
 * decimal scale.
 *
+* **Gotchas**
+*
+* Throws a `RangeError` if `scale` is not a safe integer.
+*
 * **Example** (Creating decimals from bigint and scale)
 *
 * ```ts import.meta.vitest
@@ -730,7 +769,8 @@ var isBigDecimal = (u) => hasProperty(u, TypeId$5);
 * @category constructors
 * @since 2.0.0
 */
-var make$5 = (value, scale) => {
+var make$6 = (value, scale) => {
+	if (!Number.isSafeInteger(scale)) throw new RangeError(`Scale must be a safe integer, got ${scale}`);
 	const o = Object.create(BigDecimalProto);
 	o.value = value;
 	o.scale = scale;
@@ -743,11 +783,12 @@ var make$5 = (value, scale) => {
 */
 var makeNormalizedUnsafe = (value, scale) => {
 	if (value !== bigint0 && value % bigint10 === bigint0) throw new RangeError("Value must be normalized");
-	const o = make$5(value, scale);
+	const o = make$6(value, scale);
 	o.normalized = o;
 	return o;
 };
 var bigint0 = /*#__PURE__*/ BigInt(0);
+var bigint1 = /*#__PURE__*/ BigInt(1);
 var bigint10 = /*#__PURE__*/ BigInt(10);
 var zero = /*#__PURE__*/ makeNormalizedUnsafe(bigint0, 0);
 /**
@@ -789,45 +830,55 @@ var normalize = (self) => {
 	}
 	return self.normalized;
 };
+var MAX_COMPARISON_SCALE_ALIGNMENT = 100;
+var comparisonPowersOfTen = [bigint1];
+var compareBigInt = (self, that) => self === that ? 0 : self < that ? -1 : 1;
+var compareMagnitude = (self, that) => {
+	const selfDigits = `${self.value < bigint0 ? -self.value : self.value}`;
+	const thatDigits = `${that.value < bigint0 ? -that.value : that.value}`;
+	const exponentDifference = BigInt(selfDigits.length - thatDigits.length) - BigInt(self.scale) + BigInt(that.scale);
+	if (exponentDifference !== bigint0) return exponentDifference < bigint0 ? -1 : 1;
+	const length = Math.max(selfDigits.length, thatDigits.length);
+	for (let i = 0; i < length; i++) {
+		const selfDigit = i < selfDigits.length ? selfDigits.charCodeAt(i) : 48;
+		const thatDigit = i < thatDigits.length ? thatDigits.charCodeAt(i) : 48;
+		if (selfDigit !== thatDigit) return selfDigit < thatDigit ? -1 : 1;
+	}
+	return 0;
+};
+var compare = (self, that) => {
+	if (self.scale === that.scale) return compareBigInt(self.value, that.value);
+	const selfSign = sign(self);
+	const thatSign = sign(that);
+	if (selfSign !== thatSign) return selfSign < thatSign ? -1 : 1;
+	if (selfSign === 0) return 0;
+	const scaleDifference = self.scale - that.scale;
+	const absoluteScaleDifference = Math.abs(scaleDifference);
+	if (absoluteScaleDifference > MAX_COMPARISON_SCALE_ALIGNMENT) return selfSign === -1 ? compareMagnitude(that, self) : compareMagnitude(self, that);
+	const powerOfTen = comparisonPowersOfTen[absoluteScaleDifference] ??= bigint10 ** BigInt(absoluteScaleDifference);
+	return scaleDifference > 0 ? compareBigInt(self.value, that.value * powerOfTen) : compareBigInt(self.value * powerOfTen, that.value);
+};
 /**
-* Changes a `BigDecimal` to the specified scale.
+* Determines the sign of a given `BigDecimal`.
 *
 * **When to use**
 *
-* Use to change how many decimal places are represented by a `BigDecimal`.
-*
-* **Details**
-*
-* Increasing the scale appends decimal zeros. Decreasing the scale discards
-* digits beyond the target scale by `bigint` division, which truncates toward
-* zero.
+* Use to classify a `BigDecimal` as negative, zero, or positive.
 *
-* **Example** (Scaling decimal precision)
+* **Example** (Reading decimal signs)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
-* const decimal = BigDecimal.fromNumberUnsafe(123.45)
-*
-* // Increase scale (add more precision)
-* const scaled = BigDecimal.scale(decimal, 4)
-* const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]
-*
-* // Decrease scale (reduce precision, truncating toward zero)
-* const reduced = BigDecimal.scale(decimal, 1)
-* reduced // => BigDecimal.fromStringUnsafe("123.4")
+* BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")) // => -1
+* BigDecimal.sign(BigDecimal.fromStringUnsafe("0")) // => 0
+* BigDecimal.sign(BigDecimal.fromStringUnsafe("5")) // => 1
 * ```
 *
-* @see {@link round} for changing scale with configurable rounding
-*
-* @category scaling
+* @category math
 * @since 2.0.0
 */
-var scale = /*#__PURE__*/ dual(2, (self, scale) => {
-	if (scale > self.scale) return make$5(self.value * bigint10 ** BigInt(scale - self.scale), scale);
-	if (scale < self.scale) return make$5(self.value / bigint10 ** BigInt(self.scale - scale), scale);
-	return self;
-});
+var sign = (n) => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;
 /**
 * Determines the absolute value of a given `BigDecimal`.
 *
@@ -848,7 +899,7 @@ var scale = /*#__PURE__*/ dual(2, (self, scale) => {
 * @category math
 * @since 2.0.0
 */
-var abs = (n) => n.value < bigint0 ? make$5(-n.value, n.scale) : n;
+var abs = (n) => n.value < bigint0 ? make$6(-n.value, n.scale) : n;
 /**
 * Provides an `Equivalence` instance for `BigDecimal` that determines equality between BigDecimal values.
 *
@@ -873,11 +924,7 @@ var abs = (n) => n.value < bigint0 ? make$5(-n.value, n.scale) : n;
 * @category instances
 * @since 2.0.0
 */
-var Equivalence$1 = /*#__PURE__*/ make$7((self, that) => {
-	if (self.scale > that.scale) return scale(that, self.scale).value === self.value;
-	if (self.scale < that.scale) return scale(self, that.scale).value === that.value;
-	return self.value === that.value;
-});
+var Equivalence$1 = /*#__PURE__*/ make$9((self, that) => compare(self, that) === 0);
 /**
 * Checks whether two `BigDecimal`s are equal.
 *
@@ -1029,7 +1076,7 @@ var isZero = (n) => n.value === bigint0;
 */
 var isNegative = (n) => n.value < bigint0;
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/DateTime.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/DateTime.js
 /**
 * Checks whether a value is a `DateTime`.
 *
@@ -1060,75 +1107,40 @@ var isDateTime = isDateTime$1;
 */
 var isUtc = isUtc$1;
 /**
-* Provides an `Equivalence` for comparing two `DateTime` values for equality.
-*
-* **Details**
-*
-* Two `DateTime` values are considered equivalent if they represent the same
-* point in time, regardless of their time zone.
-*
-* **Example** (Comparing DateTime values for equivalence)
-*
-* ```ts import.meta.vitest
-* import { DateTime } from "effect"
-*
-* const utc = DateTime.makeUnsafe("2024-01-01T12:00:00Z")
-* const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
-*   timeZone: "Europe/London"
-* })
+* Create a `DateTime` from supported input values.
 *
-* DateTime.Equivalence(utc, zoned) // => true
-* ```
+* **When to use**
 *
-* @category instances
-* @since 3.6.0
-*/
-var Equivalence = Equivalence$2;
-/**
-* Provides an `Order` for comparing and sorting `DateTime` values.
+* Use when creating a `DateTime` from trusted input and construction failures
+* should throw an `IllegalArgumentError` instead of returning `Option.none`.
 *
 * **Details**
 *
-* `DateTime` values are ordered by their epoch milliseconds, so earlier times
-* come before later times regardless of time zone.
+* - A `DateTime`
+* - A `Date` instance (invalid dates will throw an `IllegalArgumentError`)
+* - The `number` of milliseconds since the Unix epoch
+* - An object with the parts of a date
+* - A `string` that can be parsed by `Date.parse`
 *
-* **Example** (Sorting DateTime values chronologically)
+* **Example** (Creating DateTime values unsafely)
 *
 * ```ts import.meta.vitest
-* import { Array, DateTime } from "effect"
-*
-* const dates = [
-*   DateTime.makeUnsafe("2024-03-01"),
-*   DateTime.makeUnsafe("2024-01-01"),
-*   DateTime.makeUnsafe("2024-02-01")
-* ]
-*
-* Array.sort(dates, DateTime.Order).map(DateTime.formatIsoDateUtc) // => ["2024-01-01", "2024-02-01", "2024-03-01"]
-* ```
-*
-* @category instances
-* @since 3.6.0
-*/
-var Order = Order$2;
-/**
-* Create a `DateTime` from a `Date`.
-*
-* **Details**
-*
-* If the `Date` is invalid, an `IllegalArgumentError` will be thrown.
+* import { DateTime } from "effect"
 *
-* **Example** (Creating DateTime values from Dates)
+* // from Date
+* DateTime.makeUnsafe(new Date("2024-01-01T12:00:00Z")) // => DateTime.makeUnsafe("2024-01-01T12:00:00Z")
 *
-* ```ts import.meta.vitest
-* import { DateTime } from "effect"
+* // from parts
+* DateTime.makeUnsafe({ year: 2024 }) // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
 *
-* DateTime.fromDateUnsafe(new Date("2024-01-01T12:00:00Z")) // => DateTime.makeUnsafe("2024-01-01T12:00:00Z")
+* // from string
+* DateTime.makeUnsafe("2024-01-01") // => DateTime.makeUnsafe("2024-01-01T00:00:00Z")
 * ```
 *
 * @category constructors
 * @since 4.0.0
 */
-var fromDateUnsafe = fromDateUnsafe$1;
+var makeUnsafe = makeUnsafe$1;
 /**
 * Creates a `DateTime` safely from supported input values.
 *
@@ -1164,7 +1176,7 @@ var fromDateUnsafe = fromDateUnsafe$1;
 * @category constructors
 * @since 3.6.0
 */
-var make$4 = make$6;
+var make$5 = make$7;
 /**
 * Gets the current time using the `Clock` service and converts it to a `DateTime`.
 *
@@ -1321,29 +1333,6 @@ var distance = distance$1;
 */
 var isLessThanOrEqualTo$1 = isLessThanOrEqualTo$2;
 /**
-* Gets the UTC `Date` of a `DateTime`.
-*
-* **Details**
-*
-* This always returns the UTC representation, ignoring any time zone information.
-*
-* **Example** (Converting DateTime values to UTC Dates)
-*
-* ```ts import.meta.vitest
-* import { DateTime } from "effect"
-*
-* const dt = DateTime.makeZonedUnsafe("2024-01-01T12:00:00Z", {
-*   timeZone: "Europe/London"
-* })
-*
-* DateTime.toDateUtc(dt).toISOString() // => "2024-01-01T12:00:00.000Z"
-* ```
-*
-* @category converting
-* @since 3.6.0
-*/
-var toDateUtc = toDateUtc$1;
-/**
 * Gets the milliseconds since the Unix epoch of a `DateTime`.
 *
 * **Details**
@@ -1430,6 +1419,37 @@ var subtract = subtract$1;
 */
 var formatLocal = formatLocal$1;
 /**
+* Formats a `DateTime` with `Intl.DateTimeFormat` using the UTC time zone.
+*
+* **Details**
+*
+* This forces the time zone to be UTC.
+*
+* **Example** (Formatting DateTime values in UTC)
+*
+* ```ts import.meta.vitest
+* import { DateTime } from "effect"
+*
+* const dt = DateTime.makeZonedUnsafe("2024-06-15T14:30:00Z", {
+*   timeZone: "Europe/London"
+* })
+*
+* // Force UTC formatting regardless of time zone
+* DateTime.formatUtc(dt, {
+*   year: "numeric",
+*   month: "2-digit",
+*   day: "2-digit",
+*   hour: "2-digit",
+*   minute: "2-digit",
+*   timeZoneName: "short"
+* })
+* ```
+*
+* @category formatting
+* @since 3.6.0
+*/
+var formatUtc = formatUtc$1;
+/**
 * Formats a `DateTime` as a UTC ISO string.
 *
 * **Details**
@@ -1454,7 +1474,7 @@ var formatLocal = formatLocal$1;
 */
 var formatIso = formatIso$1;
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/internal/schema/annotations.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/annotations.js
 /** @internal */
 function resolve(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
@@ -1478,15 +1498,21 @@ var getExpected = /*#__PURE__*/ memoize((ast) => {
 	return ast.getExpected(getExpected);
 });
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/internal/schema/parser.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/parser.js
+/** @internal */
 var missing = /*#__PURE__*/ Symbol();
+/** @internal */
 var succeed = succeed$2;
+/** @internal */
 var missingExit = /*#__PURE__*/ succeed(missing);
+/** @internal */
 var sameExit = /*#__PURE__*/ succeed(missing);
+/** @internal */
 var toOption = (value) => value === missing ? none() : some(value);
+/** @internal */
 var fromOptionExit = (option) => option._tag === "None" ? missingExit : succeed(option.value);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/SchemaIssue.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaIssue.js
 /**
 * Describes problems found while decoding, encoding, or checking data with
 * schemas.
@@ -1498,7 +1524,7 @@ var fromOptionExit = (option) => option._tag === "None" ? missingExit : succeed(
 *
 * @since 4.0.0
 */
-var TypeId$4 = "~effect/SchemaIssue/Issue";
+var TypeId$6 = "~effect/SchemaIssue/Issue";
 /**
 * Returns `true` if the given value is an {@link Issue}.
 *
@@ -1528,7 +1554,7 @@ var TypeId$4 = "~effect/SchemaIssue/Issue";
 * @since 4.0.0
 */
 function isIssue(u) {
-	return hasProperty(u, TypeId$4) && u[TypeId$4] === TypeId$4;
+	return hasProperty(u, TypeId$6) && u[TypeId$6] === TypeId$6;
 }
 /**
 * Returns `true` when an issue contains an input reported by the schema parser.
@@ -1562,53 +1588,19 @@ function isIssue(u) {
 function hasInput(issue) {
 	return Object.hasOwn(issue, "input");
 }
-var Base$1 = class {
-	[TypeId$4] = TypeId$4;
+var IssueNodeImpl = class {
+	[TypeId$6] = TypeId$6;
 	constructor(input, options) {
 		if (options?.reportInput === true && input !== missing) this.input = input;
 	}
 };
 /**
-* Represents a schema issue produced when a schema filter (refinement check) fails.
-*
-* **When to use**
-*
-* Use when you need to inspect a schema issue that records which refinement
-* check rejected the value.
-*
-* **Details**
-*
-* - `filter` is the AST filter node that produced this issue.
-* - `issue` is the inner issue describing the failure reason.
-*
-* **Example** (Matching a Filter issue)
-*
-* ```ts import.meta.vitest
-* import { SchemaAST, SchemaIssue } from "effect"
-*
-* const formatIssue = SchemaIssue.makeFormatterDefault()
-*
-* function describe(issue: SchemaIssue.Issue): string {
-*   if (issue._tag === "Filter") {
-*     return `Filter failed: ${formatIssue(issue.issue)}`
-*   }
-*   return formatIssue(issue)
-* }
-*
-* const issue = new SchemaIssue.Filter(
-*   SchemaAST.isPattern(/^valid$/),
-*   new SchemaIssue.InvalidValue()
-* )
-* describe(issue) // => `Filter failed: Expected a valid value`
-* ```
+* Constructs a schema issue for a failed refinement check.
 *
-* @see {@link Leaf} — terminal issue types that commonly appear as the inner `issue`
-* @see {@link CheckHook} — formatter hook for `Filter` issues
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Filter$1 = class extends Base$1 {
+var Filter$1 = class extends IssueNodeImpl {
 	_tag = "Filter";
 	/**
 	* The filter that failed.
@@ -1625,25 +1617,12 @@ var Filter$1 = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when a schema transformation (encode/decode step) fails.
-*
-* **When to use**
+* Constructs a schema issue for a failed transformation.
 *
-* Use when you need to inspect failures from `Schema.decodeTo` / `Schema.encodeTo`
-*   transformations.
-*
-* **Details**
-*
-* - `ast` is the AST node for the transformation that failed.
-* - `issue` is the inner issue describing the failure.
-*
-* @see {@link Filter} — failure from a refinement check (not a transformation)
-* @see {@link Composite} — multiple issues from a single schema node
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Encoding = class extends Base$1 {
+var Encoding = class extends IssueNodeImpl {
 	_tag = "Encoding";
 	/**
 	* The schema that caused the issue.
@@ -1660,26 +1639,12 @@ var Encoding = class extends Base$1 {
 	}
 };
 /**
-* Wraps an inner {@link Issue} with a property-key path, indicating *where* in
-* a nested structure the error occurred.
-*
-* **When to use**
+* Constructs a schema issue that points to a nested location.
 *
-* Use when you need to walk the issue tree to accumulate path segments for error
-* reporting.
-*
-* **Details**
-*
-* - `path` is an array of property keys (strings, numbers, or symbols).
-* - Formatters concatenate nested `Pointer` paths into a single path like
-*   `["a"]["b"][0]`.
-*
-* @see {@link Composite} — groups multiple issues under one schema node
-*
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Pointer = class extends Base$1 {
+var Pointer = class extends IssueNodeImpl {
 	_tag = "Pointer";
 	/**
 	* The path to the location in the input that caused the issue.
@@ -1696,23 +1661,12 @@ var Pointer = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when a required key or tuple index is missing from the input.
+* Constructs a schema issue for a missing key or tuple index.
 *
-* **When to use**
-*
-* Use when you need to detect absent fields in struct/tuple validation.
-*
-* **Details**
-*
-* - `annotations` may contain a custom `messageMissingKey` for formatting.
-*
-* @see {@link Pointer} — wraps this issue with the missing key's path
-* @see {@link UnexpectedKey} — the opposite case (extra key present)
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var MissingKey = class extends Base$1 {
+var MissingKey = class extends IssueNodeImpl {
 	_tag = "MissingKey";
 	/**
 	* The metadata for the issue.
@@ -1724,28 +1678,12 @@ var MissingKey = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when an input object or tuple contains a key/index not
-* declared by the schema.
+* Constructs a schema issue for an unexpected key or tuple index.
 *
-* **When to use**
-*
-* Use when you need to detect excess properties during strict struct/tuple
-* validation.
-*
-* **Details**
-*
-* - `ast` is the schema that was being validated against.
-* - `annotations` on `ast` may contain a custom `messageUnexpectedKey`.
-* - The default formatter renders this as `"Expected no excess property"`, or
-*   `"Unexpected key with value <input>"` when the issue reports an input.
-*
-* @see {@link MissingKey} — the opposite case (required key absent)
-* @see {@link Pointer} — wraps this issue with the unexpected key's path
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var UnexpectedKey = class extends Base$1 {
+var UnexpectedKey = class extends IssueNodeImpl {
 	_tag = "UnexpectedKey";
 	/**
 	* The schema that caused the issue.
@@ -1757,25 +1695,12 @@ var UnexpectedKey = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue that groups multiple child issues under a single schema node.
+* Constructs a schema issue that groups multiple child issues.
 *
-* **When to use**
-*
-* Use when you need to walk the issue tree for struct/tuple schemas that collect
-* all field errors rather than failing on the first.
-*
-* **Details**
-*
-* - `issues` is a non-empty readonly array (at least one child).
-* - Formatters flatten `Composite` by recursing into each child.
-*
-* @see {@link AnyOf} — used for union no-match errors (similar but different semantics)
-* @see {@link Pointer} — adds path context to individual issues
-*
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Composite = class extends Base$1 {
+var Composite = class extends IssueNodeImpl {
 	_tag = "Composite";
 	/**
 	* The schema that caused the issue.
@@ -1792,36 +1717,12 @@ var Composite = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when the runtime type of the input does not match the type
-* expected by the schema.
-*
-* **When to use**
-*
-* Use when you need to detect basic type mismatches, such as a wrong primitive
-* or `null` where an object was expected.
-*
-* **Details**
-*
-* - `ast` is the schema node that expected a different type.
-* - The default formatter renders this as `"Expected <type>"`, adding
-*   `", got <input>"` when the issue reports an input.
+* Constructs a schema issue for an input with an invalid runtime type.
 *
-* **Example** (Formatting a type mismatch)
-*
-* ```ts import.meta.vitest
-* import { Schema, SchemaIssue } from "effect"
-*
-* const formatIssue = SchemaIssue.makeFormatterDefault()
-* const issue = new SchemaIssue.InvalidType(Schema.String.ast)
-* formatIssue(issue) // => "Expected string"
-* ```
-*
-* @see {@link InvalidValue} — the input has the right type but fails a value constraint
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var InvalidType = class extends Base$1 {
+var InvalidType = class extends IssueNodeImpl {
 	_tag = "InvalidType";
 	/**
 	* The schema that caused the issue.
@@ -1833,41 +1734,12 @@ var InvalidType = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when the input has the correct type but its value violates a
-* constraint (e.g. a string that is too short, a number out of range).
-*
-* **When to use**
-*
-* Use when you need to detect constraint violations from `Schema.filter`,
-* `Schema.minLength`, `Schema.greaterThan`, or similar checks.
-*
-* **Details**
-*
-* - A `message` annotation is returned unchanged and takes precedence over all
-*   other default formatting.
-* - Without `message`, an `expected` annotation is formatted as
-*   `"Expected <expected>"`, adding `", got <input>"` when input is reported.
-* - Without either annotation, the default formatter renders
-*   `"Expected a valid value"`, or `"Invalid data <input>"` when input is
-*   reported.
-*
-* **Example** (Returning InvalidValue from a custom filter)
-*
-* ```ts import.meta.vitest
-* import { SchemaIssue } from "effect"
-*
-* const formatIssue = SchemaIssue.makeFormatterDefault()
-* const issue = new SchemaIssue.InvalidValue({ message: "must not be empty" })
-* formatIssue(issue) // => "must not be empty"
-* ```
-*
-* @see {@link InvalidType} — the input has the wrong type entirely
-* @see {@link Filter} — composite wrapper when a schema filter produces this issue
+* Constructs a schema issue for a value that violates a constraint.
 *
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var InvalidValue = class extends Base$1 {
+var InvalidValue = class extends IssueNodeImpl {
 	_tag = "InvalidValue";
 	/**
 	* The metadata for the issue.
@@ -1883,37 +1755,12 @@ function makeCompositeAtKey(compositeAst, pointerKey, pointerIssue, compositeInp
 	return new Composite(compositeAst, [new Pointer([pointerKey], pointerIssue)], compositeInput, parseOptions);
 }
 /**
-* Represents a schema issue produced when a forbidden operation is encountered during parsing,
-* such as an asynchronous Effect running inside `Schema.decodeUnknownSync`.
-*
-* **When to use**
-*
-* Use when you need to detect that a schema requires async execution but was run
-* synchronously.
+* Constructs a schema issue for a forbidden parsing operation.
 *
-* **Details**
-*
-* - `annotations` optionally carries a `message` string.
-* - The default formatter renders this as `"Forbidden operation"`.
-*
-* **Example** (Creating a Forbidden issue)
-*
-* ```ts import.meta.vitest
-* import { SchemaIssue } from "effect"
-*
-* const formatIssue = SchemaIssue.makeFormatterDefault()
-* const issue = new SchemaIssue.Forbidden(
-*   { message: "async operation not allowed in sync context" }
-* )
-* formatIssue(issue) // => "async operation not allowed in sync context"
-* ```
-*
-* @see {@link InvalidValue} — for value-constraint failures (not operation failures)
-*
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Forbidden = class extends Base$1 {
+var Forbidden = class extends IssueNodeImpl {
 	_tag = "Forbidden";
 	/**
 	* The metadata for the issue.
@@ -1925,31 +1772,12 @@ var Forbidden = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when a value does not match *any* member of a union schema.
-*
-* **When to use**
+* Constructs a schema issue for a value that matches no union member.
 *
-* Use when you need to inspect which union members were attempted and why each
-* failed.
-*
-* **Details**
-*
-* - `ast` is the `Union` AST node.
-* - `issues` contains the per-member failures.
-*
-* **Gotchas**
-*
-* `issues` is empty when no union member was applicable. In that case, the
-* default formatter reports the expected type for the union and appends
-* `", got <input>"` when input is reported.
-*
-* @see {@link OneOf} — the opposite: *too many* members matched
-* @see {@link Composite} — groups multiple issues under a non-union schema
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var AnyOf = class extends Base$1 {
+var AnyOf = class extends IssueNodeImpl {
 	_tag = "AnyOf";
 	/**
 	* The schema that caused the issue.
@@ -1966,29 +1794,12 @@ var AnyOf = class extends Base$1 {
 	}
 };
 /**
-* Represents a schema issue produced when a value matches *multiple* members of a union that is
-* configured to allow exactly one match (oneOf mode).
-*
-* **When to use**
-*
-* Use when you need to detect ambiguous union matches when `oneOf` validation is
-* enabled.
-*
-* **Details**
-*
-* - `ast` is the `Union` AST node.
-* - `successes` lists the AST nodes of each member that accepted the input.
-* - The default formatter renders this as
-*   `"Expected exactly one member to match"`, or
-*   `"Expected exactly one member to match the input <input>"` when input is
-*   reported.
-*
-* @see {@link AnyOf} — the opposite: *no* members matched
+* Constructs a schema issue for a value that matches multiple union members.
 *
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var OneOf = class extends Base$1 {
+var OneOf = class extends IssueNodeImpl {
 	_tag = "OneOf";
 	/**
 	* The schema that caused the issue.
@@ -2278,7 +2089,7 @@ function findMessage(issue) {
 	if (typeof message === "string") return message;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/internal/schema/cause.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/cause.js
 /** @internal */
 function getSchemaIssue(cause) {
 	let issue;
@@ -2295,58 +2106,14 @@ function getSchemaIssueOrThrow(cause, message) {
 	return issue;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/SchemaGetter.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaGetter.js
 /**
-* Builds one-way conversions used by schemas.
-*
-* A `Getter<T, E, R>` receives an optional encoded value and returns an
-* optional decoded value. It can also report a schema issue or require Effect
-* services. Schema transformations use getters to describe one direction of a
-* conversion, for example decoding a field from input data. This module
-* includes basic getters, validation helpers, pure and effectful conversions,
-* and ready-made conversions for common string, number, binary, date, form, and
-* URL-related values.
+* Constructs a composable schema getter.
 *
+* @category constructors
 * @since 4.0.0
 */
-/**
-* Represents a composable transformation from an encoded type `E` to a decoded type `T`.
-*
-* **When to use**
-*
-* Use when you need a schema getter to build and compose custom transformations
-* for `Schema.decodeTo` or `Schema.decode`.
-*
-* **Details**
-*
-* A getter wraps a function `Option<E> -> Effect<Option<T>, Issue, R>`. It
-* receives `Option.None` when the encoded key is absent, such as a missing
-* struct field, and returns `Option.None` to omit the value from the decoded
-* output. It fails with `Issue` on invalid input and may require Effect
-* services via `R`. `.map(f)` applies `f` to the decoded value inside `Some`
-* while leaving `None` unchanged. `.compose(other)` chains two getters by
-* feeding the output of `this` into `other`; passthrough getters on either side
-* are optimized away.
-*
-* **Example** (Creating and composing getters)
-*
-* ```ts import.meta.vitest
-* import { Effect, Option, SchemaGetter } from "effect"
-*
-* const parseNumber = SchemaGetter.transform<number, string>((s) => Number(s))
-* const double = SchemaGetter.transform<number, number>((n) => n * 2)
-* const composed = parseNumber.compose(double)
-* await Effect.runPromise(composed.run(Option.some("21"), {})) // => Option.some(42)
-* ```
-*
-* @see {@link transform} to create a getter from a pure function
-* @see {@link passthrough} for the identity getter
-* @see {@link transformOrFail} for fallible transformation
-*
-* @category models
-* @since 4.0.0
-*/
-var Getter = class Getter extends Class {
+var Getter = class extends Class {
 	run;
 	constructor(run) {
 		super();
@@ -2433,6 +2200,35 @@ function forbidden(message) {
 		return isSome(oe) ? new Forbidden(annotations, oe.value, options) : new Forbidden(annotations);
 	});
 }
+/**
+* Getter that always fails with a `Forbidden` issue indicating that encoding is unsupported.
+*
+* **When to use**
+*
+* Use as the encode side of a decode-only Schema transformation.
+*
+* **Details**
+*
+* Its `Getter<never, unknown>` type is assignable to every encoding getter because it accepts any input and never
+* produces an output value.
+*
+* **Example** (Rejecting encoding)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, SchemaGetter } from "effect"
+*
+* const issue = await Effect.runPromise(
+*   Effect.flip(SchemaGetter.forbiddenEncoding.run(Option.some("value"), {}))
+* )
+* issue._tag // => "Forbidden"
+* ```
+*
+* @see {@link forbidden} for a forbidden getter with a custom message
+*
+* @category constructors
+* @since 4.0.0
+*/
+var forbiddenEncoding = /*#__PURE__*/ forbidden(() => "Encoding is not supported");
 var passthrough_$1 = /*#__PURE__*/ new Getter(succeed$3);
 function isPassthrough(getter) {
 	return getter.run === passthrough_$1.run;
@@ -2468,7 +2264,7 @@ function passthrough$1() {
 *
 * @see {@link onNone} to handle only absent values
 * @see {@link transform} for a simpler pure transformation of present values
-* @see {@link transformOrFail} for fallible transformation of present values
+* @see {@link transformEffect} for effectful transformation of present values
 *
 * @category transforming
 * @since 4.0.0
@@ -2506,7 +2302,7 @@ function onSome(f) {
 * Schema.decodeSync(NumberFromString)("42") // => 42
 * ```
 *
-* @see {@link transformOrFail} when the transformation can fail
+* @see {@link transformEffect} when the transformation returns an `Effect`
 * @see {@link transformOptional} when you need to handle `None` inputs
 * @see {@link passthrough} when no transformation is needed
 *
@@ -2517,7 +2313,7 @@ function transform$1(f) {
 	return transformOptional$1(map$3(f));
 }
 /**
-* Creates a getter that applies a fallible, effectful transformation to present values.
+* Creates a getter that applies an effectful transformation to present values.
 *
 * **When to use**
 *
@@ -2535,7 +2331,7 @@ function transform$1(f) {
 * ```ts import.meta.vitest
 * import { Effect, Option, SchemaGetter, SchemaIssue } from "effect"
 *
-* const safeParseInt = SchemaGetter.transformOrFail<number, string>(
+* const safeParseInt = SchemaGetter.transformEffect<number, string>(
 *   (s, options) => {
 *     const n = parseInt(s, 10)
 *     return isNaN(n)
@@ -2552,7 +2348,7 @@ function transform$1(f) {
 * @category transforming
 * @since 4.0.0
 */
-function transformOrFail$1(f) {
+function transformEffect$1(f) {
 	return onSome((e, options) => f(e, options).pipe(mapEager(some)));
 }
 /**
@@ -2674,7 +2470,7 @@ function String$3() {
 * await Effect.runPromise(toNumber.run(Option.some("42"), {})) // => Option.some(42)
 * ```
 *
-* @see {@link transformOrFail} for validated number parsing
+* @see {@link transformEffect} for effectful or validated number parsing
 *
 * @category converting
 * @since 4.0.0
@@ -2850,7 +2646,7 @@ function encodeUriComponent() {
 * @since 4.0.0
 */
 function decodeUriComponent() {
-	return transformOrFail$1((input, options) => {
+	return transformEffect$1((input, options) => {
 		try {
 			return succeed$3(globalThis.decodeURIComponent(input));
 		} catch {
@@ -2859,52 +2655,14 @@ function decodeUriComponent() {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/SchemaTransformation.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaTransformation.js
 /**
-* Middleware that wraps the entire parsing `Effect` pipeline for both
-* decode and encode directions.
-*
-* **When to use**
-*
-* Use when you need a schema middleware to catch or recover from parsing
-* errors (e.g. `Schema.catchDecoding`), run side effects around the parsing
-* pipeline, or access the full `Effect` rather than a single decoded value.
-*
-* **Details**
-*
-* Unlike `Transformation`, which operates on individual values via `Getter`,
-* `Middleware` receives the full `Effect` produced by the inner schema and can
-* intercept, modify, retry, or replace it.
+* Constructs schema middleware from its decode and encode functions.
 *
-* - `decode` receives an `Effect<Option<E>, Issue, RDE>` and returns
-*   `Effect<Option<T>, Issue, RDT>`.
-* - `encode` receives an `Effect<Option<T>, Issue, RET>` and returns
-*   `Effect<Option<E>, Issue, REE>`.
-* - `flip()` swaps the decode and encode functions, producing a
-*   `Middleware<E, T, ...>`.
-*
-* Typically constructed indirectly via `Schema.middlewareDecoding` or
-* `Schema.middlewareEncoding` rather than instantiating this class directly.
-*
-* **Example** (Creating a middleware that falls back on decode failure)
-*
-* ```ts import.meta.vitest
-* import { Effect, Option, SchemaIssue, SchemaTransformation } from "effect"
-*
-* const fallback = new SchemaTransformation.Middleware<string, string, never, never, never, never>(
-*   (effect) => Effect.catch(effect, () => Effect.succeed(Option.some("fallback"))),
-*   (effect) => effect
-* )
-* const issue = new SchemaIssue.InvalidValue({ message: "Missing value" })
-* await Effect.runPromise(fallback.decode(Effect.fail(issue), {})) // => Option.some("fallback")
-* ```
-*
-* @see {@link Transformation} — value-level bidirectional transformation
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Middleware = class Middleware {
+var Middleware = class {
 	_tag = "Middleware";
 	decode;
 	encode;
@@ -2916,50 +2674,15 @@ var Middleware = class Middleware {
 		return new Middleware(this.encode, this.decode);
 	}
 };
-var TypeId$3 = "~effect/SchemaTransformation/Transformation";
+var TypeId$5 = "~effect/SchemaTransformation/Transformation";
 /**
-* Represents a bidirectional transformation between a decoded type `T` and an encoded
-* type `E`, built from a pair of `Getter`s.
-*
-* **When to use**
-*
-* Use when you need a schema transformation that defines how a schema converts
-* between two representations.
-* - You want to compose multiple transformations into a pipeline.
-* - You want to flip a transformation to swap decode/encode.
-*
-* **Details**
+* Constructs a bidirectional schema transformation from its decode and encode getters.
 *
-* This is the primary building block for `Schema.decodeTo`, `Schema.encodeTo`,
-* `Schema.decode`, `Schema.encode`, and `Schema.link`. Each direction is a
-* `SchemaGetter.Getter` that handles optionality, failure, and Effect services.
-*
-* - Immutable — `flip()` and `compose()` return new instances.
-* - `flip()` swaps the decode and encode getters.
-* - `compose(other)` chains: `this.decode` then `other.decode` for decoding,
-*   `other.encode` then `this.encode` for encoding.
-*
-* **Example** (Composing two transformations)
-*
-* ```ts import.meta.vitest
-* import { SchemaTransformation } from "effect"
-*
-* const trimAndLower = SchemaTransformation.trim().compose(
-*   SchemaTransformation.toLowerCase()
-* )
-* trimAndLower._tag // => "Transformation"
-* ```
-*
-* @see {@link make} — construct from `{ decode, encode }` getters
-* @see {@link transform} — construct from pure functions
-* @see {@link transformOrFail} — construct from effectful functions
-* @see {@link Middleware} — effect-pipeline-level alternative
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Transformation = class Transformation {
-	[TypeId$3] = TypeId$3;
+var Transformation = class {
+	[TypeId$5] = TypeId$5;
 	_tag = "Transformation";
 	decode;
 	encode;
@@ -3003,7 +2726,7 @@ var Transformation = class Transformation {
 * @since 4.0.0
 */
 function isTransformation(u) {
-	return hasProperty(u, TypeId$3) && u[TypeId$3] === TypeId$3;
+	return hasProperty(u, TypeId$5) && u[TypeId$5] === TypeId$5;
 }
 /**
 * Constructs a `Transformation` from an object with `decode` and `encode`
@@ -3032,19 +2755,18 @@ function isTransformation(u) {
 * ```
 *
 * @see {@link transform} — simpler constructor from pure functions
-* @see {@link transformOrFail} — constructor from effectful functions
+* @see {@link transformEffect} — constructor from effectful functions
 * @see {@link Transformation}
 *
 * @category constructors
 * @since 3.10.0
 */
-var make$3 = (options) => {
+var make$4 = (options) => {
 	if (isTransformation(options)) return options;
 	return new Transformation(options.decode, options.encode);
 };
 /**
-* Creates a `Transformation` from effectful decode and encode functions that
-* can fail with `Issue`.
+* Creates a `Transformation` from effectful decode and encode functions.
 *
 * **When to use**
 *
@@ -3065,7 +2787,7 @@ var make$3 = (options) => {
 * const DateFromString = Schema.String.pipe(
 *   Schema.decodeTo(
 *     Schema.Date,
-*     SchemaTransformation.transformOrFail({
+*     SchemaTransformation.transformEffect({
 *       decode: (s, options) => {
 *         const d = new Date(s)
 *         return isNaN(d.getTime())
@@ -3086,8 +2808,8 @@ var make$3 = (options) => {
 * @category transforming
 * @since 3.10.0
 */
-function transformOrFail(options) {
-	return new Transformation(transformOrFail$1(options.decode), transformOrFail$1(options.encode));
+function transformEffect(options) {
+	return new Transformation(transformEffect$1(options.decode), transformEffect$1(options.encode));
 }
 /**
 * Creates a `Transformation` from pure (sync, infallible) decode and encode
@@ -3121,7 +2843,7 @@ function transformOrFail(options) {
 * Schema.decodeSync(CentsFromDollars)(2.5) // => 250
 * ```
 *
-* @see {@link transformOrFail} — for fallible or effectful transformations
+* @see {@link transformEffect} — for fallible or effectful transformations
 * @see {@link transformOptional} — for transformations that handle missing keys
 * @see {@link passthrough} — when no conversion is needed
 *
@@ -3399,38 +3121,8 @@ var defectFromJson = (options) => transform({
 function fromJsonString$1(options) {
 	return new Transformation(parseJson(options ?? {}), stringifyJson(options));
 }
-/**
-* Decodes a date-time string into a `DateTime.Utc` and encodes it back to an ISO
-* string.
-*
-* **When to use**
-*
-* Use when you need a schema transformation to decode date-time strings to a
-* normalized `DateTime.Utc` and encode back as a UTC ISO string.
-*
-* **Details**
-*
-* Decode accepts strings supported by `DateTime.make`, converts the result to
-* UTC, and fails with `InvalidValue` when parsing fails. Encode uses
-* `DateTime.formatIso`.
-*
-* @see {@link dateFromString} for decoding into JavaScript `Date`
-* @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information
-*
-* @category transforming
-* @since 4.0.0
-*/
-var dateTimeUtcFromString = /*#__PURE__*/ transformOrFail({
-	decode: (s, options) => {
-		return match$1(make$4(s), {
-			onNone: () => fail$2(new InvalidValue({ expected: "a valid UTC DateTime string" }, s, options)),
-			onSome: (result) => succeed$3(toUtc(result))
-		});
-	},
-	encode: (utc) => succeed$3(formatIso(utc))
-});
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/SchemaAST.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaAST.js
 /**
 * Represents Effect schemas as runtime trees.
 *
@@ -3525,22 +3217,9 @@ var isObjects = /*#__PURE__*/ makeGuard("Objects");
 */
 var isSuspend = /*#__PURE__*/ makeGuard("Suspend");
 /**
-* Represents a single step in an {@link Encoding} chain.
+* Constructs a {@link Link}.
 *
-* **Details**
-*
-* A link pairs a target {@link AST} with a `Transformation` or `Middleware`
-* that converts values between the current node and the target.
-*
-* - `to` — the AST node on the other side of this transformation step.
-* - `transformation` — the bidirectional conversion logic (decode/encode).
-*
-* Links are composed into a non-empty array ({@link Encoding}) attached to
-* AST nodes that have a different encoded representation.
-*
-* @see {@link Encoding}
-* @see {@link decodeTo}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
 var Link = class {
@@ -3554,24 +3233,9 @@ var Link = class {
 /** @internal */
 var defaultParseOptions = {};
 /**
-* Represents per-property metadata attached to AST nodes via {@link Base.context}.
+* Constructs a {@link Context}.
 *
-* **Details**
-*
-* Tracks whether a property key is optional, mutable, has a constructor
-* default, or carries key-level annotations. Typically set by helpers like
-* {@link optionalKey} and `Schema.mutableKey`.
-*
-* - `isOptional` — the property key may be absent from the input.
-* - `isMutable` — the property is `readonly` when `false`.
-* - `constructorDefault` — a {@link Link} applied during construction to
-*   supply missing values.
-* - `annotations` — key-level annotations (e.g. description of the key
-*   itself).
-*
-* @see {@link optionalKey}
-* @see {@link isOptional}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
 var Context = class {
@@ -3587,29 +3251,9 @@ var Context = class {
 		this.annotations = annotations;
 	}
 };
-var TypeId$2 = "~effect/Schema";
-/**
-* Represents the abstract base class for all {@link AST} node variants.
-*
-* **Details**
-*
-* Every AST node extends `Base` and inherits these fields:
-*
-* - `annotations` — user-supplied metadata (identifier, title, description,
-*   arbitrary keys).
-* - `checks` — optional {@link Checks} for post-type-match validation.
-* - `encoding` — optional {@link Encoding} chain for type ↔ wire
-*   transformations.
-* - `context` — optional {@link Context} for per-property metadata.
-*
-* Subclasses add a `_tag` discriminant and variant-specific data.
-*
-* @see {@link AST}
-* @category models
-* @since 4.0.0
-*/
-var Base = class {
-	[TypeId$2] = TypeId$2;
+var TypeId$4 = "~effect/Schema";
+var ASTNodeImpl = class {
+	[TypeId$4] = TypeId$4;
 	annotations;
 	checks;
 	encoding;
@@ -3625,32 +3269,19 @@ var Base = class {
 	}
 };
 /**
-* AST node for user-defined opaque types with custom parsing logic.
+* Constructs a {@link Declaration}.
 *
-* **When to use**
-*
-* Use when you need a custom schema AST node because none of the built-in
-* nodes fit.
-*
-* **Details**
-*
-* - `typeParameters` — inner schemas this declaration is parameterized over
-*   (e.g. the element type for a custom collection).
-* - `run` — factory that receives `typeParameters` and returns a parser that
-*   validates or transforms raw input.
-*
-* @see {@link isDeclaration}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Declaration = class Declaration extends Base {
+var Declaration = class extends ASTNodeImpl {
 	_tag = "Declaration";
 	typeParameters;
 	run;
 	encodingChecks;
 	/**
 	* Parser factory {@link flip} swaps in, so a declaration can behave
-	* differently when encoding. `undefined` reuses {@link run}.
+	* differently when encoding. `undefined` reuses `run`.
 	*/
 	encodingRun;
 	constructor(typeParameters, run, annotations, checks, encoding, context, encodingChecks, encodingRun) {
@@ -3688,18 +3319,12 @@ var Declaration = class Declaration extends Base {
 	}
 };
 /**
-* AST node matching the `null` literal value.
-*
-* **Details**
-*
-* Parsing succeeds only when the input is exactly `null`.
+* Constructs a {@link Null}.
 *
-* @see {@link null_ null}
-* @see {@link isNull}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Null$1 = class extends Base {
+var Null$1 = class extends ASTNodeImpl {
 	_tag = "Null";
 	/** @internal */
 	getParser() {
@@ -3712,18 +3337,12 @@ var Null$1 = class extends Base {
 };
 var null_ = /*#__PURE__*/ new Null$1();
 /**
-* AST node matching the `undefined` value.
-*
-* **Details**
+* Constructs a {@link Undefined}.
 *
-* Parsing succeeds only when the input is exactly `undefined`.
-*
-* @see {@link undefined}
-* @see {@link isUndefined}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Undefined$1 = class extends Base {
+var Undefined$1 = class extends ASTNodeImpl {
 	_tag = "Undefined";
 	/** @internal */
 	getParser() {
@@ -3741,19 +3360,44 @@ var Undefined$1 = class extends Base {
 var undefinedToNull = /*#__PURE__*/ new Link(null_, /*#__PURE__*/ new Transformation(/*#__PURE__*/ transform$1(() => void 0), /*#__PURE__*/ transform$1(() => null)));
 var undefined_ = /*#__PURE__*/ new Undefined$1();
 /**
-* AST node representing the `unknown` type — every value matches.
+* Constructs a {@link Never}.
 *
-* **Details**
+* @category constructors
+* @since 4.0.0
+*/
+var Never$1 = class extends ASTNodeImpl {
+	_tag = "Never";
+	/** @internal */
+	getParser() {
+		return fromRefinement(this, isNever$1);
+	}
+	/** @internal */
+	getExpected() {
+		return "never";
+	}
+};
+/**
+* Provides the singleton {@link Never} AST instance.
 *
-* Unlike {@link Any}, this is type-safe: the parsed result is typed as
-* `unknown` rather than `any`.
+* **When to use**
+*
+* Use to reuse the canonical bottom-type AST node when constructing,
+* comparing, or returning ASTs.
+*
+* @see {@link Never} for the AST node class
+* @see {@link isNever} for narrowing an AST to a `Never` node
+*
+* @category constructors
+* @since 4.0.0
+*/
+var never = /*#__PURE__*/ new Never$1();
+/**
+* Constructs a {@link Unknown}.
 *
-* @see {@link unknown}
-* @see {@link isUnknown}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Unknown$1 = class extends Base {
+var Unknown$1 = class extends ASTNodeImpl {
 	_tag = "Unknown";
 	/** @internal */
 	getParser() {
@@ -3778,31 +3422,49 @@ var Unknown$1 = class extends Base {
 * @since 4.0.0
 */
 var unknown = /*#__PURE__*/ new Unknown$1();
-function isTemplateLiteralPart(ast) {
+function formatTemplateLiteralPath(path) {
+	return typeof path === "number" ? `parts[${path}]` : path;
+}
+function isTemplateLiteralPart(ast, path, validated) {
+	if (validated.has(ast)) return true;
+	if (ast.encoding) throw new Error(`TemplateLiteral parts cannot have an encoding at ${formatTemplateLiteralPath(path)}`);
+	let valid;
 	switch (ast._tag) {
 		case "String":
 		case "Number":
-		case "BigInt": return true;
+		case "BigInt":
+			valid = true;
+			break;
 		case "Literal":
-		case "TemplateLiteral": return !ast.checks;
-		case "Union": return !ast.checks && ast.types.every(isTemplateLiteralPart);
+			valid = !ast.checks;
+			break;
+		case "TemplateLiteral": {
+			const currentPath = formatTemplateLiteralPath(path);
+			valid = !ast.checks && ast.parts.every((part, index) => isTemplateLiteralPart(part, `${currentPath}.parts[${index}]`, validated));
+			break;
+		}
+		case "Union": {
+			const currentPath = formatTemplateLiteralPath(path);
+			valid = !ast.checks && ast.types.every((part, index) => isTemplateLiteralPart(part, `${currentPath}.types[${index}]`, validated));
+			break;
+		}
 		default: return false;
 	}
+	if (valid) validated.add(ast);
+	return valid;
 }
 /**
-* AST node representing a TypeScript template literal type
-* (e.g. `` `user_${string}` ``).
+* Constructs a {@link TemplateLiteral}.
 *
-* **Details**
+* **Gotchas**
 *
-* `parts` is an array of AST nodes; each part contributes to matching
-* strings at runtime.
+* Throws if a part contains an encoding, including inside unions or nested
+* template literals. Parts must describe their values without transformations.
 *
-* @see {@link isTemplateLiteral}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var TemplateLiteral$1 = class extends Base {
+var TemplateLiteral$1 = class extends ASTNodeImpl {
 	_tag = "TemplateLiteral";
 	parts;
 	/** @internal */
@@ -3815,12 +3477,12 @@ var TemplateLiteral$1 = class extends Base {
 		super(annotations, checks, encoding, context);
 		const encodedParts = [];
 		const literals = [];
-		for (const part of parts) {
-			const encoded = toEncoded(part);
-			if (isTemplateLiteralPart(encoded)) {
-				encodedParts.push(encoded);
-				literals.push(encoded._tag === "Literal" ? globalThis.String(encoded.literal) : void 0);
-			} else throw new Error(`Invalid TemplateLiteral part ${encoded._tag}`);
+		const validated = /* @__PURE__ */ new Set();
+		for (let index = 0; index < parts.length; index++) {
+			const part = parts[index];
+			if (!isTemplateLiteralPart(part, index, validated)) throw new Error(`Invalid TemplateLiteral part ${part._tag}`);
+			encodedParts.push(part);
+			literals.push(part._tag === "Literal" ? globalThis.String(part.literal) : void 0);
 		}
 		const suffixLengths = new Array(encodedParts.length + 1);
 		suffixLengths[encodedParts.length] = 0;
@@ -3832,7 +3494,7 @@ var TemplateLiteral$1 = class extends Base {
 	}
 	/** @internal */
 	getParser(compile) {
-		const parser = compile(this.asTemplateLiteralParser());
+		const parser = compile(decodeTo$1(string, new Arrays(false, this.parts.map(partFromString), []), templateLiteralTransformation(this)));
 		return (input, options) => {
 			if (input === missing) return missingExit;
 			const result = parser(input, options);
@@ -3851,40 +3513,21 @@ var TemplateLiteral$1 = class extends Base {
 	matchPart(s, options) {
 		return segmentTemplateLiteralParts(this, s, options) === void 0 ? void 0 : s;
 	}
-	/** @internal */
-	asTemplateLiteralParser() {
-		return decodeTo$1(string, new Arrays(false, this.parts.map(partFromString), []), new Transformation(transformOrFail$1((s, options) => {
-			const segments = segmentTemplateLiteralParts(this, s, options);
-			if (segments) return succeed$3(segments);
-			return fail$2(new InvalidValue({ expected: "a string matching template literal parts" }, s, options));
-		}), transform$1((parts) => parts.join(""))));
-	}
 };
+function templateLiteralTransformation(template) {
+	return new Transformation(transformEffect$1((s, options) => {
+		const segments = segmentTemplateLiteralParts(template, s, options);
+		if (segments) return succeed$3(segments);
+		return fail$2(new InvalidValue({ expected: "a string matching template literal parts" }, s, options));
+	}), transform$1((parts) => parts.join("")));
+}
 /**
-* AST node matching an exact primitive value (string, number, boolean, or
-* bigint).
-*
-* **Details**
-*
-* Parsing succeeds only when the input is strictly equal (`===`) to the
-* stored `literal`. Numeric literals must be finite — `Infinity`, `-Infinity`,
-* and `NaN` are rejected at construction time.
+* Constructs a {@link Literal}.
 *
-* **Example** (Creating a literal AST)
-*
-* ```ts import.meta.vitest
-* import { SchemaAST } from "effect"
-*
-* const ast = new SchemaAST.Literal("active")
-* ast.literal // => "active"
-* ```
-*
-* @see {@link LiteralValue}
-* @see {@link isLiteral}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Literal$1 = class extends Base {
+var Literal$1 = class extends ASTNodeImpl {
 	_tag = "Literal";
 	literal;
 	constructor(literal, annotations, checks, encoding, context) {
@@ -3918,15 +3561,12 @@ function literalToString(ast) {
 	return replaceEncoding(ast, [new Link(new Literal$1(literalAsString), new Transformation(transform$1(() => ast.literal), transform$1(() => literalAsString)))]);
 }
 /**
-* AST node matching any `string` value.
+* Constructs a {@link String}.
 *
-* @see {@link string}
-* @see {@link isString}
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var String$2 = class extends Base {
+var String$2 = class extends ASTNodeImpl {
 	_tag = "String";
 	/** @internal */
 	getParser() {
@@ -3957,25 +3597,12 @@ var String$2 = class extends Base {
 */
 var string = /*#__PURE__*/ new String$2();
 /**
-* AST node matching any `number` value (including `NaN`, `Infinity`,
-* `-Infinity`).
-*
-* **Details**
+* Constructs a {@link Number}.
 *
-* Default JSON serialization:
-*
-* - Finite numbers are serialized as JSON numbers.
-* - `Infinity`, `-Infinity`, and `NaN` are serialized as JSON strings.
-*
-* If the node has an `isFinite` or `isInt` check, the string fallback is
-* skipped since non-finite values cannot occur.
-*
-* @see {@link number}
-* @see {@link isNumber}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Number$2 = class extends Base {
+var Number$2 = class extends ASTNodeImpl {
 	_tag = "Number";
 	/** @internal */
 	getParser() {
@@ -4029,15 +3656,12 @@ function hasCheck(checks, id) {
 */
 var number = /*#__PURE__*/ new Number$2();
 /**
-* AST node matching any `boolean` value (`true` or `false`).
+* Constructs a {@link Boolean}.
 *
-* @see {@link boolean}
-* @see {@link isBoolean}
-*
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Boolean$1 = class extends Base {
+var Boolean$1 = class extends ASTNodeImpl {
 	_tag = "Boolean";
 	/** @internal */
 	getParser() {
@@ -4064,19 +3688,12 @@ var Boolean$1 = class extends Base {
 */
 var boolean = /*#__PURE__*/ new Boolean$1();
 /**
-* AST node matching any `bigint` value.
-*
-* **Details**
+* Constructs a {@link BigInt}.
 *
-* When serialized to a string-based codec, bigints are converted to/from
-* their decimal string representation.
-*
-* @see {@link bigInt}
-* @see {@link isBigInt}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var BigInt$2 = class extends Base {
+var BigInt$2 = class extends ASTNodeImpl {
 	_tag = "BigInt";
 	/** @internal */
 	getParser() {
@@ -4114,48 +3731,12 @@ var BigInt$2 = class extends Base {
 */
 var bigInt = /*#__PURE__*/ new BigInt$2();
 /**
-* AST node for array-like types — both tuples and arrays.
+* Constructs a {@link Arrays}.
 *
-* **When to use**
-*
-* Use when constructing or inspecting AST nodes for tuple or array-like schemas,
-* including rest elements.
-*
-* **Details**
-*
-* - `elements` — positional element types (tuple elements). An element is
-*   optional if its {@link Context.isOptional} is `true`.
-* - `rest` — the rest/variadic element types. When non-empty, the first
-*   entry is the "spread" type (e.g. `...Array<string>`), and subsequent
-*   entries are trailing positional elements after the spread.
-* - `isMutable` — whether the resulting array is `readonly` (`false`) or
-*   mutable (`true`).
-*
-* **Gotchas**
-*
-* Construction enforces TypeScript ordering rules: a required element
-* cannot follow an optional one, and an optional element cannot follow a
-* rest element.
-*
-* **Example** (Inspecting a tuple AST)
-*
-* ```ts import.meta.vitest
-* import { Schema, SchemaAST } from "effect"
-*
-* const schema = Schema.Tuple([Schema.String, Schema.Number])
-* const ast = schema.ast
-*
-* if (SchemaAST.isArrays(ast)) {
-*   [ast.elements.length, ast.rest.length] // => [2, 0]
-* }
-* ```
-*
-* @see {@link isArrays}
-* @see {@link Objects}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Arrays = class Arrays extends Base {
+var Arrays = class extends ASTNodeImpl {
 	_tag = "Arrays";
 	isMutable;
 	elements;
@@ -4209,9 +3790,11 @@ var Arrays = class Arrays extends Base {
 				issues: void 0,
 				options
 			};
-			const eff = parseArray(state, input, {
-				concurrency: resolveConcurrency(options?.concurrency)?.concurrency,
-				end: ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen)
+			const end = ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen);
+			const concurrency = options.concurrency === void 0 ? 1 : resolveConcurrency(options.concurrency);
+			const eff = concurrency === 1 ? parseArray(state, input, 0, end) : parseArrayConcurrent(state, input, {
+				concurrency,
+				end
 			});
 			if (eff) yield* eff;
 			if (ast.rest.length === 0 && len > elementLen) for (let i = elementLen; i <= len - 1; i++) {
@@ -4244,7 +3827,7 @@ var Arrays = class Arrays extends Base {
 		return "array";
 	}
 };
-var parseArray = /*#__PURE__*/ iterateEager()({
+var parseArrayOptions = {
 	onItem(s, item, i) {
 		const value = i < s.len ? item : missing;
 		return s.getParser(s.tailThreshold, i).parser(value, s.options);
@@ -4263,11 +3846,9 @@ var parseArray = /*#__PURE__*/ iterateEager()({
 			} else return fail$3(new Composite(s.ast, [issue], s.input, s.options));
 		}
 	}
-});
-var resolveConcurrency = (value) => {
-	value = value === "unbounded" ? Infinity : value ?? 1;
-	return value > 1 ? { concurrency: value } : void 0;
 };
+var parseArray = /*#__PURE__*/ iterateEager()(parseArrayOptions);
+var parseArrayConcurrent = /*#__PURE__*/ iterateConcurrent()(parseArrayOptions);
 var wrapPropertyKeyIssue = (s, ast, key, exit) => {
 	if (exit.cause.reasons.length === 0) return exit;
 	const issue = getSchemaIssue(exit.cause);
@@ -4303,17 +3884,10 @@ function getIndexSignatureKeys(input, parameter, options = defaultParseOptions)
 	return go(parameterFromPropertyKey(toEncoded(parameter)));
 }
 /**
-* Represents a named property within an {@link Objects} node.
+* Constructs a {@link PropertySignature}.
 *
-* **Details**
-*
-* Pairs a `name` (any `PropertyKey`) with a `type` ({@link AST}). The
-* property's optionality and mutability are determined by the `type`'s
-* {@link Context}.
-*
-* @see {@link Objects}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
 var PropertySignature = class {
 	name;
@@ -4333,32 +3907,25 @@ function isIndexSignatureParameterSide(ast) {
 		default: return false;
 	}
 }
+function isIndexSignatureParameterEncodedSide(ast) {
+	const encoded = getLastEncoding(ast);
+	switch (encoded._tag) {
+		case "String":
+		case "Number":
+		case "Symbol":
+		case "TemplateLiteral": return true;
+		case "Union": return encoded.types.every(isIndexSignatureParameterEncodedSide);
+		default: return false;
+	}
+}
 function isIndexSignatureParameter(ast) {
-	return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterSide(toEncoded(ast));
+	return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterEncodedSide(ast);
 }
 /**
-* Represents an index signature entry within an {@link Objects} node.
-*
-* **When to use**
-*
-* Use when constructing or inspecting object AST entries for record-like keys
-* and values.
-*
-* **Details**
-*
-* - `parameter` — the key type AST (e.g. {@link String} for `string` keys,
-*   {@link TemplateLiteral} for patterned keys).
-* - `type` — the value type SchemaAST.
+* Constructs a {@link IndexSignature}.
 *
-* **Gotchas**
-*
-* Using `Schema.optionalKey` on the value type is not allowed for index
-* signatures (throws at construction); use `Schema.optional` instead.
-*
-* @see {@link Objects}
-* @see {@link PropertySignature}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
 var IndexSignature = class {
 	parameter;
@@ -4371,48 +3938,12 @@ var IndexSignature = class {
 	}
 };
 /**
-* AST node for object-like schemas, including structs and records.
-*
-* **When to use**
-*
-* Use when constructing or inspecting AST nodes for structs or records rather
-* than array-like schemas.
-*
-* **Details**
-*
-* - `propertySignatures` — named properties with their types (struct fields).
-* - `indexSignatures` — index signature entries (record patterns), each with
-*   a `parameter` AST for matching keys and a `type` AST for values.
-*
-* An `Objects` node with no properties and no index signatures performs only a
-* non-nullish check: it accepts any value except `null` and `undefined`,
-* including primitive values.
-*
-* **Gotchas**
-*
-* Duplicate property names throw at construction time.
-*
-* **Example** (Inspecting a struct AST)
-*
-* ```ts import.meta.vitest
-* import { Schema, SchemaAST } from "effect"
-*
-* const schema = Schema.Struct({ name: Schema.String })
-* const ast = schema.ast
+* Constructs a {@link Objects}.
 *
-* if (SchemaAST.isObjects(ast)) {
-*   ast.propertySignatures.map((ps) => [ps.name, ps.type._tag]) // => [["name", "String"]]
-* }
-* ```
-*
-* @see {@link isObjects}
-* @see {@link PropertySignature}
-* @see {@link IndexSignature}
-* @see {@link Arrays}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Objects = class Objects extends Base {
+var Objects = class extends ASTNodeImpl {
 	_tag = "Objects";
 	propertySignatures;
 	indexSignatures;
@@ -4422,14 +3953,20 @@ var Objects = class Objects extends Base {
 		this.propertySignatures = propertySignatures;
 		this.indexSignatures = indexSignatures;
 		this.encodingChecks = encodingChecks;
-		const duplicates = propertySignatures.map((ps) => ps.name).filter((name, i, arr) => arr.indexOf(name) !== i);
+		const seen = /* @__PURE__ */ new Set();
+		const duplicates = [];
+		for (const propertySignature of propertySignatures) {
+			const name = propertySignature.name;
+			if (seen.has(name)) duplicates.push(name);
+			else seen.add(name);
+		}
 		if (duplicates.length > 0) throw new Error(`Duplicate identifiers: ${JSON.stringify(duplicates)}. ts(2300)`);
 	}
 	/** @internal */
 	getParser(compile, compileConstructorDefault = compile) {
 		const ast = this;
 		const expectedKeys = [];
-		for (const ps of ast.propertySignatures) expectedKeys.push(ps.name);
+		for (const ps of ast.propertySignatures) expectedKeys.push(typeof ps.name === "number" ? globalThis.String(ps.name) : ps.name);
 		const hasProperties = expectedKeys.length;
 		const indexCount = ast.indexSignatures.length;
 		let expectedKeysSet = hasProperties && indexCount ? new Set(expectedKeys) : void 0;
@@ -4440,7 +3977,7 @@ var Objects = class Objects extends Base {
 			if (exitValue._tag === "Failure") return wrapPropertyKeyIssue(s, ast, key, exitValue) ?? void_;
 			const value = exitValue === sameExit ? inputValue : exitValue[args];
 			if (k2 !== missing && value !== missing) {
-				if (hasProperties && (expectedKeysSet.has(key) || expectedKeysSet.has(k2))) return void_;
+				if (hasProperties && (expectedKeysSet.has(key) || expectedKeysSet.has(typeof k2 === "number" ? globalThis.String(k2) : k2))) return void_;
 				assignProperty(s.out, k2, value);
 			}
 			return void_;
@@ -4462,9 +3999,9 @@ var Objects = class Objects extends Base {
 			const result = index.parserValue(inputValue, s.options);
 			return effectIsExit(result) ? finishIndex(s, key, key, inputValue, result) : flatMap(exit(result), (exit) => finishIndex(s, key, key, inputValue, exit));
 		};
-		const parseIndexes = indexCount ? iterateEager()({
-			onItem: (s, [key, index]) => parseIndex(s, key, index),
-			step: (_s, _, exit) => exit._tag === "Failure" ? exit : void 0
+		const parseIndexes = indexCount ? iterateConcurrent()({
+			onItem: (s, [key, index]) => index.is.parameter === string ? parseStringIndex(s, key, index) : parseIndex(s, key, index),
+			step: (_s, _item, exit) => exit._tag === "Failure" ? exit : void 0
 		}) : void 0;
 		const compileMembers = () => {
 			if (!properties) {
@@ -4496,35 +4033,34 @@ var Objects = class Objects extends Base {
 			};
 			const errorsAllOption = options.errors === "all";
 			const onExcessPropertyError = options.onExcessProperty === "error";
-			const onExcessPropertyPreserve = options.onExcessProperty === "preserve";
-			let inputKeys;
-			if (!indexCount && (onExcessPropertyError || onExcessPropertyPreserve)) {
+			const concurrency = options.concurrency === void 0 ? 1 : resolveConcurrency(options.concurrency);
+			const indexKeys = indexCount && onExcessPropertyError ? ast.indexSignatures.map((index) => getIndexSignatureKeys(record, index.parameter, options)) : void 0;
+			if (onExcessPropertyError) {
 				expectedKeysSet ??= new Set(expectedKeys);
-				inputKeys = Reflect.ownKeys(record);
+				const coveredKeys = indexKeys ? new Set(expectedKeysSet) : expectedKeysSet;
+				if (indexKeys) for (const keys of indexKeys) for (const key of keys) coveredKeys.add(key);
+				const inputKeys = Reflect.ownKeys(record);
 				for (let i = 0; i < inputKeys.length; i++) {
 					const key = inputKeys[i];
-					if (!expectedKeysSet.has(key)) {
-						if (onExcessPropertyError) {
-							const unexpected = new UnexpectedKey(ast, record[key], options);
-							const issue = new Pointer([key], unexpected);
-							if (errorsAllOption) {
-								if (state.issues) state.issues.push(issue);
-								else state.issues = [issue];
-								continue;
-							} else return yield* fail$2(new Composite(ast, [issue], input, options));
-						} else assignProperty(out, key, record[key]);
+					if (!coveredKeys.has(key)) {
+						const unexpected = new UnexpectedKey(ast, record[key], options);
+						const issue = new Pointer([key], unexpected);
+						if (errorsAllOption) {
+							if (state.issues) state.issues.push(issue);
+							else state.issues = [issue];
+							continue;
+						} else return yield* fail$2(new Composite(ast, [issue], input, options));
 					}
 				}
 			}
-			const concurrency = resolveConcurrency(options?.concurrency);
 			if (hasProperties) {
-				const eff = parseProperties(state, properties, concurrency);
+				const eff = concurrency === 1 ? parseProperties(state, properties) : parsePropertiesConcurrent(state, properties, { concurrency });
 				if (eff) yield* eff;
 			}
-			if (indexCount && !concurrency) for (let i = 0; i < indexCount; i++) {
+			if (indexCount && concurrency === 1) for (let i = 0; i < indexCount; i++) {
 				const index = indexes[i];
 				const parse = index.is.parameter === string ? parseStringIndex : parseIndex;
-				const keys = index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options);
+				const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));
 				for (let j = 0; j < keys.length; j++) {
 					const eff = parse(state, keys[j], index);
 					if (!effectIsExit(eff)) yield* eff;
@@ -4532,22 +4068,16 @@ var Objects = class Objects extends Base {
 				}
 			}
 			else if (parseIndexes) {
-				const keyPairs = empty$1();
+				const keyPairs = empty$2();
 				for (let i = 0; i < indexCount; i++) {
 					const index = indexes[i];
-					const keys = getIndexSignatureKeys(record, index.is.parameter, options);
+					const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));
 					for (let j = 0; j < keys.length; j++) keyPairs.push([keys[j], index]);
 				}
-				const eff = parseIndexes(state, keyPairs, concurrency);
+				const eff = parseIndexes(state, keyPairs, { concurrency });
 				if (eff) yield* eff;
 			}
 			if (state.issues) return yield* fail$2(new Composite(ast, state.issues, input, options));
-			if (options.propertyOrder === "original") {
-				const keys = (inputKeys ?? Reflect.ownKeys(record)).concat(expectedKeys);
-				const preserved = {};
-				for (const key of keys) if (Object.hasOwn(out, key)) assignProperty(preserved, key, out[key]);
-				return preserved;
-			}
 			return out;
 		});
 		if (indexCount) return fallback;
@@ -4563,7 +4093,7 @@ var Objects = class Objects extends Base {
 		};
 		return (input, options) => {
 			if (input === missing) return missingExit;
-			if (options.errors === "all" || options.onExcessProperty !== void 0 || options.propertyOrder === "original" || options.concurrency !== void 0) return fallback(input, options);
+			if (options.errors === "all" || options.onExcessProperty !== void 0 || options.concurrency !== void 0 && resolveConcurrency(options.concurrency) !== 1) return fallback(input, options);
 			if (!(typeof input === "object" && input !== null && !Array.isArray(input))) return fail$2(new InvalidType(ast, input, options));
 			const props = compileMembers();
 			const record = input;
@@ -4579,7 +4109,7 @@ var Objects = class Objects extends Base {
 				for (let index = 0; index < props.length; index++) {
 					const property = props[index];
 					const name = property.name;
-					const hasKey = Object.hasOwn(record, name);
+					const hasKey = hasPropertySignature(record, name);
 					const value = hasKey ? record[name] : missing;
 					const exit = property.parser(value, options);
 					if (!effectIsExit(exit)) return resume(state, index, exit);
@@ -4640,15 +4170,17 @@ function stepProperty(s, p, exit) {
 		} else return fail$3(new Composite(s.ast, [issue], s.input, s.options));
 	}
 }
-var parseProperties = /*#__PURE__*/ iterateEager()({
+var parsePropertiesOptions = {
 	onItem(s, p) {
-		if (!Object.hasOwn(s.input, p.name)) return p.parser(missing, s.options);
+		if (!hasPropertySignature(s.input, p.name)) return p.parser(missing, s.options);
 		const value = s.input[p.name];
 		assignProperty(s.out, p.name, value);
 		return p.parser(value, s.options);
 	},
 	step: stepProperty
-});
+};
+var parseProperties = /*#__PURE__*/ iterateEager()(parsePropertiesOptions);
+var parsePropertiesConcurrent = /*#__PURE__*/ iterateConcurrent()(parsePropertiesOptions);
 function combineChecks(a, b) {
 	if (!a) return b;
 	if (!b) return a;
@@ -4669,8 +4201,8 @@ function tuple(elements, checks = void 0) {
 	return new Arrays(false, elements.map((e) => e.ast), [], void 0, checks);
 }
 /** @internal */
-function union(members, mode, checks) {
-	return new Union$1(members.map(getAST), mode, void 0, checks);
+function union(members, options, checks) {
+	return new Union$1(members.map(getAST), options, void 0, checks);
 }
 /** @internal */
 function structWithRest(ast, records) {
@@ -4783,6 +4315,7 @@ function collectSentinels(ast) {
 }
 var candidateIndexCache = /*#__PURE__*/ new WeakMap();
 var emptyCandidates = /*#__PURE__*/ Object.freeze([]);
+var hasPropertySignature = (input, key) => key === "__proto__" ? Object.hasOwn(input, key) : key in input;
 function getIndex(types) {
 	let index = candidateIndexCache.get(types);
 	if (index) return index;
@@ -4831,7 +4364,7 @@ function getIndex(types) {
 		for (const [literal, indexes] of byValue) candidates.set(literal, Object.freeze(Array.from(indexes, (index) => types[index])));
 		index = (input, isConstructor) => {
 			if (isObjectKeyword(input)) {
-				const value = Object.hasOwn(input, key) ? input[key] : void 0;
+				const value = hasPropertySignature(input, key) ? input[key] : void 0;
 				if (value !== void 0) return candidates.get(value) ?? emptyCandidates;
 				if (isConstructor) return types;
 			}
@@ -4847,7 +4380,7 @@ function getIndex(types) {
 			let directKey;
 			if (commonSentinel) {
 				const [key, [byValue]] = commonSentinel;
-				const hasKey = Object.hasOwn(input, key);
+				const hasKey = hasPropertySignature(input, key);
 				const value = hasKey ? input[key] : void 0;
 				if (hasKey && (!isConstructor || value !== void 0)) {
 					const match = byValue.get(value);
@@ -4857,7 +4390,7 @@ function getIndex(types) {
 				}
 			}
 			if (directKey === void 0) for (const [key, [byValue, all]] of bySentinel) {
-				const hasKey = Object.hasOwn(input, key);
+				const hasKey = hasPropertySignature(input, key);
 				const value = hasKey ? input[key] : void 0;
 				if (hasKey && (!isConstructor || value !== void 0)) {
 					const match = byValue.get(value);
@@ -4866,7 +4399,7 @@ function getIndex(types) {
 			}
 			for (const [key, [byValue, all]] of bySentinel) {
 				if (key === directKey) continue;
-				const hasKey = Object.hasOwn(input, key);
+				const hasKey = hasPropertySignature(input, key);
 				const value = hasKey ? input[key] : void 0;
 				if (hasKey && (!isConstructor || value !== void 0)) {
 					const match = byValue.get(value);
@@ -4897,44 +4430,20 @@ function getCandidates(input, types, isConstructor = false) {
 	return getIndex(types)(input, isConstructor);
 }
 /**
-* AST node representing a union of schemas.
-*
-* **Details**
-*
-* - `types` — the member AST nodes.
-* - `mode` — `"anyOf"` succeeds on the first match (like TypeScript unions);
-*   `"oneOf"` requires exactly one member to match (fails if multiple do).
-*
-* During parsing, members are tried in order. An internal candidate index
-* narrows which members to try based on the runtime type of the input and
-* discriminant ("sentinel") fields, making large unions efficient.
-*
-* **Example** (Inspecting a union AST)
-*
-* ```ts import.meta.vitest
-* import { Schema, SchemaAST } from "effect"
-*
-* const schema = Schema.Union([Schema.String, Schema.Number])
-* const ast = schema.ast
-*
-* if (SchemaAST.isUnion(ast)) {
-*   [ast.types.length, ast.mode] // => [2, "anyOf"]
-* }
-* ```
+* Constructs a {@link Union}.
 *
-* @see {@link isUnion}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Union$1 = class Union$1 extends Base {
+var Union$1 = class extends ASTNodeImpl {
 	_tag = "Union";
 	types;
-	mode;
+	options;
 	encodingChecks;
-	constructor(types, mode, annotations, checks, encoding, context, encodingChecks) {
+	constructor(types, options, annotations, checks, encoding, context, encodingChecks) {
 		super(annotations, checks, encoding, context);
 		this.types = types;
-		this.mode = mode;
+		this.options = options;
 		this.encodingChecks = encodingChecks;
 	}
 	/** @internal */
@@ -4943,6 +4452,7 @@ var Union$1 = class Union$1 extends Base {
 		return (input, options) => {
 			if (input === missing) return missingExit;
 			const candidates = getCandidates(input, ast.types, compileConstructorDefault !== void 0);
+			if (candidates.length === 0) return fail$2(new AnyOf(ast, [], input, options));
 			if (candidates.length === 1) {
 				const result = compile(candidates[0])(input, options);
 				if (result._tag === "Success") return result;
@@ -4953,15 +4463,11 @@ var Union$1 = class Union$1 extends Base {
 				compile,
 				input,
 				out: void 0,
-				successes: ast.mode === "oneOf" ? [] : void 0,
+				successes: ast.options?.mode === "oneOf" ? [] : void 0,
 				issues: void 0,
 				options
 			};
-			const concurrency = resolveConcurrency(options?.concurrency);
-			const eff = parseUnion(state, candidates, concurrency ? {
-				...concurrency,
-				orderedStep: true
-			} : void 0);
+			const eff = parseUnion(state, candidates);
 			if (!eff) {
 				if (state.out) return state.out;
 				return fail$2(new AnyOf(ast, state.issues ?? [], input, options));
@@ -4975,7 +4481,7 @@ var Union$1 = class Union$1 extends Base {
 	}
 	_rebuild(recur, checks, encodingChecks) {
 		const types = mapOrSame(this.types, recur);
-		return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union$1(types, this.mode, this.annotations, checks, void 0, this.context, encodingChecks);
+		return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union$1(types, this.options, this.annotations, checks, void 0, this.context, encodingChecks);
 	}
 	/** @internal */
 	recur(recur) {
@@ -5046,62 +4552,27 @@ var nonFiniteLiterals = /*#__PURE__*/ new Union$1([
 	/*#__PURE__*/ new Literal$1("Infinity"),
 	/*#__PURE__*/ new Literal$1("-Infinity"),
 	/*#__PURE__*/ new Literal$1("NaN")
-], "anyOf");
+]);
 function formatIsMutable(isMutable) {
 	return isMutable ? "" : "readonly ";
 }
 function formatIsOptional(isOptional) {
 	return isOptional ? "?" : "";
 }
-/** @internal */
-function memoizeThunk(f) {
-	let done = false;
-	let a;
-	return () => {
-		if (done) return a;
-		a = f();
-		done = true;
-		return a;
-	};
-}
 /**
-* AST node for lazy/recursive schemas.
-*
-* **Details**
-*
-* Wraps a thunk (`() => AST`) that is memoized on first call. Use this to
-* define recursive or mutually recursive schemas without infinite loops at
-* construction time.
+* Constructs a {@link Suspend}.
 *
-* **Example** (Defining recursive schema ASTs)
-*
-* ```ts import.meta.vitest
-* import { Schema, SchemaAST } from "effect"
-*
-* interface Category {
-*   readonly name: string
-*   readonly children: ReadonlyArray<Category>
-* }
-*
-* const Category = Schema.Struct({
-*   name: Schema.String,
-*   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
-* })
-*
-* SchemaAST.isObjects(Category.ast) // => true
-* ```
-*
-* @see {@link isSuspend}
-* @category models
-* @since 3.10.0
+* @category constructors
+* @since 4.0.0
 */
-var Suspend = class Suspend extends Base {
+var Suspend = class extends ASTNodeImpl {
 	_tag = "Suspend";
 	thunk;
 	constructor(thunk, annotations, checks, encoding, context) {
 		if (checks) throw new Error("Cannot add checks to Suspend");
 		super(annotations, void 0, encoding, context);
-		this.thunk = memoizeThunk(thunk);
+		let ast;
+		this.thunk = () => ast ??= thunk();
 	}
 	/** @internal */
 	getParser(compile) {
@@ -5118,27 +4589,12 @@ var Suspend = class Suspend extends Base {
 	}
 };
 /**
-* Represents a single validation check attached to an AST node.
-*
-* **Details**
-*
-* - `run` — the validation function. Returns `undefined` on success, or an
-*   `Issue` on failure.
-* - `annotations` — optional filter-level annotations (expected message,
-*   representation, arbitrary constraint hints).
-* - `aborted` — when `true`, parsing stops immediately after this filter
-*   fails (no further checks run).
+* Constructs a {@link Filter}.
 *
-* Use `.annotate()` to add metadata and `.abort()` to mark as aborting.
-* Combine with another check via `.and()` to form a {@link FilterGroup}.
-*
-* @see {@link FilterGroup}
-* @see {@link Check}
-* @see {@link isPattern}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var Filter = class Filter extends Class {
+var Filter = class extends Class {
 	_tag = "Filter";
 	run;
 	annotations;
@@ -5166,20 +4622,12 @@ var Filter = class Filter extends Class {
 	}
 };
 /**
-* Represents a composite validation check grouping multiple {@link Check} values.
+* Constructs a {@link FilterGroup}.
 *
-* **Details**
-*
-* Created by calling `.and()` on a {@link Filter} or another `FilterGroup`.
-* All inner checks are run; failures from aborted filters still stop
-* evaluation.
-*
-* @see {@link Filter}
-* @see {@link Check}
-* @category models
+* @category constructors
 * @since 4.0.0
 */
-var FilterGroup = class FilterGroup extends Class {
+var FilterGroup = class extends Class {
 	_tag = "FilterGroup";
 	checks;
 	annotations;
@@ -5212,16 +4660,13 @@ function isFinite$1(annotations) {
 		},
 		toJsonSchema: () => ({ type: "number" }),
 		toCode: () => ({ runtime: "Schema.isFinite()" }),
-		arbitrary: { constraint: {
-			noInfinity: true,
-			noNaN: true
-		} },
+		arbitraryConstraint: { number: "finite" },
 		...annotations
 	});
 }
 /** @internal */
 var finite = /*#__PURE__*/ appendChecks(number, [/*#__PURE__*/ isFinite$1()]);
-var numberToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finite, nonFiniteLiterals], "anyOf"), /*#__PURE__*/ new Transformation(/*#__PURE__*/ Number$3(), /*#__PURE__*/ transform$1((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
+var numberToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finite, nonFiniteLiterals]), /*#__PURE__*/ new Transformation(/*#__PURE__*/ Number$3(), /*#__PURE__*/ transform$1((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
 /**
 * Creates a {@link Filter} that validates strings by running `RegExp.test`.
 *
@@ -5241,8 +4686,12 @@ var numberToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finite, non
 *
 * **Gotchas**
 *
-* When deriving an arbitrary, only `regExp.source` is used. Regular expression
-* flags are ignored because fast-check does not support them.
+* Arbitrary metadata preserves both `regExp.source` and `regExp.flags`.
+* Implementations that cannot consume all flags may still use the source as a
+* generation hint because the Schema filter validates every generated value.
+* JSON Schema has no way to carry JavaScript regular-expression flags. The
+* generated `pattern` contains the source only, so validation can differ when
+* the RegExp uses flags or relies on JavaScript's non-Unicode behavior.
 *
 * **Example** (Validating an email pattern)
 *
@@ -5274,7 +4723,10 @@ function isPattern$1(regExp, annotations) {
 			}
 		},
 		toJsonSchema: () => ({ pattern: source }),
-		arbitrary: { constraint: { patterns: [regExp.source] } },
+		arbitraryConstraint: { patterns: [{
+			source: regExp.source,
+			flags: regExp.flags
+		}] },
 		...annotations
 	});
 }
@@ -5307,6 +4759,10 @@ function replaceContext(ast, context) {
 	return out;
 }
 /** @internal */
+function getLastEncoding(ast) {
+	return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast;
+}
+/** @internal */
 function annotate(ast, annotations) {
 	if (ast.checks) {
 		const last = ast.checks[ast.checks.length - 1];
@@ -5398,7 +4854,7 @@ var optionalKey$1 = /*#__PURE__*/ memoizeIdempotent((ast) => {
 });
 var optionalKeyLastLink = /*#__PURE__*/ applyToLastLink(optionalKey$1);
 /** @internal */
-var optional$1 = /*#__PURE__*/ memoize((ast) => optionalKey$1(new Union$1([ast, undefined_], "anyOf")));
+var optional$1 = /*#__PURE__*/ memoize((ast) => optionalKey$1(new Union$1([ast, undefined_])));
 /** @internal */
 function withConstructorDefault$1(ast, defaultValue) {
 	const constructorDefault = new Link(unknown, new Transformation(withDefault(defaultValue), passthrough$1()));
@@ -5410,9 +4866,8 @@ function withConstructorDefault$1(ast, defaultValue) {
 *
 * **Details**
 *
-* This is the low-level primitive behind `Schema.transform` and
-* `Schema.transformOrFail`. It appends a {@link Link} to the `to` node's
-* encoding chain.
+* This is the low-level primitive behind `Schema.decodeTo`. It appends a
+* {@link Link} to the `to` node's encoding chain.
 *
 * - Returns a new AST with the same type as `to`.
 *
@@ -5462,7 +4917,7 @@ function record(key, value) {
 * Checks `ast.context?.isOptional`. Defaults to `false` when no
 * {@link Context} is set.
 *
-* @see {@link optionalKey}
+* @see `Schema.optionalKey`
 * @see {@link Context}
 * @category predicates
 * @since 4.0.0
@@ -5590,10 +5045,10 @@ function containsUndefined(ast) {
 	}
 }
 function fromConst(ast, value) {
-	const succeed$4 = succeed(value);
+	const succeed$5 = value === 0 ? sameExit : succeed(value);
 	return (input, options) => {
 		if (input === missing) return missingExit;
-		if (input === value) return succeed$4;
+		if (input === value) return succeed$5;
 		return fail$2(new InvalidType(ast, input, options));
 	};
 }
@@ -5692,7 +5147,7 @@ function isStringFinite$1(annotations) {
 }
 var finiteString = /*#__PURE__*/ appendChecks(string, [/*#__PURE__*/ isStringFinite$1()]);
 var finiteToString = /*#__PURE__*/ new Link(finiteString, numberFromString);
-var numberToString = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finiteString, nonFiniteLiterals], "anyOf"), numberFromString);
+var numberToString = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finiteString, nonFiniteLiterals]), numberFromString);
 var isStringBigIntRegExp = /*#__PURE__*/ new globalThis.RegExp(`^-?\\d+$`);
 /** @internal */
 function isStringBigInt(annotations) {
@@ -5800,13 +5255,12 @@ var Json$1 = /*#__PURE__*/ new Declaration([], () => (input, ast, options) => is
 	},
 	expected: "JSON value",
 	toCodecJson: () => void 0,
-	toCodecStringTree: () => unknownToStringTree,
-	toArbitrary: () => (fc) => fc.jsonValue()
+	toCodecStringTree: () => unknownToStringTree
 });
 /** @internal */
 var unknownToJson = /*#__PURE__*/ new Link(Json$1, /*#__PURE__*/ passthrough());
 /** @internal */
-var objectKeywordToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([/*#__PURE__*/ new Arrays(false, [], [Json$1]), /*#__PURE__*/ new Objects([], [/*#__PURE__*/ new IndexSignature(string, Json$1)])], "anyOf"), /*#__PURE__*/ passthrough());
+var objectKeywordToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([/*#__PURE__*/ new Arrays(false, [], [Json$1]), /*#__PURE__*/ new Objects([], [/*#__PURE__*/ new IndexSignature(string, Json$1)])]), /*#__PURE__*/ passthrough());
 /**
 * Returns true if the value is a StringTree value.
 *
@@ -5823,7 +5277,7 @@ var unknownToStringTree = /*#__PURE__*/ new Link(/* @__PURE__ */ new Declaration
 	toCodecStringTree: () => void 0
 }), /*#__PURE__*/ passthrough());
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/SchemaParser.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaParser.js
 /**
 * Runs schemas against real values.
 *
@@ -5854,9 +5308,10 @@ var unknownToStringTree = /*#__PURE__*/ new Link(/* @__PURE__ */ new Declaration
 * @since 4.0.0
 */
 function makeEffect(schema) {
-	const parser = runWithCompiler(constructorCompiler, toType$1(schema.ast));
+	const ast = schema.ast;
+	let parser;
 	return (input, options) => {
-		return parser(input, options?.disableChecks ? options?.parseOptions ? {
+		return (parser ??= runWithCompiler(constructorCompiler, toType$1(ast)))(input, options?.disableChecks ? options?.parseOptions ? {
 			...options.parseOptions,
 			disableChecks: true
 		} : { disableChecks: true } : options?.parseOptions);
@@ -5914,7 +5369,7 @@ function makeOption(schema) {
 * @category constructors
 * @since 4.0.0
 */
-function make$2(schema) {
+function make$3(schema) {
 	const parser = makeEffect(schema);
 	return (input, options) => {
 		const exit = runSyncExit(parser(input, options));
@@ -6115,11 +5570,7 @@ function makeParser(ast, compile, compileConstructorDefault, constructorDefault)
 	const checks = ast.checks;
 	const links = constructorDefault ? ast.encoding ? [...ast.encoding, constructorDefault] : [constructorDefault] : ast.encoding;
 	const encodingChecks = ast.encodingChecks;
-	const astOptions = (checks ? checks[checks.length - 1].annotations : ast.annotations)?.["parseOptions"];
-	if (!links && !checks && !encodingChecks) {
-		if (!astOptions) return parser;
-		return (input, options) => parser(input, mergeParseOptions(options, astOptions));
-	}
+	if (!links && !checks && !encodingChecks) return parser;
 	let encodingParsers;
 	const parseLocal = (input, options) => {
 		let result = parser(input, options);
@@ -6158,9 +5609,8 @@ function makeParser(ast, compile, compileConstructorDefault, constructorDefault)
 		}
 		return result;
 	};
-	if (!links) return astOptions ? (input, options) => parseLocal(input, mergeParseOptions(options, astOptions)) : parseLocal;
+	if (!links) return parseLocal;
 	return (input, options) => {
-		if (astOptions) options = mergeParseOptions(options, astOptions);
 		const parsers = encodingParsers ??= links.map((link) => compile(link.to));
 		let current = input;
 		let result = parsers[parsers.length - 1](input, options);
@@ -6190,11 +5640,11 @@ function makeParser(ast, compile, compileConstructorDefault, constructorDefault)
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/internal/schema/schema.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/make.js
 /** @internal */
-var TypeId$1 = "~effect/Schema/Schema";
+var TypeId$3 = "~effect/Schema/Schema";
 var SchemaProto = {
-	[TypeId$1]: TypeId$1,
+	[TypeId$3]: TypeId$3,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -6209,58 +5659,436 @@ var SchemaProto = {
 	}
 };
 /** @internal */
-function make$1(ast, options) {
+function make$2(ast, options) {
 	function Schema() {}
-	const self = Object.defineProperties(Object.setPrototypeOf(Schema, SchemaProto), Object.getOwnPropertyDescriptors({ ...options }));
+	const self = Object.setPrototypeOf(Schema, SchemaProto);
+	if (options && (Object.hasOwn(options, "name") || Object.hasOwn(options, "length") || Object.hasOwn(options, "__proto__"))) Object.defineProperties(self, Object.getOwnPropertyDescriptors({ ...options }));
+	else Object.assign(self, options);
 	self.ast = ast;
-	self.rebuild = (ast) => make$1(ast, options);
+	self.rebuild = (ast) => make$2(ast, options);
 	self.makeEffect = makeEffect(self);
-	self.make = make$2(self);
+	self.make = make$3(self);
 	self.makeOption = makeOption(self);
 	return self;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Struct.js
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/toCodec.js
+/** @internal */
+function toCodecJson$1(schema) {
+	return make$2(toCodecJsonAST(schema.ast), { schema });
+}
+/** @internal */
+var toCodecJsonAST = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+	const out = toCodecJsonASTStep(ast, toCodecJsonAST);
+	const context = ast.context;
+	if (out === ast || context === void 0) return out;
+	return replaceContextLastLink(out, withoutConstructorDefault(context));
+});
+function withoutConstructorDefault(context) {
+	return context.constructorDefault === void 0 ? context : new Context(context.isOptional, context.isMutable, void 0, context.annotations);
+}
+function validateCanonicalObjectPropertyNames(ast) {
+	if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) throw new globalThis.Error("Objects property names must be strings", { cause: ast });
+}
+function makeReorder(getPriority) {
+	return (types) => {
+		const indexMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < types.length; i++) indexMap.set(toEncoded(types[i]), i);
+		const sortedTypes = [...types].sort((a, b) => {
+			a = toEncoded(a);
+			b = toEncoded(b);
+			const pa = getPriority(a);
+			const pb = getPriority(b);
+			if (pa !== pb) return pa - pb;
+			return indexMap.get(a) - indexMap.get(b);
+		});
+		if (!sortedTypes.some((ast, index) => ast !== types[index])) return types;
+		return sortedTypes;
+	};
+}
+var toCodecJsonReorder = /*#__PURE__*/ makeReorder((ast) => {
+	switch (ast._tag) {
+		case "BigInt":
+		case "Symbol":
+		case "UniqueSymbol": return 0;
+		default: return 1;
+	}
+});
+function toCodecJsonASTStep(ast, recur) {
+	switch (ast._tag) {
+		case "Declaration": {
+			const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
+			if (!isFunction(getLink)) return replaceEncoding(ast, [unknownToJson]);
+			const link = getLink(ast.typeParameters.map((tp) => make$2(toEncoded(tp))));
+			return link === void 0 ? ast : replaceEncoding(ast, [mapLink(link, recur)]);
+		}
+		case "Unknown": return replaceEncoding(ast, [unknownToJson]);
+		case "ObjectKeyword": return replaceEncoding(ast, [objectKeywordToJson]);
+		case "Undefined":
+		case "Void":
+		case "Literal":
+		case "Number": return ast.toCodecJson();
+		case "UniqueSymbol":
+		case "Symbol":
+		case "BigInt": return ast.toCodecStringTree();
+		case "Objects":
+			validateCanonicalObjectPropertyNames(ast);
+			return ast.recur(recur, parameterFromString);
+		case "Union": {
+			const sortedTypes = toCodecJsonReorder(ast.types);
+			if (sortedTypes !== ast.types) return new Union$1(sortedTypes, ast.options, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
+			return ast.recur(recur);
+		}
+		case "Arrays":
+		case "Suspend": return ast.recur(recur);
+	}
+	return ast;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Struct.js
+/**
+* Wraps a plain function as a {@link Lambda} value so it can be used with
+* {@link map}, {@link mapPick}, and {@link mapOmit}.
+*
+* **When to use**
+*
+* Use to create a typed lambda for struct mapping APIs that need type-level
+* input and output tracking.
+*
+* **Details**
+*
+* The type parameter `L` encodes both the input and output types at the type
+* level, allowing the compiler to track how struct value types change. At
+* runtime, the returned value is the same function; `lambda` only adjusts the
+* type.
+*
+* **Example** (Wrapping values in arrays)
+*
+* ```ts import.meta.vitest
+* import { pipe, Struct } from "effect"
+*
+* interface AsArray extends Struct.Lambda {
+*   <A>(self: A): Array<A>
+*   readonly "~lambda.out": Array<this["~lambda.in"]>
+* }
+*
+* const asArray = Struct.lambda<AsArray>((a) => [a])
+* const result = pipe({ x: 1, y: "hello" }, Struct.map(asArray))
+* result // => { x: [1], y: ["hello"] }
+* ```
+*
+* @see {@link Lambda} – the type-level interface
+* @see {@link map} – apply a lambda to all struct values
+* @category constructors
+* @since 4.0.0
+*/
+var lambda = (f) => f;
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schemaError.js
+var SchemaErrorTypeId = "~effect/Schema/SchemaError";
+function isSchemaError$1(u) {
+	return hasProperty(u, "~effect/Schema/SchemaError") && u["~effect/Schema/SchemaError"] === "~effect/Schema/SchemaError";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/Cookies.js
+/**
+* Models HTTP cookies and cookie collections for requests and responses.
+*
+* A `Cookie` stores a name, value, encoded value, and standard cookie
+* attributes. A `Cookies` value is an immutable collection keyed by cookie
+* name. This module parses request `Cookie` headers, builds response
+* `Set-Cookie` headers, and provides helpers for adding, removing, merging, and
+* expiring cookies.
+*
+* @since 4.0.0
+*/
+var TypeId$2 = "~effect/http/Cookies";
+var CookieTypeId = "~effect/http/Cookies/Cookie";
+TaggedError$1("CookiesError");
+var Proto$1 = {
+	[TypeId$2]: TypeId$2,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "effect/Cookies",
+			cookies: map(this.cookies, (cookie) => cookie.toJSON())
+		};
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates a `Cookies` collection from an existing readonly record of cookies keyed by cookie name.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromReadonlyRecord = (cookies) => {
+	const self = Object.create(Proto$1);
+	self.cookies = cookies;
+	return self;
+};
+/**
+* Create a Cookies object from an Iterable
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromIterable = (cookies) => {
+	const record = {};
+	for (const cookie of cookies) assignProperty(record, cookie.name, cookie);
+	return fromReadonlyRecord(record);
+};
+/**
+* Create a Cookies object from a set of Set-Cookie headers
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromSetCookie = (headers) => {
+	const arrayHeaders = typeof headers === "string" ? [headers] : headers;
+	const cookies = [];
+	for (const header of arrayHeaders) {
+		const cookie = parseSetCookie(header.trim());
+		if (cookie) cookies.push(cookie);
+	}
+	return fromIterable(cookies);
+};
+function parseSetCookie(header) {
+	const parts = header.split(";").map((_) => _.trim()).filter((_) => _ !== "");
+	if (parts.length === 0) return;
+	const firstEqual = parts[0].indexOf("=");
+	if (firstEqual === -1) return;
+	const name = parts[0].slice(0, firstEqual);
+	if (!cookieNameRegExp.test(name)) return;
+	const valueEncoded = parts[0].slice(firstEqual + 1);
+	const value = tryDecodeURIComponent(valueEncoded);
+	if (parts.length === 1) return Object.assign(Object.create(CookieProto), {
+		name,
+		value,
+		valueEncoded
+	});
+	const options = {};
+	for (let i = 1; i < parts.length; i++) {
+		const part = parts[i];
+		const equalIndex = part.indexOf("=");
+		const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim();
+		const value = equalIndex === -1 ? void 0 : part.slice(equalIndex + 1).trim();
+		switch (key.toLowerCase()) {
+			case "domain": {
+				if (value === void 0) break;
+				const domain = value.trim().replace(/^\./, "");
+				if (domain) options.domain = domain;
+				break;
+			}
+			case "expires": {
+				if (value === void 0) break;
+				const date = new Date(value);
+				if (!isNaN(date.getTime())) options.expires = date;
+				break;
+			}
+			case "max-age": {
+				if (value === void 0) break;
+				const maxAge = parseInt(value, 10);
+				if (!isNaN(maxAge)) options.maxAge = seconds(maxAge);
+				break;
+			}
+			case "path":
+				if (value === void 0) break;
+				if (value[0] === "/") options.path = value;
+				break;
+			case "priority":
+				if (value === void 0) break;
+				switch (value.toLowerCase()) {
+					case "low":
+						options.priority = "low";
+						break;
+					case "medium":
+						options.priority = "medium";
+						break;
+					case "high": options.priority = "high";
+				}
+				break;
+			case "httponly":
+				options.httpOnly = true;
+				break;
+			case "secure":
+				options.secure = true;
+				break;
+			case "partitioned":
+				options.partitioned = true;
+				break;
+			case "samesite":
+				if (value === void 0) break;
+				switch (value.toLowerCase()) {
+					case "lax":
+						options.sameSite = "lax";
+						break;
+					case "strict":
+						options.sameSite = "strict";
+						break;
+					case "none": options.sameSite = "none";
+				}
+		}
+	}
+	return Object.assign(Object.create(CookieProto), {
+		name,
+		value,
+		valueEncoded,
+		options: Object.keys(options).length > 0 ? options : void 0
+	});
+}
+var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var CookieProto = {
+	[CookieTypeId]: CookieTypeId,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "effect/Cookies/Cookie",
+			name: this.name,
+			value: this.value,
+			options: this.options
+		};
+	}
+};
+var tryDecodeURIComponent = (str) => {
+	try {
+		return decodeURIComponent(str);
+	} catch (_) {
+		return str;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/UrlParams.js
+/**
+* Models URL query parameters as ordered string pairs.
+*
+* `UrlParams` is used for HTTP client query strings, URL-encoded form bodies,
+* and server-side decoding. Values can be built from records, iterables, or
+* native `URLSearchParams`, then updated, serialized, converted to a `URL`, or
+* decoded with schemas.
+*
+* @since 4.0.0
+*/
+var TypeId$1 = "~effect/http/UrlParams";
+/**
+* Returns `true` when a value is a `UrlParams` instance.
+*
+* @category guards
+* @since 4.0.0
+*/
+var isUrlParams = (u) => hasProperty(u, TypeId$1);
+var Proto = {
+	...PipeInspectableProto,
+	[TypeId$1]: TypeId$1,
+	[Symbol.iterator]() {
+		return this.params[Symbol.iterator]();
+	},
+	toJSON() {
+		return {
+			_id: "UrlParams",
+			params: Object.fromEntries(this.params)
+		};
+	},
+	[symbol$1](that) {
+		return Equivalence(this, that);
+	},
+	[symbol]() {
+		return array(this.params.flat());
+	}
+};
 /**
-* Wraps a plain function as a {@link Lambda} value so it can be used with
-* {@link map}, {@link mapPick}, and {@link mapOmit}.
+* Creates `UrlParams` from ordered string key-value pairs.
 *
-* **When to use**
+* **Details**
 *
-* Use to create a typed lambda for struct mapping APIs that need type-level
-* input and output tracking.
+* The input pairs are used as-is and are not coerced or normalized.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var make$1 = (params) => {
+	const self = Object.create(Proto);
+	self.params = params;
+	return self;
+};
+/**
+* Creates `UrlParams` from a supported input shape.
 *
 * **Details**
 *
-* The type parameter `L` encodes both the input and output types at the type
-* level, allowing the compiler to track how struct value types change. At
-* runtime, the returned value is the same function; `lambda` only adjusts the
-* type.
+* Primitive values are converted to strings, arrays produce repeated parameters,
+* nested records use bracket notation, and `undefined` values are omitted.
 *
-* **Example** (Wrapping values in arrays)
+* @category constructors
+* @since 4.0.0
+*/
+var fromInput = (input) => {
+	if (isUrlParams(input)) return input;
+	const parsed = fromInputNested(input);
+	const out = [];
+	for (let i = 0; i < parsed.length; i++) if (Array.isArray(parsed[i][0])) {
+		const [keys, value] = parsed[i];
+		out.push([`${keys[0]}[${keys.slice(1).join("][")}]`, value]);
+	} else out.push(parsed[i]);
+	return make$1(out);
+};
+var fromInputNested = (input) => {
+	const entries = typeof input[Symbol.iterator] === "function" ? fromIterable$1(input) : Object.entries(input);
+	const out = [];
+	for (const [key, value] of entries) if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) if (value[i] !== void 0) out.push([key, String(value[i])]);
+	} else if (value !== null && typeof value === "object") {
+		const nested = fromInputNested(value);
+		for (const [k, v] of nested) out.push([[key, ...typeof k === "string" ? [k] : k], v]);
+	} else if (value !== void 0) out.push([key, String(value)]);
+	return out;
+};
+/**
+* Provides an order-sensitive `Equivalence` instance for `UrlParams`.
 *
-* ```ts import.meta.vitest
-* import { pipe, Struct } from "effect"
+* **Details**
 *
-* interface AsArray extends Struct.Lambda {
-*   <A>(self: A): Array<A>
-*   readonly "~lambda.out": Array<this["~lambda.in"]>
-* }
+* Two values are equivalent when they contain the same key-value pairs in the same
+* order.
 *
-* const asArray = Struct.lambda<AsArray>((a) => [a])
-* const result = pipe({ x: 1, y: "hello" }, Struct.map(asArray))
-* result // => { x: [1], y: ["hello"] }
-* ```
+* @category instances
+* @since 4.0.0
+*/
+var Equivalence = /*#__PURE__*/ make$9((a, b) => arrayEquivalence(a.params, b.params));
+var arrayEquivalence = /*#__PURE__*/ makeEquivalence$2(/*#__PURE__*/ makeEquivalence$1([/*#__PURE__*/ strictEqual(), /*#__PURE__*/ strictEqual()]));
+/**
+* An empty `UrlParams` value.
 *
-* @see {@link Lambda} – the type-level interface
-* @see {@link map} – apply a lambda to all struct values
 * @category constructors
 * @since 4.0.0
 */
-var lambda = (f) => f;
+var empty = /*#__PURE__*/ make$1([]);
+/**
+* Sets multiple query parameters from input.
+*
+* **Details**
+*
+* Keys present in the input replace existing values for those keys, while
+* unmentioned existing parameters are preserved.
+*
+* @category combinators
+* @since 4.0.0
+*/
+var setAll = /*#__PURE__*/ dual(2, (self, input) => {
+	const params = fromInput(input).params.slice();
+	const keys = /* @__PURE__ */ new Set();
+	for (let i = 0; i < params.length; i++) keys.add(params[i][0]);
+	for (let i = 0; i < self.params.length; i++) {
+		if (keys.has(self.params[i][0])) continue;
+		params.push(self.params[i]);
+	}
+	return make$1(params);
+});
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.0-rc.112/node_modules/effect/dist/Schema.js
-var TypeId = TypeId$1;
+//#region ../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Schema.js
+var TypeId = TypeId$3;
 /**
 * Creates a schema for a **parametric** type (a generic container such as
 * `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
@@ -6356,7 +6184,6 @@ function declareConstructor() {
 function declare(is, annotations) {
 	return declareConstructor()([], () => (input, ast, options) => is(input) ? succeed$3(input) : fail$2(new InvalidType(ast, input, options)), annotations);
 }
-var SchemaErrorTypeId = "~effect/SchemaError/SchemaError";
 /**
 * Error thrown or returned when schema decoding or encoding fails.
 *
@@ -6426,7 +6253,28 @@ var SchemaError = class extends TaggedError$1("SchemaError") {
 * @since 4.0.0
 */
 function isSchemaError(u) {
-	return hasProperty(u, SchemaErrorTypeId) && u[SchemaErrorTypeId] === SchemaErrorTypeId;
+	return isSchemaError$1(u);
+}
+function fromIssueEffect(self) {
+	if (effectIsExit(self)) return fromIssueExit(self);
+	return catchCause(self, (cause) => failCauseSync(() => map$4(cause, (issue) => new SchemaError(issue))));
+}
+function fromIssueExit(exit) {
+	return isSuccess(exit) ? exit : failCause(map$4(exit.cause, (issue) => new SchemaError(issue)));
+}
+function getSchemaErrorOrThrow(cause, message) {
+	let schemaError;
+	for (const reason of cause.reasons) {
+		if (!isFailReason(reason) || !isSchemaError(reason.error)) throw new globalThis.Error(message, { cause });
+		schemaError ??= reason.error;
+	}
+	if (schemaError === void 0) throw new globalThis.Error(message, { cause });
+	return schemaError;
+}
+function runSchemaErrorSync(self) {
+	const exit = runSyncExit(self);
+	if (isSuccess(exit)) return exit.value;
+	throw getSchemaErrorOrThrow(exit.cause, "Sync adapter can only throw schema errors");
 }
 /**
 * Creates a type guard function that checks if a value conforms to a given
@@ -6493,10 +6341,6 @@ function decodeUnknownEffect(schema, options) {
 		return fromIssueEffect(parser(input, options));
 	};
 }
-function fromIssueEffect(self) {
-	if (effectIsExit(self)) return fromIssueExit(self);
-	return catchCause(self, (cause) => failCauseSync(() => map$4(cause, (issue) => new SchemaError(issue))));
-}
 /**
 * Decodes a typed input (the schema's `Encoded` type) against a schema,
 * returning an `Effect` that succeeds with the decoded value or fails with a
@@ -6519,23 +6363,6 @@ function fromIssueEffect(self) {
 * @since 4.0.0
 */
 var decodeEffect = decodeUnknownEffect;
-function getSchemaErrorOrThrow(cause, message) {
-	let schemaError;
-	for (const reason of cause.reasons) {
-		if (!isFailReason(reason) || !isSchemaError(reason.error)) throw new globalThis.Error(message, { cause });
-		schemaError ??= reason.error;
-	}
-	if (schemaError === void 0) throw new globalThis.Error(message, { cause });
-	return schemaError;
-}
-function runSchemaErrorSync(self) {
-	const exit = runSyncExit(self);
-	if (isSuccess(exit)) return exit.value;
-	throw getSchemaErrorOrThrow(exit.cause, "Sync adapter can only throw schema errors");
-}
-function fromIssueExit(exit) {
-	return isSuccess(exit) ? exit : failCause(map$4(exit.cause, (issue) => new SchemaError(issue)));
-}
 /**
 * Decodes an `unknown` input against a schema, returning an `Option` that is
 * `Some` with the decoded value on success or `None` for schema mismatches.
@@ -6799,7 +6626,7 @@ var encodeEffect = encodeUnknownEffect;
 * @category constructors
 * @since 3.10.0
 */
-var make = make$1;
+var make = make$2;
 /**
 * Checks whether a value is a `Schema`.
 *
@@ -6904,8 +6731,8 @@ function Literal(literal) {
 	});
 	return out;
 }
-function templateLiteralFromParts(parts) {
-	return new TemplateLiteral$1(parts.map((part) => isSchema(part) ? part.ast : new Literal$1(part)));
+function templateLiteralParts(parts) {
+	return parts.map((part) => isSchema(part) ? part.ast : new Literal$1(part));
 }
 /**
 * Creates a schema that validates strings by matching ordered template literal
@@ -6922,6 +6749,13 @@ function templateLiteralFromParts(parts) {
 * encoded type is `string`, `number`, or `bigint`. Checks on string, number,
 * and bigint schema parts are applied while matching each segment.
 *
+* **Gotchas**
+*
+* Parts must not contain encodings, including inside unions or nested templates.
+* Construction throws for transformed parts even when their decoded and encoded
+* types are the same. Use {@link TemplateLiteralParser} to decode transformed parts.
+* Brands and supported checks without encodings remain valid.
+*
 * **Example** (Defining a URL path pattern)
 *
 * ```ts import.meta.vitest
@@ -6936,9 +6770,16 @@ function templateLiteralFromParts(parts) {
 * @since 3.10.0
 */
 function TemplateLiteral(parts) {
-	return make(templateLiteralFromParts(parts), { parts });
+	return make(new TemplateLiteral$1(templateLiteralParts(parts)), { parts });
 }
 /**
+* Schema for the `never` type. Always fails validation — no value satisfies it.
+*
+* @category schemas
+* @since 3.10.0
+*/
+var Never = /*#__PURE__*/ make(never);
+/**
 * Schema for the `unknown` type. Accepts any value without validation.
 *
 * **When to use**
@@ -7035,6 +6876,9 @@ function makeStruct(ast, fields) {
 *
 * The resulting schema's `Type` is a readonly object type with the fields'
 * decoded types. The `Encoded` form mirrors the field schemas' encoded types.
+* Declared fields may be inherited and are copied to own properties in the
+* output. The `__proto__` field is accepted only when it is an own property.
+* Parsing does not guarantee that output keys retain their input order.
 *
 * **Example** (Defining a basic struct)
 *
@@ -7131,8 +6975,9 @@ function extendTo(fields, derive) {
 *
 * When decoded or encoded key transformations produce the same property key,
 * sequential parsing applies selected own properties in selection order, so
-* the later selected property overwrites the earlier value. With concurrency
-* greater than `1`, completion order determines which value is retained.
+* the later selected property overwrites the earlier value. Dynamic key
+* selection always examines own properties. Finite literal keys are declared
+* fields and may therefore be inherited. Output key order is not guaranteed.
 *
 * **Example** (Defining a string-keyed record of numbers)
 *
@@ -7223,30 +7068,12 @@ function Tuple(elements) {
 * @since 4.0.0
 */
 var ArraySchema = /*#__PURE__*/ lambda((schema) => make(new Arrays(false, [], [schema.ast]), { value: schema }));
-/**
-* Defines a non-empty `ReadonlyArray` schema — at least one element required.
-* Type is `readonly [T, ...T[]]`.
-*
-* **Example** (Defining a non-empty array of numbers)
-*
-* ```ts import.meta.vitest
-* import { Schema } from "effect"
-*
-* const schema = Schema.NonEmptyArray(Schema.Number)
-*
-* Schema.decodeUnknownSync(schema)([1, 2, 3]) // => [1, 2, 3]
-* ```
-*
-* @category constructors
-* @since 3.10.0
-*/
-var NonEmptyArray = /*#__PURE__*/ lambda((schema) => make(new Arrays(false, [schema.ast], [schema.ast]), { value: schema }));
 function makeUnion(ast, members) {
 	return make(ast, {
 		members,
 		mapMembers(f, options) {
 			const members = f(this.members);
-			return makeUnion(union(members, this.ast.mode, options?.unsafePreserveChecks ? this.ast.checks : void 0), members);
+			return makeUnion(union(members, this.ast.options, options?.unsafePreserveChecks ? this.ast.checks : void 0), members);
 		}
 	});
 }
@@ -7275,7 +7102,7 @@ function makeUnion(ast, members) {
 * @since 3.10.0
 */
 function Union(members, options) {
-	return makeUnion(union(members, options?.mode ?? "anyOf", void 0), members);
+	return makeUnion(union(members, options, void 0), members);
 }
 /**
 * Creates a union schema from an array of literal values.
@@ -7295,7 +7122,7 @@ function Union(members, options) {
 */
 function Literals(literals) {
 	const members = literals.map(Literal);
-	return make(union(members, "anyOf", void 0), {
+	return make(union(members, void 0, void 0), {
 		literals,
 		members,
 		mapMembers(f) {
@@ -7458,13 +7285,24 @@ function catchDecodingWithContext(f) {
 }
 function decodeTo(to, transformation) {
 	return (from) => {
-		return make(decodeTo$1(from.ast, to.ast, transformation ? make$3(transformation) : passthrough()), {
+		return make(decodeTo$1(from.ast, to.ast, transformation ? make$4(transformation) : passthrough()), {
 			from,
 			to
 		});
 	};
 }
 /**
+* Constructs a decode-only `SchemaAST.Link`.
+*
+* @internal
+*/
+function linkDecoding() {
+	return (to, decode) => link()(to, {
+		decode,
+		encode: forbiddenEncoding
+	});
+}
+/**
 * Applies a transformation to a schema, creating a new schema with the same type but transformed encoding/decoding.
 *
 * **When to use**
@@ -7648,7 +7486,7 @@ function instanceOf(constructor, annotations) {
 */
 function link() {
 	return (encodeTo, transformation) => {
-		return new Link(encodeTo.ast, make$3(transformation));
+		return new Link(encodeTo.ast, make$4(transformation));
 	};
 }
 /**
@@ -7723,7 +7561,7 @@ var TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$";
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `patterns`
+* During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the trimmed pattern.
 *
 * @category validation
@@ -7739,7 +7577,10 @@ function isTrimmed(annotations) {
 		},
 		toJsonSchema: () => ({ pattern: regExp.source }),
 		toCode: () => ({ runtime: "Schema.isTrimmed()" }),
-		arbitrary: { constraint: { patterns: [TRIMMED_PATTERN] } },
+		arbitraryConstraint: { patterns: [{
+			source: TRIMMED_PATTERN,
+			flags: ""
+		}] },
 		...annotations
 	});
 }
@@ -7750,11 +7591,13 @@ function isTrimmed(annotations) {
 *
 * JSON Schema:
 *
-* This check corresponds to the `pattern` constraint in JSON Schema.
+* JSON Schema receives the RegExp source as a `pattern`. JavaScript flags are
+* not represented, so validation can differ when the RegExp uses flags or
+* relies on JavaScript's non-Unicode behavior.
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `patterns`
+* During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the specified RegExp pattern.
 *
 * @category validation
@@ -7781,7 +7624,7 @@ function isPattern(regExp, annotations) {
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `patterns`
+* During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the number string pattern.
 *
 * @category validation
@@ -7812,8 +7655,7 @@ var Finite = /*#__PURE__*/ make(finite);
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies `noNaN: true` and
-* `noInfinity: true` constraints to ensure generated numbers are finite.
+* During arbitrary generation, this applies a finite-number constraint.
 *
 * @category validation
 * @since 4.0.0
@@ -7832,10 +7674,10 @@ function makeIsGreaterThanOrEqualTo(options) {
 	return (minimum, annotations) => {
 		return makeFilter((input) => gte(input, minimum), {
 			expected: `a value greater than or equal to ${formatter(minimum)}`,
-			arbitrary: { constraint: { ordered: {
+			arbitraryConstraint: {
 				order: options.order,
 				minimum
-			} } },
+			},
 			...options.annotate?.(minimum),
 			...annotations
 		});
@@ -7854,15 +7696,45 @@ function makeIsLessThanOrEqualTo(options) {
 	return (maximum, annotations) => {
 		return makeFilter((input) => lte(input, maximum), {
 			expected: `a value less than or equal to ${formatter(maximum)}`,
-			arbitrary: { constraint: { ordered: {
+			arbitraryConstraint: {
 				order: options.order,
 				maximum
-			} } },
+			},
 			...options.annotate?.(maximum),
 			...annotations
 		});
 	};
 }
+/**
+* Creates an inclusive or exclusive range check for any ordered type from an
+* `Order.Order` instance.
+*
+* @category validation
+* @since 4.0.0
+*/
+function makeIsBetween(deriveOptions) {
+	const greaterThanOrEqualTo = isGreaterThanOrEqualTo$1(deriveOptions.order);
+	const greaterThan = isGreaterThan$1(deriveOptions.order);
+	const lessThanOrEqualTo = isLessThanOrEqualTo$3(deriveOptions.order);
+	const lessThan = isLessThan$1(deriveOptions.order);
+	const formatter = deriveOptions.formatter ?? format$1;
+	return (options, annotations) => {
+		const gte = options.exclusiveMinimum ? greaterThan : greaterThanOrEqualTo;
+		const lte = options.exclusiveMaximum ? lessThan : lessThanOrEqualTo;
+		return makeFilter((input) => gte(input, options.minimum) && lte(input, options.maximum), {
+			expected: `a value between ${formatter(options.minimum)}${options.exclusiveMinimum ? " (excluded)" : ""} and ${formatter(options.maximum)}${options.exclusiveMaximum ? " (excluded)" : ""}`,
+			arbitraryConstraint: {
+				order: deriveOptions.order,
+				minimum: options.minimum,
+				maximum: options.maximum,
+				...options.exclusiveMinimum && { exclusiveMinimum: true },
+				...options.exclusiveMaximum && { exclusiveMaximum: true }
+			},
+			...deriveOptions.annotate?.(options),
+			...annotations
+		});
+	};
+}
 function encodeNumberPayload(number) {
 	if (!globalThis.Number.isFinite(number)) throw new globalThis.RangeError(`Expected a finite number, got ${format$1(number)}`);
 	return number;
@@ -7879,7 +7751,7 @@ function encodeNumberPayload(number) {
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `minimum` constraint
+* During arbitrary generation, this applies a `minimum` constraint
 * to ensure generated numbers are greater than or equal to the specified value.
 *
 * @category validation
@@ -7908,7 +7780,7 @@ var isGreaterThanOrEqualTo = /*#__PURE__*/ makeIsGreaterThanOrEqualTo({
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `maximum` constraint
+* During arbitrary generation, this applies a `maximum` constraint
 * to ensure generated numbers are less than or equal to the specified value.
 *
 * @category validation
@@ -7926,6 +7798,50 @@ var isLessThanOrEqualTo = /*#__PURE__*/ makeIsLessThanOrEqualTo({
 	})
 });
 /**
+* Validates that a number is within a specified range. The range boundaries can
+* be inclusive or exclusive based on the provided options.
+*
+* **Details**
+*
+* JSON Schema:
+*
+* This check corresponds to `minimum`/`maximum` or `exclusiveMinimum`/`exclusiveMaximum`
+* constraints in JSON Schema, depending on the options provided.
+*
+* Arbitrary:
+*
+* During arbitrary generation, this applies `minimum` and
+* `maximum` constraints with optional `exclusiveMinimum` and
+* `exclusiveMaximum` flags to ensure generated numbers fall within the
+* specified range.
+*
+* @category validation
+* @since 4.0.0
+*/
+var isBetween = /*#__PURE__*/ makeIsBetween({
+	order: Number$4,
+	annotate: (options) => {
+		const exclusiveMinimum = options.exclusiveMinimum ? true : void 0;
+		const exclusiveMaximum = options.exclusiveMaximum ? true : void 0;
+		return {
+			representation: {
+				id: "effect/schema/isBetween",
+				payload: {
+					minimum: encodeNumberPayload(options.minimum),
+					maximum: encodeNumberPayload(options.maximum),
+					...exclusiveMinimum && { exclusiveMinimum },
+					...exclusiveMaximum && { exclusiveMaximum }
+				}
+			},
+			toJsonSchema: () => ({
+				[exclusiveMinimum ? "exclusiveMinimum" : "minimum"]: options.minimum,
+				[exclusiveMaximum ? "exclusiveMaximum" : "maximum"]: options.maximum
+			}),
+			toCode: () => ({ runtime: `Schema.isBetween({ minimum: ${format$1(options.minimum)}, maximum: ${format$1(options.maximum)}, exclusiveMinimum: ${format$1(exclusiveMinimum)}, exclusiveMaximum: ${format$1(exclusiveMaximum)} })` })
+		};
+	}
+});
+/**
 * Validates that a number is a safe integer (within the safe integer range
 * that can be exactly represented in JavaScript).
 *
@@ -7937,8 +7853,7 @@ var isLessThanOrEqualTo = /*#__PURE__*/ makeIsLessThanOrEqualTo({
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies an `integer: true`
-* constraint to ensure generated numbers are integers.
+* During arbitrary generation, this applies an integer constraint.
 *
 * @category validation
 * @since 4.0.0
@@ -7952,11 +7867,18 @@ function isInt(annotations) {
 		},
 		toJsonSchema: () => ({ type: "integer" }),
 		toCode: () => ({ runtime: "Schema.isInt()" }),
-		arbitrary: { constraint: { integer: true } },
+		arbitraryConstraint: { number: "integer" },
 		...annotations
 	});
 }
 /**
+* Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
+*
+* @category schemas
+* @since 3.10.0
+*/
+var Int = /*#__PURE__*/ Number$1.check(/*#__PURE__*/ isInt());
+/**
 * Schema for non-negative safe integers, including zero.
 *
 * **When to use**
@@ -7968,7 +7890,7 @@ function isInt(annotations) {
 * @category schemas
 * @since 4.0.0
 */
-var Natural = /*#__PURE__*/ (/* @__PURE__ */ Number$1.check(/*#__PURE__*/ isInt())).check(/*#__PURE__*/ isGreaterThanOrEqualTo(0));
+var Natural = /*#__PURE__*/ Int.check(/*#__PURE__*/ isGreaterThanOrEqualTo(0));
 /**
 * Validates that a value has at least the specified length. Works with strings
 * and arrays.
@@ -7977,12 +7899,13 @@ var Natural = /*#__PURE__*/ (/* @__PURE__ */ Number$1.check(/*#__PURE__*/ isInt(
 *
 * JSON Schema:
 *
-* This check corresponds to the `minLength` constraint for strings or the
-* `minItems` constraint for arrays in JSON Schema.
+* For arrays, this check corresponds to `minItems`. For strings, it corresponds
+* to `minLength`. JavaScript counts UTF-16 code units while JSON Schema counts
+* Unicode code points, so the two validations can differ for some strings.
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `minLength`
+* During arbitrary generation, this applies a `minLength`
 * constraint to ensure generated strings or arrays have at least the required
 * length.
 *
@@ -8011,7 +7934,7 @@ function isMinLength(minLength, annotations) {
 		toJsonSchema: ({ type }) => type === "array" ? { minItems: minLength } : { minLength },
 		toCode: () => ({ runtime: `Schema.isMinLength(${minLength})` }),
 		[STRUCTURAL_ANNOTATION_KEY]: true,
-		arbitrary: { constraint: { minLength } },
+		arbitraryConstraint: { minLength },
 		...annotations
 	});
 }
@@ -8028,7 +7951,7 @@ function isMinLength(minLength, annotations) {
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `minLength: 1`
+* During arbitrary generation, this applies a `minLength: 1`
 * constraint to ensure generated strings or arrays are non-empty.
 *
 * @category validation
@@ -8050,7 +7973,7 @@ function isNonEmpty(annotations) {
 *
 * Arbitrary:
 *
-* When generating test data with fast-check, this applies a `maxLength`
+* During arbitrary generation, this applies a `maxLength`
 * constraint to ensure generated strings or arrays have at most the required
 * length.
 *
@@ -8068,7 +7991,7 @@ function isMaxLength(maxLength, annotations) {
 		toJsonSchema: ({ type }) => type === "array" ? { maxItems: maxLength } : { maxLength },
 		toCode: () => ({ runtime: `Schema.isMaxLength(${maxLength})` }),
 		[STRUCTURAL_ANNOTATION_KEY]: true,
-		arbitrary: { constraint: { maxLength } },
+		arbitraryConstraint: { maxLength },
 		...annotations
 	});
 }
@@ -8142,35 +8065,6 @@ function Defect(options) {
 	defectSchemaCache[key] = schema;
 	return schema;
 }
-function withRecursion(fc, ctx, terminal, arbitrary) {
-	return {
-		arbitrary: terminal === void 0 || ctx.recursion === void 0 ? arbitrary : fc.oneof(ctx.recursion, terminal, arbitrary),
-		terminal
-	};
-}
-function arrayFromItems(fc, item, constraints, comparator) {
-	return comparator === void 0 ? fc.array(item, constraints) : fc.uniqueArray(item, {
-		...constraints,
-		comparator
-	});
-}
-function collectionArbitrary(fc, ctx, item, terminalItem, fromIterable, comparator) {
-	const constraint = ctx.constraint;
-	const constraints = constraint === void 0 || constraint.minLength === void 0 && constraint.maxLength === void 0 ? void 0 : {
-		...constraint.minLength !== void 0 ? { minLength: constraint.minLength } : {},
-		...constraint.maxLength !== void 0 ? { maxLength: constraint.maxLength } : {}
-	};
-	if (constraints?.minLength !== void 0 && constraints.maxLength !== void 0 && constraints.minLength > constraints.maxLength) throw new globalThis.Error("Unable to derive an arbitrary for size constraints");
-	const minLength = constraints?.minLength ?? 0;
-	const arrays = withRecursion(fc, ctx, minLength === 0 ? fc.constant([]) : terminalItem === void 0 ? void 0 : arrayFromItems(fc, terminalItem, {
-		...constraints,
-		maxLength: minLength
-	}, comparator), arrayFromItems(fc, item, constraints, comparator));
-	return {
-		arbitrary: arrays.arbitrary.map(fromIterable),
-		terminal: arrays.terminal?.map(fromIterable)
-	};
-}
 /**
 * Schema for readonly sets whose values conform to the provided element schema.
 *
@@ -8198,34 +8092,13 @@ function ReadonlySet(value) {
 		}),
 		expected: "ReadonlySet",
 		toCodec: ([value]) => link()(ArraySchema(value), transform({
-			decode: (e) => new globalThis.Set(e),
+			decode: (values) => new globalThis.Set(values),
 			encode: (set) => [...set.values()]
-		})),
-		toArbitrary: ([value]) => (fc, ctx) => collectionArbitrary(fc, ctx, value.arbitrary, value.terminal, (as) => new globalThis.Set(as), equals$1),
-		toEquivalence: ([value]) => makeCompareSet(value),
-		toFormatter: ([value]) => (t) => {
-			const size = t.size;
-			if (size === 0) return "ReadonlySet(0) {}";
-			return `ReadonlySet(${size}) { ${globalThis.Array.from(t.values()).sort().map((v) => `${value(v)}`).join(", ")} }`;
-		}
+		}))
 	}).ast, { value });
 }
 globalThis.RegExp;
 globalThis.URL;
-function dateArbitraryConstraints(ordered, base, toDate) {
-	const out = { ...base };
-	if (ordered?.minimum !== void 0) {
-		const minimum = toDate === void 0 ? ordered.minimum : toDate(ordered.minimum);
-		const nextMin = ordered.exclusiveMinimum ? new globalThis.Date(minimum.getTime() + 1) : minimum;
-		if (out.min === void 0 || nextMin.getTime() > out.min.getTime()) out.min = nextMin;
-	}
-	if (ordered?.maximum !== void 0) {
-		const maximum = toDate === void 0 ? ordered.maximum : toDate(ordered.maximum);
-		const nextMax = ordered.exclusiveMaximum ? new globalThis.Date(maximum.getTime() - 1) : maximum;
-		if (out.max === void 0 || nextMax.getTime() < out.max.getTime()) out.max = nextMax;
-	}
-	return out;
-}
 var JsonString = /*#__PURE__*/ String$1.annotate({
 	expected: "a string that will be decoded as JSON",
 	contentMediaType: "application/json"
@@ -8333,6 +8206,28 @@ var Trimmed = /*#__PURE__*/ String$1.check(/*#__PURE__*/ isTrimmed());
 */
 var Trim = /*#__PURE__*/ String$1.annotate({ expected: "a string that will be decoded as a trimmed string" }).pipe(/*#__PURE__*/ decodeTo(Trimmed, /*#__PURE__*/ trim()));
 globalThis.Uint8Array;
+var dateTimeUtcFromString = /*#__PURE__*/ transformEffect({
+	decode: (s, options) => {
+		return match$1(make$5(s), {
+			onNone: () => fail$2(new InvalidValue({ expected: "a valid UTC DateTime string" }, s, options)),
+			onSome: (result) => succeed$3(toUtc(result))
+		});
+	},
+	encode: (utc) => succeed$3(formatIso(utc))
+});
+var arbitraryMinimumDateTimestamp = -864e13;
+var arbitraryMaximumDateTimestamp = 864e13;
+function dateTimeArbitraryBounds(constraint, domainMinimum, domainMaximum) {
+	const minimum = Math.max(domainMinimum, constraint?.minimum === void 0 ? domainMinimum : constraint.minimum.epochMilliseconds + (constraint.exclusiveMinimum === true ? 1 : 0));
+	const maximum = Math.min(domainMaximum, constraint?.maximum === void 0 ? domainMaximum : constraint.maximum.epochMilliseconds - (constraint.exclusiveMaximum === true ? 1 : 0));
+	return minimum <= maximum ? [minimum, maximum] : [domainMinimum, domainMaximum];
+}
+function dateTimeArbitraryInteger(minimum, maximum) {
+	return Int.check(isBetween({
+		minimum,
+		maximum
+	}));
+}
 /**
 * Schema for `DateTime.Utc` values.
 *
@@ -8365,10 +8260,12 @@ var DateTimeUtc = /*#__PURE__*/ declare((u) => isDateTime(u) && isUtc(u), {
 		importDeclarations: [`import * as DateTime from "effect/DateTime"`]
 	}),
 	expected: "DateTime.Utc",
+	toCodecArbitrary: ({ constraint }) => {
+		const [minimum, maximum] = dateTimeArbitraryBounds(constraint, arbitraryMinimumDateTimestamp, arbitraryMaximumDateTimestamp);
+		return linkDecoding()(dateTimeArbitraryInteger(minimum, maximum), transform$1(makeUnsafe));
+	},
 	toCodecJson: () => link()(String$1, dateTimeUtcFromString),
-	toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint?.ordered?.order === Order ? ctx.constraint.ordered : void 0, { noInvalidDate: true }, toDateUtc)).map((date) => fromDateUnsafe(date)),
-	toFormatter: () => (utc) => utc.toString(),
-	toEquivalence: () => Equivalence
+	toFormatter: () => (utc) => utc.toString()
 });
 /**
 * Schema that decodes a date-time string into a `DateTime.Utc`.
@@ -8427,7 +8324,7 @@ function makeClass(Inherited, identifier, struct$1, annotations, proto) {
 			return getClassSchema(this).rebuild(ast);
 		}
 		static make(input, options) {
-			return new this(input, options);
+			return make$3(getClassSchema(this))(input ?? {}, options);
 		}
 		static makeOption(input, options) {
 			return makeOption(getClassSchema(this))(input ?? {}, options);
@@ -8487,10 +8384,7 @@ function getClassSchemaFactory(from, identifier, annotations) {
 				link: new Link(from, transformation)
 			}),
 			toCodec: ([from]) => new Link(from.ast, transformation),
-			toArbitrary: ([from]) => () => ({
-				arbitrary: from.arbitrary.map((args) => new self(args)),
-				terminal: from.terminal?.map((args) => new self(args))
-			}),
+			toEquivalence: ([from]) => from,
 			toFormatter: ([from]) => (t) => `${self.identifier}(${from(t)})`,
 			[SENTINELS_ANNOTATION_KEY]: collectSentinels(from.ast),
 			...annotations
@@ -8591,76 +8485,7 @@ var TaggedError = (identifier) => {
 * @category converting
 * @since 4.0.0
 */
-function toCodecJson(schema) {
-	return make(toCodecJsonAST(schema.ast), { schema });
-}
-/** @internal */
-var toCodecJsonAST = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempotent((ast) => {
-	const out = toCodecJsonASTStep(ast, toCodecJsonAST);
-	const context = ast.context;
-	if (out === ast || context === void 0) return out;
-	return replaceContextLastLink(out, withoutConstructorDefault(context));
-});
-function withoutConstructorDefault(context) {
-	return context.constructorDefault === void 0 ? context : new Context(context.isOptional, context.isMutable, void 0, context.annotations);
-}
-function validateCanonicalObjectPropertyNames(ast) {
-	if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) throw new globalThis.Error("Objects property names must be strings", { cause: ast });
-}
-function makeReorder(getPriority) {
-	return (types) => {
-		const indexMap = /* @__PURE__ */ new Map();
-		for (let i = 0; i < types.length; i++) indexMap.set(toEncoded(types[i]), i);
-		const sortedTypes = [...types].sort((a, b) => {
-			a = toEncoded(a);
-			b = toEncoded(b);
-			const pa = getPriority(a);
-			const pb = getPriority(b);
-			if (pa !== pb) return pa - pb;
-			return indexMap.get(a) - indexMap.get(b);
-		});
-		if (!sortedTypes.some((ast, index) => ast !== types[index])) return types;
-		return sortedTypes;
-	};
-}
-var toCodecJsonReorder = /*#__PURE__*/ makeReorder((ast) => {
-	switch (ast._tag) {
-		case "BigInt":
-		case "Symbol":
-		case "UniqueSymbol": return 0;
-		default: return 1;
-	}
-});
-function toCodecJsonASTStep(ast, recur) {
-	switch (ast._tag) {
-		case "Declaration": {
-			const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
-			if (!isFunction(getLink)) return replaceEncoding(ast, [unknownToJson]);
-			const link = getLink(ast.typeParameters.map((tp) => make$1(toEncoded(tp))));
-			return link === void 0 ? ast : replaceEncoding(ast, [mapLink(link, recur)]);
-		}
-		case "Unknown": return replaceEncoding(ast, [unknownToJson]);
-		case "ObjectKeyword": return replaceEncoding(ast, [objectKeywordToJson]);
-		case "Undefined":
-		case "Void":
-		case "Literal":
-		case "Number": return ast.toCodecJson();
-		case "UniqueSymbol":
-		case "Symbol":
-		case "BigInt": return ast.toCodecStringTree();
-		case "Objects":
-			validateCanonicalObjectPropertyNames(ast);
-			return ast.recur(recur, parameterFromString);
-		case "Union": {
-			const sortedTypes = toCodecJsonReorder(ast.types);
-			if (sortedTypes !== ast.types) return new Union$1(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
-			return ast.recur(recur);
-		}
-		case "Arrays":
-		case "Suspend": return ast.recur(recur);
-	}
-	return ast;
-}
+var toCodecJson = toCodecJson$1;
 /**
 * Schema that accepts and validates any immutable JSON-compatible value.
 *
@@ -8680,4 +8505,4 @@ var Json = /*#__PURE__*/ make(/*#__PURE__*/ annotate(Json$1, { toCode: () => ({
 	Type: "Schema.Json"
 }) }));
 //#endregion
-export { isInt as $, UndefinedOr as A, nowUnsafe as At, decodeSync as B, filter as Bt, String$1 as C, MissingKey as Ct, TemplateLiteral as D, formatLocal as Dt, TaggedError as E, formatIso as Et, declare as F, zoneMakeLocal as Ft, decodeUnknownSync as G, decodeUnknownEffect as H, map as Ht, decode as I, capitalize as It, fromJsonString as J, encodeEffect as K, decodeEffect as L, startsWith as Lt, Unknown as M, subtract as Mt, brand as N, toEpochMillis as Nt, Trim as O, isLessThanOrEqualTo$1 as Ot, catchDecoding as P, toParts as Pt, isGreaterThanOrEqualTo as Q, decodeOption as R, toLowerCase$2 as Rt, SchemaError as S, transformOrFail$1 as St, StructWithRest as T, distance as Tt, decodeUnknownOption as U, toEntries as Ut, decodeTo as V, makeEquivalence as Vt, decodeUnknownResult as W, union$1 as Wt, is as X, instanceOf as Y, isFinite as Z, Null as _, transformOptional as _t, DateTimeUtc as a, link as at, ReadonlySet as b, forbidden as bt, Error$1 as c, optionalKey as ct, Json as d, toCodecJson as dt, isLessThanOrEqualTo as et, Literal as f, toType as ft, NonEmptyString as g, transform as gt, NonEmptyArray as h, toLowerCase as ht, Boolean as i, isStringFinite as it, Union as j, setZone as jt, Tuple as k, now as kt, Finite as l, suspend as lt, Natural as m, decodeUnknownEffect$1 as mt, BigInt$1 as n, isMinLength as nt, DateTimeUtcFromString as o, makeFilter as ot, Literals as p, withConstructorDefault as pt, extendTo as q, BigIntFromString as r, isPattern as rt, Defect as s, optional as st, ArraySchema as t, isMaxLength as tt, FiniteFromString as u, tag as ut, NullOr as v, decodeUriComponent as vt, Struct as w, makeFormatterStandardSchemaV1 as wt, Record as x, transform$1 as xt, Number$1 as y, encodeUriComponent as yt, decodeResult as z, empty as zt };
+export { isInt as $, UndefinedOr as A, formatLocal as At, decodeSync as B, capitalize as Bt, String$1 as C, forbidden as Ct, TemplateLiteral as D, makeFormatterStandardSchemaV1 as Dt, TaggedError as E, MissingKey as Et, declare as F, setZone as Ft, decodeUnknownSync as G, makeEquivalence as Gt, decodeUnknownEffect as H, toLowerCase$2 as Ht, decode as I, subtract as It, fromJsonString as J, encodeEffect as K, toEntries as Kt, decodeEffect as L, toEpochMillis as Lt, Unknown as M, isLessThanOrEqualTo$1 as Mt, brand as N, now as Nt, Trim as O, distance as Ot, catchDecoding as P, nowUnsafe as Pt, isGreaterThanOrEqualTo as Q, decodeOption as R, toParts as Rt, SchemaError as S, encodeUriComponent as St, StructWithRest as T, transformEffect$1 as Tt, decodeUnknownOption as U, empty$1 as Ut, decodeTo as V, startsWith as Vt, decodeUnknownResult as W, filter as Wt, is as X, instanceOf as Y, isFinite as Z, Null as _, decodeUnknownEffect$1 as _t, DateTimeUtc as a, makeFilter as at, ReadonlySet as b, transformOptional as bt, Error$1 as c, suspend as ct, Json as d, toType as dt, isLessThanOrEqualTo as et, Literal as f, withConstructorDefault as ft, NonEmptyString as g, fromSetCookie as gt, Never as h, setAll as ht, Boolean as i, isStringFinite as it, Union as j, formatUtc as jt, Tuple as k, formatIso as kt, Finite as l, tag as lt, Natural as m, fromInput as mt, BigInt$1 as n, isMinLength as nt, DateTimeUtcFromString as o, optional as ot, Literals as p, empty as pt, extendTo as q, union$1 as qt, BigIntFromString as r, isPattern as rt, Defect as s, optionalKey as st, ArraySchema as t, isMaxLength as tt, FiniteFromString as u, toCodecJson as ut, NullOr as v, toLowerCase as vt, Struct as w, transform$1 as wt, Record as x, decodeUriComponent as xt, Number$1 as y, transform as yt, decodeResult as z, zoneMakeLocal as zt };