t3code-cli 0.7.0 → 0.9.0

package/dist/Context-DueQ9iMH.js

@@ -1,4916 +0,0 @@
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Pipeable.js
-/**
-* The `Pipeable` module defines the shared interface and implementation helpers
-* for values that support Effect-style method chaining with `.pipe(...)`.
-*
-* A `Pipeable` value can pass itself through a sequence of unary functions from
-* left to right, so code can be written as `value.pipe(f, g, h)` instead of
-* deeply nesting calls. This is the method form used by many Effect data types
-* to compose transformations, validations, and effectful operations while
-* keeping the original value as the starting point of the pipeline.
-*
-* **Common tasks**
-*
-* - Type values that expose a `.pipe(...)` method with the {@link Pipeable} interface
-* - Implement a custom `.pipe(...)` method with {@link pipeArguments}
-* - Reuse the standard implementation through {@link Prototype}, {@link Class}, or {@link Mixin}
-*
-* **Gotchas**
-*
-* - Each function receives the result of the previous function, not the original value
-* - The overloads preserve precise types for long pipelines, but very long chains may be easier to read when split
-*
-* @since 2.0.0
-*/
-/**
-* Applies a `pipe` method's variadic arguments to an initial value from left
-* to right.
-*
-* **When to use**
-*
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
-*
-* **Details**
-*
-* This helper is intended for implementing `Pipeable.pipe` methods that
-* receive JavaScript's `arguments` object. With no functions it returns the
-* original value; otherwise it feeds each result into the next function.
-*
-* **Example** (Implementing a pipe method)
-*
-* ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
-*
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
-*
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* console.log(result) // 21
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
-const pipeArguments = (self, args) => {
-	switch (args.length) {
-		case 0: return self;
-		case 1: return args[0](self);
-		case 2: return args[1](args[0](self));
-		case 3: return args[2](args[1](args[0](self)));
-		case 4: return args[3](args[2](args[1](args[0](self))));
-		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
-		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
-		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
-		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
-		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
-		default: {
-			let ret = self;
-			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
-			return ret;
-		}
-	}
-};
-/**
-* Reusable prototype that implements `Pipeable.pipe`.
-*
-* **When to use**
-*
-* Use when classes or object prototypes can reuse this value when they need the
-* standard pipe implementation backed by `pipeArguments`.
-*
-* @category prototypes
-* @since 3.15.0
-*/
-const Prototype$1 = { pipe() {
-	return pipeArguments(this, arguments);
-} };
-/**
-* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
-* method.
-*
-* **When to use**
-*
-* Use when you need to define a class that supports Effect-style method
-* chaining through `.pipe(...)`.
-*
-* @category constructors
-* @since 3.15.0
-*/
-const Class$1 = /*#__PURE__*/ function() {
-	function PipeableBase() {}
-	PipeableBase.prototype = Prototype$1;
-	return PipeableBase;
-}();
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Function.js
-/**
-* Creates a function that can be called in data-first style or data-last
-* (`pipe`-friendly) style.
-*
-* **When to use**
-*
-* Use to expose one implementation through both direct and `pipe`-friendly
-* call styles.
-*
-* **Details**
-*
-* Pass either the arity of the uncurried function or a predicate that decides
-* whether the current call is data-first. Arity is the common case. Use a
-* predicate when optional arguments make arity ambiguous.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = Function.dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { Function, pipe } from "effect"
-*
-* const sum = Function.dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : (self) => body(self, ...arguments);
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* Returns its input argument unchanged.
-*
-* **When to use**
-*
-* Use to return a value unchanged where a function is required.
-*
-* **Example** (Returning the same value)
-*
-* ```ts
-* import { identity } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(identity(5), 5)
-* ```
-*
-* @category combinators
-* @since 2.0.0
-*/
-const identity = (a) => a;
-/**
-* Creates a zero-argument function that always returns the provided value.
-*
-* **When to use**
-*
-* Use when you need a thunk or callback that returns the same value on every
-* invocation.
-*
-* **Example** (Creating a constant thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* const constNull = Function.constant(null)
-*
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(constNull(), null)
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const constant = (value) => () => value;
-/**
-* Returns `true` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `true` on every invocation.
-*
-* **Example** (Returning true from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constTrue(), true)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constTrue = /*#__PURE__*/ constant(true);
-/**
-* Returns `false` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `false` on every invocation.
-*
-* **Example** (Returning false from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constFalse(), false)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constFalse = /*#__PURE__*/ constant(false);
-/**
-* Returns `undefined` when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that returns `undefined` on every invocation.
-*
-* **Example** (Returning undefined from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constUndefined = /*#__PURE__*/ constant(void 0);
-/**
-* Returns no meaningful value when called.
-*
-* **When to use**
-*
-* Use when you need a thunk that is called only for its effect and has no
-* meaningful return value.
-*
-* **Example** (Returning void from a thunk)
-*
-* ```ts
-* import { Function } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Function.constVoid(), undefined)
-* ```
-*
-* @category constants
-* @since 2.0.0
-*/
-const constVoid = constUndefined;
-function pipe(a, ...args) {
-	return pipeArguments(a, args);
-}
-function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
-	switch (arguments.length) {
-		case 1: return ab;
-		case 2: return function() {
-			return bc(ab.apply(this, arguments));
-		};
-		case 3: return function() {
-			return cd(bc(ab.apply(this, arguments)));
-		};
-		case 4: return function() {
-			return de(cd(bc(ab.apply(this, arguments))));
-		};
-		case 5: return function() {
-			return ef(de(cd(bc(ab.apply(this, arguments)))));
-		};
-		case 6: return function() {
-			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-		};
-		case 7: return function() {
-			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-		};
-		case 8: return function() {
-			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-		};
-		case 9: return function() {
-			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-		};
-	}
-}
-/**
-* Creates a memoized function whose input is an object, caching results by
-* object identity.
-*
-* **When to use**
-*
-* Use to reuse the result of a synchronous computation whose output is stable
-* for a given object reference.
-*
-* **Details**
-*
-* Each memoized wrapper owns a private `WeakMap` keyed by object identity.
-* Cached `undefined` results are still returned because the cache is checked
-* with `WeakMap.has`.
-*
-* **Gotchas**
-*
-* Structurally equal objects do not share cache entries. If the same object is
-* mutated after its first call, later calls still return the cached result for
-* that reference.
-*
-* @category caching
-* @since 4.0.0
-*/
-function memoize(f) {
-	const cache = /* @__PURE__ */ new WeakMap();
-	return (a) => {
-		if (cache.has(a)) return cache.get(a);
-		const result = f(a);
-		cache.set(a, result);
-		return result;
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/internal/equal.js
-/** @internal */
-const getAllObjectKeys = (obj) => {
-	const keys = new Set(Reflect.ownKeys(obj));
-	if (obj.constructor === Object) return keys;
-	if (obj instanceof Error) keys.delete("stack");
-	const proto = Object.getPrototypeOf(obj);
-	let current = proto;
-	while (current !== null && current !== Object.prototype) {
-		const ownKeys = Reflect.ownKeys(current);
-		for (let i = 0; i < ownKeys.length; i++) keys.add(ownKeys[i]);
-		current = Object.getPrototypeOf(current);
-	}
-	if (keys.has("constructor") && typeof obj.constructor === "function" && proto === obj.constructor.prototype) keys.delete("constructor");
-	return keys;
-};
-/** @internal */
-const byReferenceInstances = /*#__PURE__*/ new WeakSet();
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Predicate.js
-/**
-* Predicates are small boolean functions for checking values at runtime.
-* Refinements are predicates that also narrow TypeScript types after a
-* successful check. This module provides primitive guards for common JavaScript
-* values and combinators for building larger checks from smaller ones.
-*
-* **Mental model**
-*
-* - A `Predicate<A>` is `(a: A) => boolean`
-* - A `Refinement<A, B>` is `(a: A) => a is B`; when it returns `true`,
-*   TypeScript can treat the value as `B`
-* - Guards such as {@link isString}, {@link isNumber}, and {@link isObject}
-*   refine `unknown` values into useful runtime types
-* - Combinators such as {@link and}, {@link or}, {@link not}, and {@link xor}
-*   build new predicates while preserving refinement information where possible
-* - {@link Tuple} and {@link Struct} lift element and property predicates to
-*   tuple-like arrays and object shapes
-*
-* **Common tasks**
-*
-* - Check primitive runtime types: {@link isString}, {@link isNumber},
-*   {@link isBoolean}, {@link isBigInt}, {@link isSymbol}
-* - Check object-like values: {@link isObject}, {@link isObjectOrArray},
-*   {@link hasProperty}, {@link isTagged}
-* - Combine predicates: {@link and}, {@link or}, {@link not}, {@link xor}
-* - Reuse a predicate on derived input: {@link mapInput}
-* - Compose refinements that narrow in stages: {@link compose}
-* - Validate tuple or object shapes: {@link Tuple}, {@link Struct}
-*
-* **Gotchas**
-*
-* - Predicates only return `true` or `false`; they do not explain why a value
-*   failed a check
-* - {@link isTruthy} uses JavaScript truthiness, so `0`, `""`, and `false`
-*   are rejected
-* - {@link isObject} excludes arrays; use {@link isObjectOrArray} when arrays
-*   should also pass
-* - {@link isIterable} accepts strings because strings are iterable in
-*   JavaScript
-* - {@link isPromise} and {@link isPromiseLike} are structural checks, not
-*   `instanceof` checks
-* - {@link isTupleOf} and {@link isTupleOfAtLeast} check length only, not
-*   element types
-*
-* **Quickstart**
-*
-* **Example** (Filter by a predicate)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const values: Array<unknown> = ["one", 2, "three", null]
-* const strings = values.filter(Predicate.isString)
-*
-* console.log(strings)
-* // Output: ["one", "three"]
-* ```
-*
-* **See also**
-*
-* - {@link Predicate} for plain boolean checks
-* - {@link Refinement} for checks that narrow types
-* - {@link Struct} and {@link Tuple} for checking compound values
-*
-* @since 2.0.0
-*/
-/**
-* Checks whether a value is a `string`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* string.
-*
-* **Details**
-*
-* Uses `typeof input === "string"`.
-*
-* **Example** (Guard string)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = "hi"
-*
-* if (Predicate.isString(data)) {
-*   console.log(data.toUpperCase())
-* }
-* ```
-*
-* @see {@link isNumber}
-* @see {@link isBoolean}
-* @see {@link Refinement}
-* @category guards
-* @since 2.0.0
-*/
-function isString(input) {
-	return typeof input === "string";
-}
-/**
-* Checks whether a value is a `number`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* number.
-*
-* **Details**
-*
-* Uses `typeof input === "number"` and does not exclude `NaN` or `Infinity`.
-*
-* **Example** (Guard number)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = 42
-*
-* if (Predicate.isNumber(data)) {
-*   console.log(data + 1)
-* }
-* ```
-*
-* @see {@link isBigInt}
-* @see {@link isString}
-* @category guards
-* @since 2.0.0
-*/
-function isNumber(input) {
-	return typeof input === "number";
-}
-/**
-* Checks whether a value is a `boolean`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* boolean.
-*
-* **Details**
-*
-* Uses `typeof input === "boolean"`.
-*
-* **Example** (Guard boolean)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = true
-*
-* if (Predicate.isBoolean(data)) {
-*   console.log(data ? "yes" : "no")
-* }
-* ```
-*
-* @see {@link isString}
-* @see {@link isNumber}
-* @category guards
-* @since 2.0.0
-*/
-function isBoolean(input) {
-	return typeof input === "boolean";
-}
-/**
-* Checks whether a value is a `bigint`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* bigint.
-*
-* **Details**
-*
-* Uses `typeof input === "bigint"`.
-*
-* **Example** (Guard bigint)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = 1n
-*
-* if (Predicate.isBigInt(data)) {
-*   console.log(data + 2n)
-* }
-* ```
-*
-* @see {@link isNumber}
-* @category guards
-* @since 2.0.0
-*/
-function isBigInt(input) {
-	return typeof input === "bigint";
-}
-/**
-* Checks whether a value is a `symbol`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* symbol.
-*
-* **Details**
-*
-* Uses `typeof input === "symbol"`.
-*
-* **Example** (Guard symbol)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = Symbol.for("id")
-*
-* if (Predicate.isSymbol(data)) {
-*   console.log(data.description)
-* }
-* ```
-*
-* @see {@link isPropertyKey}
-* @category guards
-* @since 2.0.0
-*/
-function isSymbol(input) {
-	return typeof input === "symbol";
-}
-/**
-* Checks whether a value is a valid `PropertyKey` (string, number, or symbol).
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for unknown property keys before
-* indexing.
-*
-* **Details**
-*
-* Uses `isString`, `isNumber`, and `isSymbol`.
-*
-* **Example** (Guard property key)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const key: unknown = "name"
-* const obj: Record<PropertyKey, unknown> = { name: "Ada" }
-*
-* if (Predicate.isPropertyKey(key) && key in obj) {
-*   console.log(obj[key])
-* }
-* ```
-*
-* @see {@link isString}
-* @see {@link isNumber}
-* @see {@link isSymbol}
-* @category guards
-* @since 4.0.0
-*/
-function isPropertyKey(u) {
-	return isString(u) || isNumber(u) || isSymbol(u);
-}
-/**
-* Checks whether a value is a `function`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard to narrow an `unknown` value to a
-* callable function.
-*
-* **Details**
-*
-* Uses `typeof input === "function"`.
-*
-* **Example** (Guard function)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = () => 1
-*
-* if (Predicate.isFunction(data)) {
-*   console.log(data())
-* }
-* ```
-*
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
-function isFunction(input) {
-	return typeof input === "function";
-}
-/**
-* Checks whether a value is `undefined`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for values that are exactly
-* `undefined`.
-*
-* **Details**
-*
-* Uses `input === undefined`.
-*
-* **Example** (Guard undefined)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = undefined
-*
-* console.log(Predicate.isUndefined(data))
-* ```
-*
-* @see {@link isNotUndefined}
-* @see {@link isNullish}
-* @category guards
-* @since 2.0.0
-*/
-function isUndefined(input) {
-	return input === void 0;
-}
-/**
-* Checks whether a value is not `undefined`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` refinement that filters out `undefined`
-* while preserving other falsy values.
-*
-* **Details**
-*
-* Returns a refinement that excludes `undefined`.
-*
-* **Example** (Filter undefined)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const values = [1, undefined, 2]
-* const defined = values.filter(Predicate.isNotUndefined)
-*
-* console.log(defined)
-* ```
-*
-* @see {@link isUndefined}
-* @see {@link isNotNullish}
-* @category guards
-* @since 2.0.0
-*/
-function isNotUndefined(input) {
-	return input !== void 0;
-}
-/**
-* Checks whether a value is not `null`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` refinement that filters out `null` while
-* preserving other falsy values.
-*
-* **Details**
-*
-* Returns a refinement that excludes `null`.
-*
-* **Example** (Filter null)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const values = [1, null, 2]
-* const nonNull = values.filter(Predicate.isNotNull)
-*
-* console.log(nonNull)
-* ```
-*
-* @see {@link isNull}
-* @see {@link isNotNullish}
-* @category guards
-* @since 2.0.0
-*/
-function isNotNull(input) {
-	return input !== null;
-}
-/**
-* Checks whether a value is `null` or `undefined`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for nullish values.
-*
-* **Details**
-*
-* Uses `input === null || input === undefined`.
-*
-* **Example** (Guard nullish)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const values = [0, null, "", undefined]
-* const nullish = values.filter(Predicate.isNullish)
-*
-* console.log(nullish)
-* ```
-*
-* @see {@link isNotNullish}
-* @see {@link isUndefined}
-* @see {@link isNull}
-* @category guards
-* @since 4.0.0
-*/
-function isNullish(input) {
-	return input === null || input === void 0;
-}
-/**
-* Checks whether a value is not `null` and not `undefined`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` refinement that filters out nullish values
-* but keeps other falsy ones.
-*
-* **Details**
-*
-* Uses `input != null`.
-*
-* **Example** (Filter non-nullish)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const values = [0, null, "", undefined]
-* const present = values.filter(Predicate.isNotNullish)
-*
-* console.log(present)
-* ```
-*
-* @see {@link isNullish}
-* @see {@link isNotNull}
-* @see {@link isNotUndefined}
-* @category guards
-* @since 4.0.0
-*/
-function isNotNullish(input) {
-	return input != null;
-}
-/**
-* Type guard that always returns `false`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` that never accepts, e.g. in default branches.
-*
-* **Example** (Never matches)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* console.log(Predicate.isNever("anything"))
-* ```
-*
-* @see {@link isUnknown}
-* @category guards
-* @since 2.0.0
-*/
-function isNever(_) {
-	return false;
-}
-/**
-* Type guard that always returns `true`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` that always accepts, e.g. as a placeholder.
-*
-* **Example** (Always matches)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* console.log(Predicate.isUnknown(123))
-* ```
-*
-* @see {@link isNever}
-* @category guards
-* @since 2.0.0
-*/
-function isUnknown(_) {
-	return true;
-}
-/**
-* Checks whether a value is a non-null object value that is not an array.
-*
-* **When to use**
-*
-* Use to narrow unknown input to a non-null, non-array object with a
-* `Predicate` guard.
-*
-* **Details**
-*
-* This is a structural runtime check using `typeof input === "object"`, so it
-* also accepts object instances such as `Date`, `Map`, class instances, and
-* typed arrays. It excludes `null` and arrays.
-*
-* **Example** (Guard object)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* console.log(Predicate.isObject({ a: 1 }))
-* console.log(Predicate.isObject([1, 2]))
-* ```
-*
-* @see {@link isObjectOrArray}
-* @see {@link isReadonlyObject}
-* @category guards
-* @since 2.0.0
-*/
-function isObject(input) {
-	return typeof input === "object" && input !== null && !Array.isArray(input);
-}
-/**
-* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard that accepts arrays and functions as
-* well as objects.
-*
-* **Details**
-*
-* Returns `true` for arrays and functions, and `false` for `null`.
-*
-* **Example** (Object keyword)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* console.log(Predicate.isObjectKeyword(() => 1))
-* console.log(Predicate.isObjectKeyword(null))
-* ```
-*
-* @see {@link isObject}
-* @see {@link isObjectOrArray}
-* @category guards
-* @since 4.0.0
-*/
-function isObjectKeyword(input) {
-	return typeof input === "object" && input !== null || isFunction(input);
-}
-/**
-* Checks whether a value has a given property key.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for property access on `unknown`
-* values with a simple structural object check.
-*
-* **Details**
-*
-* Uses the `in` operator and `isObjectKeyword`. This does not check property
-* value types.
-*
-* **Example** (Guard property)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const hasName = Predicate.hasProperty("name")
-* const data: unknown = { name: "Ada" }
-*
-* if (hasName(data)) {
-*   console.log(data.name)
-* }
-* ```
-*
-* @see {@link isTagged}
-* @see {@link isObjectKeyword}
-* @category guards
-* @since 2.0.0
-*/
-const hasProperty = /*#__PURE__*/ dual(2, (self, property) => isObjectKeyword(self) && property in self);
-/**
-* Checks whether a value has a `_tag` property equal to the given tag.
-*
-* **When to use**
-*
-* Use when you model tagged unions with a `_tag` field and want a quick
-* `Predicate` guard for tagged values.
-*
-* **Details**
-*
-* Uses `hasProperty` and strict equality on `_tag`.
-*
-* **Example** (Guard tagged)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const isOk = Predicate.isTagged("Ok")
-*
-* console.log(isOk({ _tag: "Ok", value: 1 }))
-* ```
-*
-* @see {@link hasProperty}
-* @category guards
-* @since 2.0.0
-*/
-const isTagged = /*#__PURE__*/ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
-/**
-* Checks whether a value is an `Error`.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard for errors caught from unknown sources.
-*
-* **Details**
-*
-* Uses `instanceof Error`.
-*
-* **Example** (Guard error)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = new Error("boom")
-*
-* console.log(Predicate.isError(data))
-* ```
-*
-* @see {@link isUnknown}
-* @category guards
-* @since 2.0.0
-*/
-function isError(input) {
-	return input instanceof Error;
-}
-/**
-* Checks whether a value is iterable.
-*
-* **When to use**
-*
-* Use when you need a `Predicate` guard before iterating an unknown value.
-*
-* **Details**
-*
-* Accepts strings as iterable and uses `hasProperty` for `Symbol.iterator`.
-*
-* **Example** (Guard iterable)
-*
-* ```ts
-* import { Predicate } from "effect"
-*
-* const data: unknown = [1, 2, 3]
-*
-* console.log(Predicate.isIterable(data))
-* ```
-*
-* @see {@link isSet}
-* @see {@link isMap}
-* @category guards
-* @since 2.0.0
-*/
-function isIterable(input) {
-	return hasProperty(input, Symbol.iterator) || isString(input);
-}
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Hash.js
-/**
-* The `Hash` module computes Effect hash values and defines the interface for
-* objects that want to provide their own hash implementation. Hashes are small
-* numeric fingerprints used by Effect data structures to bucket values quickly;
-* they are not cryptographic digests and they are not proof that two values are
-* equal.
-*
-* **Mental model**
-*
-* - {@link hash} dispatches by JavaScript type and handles primitives,
-*   arrays, typed arrays, maps, sets, plain objects, dates, regular
-*   expressions, and custom hashable objects
-* - Objects can implement {@link Hash} by defining a method at {@link symbol}
-* - Structural object hashes are cached, so repeated hashing of the same object
-*   is cheap after the first computation
-* - {@link random} gives reference-stable hash values for values that should
-*   be hashed by identity
-* - Lower-level helpers such as {@link combine}, {@link string},
-*   {@link number}, {@link structure}, {@link structureKeys}, and
-*   {@link array} are useful when implementing custom hashes
-*
-* **Quickstart**
-*
-* **Example** (Implementing a custom hash)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* class UserKey implements Hash.Hash {
-*   constructor(
-*     readonly id: string,
-*     readonly region: string
-*   ) {}
-*
-*   [Hash.symbol](): number {
-*     return Hash.combine(Hash.string(this.region))(Hash.string(this.id))
-*   }
-* }
-*
-* const value = Hash.hash(new UserKey("user-1", "eu"))
-* ```
-*
-* **Gotchas**
-*
-* - Hash collisions are possible; hash-based collections also need equality
-*   semantics to decide whether two values are actually the same
-* - Do not mutate an object after hashing it structurally, because the cached
-*   hash can become stale
-* - Use {@link random} or a custom {@link Hash} implementation for mutable
-*   objects that should be compared by reference identity
-*
-* @since 2.0.0
-*/
-/**
-* Defines the unique identifier used to identify objects that implement the Hash interface.
-*
-* **When to use**
-*
-* Use as the computed property key for the method that supplies a custom hash
-* value on a `Hash` implementor.
-*
-* @see {@link Hash} for the interface implemented with this symbol
-* @see {@link isHash} for checking whether a value implements `Hash`
-* @see {@link hash} for computing hash values
-*
-* @category symbols
-* @since 2.0.0
-*/
-const symbol$1 = "~effect/interfaces/Hash";
-/**
-* Computes a hash value for any given value.
-*
-* **When to use**
-*
-* Use to compute an Effect hash for primitives, collections, and hashable
-* objects.
-*
-* **Details**
-*
-* This function can hash primitives (numbers, strings, booleans, etc.) as well as
-* objects, arrays, and other complex data structures. It automatically handles
-* different types and provides a consistent hash value for equivalent inputs.
-*
-* **Gotchas**
-*
-* Objects being hashed must be treated as immutable after their first hash
-* computation. Hash results are cached, so mutating an object after hashing will
-* lead to stale cached values and broken hash-based operations. For mutable
-* objects, implement a custom `Hash` interface that hashes the object reference
-* rather than its content.
-*
-* **Example** (Hashing different values)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* // Hash primitive values
-* console.log(Hash.hash(42)) // numeric hash
-* console.log(Hash.hash("hello")) // string hash
-* console.log(Hash.hash(true)) // boolean hash
-*
-* // Hash objects and arrays
-* console.log(Hash.hash({ name: "John", age: 30 }))
-* console.log(Hash.hash([1, 2, 3]))
-* console.log(Hash.hash({ id: "user-1", roles: ["admin", "editor"] }))
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const hash = (self) => {
-	switch (typeof self) {
-		case "number": return number(self);
-		case "bigint": return string(self.toString(10));
-		case "boolean": return string(String(self));
-		case "symbol": return string(String(self));
-		case "string": return string(self);
-		case "undefined": return string("undefined");
-		case "function":
-		case "object": if (self === null) return string("null");
-		else if (self instanceof Date) return string(self.toISOString());
-		else if (self instanceof RegExp) return string(self.toString());
-		else {
-			if (byReferenceInstances.has(self)) return random(self);
-			if (hashCache.has(self)) return hashCache.get(self);
-			const h = withVisitedTracking$1(self, () => {
-				if (isHash(self)) return self[symbol$1]();
-				else if (typeof self === "function") return random(self);
-				else if (Array.isArray(self) || ArrayBuffer.isView(self)) return array(self);
-				else if (self instanceof Map) return hashMap(self);
-				else if (self instanceof Set) return hashSet(self);
-				return structure(self);
-			});
-			hashCache.set(self, h);
-			return h;
-		}
-		default: throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
-	}
-};
-/**
-* Generates a random hash value for an object and caches it.
-*
-* **When to use**
-*
-* Use to hash an object by reference identity instead of structural content.
-*
-* **Details**
-*
-* This function creates a random hash value for objects that don't have their own
-* hash implementation. The hash value is cached using a WeakMap, so the same object
-* will always return the same hash value during its lifetime.
-*
-* **Example** (Hashing objects by reference)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* const obj1 = { a: 1 }
-* const obj2 = { a: 1 }
-*
-* // Same object always returns the same hash
-* console.log(Hash.random(obj1) === Hash.random(obj1)) // true
-*
-* // Different objects get different hashes
-* console.log(Hash.random(obj1) === Hash.random(obj2)) // false
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const random = (self) => {
-	if (!randomHashCache.has(self)) randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
-	return randomHashCache.get(self);
-};
-/**
-* Combines two hash values into a single hash value.
-*
-* **When to use**
-*
-* Use to build a hash for a composite value by folding together hash values for
-* its parts.
-*
-* **Details**
-*
-* Supports both direct and pipeable usage. The implementation combines two
-* hash values with `(self * 53) ^ b`.
-*
-* **Example** (Combining hash values)
-*
-* ```ts
-* import { Hash, pipe } from "effect"
-*
-* // Can also be used with pipe
-*
-* const hash1 = Hash.hash("hello")
-* const hash2 = Hash.hash("world")
-*
-* // Combine two hash values
-* const combined = Hash.combine(hash2)(hash1)
-* console.log(combined)
-* const result = pipe(hash1, Hash.combine(hash2))
-* ```
-*
-* @see {@link hash} for computing hash values from arbitrary inputs
-* @see {@link structureKeys} for hashing selected object fields without manual combination
-*
-* @category hashing
-* @since 2.0.0
-*/
-const combine = /*#__PURE__*/ dual(2, (self, b) => self * 53 ^ b);
-/**
-* Applies bit manipulation techniques to optimize a hash value.
-*
-* **When to use**
-*
-* Use to improve the bit distribution of a raw numeric hash value.
-*
-* **Details**
-*
-* This function takes a hash value and applies bitwise operations to improve
-* the distribution of hash values, reducing the likelihood of collisions.
-*
-* **Example** (Optimizing a hash value)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* const rawHash = 1234567890
-* const optimizedHash = Hash.optimize(rawHash)
-* console.log(optimizedHash) // optimized hash value
-*
-* // Often used internally by other hash functions
-* const stringHash = Hash.optimize(Hash.string("hello"))
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
-/**
-* Checks whether a value implements the Hash interface.
-*
-* **When to use**
-*
-* Use to detect whether an unknown value provides a custom hash implementation.
-*
-* **Details**
-*
-* This function determines whether a given value has the Hash symbol property,
-* indicating that it can provide its own hash value implementation.
-*
-* **Example** (Checking for Hash support)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* class MyHashable implements Hash.Hash {
-*   [Hash.symbol]() {
-*     return 42
-*   }
-* }
-*
-* const obj = new MyHashable()
-* console.log(Hash.isHash(obj)) // true
-* console.log(Hash.isHash({})) // false
-* console.log(Hash.isHash("string")) // false
-* ```
-*
-* @category guards
-* @since 2.0.0
-*/
-const isHash = (u) => hasProperty(u, symbol$1);
-/**
-* Computes a hash value for a number.
-*
-* **When to use**
-*
-* Use to hash a JavaScript number with Effect's numeric hash semantics.
-*
-* **Details**
-*
-* This function creates a hash value for numeric inputs, handling special cases
-* like NaN, Infinity, and -Infinity with distinct hash values. It uses bitwise operations to ensure good distribution
-* of hash values across different numeric inputs.
-*
-* **Example** (Hashing numbers)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* console.log(Hash.number(42)) // hash of 42
-* console.log(Hash.number(3.14)) // hash of 3.14
-* console.log(Hash.number(NaN)) // hash of "NaN"
-* console.log(Hash.number(Infinity)) // 0 (special case)
-*
-* // Same numbers produce the same hash
-* console.log(Hash.number(100) === Hash.number(100)) // true
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const number = (n) => {
-	if (n !== n) return string("NaN");
-	if (n === Infinity) return string("Infinity");
-	if (n === -Infinity) return string("-Infinity");
-	let h = n | 0;
-	if (h !== n) h ^= n * 4294967295;
-	while (n > 4294967295) h ^= n /= 4294967295;
-	return optimize(h);
-};
-/**
-* Computes a hash value for a string using the djb2 algorithm.
-*
-* **When to use**
-*
-* Use when you need a string field to contribute to a custom structural hash
-* implementation.
-*
-* **Details**
-*
-* This function implements a variation of the djb2 hash algorithm, which is
-* known for its good distribution properties and speed. It processes each
-* character of the string to produce a consistent hash value.
-*
-* **Example** (Hashing strings)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* console.log(Hash.string("hello")) // hash of "hello"
-* console.log(Hash.string("world")) // hash of "world"
-* console.log(Hash.string("")) // hash of empty string
-*
-* // Same strings produce the same hash
-* console.log(Hash.string("test") === Hash.string("test")) // true
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const string = (str) => {
-	let h = 5381, i = str.length;
-	while (i) h = h * 33 ^ str.charCodeAt(--i);
-	return optimize(h);
-};
-/**
-* Computes a hash value for an object using only the specified keys.
-*
-* **When to use**
-*
-* Use to hash an object by a selected set of property keys.
-*
-* **Details**
-*
-* This function allows you to hash an object by considering only specific keys,
-* which is useful when you want to create a hash based on a subset of an object's
-* properties.
-*
-* **Example** (Hashing selected object keys)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* const person = { name: "John", age: 30, city: "New York" }
-*
-* // Hash only specific keys
-* const hash1 = Hash.structureKeys(person, ["name", "age"])
-* const hash2 = Hash.structureKeys(person, ["name", "city"])
-*
-* console.log(hash1) // hash based on name and age
-* console.log(hash2) // hash based on name and city
-*
-* // Same keys produce the same hash
-* const person2 = { name: "John", age: 30, city: "Boston" }
-* const hash3 = Hash.structureKeys(person2, ["name", "age"])
-* console.log(hash1 === hash3) // true
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const structureKeys = (o, keys) => {
-	let h = 12289;
-	for (const key of keys) h ^= combine(hash(key), hash(o[key]));
-	return optimize(h);
-};
-/**
-* Computes a structural hash for an object using Effect's object key collection.
-*
-* **When to use**
-*
-* Use to hash an object from all structural keys collected by Effect.
-*
-* **Details**
-*
-* The hash is based on the object's structural keys and their values, including
-* symbol keys and relevant prototype keys for non-plain objects.
-*
-* **Example** (Hashing object structures)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* const obj1 = { name: "John", age: 30 }
-* const obj2 = { name: "Jane", age: 25 }
-* const obj3 = { name: "John", age: 30 }
-*
-* console.log(Hash.structure(obj1)) // hash of obj1
-* console.log(Hash.structure(obj2)) // different hash
-* console.log(Hash.structure(obj3)) // same as obj1
-*
-* // Objects with same properties produce same hash
-* console.log(Hash.structure(obj1) === Hash.structure(obj3)) // true
-* ```
-*
-* @category hashing
-* @since 2.0.0
-*/
-const structure = (o) => structureKeys(o, getAllObjectKeys(o));
-const iterableWith = (seed, f) => (iter) => {
-	let h = seed;
-	for (const element of iter) h ^= f(element);
-	return optimize(h);
-};
-/**
-* Computes a hash value for an iterable by hashing all of its elements.
-*
-* **When to use**
-*
-* Use to hash the values yielded by an iterable with Effect hash semantics.
-*
-* **Details**
-*
-* The implementation folds element hashes from the seed `6151` with XOR and
-* then optimizes the final hash.
-*
-* **Gotchas**
-*
-* A hash is not an equality proof. Because this implementation uses XOR,
-* reordered inputs can produce the same hash.
-*
-* **Example** (Hashing arrays)
-*
-* ```ts
-* import { Hash } from "effect"
-*
-* const arr1 = [1, 2, 3]
-* const arr2 = [1, 2, 3]
-* const arr3 = [3, 2, 1]
-*
-* console.log(Hash.array(arr1)) // hash of [1, 2, 3]
-* console.log(Hash.array(arr2)) // same hash as arr1
-* console.log(Hash.array(arr3)) // may match reordered inputs
-*
-* console.log(Hash.array(arr1) === Hash.array(arr2)) // true
-* console.log(Hash.array(arr1) === Hash.array(arr3)) // true
-* ```
-*
-* @see {@link hash} for the general-purpose hash dispatcher
-*
-* @category hashing
-* @since 2.0.0
-*/
-const array = /*#__PURE__*/ iterableWith(6151, hash);
-const hashMap = /*#__PURE__*/ iterableWith(/*#__PURE__*/ string("Map"), ([k, v]) => combine(hash(k), hash(v)));
-const hashSet = /*#__PURE__*/ iterableWith(/*#__PURE__*/ string("Set"), hash);
-const randomHashCache = /*#__PURE__*/ new WeakMap();
-const hashCache = /*#__PURE__*/ new WeakMap();
-const visitedObjects = /*#__PURE__*/ new WeakSet();
-function withVisitedTracking$1(obj, fn) {
-	if (visitedObjects.has(obj)) return string("[Circular]");
-	visitedObjects.add(obj);
-	const result = fn();
-	visitedObjects.delete(obj);
-	return result;
-}
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Equal.js
-/**
-* Defines the unique string identifier for the `Equal` interface.
-*
-* **When to use**
-*
-* Use when you implement custom equality and need the computed property key for
-* the equality method.
-*
-* **Details**
-*
-* This is a pure constant with no allocation or side effects.
-*
-* **Example** (Implementing Equal on a Class)
-*
-* ```ts
-* import { Equal, Hash } from "effect"
-*
-* class UserId implements Equal.Equal {
-*   constructor(readonly id: string) {}
-*
-*   [Equal.symbol](that: Equal.Equal): boolean {
-*     return that instanceof UserId && this.id === that.id
-*   }
-*
-*   [Hash.symbol](): number {
-*     return Hash.string(this.id)
-*   }
-* }
-* ```
-*
-* @see {@link Equal} — the interface that uses this symbol
-* @see {@link isEqual} — type guard for `Equal` implementors
-* @category symbols
-* @since 2.0.0
-*/
-const symbol = "~effect/interfaces/Equal";
-function equals() {
-	if (arguments.length === 1) return (self) => compareBoth(self, arguments[0]);
-	return compareBoth(arguments[0], arguments[1]);
-}
-function compareBoth(self, that) {
-	if (self === that) return true;
-	if (self == null || that == null) return false;
-	const selfType = typeof self;
-	if (selfType !== typeof that) return false;
-	if (selfType === "number" && self !== self && that !== that) return true;
-	if (selfType !== "object" && selfType !== "function") return false;
-	if (byReferenceInstances.has(self) || byReferenceInstances.has(that)) return false;
-	return withCache(self, that, compareObjects);
-}
-/** Helper to run comparison with proper visited tracking */
-function withVisitedTracking(self, that, fn) {
-	const hasLeft = visitedLeft.has(self);
-	const hasRight = visitedRight.has(that);
-	if (hasLeft && hasRight) return true;
-	if (hasLeft || hasRight) return false;
-	visitedLeft.add(self);
-	visitedRight.add(that);
-	const result = fn();
-	visitedLeft.delete(self);
-	visitedRight.delete(that);
-	return result;
-}
-const visitedLeft = /*#__PURE__*/ new WeakSet();
-const visitedRight = /*#__PURE__*/ new WeakSet();
-/** Helper to perform cached object comparison */
-function compareObjects(self, that) {
-	if (hash(self) !== hash(that)) return false;
-	else if (self instanceof Date) {
-		if (!(that instanceof Date)) return false;
-		return self.toISOString() === that.toISOString();
-	} else if (self instanceof RegExp) {
-		if (!(that instanceof RegExp)) return false;
-		return self.toString() === that.toString();
-	}
-	const selfIsEqual = isEqual(self);
-	const thatIsEqual = isEqual(that);
-	if (selfIsEqual !== thatIsEqual) return false;
-	const bothEquals = selfIsEqual && thatIsEqual;
-	if (typeof self === "function" && !bothEquals) return false;
-	return withVisitedTracking(self, that, () => {
-		if (bothEquals) return self[symbol](that);
-		else if (Array.isArray(self)) {
-			if (!Array.isArray(that) || self.length !== that.length) return false;
-			return compareArrays(self, that);
-		} else if (ArrayBuffer.isView(self)) {
-			if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength) return false;
-			return compareTypedArrays(self, that);
-		} else if (self instanceof Map) {
-			if (!(that instanceof Map) || self.size !== that.size) return false;
-			return compareMaps(self, that);
-		} else if (self instanceof Set) {
-			if (!(that instanceof Set) || self.size !== that.size) return false;
-			return compareSets(self, that);
-		}
-		return compareRecords(self, that);
-	});
-}
-function withCache(self, that, f) {
-	let selfMap = equalityCache.get(self);
-	if (!selfMap) {
-		selfMap = /* @__PURE__ */ new WeakMap();
-		equalityCache.set(self, selfMap);
-	} else if (selfMap.has(that)) return selfMap.get(that);
-	const result = f(self, that);
-	selfMap.set(that, result);
-	let thatMap = equalityCache.get(that);
-	if (!thatMap) {
-		thatMap = /* @__PURE__ */ new WeakMap();
-		equalityCache.set(that, thatMap);
-	}
-	thatMap.set(self, result);
-	return result;
-}
-const equalityCache = /*#__PURE__*/ new WeakMap();
-function compareArrays(self, that) {
-	for (let i = 0; i < self.length; i++) if (!compareBoth(self[i], that[i])) return false;
-	return true;
-}
-function compareTypedArrays(self, that) {
-	if (self.length !== that.length) return false;
-	for (let i = 0; i < self.length; i++) if (self[i] !== that[i]) return false;
-	return true;
-}
-function compareRecords(self, that) {
-	const selfKeys = getAllObjectKeys(self);
-	const thatKeys = getAllObjectKeys(that);
-	if (selfKeys.size !== thatKeys.size) return false;
-	for (const key of selfKeys) if (!thatKeys.has(key) || !compareBoth(self[key], that[key])) return false;
-	return true;
-}
-/** @internal */
-function makeCompareMap(keyEquivalence, valueEquivalence) {
-	return function compareMaps(self, that) {
-		for (const [selfKey, selfValue] of self) {
-			let found = false;
-			for (const [thatKey, thatValue] of that) if (keyEquivalence(selfKey, thatKey) && valueEquivalence(selfValue, thatValue)) {
-				found = true;
-				break;
-			}
-			if (!found) return false;
-		}
-		return true;
-	};
-}
-const compareMaps = /*#__PURE__*/ makeCompareMap(compareBoth, compareBoth);
-/** @internal */
-function makeCompareSet(equivalence) {
-	return function compareSets(self, that) {
-		for (const selfValue of self) {
-			let found = false;
-			for (const thatValue of that) if (equivalence(selfValue, thatValue)) {
-				found = true;
-				break;
-			}
-			if (!found) return false;
-		}
-		return true;
-	};
-}
-const compareSets = /*#__PURE__*/ makeCompareSet(compareBoth);
-/**
-* Checks whether a value implements the {@link Equal} interface.
-*
-* **When to use**
-*
-* Use when you need generic utility code to distinguish `Equal` implementors
-* from plain values before calling `[Equal.symbol]` directly.
-*
-* **Details**
-*
-* - Pure function, no side effects.
-* - Returns `true` if and only if `u` has a property keyed by
-*   {@link symbol}.
-* - Acts as a TypeScript type guard, narrowing the input to {@link Equal}.
-*
-* **Example** (Type Guard)
-*
-* ```ts
-* import { Equal, Hash } from "effect"
-*
-* class Token implements Equal.Equal {
-*   constructor(readonly value: string) {}
-*   [Equal.symbol](that: Equal.Equal): boolean {
-*     return that instanceof Token && this.value === that.value
-*   }
-*   [Hash.symbol](): number {
-*     return Hash.string(this.value)
-*   }
-* }
-*
-* console.log(Equal.isEqual(new Token("abc"))) // true
-* console.log(Equal.isEqual({ x: 1 }))         // false
-* console.log(Equal.isEqual(42))                // false
-* ```
-*
-* @see {@link Equal} — the interface being checked
-* @see {@link symbol} — the property key that signals `Equal` support
-* @category guards
-* @since 2.0.0
-*/
-const isEqual = (u) => hasProperty(u, symbol);
-/**
-* Wraps {@link equals} as an `Equivalence<A>`.
-*
-* **When to use**
-*
-* Use when you want to pass `Equal.equals` to APIs that require an
-* `Equivalence`.
-*
-* **Details**
-*
-* - Returns a function `(a: A, b: A) => boolean` that delegates to
-*   {@link equals}.
-* - Pure; allocates a thin wrapper on each call.
-*
-* **Example** (Deduplicating with Equal Semantics)
-*
-* ```ts
-* import { Array, Equal } from "effect"
-*
-* const eq = Equal.asEquivalence<number>()
-* const result = Array.dedupeWith([1, 2, 2, 3, 1], eq)
-* console.log(result) // [1, 2, 3]
-* ```
-*
-* @see {@link equals} — the underlying comparison function
-* @category instances
-* @since 4.0.0
-*/
-const asEquivalence = () => equals;
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Redactable.js
-/**
-* Defines the symbol used to identify objects that implement the {@link Redactable}
-* protocol.
-*
-* **When to use**
-*
-* Use as the property key when implementing the `Redactable` protocol.
-*
-* **Details**
-*
-* Add a method under this key to make an object redactable. The method receives
-* the current `Context` and must return the replacement value. The symbol is
-* registered globally via `Symbol.for("~effect/Redactable")`, so it is
-* identical across multiple copies of the library at runtime.
-*
-* **Example** (Masking an API key)
-*
-* ```ts
-* import { Context, Redactable } from "effect"
-*
-* class ApiKey {
-*   constructor(readonly raw: string) {}
-*
-*   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
-*     return this.raw.slice(0, 4) + "..."
-*   }
-* }
-* ```
-*
-* @see {@link Redactable} for the interface this symbol belongs to
-* @see {@link isRedactable} to check whether a value has this symbol
-* @category symbols
-* @since 3.10.0
-*/
-const symbolRedactable = /*#__PURE__*/ Symbol.for("~effect/Redactable");
-/**
-* Type guard that checks whether a value implements the {@link Redactable}
-* interface.
-*
-* **When to use**
-*
-* Use to narrow an unknown value before calling redaction-specific helpers.
-*
-* @see {@link Redactable} for the interface being checked
-* @see {@link redact} to apply redaction if the value is redactable
-* @category guards
-* @since 3.10.0
-*/
-const isRedactable = (u) => hasProperty(u, symbolRedactable);
-/**
-* Returns a redacted value if it implements {@link Redactable}, otherwise returns it
-* unchanged.
-*
-* **When to use**
-*
-* Use as the general-purpose entry point for redaction when the input may
-* or may not implement the redaction protocol.
-*
-* **Details**
-*
-* This function calls {@link isRedactable} and, when it returns `true`,
-* delegates to {@link getRedacted}.
-*
-* **Gotchas**
-*
-* Redaction is not recursive. Nested redactable values inside the returned
-* object are not automatically redacted.
-*
-* @see {@link isRedactable} to check before redacting
-* @see {@link getRedacted} for the lower-level variant for known redactables
-* @category destructors
-* @since 3.10.0
-*/
-function redact(u) {
-	if (isRedactable(u)) return getRedacted(u);
-	return u;
-}
-/**
-* Returns the result of calling `[symbolRedactable]` on a value that is
-* already known to be {@link Redactable}.
-*
-* **When to use**
-*
-* Use when you need to read the redacted representation from a value already
-* verified as `Redactable`.
-*
-* **Details**
-*
-* This function reads the current fiber's `Context` from the global fiber
-* reference and passes it to the redaction method.
-*
-* **Gotchas**
-*
-* If no fiber is active, an empty `Context` is passed to the redaction method.
-*
-* @see {@link redact} for the higher-level variant that handles non-redactable values
-* @see {@link isRedactable} for the type guard to verify before calling this
-* @category destructors
-* @since 4.0.0
-*/
-function getRedacted(redactable) {
-	return redactable[symbolRedactable](globalThis["~effect/Fiber/currentFiber"]?.context ?? emptyContext$1);
-}
-/** @internal */
-const currentFiberTypeId = "~effect/Fiber/currentFiber";
-const emptyContext$1 = {
-	"~effect/Context": {},
-	mapUnsafe: /*#__PURE__*/ new Map(),
-	pipe() {
-		return pipeArguments(this, arguments);
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Formatter.js
-/**
-* Utilities for converting arbitrary JavaScript values into human-readable
-* strings, with support for circular references, redaction, and common JS
-* types that `JSON.stringify` handles poorly.
-*
-* Mental model:
-* - A `Formatter<Value, Format>` is a callable `(value: Value) => Format`.
-* - {@link format} is the general-purpose pretty-printer: it handles
-*   primitives, arrays, objects, `BigInt`, `Symbol`, `Date`, `RegExp`,
-*   `Set`, `Map`, class instances, and circular references.
-* - {@link formatJson} is a safe `JSON.stringify` wrapper that silently
-*   drops circular references and applies redaction.
-* - Both functions accept a `space` option for indentation control.
-*
-* Common tasks:
-* - Pretty-print any value for debugging / logging -> {@link format}
-* - Serialize to JSON safely (no circular throws) -> {@link formatJson}
-* - Format a single object property key -> {@link formatPropertyKey}
-* - Format a property path like `["a"]["b"]` -> {@link formatPath}
-* - Format a `Date` to ISO string safely -> {@link formatDate}
-*
-* Gotchas:
-* - {@link format} output is **not** valid JSON; use {@link formatJson} when
-*   you need parseable JSON.
-* - {@link format} calls `toString()` on objects by default; pass
-*   `ignoreToString: true` to disable.
-* - {@link formatJson} silently omits circular references (the key is
-*   dropped from the output).
-* - Values implementing the `Redactable` protocol are automatically
-*   redacted by both {@link format} and {@link formatJson}.
-*
-* **Example** (Pretty-print a value)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* const obj = { name: "Alice", scores: [100, 97] }
-* console.log(Formatter.format(obj))
-* // {"name":"Alice","scores":[100,97]}
-*
-* console.log(Formatter.format(obj, { space: 2 }))
-* // {
-* //   "name": "Alice",
-* //   "scores": [
-* //     100,
-* //     97
-* //   ]
-* // }
-* ```
-*
-* See also: {@link Formatter}, {@link format}, {@link formatJson}
-*
-* @since 4.0.0
-*/
-/**
-* Converts any JavaScript value into a human-readable string.
-*
-* **When to use**
-*
-* Use when you need to format arbitrary JavaScript values for debugging,
-* logging, or error messages.
-*
-* **Details**
-*
-* - Output is **not** valid JSON; use {@link formatJson} when you need
-*   parseable JSON.
-* - Handles `BigInt`, `Symbol`, `Set`, `Map`, `Date`, `RegExp`, and class
-*   instances that `JSON.stringify` cannot represent.
-* - Circular references are shown as `"[Circular]"` instead of throwing.
-* - Primitives: stringified naturally (`null`, `undefined`, `123`, `true`).
-*   Strings are JSON-quoted.
-* - Objects with a custom `toString` (not `Object.prototype.toString`):
-*   `toString()` is called unless `ignoreToString` is `true`.
-* - Errors with a `cause`: formatted as `"<message> (cause: <cause>)"`.
-* - Iterables (`Set`, `Map`, etc.): formatted as
-*   `ClassName([...elements])`.
-* - Class instances: wrapped as `ClassName({...})`.
-* - `Redactable` values are automatically redacted.
-* - Arrays/objects with 0–1 entries are inline; larger ones are
-*   pretty-printed when `space` is set.
-* - `space` — indentation unit (number of spaces, or a string like
-*   `"\t"`). Defaults to `0` (compact).
-* - `ignoreToString` — skip calling `toString()`. Defaults to `false`.
-*
-* **Example** (Compact output)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* console.log(Formatter.format({ a: 1, b: [2, 3] }))
-* // {"a":1,"b":[2,3]}
-* ```
-*
-* **Example** (Pretty-printed output)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* console.log(Formatter.format({ a: 1, b: [2, 3] }, { space: 2 }))
-* // {
-* //   "a": 1,
-* //   "b": [
-* //     2,
-* //     3
-* //   ]
-* // }
-* ```
-*
-* **Example** (Circular reference handling)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* const obj: any = { name: "loop" }
-* obj.self = obj
-* console.log(Formatter.format(obj))
-* // {"name":"loop","self":[Circular]}
-* ```
-*
-* @see {@link formatJson}
-* @see {@link Formatter}
-* @category formatting
-* @since 2.0.0
-*/
-function format(input, options) {
-	const space = options?.space ?? 0;
-	const seen = /* @__PURE__ */ new WeakSet();
-	const gap = !space ? "" : typeof space === "number" ? " ".repeat(space) : space;
-	const ind = (d) => gap.repeat(d);
-	const wrap = (v, body) => {
-		const ctor = v?.constructor;
-		return ctor && ctor !== Object.prototype.constructor && ctor.name ? `${ctor.name}(${body})` : body;
-	};
-	const ownKeys = (o) => {
-		try {
-			return Reflect.ownKeys(o);
-		} catch {
-			return ["[ownKeys threw]"];
-		}
-	};
-	function recur(v, d = 0) {
-		if (Array.isArray(v)) {
-			if (seen.has(v)) return CIRCULAR;
-			seen.add(v);
-			if (!gap || v.length <= 1) return `[${v.map((x) => recur(x, d)).join(",")}]`;
-			const inner = v.map((x) => recur(x, d + 1)).join(",\n" + ind(d + 1));
-			return `[\n${ind(d + 1)}${inner}\n${ind(d)}]`;
-		}
-		if (v instanceof Date) return formatDate(v);
-		if (!options?.ignoreToString && hasProperty(v, "toString") && typeof v["toString"] === "function" && v["toString"] !== Object.prototype.toString && v["toString"] !== Array.prototype.toString) {
-			const s = safeToString(v);
-			if (v instanceof Error && v.cause) return `${s} (cause: ${recur(v.cause, d)})`;
-			return s;
-		}
-		if (typeof v === "string") return JSON.stringify(v);
-		if (typeof v === "number" || v == null || typeof v === "boolean" || typeof v === "symbol") return String(v);
-		if (typeof v === "bigint") return String(v) + "n";
-		if (typeof v === "object" || typeof v === "function") {
-			if (seen.has(v)) return CIRCULAR;
-			seen.add(v);
-			if (symbolRedactable in v) return format(getRedacted(v));
-			if (Symbol.iterator in v) return `${v.constructor.name}(${recur(Array.from(v), d)})`;
-			const keys = ownKeys(v);
-			if (!gap || keys.length <= 1) return wrap(v, `{${keys.map((k) => `${formatPropertyKey(k)}:${recur(v[k], d)}`).join(",")}}`);
-			return wrap(v, `{\n${keys.map((k) => `${ind(d + 1)}${formatPropertyKey(k)}: ${recur(v[k], d + 1)}`).join(",\n")}\n${ind(d)}}`);
-		}
-		return String(v);
-	}
-	return recur(input, 0);
-}
-const CIRCULAR = "[Circular]";
-/**
-* @internal
-*/
-function formatPropertyKey(name) {
-	return typeof name === "string" ? JSON.stringify(name) : String(name);
-}
-/**
-* Formats an array of property keys as a bracket-notation path string.
-*
-* @internal
-*/
-function formatPath(path) {
-	return path.map((key) => `[${formatPropertyKey(key)}]`).join("");
-}
-/**
-* Formats a `Date` as an ISO 8601 string, returning `"Invalid Date"` for
-* invalid dates instead of throwing.
-*
-* @internal
-*/
-function formatDate(date) {
-	try {
-		return date.toISOString();
-	} catch {
-		return "Invalid Date";
-	}
-}
-function safeToString(input) {
-	try {
-		const s = input.toString();
-		return typeof s === "string" ? s : String(s);
-	} catch {
-		return "[toString threw]";
-	}
-}
-/**
-* Stringifies a value to JSON safely, silently dropping circular references.
-*
-* **When to use**
-*
-* Use when you need valid JSON output, unlike `format`, and the input may
-* contain circular references that should be silently omitted rather than
-* throwing a `TypeError`.
-*
-* **Details**
-*
-* Uses `JSON.stringify` internally with a replacer that tracks the current
-* object ancestry. Circular references are replaced with `undefined`, which
-* omits them from object output. `Redactable` values are automatically redacted
-* before serialization. Values not supported by JSON, such as `BigInt`,
-* `Symbol`, `undefined`, and functions, follow standard `JSON.stringify`
-* behavior. The `space` parameter controls indentation and defaults to `0`.
-*
-* **Example** (Compact JSON)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* console.log(Formatter.formatJson({ name: "Alice", age: 30 }))
-* // {"name":"Alice","age":30}
-* ```
-*
-* **Example** (Circular reference handling)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* const obj: any = { name: "test" }
-* obj.self = obj
-* console.log(Formatter.formatJson(obj))
-* // {"name":"test"}
-* ```
-*
-* **Example** (Pretty-printed JSON)
-*
-* ```ts
-* import { Formatter } from "effect"
-*
-* console.log(Formatter.formatJson({ name: "Alice", age: 30 }, { space: 2 }))
-* // {
-* //   "name": "Alice",
-* //   "age": 30
-* // }
-* ```
-*
-* @see {@link format}
-* @see {@link Formatter}
-* @category serialization
-* @since 4.0.0
-*/
-function formatJson(input, options) {
-	const ancestors = [];
-	return JSON.stringify(input, function(_key, value) {
-		const redacted = redact(value);
-		if (typeof redacted !== "object" || redacted === null) return redacted;
-		while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop();
-		if (ancestors.includes(redacted)) return;
-		ancestors.push(redacted);
-		return redacted;
-	}, options?.space);
-}
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Inspectable.js
-/**
-* Inspection protocol for stable string, JSON, and Node.js representations.
-*
-* This module is the small bridge used by Effect data types to explain
-* themselves in logs, REPLs, test failures, and JSON-like diagnostics. Implement
-* `Inspectable` or extend {@link Class} when a value should expose one
-* representation to `toString`, `toJSON`, and Node's `util.inspect`; use
-* {@link toJson} and {@link toStringUnknown} when formatting values supplied by
-* user code.
-*
-* ## Mental model
-*
-* Inspectable values choose their own JSON representation. {@link BaseProto}
-* and {@link Class} derive `toString()` from that representation with the
-* formatter and expose the same value through {@link NodeInspectSymbol}.
-* {@link toJson} is defensive: it calls zero-argument `toJSON` methods,
-* recurses through arrays, returns `"[toJSON threw]"` if a custom serializer
-* fails, and applies redaction to other values.
-*
-* ## Common tasks
-*
-* - Extend {@link Class} for classes that only need to define `toJSON`.
-* - Reuse {@link BaseProto} for object prototypes that should share standard
-*   inspection behavior.
-* - Format unknown diagnostic values with {@link toStringUnknown}.
-* - Implement {@link NodeInspectSymbol} when integrating directly with
-*   Node.js inspection.
-*
-* ## Gotchas
-*
-* `toJson` is meant for inspection, not canonical persistence. It catches
-* `toJSON` failures, does not deeply traverse arbitrary objects, and may
-* replace redactable values according to current redaction behavior. Keep
-* custom `toJSON` implementations side-effect free so logging and debugging do
-* not change program state.
-*
-* **Example** (Creating inspectable values)
-*
-* ```ts
-* import { Inspectable } from "effect"
-*
-* class User extends Inspectable.Class {
-*   constructor(
-*     readonly id: number,
-*     readonly name: string
-*   ) {
-*     super()
-*   }
-*
-*   toJSON() {
-*     return {
-*       _tag: "User",
-*       id: this.id,
-*       name: this.name,
-*     }
-*   }
-* }
-*
-* const user = new User(1, "Alice")
-* console.log(user.toString())
-* console.log(user[Inspectable.NodeInspectSymbol]())
-* ```
-*
-* @since 2.0.0
-*/
-/**
-* Defines the symbol used by Node.js for custom object inspection.
-*
-* **When to use**
-*
-* Use to implement Node.js custom inspection for a value.
-*
-* **Details**
-*
-* This symbol is recognized by Node.js's `util.inspect()` function and the REPL
-* for custom object representation. When an object has a method with this symbol,
-* it will be called to determine how the object should be displayed.
-*
-* **Example** (Defining custom Node inspection)
-*
-* ```ts
-* import { Inspectable } from "effect"
-*
-* class CustomObject {
-*   constructor(private value: string) {}
-*
-*   [Inspectable.NodeInspectSymbol]() {
-*     return `CustomObject(${this.value})`
-*   }
-* }
-*
-* const obj = new CustomObject("hello")
-* console.log(obj) // Displays: CustomObject(hello)
-* ```
-*
-* @category symbols
-* @since 2.0.0
-*/
-const NodeInspectSymbol = /*#__PURE__*/ Symbol.for("nodejs.util.inspect.custom");
-/**
-* Converts a value to a JSON-serializable representation safely.
-*
-* **When to use**
-*
-* Use when you need a safe, JSON-serializable representation of a value
-* without risking unhandled errors.
-*
-* **Details**
-*
-* This function attempts to extract JSON data from objects that implement the
-* `toJSON` method, recursively processes arrays, and handles errors gracefully.
-* For objects that don't have a `toJSON` method, it applies redaction to
-* protect sensitive information.
-*
-* @see {@link toStringUnknown} for converting unknown values to strings
-*
-* @category converting
-* @since 4.0.0
-*/
-const toJson = (input) => {
-	try {
-		if (hasProperty(input, "toJSON") && isFunction(input["toJSON"]) && input["toJSON"].length === 0) return input.toJSON();
-		else if (Array.isArray(input)) return input.map(toJson);
-	} catch {
-		return "[toJSON threw]";
-	}
-	return redact(input);
-};
-/**
-* Converts an unknown value to a string for diagnostics.
-*
-* **When to use**
-*
-* Use to produce a diagnostic string from a value whose runtime type is unknown.
-*
-* **Details**
-*
-* Strings are returned unchanged. Objects are formatted as JSON using the
-* provided whitespace setting when possible, and values that cannot be
-* formatted are converted with `String`.
-*
-* @category converting
-* @since 2.0.0
-*/
-const toStringUnknown = (u, whitespace = 2) => {
-	if (typeof u === "string") return u;
-	try {
-		return typeof u === "object" ? formatJson(u, { space: whitespace }) : String(u);
-	} catch {
-		return String(u);
-	}
-};
-/**
-* A base prototype object that implements the {@link Inspectable} interface.
-*
-* **When to use**
-*
-* Use as a prototype for plain objects that should share standard inspectable behavior.
-*
-* **Details**
-*
-* This object provides default implementations for the {@link Inspectable} methods.
-* It can be used as a prototype for objects that want to be inspectable,
-* or as a mixin to add inspection capabilities to existing objects.
-*
-* **Example** (Using the base inspectable prototype)
-*
-* ```ts
-* import { Inspectable } from "effect"
-*
-* // Use as prototype
-* const myObject = Object.create(Inspectable.BaseProto)
-* myObject.name = "example"
-* myObject.value = 42
-*
-* console.log(myObject.toString()) // Pretty printed representation
-*
-* // Or extend in a constructor
-* function MyClass(this: any, name: string) {
-*   this.name = name
-* }
-* MyClass.prototype = Object.create(Inspectable.BaseProto)
-* MyClass.prototype.constructor = MyClass
-* ```
-*
-* @category prototypes
-* @since 2.0.0
-*/
-const BaseProto = {
-	toJSON() {
-		return toJson(this);
-	},
-	[NodeInspectSymbol]() {
-		return this.toJSON();
-	},
-	toString() {
-		return format(this.toJSON());
-	}
-};
-/**
-* Provides an abstract base class that implements the Inspectable interface.
-*
-* **When to use**
-*
-* Use as a base class for inspectable objects that define their own JSON representation.
-*
-* **Details**
-*
-* This class provides a convenient way to create inspectable objects by extending it.
-* Subclasses only need to implement the `toJSON()` method, and they automatically
-* get proper `toString()` and Node.js inspection support.
-*
-* **Example** (Extending the inspectable base class)
-*
-* ```ts
-* import { Inspectable } from "effect"
-*
-* class User extends Inspectable.Class {
-*   constructor(
-*     public readonly id: number,
-*     public readonly name: string,
-*     public readonly email: string
-*   ) {
-*     super()
-*   }
-*
-*   toJSON() {
-*     return {
-*       _tag: "User",
-*       id: this.id,
-*       name: this.name,
-*       email: this.email
-*     }
-*   }
-* }
-*
-* const user = new User(1, "Alice", "alice@example.com")
-* console.log(user.toString()) // Pretty printed JSON with _tag, id, name, email
-* console.log(user) // In Node.js, shows the same formatted output
-* ```
-*
-* @category classes
-* @since 2.0.0
-*/
-var Class = class {
-	/**
-	* Node.js custom inspection method.
-	*
-	* **When to use**
-	*
-	* Use to expose the class JSON representation to Node.js inspection.
-	*
-	* @since 2.0.0
-	*/
-	[NodeInspectSymbol]() {
-		return this.toJSON();
-	}
-	/**
-	* Returns a formatted string representation of this object.
-	*
-	* **When to use**
-	*
-	* Use to format the class JSON representation as a string.
-	*
-	* @since 2.0.0
-	*/
-	toString() {
-		return format(this.toJSON());
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Utils.js
-/**
-* Yields its wrapped value exactly once through an `IterableIterator`.
-*
-* **When to use**
-*
-* Use to implement `[Symbol.iterator]()` on Effect-like types so they can be
-* `yield*`-ed inside generator functions, such as `Effect.gen` and
-* `Option.gen`.
-*
-* **Details**
-*
-* The first call to `next()` returns `{ value: self, done: false }`. Every
-* subsequent call returns `{ value: a, done: true }` where `a` is the argument
-* passed to `next()`. `[Symbol.iterator]()` returns a **new** `SingleShotGen`
-* wrapping the same value, so the outer type can be iterated multiple times.
-*
-* **Example** (Yielding a wrapped value in a generator)
-*
-* ```ts
-* import { Utils } from "effect"
-*
-* const gen = new Utils.SingleShotGen<string, number>("hello")
-*
-* // First call yields the wrapped value
-* console.log(gen.next(0))
-* // { value: "hello", done: false }
-*
-* // Second call signals completion with the provided value
-* console.log(gen.next(42))
-* // { value: 42, done: true }
-* ```
-*
-* @see {@link Gen} for the type-level signature that relies on `SingleShotGen`
-* @category constructors
-* @since 2.0.0
-*/
-var SingleShotGen = class SingleShotGen {
-	called = false;
-	self;
-	constructor(self) {
-		this.self = self;
-	}
-	/**
-	* Yields the stored value once, then completes with the value sent back in.
-	*
-	* **When to use**
-	*
-	* Use to advance a `SingleShotGen` through its single yield and completion
-	* step.
-	*
-	* @since 2.0.0
-	*/
-	next(a) {
-		return this.called ? {
-			value: a,
-			done: true
-		} : (this.called = true, {
-			value: this.self,
-			done: false
-		});
-	}
-	/**
-	* Creates a fresh single-shot iterator over the stored value.
-	*
-	* **When to use**
-	*
-	* Use to iterate the wrapped value again without reusing the consumed
-	* iterator state.
-	*
-	* @since 2.0.0
-	*/
-	[Symbol.iterator]() {
-		return new SingleShotGen(this.self);
-	}
-};
-const InternalTypeId = "~effect/Utils/internal";
-const standard = { [InternalTypeId]: (body) => {
-	return body();
-} };
-const forced = { [InternalTypeId]: (body) => {
-	try {
-		return body();
-	} finally {}
-} };
-/** @internal */
-const internalCall = /*#__PURE__*/ standard[InternalTypeId](() => (/* @__PURE__ */ new Error()).stack)?.includes(InternalTypeId) === true ? standard[InternalTypeId] : forced[InternalTypeId];
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/internal/core.js
-/** @internal */
-const EffectTypeId = `~effect/Effect`;
-/** @internal */
-const ExitTypeId = `~effect/Exit`;
-const effectVariance = {
-	_A: identity,
-	_E: identity,
-	_R: identity
-};
-/** @internal */
-const identifier = `${EffectTypeId}/identifier`;
-/** @internal */
-const args = `${EffectTypeId}/args`;
-/** @internal */
-const evaluate = `${EffectTypeId}/evaluate`;
-/** @internal */
-const contA = `${EffectTypeId}/successCont`;
-/** @internal */
-const contE = `${EffectTypeId}/failureCont`;
-/** @internal */
-const contAll = `${EffectTypeId}/ensureCont`;
-/** @internal */
-const Yield = /*#__PURE__*/ Symbol.for("effect/Effect/Yield");
-/** @internal */
-const PipeInspectableProto = {
-	pipe() {
-		return pipeArguments(this, arguments);
-	},
-	toJSON() {
-		return { ...this };
-	},
-	toString() {
-		return format(this.toJSON(), {
-			ignoreToString: true,
-			space: 2
-		});
-	},
-	[NodeInspectSymbol]() {
-		return this.toJSON();
-	}
-};
-/** @internal */
-const EffectProto = {
-	[EffectTypeId]: effectVariance,
-	...PipeInspectableProto,
-	[Symbol.iterator]() {
-		return new SingleShotGen(this);
-	},
-	toJSON() {
-		return {
-			_id: "Effect",
-			op: this[identifier],
-			...args in this ? { args: this[args] } : void 0
-		};
-	}
-};
-/** @internal */
-const isEffect = (u) => hasProperty(u, EffectTypeId);
-/** @internal */
-const isExit = (u) => hasProperty(u, ExitTypeId);
-/** @internal */
-const CauseTypeId = "~effect/Cause";
-/** @internal */
-const CauseReasonTypeId = "~effect/Cause/Reason";
-/** @internal */
-const isCause = (self) => hasProperty(self, CauseTypeId);
-/** @internal */
-const isCauseReason = (self) => hasProperty(self, CauseReasonTypeId);
-/** @internal */
-var CauseImpl = class {
-	[CauseTypeId];
-	reasons;
-	constructor(failures) {
-		this[CauseTypeId] = CauseTypeId;
-		this.reasons = failures;
-	}
-	pipe() {
-		return pipeArguments(this, arguments);
-	}
-	toJSON() {
-		return {
-			_id: "Cause",
-			failures: this.reasons.map((f) => f.toJSON())
-		};
-	}
-	toString() {
-		return `Cause(${format(this.reasons)})`;
-	}
-	[NodeInspectSymbol]() {
-		return this.toJSON();
-	}
-	[symbol](that) {
-		return isCause(that) && this.reasons.length === that.reasons.length && this.reasons.every((e, i) => equals(e, that.reasons[i]));
-	}
-	[symbol$1]() {
-		return array(this.reasons);
-	}
-};
-const annotationsMap = /*#__PURE__*/ new WeakMap();
-/** @internal */
-var ReasonBase = class {
-	[CauseReasonTypeId];
-	annotations;
-	_tag;
-	constructor(_tag, annotations, originalError) {
-		this[CauseReasonTypeId] = CauseReasonTypeId;
-		this._tag = _tag;
-		if (annotations !== constEmptyAnnotations && typeof originalError === "object" && originalError !== null && annotations.size > 0) {
-			const prevAnnotations = annotationsMap.get(originalError);
-			if (prevAnnotations) annotations = new Map([...prevAnnotations, ...annotations]);
-			annotationsMap.set(originalError, annotations);
-		}
-		this.annotations = annotations;
-	}
-	annotate(annotations, options) {
-		if (annotations.mapUnsafe.size === 0) return this;
-		const newAnnotations = new Map(this.annotations);
-		annotations.mapUnsafe.forEach((value, key) => {
-			if (options?.overwrite !== true && newAnnotations.has(key)) return;
-			newAnnotations.set(key, value);
-		});
-		const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-		self.annotations = newAnnotations;
-		return self;
-	}
-	pipe() {
-		return pipeArguments(this, arguments);
-	}
-	toString() {
-		return format(this);
-	}
-	[NodeInspectSymbol]() {
-		return this.toString();
-	}
-};
-/** @internal */
-const constEmptyAnnotations = /*#__PURE__*/ new Map();
-/** @internal */
-var Fail = class extends ReasonBase {
-	error;
-	constructor(error, annotations = constEmptyAnnotations) {
-		super("Fail", annotations, error);
-		this.error = error;
-	}
-	toString() {
-		return `Fail(${format(this.error)})`;
-	}
-	toJSON() {
-		return {
-			_tag: "Fail",
-			error: this.error
-		};
-	}
-	[symbol](that) {
-		return isFailReason(that) && equals(this.error, that.error) && equals(this.annotations, that.annotations);
-	}
-	[symbol$1]() {
-		return combine(string(this._tag))(combine(hash(this.error))(hash(this.annotations)));
-	}
-};
-/** @internal */
-const causeFromReasons = (reasons) => new CauseImpl(reasons);
-/** @internal */
-const causeEmpty = /*#__PURE__*/ new CauseImpl([]);
-/** @internal */
-const causeFail = (error) => new CauseImpl([new Fail(error)]);
-/** @internal */
-var Die = class extends ReasonBase {
-	defect;
-	constructor(defect, annotations = constEmptyAnnotations) {
-		super("Die", annotations, defect);
-		this.defect = defect;
-	}
-	toString() {
-		return `Die(${format(this.defect)})`;
-	}
-	toJSON() {
-		return {
-			_tag: "Die",
-			defect: this.defect
-		};
-	}
-	[symbol](that) {
-		return isDieReason(that) && equals(this.defect, that.defect) && equals(this.annotations, that.annotations);
-	}
-	[symbol$1]() {
-		return combine(string(this._tag))(combine(hash(this.defect))(hash(this.annotations)));
-	}
-};
-/** @internal */
-const causeDie = (defect) => new CauseImpl([new Die(defect)]);
-/** @internal */
-const causeAnnotate = /*#__PURE__*/ dual((args) => isCause(args[0]), (self, annotations, options) => {
-	if (annotations.mapUnsafe.size === 0) return self;
-	return new CauseImpl(self.reasons.map((f) => f.annotate(annotations, options)));
-});
-/** @internal */
-const isFailReason = (self) => self._tag === "Fail";
-/** @internal */
-const isDieReason = (self) => self._tag === "Die";
-/** @internal */
-const isInterruptReason = (self) => self._tag === "Interrupt";
-function defaultEvaluate(_fiber) {
-	return exitDie(`Effect.evaluate: Not implemented`);
-}
-/** @internal */
-const makePrimitiveProto = (options) => ({
-	...EffectProto,
-	[identifier]: options.op,
-	[evaluate]: options[evaluate] ?? defaultEvaluate,
-	[contA]: options[contA],
-	[contE]: options[contE],
-	[contAll]: options[contAll]
-});
-/** @internal */
-const makePrimitive = (options) => {
-	const Proto = makePrimitiveProto(options);
-	return function() {
-		const self = Object.create(Proto);
-		self[args] = options.single === false ? arguments : arguments[0];
-		return self;
-	};
-};
-/** @internal */
-const makeExit = (options) => {
-	const Proto = {
-		...makePrimitiveProto(options),
-		[ExitTypeId]: ExitTypeId,
-		_tag: options.op,
-		get [options.prop]() {
-			return this[args];
-		},
-		toString() {
-			return `${options.op}(${format(this[args])})`;
-		},
-		toJSON() {
-			return {
-				_id: "Exit",
-				_tag: options.op,
-				[options.prop]: this[args]
-			};
-		},
-		[symbol](that) {
-			return isExit(that) && that._tag === this._tag && equals(this[args], that[args]);
-		},
-		[symbol$1]() {
-			return combine(string(options.op), hash(this[args]));
-		}
-	};
-	return function(value) {
-		const self = Object.create(Proto);
-		self[args] = value;
-		return self;
-	};
-};
-/** @internal */
-const exitSucceed = /*#__PURE__*/ makeExit({
-	op: "Success",
-	prop: "value",
-	[evaluate](fiber) {
-		const cont = fiber.getCont(contA);
-		return cont ? cont[contA](this[args], fiber, this) : fiber.yieldWith(this);
-	}
-});
-/** @internal */
-const StackTraceKey = { key: "effect/Cause/StackTrace" };
-/** @internal */
-const InterruptorStackTrace = { key: "effect/Cause/InterruptorStackTrace" };
-/** @internal */
-const exitFailCause = /*#__PURE__*/ makeExit({
-	op: "Failure",
-	prop: "cause",
-	[evaluate](fiber) {
-		let cause = this[args];
-		let annotated = false;
-		if (fiber.currentStackFrame) {
-			cause = causeAnnotate(cause, { mapUnsafe: new Map([[StackTraceKey.key, fiber.currentStackFrame]]) });
-			annotated = true;
-		}
-		let cont = fiber.getCont(contE);
-		while (fiber.interruptible && fiber._interruptedCause && cont) cont = fiber.getCont(contE);
-		return cont ? cont[contE](cause, fiber, annotated ? void 0 : this) : fiber.yieldWith(annotated ? this : exitFailCause(cause));
-	}
-});
-/** @internal */
-const exitFail = (e) => exitFailCause(causeFail(e));
-/** @internal */
-const exitDie = (defect) => exitFailCause(causeDie(defect));
-/** @internal */
-const withFiber = /*#__PURE__*/ makePrimitive({
-	op: "WithFiber",
-	[evaluate](fiber) {
-		return this[args](fiber);
-	}
-});
-/** @internal */
-const YieldableError = /*#__PURE__*/ function() {
-	class YieldableError extends globalThis.Error {}
-	const proto = /*#__PURE__*/ makePrimitiveProto({
-		op: "YieldableError",
-		[evaluate]() {
-			return exitFail(this);
-		}
-	});
-	delete proto.toString;
-	Object.assign(YieldableError.prototype, proto);
-	return YieldableError;
-}();
-/** @internal */
-const Error$1 = /*#__PURE__*/ function() {
-	const plainArgsSymbol = /*#__PURE__*/ Symbol.for("effect/Data/Error/plainArgs");
-	return class Base extends YieldableError {
-		constructor(args) {
-			super(args?.message, args?.cause ? { cause: args.cause } : void 0);
-			if (args) {
-				Object.assign(this, args);
-				Object.defineProperty(this, plainArgsSymbol, {
-					value: args,
-					enumerable: false
-				});
-			}
-		}
-		toJSON() {
-			return {
-				...this[plainArgsSymbol],
-				...this
-			};
-		}
-	};
-}();
-/** @internal */
-const TaggedError = (tag) => {
-	class Base extends Error$1 {
-		_tag = tag;
-	}
-	Base.prototype.name = tag;
-	return Base;
-};
-TaggedError("NoSuchElementError");
-/** @internal */
-const DoneTypeId = "~effect/Cause/Done";
-/** @internal */
-const isDone = (u) => hasProperty(u, DoneTypeId);
-const DoneVoid = {
-	[DoneTypeId]: DoneTypeId,
-	_tag: "Done",
-	value: void 0
-};
-/** @internal */
-const Done = (value) => {
-	if (value === void 0) return DoneVoid;
-	return {
-		[DoneTypeId]: DoneTypeId,
-		_tag: "Done",
-		value
-	};
-};
-const doneVoid = /*#__PURE__*/ exitFail(DoneVoid);
-/** @internal */
-const done = (value) => {
-	if (value === void 0) return doneVoid;
-	return exitFail(Done(value));
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Effectable.js
-/**
-* Create a low-level `Effect` prototype.
-*
-* **When to use**
-*
-* Use when you need to create a custom Effect-like value without extending a
-* class, by providing a label and an evaluate function that receives the
-* current fiber.
-*
-* **Details**
-*
-* When the effect is evaluated, it calls `evaluate` with the current fiber.
-*
-* @see {@link Class} for a class-based approach to defining custom Effect values
-*
-* @category prototypes
-* @since 4.0.0
-*/
-const Prototype = (options) => makePrimitiveProto({
-	op: options.label,
-	[evaluate]: options.evaluate
-});
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Equivalence.js
-/**
-* Creates a custom equivalence relation with an optimized reference equality check.
-*
-* **When to use**
-*
-* Use when you need an equality rule that the built-in instances and input
-* mapping helpers cannot express, and you can provide a law-abiding comparison.
-*
-* **Details**
-*
-* The returned equivalence first checks reference equality (`===`) for
-* performance. If the values are not the same reference, it falls back to the
-* provided equivalence function, which must satisfy reflexive, symmetric, and
-* transitive properties.
-*
-* **Example** (Case-insensitive string equivalence)
-*
-* ```ts
-* import { Equivalence } from "effect"
-*
-* const caseInsensitive = Equivalence.make<string>((a, b) =>
-*   a.toLowerCase() === b.toLowerCase()
-* )
-*
-* console.log(caseInsensitive("Hello", "HELLO")) // true
-* console.log(caseInsensitive("foo", "bar")) // false
-*
-* // Same reference optimization
-* const str = "test"
-* console.log(caseInsensitive(str, str)) // true (fast path)
-* ```
-*
-* **Example** (Numeric tolerance equivalence)
-*
-* ```ts
-* import { Equivalence } from "effect"
-*
-* const tolerance = Equivalence.make<number>((a, b) => Math.abs(a - b) < 0.0001)
-*
-* console.log(tolerance(1.0, 1.001)) // false
-* console.log(tolerance(1.0, 1.00001)) // true
-* ```
-*
-* @see {@link strictEqual}
-* @see {@link mapInput}
-* @category constructors
-* @since 2.0.0
-*/
-const make$2 = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
-const isStrictEquivalent = (x, y) => x === y;
-/**
-* Creates an equivalence relation that uses strict equality (`===`) to compare values.
-*
-* **When to use**
-*
-* Use when you need strict equality (`===`) as the comparison.
-*
-* **Details**
-*
-* Uses JavaScript's strict equality operator (`===`). Primitives compare by
-* value. Objects compare by reference, so only the same object instance is
-* equivalent. Use this as a building block for more complex equivalences via
-* `mapInput` or `combine`.
-*
-* **Gotchas**
-*
-* `NaN !== NaN`, so `NaN` values are never considered equivalent.
-*
-* **Example** (Primitive types)
-*
-* ```ts
-* import { Equivalence } from "effect"
-*
-* 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"
-*
-* const obj = { value: 42 }
-* const strictObjEq = Equivalence.strictEqual<typeof obj>()
-*
-* console.log(strictObjEq(obj, obj)) // true
-* console.log(strictObjEq(obj, { value: 42 })) // false (different references)
-* ```
-*
-* @see {@link make}
-* @see `Equal` for structural equality
-* @category constructors
-* @since 4.0.0
-*/
-const strictEqual = () => isStrictEquivalent;
-/**
-* Creates an equivalence for tuples with heterogeneous element types.
-*
-* **When to use**
-*
-* Use when you need an `Equivalence` for fixed-length tuples with per-position
-* equivalences.
-*
-* **Details**
-*
-* Tuples must have the same length; different lengths are never equivalent.
-* Each equivalence is applied to the corresponding element position. The result
-* returns `true` only if all elements are equivalent according to their
-* respective equivalences, and it also satisfies reflexive, symmetric, and
-* transitive properties.
-*
-* **Example** (Homogeneous tuple equivalence)
-*
-* ```ts
-* import { Equivalence } from "effect"
-*
-* const stringTupleEq = Equivalence.Tuple([
-*   Equivalence.strictEqual<string>(),
-*   Equivalence.strictEqual<string>(),
-*   Equivalence.strictEqual<string>()
-* ])
-*
-* const tuple1 = ["hello", "world", "test"] as const
-* const tuple2 = ["hello", "world", "test"] as const
-* const tuple3 = ["hello", "world", "different"] as const
-*
-* console.log(stringTupleEq(tuple1, tuple2)) // true
-* console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
-* ```
-*
-* **Example** (Tuple with custom equivalences)
-*
-* ```ts
-* import { Equivalence } from "effect"
-*
-* const caseInsensitive = Equivalence.mapInput(
-*   Equivalence.strictEqual<string>(),
-*   (s: string) => s.toLowerCase()
-* )
-*
-* const customTupleEq = Equivalence.Tuple([
-*   caseInsensitive,
-*   caseInsensitive,
-*   caseInsensitive
-* ])
-*
-* console.log(
-*   customTupleEq(["Hello", "World", "Test"], ["HELLO", "WORLD", "TEST"])
-* ) // true
-* ```
-*
-* @category combinators
-* @since 4.0.0
-*/
-function Tuple(elements) {
-	return make$2((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;
-		return true;
-	});
-}
-/**
-* @since 4.0.0
-*/
-function Array_(item) {
-	return make$2((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;
-		return true;
-	});
-}
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/internal/option.js
-/**
-* @since 2.0.0
-*/
-const TypeId$2 = "~effect/data/Option";
-const CommonProto$1 = {
-	[TypeId$2]: { _A: (_) => _ },
-	...PipeInspectableProto,
-	[Symbol.iterator]() {
-		return new SingleShotGen(this);
-	}
-};
-const SomeProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto$1), {
-	_tag: "Some",
-	_op: "Some",
-	[symbol](that) {
-		return isOption$1(that) && isSome$1(that) && equals(this.value, that.value);
-	},
-	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.value));
-	},
-	toString() {
-		return `some(${format(this.value)})`;
-	},
-	toJSON() {
-		return {
-			_id: "Option",
-			_tag: this._tag,
-			value: toJson(this.value)
-		};
-	}
-});
-Object.defineProperty(SomeProto, "valueOrUndefined", { get() {
-	return this.value;
-} });
-const NoneHash = /*#__PURE__*/ hash("None");
-const NoneProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto$1), {
-	_tag: "None",
-	_op: "None",
-	valueOrUndefined: void 0,
-	[symbol](that) {
-		return isOption$1(that) && isNone$1(that);
-	},
-	[symbol$1]() {
-		return NoneHash;
-	},
-	toString() {
-		return `none()`;
-	},
-	toJSON() {
-		return {
-			_id: "Option",
-			_tag: this._tag
-		};
-	}
-});
-/** @internal */
-const isOption$1 = (input) => hasProperty(input, TypeId$2);
-/** @internal */
-const isNone$1 = (fa) => fa._tag === "None";
-/** @internal */
-const isSome$1 = (fa) => fa._tag === "Some";
-/** @internal */
-const none$1 = /*#__PURE__*/ Object.create(NoneProto);
-/** @internal */
-const some$1 = (value) => {
-	const a = Object.create(SomeProto);
-	a.value = value;
-	return a;
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/internal/result.js
-const TypeId$1 = "~effect/data/Result";
-const CommonProto = {
-	[TypeId$1]: {
-		/* v8 ignore next 2 */
-		_A: (_) => _,
-		_E: (_) => _
-	},
-	...PipeInspectableProto,
-	[Symbol.iterator]() {
-		return new SingleShotGen(this);
-	}
-};
-const SuccessProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
-	_tag: "Success",
-	_op: "Success",
-	[symbol](that) {
-		return isResult(that) && isSuccess(that) && equals(this.success, that.success);
-	},
-	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.success));
-	},
-	toString() {
-		return `success(${format(this.success)})`;
-	},
-	toJSON() {
-		return {
-			_id: "Result",
-			_tag: this._tag,
-			value: toJson(this.success)
-		};
-	}
-});
-const FailureProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
-	_tag: "Failure",
-	_op: "Failure",
-	[symbol](that) {
-		return isResult(that) && isFailure(that) && equals(this.failure, that.failure);
-	},
-	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.failure));
-	},
-	toString() {
-		return `failure(${format(this.failure)})`;
-	},
-	toJSON() {
-		return {
-			_id: "Result",
-			_tag: this._tag,
-			failure: toJson(this.failure)
-		};
-	}
-});
-/** @internal */
-const isResult = (input) => hasProperty(input, TypeId$1);
-/** @internal */
-const isFailure = (result) => result._tag === "Failure";
-/** @internal */
-const isSuccess = (result) => result._tag === "Success";
-/** @internal */
-const fail = (failure) => {
-	const a = Object.create(FailureProto);
-	a.failure = failure;
-	return a;
-};
-/** @internal */
-const succeed = (success) => {
-	const a = Object.create(SuccessProto);
-	a.success = success;
-	return a;
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Order.js
-/**
-* The `Order` module defines total orderings: pure comparison functions that
-* decide whether one value is less than, equal to, or greater than another. An
-* `Order<A>` returns a normalized {@link Ordering} (`-1`, `0`, or `1`), making
-* it suitable for sorting, finding minimum and maximum values, range checks, and
-* building ordered data structures.
-*
-* **Mental model**
-*
-* - An {@link Order} is a comparator with laws: totality, antisymmetry, and
-*   transitivity. If those laws do not hold, sorting and range operations can
-*   produce surprising results.
-* - `-1` means the left value comes before the right value, `0` means they are
-*   equal for this ordering, and `1` means the left value comes after the right
-*   value.
-* - Primitive orders such as {@link Number}, {@link String}, {@link Boolean},
-*   {@link BigInt}, and {@link Date} are building blocks.
-* - Use {@link mapInput} to compare larger values by a field or derived key.
-* - Use {@link combine} or {@link combineAll} for tie-breaking, where the first
-*   non-zero comparison result wins.
-*
-* **Common tasks**
-*
-* - Create a custom order from a comparison function with {@link make}.
-* - Sort or compare using built-in orders such as {@link Number} and
-*   {@link String}.
-* - Compare records and tuples with {@link Struct} and {@link Tuple}.
-* - Compare arrays lexicographically with {@link Array}.
-* - Convert an order into predicates with {@link isLessThan},
-*   {@link isGreaterThan}, {@link isLessThanOrEqualTo}, and
-*   {@link isGreaterThanOrEqualTo}.
-* - Select boundaries with {@link min}, {@link max}, {@link clamp}, and
-*   {@link isBetween}.
-*
-* **Gotchas**
-*
-* - {@link make} returns `0` immediately when `self === that`; the custom
-*   comparison function is not called for identical references.
-* - {@link Number} treats all `NaN` values as equal to each other and less than
-*   every non-`NaN` number.
-* - {@link Array} compares elements first and length second. {@link Tuple}
-*   compares a fixed number of positions.
-* - {@link Struct} compares fields in the key order of the object passed to it,
-*   so put the highest-priority fields first.
-* - {@link min} and {@link max} return the first argument when two values
-*   compare as equal.
-*
-* **Example** (Sorting by multiple fields)
-*
-* ```ts
-* import { Array, Order } from "effect"
-*
-* interface User {
-*   readonly name: string
-*   readonly age: number
-* }
-*
-* const byAge = Order.mapInput(Order.Number, (user: User) => user.age)
-* const byName = Order.mapInput(Order.String, (user: User) => user.name)
-* const byAgeThenName = Order.combine(byAge, byName)
-*
-* const users = [
-*   { name: "Charlie", age: 30 },
-*   { name: "Bob", age: 25 },
-*   { name: "Alice", age: 30 }
-* ]
-*
-* const sorted = Array.sort(users, byAgeThenName)
-* console.log(sorted.map((user) => user.name))
-* // ["Bob", "Alice", "Charlie"]
-* ```
-*
-* **See also**
-*
-* - {@link Ordering} for the normalized comparison result type.
-* - `Equivalence` for equality without less-than or greater-than.
-* - {@link Reducer} for combining orders with reducer-style APIs.
-*
-* @since 2.0.0
-*/
-/**
-* Creates a new `Order` instance from a comparison function.
-*
-* **When to use**
-*
-* Use when you need a sorting rule not covered by the built-in orders or input
-* mapping helpers, and you can provide a total comparison.
-*
-* **Details**
-*
-* Uses reference equality (`===`) as a shortcut: if `self === that`, it returns
-* `0` without calling the comparison function. The comparison function should
-* return `-1`, `0`, or `1`, and the returned order satisfies total ordering
-* laws when the comparison function does.
-*
-* **Example** (Creating an Order)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const byAge = Order.make<{ name: string; age: number }>((self, that) => {
-*   if (self.age < that.age) return -1
-*   if (self.age > that.age) return 1
-*   return 0
-* })
-*
-* 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 {@link mapInput} to transform an order by mapping the input type
-* @see {@link combine} to combine multiple orders
-* @category constructors
-* @since 2.0.0
-*/
-function make$1(compare) {
-	return (self, that) => self === that ? 0 : compare(self, that);
-}
-/**
-* Order instance for numbers that compares them numerically.
-*
-* **When to use**
-*
-* Use when you need numeric ordering for numbers.
-*
-* **Details**
-*
-* `0` is considered equal to `-0`. All `NaN` values are considered equal to
-* each other, and any `NaN` is considered less than any non-`NaN` number. All
-* other values use standard numeric comparison.
-*
-* **Example** (Number Ordering)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* console.log(Order.Number(1, 1)) // 0
-* console.log(Order.Number(1, 2)) // -1
-* console.log(Order.Number(2, 1)) // 1
-*
-* console.log(Order.Number(0, -0)) // 0
-* console.log(Order.Number(NaN, 1)) // -1
-* ```
-*
-* @see {@link mapInput} to compare objects by a number property
-* @see {@link BigInt} for bigint comparisons
-* @category instances
-* @since 4.0.0
-*/
-const Number$1 = /*#__PURE__*/ make$1((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;
-});
-/**
-* Order instance for bigints that compares them numerically.
-*
-* **When to use**
-*
-* Use when you need numeric ordering for `bigint` values.
-*
-* **Details**
-*
-* Uses standard numeric comparison for bigint values and handles arbitrarily
-* large integers.
-*
-* **Example** (BigInt Ordering)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* console.log(Order.BigInt(1n, 2n)) // -1
-* console.log(Order.BigInt(2n, 1n)) // 1
-* console.log(Order.BigInt(1n, 1n)) // 0
-* ```
-*
-* @see {@link Number} for regular number comparisons
-* @see {@link mapInput} to compare objects by a bigint property
-* @category instances
-* @since 4.0.0
-*/
-const BigInt = /*#__PURE__*/ make$1((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`.
-*
-* **When to use**
-*
-* Use when you need to adapt an `Order` to compare a larger value by one
-* derived property.
-*
-* **Details**
-*
-* Applies the mapping function to both values before comparison. The mapping
-* function should be pure and not have side effects so the ordering properties
-* of the original order are preserved.
-*
-* **Example** (Mapping Input)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const byLength = Order.mapInput(Order.Number, (s: string) => s.length)
-*
-* console.log(byLength("a", "bb")) // -1
-* console.log(byLength("bb", "a")) // 1
-* console.log(byLength("aa", "bb")) // 0
-* ```
-*
-* @see {@link combine} to combine mapped orders for multi-criteria comparison
-* @see {@link Struct} to create orders for structs with multiple fields
-* @category mapping
-* @since 2.0.0
-*/
-const mapInput = /*#__PURE__*/ dual(2, (self, f) => make$1((b1, b2) => self(f(b1), f(b2))));
-/**
-* Order instance for `Date` objects that compares them chronologically by their timestamp.
-*
-* **When to use**
-*
-* Use when you need chronological ordering for JavaScript date values.
-*
-* **Details**
-*
-* Compares dates by their underlying timestamp in milliseconds since the epoch.
-* Earlier dates are less than later dates. Invalid dates are compared through
-* their `getTime()` result.
-*
-* **Example** (Date Ordering)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const date1 = new Date("2023-01-01")
-* const date2 = new Date("2023-01-02")
-*
-* console.log(Order.Date(date1, date2)) // -1
-* console.log(Order.Date(date2, date1)) // 1
-* console.log(Order.Date(date1, date1)) // 0
-* ```
-*
-* @see {@link mapInput} to compare objects by a date property
-* @category instances
-* @since 2.0.0
-*/
-const Date$1 = /*#__PURE__*/ mapInput(Number$1, (date) => date.getTime());
-/**
-* Checks whether one value is strictly less than another according to the given order.
-*
-* **When to use**
-*
-* Use when you need a boolean less-than predicate using an `Order`.
-*
-* **Details**
-*
-* Returns `true` if the order returns `-1`, meaning the first value is less
-* than the second. Equal or greater values return `false`.
-*
-* **Example** (Less Than)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const isLessThanNumber = Order.isLessThan(Order.Number)
-*
-* console.log(isLessThanNumber(1, 2)) // true
-* console.log(isLessThanNumber(2, 1)) // false
-* console.log(isLessThanNumber(1, 1)) // false
-* ```
-*
-* @see {@link isLessThanOrEqualTo} for non-strict less than or equal
-* @see {@link isGreaterThan} for strict greater than
-* @category predicates
-* @since 4.0.0
-*/
-const isLessThan = (O) => dual(2, (self, that) => O(self, that) === -1);
-/**
-* Checks whether one value is strictly greater than another according to the given order.
-*
-* **When to use**
-*
-* Use when you need a boolean greater-than predicate using an `Order`.
-*
-* **Details**
-*
-* Returns `true` if the order returns `1`, meaning the first value is greater
-* than the second. Equal or lesser values return `false`.
-*
-* **Example** (Greater Than)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const isGreaterThanNumber = Order.isGreaterThan(Order.Number)
-*
-* console.log(isGreaterThanNumber(2, 1)) // true
-* console.log(isGreaterThanNumber(1, 2)) // false
-* console.log(isGreaterThanNumber(1, 1)) // false
-* ```
-*
-* @see {@link isGreaterThanOrEqualTo} for non-strict greater than or equal
-* @see {@link isLessThan} for strict less than
-* @category predicates
-* @since 4.0.0
-*/
-const isGreaterThan = (O) => dual(2, (self, that) => O(self, that) === 1);
-/**
-* Checks whether one value is less than or equal to another according to the given order.
-*
-* **When to use**
-*
-* Use when you need a boolean less-than-or-equal predicate using an `Order`.
-*
-* **Details**
-*
-* Returns `true` if the order returns `-1` or `0`, and returns `false` only if
-* the order returns `1`.
-*
-* **Example** (Less Than Or Equal)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const isLessThanOrEqualToNumber = Order.isLessThanOrEqualTo(Order.Number)
-*
-* console.log(isLessThanOrEqualToNumber(1, 2)) // true
-* console.log(isLessThanOrEqualToNumber(1, 1)) // true
-* console.log(isLessThanOrEqualToNumber(2, 1)) // false
-* ```
-*
-* @see {@link isLessThan} for strict less than
-* @see {@link isGreaterThan} for strict greater than
-* @category predicates
-* @since 4.0.0
-*/
-const isLessThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== 1);
-/**
-* Checks whether one value is greater than or equal to another according to the given order.
-*
-* **When to use**
-*
-* Use when you need a boolean greater-than-or-equal predicate using an
-* `Order`.
-*
-* **Details**
-*
-* Returns `true` if the order returns `1` or `0`, and returns `false` only if
-* the order returns `-1`.
-*
-* **Example** (Greater Than Or Equal)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const isGreaterThanOrEqualToNumber = Order.isGreaterThanOrEqualTo(Order.Number)
-*
-* console.log(isGreaterThanOrEqualToNumber(2, 1)) // true
-* console.log(isGreaterThanOrEqualToNumber(1, 1)) // true
-* console.log(isGreaterThanOrEqualToNumber(1, 2)) // false
-* ```
-*
-* @see {@link isGreaterThan} for strict greater than
-* @see {@link isLessThanOrEqualTo} for less than or equal
-* @category predicates
-* @since 4.0.0
-*/
-const isGreaterThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== -1);
-/**
-* Returns the minimum of two values according to the given order. If they are equal, returns the first argument.
-*
-* **When to use**
-*
-* Use when you need to select the smaller of two values according to an
-* `Order`.
-*
-* **Details**
-*
-* Returns the value that compares as less than or equal to the other value. If
-* values are equal, the first argument is returned.
-*
-* **Example** (Minimum Value)
-*
-* ```ts
-* import { Order } from "effect"
-*
-* const minNumber = Order.min(Order.Number)
-*
-* console.log(minNumber(1, 2)) // 1
-* console.log(minNumber(2, 1)) // 1
-* console.log(minNumber(1, 1)) // 1
-* ```
-*
-* @see {@link max} for the maximum of two values
-* @see {@link clamp} to clamp a value between min and max
-* @category comparisons
-* @since 2.0.0
-*/
-const min = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Option.js
-/**
-* Creates an `Option` representing the absence of a value.
-*
-* **When to use**
-*
-* Use to represent a missing or uninitialized value, such as returning "no
-* result" from a function.
-*
-* **Details**
-*
-* - Returns `Option<never>`, which is a subtype of `Option<A>` for any `A`
-* - Always returns the same singleton instance
-*
-* **Example** (Creating an empty Option)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* //      ┌─── Option<never>
-* //      ▼
-* const noValue = Option.none()
-*
-* console.log(noValue)
-* // Output: { _id: 'Option', _tag: 'None' }
-* ```
-*
-* @see {@link some} for the opposite operation.
-*
-* @category constructors
-* @since 2.0.0
-*/
-const none = () => none$1;
-/**
-* Wraps the given value into an `Option` to represent its presence.
-*
-* **When to use**
-*
-* Use to wrap a known present value as `Option`
-* - Returning a successful result from a partial function
-*
-* **Details**
-*
-* - Always returns `Some<A>`
-* - Does not filter `null` or `undefined`; use {@link fromNullishOr} for that
-*
-* **Example** (Wrapping a value)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* //      ┌─── Option<number>
-* //      ▼
-* const value = Option.some(1)
-*
-* console.log(value)
-* // Output: { _id: 'Option', _tag: 'Some', value: 1 }
-* ```
-*
-* @see {@link none} for the opposite operation.
-*
-* @category constructors
-* @since 2.0.0
-*/
-const some = some$1;
-/**
-* Determines whether the given value is an `Option`.
-*
-* **When to use**
-*
-* Use to validate unknown values at runtime boundaries, such as type-narrowing
-* in union types.
-*
-* **Details**
-*
-* - Returns `true` for both `Some` and `None` instances
-* - Acts as a type guard, narrowing the input to `Option<unknown>`
-*
-* **Example** (Checking if a value is an Option)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.isOption(Option.some(1)))
-* // Output: true
-*
-* console.log(Option.isOption(Option.none()))
-* // Output: true
-*
-* console.log(Option.isOption({}))
-* // Output: false
-* ```
-*
-* @see {@link isNone} to check for `None` specifically
-* @see {@link isSome} to check for `Some` specifically
-*
-* @category guards
-* @since 2.0.0
-*/
-const isOption = isOption$1;
-/**
-* Checks whether an `Option` is `None` (absent).
-*
-* **When to use**
-*
-* Use when you need to branch on an absent `Option` before accessing `.value`.
-*
-* **Details**
-*
-* - Acts as a type guard, narrowing to `None<A>`
-*
-* **Example** (Checking for None)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.isNone(Option.some(1)))
-* // Output: false
-*
-* console.log(Option.isNone(Option.none()))
-* // Output: true
-* ```
-*
-* @see {@link isSome} for the opposite check.
-*
-* @category guards
-* @since 2.0.0
-*/
-const isNone = isNone$1;
-/**
-* Checks whether an `Option` contains a value (`Some`).
-*
-* **When to use**
-*
-* Use when you need to branch on a present `Option` before accessing `.value`.
-*
-* **Details**
-*
-* - Acts as a type guard, narrowing to `Some<A>`
-*
-* **Example** (Checking for Some)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.isSome(Option.some(1)))
-* // Output: true
-*
-* console.log(Option.isSome(Option.none()))
-* // Output: false
-* ```
-*
-* @see {@link isNone} for the opposite check.
-*
-* @category guards
-* @since 2.0.0
-*/
-const isSome = isSome$1;
-/**
-* Pattern-matches on an `Option`, handling both `None` and `Some` cases.
-*
-* **When to use**
-*
-* Use when you need to handle both `Some` and `None` in one expression and
-* transform an `Option` into a plain value.
-*
-* **Details**
-*
-* - If `None`, calls `onNone` and returns its result
-* - If `Some`, calls `onSome` with the value and returns its result
-* - Supports the `dual` API (data-last and data-first)
-*
-* **Example** (Matching on an Option)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* const message = Option.match(Option.some(1), {
-*   onNone: () => "Option is empty",
-*   onSome: (value) => `Option has a value: ${value}`
-* })
-*
-* console.log(message)
-* // Output: "Option has a value: 1"
-* ```
-*
-* @see {@link getOrElse} for unwrapping with a default
-*
-* @category pattern matching
-* @since 2.0.0
-*/
-const match = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
-/**
-* Extracts the value from a `Some`, or evaluates a fallback thunk on `None`.
-*
-* **When to use**
-*
-* Use when providing a default value for an absent `Option`
-* - Unwrapping with lazy evaluation of the fallback
-*
-* **Details**
-*
-* - `Some` → returns the inner value
-* - `None` → calls `onNone()` and returns its result
-* - `onNone` is only called when needed (lazy)
-*
-* **Example** (Unwrapping with a fallback)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.some(1).pipe(Option.getOrElse(() => 0)))
-* // Output: 1
-*
-* console.log(Option.none().pipe(Option.getOrElse(() => 0)))
-* // Output: 0
-* ```
-*
-* @see {@link getOrNull} to fall back to `null`
-* @see {@link getOrUndefined} to fall back to `undefined`
-* @see {@link getOrThrow} to throw on `None`
-*
-* @category getters
-* @since 2.0.0
-*/
-const getOrElse$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);
-/**
-* Converts a nullable value (`null` or `undefined`) into an `Option`.
-*
-* **When to use**
-*
-* Use when you need JavaScript nullish values to become absence at an API
-* boundary while all other values, including falsy ones, remain present.
-*
-* **Details**
-*
-* - `null` or `undefined` → `None`
-* - Any other value → `Some` (typed as `NonNullable<A>`)
-*
-* **Example** (From nullable values)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.fromNullishOr(undefined))
-* // Output: { _id: 'Option', _tag: 'None' }
-*
-* console.log(Option.fromNullishOr(null))
-* // Output: { _id: 'Option', _tag: 'None' }
-*
-* console.log(Option.fromNullishOr(1))
-* // Output: { _id: 'Option', _tag: 'Some', value: 1 }
-* ```
-*
-* @see {@link fromNullOr} to only treat `null` as absent
-* @see {@link fromUndefinedOr} to only treat `undefined` as absent
-* @see {@link liftNullishOr} to lift a nullable-returning function
-*
-* @category converting
-* @since 4.0.0
-*/
-const fromNullishOr = (a) => a == null ? none() : some(a);
-/**
-* Converts a possibly `undefined` value into an `Option`, leaving `null`
-* as a valid `Some`.
-*
-* **When to use**
-*
-* Use when you want to treat only `undefined` as absent while preserving `null`
-* as a meaningful value.
-*
-* **Details**
-*
-* - `undefined` → `None`
-* - Any other value (including `null`) → `Some`
-*
-* **Example** (From possibly-undefined values)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.fromUndefinedOr(undefined))
-* // Output: { _id: 'Option', _tag: 'None' }
-*
-* console.log(Option.fromUndefinedOr(null))
-* // Output: { _id: 'Option', _tag: 'Some', value: null }
-*
-* console.log(Option.fromUndefinedOr(42))
-* // Output: { _id: 'Option', _tag: 'Some', value: 42 }
-* ```
-*
-* @see {@link fromNullishOr} to treat both `null` and `undefined` as absent
-* @see {@link fromNullOr} to only treat `null` as absent
-*
-* @category converting
-* @since 4.0.0
-*/
-const fromUndefinedOr = (a) => a === void 0 ? none() : some(a);
-/**
-* Extracts the value from a `Some`, or returns `undefined` for `None`.
-*
-* **When to use**
-*
-* Use when you need to pass absent `Option` values to APIs that expect
-* `undefined`.
-*
-* **Details**
-*
-* - `Some` → the inner value
-* - `None` → `undefined`
-*
-* **Example** (Unwrapping to undefined)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.getOrUndefined(Option.some(1)))
-* // Output: 1
-*
-* console.log(Option.getOrUndefined(Option.none()))
-* // Output: undefined
-* ```
-*
-* @see {@link getOrNull} to return `null` instead
-* @see {@link getOrElse} for a custom fallback
-*
-* @category getters
-* @since 2.0.0
-*/
-const getOrUndefined = /*#__PURE__*/ getOrElse$1(constUndefined);
-/**
-* Lifts a function that may throw into one that returns an `Option`.
-*
-* **When to use**
-*
-* Use to wrap exception-throwing APIs (e.g. `JSON.parse`) for safe usage
-*
-* **Details**
-*
-* - If the function returns normally → `Some` with the result
-* - If the function throws → `None` (exception is swallowed)
-*
-* **Example** (Lifting JSON.parse)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* const parse = Option.liftThrowable(JSON.parse)
-*
-* console.log(parse("1"))
-* // Output: { _id: 'Option', _tag: 'Some', value: 1 }
-*
-* console.log(parse(""))
-* // Output: { _id: 'Option', _tag: 'None' }
-* ```
-*
-* @see {@link liftNullishOr} for nullable-returning functions
-*
-* @category converting
-* @since 2.0.0
-*/
-const liftThrowable = (f) => (...a) => {
-	try {
-		return some(f(...a));
-	} catch {
-		return none();
-	}
-};
-/**
-* Extracts the value from a `Some`, or throws a default `Error` for `None`.
-*
-* **When to use**
-*
-* Use when you need quick fail-fast unwrapping of an `Option` and a generic
-* error is acceptable.
-*
-* **Details**
-*
-* - `Some` → returns the inner value
-* - `None` → throws `new Error("getOrThrow called on a None")`
-*
-* **Example** (Throwing a default error)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.getOrThrow(Option.some(1)))
-* // Output: 1
-*
-* Option.getOrThrow(Option.none())
-* // throws Error: getOrThrow called on a None
-* ```
-*
-* @see {@link getOrThrowWith} for a custom error
-* @see {@link getOrElse} for a non-throwing alternative
-*
-* @category converting
-* @since 2.0.0
-*/
-const getOrThrow = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, onNone) => {
-	if (isSome(self)) return self.value;
-	throw onNone();
-}))(() => /* @__PURE__ */ new Error("getOrThrow called on a None"));
-/**
-* Transforms the value inside a `Some` using the provided function, leaving
-* `None` unchanged.
-*
-* **When to use**
-*
-* Use to apply a pure transformation to an `Option`'s present value, especially
-* when chaining transformations in a pipeline.
-*
-* **Details**
-*
-* - `Some` → applies `f` and wraps the result in a new `Some`
-* - `None` → returns `None` unchanged
-*
-* **Example** (Mapping over an Option)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* console.log(Option.map(Option.some(2), (n) => n * 2))
-* // Output: { _id: 'Option', _tag: 'Some', value: 4 }
-*
-* console.log(Option.map(Option.none(), (n: number) => n * 2))
-* // Output: { _id: 'Option', _tag: 'None' }
-* ```
-*
-* @see {@link flatMap} when `f` returns an `Option`
-* @see {@link as} to replace the value with a constant
-*
-* @category mapping
-* @since 2.0.0
-*/
-const map = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some(f(self.value)));
-/**
-* Applies a function that returns an `Option` to the value of a `Some`,
-* flattening the result. Returns `None` if the input is `None`.
-*
-* **When to use**
-*
-* Use when you need to chain dependent `Option` computations where each step
-* may return `None`.
-*
-* **Details**
-*
-* - `Some` → applies `f` to the value and returns its `Option` result
-* - `None` → returns `None` without calling `f`
-* - Equivalent to `map` followed by {@link flatten}
-*
-* **Example** (Chaining optional lookups)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* interface User {
-*   readonly name: string
-*   readonly address: Option.Option<{ readonly street: Option.Option<string> }>
-* }
-*
-* const user: User = {
-*   name: "John",
-*   address: Option.some({ street: Option.some("123 Main St") })
-* }
-*
-* const street = user.address.pipe(
-*   Option.flatMap((addr) => addr.street)
-* )
-*
-* console.log(street)
-* // Output: { _id: 'Option', _tag: 'Some', value: '123 Main St' }
-* ```
-*
-* @see {@link map} when `f` returns a plain value
-* @see {@link andThen} for a more flexible variant
-* @see {@link flatten} to unwrap a nested `Option<Option<A>>`
-*
-* @category sequencing
-* @since 2.0.0
-*/
-const flatMap = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
-/**
-* Filters an `Option` using a predicate. Returns `None` if the predicate is
-* not satisfied or the input is `None`.
-*
-* **When to use**
-*
-* Use when you need to discard an `Option`'s present value when it does not
-* meet a condition, while narrowing the type via a refinement predicate.
-*
-* **Details**
-*
-* - `None` → `None`
-* - `Some` where `predicate(value)` is `true` → `Some(value)`
-* - `Some` where `predicate(value)` is `false` → `None`
-* - Supports refinements for type narrowing
-*
-* **Example** (Filtering with a predicate)
-*
-* ```ts
-* import { Option } from "effect"
-*
-* const removeEmpty = (input: Option.Option<string>) =>
-*   Option.filter(input, (value) => value !== "")
-*
-* console.log(removeEmpty(Option.some("hello")))
-* // Output: { _id: 'Option', _tag: 'Some', value: 'hello' }
-*
-* console.log(removeEmpty(Option.some("")))
-* // Output: { _id: 'Option', _tag: 'None' }
-*
-* console.log(removeEmpty(Option.none()))
-* // Output: { _id: 'Option', _tag: 'None' }
-* ```
-*
-* @see {@link filterMap} to transform and filter simultaneously
-* @see {@link exists} to test without filtering
-*
-* @category filtering
-* @since 2.0.0
-*/
-const filter = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());
-/**
-* Creates an `Equivalence` for `Option<A>` from an `Equivalence` for `A`.
-*
-* **When to use**
-*
-* Use when you need equality to treat two `None` values as equal and compare
-* two `Some` values with a supplied equality rule.
-*
-* **Details**
-*
-* - `None` vs `None` → `true`
-* - `Some` vs `None` (or vice versa) → `false`
-* - `Some(a)` vs `Some(b)` → delegates to the provided `Equivalence`
-*
-* **Example** (Comparing Options)
-*
-* ```ts
-* import { Equivalence, Option } from "effect"
-*
-* const eq = Option.makeEquivalence(Equivalence.strictEqual<number>())
-*
-* console.log(eq(Option.some(1), Option.some(1)))
-* // Output: true
-*
-* console.log(eq(Option.some(1), Option.some(2)))
-* // Output: false
-*
-* console.log(eq(Option.none(), Option.none()))
-* // Output: true
-* ```
-*
-* @category instances
-* @since 4.0.0
-*/
-const makeEquivalence = (isEquivalent) => make$2((x, y) => isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value));
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Context.js
-/**
-* Runtime type identifier attached to `Context` service keys and used by
-* `isKey` to recognize them.
-*
-* @category type IDs
-* @since 4.0.0
-*/
-const ServiceTypeId = "~effect/Context/Service";
-/**
-* Creates a `Context` service key.
-*
-* **When to use**
-*
-* Use when you need to define a context service key for a dependency that must
-* be provided by the surrounding context.
-*
-* **Details**
-*
-* Call `Context.Service("Key")` for a function-style key, or use the two-stage
-* form `Context.Service<Self, Shape>()("Key")` for class-style service
-* declarations. The returned key can be yielded as an Effect and passed to
-* `Context.make`, `Context.add`, and the Context getter functions.
-*
-* **Gotchas**
-*
-* The string key is the runtime identity of the service. Reusing the same key
-* string for unrelated services makes them occupy the same slot in a
-* `Context`.
-*
-* **Example** (Creating service keys)
-*
-* ```ts
-* import { Context } from "effect"
-*
-* // Create a simple service
-* const Database = Context.Service<{
-*   query: (sql: string) => string
-* }>("Database")
-*
-* // Create a service class
-* class Config extends Context.Service<Config, {
-*   port: number
-* }>()("Config") {}
-*
-* // Use the services to create contexts
-* const db = Context.make(Database, {
-*   query: (sql) => `Result: ${sql}`
-* })
-* const config = Context.make(Config, { port: 8080 })
-* ```
-*
-* @see {@link Reference} for service keys with default values
-*
-* @category constructors
-* @since 4.0.0
-*/
-const Service = function() {
-	const prevLimit = Error.stackTraceLimit;
-	Error.stackTraceLimit = 2;
-	const err = /* @__PURE__ */ new Error();
-	Error.stackTraceLimit = prevLimit;
-	function KeyClass() {}
-	const self = KeyClass;
-	Object.setPrototypeOf(self, ServiceProto);
-	Object.defineProperty(self, "stack", { get() {
-		return err.stack;
-	} });
-	if (arguments.length > 0) {
-		self.key = arguments[0];
-		if (arguments[1]?.defaultValue) {
-			self[ReferenceTypeId] = ReferenceTypeId;
-			self.defaultValue = arguments[1].defaultValue;
-		}
-		return self;
-	}
-	return function(key, options) {
-		self.key = key;
-		if (options?.make) self.make = options.make;
-		return self;
-	};
-};
-const ServiceProto = {
-	[ServiceTypeId]: ServiceTypeId,
-	.../*#__PURE__*/ Prototype({
-		label: "Service",
-		evaluate(fiber) {
-			return exitSucceed(get(fiber.context, this));
-		}
-	}),
-	toJSON() {
-		return {
-			_id: "Service",
-			key: this.key,
-			stack: this.stack
-		};
-	},
-	of(self) {
-		return self;
-	},
-	context(self) {
-		return make(this, self);
-	},
-	use(f) {
-		return withFiber((fiber) => f(get(fiber.context, this)));
-	},
-	useSync(f) {
-		return withFiber((fiber) => exitSucceed(f(get(fiber.context, this))));
-	}
-};
-const ReferenceTypeId = "~effect/Context/Reference";
-const TypeId = "~effect/Context";
-/**
-* Creates a `Context` from an existing service map.
-*
-* **When to use**
-*
-* Use when constructing a low-level `Context` from a trusted map whose lifecycle
-* you control.
-*
-* **Gotchas**
-*
-* This is unsafe because later mutation of the provided map can affect the
-* created `Context`. Prefer `empty`, `make`, `add`, or `merge` for normal
-* Context construction.
-*
-* **Example** (Creating a context from a map)
-*
-* ```ts
-* import { Context } from "effect"
-*
-* // Create a context from a Map (unsafe)
-* const map = new Map([
-*   ["Logger", { log: (msg: string) => console.log(msg) }]
-* ])
-*
-* const context = Context.makeUnsafe(map)
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const makeUnsafe = (mapUnsafe) => {
-	const self = Object.create(Proto);
-	self.mapUnsafe = mapUnsafe;
-	self.mutable = false;
-	return self;
-};
-const Proto = {
-	...PipeInspectableProto,
-	[TypeId]: { _Services: (_) => _ },
-	toJSON() {
-		return {
-			_id: "Context",
-			services: Array.from(this.mapUnsafe).map(([key, value]) => ({
-				key,
-				value
-			}))
-		};
-	},
-	[symbol](that) {
-		if (!isContext(that) || this.mapUnsafe.size !== that.mapUnsafe.size) return false;
-		for (const k of this.mapUnsafe.keys()) if (!that.mapUnsafe.has(k) || !equals(this.mapUnsafe.get(k), that.mapUnsafe.get(k))) return false;
-		return true;
-	},
-	[symbol$1]() {
-		return number(this.mapUnsafe.size);
-	}
-};
-/**
-* Checks whether the provided argument is a `Context`.
-*
-* **When to use**
-*
-* Use to narrow an unknown value before passing it to APIs that require a
-* `Context`.
-*
-* **Details**
-*
-* This checks the runtime `Context` marker and does not inspect which services
-* the context contains.
-*
-* **Gotchas**
-*
-* This guard only proves that the value is a `Context`; it does not prove that
-* any specific service is present.
-*
-* **Example** (Checking for contexts)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.strictEqual(Context.isContext(Context.empty()), true)
-* ```
-*
-* @see {@link isKey} for checking service keys
-* @see {@link isReference} for checking references with defaults
-*
-* @category guards
-* @since 2.0.0
-*/
-const isContext = (u) => hasProperty(u, TypeId);
-/**
-* Checks whether the provided argument is a `Reference`.
-*
-* **Example** (Checking for references)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* const LoggerRef = Context.Reference("Logger", {
-*   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
-* })
-*
-* assert.strictEqual(Context.isReference(LoggerRef), true)
-* assert.strictEqual(Context.isReference(Context.Service("Key")), false)
-* ```
-*
-* @category guards
-* @since 3.11.0
-*/
-const isReference = (u) => hasProperty(u, ReferenceTypeId);
-/**
-* Returns an empty `Context`.
-*
-* **Example** (Creating an empty context)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.strictEqual(Context.isContext(Context.empty()), true)
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const empty = () => emptyContext;
-const emptyContext = /*#__PURE__*/ makeUnsafe(/*#__PURE__*/ new Map());
-/**
-* Creates a new `Context` with a single service associated to the key.
-*
-* **Example** (Creating a context with one service)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-*
-* const context = Context.make(Port, { PORT: 8080 })
-*
-* assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const make = (key, service) => makeUnsafe(new Map([[key.key, service]]));
-/**
-* Adds a service to a given `Context`.
-*
-* **When to use**
-*
-* Use when you need to store a known service value in a `Context`.
-*
-* **Details**
-*
-* If the context already contains the same service key, the new service
-* replaces the previous one.
-*
-* **Example** (Adding a service to a context)
-*
-* ```ts
-* import { Context, pipe } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-*
-* const someContext = Context.make(Port, { PORT: 8080 })
-*
-* const context = pipe(
-*   someContext,
-*   Context.add(Timeout, { TIMEOUT: 5000 })
-* )
-*
-* assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
-* assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
-* ```
-*
-* @see {@link addOrOmit} for adding or removing a service from an `Option`
-*
-* @category adders
-* @since 2.0.0
-*/
-const add = /*#__PURE__*/ dual(3, (self, key, service) => withMapUnsafe(self, (map) => {
-	map.set(key.key, service);
-}));
-/**
-* Gets the service for a key, or evaluates the fallback when a non-reference
-* key is absent.
-*
-* **When to use**
-*
-* Use when you need a fallback for a missing `Context.Service` key while still
-* resolving `Context.Reference` defaults.
-*
-* **Details**
-*
-* If the key is a `Context.Reference` and no override is stored in the
-* context, its cached default value is returned instead of the fallback.
-*
-* **Gotchas**
-*
-* The fallback is not evaluated for missing `Context.Reference` keys because
-* references resolve to their default value.
-*
-* **Example** (Falling back for missing services)
-*
-* ```ts
-* import { Context } from "effect"
-*
-* const Logger = Context.Service<{ log: (msg: string) => void }>("Logger")
-* const Database = Context.Service<{ query: (sql: string) => string }>(
-*   "Database"
-* )
-*
-* const context = Context.make(Logger, {
-*   log: (msg: string) => console.log(msg)
-* })
-*
-* const logger = Context.getOrElse(context, Logger, () => ({ log: () => {} }))
-* const database = Context.getOrElse(
-*   context,
-*   Database,
-*   () => ({ query: () => "fallback" })
-* )
-*
-* console.log(logger === Context.get(context, Logger)) // true
-* console.log(database.query("SELECT 1")) // "fallback"
-* ```
-*
-* @see {@link getOption} for returning `Option.none` when a non-reference key is missing
-*
-* @category getters
-* @since 3.7.0
-*/
-const getOrElse = /*#__PURE__*/ dual(3, (self, key, orElse) => {
-	if (self.mapUnsafe.has(key.key)) return self.mapUnsafe.get(key.key);
-	return isReference(key) ? getDefaultValue(key) : orElse();
-});
-/**
-* Gets the service for a key, throwing if an absent non-reference key cannot be
-* resolved.
-*
-* **When to use**
-*
-* Use when you need to read a service from a context whose type does not prove
-* the service is present.
-*
-* **Details**
-*
-* If the key is a `Context.Reference` and no override is stored in the
-* context, its cached default value is returned. For absent non-reference keys,
-* this function throws a runtime error.
-*
-* **Example** (Getting services unsafely)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-*
-* const context = Context.make(Port, { PORT: 8080 })
-*
-* assert.deepStrictEqual(Context.getUnsafe(context, Port), { PORT: 8080 })
-* assert.throws(() => Context.getUnsafe(context, Timeout))
-* ```
-*
-* @see {@link get} for type-checked service access
-* @see {@link getOption} for optional service access
-*
-* @category unsafe
-* @since 4.0.0
-*/
-const getUnsafe = /*#__PURE__*/ dual(2, (self, service) => {
-	if (!self.mapUnsafe.has(service.key)) {
-		if (ReferenceTypeId in service) return getDefaultValue(service);
-		throw serviceNotFoundError(service);
-	}
-	return self.mapUnsafe.get(service.key);
-});
-/**
-* Gets a service from the context that corresponds to the given key.
-*
-* **When to use**
-*
-* Use when you need type-checked access to a service already included in the
-* context type.
-*
-* **Example** (Getting a service from a context)
-*
-* ```ts
-* import { Context, pipe } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-*
-* const context = pipe(
-*   Context.make(Port, { PORT: 8080 }),
-*   Context.add(Timeout, { TIMEOUT: 5000 })
-* )
-*
-* assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
-* ```
-*
-* @see {@link getOption} for optional service access
-* @see {@link getOrElse} for fallback values
-*
-* @category getters
-* @since 2.0.0
-*/
-const get = getUnsafe;
-/**
-* Gets the value for a `Context.Reference`, returning its cached default when
-* the context does not contain an override.
-*
-* **When to use**
-*
-* Use when you need a `Context.Reference` value resolved from either a stored
-* override or the reference's default value.
-*
-* **Details**
-*
-* Stored overrides take precedence. If no override is present, the reference's
-* default value is computed lazily and cached on the reference itself.
-*
-* **Gotchas**
-*
-* Mutable default values can be shared across contexts unless an override is
-* provided, because the default is cached on the `Context.Reference`.
-*
-* **Example** (Getting reference defaults unsafely)
-*
-* ```ts
-* import { Context } from "effect"
-*
-* const LoggerRef = Context.Reference("Logger", {
-*   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
-* })
-*
-* const context = Context.empty()
-* const logger = Context.getReferenceUnsafe(context, LoggerRef)
-*
-* console.log(typeof logger.log) // "function"
-* ```
-*
-* @see {@link getUnsafe} for unsafe access with any service key
-* @see {@link get} for type-checked reference-aware access
-* @see {@link getOption} for optional access to non-reference keys
-*
-* @category unsafe
-* @since 4.0.0
-*/
-const getReferenceUnsafe = (self, service) => {
-	if (!self.mapUnsafe.has(service.key)) return getDefaultValue(service);
-	return self.mapUnsafe.get(service.key);
-};
-const defaultValueCacheKey = "~effect/Context/defaultValue";
-const getDefaultValue = (ref) => {
-	if (defaultValueCacheKey in ref) return ref[defaultValueCacheKey];
-	return ref[defaultValueCacheKey] = ref.defaultValue();
-};
-const serviceNotFoundError = (service) => {
-	const error = /* @__PURE__ */ new Error(`Service not found${service.key ? `: ${String(service.key)}` : ""}`);
-	if (service.stack) {
-		const lines = service.stack.split("\n");
-		if (lines.length > 2) {
-			const afterAt = lines[2].match(/at (.*)/);
-			if (afterAt) error.message = error.message + ` (defined at ${afterAt[1]})`;
-		}
-	}
-	if (error.stack) {
-		const lines = error.stack.split("\n");
-		lines.splice(1, 3);
-		error.stack = lines.join("\n");
-	}
-	return error;
-};
-/**
-* Gets the service for a key safely wrapped in an `Option`.
-*
-* **When to use**
-*
-* Use when you need to read a `Context` service as an `Option` so absence is
-* represented as data.
-*
-* **Details**
-*
-* Returns `Option.some` when the service is stored in the context. If the key
-* is a `Context.Reference` and no override is stored, returns `Option.some` of
-* the cached default value. Missing non-reference keys return `Option.none`.
-*
-* **Example** (Getting optional services)
-*
-* ```ts
-* import { Context, Option } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-*
-* const context = Context.make(Port, { PORT: 8080 })
-*
-* assert.deepStrictEqual(
-*   Context.getOption(context, Port),
-*   Option.some({ PORT: 8080 })
-* )
-* assert.deepStrictEqual(Context.getOption(context, Timeout), Option.none())
-* ```
-*
-* @see {@link getOrElse} for returning a fallback value directly
-*
-* @category getters
-* @since 2.0.0
-*/
-const getOption = /*#__PURE__*/ dual(2, (self, service) => {
-	if (self.mapUnsafe.has(service.key)) return some(self.mapUnsafe.get(service.key));
-	return isReference(service) ? some(getDefaultValue(service)) : none();
-});
-/**
-* Merges two `Context`s into one.
-*
-* **When to use**
-*
-* Use when you need to combine two contexts.
-*
-* **Details**
-*
-* When both contexts contain the same service key, the service from `that`
-* overrides the service from `self`.
-*
-* **Example** (Merging two contexts)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-*
-* const firstContext = Context.make(Port, { PORT: 8080 })
-* const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
-*
-* const context = Context.merge(firstContext, secondContext)
-*
-* assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
-* assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
-* ```
-*
-* @see {@link mergeAll} for merging more than two contexts at once
-*
-* @category combining
-* @since 2.0.0
-*/
-const merge = /*#__PURE__*/ dual(2, (self, that) => {
-	if (self.mapUnsafe.size === 0) return that;
-	if (that.mapUnsafe.size === 0) return self;
-	return withMapUnsafe(self, (map) => {
-		that.mapUnsafe.forEach((value, key) => map.set(key, value));
-	});
-});
-/**
-* Merges any number of `Context`s into one.
-*
-* **When to use**
-*
-* Use when you need to combine a variadic list of contexts.
-*
-* **Details**
-*
-* When multiple contexts contain the same service key, the service from the
-* last context with that key is kept.
-*
-* **Example** (Merging multiple contexts)
-*
-* ```ts
-* import { Context } from "effect"
-* import * as assert from "node:assert"
-*
-* const Port = Context.Service<{ PORT: number }>("Port")
-* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
-* const Host = Context.Service<{ HOST: string }>("Host")
-*
-* const firstContext = Context.make(Port, { PORT: 8080 })
-* const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })
-* const thirdContext = Context.make(Host, { HOST: "localhost" })
-*
-* const context = Context.mergeAll(
-*   firstContext,
-*   secondContext,
-*   thirdContext
-* )
-*
-* assert.deepStrictEqual(Context.get(context, Port), { PORT: 8080 })
-* assert.deepStrictEqual(Context.get(context, Timeout), { TIMEOUT: 5000 })
-* assert.deepStrictEqual(Context.get(context, Host), { HOST: "localhost" })
-* ```
-*
-* @see {@link merge} for merging two contexts
-*
-* @category combining
-* @since 3.12.0
-*/
-const mergeAll = (...ctxs) => {
-	const map = /* @__PURE__ */ new Map();
-	for (let i = 0; i < ctxs.length; i++) ctxs[i].mapUnsafe.forEach((value, key) => {
-		map.set(key, value);
-	});
-	return makeUnsafe(map);
-};
-/**
-* Performs a series of mutations on a `Context`. Prevents unnecessary copying
-* of the underlying map when multiple mutations are needed.
-*
-* **When to use**
-*
-* Use to apply several `Context` transformations in one callback while copying
-* the underlying service map only once.
-*
-* @see {@link add} for adding or replacing a service
-* @see {@link addOrOmit} for adding or removing a service from an `Option`
-* @see {@link merge} for combining two contexts
-* @see {@link pick} for keeping selected services
-* @see {@link omit} for removing selected services
-*
-* @category mutations
-* @since 4.0.0
-*/
-const mutate = /*#__PURE__*/ dual(2, (self, f) => {
-	const next = makeUnsafe(new Map(self.mapUnsafe));
-	next.mutable = true;
-	const result = f(next);
-	result.mutable = false;
-	return result;
-});
-const withMapUnsafe = (self, f) => {
-	if (self.mutable) {
-		f(self.mapUnsafe);
-		return self;
-	}
-	const map = new Map(self.mapUnsafe);
-	f(map);
-	return makeUnsafe(map);
-};
-/**
-* Creates a context key with a default value.
-*
-* **When to use**
-*
-* Use when you need to define a context key with a lazily computed default
-* value.
-*
-* **Details**
-*
-* `Context.Reference` allows you to create a key that can hold a value. You
-* can provide a default value for the service, which will automatically be used
-* when the context is accessed, or override it with a custom implementation
-* when needed. The default value is computed lazily and cached on the
-* reference.
-*
-* **Example** (Creating references with default values)
-*
-* ```ts
-* import { Context } from "effect"
-*
-* // Create a reference with a default value
-* const LoggerRef = Context.Reference("Logger", {
-*   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
-* })
-*
-* // The reference provides the default value when accessed from an empty context
-* const context = Context.empty()
-* const logger = Context.get(context, LoggerRef)
-*
-* // You can also override the default value
-* const customContext = Context.make(LoggerRef, {
-*   log: (msg: string) => `Custom: ${msg}`
-* })
-* const customLogger = Context.get(customContext, LoggerRef)
-* ```
-*
-* @see {@link Service} for required services without default values
-*
-* @category references
-* @since 3.11.0
-*/
-const Reference = Service;
-//#endregion
-export { Done as $, hash as $t, none as A, identity as An, isInterruptReason as At, mapInput as B, format as Bt, isNone as C, constFalse as Cn, exitSucceed as Ct, makeEquivalence as D, constant as Dn, isEffect as Dt, liftThrowable as E, constVoid as En, isDone as Et, isGreaterThan as F, BaseProto as Ft, succeed as G, currentFiberTypeId as Gt, fail as H, formatJson as Ht, isGreaterThanOrEqualTo as I, Class as It, make$2 as J, asEquivalence as Jt, Array_ as K, redact as Kt, isLessThan as L, NodeInspectSymbol as Lt, BigInt as M, pipe as Mn, makePrimitiveProto as Mt, Date$1 as N, Class$1 as Nn, withFiber as Nt, map as O, dual as On, isExit as Ot, Number$1 as P, pipeArguments as Pn, internalCall as Pt, Die as Q, combine as Qt, isLessThanOrEqualTo as R, toJson as Rt, getOrUndefined as S, isUnknown as Sn, exitFailCause as St, isSome as T, constUndefined as Tn, isCauseReason as Tt, isFailure as U, formatPath as Ut, min as V, formatDate as Vt, isSuccess as W, formatPropertyKey as Wt, Prototype as X, symbol as Xt, strictEqual as Y, equals as Yt, CauseImpl as Z, array as Zt, flatMap as _, isObject as _n, contE as _t, get as a, hasProperty as an, ReasonBase as at, getOrElse$1 as b, isTagged as bn, exitDie as bt, getReferenceUnsafe as c, isError as cn, Yield as ct, make as d, isNever as dn, causeEmpty as dt, number as en, Error$1 as et, makeUnsafe as f, isNotNull as fn, causeFail as ft, filter as g, isNumber as gn, contAll as gt, mutate as h, isNullish as hn, contA as ht, empty as i, symbol$1 as in, PipeInspectableProto as it, some as j, memoize as jn, makePrimitive as jt, match as k, flow as kn, isFailReason as kt, getUnsafe as l, isFunction as ln, args as lt, mergeAll as m, isNotUndefined as mn, constEmptyAnnotations as mt, Service as n, string as nn, Fail as nt, getOption as o, isBigInt as on, StackTraceKey as ot, merge as p, isNotNullish as pn, causeFromReasons as pt, Tuple as q, symbolRedactable as qt, add as r, structure as rn, InterruptorStackTrace as rt, getOrElse as s, isBoolean as sn, TaggedError as st, Reference as t, random as tn, ExitTypeId as tt, isContext as u, isIterable as un, causeAnnotate as ut, fromNullishOr as v, isPropertyKey as vn, done as vt, isOption as w, constTrue as wn, isCause as wt, getOrThrow as x, isUndefined as xn, exitFail as xt, fromUndefinedOr as y, isString as yn, evaluate as yt, make$1 as z, toStringUnknown as zt };