lalph 0.1.6 → 0.1.7

package/dist/cli.mjs

@@ -43,7 +43,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Pipeable.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Pipeable.js
 /**
 * @since 2.0.0
 */
@@ -96,7 +96,7 @@ const Class$3 = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Function.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Function.js
 /**
 * Tests if a value is a `function`.
 *
@@ -367,7 +367,7 @@ function memoize(f) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/equal.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/equal.js
 /** @internal */
 const getAllObjectKeys = (obj) => {
 	const keys$1 = new Set(Reflect.ownKeys(obj));
@@ -387,7 +387,7 @@ const getAllObjectKeys = (obj) => {
 const byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Predicate.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Predicate.js
 /**
 * @since 2.0.0
 */
@@ -793,7 +793,7 @@ const isRegExp$1 = (input) => input instanceof RegExp;
 * import * as N from "effect/Number"
 * import * as assert from "node:assert"
 *
-* const nonZero = Predicate.or(N.lessThan(0), N.greaterThan(0))
+* const nonZero = Predicate.or(N.isLessThan(0), N.isGreaterThan(0))
 *
 * assert.deepStrictEqual(nonZero(-1), true)
 * assert.deepStrictEqual(nonZero(0), false)
@@ -806,7 +806,7 @@ const isRegExp$1 = (input) => input instanceof RegExp;
 const or = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) || that(a));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Hash.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Hash.js
 /**
 * This module provides utilities for hashing values in TypeScript.
 *
@@ -859,7 +859,7 @@ const symbol$3 = "~effect/interfaces/Hash";
 */
 const hash = (self) => {
 	switch (typeof self) {
-		case "number": return number$3(self);
+		case "number": return number$2(self);
 		case "bigint": return string$2(self.toString(10));
 		case "boolean": return string$2(String(self));
 		case "symbol": return string$2(String(self));
@@ -875,7 +875,7 @@ const hash = (self) => {
 			const h = withVisitedTracking$1(self, () => {
 				if (isHash(self)) return self[symbol$3]();
 				else if (typeof self === "function") return random(self);
-				else if (Array.isArray(self)) return array$2(self);
+				else if (Array.isArray(self)) return array(self);
 				else if (self instanceof Map) return hashMap(self);
 				else if (self instanceof Set) return hashSet(self);
 				return structure(self);
@@ -911,7 +911,7 @@ const hash = (self) => {
 * @since 2.0.0
 */
 const random = (self) => {
-	if (!randomHashCache.has(self)) randomHashCache.set(self, number$3(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
+	if (!randomHashCache.has(self)) randomHashCache.set(self, number$2(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
 	return randomHashCache.get(self);
 };
 /**
@@ -1012,7 +1012,7 @@ const isHash = (u) => hasProperty(u, symbol$3);
 * @category hashing
 * @since 2.0.0
 */
-const number$3 = (n) => {
+const number$2 = (n) => {
 	if (n !== n) return string$2("NaN");
 	if (n === Infinity) return string$2("Infinity");
 	if (n === -Infinity) return string$2("-Infinity");
@@ -1141,7 +1141,7 @@ const iterableWith = (seed, f) => (iter) => {
 * @category hashing
 * @since 2.0.0
 */
-const array$2 = /* @__PURE__ */ iterableWith(6151, hash);
+const array = /* @__PURE__ */ iterableWith(6151, hash);
 const hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Map"), ([k, v]) => combine$1(hash(k), hash(v)));
 const hashSet = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Set"), hash);
 const randomHashCache = /* @__PURE__ */ new WeakMap();
@@ -1156,7 +1156,7 @@ function withVisitedTracking$1(obj, fn$2) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Equal.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Equal.js
 /**
 * The unique identifier used to identify objects that implement the `Equal` interface.
 *
@@ -1266,11 +1266,11 @@ function makeCompareMap(keyEquivalence, valueEquivalence) {
 }
 const compareMaps = /* @__PURE__ */ makeCompareMap(compareBoth, compareBoth);
 /** @internal */
-function makeCompareSet(equivalence$1) {
+function makeCompareSet(equivalence) {
 	return function compareSets$1(self, that) {
 		for (const selfValue of self) {
 			let found = false;
-			for (const thatValue of that) if (equivalence$1(selfValue, thatValue)) {
+			for (const thatValue of that) if (equivalence(selfValue, thatValue)) {
 				found = true;
 				break;
 			}
@@ -1315,7 +1315,7 @@ const isEqual = (u) => hasProperty(u, symbol$2);
 * ```ts
 * import { Array, Equal } from "effect"
 *
-* const eq = Equal.equivalence<number>()
+* const eq = Equal.asEquivalence<number>()
 * const result = Array.dedupeWith([1, 2, 2, 3, 1], eq)
 * console.log(result) // [1, 2, 3]
 * ```
@@ -1323,7 +1323,7 @@ const isEqual = (u) => hasProperty(u, symbol$2);
 * @category instances
 * @since 2.0.0
 */
-const equivalence = () => equals$1;
+const asEquivalence = () => equals$1;
 /**
 * Marks an object to use reference equality instead of structural equality, without creating a proxy.
 *
@@ -1358,7 +1358,7 @@ const byReferenceUnsafe = (obj) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Redactable.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Redactable.js
 /**
 * @since 4.0.0
 */
@@ -1453,7 +1453,7 @@ const emptyServiceMap$1 = {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Formatter.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Formatter.js
 /**
 * @since 4.0.0
 */
@@ -1618,7 +1618,7 @@ function formatJson(input, options) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Inspectable.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Inspectable.js
 /**
 * This module provides utilities for making values inspectable and debuggable in TypeScript.
 *
@@ -1822,32 +1822,76 @@ var Class$2 = class {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Order.js
-/**
-* This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
-* An order is defined by a relation `<=`, which obeys the following laws:
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Order.js
+/**
+* This module provides the `Order` type class for defining total orderings on types.
+* An `Order` is a comparison function that returns `-1` (less than), `0` (equal), or `1` (greater than).
+*
+* Mental model:
+* - An `Order<A>` is a pure function `(a: A, b: A) => Ordering` that compares two values
+* - The result `-1` means the first value is less than the second
+* - The result `0` means the values are equal according to this ordering
+* - The result `1` means the first value is greater than the second
+* - Orders must satisfy total ordering laws: totality (either `x <= y` or `y <= x`), antisymmetry (if `x <= y` and `y <= x` then `x == y`), and transitivity (if `x <= y` and `y <= z` then `x <= z`)
+* - Orders can be composed using {@link combine} and {@link combineAll} to create multi-criteria comparisons
+* - Orders can be transformed using {@link mapInput} to compare values by extracting a comparable property
+* - Built-in orders exist for common types: {@link Number}, {@link String}, {@link Boolean}, {@link BigInt}, {@link Date}
+*
+* Common tasks:
+* - Creating custom orders → {@link make}
+* - Using built-in orders → {@link Number}, {@link String}, {@link Boolean}, {@link BigInt}, {@link Date}
+* - Combining multiple orders → {@link combine}, {@link combineAll}
+* - Transforming orders → {@link mapInput}
+* - Comparing values → {@link isLessThan}, {@link isGreaterThan}, {@link isLessThanOrEqualTo}, {@link isGreaterThanOrEqualTo}
+* - Finding min/max → {@link min}, {@link max}
+* - Clamping values → {@link clamp}, {@link isBetween}
+* - Ordering collections → {@link Array}, {@link Tuple}, {@link Struct}
+*
+* Gotchas:
+* - `Order.Number` treats all `NaN` values as equal and less than any other number
+* - `Order.make` uses reference equality (`===`) as a shortcut: if `self === that`, it returns `0` without calling the comparison function
+* - `Order.Array` compares arrays element-by-element, then by length if all elements are equal; `Order.all` only compares elements up to the shorter array's length
+* - `Order.Tuple` requires a fixed-length tuple with matching order types; `Order.Array` works with variable-length arrays
+* - `Order.min` and `Order.max` return the first argument when values are equal
+*
+* Quickstart:
 *
-* - either `x <= y` or `y <= x` (totality)
-* - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
-* - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
+* **Example** (Basic Usage)
 *
-* The truth table for compare is defined as follows:
+* ```ts
+* import { Order } from "effect"
+*
+* const result = Order.Number(5, 10)
+* console.log(result) // -1 (5 is less than 10)
+*
+* const isLessThan = Order.isLessThan(Order.Number)(5, 10)
+* console.log(isLessThan) // true
+* ```
 *
-* | `x <= y` | `x >= y` | Ordering |                       |
-* | -------- | -------- | -------- | --------------------- |
-* | `true`   | `true`   | `0`      | corresponds to x == y |
-* | `true`   | `false`  | `< 0`    | corresponds to x < y  |
-* | `false`  | `true`   | `> 0`    | corresponds to x > y  |
+* See also:
+* - {@link Ordering} - The result type of comparisons
+* - {@link Reducer} - For combining orders in collections
 *
 * @since 2.0.0
 */
 /**
 * Creates a new `Order` instance from a comparison function.
 *
-* @example
+* When to use this:
+* - When creating a custom order for a type that doesn't have a built-in order
+* - When you need fine-grained control over comparison logic
+* - When implementing orders for complex types
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Uses reference equality (`===`) as a shortcut: if `self === that`, returns `0` without calling the comparison function
+* - The comparison function should return `-1`, `0`, or `1` based on the comparison result
+* - The returned order satisfies total ordering laws if the comparison function does
+*
+* **Example** (Creating an Order)
+*
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
 * const byAge = Order.make<{ name: string; age: number }>((self, that) => {
 *   if (self.age < that.age) return -1
@@ -1855,224 +1899,292 @@ var Class$2 = class {
 *   return 0
 * })
 *
-* assert.deepStrictEqual(
-*   byAge({ name: "Alice", age: 30 }, { name: "Bob", age: 25 }),
-*   1
-* )
-* assert.deepStrictEqual(
-*   byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 }),
-*   -1
-* )
+* console.log(byAge({ name: "Alice", age: 30 }, { name: "Bob", age: 25 })) // 1
+* console.log(byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 })) // -1
 * ```
 *
+* See also:
+* - {@link mapInput} - Transform an order by mapping the input type
+* - {@link combine} - Combine multiple orders
+*
 * @category constructors
 * @since 2.0.0
 */
-const make$50 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+function make$50(compare) {
+	return (self, that) => self === that ? 0 : compare(self, that);
+}
 /**
 * An `Order` instance for numbers that compares them numerically.
 *
-* - `0` is considered equal to `-0`.
-* - all `NaN` values are considered equal and less than any other value.
+* When to use this:
+* - When comparing numbers for sorting or searching
+* - As a base for creating orders on types containing numbers
+* - When implementing numeric comparisons in data structures
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - `0` is considered equal to `-0`
+* - All `NaN` values are considered equal to each other
+* - Any `NaN` is considered less than any non-NaN number
+* - Uses standard numeric comparison for all other values
+*
+* **Example** (Number Ordering)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Order.number(1, 1), 0)
-* assert.deepStrictEqual(Order.number(1, 2), -1)
-* assert.deepStrictEqual(Order.number(2, 1), 1)
+* console.log(Order.Number(1, 1)) // 0
+* console.log(Order.Number(1, 2)) // -1
+* console.log(Order.Number(2, 1)) // 1
 *
-* assert.deepStrictEqual(Order.number(0, -0), 0)
-* assert.deepStrictEqual(Order.number(NaN, 1), -1)
+* console.log(Order.Number(0, -0)) // 0
+* console.log(Order.Number(NaN, 1)) // -1
 * ```
 *
+* See also:
+* - {@link mapInput} - Use this order to compare objects by a number property
+* - {@link BigInt} - For bigint comparisons
+*
 * @category instances
-* @since 2.0.0
+* @since 4.0.0
 */
-const number$2 = /* @__PURE__ */ make$50((self, that) => {
-	if (Number.isNaN(self) && Number.isNaN(that)) return 0;
-	if (Number.isNaN(self)) return -1;
-	if (Number.isNaN(that)) return 1;
+const Number$4 = /* @__PURE__ */ make$50((self, that) => {
+	if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
+	if (globalThis.Number.isNaN(self)) return -1;
+	if (globalThis.Number.isNaN(that)) return 1;
 	return self < that ? -1 : 1;
 });
 /**
 * An `Order` instance for bigints that compares them numerically.
 *
-* @example
+* When to use this:
+* - When comparing bigint values for sorting or searching
+* - As a base for creating orders on types containing bigints
+* - When working with large integers that exceed number precision
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Uses standard numeric comparison for bigint values
+* - Handles arbitrarily large integers
+*
+* **Example** (BigInt Ordering)
+*
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Order.bigint(1n, 2n), -1)
-* assert.deepStrictEqual(Order.bigint(2n, 1n), 1)
-* assert.deepStrictEqual(Order.bigint(1n, 1n), 0)
+* console.log(Order.BigInt(1n, 2n)) // -1
+* console.log(Order.BigInt(2n, 1n)) // 1
+* console.log(Order.BigInt(1n, 1n)) // 0
 * ```
 *
+* See also:
+* - {@link Number} - For regular number comparisons
+* - {@link mapInput} - Use this order to compare objects by a bigint property
+*
 * @category instances
-* @since 2.0.0
+* @since 4.0.0
 */
-const bigint$1 = /* @__PURE__ */ make$50((self, that) => self < that ? -1 : 1);
+const BigInt$3 = /* @__PURE__ */ make$50((self, that) => self < that ? -1 : 1);
 /**
 * Transforms an `Order` on type `A` into an `Order` on type `B` by providing a function that
 * maps values of type `B` to values of type `A`.
 *
-* @example
+* When to use this:
+* - When you have an order for a property type and want to compare objects by that property
+* - When extracting a comparable value from a complex type
+* - When creating orders for types that contain comparable values
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Applies the mapping function to both values before comparison
+* - The mapping function should be pure and not have side effects
+* - Preserves the ordering properties of the original order
+*
+* **Example** (Mapping Input)
+*
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const byLength = Order.mapInput(Order.number, (s: string) => s.length)
+* const byLength = Order.mapInput(Order.Number, (s: string) => s.length)
 *
-* assert.deepStrictEqual(byLength("a", "bb"), -1)
-* assert.deepStrictEqual(byLength("bb", "a"), 1)
-* assert.deepStrictEqual(byLength("aa", "bb"), 0)
+* console.log(byLength("a", "bb")) // -1
+* console.log(byLength("bb", "a")) // 1
+* console.log(byLength("aa", "bb")) // 0
 * ```
 *
+* See also:
+* - {@link combine} - Combine mapped orders for multi-criteria comparison
+* - {@link Struct} - Create orders for structs with multiple fields
+*
 * @category mapping
 * @since 2.0.0
 */
 const mapInput = /* @__PURE__ */ dual(2, (self, f) => make$50((b1, b2) => self(f(b1), f(b2))));
 /**
-* An `Order` instance for `Date` objects that compares them chronologically.
+* An `Order` instance for `Date` objects that compares them chronologically by their timestamp.
+*
+* When to use this:
+* - When comparing dates for sorting or searching
+* - As a base for creating orders on types containing dates
+* - When implementing time-based comparisons
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Compares dates by their underlying timestamp (milliseconds since epoch)
+* - Earlier dates are less than later dates
+* - Invalid dates are compared as if they were valid (uses `getTime()` result)
+*
+* **Example** (Date Ordering)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
 * const date1 = new Date("2023-01-01")
 * const date2 = new Date("2023-01-02")
 *
-* assert.deepStrictEqual(Order.Date(date1, date2), -1)
-* assert.deepStrictEqual(Order.Date(date2, date1), 1)
-* assert.deepStrictEqual(Order.Date(date1, date1), 0)
+* console.log(Order.Date(date1, date2)) // -1
+* console.log(Order.Date(date2, date1)) // 1
+* console.log(Order.Date(date1, date1)) // 0
 * ```
 *
+* See also:
+* - {@link mapInput} - Use this order to compare objects by a date property
+*
 * @category instances
 * @since 2.0.0
 */
-const Date$2 = /* @__PURE__ */ mapInput(number$2, (date$2) => date$2.getTime());
+const Date$2 = /* @__PURE__ */ mapInput(Number$4, (date$2) => date$2.getTime());
 /**
-* Creates an `Order` for arrays by applying the provided collection of `Order` instances to corresponding elements.
-* The comparison stops at the first non-zero result or when either array is exhausted.
+* Creates an `Order` for a tuple type based on orders for each element.
+*
+* When to use this:
+* - When comparing tuples with different types for each position
+* - When you need type-safe tuple ordering
+* - When working with fixed-length heterogeneous collections
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Compares tuples element-by-element using the corresponding order
+* - Stops at the first non-zero comparison result
+* - Requires tuples to have the same length as the order collection
+* - Returns `0` if all elements are equal
+*
+* **Example** (Tuple Ordering)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const arrayOrder = Order.all([Order.number, Order.number])
+* const tupleOrder = Order.Tuple([Order.Number, Order.String])
 *
-* assert.deepStrictEqual(arrayOrder([1, 10], [2, 20]), -1)
-* assert.deepStrictEqual(arrayOrder([1, 20], [1, 10]), 1)
-* assert.deepStrictEqual(arrayOrder([1, 10], [1, 10]), 0)
+* console.log(tupleOrder([1, "a"], [2, "b"])) // -1
+* console.log(tupleOrder([1, "b"], [1, "a"])) // 1
+* console.log(tupleOrder([1, "a"], [1, "a"])) // 0
 * ```
 *
-* @category combining
-* @since 2.0.0
+* See also:
+* - {@link Array} - Compare arrays with length consideration
+*
+* @category combinators
+* @since 4.0.0
 */
-const all$2 = (collection) => {
-	return make$50((x, y) => {
-		const len = Math.min(x.length, y.length);
-		let collectionLength = 0;
-		for (const O of collection) {
-			if (collectionLength >= len) break;
-			const o = O(x[collectionLength], y[collectionLength]);
+function Tuple$2(elements) {
+	return make$50((self, that) => {
+		const len = elements.length;
+		for (let i = 0; i < len; i++) {
+			const o = elements[i](self[i], that[i]);
 			if (o !== 0) return o;
-			collectionLength++;
 		}
 		return 0;
 	});
-};
+}
 /**
-* Similar to `Promise.all` but operates on `Order`s.
+* Creates an `Order` for arrays by applying the given `Order` to each element, then comparing by length if all elements are equal.
 *
-* ```
-* [Order<A>, Order<B>, ...] -> Order<[A, B, ...]>
-* ```
+* When to use this:
+* - When comparing arrays of the same element type
+* - When you want shorter arrays to be considered less than longer arrays
+* - When sorting collections of arrays
 *
-* This function creates and returns a new `Order` for a tuple of values based on the given `Order`s for each element in the tuple.
-* The returned `Order` compares two tuples of the same type by applying the corresponding `Order` to each element in the tuple.
-* It is useful when you need to compare two tuples of the same type and you have a specific way of comparing each element
-* of the tuple.
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Compares arrays element-by-element using the provided order
+* - Stops at the first non-zero comparison result
+* - If all elements are equal, shorter arrays are less than longer arrays
+* - Returns `0` only if arrays have the same length and all elements are equal
+*
+* **Example** (Array Element Ordering)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const tupleOrder = Order.tuple([Order.number, Order.number])
+* const arrayOrder = Order.Array(Order.Number)
 *
-* assert.deepStrictEqual(tupleOrder([1, 10], [2, 20]), -1)
-* assert.deepStrictEqual(tupleOrder([1, 20], [1, 10]), 1)
-* assert.deepStrictEqual(tupleOrder([1, 10], [1, 10]), 0)
+* console.log(arrayOrder([1, 2], [1, 3])) // -1
+* console.log(arrayOrder([1, 2], [1, 2, 3])) // -1 (shorter array is less)
+* console.log(arrayOrder([1, 2, 3], [1, 2])) // 1 (longer array is greater)
+* console.log(arrayOrder([1, 2], [1, 2])) // 0
 * ```
 *
+* See also:
+* - {@link Tuple} - Type-safe tuple ordering
+*
 * @category combinators
-* @since 2.0.0
+* @since 4.0.0
 */
-const tuple$2 = (elements) => all$2(elements);
+function Array$4(O) {
+	return make$50((self, that) => {
+		const aLen = self.length;
+		const bLen = that.length;
+		const len = Math.min(aLen, bLen);
+		for (let i = 0; i < len; i++) {
+			const o = O(self[i], that[i]);
+			if (o !== 0) return o;
+		}
+		return Number$4(aLen, bLen);
+	});
+}
 /**
-* This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.
-* The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays.
-* If all elements are equal, the arrays are then compared based on their length.
-* It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.
+* Creates an `Order` for structs by applying the given `Order`s to each property in sequence.
 *
-* @example
-* ```ts
-* import { Order } from "effect"
-* import * as assert from "node:assert"
+* When to use this:
+* - When comparing objects with multiple properties
+* - When you need multi-field comparison for structs
+* - When creating orders for complex data types
 *
-* const arrayOrder = Order.array(Order.number)
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Compares structs field-by-field in the order of keys in the fields object
+* - Stops at the first non-zero comparison result
+* - Returns `0` only if all fields are equal
+* - Field order matters: earlier fields take precedence
 *
-* assert.deepStrictEqual(arrayOrder([1, 2], [1, 3]), -1)
-* assert.deepStrictEqual(arrayOrder([1, 2], [1, 2, 3]), -1) // shorter array is less
-* assert.deepStrictEqual(arrayOrder([1, 2, 3], [1, 2]), 1) // longer array is greater
-* assert.deepStrictEqual(arrayOrder([1, 2], [1, 2]), 0)
-* ```
+* **Example** (Struct Ordering)
 *
-* @category combinators
-* @since 2.0.0
-*/
-const array$1 = (O) => make$50((self, that) => {
-	const aLen = self.length;
-	const bLen = that.length;
-	const len = Math.min(aLen, bLen);
-	for (let i = 0; i < len; i++) {
-		const o = O(self[i], that[i]);
-		if (o !== 0) return o;
-	}
-	return number$2(aLen, bLen);
-});
-/**
-* This function creates and returns a new `Order` for a struct of values based on the given `Order`s
-* for each property in the struct.
-*
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const personOrder = Order.struct({
-*   name: Order.string,
-*   age: Order.number
+* const personOrder = Order.Struct({
+*   name: Order.String,
+*   age: Order.Number
 * })
 *
 * const person1 = { name: "Alice", age: 30 }
 * const person2 = { name: "Bob", age: 25 }
 * const person3 = { name: "Alice", age: 25 }
 *
-* assert.deepStrictEqual(personOrder(person1, person2), -1) // Alice < Bob
-* assert.deepStrictEqual(personOrder(person1, person3), 1) // same name, 30 > 25
-* assert.deepStrictEqual(personOrder(person1, person1), 0)
+* console.log(personOrder(person1, person2)) // -1 (Alice < Bob)
+* console.log(personOrder(person1, person3)) // 1 (same name, 30 > 25)
+* console.log(personOrder(person1, person1)) // 0
 * ```
 *
+* See also:
+* - {@link combine} - Combine orders manually
+* - {@link mapInput} - Extract and compare by a single property
+*
 * @category combinators
-* @since 2.0.0
+* @since 4.0.0
 */
-const struct$2 = (fields) => {
+function Struct$2(fields) {
 	const keys$1 = Object.keys(fields);
 	return make$50((self, that) => {
 		for (const key of keys$1) {
@@ -2081,165 +2193,289 @@ const struct$2 = (fields) => {
 		}
 		return 0;
 	});
-};
+}
 /**
-* Test whether one value is _strictly less than_ another.
+* Tests whether one value is strictly less than another according to the given order.
+*
+* When to use this:
+* - When you need a boolean predicate instead of an ordering result
+* - When checking if a value is less than another in conditional logic
+* - When implementing range checks or comparisons
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns `true` if the order returns `-1` (first value is less than second)
+* - Returns `false` for equal or greater values
+* - Supports curried and uncurried call styles
+*
+* **Example** (Less Than)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const lessThanNumber = Order.lessThan(Order.number)
+* const isLessThanNumber = Order.isLessThan(Order.Number)
 *
-* assert.deepStrictEqual(lessThanNumber(1, 2), true)
-* assert.deepStrictEqual(lessThanNumber(2, 1), false)
-* assert.deepStrictEqual(lessThanNumber(1, 1), false)
+* console.log(isLessThanNumber(1, 2)) // true
+* console.log(isLessThanNumber(2, 1)) // false
+* console.log(isLessThanNumber(1, 1)) // false
 * ```
 *
+* See also:
+* - {@link isLessThanOrEqualTo} - Non-strict less than or equal
+* - {@link isGreaterThan} - Strict greater than
+*
 * @category predicates
 * @since 2.0.0
 */
-const lessThan$2 = (O) => dual(2, (self, that) => O(self, that) === -1);
+const isLessThan$3 = (O) => dual(2, (self, that) => O(self, that) === -1);
 /**
-* Test whether one value is _strictly greater than_ another.
+* Tests whether one value is strictly greater than another according to the given order.
+*
+* When to use this:
+* - When you need a boolean predicate instead of an ordering result
+* - When checking if a value is greater than another in conditional logic
+* - When implementing range checks or comparisons
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns `true` if the order returns `1` (first value is greater than second)
+* - Returns `false` for equal or lesser values
+* - Supports curried and uncurried call styles
+*
+* **Example** (Greater Than)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const greaterThanNumber = Order.greaterThan(Order.number)
+* const isGreaterThanNumber = Order.isGreaterThan(Order.Number)
 *
-* assert.deepStrictEqual(greaterThanNumber(2, 1), true)
-* assert.deepStrictEqual(greaterThanNumber(1, 2), false)
-* assert.deepStrictEqual(greaterThanNumber(1, 1), false)
+* console.log(isGreaterThanNumber(2, 1)) // true
+* console.log(isGreaterThanNumber(1, 2)) // false
+* console.log(isGreaterThanNumber(1, 1)) // false
 * ```
 *
+* See also:
+* - {@link isGreaterThanOrEqualTo} - Non-strict greater than or equal
+* - {@link isLessThan} - Strict less than
+*
 * @category predicates
 * @since 2.0.0
 */
-const greaterThan$3 = (O) => dual(2, (self, that) => O(self, that) === 1);
+const isGreaterThan$4 = (O) => dual(2, (self, that) => O(self, that) === 1);
 /**
-* Test whether one value is _non-strictly less than_ another.
+* Tests whether one value is less than or equal to another according to the given order.
+*
+* When to use this:
+* - When you need a boolean predicate for non-strict comparison
+* - When checking if a value is within a range (inclusive lower bound)
+* - When implementing inclusive comparisons
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns `true` if the order returns `-1` or `0` (less than or equal)
+* - Returns `false` only if the order returns `1` (greater than)
+* - Supports curried and uncurried call styles
+*
+* **Example** (Less Than Or Equal)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const lessThanOrEqualToNumber = Order.lessThanOrEqualTo(Order.number)
+* const isLessThanOrEqualToNumber = Order.isLessThanOrEqualTo(Order.Number)
 *
-* assert.deepStrictEqual(lessThanOrEqualToNumber(1, 2), true)
-* assert.deepStrictEqual(lessThanOrEqualToNumber(1, 1), true)
-* assert.deepStrictEqual(lessThanOrEqualToNumber(2, 1), false)
+* console.log(isLessThanOrEqualToNumber(1, 2)) // true
+* console.log(isLessThanOrEqualToNumber(1, 1)) // true
+* console.log(isLessThanOrEqualToNumber(2, 1)) // false
 * ```
 *
+* See also:
+* - {@link isLessThan} - Strict less than
+* - {@link isGreaterThan} - Strict greater than
+*
 * @category predicates
 * @since 2.0.0
 */
-const lessThanOrEqualTo$2 = (O) => dual(2, (self, that) => O(self, that) !== 1);
+const isLessThanOrEqualTo$3 = (O) => dual(2, (self, that) => O(self, that) !== 1);
 /**
-* Test whether one value is _non-strictly greater than_ another.
+* Tests whether one value is greater than or equal to another according to the given order.
+*
+* When to use this:
+* - When you need a boolean predicate for non-strict comparison
+* - When checking if a value is within a range (inclusive upper bound)
+* - When implementing inclusive comparisons
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns `true` if the order returns `1` or `0` (greater than or equal)
+* - Returns `false` only if the order returns `-1` (less than)
+* - Supports curried and uncurried call styles
+*
+* **Example** (Greater Than Or Equal)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const greaterThanOrEqualToNumber = Order.greaterThanOrEqualTo(Order.number)
+* const isGreaterThanOrEqualToNumber = Order.isGreaterThanOrEqualTo(Order.Number)
 *
-* assert.deepStrictEqual(greaterThanOrEqualToNumber(2, 1), true)
-* assert.deepStrictEqual(greaterThanOrEqualToNumber(1, 1), true)
-* assert.deepStrictEqual(greaterThanOrEqualToNumber(1, 2), false)
+* console.log(isGreaterThanOrEqualToNumber(2, 1)) // true
+* console.log(isGreaterThanOrEqualToNumber(1, 1)) // true
+* console.log(isGreaterThanOrEqualToNumber(1, 2)) // false
 * ```
 *
+* See also:
+* - {@link isGreaterThan} - Strict greater than
+* - {@link isLessThanOrEqualTo} - Less than or equal
+*
 * @category predicates
 * @since 2.0.0
 */
-const greaterThanOrEqualTo$2 = (O) => dual(2, (self, that) => O(self, that) !== -1);
+const isGreaterThanOrEqualTo$3 = (O) => dual(2, (self, that) => O(self, that) !== -1);
 /**
-* Take the minimum of two values. If they are considered equal, the first argument is chosen.
+* Returns the minimum of two values according to the given order. If they are equal, returns the first argument.
+*
+* When to use this:
+* - When you need to find the smaller of two values
+* - When implementing min/max operations
+* - When selecting values based on ordering
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns the value that compares as less than or equal to the other
+* - If values are equal, returns the first argument
+* - Supports curried and uncurried call styles
+*
+* **Example** (Minimum Value)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const minNumber = Order.min(Order.number)
+* const minNumber = Order.min(Order.Number)
 *
-* assert.deepStrictEqual(minNumber(1, 2), 1)
-* assert.deepStrictEqual(minNumber(2, 1), 1)
-* assert.deepStrictEqual(minNumber(1, 1), 1)
+* console.log(minNumber(1, 2)) // 1
+* console.log(minNumber(2, 1)) // 1
+* console.log(minNumber(1, 1)) // 1
 * ```
 *
+* See also:
+* - {@link max} - Maximum of two values
+* - {@link clamp} - Clamp a value between min and max
+*
 * @category comparisons
 * @since 2.0.0
 */
 const min$2 = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
 /**
-* Take the maximum of two values. If they are considered equal, the first argument is chosen.
+* Returns the maximum of two values according to the given order. If they are equal, returns the first argument.
+*
+* When to use this:
+* - When you need to find the larger of two values
+* - When implementing min/max operations
+* - When selecting values based on ordering
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns the value that compares as greater than or equal to the other
+* - If values are equal, returns the first argument
+* - Supports curried and uncurried call styles
+*
+* **Example** (Maximum Value)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const maxNumber = Order.max(Order.number)
+* const maxNumber = Order.max(Order.Number)
 *
-* assert.deepStrictEqual(maxNumber(1, 2), 2)
-* assert.deepStrictEqual(maxNumber(2, 1), 2)
-* assert.deepStrictEqual(maxNumber(1, 1), 1)
+* console.log(maxNumber(1, 2)) // 2
+* console.log(maxNumber(2, 1)) // 2
+* console.log(maxNumber(1, 1)) // 1
 * ```
 *
+* See also:
+* - {@link min} - Minimum of two values
+* - {@link clamp} - Clamp a value between min and max
+*
 * @category comparisons
 * @since 2.0.0
 */
 const max$2 = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
 /**
-* Clamp a value between a minimum and a maximum.
+* Clamps a value between a minimum and a maximum according to the given order.
+*
+* When to use this:
+* - When you need to restrict a value to a specific range
+* - When implementing bounds checking and normalization
+* - When ensuring values stay within valid ranges
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns the value if it's between minimum and maximum (inclusive)
+* - Returns minimum if the value is less than minimum
+* - Returns maximum if the value is greater than maximum
+* - Supports curried and uncurried call styles
+* - Requires that minimum <= maximum according to the order
+*
+* **Example** (Clamping Values)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as N from "effect/Number"
-* import * as assert from "node:assert"
 *
-* const clamp = Order.clamp(N.Order)({ minimum: 1, maximum: 5 })
+* const clamp = Order.clamp(Order.Number)({ minimum: 1, maximum: 5 })
 *
-* assert.equal(clamp(3), 3)
-* assert.equal(clamp(0), 1)
-* assert.equal(clamp(6), 5)
+* console.log(clamp(3)) // 3
+* console.log(clamp(0)) // 1
+* console.log(clamp(6)) // 5
 * ```
 *
+* See also:
+* - {@link min} - Minimum of two values
+* - {@link max} - Maximum of two values
+* - {@link isBetween} - Check if a value is within a range
+*
 * @category comparisons
 * @since 2.0.0
 */
 const clamp$2 = (O) => dual(2, (self, options) => min$2(O)(options.maximum, max$2(O)(options.minimum, self)));
 /**
-* Test whether a value is between a minimum and a maximum (inclusive).
+* Tests whether a value is between a minimum and a maximum (inclusive) according to the given order.
+*
+* When to use this:
+* - When validating that a value is within a valid range
+* - When implementing range checks for bounds validation
+* - When filtering or selecting values within a range
+*
+* Behavior:
+* - Pure function: does not mutate inputs
+* - Returns `true` if the value is greater than or equal to minimum and less than or equal to maximum
+* - Returns `false` if the value is outside the range
+* - Supports curried and uncurried call styles
+* - Both bounds are inclusive
+*
+* **Example** (Checking Range)
 *
-* @example
 * ```ts
 * import { Order } from "effect"
-* import * as assert from "node:assert"
 *
-* const betweenNumber = Order.between(Order.number)
+* const betweenNumber = Order.isBetween(Order.Number)
 *
-* assert.deepStrictEqual(betweenNumber(5, { minimum: 1, maximum: 10 }), true)
-* assert.deepStrictEqual(betweenNumber(1, { minimum: 1, maximum: 10 }), true)
-* assert.deepStrictEqual(betweenNumber(10, { minimum: 1, maximum: 10 }), true)
-* assert.deepStrictEqual(betweenNumber(0, { minimum: 1, maximum: 10 }), false)
-* assert.deepStrictEqual(betweenNumber(11, { minimum: 1, maximum: 10 }), false)
+* console.log(betweenNumber(5, { minimum: 1, maximum: 10 })) // true
+* console.log(betweenNumber(1, { minimum: 1, maximum: 10 })) // true
+* console.log(betweenNumber(10, { minimum: 1, maximum: 10 })) // true
+* console.log(betweenNumber(0, { minimum: 1, maximum: 10 })) // false
+* console.log(betweenNumber(11, { minimum: 1, maximum: 10 })) // false
 * ```
 *
+* See also:
+* - {@link clamp} - Clamp a value to a range
+* - {@link isLessThanOrEqualTo} - Less than or equal check
+* - {@link isGreaterThanOrEqualTo} - Greater than or equal check
+*
 * @category predicates
-* @since 2.0.0
+* @since 4.0.0
 */
-const between$2 = (O) => dual(2, (self, options) => !lessThan$2(O)(self, options.minimum) && !greaterThan$3(O)(self, options.maximum));
+const isBetween$1 = (O) => dual(2, (self, options) => !isLessThan$3(O)(self, options.minimum) && !isGreaterThan$4(O)(self, options.maximum));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/UndefinedOr.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/UndefinedOr.js
 /**
 * @since 4.0.0
 */
@@ -2260,7 +2496,7 @@ const liftThrowable = (f) => (...a) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Duration.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Duration.js
 const TypeId$55 = "~effect/time/Duration";
 const bigint0$1 = /* @__PURE__ */ BigInt(0);
 const bigint1e3 = /* @__PURE__ */ BigInt(1e3);
@@ -2773,7 +3009,7 @@ const Equivalence$4 = (self, that) => matchPair(self, that, {
 const equals = /* @__PURE__ */ dual(2, (self, that) => Equivalence$4(self, that));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Utils.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Utils.js
 /**
 * @since 2.0.0
 */
@@ -2851,7 +3087,7 @@ const internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[Inte
 const genConstructor = function* () {}.constructor;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/core.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/core.js
 /** @internal */
 const EffectTypeId = `~effect/Effect`;
 /** @internal */
@@ -2964,7 +3200,7 @@ var CauseImpl = class {
 		return isCause$1(that) && this.failures.length === that.failures.length && this.failures.every((e, i) => equals$1(e, that.failures[i]));
 	}
 	[symbol$3]() {
-		return array$2(this.failures);
+		return array(this.failures);
 	}
 };
 const annotationsMap = /* @__PURE__ */ new WeakMap();
@@ -3220,18 +3456,26 @@ var NoSuchElementError$1 = class extends TaggedError$1("NoSuchElementError") {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Equivalence.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Equivalence.js
 /**
 * Creates a custom equivalence relation with an optimized reference equality check.
 *
-* The resulting equivalence first performs a reference equality check (`===`) for performance,
-* then falls back to the provided equivalence function if the values are not identical.
+* When to use this:
+* - When you need a custom equivalence that isn't just strict equality
+* - When creating equivalences for complex types with custom comparison logic
+* - When you want the performance benefit of reference equality optimization
+*
+* Behavior:
+* - Does not mutate inputs
+* - First checks reference equality (`===`) for performance; if values are identical, returns `true` without calling the function
+* - Falls back to the provided equivalence function if values are not the same reference
+* - The provided function must satisfy reflexive, symmetric, and transitive properties
+*
+* **Example** (Case-insensitive string equivalence)
 *
-* @example
 * ```ts
 * import { Equivalence } from "effect"
 *
-* // Case-insensitive string equivalence
 * const caseInsensitive = Equivalence.make<string>((a, b) =>
 *   a.toLowerCase() === b.toLowerCase()
 * )
@@ -3242,14 +3486,21 @@ var NoSuchElementError$1 = class extends TaggedError$1("NoSuchElementError") {
 * // Same reference optimization
 * const str = "test"
 * console.log(caseInsensitive(str, str)) // true (fast path)
+* ```
+*
+* **Example** (Numeric tolerance equivalence)
+*
+* ```ts
+* import { Equivalence } from "effect"
 *
-* // Numeric tolerance equivalence
 * const tolerance = Equivalence.make<number>((a, b) => Math.abs(a - b) < 0.0001)
 *
 * console.log(tolerance(1.0, 1.0001)) // false
 * console.log(tolerance(1.0, 1.00001)) // true
 * ```
 *
+* See also: {@link strictEqual}, {@link mapInput}
+*
 * @category constructors
 * @since 2.0.0
 */
@@ -3258,51 +3509,74 @@ const isStrictEquivalent = (x, y) => x === y;
 /**
 * Creates an equivalence relation that uses strict equality (`===`) to compare values.
 *
-* This is the most basic and fastest equivalence relation, suitable for primitive types
-* and when you only want to compare by reference equality.
+* When to use this:
+* - For primitive types (numbers, strings, booleans) where `===` is appropriate
+* - When you need reference equality for objects (same object instance)
+* - As a building block for more complex equivalences via {@link mapInput} or {@link combine}
+* - When performance is critical and you don't need structural equality
+*
+* Behavior:
+* - Does not mutate inputs
+* - Uses JavaScript's strict equality operator (`===`)
+* - For primitives: compares values directly
+* - For objects: compares by reference (same object instance)
+* - Note: `NaN !== NaN`, so `NaN` values are never considered equivalent
+*
+* **Example** (Primitive types)
 *
-* @example
 * ```ts
 * import { Equivalence } from "effect"
 *
-* const strictEq = Equivalence.strict<number>()
+* const strictEq = Equivalence.strictEqual<number>()
 *
 * console.log(strictEq(1, 1)) // true
 * console.log(strictEq(1, 2)) // false
 * console.log(strictEq(NaN, NaN)) // false (NaN !== NaN)
+* ```
+*
+* **Example** (Reference equality for objects)
+*
+* ```ts
+* import { Equivalence } from "effect"
 *
-* // Reference equality for objects
 * const obj = { value: 42 }
-* const strictObjEq = Equivalence.strict<typeof obj>()
+* const strictObjEq = Equivalence.strictEqual<typeof obj>()
 *
 * console.log(strictObjEq(obj, obj)) // true
 * console.log(strictObjEq(obj, { value: 42 })) // false (different references)
 * ```
 *
+* See also: {@link make}, {@link Equal} (for structural equality)
+*
 * @category constructors
-* @since 2.0.0
+* @since 4.0.0
 */
-const strict = () => isStrictEquivalent;
+const strictEqual = () => isStrictEquivalent;
 /**
 * Creates an equivalence for tuples with heterogeneous element types.
 *
-* Similar to `Promise.all` but operates on `Equivalence`s. Given a tuple of `Equivalence`s,
-* returns a new `Equivalence` that compares tuples by applying each `Equivalence` to the
-* corresponding element of the tuple.
+* When to use this:
+* - When comparing tuples with different types at each position
+* - When you need different equivalence logic for each tuple element
+* - When working with fixed-length tuples (not arrays)
+* - Prefer over `Array` when you have a known tuple structure with different types
 *
-* ```
-* [Equivalence<A>, Equivalence<B>, ...] -> Equivalence<[A, B, ...]>
-* ```
+* Behavior:
+* - Does not mutate inputs
+* - Requires tuples to have the same length; different lengths are never equivalent
+* - Applies each equivalence to the corresponding element position
+* - Returns `true` only if all elements are equivalent according to their respective equivalences
+* - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+*
+* **Example** (Homogeneous tuple equivalence)
 *
-* @example
 * ```ts
 * import { Equivalence } from "effect"
 *
-* // Create equivalence for string tuples
-* const stringTupleEq = Equivalence.tuple([
-*   Equivalence.strict<string>(),
-*   Equivalence.strict<string>(),
-*   Equivalence.strict<string>()
+* const stringTupleEq = Equivalence.Tuple([
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<string>()
 * ])
 *
 * const tuple1 = ["hello", "world", "test"] as const
@@ -3311,16 +3585,21 @@ const strict = () => isStrictEquivalent;
 *
 * console.log(stringTupleEq(tuple1, tuple2)) // true
 * console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
+* ```
+*
+* **Example** (Heterogeneous tuple with custom equivalences)
+*
+* ```ts
+* import { Equivalence } from "effect"
 *
-* // Custom equivalences for each position
 * const caseInsensitive = Equivalence.mapInput(
-*   Equivalence.strict<string>(),
+*   Equivalence.strictEqual<string>(),
 *   (s: string) => s.toLowerCase()
 * )
 *
-* const customTupleEq = Equivalence.tuple([
+* const customTupleEq = Equivalence.Tuple([
+*   caseInsensitive,
 *   caseInsensitive,
-*   caseInsensitive, // Case-insensitive string comparison
 *   caseInsensitive
 * ])
 *
@@ -3329,10 +3608,12 @@ const strict = () => isStrictEquivalent;
 * ) // true
 * ```
 *
+* See also: {@link Array}, {@link Struct}
+*
 * @category combinators
-* @since 2.0.0
+* @since 4.0.0
 */
-function tuple$1(elements) {
+function Tuple$1(elements) {
 	return make$48((self, that) => {
 		if (self.length !== that.length) return false;
 		for (let i = 0; i < self.length; i++) if (!elements[i](self[i], that[i])) return false;
@@ -3342,37 +3623,54 @@ function tuple$1(elements) {
 /**
 * Creates an equivalence for arrays where all elements are compared using the same equivalence.
 *
-* Two arrays are considered equivalent if they have the same length and all corresponding
-* elements are equivalent according to the provided element equivalence.
+* When to use this:
+* - When comparing arrays with homogeneous element types
+* - When all elements should use the same equivalence logic
+* - When working with variable-length arrays (not fixed tuples)
+* - Prefer over `Tuple` when you have arrays of the same type
+*
+* Behavior:
+* - Does not mutate inputs
+* - Requires arrays to have the same length; different lengths are never equivalent
+* - Compares elements positionally (index 0 with index 0, etc.)
+* - Returns `true` only if all corresponding elements are equivalent
+* - Empty arrays are considered equivalent
+* - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+*
+* **Example** (Number array equivalence)
 *
-* @example
 * ```ts
 * import { Equivalence } from "effect"
 *
-* const numberArrayEq = Equivalence.array(Equivalence.strict<number>())
+* const numberArrayEq = Equivalence.Array(Equivalence.strictEqual<number>())
 *
 * console.log(numberArrayEq([1, 2, 3], [1, 2, 3])) // true
 * console.log(numberArrayEq([1, 2, 3], [1, 2, 4])) // false
 * console.log(numberArrayEq([1, 2], [1, 2, 3])) // false (different length)
+* ```
+*
+* **Example** (Case-insensitive string array)
+*
+* ```ts
+* import { Equivalence } from "effect"
 *
-* // Case-insensitive string array
 * const caseInsensitive = Equivalence.mapInput(
-*   Equivalence.strict<string>(),
+*   Equivalence.strictEqual<string>(),
 *   (s: string) => s.toLowerCase()
 * )
-* const stringArrayEq = Equivalence.array(caseInsensitive)
+* const stringArrayEq = Equivalence.Array(caseInsensitive)
 *
 * console.log(stringArrayEq(["Hello", "World"], ["HELLO", "WORLD"])) // true
 * console.log(stringArrayEq(["Hello"], ["Hi"])) // false
-*
-* // Empty arrays
-* console.log(numberArrayEq([], [])) // true
+* console.log(stringArrayEq([], [])) // true (empty arrays)
 * ```
 *
+* See also: {@link Tuple}, {@link Record}
+*
 * @category combinators
-* @since 2.0.0
+* @since 4.0.0
 */
-function array(item) {
+function Array$3(item) {
 	return make$48((self, that) => {
 		if (self.length !== that.length) return false;
 		for (let i = 0; i < self.length; i++) if (!item(self[i], that[i])) return false;
@@ -3380,13 +3678,24 @@ function array(item) {
 	});
 }
 /**
-* Creates an equivalence for objects by comparing their properties using
-* provided equivalences.
+* Creates an equivalence for objects by comparing their properties using provided equivalences.
 *
-* Given a struct of `Equivalence`s, returns a new `Equivalence` that compares objects
-* by applying each `Equivalence` to the corresponding property of the object.
+* When to use this:
+* - When comparing objects with known, fixed property names
+* - When you need different equivalence logic for different properties
+* - When working with struct/interface types with specific fields
+* - Prefer over `Record` when you have a fixed set of known properties
+*
+* Behavior:
+* - Does not mutate inputs
+* - Compares only the properties specified in the struct definition
+* - Properties not in the struct are ignored
+* - Returns `true` only if all specified properties are equivalent according to their equivalences
+* - Supports both string and symbol keys (via `Reflect.ownKeys`)
+* - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+*
+* **Example** (Struct with different equivalences per field)
 *
-* @example
 * ```ts
 * import { Equivalence } from "effect"
 *
@@ -3397,14 +3706,14 @@ function array(item) {
 * }
 *
 * const caseInsensitive = Equivalence.mapInput(
-*   Equivalence.strict<string>(),
+*   Equivalence.strictEqual<string>(),
 *   (s: string) => s.toLowerCase()
 * )
 *
-* const personEq = Equivalence.struct({
-*   name: caseInsensitive, // Case-insensitive name comparison
-*   age: Equivalence.strict<number>(), // Exact age comparison
-*   email: caseInsensitive // Case-insensitive email comparison
+* const personEq = Equivalence.Struct({
+*   name: caseInsensitive,
+*   age: Equivalence.strictEqual<number>(),
+*   email: caseInsensitive
 * })
 *
 * const person1 = { name: "Alice", age: 30, email: "alice@example.com" }
@@ -3413,18 +3722,30 @@ function array(item) {
 *
 * console.log(personEq(person1, person2)) // true (case-insensitive match)
 * console.log(personEq(person1, person3)) // false (different age)
+* ```
+*
+* **Example** (Partial equivalence for specific fields)
+*
+* ```ts
+* import { Equivalence } from "effect"
 *
-* // Partial equivalence for specific fields
-* const nameAgeEq = Equivalence.struct({
-*   name: Equivalence.strict<string>(),
-*   age: Equivalence.strict<number>()
+* const nameAgeEq = Equivalence.Struct({
+*   name: Equivalence.strictEqual<string>(),
+*   age: Equivalence.strictEqual<number>()
 * })
+*
+* // Only compares name and age, ignores other properties
+* const obj1 = { name: "Alice", age: 30, extra: "ignored" }
+* const obj2 = { name: "Alice", age: 30, extra: "different" }
+* console.log(nameAgeEq(obj1, obj2)) // true
 * ```
 *
+* See also: {@link Record}, {@link mapInput}, {@link combine}
+*
 * @category combinators
-* @since 2.0.0
+* @since 4.0.0
 */
-function struct$1(fields) {
+function Struct$1(fields) {
 	const keys$1 = Reflect.ownKeys(fields);
 	return make$48((self, that) => {
 		for (const key of keys$1) if (!fields[key](self[key], that[key])) return false;
@@ -3433,7 +3754,7 @@ function struct$1(fields) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/option.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/option.js
 /**
 * @since 2.0.0
 */
@@ -3505,7 +3826,7 @@ const some$1 = (value) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/result.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/result.js
 const TypeId$53 = "~effect/data/Result";
 const CommonProto = {
 	[TypeId$53]: {
@@ -3587,7 +3908,7 @@ const getSuccess$3 = (self) => isFailure$5(self) ? none$4 : some$1(self.success)
 const fromOption$4 = /* @__PURE__ */ dual(2, (self, onNone) => isNone$1(self) ? fail$9(onNone()) : succeed$6(self.value));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Option.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Option.js
 /**
 * Represents the absence of a value by creating an empty `Option`.
 *
@@ -4145,7 +4466,7 @@ const filterMap = flatMap$3;
 const filter$3 = /* @__PURE__ */ dual(2, (self, predicate) => filterMap(self, (b) => predicate(b) ? some$1(b) : none$4));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Result.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Result.js
 /**
 * Constructs a new `Result` holding a `Success` value.
 *
@@ -4413,7 +4734,7 @@ const getOrThrow = /* @__PURE__ */ getOrThrowWith(identity);
 const succeedNone$2 = /* @__PURE__ */ succeed$5(none$4);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Filter.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Filter.js
 const FailTypeId = "~effect/data/Filter/fail";
 /**
 * @since 4.0.0
@@ -4662,7 +4983,7 @@ const toOption = (self) => (input) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/array.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/array.js
 /**
 * @since 2.0.0
 */
@@ -4670,7 +4991,7 @@ const toOption = (self) => (input) => {
 const isArrayNonEmpty$1 = (self) => self.length > 0;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Tuple.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Tuple.js
 /**
 * Creates an `Equivalence` for tuples by comparing corresponding elements using the provided `Equivalence`s.
 *
@@ -4679,16 +5000,16 @@ const isArrayNonEmpty$1 = (self) => self.length > 0;
 * import { Equivalence, Tuple } from "effect"
 *
 * // Creates an equivalence for tuples with string and number elements
-* const equivalence = Tuple.getEquivalence([
-*   Equivalence.strict<string>(),
-*   Equivalence.strict<number>()
+* const equivalence = Tuple.makeEquivalence([
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<number>()
 * ])
 * ```
 *
 * @category Equivalence
 * @since 2.0.0
 */
-const getEquivalence$3 = tuple$1;
+const makeEquivalence$3 = Tuple$1;
 /**
 * Creates an `Order` for tuples by comparing corresponding elements using the provided `Order`s.
 *
@@ -4699,16 +5020,16 @@ const getEquivalence$3 = tuple$1;
 * import * as S from "effect/String"
 *
 * // Creates an order for tuples with string and number elements
-* const tupleOrder = Tuple.getOrder([S.Order, N.Order])
+* const tupleOrder = Tuple.makeOrder([S.Order, N.Order])
 * ```
 *
 * @category Ordering
 * @since 2.0.0
 */
-const getOrder$2 = tuple$2;
+const makeOrder$2 = Tuple$2;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Iterable.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Iterable.js
 /**
 * Returns the first element that satisfies the specified
 * predicate, or `None` if no such element exists.
@@ -4796,7 +5117,7 @@ const constEmptyIterator = { next() {
 const empty$13 = () => constEmpty;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Record.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Record.js
 /**
 * Creates a new, empty record.
 *
@@ -4957,7 +5278,7 @@ const keys = (self) => Object.keys(self);
 * import { Equal, Record } from "effect"
 * import * as assert from "node:assert"
 *
-* const isSubrecord = Record.isSubrecordBy(Equal.equivalence<number>())
+* const isSubrecord = Record.isSubrecordBy(Equal.asEquivalence<number>())
 *
 * assert.deepStrictEqual(
 *   Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }),
@@ -4972,8 +5293,8 @@ const keys = (self) => Object.keys(self);
 * @category predicates
 * @since 2.0.0
 */
-const isSubrecordBy = (equivalence$1) => dual(2, (self, that) => {
-	for (const key of keys(self)) if (!has(that, key) || !equivalence$1(self[key], that[key])) return false;
+const isSubrecordBy = (equivalence) => dual(2, (self, that) => {
+	for (const key of keys(self)) if (!has(that, key) || !equivalence(self[key], that[key])) return false;
 	return true;
 });
 /**
@@ -4985,7 +5306,7 @@ const isSubrecordBy = (equivalence$1) => dual(2, (self, that) => {
 * import { Equal, Record } from "effect"
 * import * as assert from "node:assert"
 *
-* const recordEquivalence = Record.getEquivalence(Equal.equivalence<number>())
+* const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence<number>())
 *
 * assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }), true)
 * assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }), false)
@@ -4994,13 +5315,13 @@ const isSubrecordBy = (equivalence$1) => dual(2, (self, that) => {
 * @category instances
 * @since 2.0.0
 */
-const getEquivalence$2 = (equivalence$1) => {
-	const is$2 = isSubrecordBy(equivalence$1);
+const makeEquivalence$2 = (equivalence) => {
+	const is$2 = isSubrecordBy(equivalence);
 	return (self, that) => is$2(self, that) && is$2(that, self);
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Array.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Array.js
 /**
 * This module provides utility functions for working with arrays in TypeScript.
 *
@@ -5297,7 +5618,6 @@ const findFirst = findFirst$1;
 * @since 2.0.0
 */
 const reverse = (self) => Array$2.from(self).reverse();
-const _equivalence = /* @__PURE__ */ equivalence();
 /**
 * Calculates the union of two arrays using the provided equivalence relation.
 *
@@ -5337,7 +5657,7 @@ const unionWith = /* @__PURE__ */ dual(3, (self, that, isEquivalent) => {
 * @category elements
 * @since 2.0.0
 */
-const union$1 = /* @__PURE__ */ dual(2, (self, that) => unionWith(self, that, _equivalence));
+const union$1 = /* @__PURE__ */ dual(2, (self, that) => unionWith(self, that, asEquivalence()));
 /**
 * Creates an empty array.
 *
@@ -5393,14 +5713,14 @@ const map$8 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 * ```ts
 * import { Array, Order } from "effect"
 *
-* const arrayOrder = Array.getOrder(Order.number)
+* const arrayOrder = Array.makeOrder(Order.Number)
 * console.log(arrayOrder([1, 2], [1, 3])) // -1 (first is less than second)
 * ```
 *
 * @category instances
 * @since 2.0.0
 */
-const getOrder$1 = array$1;
+const makeOrder$1 = Array$4;
 /**
 * Creates an equivalence relation for arrays.
 *
@@ -5409,14 +5729,14 @@ const getOrder$1 = array$1;
 * ```ts
 * import { Array } from "effect"
 *
-* const eq = Array.getEquivalence<number>((a, b) => a === b)
+* const eq = Array.makeEquivalence<number>((a, b) => a === b)
 * console.log(eq([1, 2, 3], [1, 2, 3])) // true
 * ```
 *
 * @category instances
 * @since 2.0.0
 */
-const getEquivalence$1 = array;
+const makeEquivalence$1 = Array$3;
 /**
 * Remove duplicates from an `Iterable` using the provided `isEquivalent` function,
 * preserving the order of the first occurrence of each element.
@@ -5445,7 +5765,7 @@ const dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/ServiceMap.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/ServiceMap.js
 const ServiceTypeId = "~effect/ServiceMap/Service";
 /**
 * @example
@@ -5568,7 +5888,7 @@ const Proto$19 = {
 		return true;
 	},
 	[symbol$3]() {
-		return number$3(this.mapUnsafe.size);
+		return number$2(this.mapUnsafe.size);
 	}
 };
 /**
@@ -5923,7 +6243,7 @@ const mergeAll$1 = (...ctxs) => {
 const Reference = Service;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Scheduler.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Scheduler.js
 /**
 * @since 4.0.0
 * @category references
@@ -6129,7 +6449,7 @@ var MixedScheduler = class {
 const MaxOpsBeforeYield = /* @__PURE__ */ Reference("effect/Scheduler/MaxOpsBeforeYield", { defaultValue: () => 2048 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Tracer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Tracer.js
 /**
 * @since 2.0.0
 * @category tags
@@ -6338,7 +6658,7 @@ const randomHexString = /* @__PURE__ */ function() {
 }();
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/References.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/References.js
 /**
 * This module provides a collection of reference implementations for commonly used
 * Effect runtime configuration values. These references allow you to access and
@@ -6801,12 +7121,12 @@ const CurrentLogSpans = /* @__PURE__ */ Reference("effect/References/CurrentLogS
 const MinimumLogLevel = /* @__PURE__ */ Reference("effect/References/MinimumLogLevel", { defaultValue: () => "Info" });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/metric.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/metric.js
 /** @internal */
 const FiberRuntimeMetricsKey = "effect/observability/Metric/FiberRuntimeMetricsKey";
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/tracer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/tracer.js
 /** @internal */
 const addSpanStackTrace = (options) => {
 	if (options?.captureStackTrace === false) return options;
@@ -6837,11 +7157,11 @@ const makeStackCleaner = (line) => (stack) => {
 const spanCleaner = /* @__PURE__ */ makeStackCleaner(3);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/version.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/version.js
 const version = "dev";
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/effect.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/effect.js
 /** @internal */
 var Interrupt = class extends FailureBase {
 	fiberId;
@@ -7600,8 +7920,8 @@ const asVoid$2 = (self) => flatMap$2(self, (_) => exitVoid);
 /** @internal */
 const sandbox$1 = (self) => catchCause$2(self, fail$6);
 /** @internal */
-const raceAll$1 = (all$3, options) => withFiber$1((parent) => callback$2((resume) => {
-	const effects = fromIterable$2(all$3);
+const raceAll$1 = (all$2, options) => withFiber$1((parent) => callback$2((resume) => {
+	const effects = fromIterable$2(all$2);
 	const len = effects.length;
 	let doneCount = 0;
 	let done$2 = false;
@@ -7635,7 +7955,7 @@ const raceAll$1 = (all$3, options) => withFiber$1((parent) => callback$2((resume
 	return fiberInterruptAll(fibers);
 }));
 /** @internal */
-const raceAllFirst$1 = (all$3, options) => withFiber$1((parent) => callback$2((resume) => {
+const raceAllFirst$1 = (all$2, options) => withFiber$1((parent) => callback$2((resume) => {
 	let done$2 = false;
 	const fibers = /* @__PURE__ */ new Set();
 	const onExit$4 = (exit$2) => {
@@ -7643,7 +7963,7 @@ const raceAllFirst$1 = (all$3, options) => withFiber$1((parent) => callback$2((r
 		resume(fibers.size === 0 ? exit$2 : flatMap$2(uninterruptible$1(fiberInterruptAll(fibers)), () => exit$2));
 	};
 	let i = 0;
-	for (const effect$1 of all$3) {
+	for (const effect$1 of all$2) {
 		if (done$2) break;
 		const index = i++;
 		const fiber$2 = forkUnsafe$1(parent, effect$1, true, true, false);
@@ -8191,7 +8511,7 @@ const cachedInvalidateWithTTL$1 = /* @__PURE__ */ dual(2, (self, ttl) => sync$1(
 	})];
 }));
 /** @internal */
-const cachedWithTTL$1 = /* @__PURE__ */ dual(2, (self, timeToLive) => map$7(cachedInvalidateWithTTL$1(self, timeToLive), (tuple$3) => tuple$3[0]));
+const cachedWithTTL$1 = /* @__PURE__ */ dual(2, (self, timeToLive) => map$7(cachedInvalidateWithTTL$1(self, timeToLive), (tuple$1) => tuple$1[0]));
 /** @internal */
 const cached$1 = (self) => cachedWithTTL$1(self, infinity);
 /** @internal */
@@ -8861,9 +9181,9 @@ const logLevelToOrder = (level) => {
 	}
 };
 /** @internal */
-const LogLevelOrder = /* @__PURE__ */ mapInput(number$2, logLevelToOrder);
+const LogLevelOrder = /* @__PURE__ */ mapInput(Number$4, logLevelToOrder);
 /** @internal */
-const logLevelGreaterThan = /* @__PURE__ */ greaterThan$3(LogLevelOrder);
+const isLogLevelGreaterThan = /* @__PURE__ */ isGreaterThan$4(LogLevelOrder);
 /** @internal */
 const CurrentLoggers = /* @__PURE__ */ Reference("effect/Loggers/CurrentLoggers", { defaultValue: () => new Set([defaultLogger, tracerLogger]) });
 /** @internal */
@@ -8915,7 +9235,7 @@ const logWithLevel$1 = (level) => (...message) => {
 	if (cause === void 0) cause = causeEmpty;
 	return withFiber$1((fiber$2) => {
 		const logLevel = level ?? fiber$2.getRef(CurrentLogLevel);
-		if (logLevelGreaterThan(fiber$2.getRef(MinimumLogLevel), logLevel)) return void_$3;
+		if (isLogLevelGreaterThan(fiber$2.getRef(MinimumLogLevel), logLevel)) return void_$3;
 		const clock = fiber$2.getRef(ClockRef);
 		const loggers = fiber$2.getRef(CurrentLoggers);
 		if (loggers.size > 0) {
@@ -8991,7 +9311,7 @@ function interruptChildrenPatch() {
 const undefined_$2 = /* @__PURE__ */ succeed$4(void 0);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Exit.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Exit.js
 ExitTypeId;
 /**
 * Tests if a value is an `Exit`.
@@ -9365,7 +9685,7 @@ const getCause = exitGetCause;
 const getError = exitGetError;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Deferred.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Deferred.js
 const DeferredProto = {
 	["~effect/Deferred"]: {
 		_A: identity,
@@ -9585,7 +9905,7 @@ const doneUnsafe$1 = (self, effect$1) => {
 const into = /* @__PURE__ */ dual(2, (self, deferred) => uninterruptibleMask$1((restore) => flatMap$2(exit$1(restore(self)), (exit$2) => done$1(deferred, exit$2))));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Scope.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Scope.js
 /**
 * The `Scope` module provides functionality for managing resource lifecycles
 * and cleanup operations in a functional and composable manner.
@@ -9859,7 +10179,7 @@ const closeUnsafe = scopeCloseUnsafe;
 const use$1 = scopeUse;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Layer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Layer.js
 const TypeId$51 = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
 /**
@@ -10651,7 +10971,7 @@ const flatMap$1 = /* @__PURE__ */ dual(2, (self, f) => fromBuild((memoMap, scope
 const fresh = (self) => fromBuildUnsafe((_, scope$2) => self.build(makeMemoMapUnsafe(), scope$2));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/ExecutionPlan.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/ExecutionPlan.js
 /**
 * @since 3.16.0
 * @category Type IDs
@@ -10685,7 +11005,7 @@ const CurrentMetadata$1 = /* @__PURE__ */ Reference("effect/ExecutionPlan/Curren
 }) });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Data.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Data.js
 /**
 * Provides a constructor for a Case Class.
 *
@@ -10836,7 +11156,7 @@ const Error$2 = Error$3;
 const TaggedError = TaggedError$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Cause.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Cause.js
 /**
 * @since 2.0.0
 */
@@ -11371,7 +11691,7 @@ const failureAnnotations = failureAnnotations$1;
 const annotations = causeAnnotations;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Clock.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Clock.js
 /**
 * A reference to the current Clock service in the environment.
 *
@@ -11447,7 +11767,7 @@ const currentTimeMillis = currentTimeMillis$1;
 const currentTimeNanos = currentTimeNanos$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/dateTime.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
 const TypeId$48 = "~effect/time/DateTime";
 /** @internal */
@@ -11468,7 +11788,7 @@ const ProtoUtc = {
 	...Proto$17,
 	_tag: "Utc",
 	[symbol$3]() {
-		return number$3(this.epochMillis);
+		return number$2(this.epochMillis);
 	},
 	[symbol$2](that) {
 		return isDateTime$1(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis;
@@ -11481,7 +11801,7 @@ const ProtoZoned = {
 	...Proto$17,
 	_tag: "Zoned",
 	[symbol$3]() {
-		return combine$1(number$3(this.epochMillis))(hash(this.zone));
+		return combine$1(number$2(this.epochMillis))(hash(this.zone));
 	},
 	[symbol$2](that) {
 		return isDateTime$1(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis && equals$1(this.zone, that.zone);
@@ -11731,23 +12051,23 @@ const min$1 = /* @__PURE__ */ min$2(Order$2);
 /** @internal */
 const max$1 = /* @__PURE__ */ max$2(Order$2);
 /** @internal */
-const greaterThan$2 = /* @__PURE__ */ greaterThan$3(Order$2);
+const isGreaterThan$3 = /* @__PURE__ */ isGreaterThan$4(Order$2);
 /** @internal */
-const greaterThanOrEqualTo$1 = /* @__PURE__ */ greaterThanOrEqualTo$2(Order$2);
+const isGreaterThanOrEqualTo$2 = /* @__PURE__ */ isGreaterThanOrEqualTo$3(Order$2);
 /** @internal */
-const lessThan$1 = /* @__PURE__ */ lessThan$2(Order$2);
+const isLessThan$2 = /* @__PURE__ */ isLessThan$3(Order$2);
 /** @internal */
-const lessThanOrEqualTo$1 = /* @__PURE__ */ lessThanOrEqualTo$2(Order$2);
+const isLessThanOrEqualTo$2 = /* @__PURE__ */ isLessThanOrEqualTo$3(Order$2);
 /** @internal */
-const between$1 = /* @__PURE__ */ between$2(Order$2);
+const between$1 = /* @__PURE__ */ isBetween$1(Order$2);
 /** @internal */
-const isFuture$1 = (self) => map$7(now$1, lessThan$1(self));
+const isFuture$1 = (self) => map$7(now$1, isLessThan$2(self));
 /** @internal */
-const isFutureUnsafe$1 = (self) => lessThan$1(nowUnsafe$1(), self);
+const isFutureUnsafe$1 = (self) => isLessThan$2(nowUnsafe$1(), self);
 /** @internal */
-const isPast$1 = (self) => map$7(now$1, greaterThan$2(self));
+const isPast$1 = (self) => map$7(now$1, isGreaterThan$3(self));
 /** @internal */
-const isPastUnsafe$1 = (self) => greaterThan$2(nowUnsafe$1(), self);
+const isPastUnsafe$1 = (self) => isGreaterThan$3(nowUnsafe$1(), self);
 /** @internal */
 const toDateUtc$1 = (self) => new Date(self.epochMillis);
 /** @internal */
@@ -12058,7 +12378,7 @@ const formatIsoOffset$1 = (self) => {
 const formatIsoZoned$1 = (self) => self.zone._tag === "Offset" ? formatIsoOffset$1(self) : `${formatIsoOffset$1(self)}[${self.zone.id}]`;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Pull.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Pull.js
 /**
 * @since 4.0.0
 */
@@ -12271,7 +12591,7 @@ const matchEffect$1 = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffec
 }));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Schedule.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Schedule.js
 const TypeId$47 = "~effect/Schedule";
 /**
 * @since 4.0.0
@@ -12620,13 +12940,13 @@ const while_ = /* @__PURE__ */ dual(2, (self, predicate) => fromStep(map$7(toSte
 const forever$1 = /* @__PURE__ */ spaced(zero);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/layer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/layer.js
 const provideLayer = (self, layer$14) => scopedWith$1((scope$2) => flatMap$2(buildWithScope(layer$14, scope$2), (context) => provideServices$1(self, context)));
 /** @internal */
 const provide$1 = /* @__PURE__ */ dual(2, (self, source) => isServiceMap(source) ? provideServices$1(self, source) : provideLayer(self, Array.isArray(source) ? mergeAll(...source) : source));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schedule.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schedule.js
 /** @internal */
 const repeatOrElse$1 = /* @__PURE__ */ dual(3, (self, schedule, orElse) => flatMap$2(toStepWithMetadata(schedule), (step) => {
 	let meta = CurrentMetadata.defaultValue();
@@ -12681,7 +13001,7 @@ const buildFromOptions = (options) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/executionPlan.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/executionPlan.js
 /** @internal */
 const withExecutionPlan$1 = /* @__PURE__ */ dual(2, (self, plan) => suspend$3(() => {
 	let i = 0;
@@ -12740,7 +13060,7 @@ const scheduleFromStep = (step, first) => {
 const scheduleOnce = /* @__PURE__ */ recurs(1);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Request.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Request.js
 const TypeId$46 = "~effect/Request";
 const requestVariance = /* @__PURE__ */ byReferenceUnsafe({
 	_E: (_) => _,
@@ -12761,7 +13081,7 @@ const RequestPrototype = {
 const makeEntry = (options) => options;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/request.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/request.js
 /** @internal */
 const request$1 = /* @__PURE__ */ dual(2, (self, resolver) => {
 	const withResolver = (resolver$1) => callback$2((resume) => {
@@ -12861,7 +13181,7 @@ function runBatch(batch) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Effect.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Effect.js
 const TypeId$45 = EffectTypeId;
 /**
 * Tests if a value is an `Effect`.
@@ -18743,7 +19063,7 @@ const catchEager = catchEager$1;
 const fnUntracedEager = fnUntracedEager$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/DateTime.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/DateTime.js
 TypeId$48;
 TimeZoneTypeId;
 /**
@@ -19404,14 +19724,14 @@ const max = max$1;
 * const date1 = DateTime.makeUnsafe("2024-02-01")
 * const date2 = DateTime.makeUnsafe("2024-01-01")
 *
-* console.log(DateTime.greaterThan(date1, date2)) // true
-* console.log(DateTime.greaterThan(date2, date1)) // false
+* console.log(DateTime.isGreaterThan(date1, date2)) // true
+* console.log(DateTime.isGreaterThan(date2, date1)) // false
 * ```
 *
 * @category comparisons
 * @since 3.6.0
 */
-const greaterThan$1 = greaterThan$2;
+const isGreaterThan$2 = isGreaterThan$3;
 /**
 * Checks if the first `DateTime` is after or equal to the second `DateTime`.
 *
@@ -19423,15 +19743,15 @@ const greaterThan$1 = greaterThan$2;
 * const date2 = DateTime.makeUnsafe("2024-01-01")
 * const date3 = DateTime.makeUnsafe("2024-02-01")
 *
-* console.log(DateTime.greaterThanOrEqualTo(date1, date2)) // true
-* console.log(DateTime.greaterThanOrEqualTo(date3, date1)) // true
-* console.log(DateTime.greaterThanOrEqualTo(date1, date3)) // false
+* console.log(DateTime.isGreaterThanOrEqualTo(date1, date2)) // true
+* console.log(DateTime.isGreaterThanOrEqualTo(date3, date1)) // true
+* console.log(DateTime.isGreaterThanOrEqualTo(date1, date3)) // false
 * ```
 *
 * @category comparisons
 * @since 3.6.0
 */
-const greaterThanOrEqualTo = greaterThanOrEqualTo$1;
+const isGreaterThanOrEqualTo$1 = isGreaterThanOrEqualTo$2;
 /**
 * Checks if the first `DateTime` is before the second `DateTime`.
 *
@@ -19442,14 +19762,14 @@ const greaterThanOrEqualTo = greaterThanOrEqualTo$1;
 * const date1 = DateTime.makeUnsafe("2024-01-01")
 * const date2 = DateTime.makeUnsafe("2024-02-01")
 *
-* console.log(DateTime.lessThan(date1, date2)) // true
-* console.log(DateTime.lessThan(date2, date1)) // false
+* console.log(DateTime.isLessThan(date1, date2)) // true
+* console.log(DateTime.isLessThan(date2, date1)) // false
 * ```
 *
 * @category comparisons
 * @since 3.6.0
 */
-const lessThan = lessThan$1;
+const isLessThan$1 = isLessThan$2;
 /**
 * Checks if the first `DateTime` is before or equal to the second `DateTime`.
 *
@@ -19461,15 +19781,15 @@ const lessThan = lessThan$1;
 * const date2 = DateTime.makeUnsafe("2024-01-01")
 * const date3 = DateTime.makeUnsafe("2024-02-01")
 *
-* console.log(DateTime.lessThanOrEqualTo(date1, date2)) // true
-* console.log(DateTime.lessThanOrEqualTo(date1, date3)) // true
-* console.log(DateTime.lessThanOrEqualTo(date3, date1)) // false
+* console.log(DateTime.isLessThanOrEqualTo(date1, date2)) // true
+* console.log(DateTime.isLessThanOrEqualTo(date1, date3)) // true
+* console.log(DateTime.isLessThanOrEqualTo(date3, date1)) // false
 * ```
 *
 * @category comparisons
 * @since 3.6.0
 */
-const lessThanOrEqualTo = lessThanOrEqualTo$1;
+const isLessThanOrEqualTo$1 = isLessThanOrEqualTo$2;
 /**
 * Checks if a `DateTime` is between two other `DateTime` values (inclusive).
 *
@@ -20357,7 +20677,7 @@ const formatIsoZoned = formatIsoZoned$1;
 const layerCurrentZoneNamed = /* @__PURE__ */ effect(CurrentTimeZone)(zoneMakeNamedEffect$1);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/encoding/EncodingError.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/encoding/EncodingError.js
 /**
 * @since 4.0.0
 */
@@ -20374,7 +20694,7 @@ var EncodingError = class extends TaggedError("EncodingError") {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/encoding/Base64.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/encoding/Base64.js
 /**
 * This module provides encoding & decoding functionality for:
 *
@@ -20679,7 +20999,7 @@ const base64codes = [
 ];
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schema/annotations.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schema/annotations.js
 /** @internal */
 function resolve$2(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
@@ -20700,7 +21020,7 @@ const getExpected = /* @__PURE__ */ memoize((ast) => {
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/record.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/record.js
 /**
 * @since 4.0.0
 */
@@ -20717,7 +21037,7 @@ function set$3(self, key, value) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/RegExp.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/RegExp.js
 /**
 * This module provides utility functions for working with RegExp in TypeScript.
 *
@@ -20772,7 +21092,7 @@ const isRegExp = isRegExp$1;
 const escape = (string$3) => string$3.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/encoding/Base64Url.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/encoding/Base64Url.js
 /**
 * Encodes the given value into a base64 (URL) `string`.
 *
@@ -20795,7 +21115,7 @@ const encodeUint8Array = (data) => encode$1(data).replace(/=/g, "").replace(/\+/
 const encoder$1 = /* @__PURE__ */ new TextEncoder();
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SchemaIssue.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SchemaIssue.js
 const TypeId$44 = "~effect/SchemaIssue/Issue";
 /**
 * @since 4.0.0
@@ -21201,7 +21521,7 @@ function formatOption(actual) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SchemaGetter.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SchemaGetter.js
 /**
 * @since 4.0.0
 */
@@ -21377,7 +21697,7 @@ function collectBracketPathEntries(isLeaf) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SchemaTransformation.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SchemaTransformation.js
 /**
 * @since 4.0.0
 */
@@ -21489,7 +21809,7 @@ const uint8ArrayFromBase64String = /* @__PURE__ */ new Transformation(/* @__PURE
 const fromJsonString$1 = /* @__PURE__ */ new Transformation(/* @__PURE__ */ parseJson$1(), /* @__PURE__ */ stringifyJson());
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SchemaAST.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SchemaAST.js
 /**
 * @since 4.0.0
 */
@@ -22911,20 +23231,20 @@ const resolveTitle = resolveTitle$1;
 const resolveDescription = resolveDescription$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Struct.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Struct.js
 /**
 * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
 * by applying each `Equivalence` to the corresponding property of the struct.
 *
-* Alias of {@link Equivalence.struct}.
+* Alias of {@link Equivalence.Struct}.
 *
 * @example
 * ```ts
 * import { Equivalence, Struct } from "effect"
 *
-* const PersonEquivalence = Struct.getEquivalence({
-*   name: Equivalence.strict<string>(),
-*   age: Equivalence.strict<number>()
+* const PersonEquivalence = Struct.makeEquivalence({
+*   name: Equivalence.strictEqual<string>(),
+*   age: Equivalence.strictEqual<number>()
 * })
 *
 * console.log(
@@ -22941,11 +23261,11 @@ const resolveDescription = resolveDescription$1;
 * @category Equivalence
 * @since 2.0.0
 */
-const getEquivalence = struct$1;
+const makeEquivalence = Struct$1;
 /**
 * Creates an `Order` for a struct of values based on the given `Order`s for each property.
 *
-* Alias of {@link order.struct}.
+* Alias of {@link order.Struct}.
 *
 * @example
 * ```ts
@@ -22953,7 +23273,7 @@ const getEquivalence = struct$1;
 * import * as N from "effect/Number"
 * import * as S from "effect/String"
 *
-* const PersonOrder = Struct.getOrder({
+* const PersonOrder = Struct.makeOrder({
 *   name: S.Order,
 *   age: N.Order
 * })
@@ -22968,7 +23288,7 @@ const getEquivalence = struct$1;
 * @category Ordering
 * @since 2.0.0
 */
-const getOrder = struct$2;
+const makeOrder = Struct$2;
 /**
 * Creates a type-level function that can be used with struct mapping operations.
 *
@@ -22986,7 +23306,7 @@ const getOrder = struct$2;
 const lambda = (f) => f;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SchemaParser.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SchemaParser.js
 /**
 * @since 4.0.0
 */
@@ -23224,14 +23544,14 @@ const recur = /* @__PURE__ */ memoize((ast) => {
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schema/json-pointer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schema/json-pointer.js
 /** @internal */
 function escapeToken(token) {
 	return token.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schema/schema.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schema/schema.js
 /** @internal */
 const TypeId$41 = "~effect/Schema/Schema";
 const SchemaProto = {
@@ -23260,7 +23580,7 @@ function make$39(ast, options) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schema/to-codec.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schema/to-codec.js
 /** @internal */
 const toCodecJson$1 = /* @__PURE__ */ toCodec((ast) => {
 	const out = toCodecJsonBase(ast);
@@ -23330,7 +23650,7 @@ function makeReorder(getPriority) {
 const unknownToNull = /* @__PURE__ */ new Link(null_, /* @__PURE__ */ new Transformation(/* @__PURE__ */ passthrough$1(), /* @__PURE__ */ transform$1(() => null)));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/schema/representation.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/schema/representation.js
 /** @internal */
 function fromAST(ast) {
 	const { references, representations: schemas } = fromASTs([ast]);
@@ -23938,12 +24258,12 @@ function getPartPattern(part) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/redacted.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/redacted.js
 /** @internal */
 const redactedRegistry = /* @__PURE__ */ new WeakMap();
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Redacted.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Redacted.js
 /**
 * The Redacted module provides functionality for handling sensitive information
 * securely within your application. By using the `Redacted` data type, you can
@@ -24008,7 +24328,7 @@ const Proto$16 = {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Schema.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Schema.js
 const TypeId$39 = TypeId$41;
 /**
 * An API for creating schemas for parametric types.
@@ -24671,10 +24991,10 @@ function isFinite$1(annotations$1) {
 * @since 4.0.0
 */
 function makeIsGreaterThan(options) {
-	const greaterThan$4 = greaterThan$3(options.order);
+	const gt = isGreaterThan$4(options.order);
 	const formatter = options.formatter ?? format$2;
 	return (exclusiveMinimum, annotations$1) => {
-		return makeFilter((input) => greaterThan$4(input, exclusiveMinimum), {
+		return makeFilter((input) => gt(input, exclusiveMinimum), {
 			expected: `a value greater than ${formatter(exclusiveMinimum)}`,
 			...options.annotate?.(exclusiveMinimum),
 			...annotations$1
@@ -24686,10 +25006,10 @@ function makeIsGreaterThan(options) {
 * @since 4.0.0
 */
 function makeIsGreaterThanOrEqualTo(options) {
-	const greaterThanOrEqualTo$3 = greaterThanOrEqualTo$2(options.order);
+	const gte = isGreaterThanOrEqualTo$3(options.order);
 	const formatter = options.formatter ?? format$2;
 	return (minimum, annotations$1) => {
-		return makeFilter((input) => greaterThanOrEqualTo$3(input, minimum), {
+		return makeFilter((input) => gte(input, minimum), {
 			expected: `a value greater than or equal to ${formatter(minimum)}`,
 			...options.annotate?.(minimum),
 			...annotations$1
@@ -24701,10 +25021,10 @@ function makeIsGreaterThanOrEqualTo(options) {
 * @since 4.0.0
 */
 function makeIsLessThan(options) {
-	const lessThan$3 = lessThan$2(options.order);
+	const lt = isLessThan$3(options.order);
 	const formatter = options.formatter ?? format$2;
 	return (exclusiveMaximum, annotations$1) => {
-		return makeFilter((input) => lessThan$3(input, exclusiveMaximum), {
+		return makeFilter((input) => lt(input, exclusiveMaximum), {
 			expected: `a value less than ${formatter(exclusiveMaximum)}`,
 			...options.annotate?.(exclusiveMaximum),
 			...annotations$1
@@ -24716,10 +25036,10 @@ function makeIsLessThan(options) {
 * @since 4.0.0
 */
 function makeIsLessThanOrEqualTo(options) {
-	const lessThanOrEqualTo$3 = lessThanOrEqualTo$2(options.order);
+	const lte = isLessThanOrEqualTo$3(options.order);
 	const formatter = options.formatter ?? format$2;
 	return (maximum, annotations$1) => {
-		return makeFilter((input) => lessThanOrEqualTo$3(input, maximum), {
+		return makeFilter((input) => lte(input, maximum), {
 			expected: `a value less than or equal to ${formatter(maximum)}`,
 			...options.annotate?.(maximum),
 			...annotations$1
@@ -24731,14 +25051,14 @@ function makeIsLessThanOrEqualTo(options) {
 * @since 4.0.0
 */
 function makeIsBetween(deriveOptions) {
-	const greaterThanOrEqualTo$3 = greaterThanOrEqualTo$2(deriveOptions.order);
-	const greaterThan$4 = greaterThan$3(deriveOptions.order);
-	const lessThanOrEqualTo$3 = lessThanOrEqualTo$2(deriveOptions.order);
-	const lessThan$3 = lessThan$2(deriveOptions.order);
+	const greaterThanOrEqualTo = isGreaterThanOrEqualTo$3(deriveOptions.order);
+	const greaterThan = isGreaterThan$4(deriveOptions.order);
+	const lessThanOrEqualTo = isLessThanOrEqualTo$3(deriveOptions.order);
+	const lessThan = isLessThan$3(deriveOptions.order);
 	const formatter = deriveOptions.formatter ?? format$2;
 	return (options, annotations$1) => {
-		const gte = options.exclusiveMinimum ? greaterThan$4 : greaterThanOrEqualTo$3;
-		const lte = options.exclusiveMaximum ? lessThan$3 : lessThanOrEqualTo$3;
+		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)" : ""}`,
 			...deriveOptions.annotate?.(options),
@@ -24762,8 +25082,8 @@ function makeIsBetween(deriveOptions) {
 * @category Number checks
 * @since 4.0.0
 */
-const isGreaterThan = /* @__PURE__ */ makeIsGreaterThan({
-	order: number$2,
+const isGreaterThan$1 = /* @__PURE__ */ makeIsGreaterThan({
+	order: Number$4,
 	annotate: (exclusiveMinimum) => ({
 		meta: {
 			_tag: "isGreaterThan",
@@ -24792,7 +25112,7 @@ const isGreaterThan = /* @__PURE__ */ makeIsGreaterThan({
 * @since 4.0.0
 */
 const isGreaterThanOrEqualTo = /* @__PURE__ */ makeIsGreaterThanOrEqualTo({
-	order: number$2,
+	order: Number$4,
 	annotate: (minimum) => ({
 		meta: {
 			_tag: "isGreaterThanOrEqualTo",
@@ -24818,7 +25138,7 @@ const isGreaterThanOrEqualTo = /* @__PURE__ */ makeIsGreaterThanOrEqualTo({
 * @since 4.0.0
 */
 const isLessThan = /* @__PURE__ */ makeIsLessThan({
-	order: number$2,
+	order: Number$4,
 	annotate: (exclusiveMaximum) => ({
 		meta: {
 			_tag: "isLessThan",
@@ -24847,7 +25167,7 @@ const isLessThan = /* @__PURE__ */ makeIsLessThan({
 * @since 4.0.0
 */
 const isLessThanOrEqualTo = /* @__PURE__ */ makeIsLessThanOrEqualTo({
-	order: number$2,
+	order: Number$4,
 	annotate: (maximum) => ({
 		meta: {
 			_tag: "isLessThanOrEqualTo",
@@ -24875,7 +25195,7 @@ const isLessThanOrEqualTo = /* @__PURE__ */ makeIsLessThanOrEqualTo({
 * @since 4.0.0
 */
 const isBetween = /* @__PURE__ */ makeIsBetween({
-	order: number$2,
+	order: Number$4,
 	annotate: (options) => {
 		return {
 			meta: {
@@ -25089,7 +25409,7 @@ const isBetweenDate = /* @__PURE__ */ makeIsBetween({
 * @since 4.0.0
 */
 const isGreaterThanBigInt = /* @__PURE__ */ makeIsGreaterThan({
-	order: bigint$1,
+	order: BigInt$3,
 	annotate: (exclusiveMinimum) => ({
 		meta: {
 			_tag: "isGreaterThanBigInt",
@@ -25115,7 +25435,7 @@ const isGreaterThanBigInt = /* @__PURE__ */ makeIsGreaterThan({
 * @since 4.0.0
 */
 const isGreaterThanOrEqualToBigInt = /* @__PURE__ */ makeIsGreaterThanOrEqualTo({
-	order: bigint$1,
+	order: BigInt$3,
 	annotate: (minimum) => ({
 		meta: {
 			_tag: "isGreaterThanOrEqualToBigInt",
@@ -25137,7 +25457,7 @@ const isGreaterThanOrEqualToBigInt = /* @__PURE__ */ makeIsGreaterThanOrEqualTo(
 * @since 4.0.0
 */
 const isLessThanBigInt = /* @__PURE__ */ makeIsLessThan({
-	order: bigint$1,
+	order: BigInt$3,
 	annotate: (exclusiveMaximum) => ({
 		meta: {
 			_tag: "isLessThanBigInt",
@@ -25163,7 +25483,7 @@ const isLessThanBigInt = /* @__PURE__ */ makeIsLessThan({
 * @since 4.0.0
 */
 const isLessThanOrEqualToBigInt = /* @__PURE__ */ makeIsLessThanOrEqualTo({
-	order: bigint$1,
+	order: BigInt$3,
 	annotate: (maximum) => ({
 		meta: {
 			_tag: "isLessThanOrEqualToBigInt",
@@ -25186,7 +25506,7 @@ const isLessThanOrEqualToBigInt = /* @__PURE__ */ makeIsLessThanOrEqualTo({
 * @since 4.0.0
 */
 const isBetweenBigInt = /* @__PURE__ */ makeIsBetween({
-	order: bigint$1,
+	order: BigInt$3,
 	annotate: (options) => ({
 		meta: {
 			_tag: "isBetweenBigInt",
@@ -25745,14 +26065,14 @@ const DateTimeUtcFromMillis = /* @__PURE__ */ Number$1.pipe(/* @__PURE__ */ deco
 	encode: /* @__PURE__ */ transform$1(toEpochMillis)
 }));
 const immerable = /* @__PURE__ */ globalThis.Symbol.for("immer-draftable");
-function makeClass(Inherited, identifier$1, struct$3, annotations$1) {
-	const getClassSchema = getClassSchemaFactory(struct$3, identifier$1, annotations$1);
+function makeClass(Inherited, identifier$1, struct$1, annotations$1) {
+	const getClassSchema = getClassSchemaFactory(struct$1, identifier$1, annotations$1);
 	const ClassTypeId$1 = getClassTypeId(identifier$1);
 	return class extends Inherited {
 		constructor(...[input, options]) {
 			if (options?.disableValidation) super(input, options);
 			else {
-				const validated = struct$3.makeUnsafe(input, options);
+				const validated = struct$1.makeUnsafe(input, options);
 				super({
 					...input,
 					...validated
@@ -25771,7 +26091,7 @@ function makeClass(Inherited, identifier$1, struct$3, annotations$1) {
 		}
 		static [immerable] = true;
 		static identifier = identifier$1;
-		static fields = struct$3.fields;
+		static fields = struct$1.fields;
 		static get ast() {
 			return getClassSchema(this).ast;
 		}
@@ -25796,14 +26116,14 @@ function makeClass(Inherited, identifier$1, struct$3, annotations$1) {
 		static extend(identifier$2) {
 			return (newFields, annotations$2) => {
 				const fields = {
-					...struct$3.fields,
+					...struct$1.fields,
 					...newFields
 				};
-				return makeClass(this, identifier$2, makeStruct(struct(fields, struct$3.ast.checks, { identifier: identifier$2 }), fields), annotations$2);
+				return makeClass(this, identifier$2, makeStruct(struct(fields, struct$1.ast.checks, { identifier: identifier$2 }), fields), annotations$2);
 			};
 		}
 		static mapFields(f, options) {
-			return struct$3.mapFields(f, options);
+			return struct$1.mapFields(f, options);
 		}
 	};
 }
@@ -25841,16 +26161,16 @@ function isStruct(schema) {
 * @since 4.0.0
 */
 const Class = (identifier$1) => (schema, annotations$1) => {
-	const struct$3 = isStruct(schema) ? schema : Struct(schema);
-	return makeClass(Class$1, identifier$1, struct$3, annotations$1);
+	const struct$1 = isStruct(schema) ? schema : Struct(schema);
+	return makeClass(Class$1, identifier$1, struct$1, annotations$1);
 };
 /**
 * @category Constructors
 * @since 4.0.0
 */
 const ErrorClass = (identifier$1) => (schema, annotations$1) => {
-	const struct$3 = isStruct(schema) ? schema : Struct(schema);
-	return makeClass(Error$3, identifier$1, struct$3, annotations$1);
+	const struct$1 = isStruct(schema) ? schema : Struct(schema);
+	return makeClass(Error$3, identifier$1, struct$1, annotations$1);
 };
 /**
 * Returns a JSON Schema Document (draft-2020-12).
@@ -25961,7 +26281,7 @@ function onSerializerEnsureArray(ast) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/CliError.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/CliError.js
 /**
 * @since 4.0.0
 */
@@ -30286,14 +30606,14 @@ var require_compiler = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
 			}
 			return ctx;
 		}
-		function reduceArrayWithTypeChecking(array$3) {
+		function reduceArrayWithTypeChecking(array$1) {
 			var firstType = null;
-			for (var i = 0; i < array$3.length; i++) {
-				var node = array$3[i];
+			for (var i = 0; i < array$1.length; i++) {
+				var node = array$1[i];
 				if (firstType === null) firstType = node.type;
 				else if (node.type !== firstType) genError("Cannot add value of type " + node.type + " to array of type " + firstType + ".", node.line, node.column);
 			}
-			return array$3.map(reduceValueNode);
+			return array$1.map(reduceValueNode);
 		}
 		function quoteDottedString(str) {
 			if (str.indexOf(".") > -1) return "\"" + str + "\"";
@@ -34220,7 +34540,7 @@ var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) =>
 			]
 		};
 	}
-	function parseBlockScalarHeader({ offset, props }, strict$1, onError$2) {
+	function parseBlockScalarHeader({ offset, props }, strict, onError$2) {
 		/* istanbul ignore if should not happen */
 		if (props[0].type !== "block-scalar-header") {
 			onError$2(props[0], "IMPOSSIBLE", "Block scalar header not found");
@@ -34252,7 +34572,7 @@ var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) =>
 					length += token.source.length;
 					break;
 				case "comment":
-					if (strict$1 && !hasSpace) onError$2(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+					if (strict && !hasSpace) onError$2(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
 					length += token.source.length;
 					comment = token.source.substring(1);
 					break;
@@ -34292,7 +34612,7 @@ var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) =>
 var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) => {
 	var Scalar = require_Scalar();
 	var resolveEnd = require_resolve_end();
-	function resolveFlowScalar(scalar, strict$1, onError$2) {
+	function resolveFlowScalar(scalar, strict, onError$2) {
 		const { offset, type, source, end } = scalar;
 		let _type;
 		let value;
@@ -34324,7 +34644,7 @@ var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) =>
 				};
 		}
 		const valueEnd = offset + source.length;
-		const re = resolveEnd.resolveEnd(end, valueEnd, strict$1, onError$2);
+		const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError$2);
 		return {
 			value,
 			type: _type,
@@ -34917,7 +35237,7 @@ var require_cst_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) => {
 	var resolveFlowScalar = require_resolve_flow_scalar();
 	var errors = require_errors();
 	var stringifyString = require_stringifyString();
-	function resolveAsScalar(token, strict$1 = true, onError$2) {
+	function resolveAsScalar(token, strict = true, onError$2) {
 		if (token) {
 			const _onError = (pos, code, message) => {
 				const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
@@ -34927,8 +35247,8 @@ var require_cst_scalar = /* @__PURE__ */ __commonJSMin$1(((exports) => {
 			switch (token.type) {
 				case "scalar":
 				case "single-quoted-scalar":
-				case "double-quoted-scalar": return resolveFlowScalar.resolveFlowScalar(token, strict$1, _onError);
-				case "block-scalar": return resolveBlockScalar.resolveBlockScalar({ options: { strict: strict$1 } }, token, _onError);
+				case "double-quoted-scalar": return resolveFlowScalar.resolveFlowScalar(token, strict, _onError);
+				case "block-scalar": return resolveBlockScalar.resolveBlockScalar({ options: { strict } }, token, _onError);
 			}
 		}
 		return null;
@@ -36967,7 +37287,7 @@ var require_dist = /* @__PURE__ */ __commonJSMin$1(((exports) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Brand.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Brand.js
 /**
 * This function returns a `Constructor` that **does not apply any runtime
 * checks**, it just returns the provided value. It can be used to create
@@ -36989,7 +37309,7 @@ function nominal() {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/PlatformError.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/PlatformError.js
 /**
 * @since 4.0.0
 */
@@ -37032,7 +37352,7 @@ var SystemError = class extends TaggedError("PlatformError") {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Fiber.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Fiber.js
 `${version}`;
 const await_ = fiberAwait;
 /**
@@ -37240,7 +37560,7 @@ const getCurrent = getCurrentFiber;
 const runIn = fiberRunIn;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/MutableList.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/MutableList.js
 /**
 * @fileoverview
 * MutableList is an efficient, mutable linked list implementation optimized for high-throughput
@@ -37598,29 +37918,29 @@ const takeN = (self, n) => {
 	if (n <= 0 || !self.head) return [];
 	n = Math.min(n, self.length);
 	if (n === self.length && self.head?.offset === 0 && !self.head.next) {
-		const array$4 = self.head.array;
+		const array$2 = self.head.array;
 		clear(self);
-		return array$4;
+		return array$2;
 	}
-	const array$3 = new Array(n);
+	const array$1 = new Array(n);
 	let index = 0;
 	let chunk = self.head;
 	while (chunk) {
 		while (chunk.offset < chunk.array.length) {
-			array$3[index++] = chunk.array[chunk.offset];
+			array$1[index++] = chunk.array[chunk.offset];
 			if (chunk.mutable) chunk.array[chunk.offset] = void 0;
 			chunk.offset++;
 			if (index === n) {
 				self.head = chunk;
 				self.length -= n;
 				if (self.length === 0) clear(self);
-				return array$3;
+				return array$1;
 			}
 		}
 		chunk = chunk.next;
 	}
 	clear(self);
-	return array$3;
+	return array$1;
 };
 /**
 * Takes a single element from the beginning of the MutableList.
@@ -37682,7 +38002,7 @@ const take$1 = (self) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/MutableRef.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/MutableRef.js
 const TypeId$36 = "~effect/MutableRef";
 const MutableRefProto = {
 	[TypeId$36]: TypeId$36,
@@ -37725,7 +38045,7 @@ const make$35 = (value) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/PubSub.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/PubSub.js
 const TypeId$35 = "~effect/PubSub";
 const SubscriptionTypeId = "~effect/PubSub/Subscription";
 /**
@@ -38185,7 +38505,7 @@ const emptyReplayWindow = {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Queue.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Queue.js
 /**
 * This module provides utilities for working with asynchronous queues that support various backpressure strategies.
 *
@@ -38989,7 +39309,7 @@ const finalize = (self, exit$2) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Channel.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Channel.js
 const TypeId$33 = "~effect/Channel";
 const ChannelProto = {
 	[TypeId$33]: {
@@ -39626,7 +39946,7 @@ const runFold$1 = /* @__PURE__ */ dual(3, (self, initial, f) => suspend$2(() =>
 const toPullScoped = (self, scope$2) => toTransform(self)(haltVoid, scope$2);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/stream.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/stream.js
 const TypeId$32 = "~effect/Stream";
 const streamVariance = {
 	_R: identity,
@@ -39647,7 +39967,7 @@ const fromChannel$2 = (channel) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Sink.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Sink.js
 const TypeId$31 = "~effect/Sink";
 const endVoid = /* @__PURE__ */ succeed([void 0]);
 const sinkVariance = {
@@ -39853,7 +40173,7 @@ const forEachArray = (f) => fromTransform((upstream) => upstream.pipe(flatMap(f)
 const unwrap$1 = (effect$1) => fromChannel$1(unwrap$2(map$4(effect$1, toChannel$1)));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/MutableHashMap.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/MutableHashMap.js
 const TypeId$30 = "~effect/collections/MutableHashMap";
 const MutableHashMapProto = {
 	[TypeId$30]: TypeId$30,
@@ -40135,7 +40455,7 @@ const remove$2 = /* @__PURE__ */ dual(2, (self, key_) => {
 const size = (self) => self.backing.size;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/internal/rcRef.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/internal/rcRef.js
 const TypeId$29 = "~effect/RcRef";
 const stateEmpty = { _tag: "Empty" };
 const stateClosed = { _tag: "Closed" };
@@ -40234,7 +40554,7 @@ const invalidate$1 = (self_) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/RcRef.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/RcRef.js
 /**
 * Create an `RcRef` from an acquire `Effect`.
 *
@@ -40309,7 +40629,7 @@ const get$2 = get$3;
 const invalidate = invalidate$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Stream.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Stream.js
 /**
 * @since 2.0.0
 */
@@ -40971,7 +41291,7 @@ const toReadableStreamWith = /* @__PURE__ */ dual((args$1) => isStream(args$1[0]
 const toReadableStreamEffect = /* @__PURE__ */ dual((args$1) => isStream(args$1[0]), (self, options) => map$4(services(), (context) => toReadableStreamWith(self, context, options)));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/FileSystem.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/FileSystem.js
 /**
 * This module provides a comprehensive file system abstraction that supports both synchronous
 * and asynchronous file operations through Effect. It includes utilities for file I/O, directory
@@ -41194,7 +41514,7 @@ const FileDescriptor = /* @__PURE__ */ nominal();
 var WatchBackend = class extends Service()("effect/platform/FileSystem/WatchBackend") {};
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Path.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Path.js
 /**
 * @since 4.0.0
 */
@@ -41619,7 +41939,7 @@ const posixImpl = /* @__PURE__ */ Path$1.of({
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/ConfigProvider.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/ConfigProvider.js
 /**
 * @category Constructors
 * @since 4.0.0
@@ -41730,7 +42050,7 @@ function trieNodeAt(root$1, path) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/LogLevel.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/LogLevel.js
 /**
 * @since 2.0.0
 *
@@ -41773,12 +42093,12 @@ function trieNodeAt(root$1, path) {
 * import { LogLevel } from "effect"
 *
 * // Check if one level is more severe than another
-* console.log(LogLevel.greaterThan("Error", "Info")) // true
-* console.log(LogLevel.greaterThan("Debug", "Error")) // false
+* console.log(LogLevel.isGreaterThan("Error", "Info")) // true
+* console.log(LogLevel.isGreaterThan("Debug", "Error")) // false
 *
 * // Check if level meets minimum threshold
-* console.log(LogLevel.greaterThanOrEqualTo("Info", "Debug")) // true
-* console.log(LogLevel.lessThan("Trace", "Info")) // true
+* console.log(LogLevel.isGreaterThanOrEqualTo("Info", "Debug")) // true
+* console.log(LogLevel.isLessThan("Trace", "Info")) // true
 * ```
 *
 * ## Filtering by Level
@@ -41788,14 +42108,14 @@ function trieNodeAt(root$1, path) {
 *
 * // Create a logger that only logs Error and above
 * const errorLogger = Logger.make((options) => {
-*   if (LogLevel.greaterThanOrEqualTo(options.logLevel, "Error")) {
+*   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Error")) {
 *     console.log(`[${options.logLevel}] ${options.message}`)
 *   }
 * })
 *
 * // Production logger - Info and above
 * const productionLogger = Logger.make((options) => {
-*   if (LogLevel.greaterThanOrEqualTo(options.logLevel, "Info")) {
+*   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Info")) {
 *     console.log(
 *       `${options.date.toISOString()} [${options.logLevel}] ${options.message}`
 *     )
@@ -41804,7 +42124,7 @@ function trieNodeAt(root$1, path) {
 *
 * // Development logger - Debug and above
 * const devLogger = Logger.make((options) => {
-*   if (LogLevel.greaterThanOrEqualTo(options.logLevel, "Debug")) {
+*   if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, "Debug")) {
 *     console.log(`[${options.logLevel}] ${options.message}`)
 *   }
 * })
@@ -41824,7 +42144,7 @@ function trieNodeAt(root$1, path) {
 *   const minLevel = yield* logLevelConfig
 *
 *   return Logger.make((options) => {
-*     if (LogLevel.greaterThanOrEqualTo(options.logLevel, minLevel)) {
+*     if (LogLevel.isGreaterThanOrEqualTo(options.logLevel, minLevel)) {
 *       console.log(`[${options.logLevel}] ${options.message}`)
 *     }
 *   })
@@ -41876,19 +42196,19 @@ const Order = LogLevelOrder;
 * import { LogLevel } from "effect"
 *
 * // Check if Error is more severe than Info
-* console.log(LogLevel.greaterThan("Error", "Info")) // true
-* console.log(LogLevel.greaterThan("Debug", "Error")) // false
+* console.log(LogLevel.isGreaterThan("Error", "Info")) // true
+* console.log(LogLevel.isGreaterThan("Debug", "Error")) // false
 *
 * // Use with filtering
-* const isFatal = LogLevel.greaterThan("Fatal", "Warn")
-* const isError = LogLevel.greaterThan("Error", "Warn")
-* const isDebug = LogLevel.greaterThan("Debug", "Warn")
+* const isFatal = LogLevel.isGreaterThan("Fatal", "Warn")
+* const isError = LogLevel.isGreaterThan("Error", "Warn")
+* const isDebug = LogLevel.isGreaterThan("Debug", "Warn")
 * console.log(isFatal) // true
 * console.log(isError) // true
 * console.log(isDebug) // false
 *
 * // Curried usage
-* const isMoreSevereThanInfo = LogLevel.greaterThan("Info")
+* const isMoreSevereThanInfo = LogLevel.isGreaterThan("Info")
 * console.log(isMoreSevereThanInfo("Error")) // true
 * console.log(isMoreSevereThanInfo("Debug")) // false
 * ```
@@ -41896,10 +42216,10 @@ const Order = LogLevelOrder;
 * @since 2.0.0
 * @category ordering
 */
-const greaterThan = logLevelGreaterThan;
+const isGreaterThan = isLogLevelGreaterThan;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Config.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Config.js
 const TypeId$25 = "~effect/Config";
 const Proto$14 = {
 	...PipeInspectableProto,
@@ -41975,7 +42295,7 @@ const Duration = /* @__PURE__ */ String$1.pipe(/* @__PURE__ */ decodeTo(Duration
 const LogLevel = /* @__PURE__ */ Literals(values);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/Primitive.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/Primitive.js
 var import_ini = /* @__PURE__ */ __toESM(require_ini(), 1);
 var import_toml = /* @__PURE__ */ __toESM(require_toml(), 1);
 var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
@@ -42202,7 +42522,7 @@ const getTypeName = (primitive) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/Param.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/Param.js
 /**
 * @internal
 *
@@ -42808,7 +43128,7 @@ const getParamMetadata = (param) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/CliOutput.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/CliOutput.js
 /**
 * Service reference for the CLI output formatter. Provides a default implementation
 * that can be overridden for custom formatting or testing.
@@ -43010,7 +43330,7 @@ const formatHelpDocImpl = (doc, colors$1) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Console.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Console.js
 /**
 * A reference to the current console service in the Effect system.
 *
@@ -43103,7 +43423,7 @@ const log = (...args$1) => consoleWith((console$1) => sync$1(() => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/config.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/config.js
 const ConfigInternalTypeId = "~effect/cli/Command/Config/Internal";
 /**
 * Parses a Command.Config into a ConfigInternal.
@@ -43173,7 +43493,7 @@ const reconstructTree = (tree, results) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/command.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/command.js
 /**
 * Command Implementation
 * ======================
@@ -43326,7 +43646,7 @@ const getHelpForCommandPath = (command, commandPath) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/bash.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/bash.js
 /**
 * Dynamic Bash completion template.
 * This generates a completion script that calls the CLI at runtime to get completions.
@@ -43383,7 +43703,7 @@ complete -F _${executableName}_dynamic_completions ${executableName}
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/fish.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/fish.js
 /**
 * Dynamic Fish completion template.
 * This generates a completion script that calls the CLI at runtime to get completions.
@@ -43443,7 +43763,7 @@ complete -c ${executableName} -f -a '(__${executableName}_complete)'
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/zsh.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/zsh.js
 /**
 * Dynamic Zsh completion template.
 * This generates a completion script that calls the CLI at runtime to get completions.
@@ -43565,7 +43885,7 @@ fi
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/core.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/core.js
 /**
 * Core dynamic completion functions.
 */
@@ -43595,7 +43915,7 @@ const isCompletionRequest = (args$1) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/shared.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/shared.js
 /** @internal */
 const getSingles = (flags) => flags.flatMap(extractSingleParams).filter((s) => s.kind === "flag").map((s) => {
 	const description = s.description;
@@ -43612,12 +43932,12 @@ const getSingles = (flags) => flags.flatMap(extractSingleParams).filter((s) => s
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/types.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/types.js
 /** @internal */
 const optionRequiresValue = (s) => s.primitiveTag !== "Boolean";
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/handler.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/completions/dynamic/handler.js
 /**
 * Runtime completion handler for dynamic completion.
 * This processes completion requests from the shell and returns appropriate suggestions.
@@ -43789,7 +44109,7 @@ const handleCompletionRequest = (rootCmd) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/lexer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/lexer.js
 /** @internal */
 function lex(argv) {
 	const endIndex = argv.indexOf("--");
@@ -43841,7 +44161,7 @@ const lexTokens = (args$1) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/auto-suggest.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/auto-suggest.js
 /**
 * Simple Levenshtein distance implementation (small N, no perf worries)
 */
@@ -43870,7 +44190,7 @@ const suggest = (input, candidates) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/Flag.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/Flag.js
 /**
 * Creates a boolean flag that can be enabled or disabled.
 *
@@ -44063,7 +44383,7 @@ const withDefault = /* @__PURE__ */ dual(2, (self, defaultValue) => withDefault$
 const map = /* @__PURE__ */ dual(2, (self, f) => map$1(self, f));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/builtInFlags.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/builtInFlags.js
 /**
 * Built-in options that are automatically available for CLI commands.
 * @since 4.0.0
@@ -44117,7 +44437,7 @@ const completionsFlag = /* @__PURE__ */ choice("completions", [
 ]).pipe(optional, /* @__PURE__ */ map((v) => map$10(v, (s) => s === "sh" ? "bash" : s)), /* @__PURE__ */ withDescription$1("Print shell completion script for the given shell"));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/parser.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/parser.js
 /**
 * Parsing Pipeline for CLI Commands
 * ==================================
@@ -44428,7 +44748,7 @@ const scanCommandLevel = (tokens, context) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Terminal.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Terminal.js
 const TypeId$22 = "~effect/platform/Terminal";
 const QuitErrorTypeId = "effect/platform/Terminal/QuitError";
 /**
@@ -44438,7 +44758,7 @@ const QuitErrorTypeId = "effect/platform/Terminal/QuitError";
 * @since 4.0.0
 * @category QuitError
 */
-var QuitError = class extends ErrorClass("QuitError")({ tag: /* @__PURE__ */ tag("QuitError") }) {
+var QuitError = class extends ErrorClass("QuitError")({ _tag: /* @__PURE__ */ tag("QuitError") }) {
 	/**
 	* @since 4.0.0
 	*/
@@ -44461,7 +44781,7 @@ const make$27 = (impl) => Terminal.of({
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/internal/ansi.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/internal/ansi.js
 const ESC = "\x1B[";
 const BEL = "\x07";
 const SEP = ";";
@@ -44539,7 +44859,7 @@ const eraseLines = (rows) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/Prompt.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/Prompt.js
 /**
 * @since 4.0.0
 */
@@ -44809,7 +45129,7 @@ const entriesToDisplay = (cursor, total, maxVisible) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/cli/Command.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/cli/Command.js
 /**
 * @since 4.0.0
 */
@@ -45109,7 +45429,7 @@ const runWith = (command, config) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Cache.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Cache.js
 /**
 * @since 4.0.0
 */
@@ -45480,7 +45800,7 @@ const set$1 = /* @__PURE__ */ dual(3, (self, key, value) => withFiber$1((fiber$2
 }));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/FiberSet.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/FiberSet.js
 /**
 * @since 2.0.0
 */
@@ -45664,7 +45984,7 @@ const runtime = (self) => () => map$4(services(), (services$2) => {
 const join = (self) => _await(self.deferred);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Ref.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Ref.js
 const RefProto = {
 	["~effect/Ref"]: { _A: identity },
 	...PipeInspectableProto,
@@ -45706,7 +46026,7 @@ const makeUnsafe = (value) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
 /**
 * @since 4.0.0
 */
@@ -45850,7 +46170,7 @@ const toSchemaStore = (self, schema) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/Runtime.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/Runtime.js
 /**
 * This module provides utilities for running Effect programs and managing their execution lifecycle.
 *
@@ -45986,7 +46306,7 @@ const makeRunMain = (f) => dual((args$1) => isEffect(args$1[0]), (effect$1, opti
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/SubscriptionRef.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/SubscriptionRef.js
 /**
 * @since 2.0.0
 */
@@ -47449,7 +47769,7 @@ var Mime_default$1 = Mime;
 var src_default = new Mime_default$1(standard_default, other_default)._freeze();
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/Mime.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/Mime.js
 /**
 * @since 1.0.0
 */
@@ -47460,7 +47780,7 @@ var src_default = new Mime_default$1(standard_default, other_default)._freeze();
 var Mime_default = src_default;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/process/ChildProcessSpawner.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/process/ChildProcessSpawner.js
 /**
 * A module providing a generic service interface for spawning child processes.
 *
@@ -47506,7 +47826,7 @@ const makeHandle = (params) => Object.assign(Object.create(HandleProto), params)
 const ChildProcessSpawner = /* @__PURE__ */ Service("effect/process/ChildProcessSpawner");
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/process/ChildProcess.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/process/ChildProcess.js
 const TypeId$16 = "~effect/unstable/process/ChildProcess";
 const Proto$7 = {
 	...PipeInspectableProto,
@@ -47643,7 +47963,7 @@ const parseFdName = (name) => {
 const fdName = (fd) => `fd${fd}`;
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/internal/process.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/internal/process.js
 /**
 * This is a derivative work copyright (c) 2025 Effectful Technologies Inc, under MIT license.
 *
@@ -47764,7 +48084,7 @@ const concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || pre
 ];
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/internal/utils.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/internal/utils.js
 /** @internal */
 const handleErrnoException = (module$1, method) => (err, [path]) => {
 	let reason = "Unknown";
@@ -47802,7 +48122,7 @@ const handleErrnoException = (module$1, method) => (err, [path]) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeSink.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeSink.js
 /**
 * @category constructors
 * @since 1.0.0
@@ -47841,7 +48161,7 @@ const pullIntoWritable = (options) => options.pull.pipe(flatMap((chunk) => {
 }) : identity);
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeStream.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeStream.js
 /**
 * @since 1.0.0
 */
@@ -47972,7 +48292,7 @@ const readableToPullUnsafe = (options) => {
 const defaultOnError = (error$1) => new UnknownError(error$1);
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
 const toError = (error$1) => error$1 instanceof globalThis.Error ? error$1 : new globalThis.Error(String(error$1));
 const toPlatformError = (method, error$1, command) => {
 	const { commands } = flattenCommand(command);
@@ -48171,14 +48491,14 @@ const make$20 = /* @__PURE__ */ gen(function* () {
 			});
 			if (isSink(stderrConfig.stream)) stderr = transduce(stderr, stderrConfig.stream);
 		}
-		const all$3 = fromReadable({
+		const all$2 = fromReadable({
 			evaluate: () => combinedPassThrough,
 			onError: (error$1) => toPlatformError("fromReadable(all)", toError(error$1), command)
 		});
 		return {
 			stdout,
 			stderr,
-			all: all$3
+			all: all$2
 		};
 	};
 	const spawn$1 = fnUntraced(function* (command, spawnOptions) {
@@ -48274,7 +48594,7 @@ const make$20 = /* @__PURE__ */ gen(function* () {
 				}));
 				const pid = ProcessId(childProcess.pid);
 				const stdin = yield* setupChildStdin(command, childProcess, stdinConfig);
-				const { all: all$3, stderr, stdout } = setupChildOutputStreams(command, childProcess, stdoutConfig, stderrConfig);
+				const { all: all$2, stderr, stdout } = setupChildOutputStreams(command, childProcess, stdoutConfig, stderrConfig);
 				const { getInputFd, getOutputFd } = yield* setupAdditionalFds(command, childProcess, resolvedAdditionalFds);
 				const isRunning = map$4(isDone$1(exitSignal), (done$2) => !done$2);
 				return makeHandle({
@@ -48292,7 +48612,7 @@ const make$20 = /* @__PURE__ */ gen(function* () {
 					stdin,
 					stdout,
 					stderr,
-					all: all$3,
+					all: all$2,
 					getInputFd,
 					getOutputFd
 				});
@@ -48388,7 +48708,7 @@ const flattenCommand = (command) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/Cookies.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/Cookies.js
 /**
 * @since 4.0.0
 */
@@ -48764,7 +49084,7 @@ const tryDecodeURIComponent = (str) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/Headers.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/Headers.js
 /**
 * @since 4.0.0
 */
@@ -48795,7 +49115,7 @@ const make$19 = (input) => Object.assign(Object.create(Proto$5), input);
 * @since 4.0.0
 * @category Equivalence
 */
-const Equivalence$1 = /* @__PURE__ */ getEquivalence$2(/* @__PURE__ */ strict());
+const Equivalence$1 = /* @__PURE__ */ makeEquivalence$2(/* @__PURE__ */ strictEqual());
 /**
 * @since 4.0.0
 * @category constructors
@@ -48885,7 +49205,7 @@ const CurrentRedactedNames = /* @__PURE__ */ Reference("effect/Headers/CurrentRe
 ] });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpClientError.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpClientError.js
 /**
 * @since 4.0.0
 */
@@ -48942,7 +49262,7 @@ var ResponseError$1 = class extends TaggedError("ResponseError") {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/UrlParams.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/UrlParams.js
 /**
 * @since 4.0.0
 */
@@ -48968,7 +49288,7 @@ const Proto$4 = {
 		return Equivalence(this, that);
 	},
 	[symbol$3]() {
-		return array$2(this.params.flat());
+		return array(this.params.flat());
 	}
 };
 /**
@@ -49009,7 +49329,7 @@ const fromInputNested = (input) => {
 * @category Equivalence
 */
 const Equivalence = /* @__PURE__ */ make$48((a, b) => arrayEquivalence(a.params, b.params));
-const arrayEquivalence = /* @__PURE__ */ getEquivalence$1(/* @__PURE__ */ getEquivalence$3([/* @__PURE__ */ strict(), /* @__PURE__ */ strict()]));
+const arrayEquivalence = /* @__PURE__ */ makeEquivalence$1(/* @__PURE__ */ makeEquivalence$3([/* @__PURE__ */ strictEqual(), /* @__PURE__ */ strictEqual()]));
 /**
 * @since 4.0.0
 * @category schemas
@@ -49155,7 +49475,7 @@ const schemaRecord = /* @__PURE__ */ UrlParamsSchema.pipe(/* @__PURE__ */ decode
 })));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpBody.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpBody.js
 /**
 * @since 4.0.0
 */
@@ -49303,7 +49623,7 @@ var Stream = class extends Proto$3 {
 const stream$2 = (body, contentType, contentLength) => new Stream(body, contentType ?? "application/octet-stream", contentLength);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpClientRequest.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpClientRequest.js
 const TypeId$10 = "~effect/http/HttpClientRequest";
 const Proto$2 = {
 	[TypeId$10]: TypeId$10,
@@ -49441,7 +49761,7 @@ const setBody = /* @__PURE__ */ dual(2, (self, body) => {
 const bodyUrlParams = /* @__PURE__ */ dual(2, (self, input) => setBody(self, urlParams(fromInput(input))));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpIncomingMessage.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpIncomingMessage.js
 /**
 * @since 4.0.0
 */
@@ -49485,7 +49805,7 @@ const inspect = (self, that) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpClientResponse.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpClientResponse.js
 /**
 * @since 4.0.0
 */
@@ -49617,7 +49937,7 @@ var WebHttpClientResponse = class extends Class$2 {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpMethod.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpMethod.js
 /**
 * @since 4.0.0
 */
@@ -49632,7 +49952,7 @@ const allShort = [
 ];
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpTraceContext.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpTraceContext.js
 /**
 * @since 4.0.0
 */
@@ -49701,7 +50021,7 @@ const w3c = (headers) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpClient.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpClient.js
 const TypeId$7 = "~effect/http/HttpClient";
 /**
 * @since 4.0.0
@@ -50531,7 +50851,7 @@ const httpMethods = [
 const make$14 = make$15;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/Template.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/Template.js
 /**
 * @since 4.0.0
 */
@@ -50581,7 +50901,7 @@ function isSuccess(u) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpServerResponse.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpServerResponse.js
 /**
 * @since 4.0.0
 */
@@ -50684,7 +51004,7 @@ const makeResponse = (options) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpServerRespondable.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpServerRespondable.js
 /**
 * @since 4.0.0
 */
@@ -50722,7 +51042,7 @@ const toResponseOrElseDefect = (u, orElse) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpServerError.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpServerError.js
 /**
 * @since 4.0.0
 */
@@ -50862,7 +51182,7 @@ const exitResponse = (exit$2) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/socket/Socket.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/socket/Socket.js
 /**
 * @since 4.0.0
 * @category Type IDs
@@ -51943,7 +52263,7 @@ const defaultIsFile = defaultIsFile$1;
 const decodeField = decodeField$1;
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/Multipart.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/Multipart.js
 /**
 * @since 4.0.0
 */
@@ -52220,7 +52540,7 @@ const MaxFileSize = /* @__PURE__ */ Reference("effect/http/Multipart/MaxFileSize
 const FieldMimeTypes = /* @__PURE__ */ Reference("effect/http/Multipart/FieldMimeTypes", { defaultValue: /* @__PURE__ */ constant(["application/json"]) });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpServerRequest.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpServerRequest.js
 /**
 * @since 4.0.0
 * @category Type IDs
@@ -52383,7 +52703,7 @@ const toURL = (self) => {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpMiddleware.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpMiddleware.js
 /**
 * @since 4.0.0
 */
@@ -52486,7 +52806,7 @@ const tracer = /* @__PURE__ */ make$8((httpApp) => withFiber((fiber$2) => {
 }));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpEffect.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpEffect.js
 /**
 * @since 4.0.0
 * @category combinators
@@ -52564,7 +52884,7 @@ const scoped = (effect$1) => withFiber((fiber$2) => {
 const PreResponseHandlers = /* @__PURE__ */ Reference("effect/http/HttpEffect/PreResponseHandlers", { defaultValue: () => void 0 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/Etag.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/Etag.js
 /**
 * @since 4.0.0
 */
@@ -52628,7 +52948,7 @@ const layerWeak = /* @__PURE__ */ succeed$1(Generator)({
 });
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpPlatform.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpPlatform.js
 /**
 * @since 4.0.0
 */
@@ -52695,7 +53015,7 @@ const layer$11 = /* @__PURE__ */ effect(HttpPlatform)(flatMap(FileSystem.asEffec
 }))).pipe(/* @__PURE__ */ provide$2(layerWeak));
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpServer.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpServer.js
 /**
 * @since 4.0.0
 */
@@ -52758,7 +53078,7 @@ const makeTestClient = /* @__PURE__ */ gen(function* () {
 const layerTestClient = /* @__PURE__ */ effect(HttpClient)(makeTestClient);
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/HttpRouter.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/HttpRouter.js
 /**
 * @since 4.0.0
 */
@@ -56628,7 +56948,7 @@ var import_websocket = /* @__PURE__ */ __toESM(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server(), 1);
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js
 /**
 * @since 1.0.0
 */
@@ -56978,7 +57298,7 @@ const makeFileSystem = /* @__PURE__ */ map$4(/* @__PURE__ */ serviceOption(Watch
 const layer$9 = /* @__PURE__ */ effect(FileSystem)(makeFileSystem);
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeFileSystem.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeFileSystem.js
 /**
 * @since 1.0.0
 */
@@ -56989,7 +57309,7 @@ const layer$9 = /* @__PURE__ */ effect(FileSystem)(makeFileSystem);
 const layer$8 = layer$9;
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
 /**
 * @since 1.0.0
 */
@@ -57060,7 +57380,7 @@ var NodeHttpIncomingMessage = class extends Class$2 {
 };
 
 //#endregion
-//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@bc26c98_39891726b671127654a83bc8bf76f2bd/node_modules/effect/dist/unstable/http/FetchHttpClient.js
+//#region node_modules/.pnpm/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@116f7c8_9b35cee4c324761fd30af9060c50d0d5/node_modules/effect/dist/unstable/http/FetchHttpClient.js
 /**
 * @since 4.0.0
 */
@@ -57108,7 +57428,7 @@ const fetch$1 = /* @__PURE__ */ make$16((request$2, url, signal, fiber$2) => {
 const layer$7 = /* @__PURE__ */ layerMergedServices(/* @__PURE__ */ succeed(fetch$1));
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeHttpPlatform.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeHttpPlatform.js
 /**
 * @since 1.0.0
 */
@@ -57232,7 +57552,7 @@ var FileStream = class extends Readable {
 };
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeMultipart.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeMultipart.js
 /**
 * @since 1.0.0
 */
@@ -57352,7 +57672,7 @@ function convertError(cause) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodePath.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodePath.js
 /**
 * @since 1.0.0
 */
@@ -57404,7 +57724,7 @@ const layer$5 = /* @__PURE__ */ succeed$1(Path$1)({
 });
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodePath.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodePath.js
 /**
 * @since 1.0.0
 */
@@ -57425,7 +57745,7 @@ const layerPosix = layerPosix$1;
 const layerWin32 = layerWin32$1;
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeTerminal.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeTerminal.js
 /**
 * @since 1.0.0
 */
@@ -57499,7 +57819,7 @@ function defaultShouldQuit(input) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeTerminal.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeTerminal.js
 /**
 * @since 1.0.0
 */
@@ -57515,7 +57835,7 @@ const make$1 = make$2;
 const layer$2 = layer$3;
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeServices.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeServices.js
 /**
 * @since 1.0.0
 * @category layer
@@ -57523,7 +57843,7 @@ const layer$2 = layer$3;
 const layer$1 = /* @__PURE__ */ provideMerge(layer$13, /* @__PURE__ */ mergeAll(layer$8, layer$4, layer$2));
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeHttpServer.js
 /**
 * @since 1.0.0
 */
@@ -57786,10 +58106,10 @@ const handleResponse = (request$2, response) => {
 			nodeResponse.writeHead(response.status, headers);
 			const drainLatch = makeLatchUnsafe();
 			nodeResponse.on("drain", () => drainLatch.openUnsafe());
-			return body.stream.pipe(orDie, runForEachArray((array$3) => {
+			return body.stream.pipe(orDie, runForEachArray((array$1) => {
 				let needDrain = false;
-				for (let i = 0; i < array$3.length; i++) {
-					const written = nodeResponse.write(array$3[i]);
+				for (let i = 0; i < array$1.length; i++) {
+					const written = nodeResponse.write(array$1[i]);
 					if (!written && !needDrain) {
 						needDrain = true;
 						drainLatch.closeUnsafe();
@@ -57812,7 +58132,7 @@ const handleCause = (nodeResponse, originalResponse) => (originalCause) => flatM
 });
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_d393194bb3ab2ece8980cda0f0e094ab/node_modules/@effect/platform-node-shared/dist/NodeRuntime.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-_ce145807d4d34cc94a2615fb48433791/node_modules/@effect/platform-node-shared/dist/NodeRuntime.js
 /**
 * @since 1.0.0
 * @category Run main
@@ -57839,7 +58159,7 @@ const runMain$1 = /* @__PURE__ */ makeRunMain(({ fiber: fiber$2, teardown }) =>
 });
 
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@bc_f9e8876b4df14192b37a495b1cc1e01e/node_modules/@effect/platform-node/dist/NodeRuntime.js
+//#region node_modules/.pnpm/@effect+platform-node@https+++pkg.pr.new+Effect-TS+effect-smol+@effect+platform-node@11_e41eed9c01fe65d9f63e2979c8fac523/node_modules/@effect/platform-node/dist/NodeRuntime.js
 /**
 * @since 1.0.0
 */
@@ -58202,13 +58522,13 @@ var require_inspect = /* @__PURE__ */ __commonJSMin(((exports$1) => {
 			return key + ": " + value;
 		}).join(", ") + " }";
 	}
-	function formatArray(array$3, seenValues) {
-		if (array$3.length === 0) return "[]";
+	function formatArray(array$1, seenValues) {
+		if (array$1.length === 0) return "[]";
 		if (seenValues.length > MAX_RECURSIVE_DEPTH) return "[Array]";
-		var len = Math.min(MAX_ARRAY_LENGTH, array$3.length);
-		var remaining = array$3.length - len;
+		var len = Math.min(MAX_ARRAY_LENGTH, array$1.length);
+		var remaining = array$1.length - len;
 		var items = [];
-		for (var i = 0; i < len; ++i) items.push(formatValue(array$3[i], seenValues));
+		for (var i = 0; i < len; ++i) items.push(formatValue(array$1[i], seenValues));
 		if (remaining === 1) items.push("... 1 more item");
 		else if (remaining > 1) items.push("... ".concat(remaining, " more items"));
 		return "[" + items.join(", ") + "]";
@@ -59123,8 +59443,8 @@ var import_printer = (/* @__PURE__ */ __commonJSMin(((exports$1) => {
 	* Given array, print each item on its own line, wrapped in an
 	* indented "{ }" block.
 	*/
-	function block(array$3) {
-		return wrap("{\n", indent(join$2(array$3, "\n")), "\n}");
+	function block(array$1) {
+		return wrap("{\n", indent(join$2(array$1, "\n")), "\n}");
 	}
 	/**
 	* If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
@@ -119699,10 +120019,10 @@ var AttachmentLinkGitLabMrMutation = class extends Request$1 {
 	* @param variables - variables without 'issueId', 'number', 'projectPathWithNamespace', 'url' to pass into the AttachmentLinkGitLabMrMutation
 	* @returns parsed response from AttachmentLinkGitLabMrMutation
 	*/
-	async fetch(issueId, number$4, projectPathWithNamespace, url, variables) {
+	async fetch(issueId, number$3, projectPathWithNamespace, url, variables) {
 		const data = (await this._request(AttachmentLinkGitLabMrDocument.toString(), {
 			issueId,
-			number: number$4,
+			number: number$3,
 			projectPathWithNamespace,
 			url,
 			...variables
@@ -129326,8 +129646,8 @@ var LinearSdk = class extends Request$1 {
 	* @param variables - variables without 'issueId', 'number', 'projectPathWithNamespace', 'url' to pass into the AttachmentLinkGitLabMrMutation
 	* @returns AttachmentPayload
 	*/
-	attachmentLinkGitLabMR(issueId, number$4, projectPathWithNamespace, url, variables) {
-		return new AttachmentLinkGitLabMrMutation(this._request).fetch(issueId, number$4, projectPathWithNamespace, url, variables);
+	attachmentLinkGitLabMR(issueId, number$3, projectPathWithNamespace, url, variables) {
+		return new AttachmentLinkGitLabMrMutation(this._request).fetch(issueId, number$3, projectPathWithNamespace, url, variables);
 	}
 	/**
 	* Link an existing Intercom conversation to an issue.
@@ -131986,7 +132306,7 @@ var TokenManager = class extends Service()("lalph/Linear/TokenManager", { make:
 		yield* serve(CallbackRoute, {
 			disableListenLog: true,
 			disableLogger: true
-		}).pipe(provide$2(layer(createServer, { port: 34338 })), build);
+		}).pipe(provide$2(layer(createServer, { port: 34338 })), build, orDie$2);
 		const redirectUri = `http://localhost:34338/callback`;
 		const verifier = crypto.randomUUID();
 		const verifierSha256 = yield* promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
@@ -132002,7 +132322,7 @@ var TokenManager = class extends Service()("lalph/Linear/TokenManager", { make:
 			grant_type: "authorization_code"
 		}), httpClient.execute, flatMap(schemaBodyJson(TokenResponse)));
 		return AccessToken.fromResponse(res);
-	}).pipe(scoped$1, orDie$2);
+	}).pipe(scoped$1);
 	const refresh = fnUntraced(function* (token) {
 		const res = yield* post("https://api.linear.app/oauth/token").pipe(bodyUrlParams({
 			refresh_token: token.refreshToken,
@@ -132283,7 +132603,7 @@ var Prd = class extends Service()("lalph/Prd", { make: gen(function* () {
 			}));
 		}
 	});
-	yield* addFinalizer(() => orDie$2(sync$2));
+	yield* addFinalizer(() => ignore(sync$2));
 	yield* fs.watch(prdFile).pipe(buffer({
 		capacity: 1,
 		strategy: "dropping"
@@ -132483,9 +132803,10 @@ const root = make$26("lalph", {
 	let iteration = 0;
 	let lastStartedAt = makeUnsafe$3(0);
 	let inProgress = 0;
+	let quit = false;
 	while (true) {
 		yield* semaphore.take(1);
-		if (isFinite$3 && iteration >= iterations$1) break;
+		if (quit || isFinite$3 && iteration >= iterations$1) break;
 		const currentIteration = iteration;
 		if (inProgress > 0) {
 			const nextEarliestStart = lastStartedAt.pipe(add$1({ seconds: 30 }));
@@ -132494,13 +132815,16 @@ const root = make$26("lalph", {
 		}
 		lastStartedAt = yield* now;
 		inProgress++;
-		yield* run.pipe(catchTag("NoMoreWork", (e) => {
+		yield* run.pipe(catchFilter((e) => e._tag === "NoMoreWork" || e._tag === "QuitError" ? fail$7(e) : e, logWarning), catchTag("NoMoreWork", (e) => {
 			if (isFinite$3) {
 				iterations$1 = currentIteration;
 				return fail$3(e);
 			}
 			return log$1("No more work to process, waiting 30 seconds...").pipe(andThen(sleep("30 seconds")));
-		}), catchCause$1(logWarning), annotateLogs({ iteration: currentIteration }), ensuring(suspend$2(() => {
+		}), catchTag("QuitError", (_) => {
+			quit = true;
+			return void_$1;
+		}), annotateLogs({ iteration: currentIteration }), ensuring(suspend$2(() => {
 			inProgress--;
 			return semaphore.release(1);
 		})), forkChild);