@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Option-DkxSnBhp.mjs

@@ -0,0 +1,3967 @@
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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.
+*
+* @stability stable
+* @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.meta.vitest
+* 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
+* )
+* result // => 21
+* ```
+*
+* @stability stable
+* @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`.
+*
+* @stability stable
+* @category prototypes
+* @since 3.15.0
+*/
+const Prototype = { 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(...)`.
+*
+* @stability stable
+* @category constructors
+* @since 3.15.0
+*/
+const Class$1 = /*#__PURE__*/ function() {
+	function PipeableBase() {}
+	PipeableBase.prototype = Prototype;
+	return PipeableBase;
+}();
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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** (Selecting data-first or data-last style by arity)
+*
+* ```ts import.meta.vitest
+* import { Function, pipe } from "effect"
+*
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
+* ```
+*
+* **Example** (Defining overloads with call signatures)
+*
+* ```ts import.meta.vitest
+* 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)
+*
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
+* ```
+*
+* **Example** (Selecting data-first or data-last style with a predicate)
+*
+* ```ts import.meta.vitest
+* 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
+* )
+*
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { identity } from "effect"
+*
+* identity(5) // => 5
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Function } from "effect"
+*
+* const constNull = Function.constant(null)
+*
+* constNull() // => null
+* constNull() // => null
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Function } from "effect"
+*
+* Function.constTrue() // => true
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Function } from "effect"
+*
+* Function.constFalse() // => false
+* ```
+*
+* @stability stable
+* @category constants
+* @since 2.0.0
+*/
+const constFalse = /*#__PURE__*/ constant(false);
+/**
+* Returns `null` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `null` on every invocation.
+*
+* **Example** (Returning null from a thunk)
+*
+* ```ts import.meta.vitest
+* import { Function } from "effect"
+*
+* Function.constNull() // => null
+* ```
+*
+* @stability stable
+* @category constants
+* @since 2.0.0
+*/
+const constNull = /*#__PURE__*/ constant(null);
+/**
+* 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.meta.vitest
+* import { Function } from "effect"
+*
+* Function.constUndefined() // => undefined
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Function } from "effect"
+*
+* Function.constVoid() // => undefined
+* ```
+*
+* @stability stable
+* @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.
+*
+* **Gotchas**
+*
+* `undefined` is reserved to represent a cache miss and is therefore not
+* supported as a return value.
+*
+* 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.
+*
+* @stability stable
+* @category caching
+* @since 4.0.0
+*/
+function memoize(f) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (a) => {
+		const cached = cache.get(a);
+		if (cached !== void 0) return cached;
+		const result = f(a);
+		cache.set(a, result);
+		return result;
+	};
+}
+/**
+* Creates a memoized idempotent object transformation that caches both inputs
+* and their outputs by object identity.
+*
+* **When to use**
+*
+* Use when an object transformation is idempotent and its output can be safely
+* reused as a fixed point.
+*
+* **Details**
+*
+* After computing an input, the returned function caches both the input and
+* the output. Calling it with either reference returns the output without
+* invoking the supplied function again.
+*
+* **Gotchas**
+*
+* The returned function treats each computed output as a fixed point. If
+* applying the supplied function to an output would produce an observably
+* different value, this memoization changes that behavior.
+*
+* @see {@link memoize} for memoizing functions without an idempotence requirement
+* @stability stable
+* @category caching
+* @since 4.0.0
+*/
+function memoizeIdempotent(f) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (a) => {
+		const cached = cache.get(a);
+		if (cached !== void 0) return cached;
+		const result = f(a);
+		cache.set(a, result);
+		if (result !== a) cache.set(result, result);
+		return result;
+	};
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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();
+/** @internal */
+const viewBytes = (view) => new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+/** @internal */
+const isArrayBufferLike = (u) => u instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && u instanceof SharedArrayBuffer;
+/**
+* Returns `undefined` for detached buffers, which can no longer be read.
+*
+* @internal
+*/
+const bufferBytes = (buffer) => {
+	try {
+		return new Uint8Array(buffer);
+	} catch {
+		return;
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/hash.js
+/**
+* Back-edge count used to avoid caching entry-point-dependent hashes.
+*
+* @internal
+*/
+let backEdges = 0;
+/** @internal */
+const addBackEdge = () => {
+	backEdges++;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Predicate.js
+/**
+* Defines runtime checks for values.
+*
+* A `Predicate<A>` returns `true` or `false` for an `A`. A
+* `Refinement<A, B>` is a predicate that also narrows the TypeScript type when
+* it succeeds. This module includes guards for common JavaScript values,
+* property and tag checks, tuple and struct checks, boolean combinators, and
+* helpers for composing predicates and refinements.
+*
+* @stability stable
+* @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** (Guarding strings)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = "hi"
+*
+* if (Predicate.isString(data)) {
+*   data.toUpperCase() // => "HI"
+* }
+* ```
+*
+* @see {@link isNumber}
+* @see {@link isBoolean}
+* @see {@link Refinement}
+* @stability stable
+* @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** (Guarding numbers)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = 42
+*
+* if (Predicate.isNumber(data)) {
+*   data + 1 // => 43
+* }
+* ```
+*
+* @see {@link isBigInt}
+* @see {@link isString}
+* @stability stable
+* @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** (Guarding booleans)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = true
+*
+* if (Predicate.isBoolean(data)) {
+*   data ? "yes" : "no" // => "yes"
+* }
+* ```
+*
+* @see {@link isString}
+* @see {@link isNumber}
+* @stability stable
+* @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** (Guarding bigints)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = 1n
+*
+* if (Predicate.isBigInt(data)) {
+*   data + 2n // => 3n
+* }
+* ```
+*
+* @see {@link isNumber}
+* @stability stable
+* @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** (Guarding symbols)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = Symbol.for("id")
+*
+* if (Predicate.isSymbol(data)) {
+*   data.description // => "id"
+* }
+* ```
+*
+* @see {@link isPropertyKey}
+* @stability stable
+* @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** (Guarding property keys)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const key: unknown = "name"
+* const obj: Record<PropertyKey, unknown> = { name: "Ada" }
+*
+* if (Predicate.isPropertyKey(key) && key in obj) {
+*   obj[key] // => "Ada"
+* }
+* ```
+*
+* @see {@link isString}
+* @see {@link isNumber}
+* @see {@link isSymbol}
+* @stability stable
+* @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** (Guarding functions)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = () => 1
+*
+* if (Predicate.isFunction(data)) {
+*   data() // => 1
+* }
+* ```
+*
+* @see {@link isObjectKeyword}
+* @stability stable
+* @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** (Guarding undefined values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = undefined
+*
+* Predicate.isUndefined(data) // => true
+* ```
+*
+* @see {@link isNotUndefined}
+* @see {@link isNullish}
+* @stability stable
+* @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** (Filtering undefined values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const values = [1, undefined, 2]
+* const defined = values.filter(Predicate.isNotUndefined) // => [1, 2]
+* ```
+*
+* @see {@link isUndefined}
+* @see {@link isNotNullish}
+* @stability stable
+* @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** (Filtering null values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const values = [1, null, 2]
+* const nonNull = values.filter(Predicate.isNotNull) // => [1, 2]
+* ```
+*
+* @see {@link isNull}
+* @see {@link isNotNullish}
+* @stability stable
+* @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** (Guarding nullish values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const values = [0, null, "", undefined]
+* const nullish = values.filter(Predicate.isNullish) // => [null, undefined]
+* ```
+*
+* @see {@link isNotNullish}
+* @see {@link isUndefined}
+* @see {@link isNull}
+* @stability stable
+* @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** (Filtering non-nullish values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const values = [0, null, "", undefined]
+* const present = values.filter(Predicate.isNotNullish) // => [0, ""]
+* ```
+*
+* @see {@link isNullish}
+* @see {@link isNotNull}
+* @see {@link isNotUndefined}
+* @stability stable
+* @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** (Matching no values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* Predicate.isNever("anything") // => false
+* ```
+*
+* @see {@link isUnknown}
+* @stability stable
+* @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** (Matching every value)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* Predicate.isUnknown(123) // => true
+* ```
+*
+* @see {@link isNever}
+* @stability stable
+* @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** (Guarding objects)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* Predicate.isObject({ a: 1 }) // => true
+* Predicate.isObject([1, 2]) // => false
+* ```
+*
+* @see {@link isObjectOrArray}
+* @see {@link isReadonlyObject}
+* @stability stable
+* @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** (Checking object keywords)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* Predicate.isObjectKeyword(() => 1) // => true
+* Predicate.isObjectKeyword(null) // => false
+* ```
+*
+* @see {@link isObject}
+* @see {@link isObjectOrArray}
+* @stability stable
+* @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** (Guarding object properties)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const hasName = Predicate.hasProperty("name")
+* const data: unknown = { name: "Ada" }
+*
+* if (hasName(data)) {
+*   data.name // => "Ada"
+* }
+* ```
+*
+* @see {@link isTagged}
+* @see {@link isObjectKeyword}
+* @stability stable
+* @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** (Guarding tagged values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const isOk = Predicate.isTagged("Ok")
+*
+* isOk({ _tag: "Ok", value: 1 }) // => true
+* ```
+*
+* @see {@link hasProperty}
+* @stability stable
+* @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** (Guarding errors)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = new Error("boom")
+*
+* Predicate.isError(data) // => true
+* ```
+*
+* @see {@link isUnknown}
+* @stability stable
+* @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** (Guarding iterables)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = [1, 2, 3]
+*
+* Predicate.isIterable(data) // => true
+* ```
+*
+* @see {@link isSet}
+* @see {@link isMap}
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+function isIterable(input) {
+	return hasProperty(input, Symbol.iterator) || isString(input);
+}
+/**
+* Creates a predicate that returns `true` if either predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine `Predicate`s with OR, accepting values that
+* satisfy at least one condition, including refinements that narrow to a union.
+*
+* **Details**
+*
+* Evaluation short-circuits on the first `true`. For refinements, the output
+* type is a union.
+*
+* **Example** (Checking either condition)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
+*
+* isStringOrNumber("a") // => true
+* ```
+*
+* @see {@link and}
+* @see {@link xor}
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const or = /*#__PURE__*/ dual(2, (self, that) => (a) => self(a) || that(a));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Hash.js
+/**
+* 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. The module also includes helpers for primitive, structure, array, and
+* reference-based hashes, plus functions for combining and optimizing numeric
+* hash values.
+*
+* @stability stable
+* @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
+*
+* @stability stable
+* @category symbols
+* @since 2.0.0
+*/
+const symbol$1 = "~effect/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.meta.vitest
+* import { Hash } from "effect"
+*
+* Hash.hash(42) === Hash.hash(42) // => true
+* Hash.hash("hello") === Hash.hash("hello") // => true
+* Hash.hash([1, 2, 3]) === Hash.hash([1, 2, 3]) // => true
+* ```
+*
+* @stability stable
+* @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 "string": return string(self);
+		case "function":
+		case "object": if (self === null) break;
+		else if (self instanceof Date) {
+			if (Number.isNaN(self.getTime())) return string("Invalid Date");
+			return string(self.toISOString());
+		} else if (self instanceof RegExp) return string(self.toString());
+		else {
+			if (byReferenceInstances.has(self)) return random(self);
+			const cached = hashCache.get(self);
+			if (cached !== void 0) return cached;
+			if (visitedObjects.has(self)) {
+				addBackEdge();
+				return string("[Circular]");
+			}
+			visitedObjects.add(self);
+			const seen = backEdges;
+			let h;
+			try {
+				if (isHash(self)) h = self[symbol$1]();
+				else if (typeof self === "function") h = random(self);
+				else if (isArrayBufferLike(self)) {
+					const bytes = bufferBytes(self);
+					h = bytes === void 0 ? random(self) : array(bytes);
+				} else if (self instanceof DataView) h = array(viewBytes(self));
+				else if (Array.isArray(self) || ArrayBuffer.isView(self)) h = array(self);
+				else if (self instanceof Map) h = hashMap(self);
+				else if (self instanceof Set) h = hashSet(self);
+				else h = structure(self);
+			} finally {
+				visitedObjects.delete(self);
+			}
+			if (seen === backEdges) hashCache.set(self, h);
+			return h;
+		}
+	}
+	return optimize(mix(string(String(self))));
+};
+/**
+* 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.meta.vitest
+* import { Hash } from "effect"
+*
+* const obj1 = { a: 1 }
+* const obj2 = { a: 1 }
+*
+* Hash.random(obj1) === Hash.random(obj1) // => true
+*
+* typeof Hash.random(obj2) // => "number"
+* ```
+*
+* @stability stable
+* @category hashing
+* @since 2.0.0
+*/
+const random = (self) => {
+	if (!randomHashCache.has(self)) randomHashCache.set(self, optimize(Math.random() * 4294967296 | 0));
+	return randomHashCache.get(self);
+};
+const mix = (h) => {
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	return h ^ h >>> 16;
+};
+/**
+* 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 direct and pipeable usage. Argument order affects the result.
+*
+* **Example** (Combining hash values)
+*
+* ```ts import.meta.vitest
+* import { Hash, pipe } from "effect"
+*
+* const hash1 = Hash.hash("hello")
+* const hash2 = Hash.hash("world")
+*
+* const combined = Hash.combine(hash2)(hash1)
+* combined === pipe(hash1, Hash.combine(hash2)) // => true
+* ```
+*
+* @see {@link hash} for computing hash values from arbitrary inputs
+* @see {@link structureKeys} for hashing selected object fields without manual combination
+*
+* @stability stable
+* @category hashing
+* @since 2.0.0
+*/
+const combine = /*#__PURE__*/ dual(2, (self, b) => mix(Math.imul(self, 2654435761) + Math.imul(b, 2246822507)));
+/**
+* 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.meta.vitest
+* import { Hash } from "effect"
+*
+* Hash.optimize(1234567890) // => 160826066
+* ```
+*
+* @stability stable
+* @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 a function under the Hash
+* symbol, indicating that it can provide its own hash value implementation.
+* Data that merely carries the key, such as parsed JSON, is hashed as data.
+*
+* **Example** (Checking for Hash support)
+*
+* ```ts import.meta.vitest
+* import { Hash } from "effect"
+*
+* class MyHashable implements Hash.Hash {
+*   [Hash.symbol]() {
+*     return 42
+*   }
+* }
+*
+* Hash.isHash(new MyHashable()) // => true
+* Hash.isHash({}) // => false
+* Hash.isHash("string") // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isHash = (u) => hasProperty(u, "~effect/Hash") && typeof u["~effect/Hash"] === "function";
+const float64 = /*#__PURE__*/ new DataView(/*#__PURE__*/ new ArrayBuffer(8));
+/**
+* Computes a hash value for a number.
+*
+* **When to use**
+*
+* Use to hash a JavaScript number with Effect's numeric hash semantics.
+*
+* **Details**
+*
+* Int32 values hash to themselves. Other numbers hash from their IEEE-754 bits,
+* with a canonical representation for `NaN`.
+*
+* **Example** (Hashing numbers)
+*
+* ```ts import.meta.vitest
+* import { Hash } from "effect"
+*
+* Number.isInteger(Hash.number(42)) // => true
+* Number.isInteger(Hash.number(3.14)) // => true
+* Hash.number(NaN) === Hash.number(NaN) // => true
+* Hash.number(Infinity) === Hash.number(Infinity) // => true
+* Hash.number(100) === Hash.number(100) // => true
+* ```
+*
+* @stability stable
+* @category hashing
+* @since 2.0.0
+*/
+const number = (n) => {
+	const h = n | 0;
+	if (h === n) return optimize(h);
+	float64.setFloat64(0, n !== n ? NaN : n);
+	return optimize(combine(float64.getInt32(0), float64.getInt32(4)));
+};
+/**
+* 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.meta.vitest
+* import { Hash } from "effect"
+*
+* Hash.string("hello") // => 181380007
+* Hash.string("world") // => 164394279
+* Hash.string("") // => 5381
+* Hash.string("test") === Hash.string("test") // => true
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Hash } from "effect"
+*
+* const person = { name: "John", age: 30, city: "New York" }
+*
+* const hash1 = Hash.structureKeys(person, ["name", "age"])
+* const hash2 = Hash.structureKeys(person, ["name", "city"])
+*
+* hash1 // => -731887653
+* hash2 // => 148523102
+*
+* const person2 = { name: "John", age: 30, city: "Boston" }
+* const hash3 = Hash.structureKeys(person2, ["name", "age"])
+* hash1 === hash3 // => true
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* import { Hash } from "effect"
+*
+* const obj1 = { name: "John", age: 30 }
+* const obj2 = { name: "Jane", age: 25 }
+* const obj3 = { name: "John", age: 30 }
+*
+* Hash.structure(obj1) // => -731887653
+* Hash.structure(obj2) // => -222100417
+* Hash.structure(obj3) // => -731887653
+* Hash.structure(obj1) === Hash.structure(obj3) // => true
+* ```
+*
+* @stability stable
+* @category hashing
+* @since 2.0.0
+*/
+const structure = (o) => structureKeys(o, getAllObjectKeys(o));
+const unordered = (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**
+*
+* Folds element hashes with {@link combine}, so order and length affect the
+* result.
+*
+* **Gotchas**
+*
+* A hash is not an equality proof. Distinct inputs can still share a hash.
+*
+* **Example** (Hashing arrays)
+*
+* ```ts import.meta.vitest
+* import { Hash } from "effect"
+*
+* const arr1 = [1, 2, 3]
+* const arr2 = [1, 2, 3]
+* const arr3 = [3, 2, 1]
+*
+* Hash.array(arr1) === Hash.array(arr2) // => true
+* Hash.array(arr1) === Hash.array(arr3) // => false
+* ```
+*
+* @see {@link hash} for the general-purpose hash dispatcher
+*
+* @stability stable
+* @category hashing
+* @since 2.0.0
+*/
+const array = (arr) => {
+	let h = 6151;
+	for (const element of arr) h = combine(h, hash(element));
+	return optimize(h);
+};
+const hashMap = /*#__PURE__*/ unordered(/*#__PURE__*/ string("Map"), ([k, v]) => combine(hash(k), hash(v)));
+const setSeed = /*#__PURE__*/ string("Set");
+const hashSet = /*#__PURE__*/ unordered(setSeed, (element) => combine(setSeed, hash(element)));
+const randomHashCache = /*#__PURE__*/ new WeakMap();
+const hashCache = /*#__PURE__*/ new WeakMap();
+const visitedObjects = /*#__PURE__*/ new WeakSet();
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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.meta.vitest
+* 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)
+*   }
+* }
+*
+* Equal.equals(new UserId("1"), new UserId("1")) // => true
+* Equal.equals(new UserId("1"), new UserId("2")) // => false
+* ```
+*
+* @see {@link Equal} — the interface that uses this symbol
+* @see {@link isEqual} — type guard for `Equal` implementors
+* @stability stable
+* @category symbols
+* @since 2.0.0
+*/
+const symbol = "~effect/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 compareObjects(self, that);
+}
+function compareObjects(self, that) {
+	const depth = pathLeft.length;
+	for (let i = depth; i-- > 0;) if (pathLeft[i] === self && pathRight[i] === that) return true;
+	if (depth) return compareOnPath(self, that);
+	let known = results.get(self);
+	if (!known) results.set(self, known = /* @__PURE__ */ new WeakMap());
+	let result = known.get(that);
+	if (result === void 0) known.set(that, result = compareOnPath(self, that));
+	return result;
+}
+function compareOnPath(self, that) {
+	pathLeft.push(self);
+	pathRight.push(that);
+	try {
+		return compareStructure(self, that);
+	} finally {
+		pathLeft.pop();
+		pathRight.pop();
+	}
+}
+const pathLeft = [];
+const pathRight = [];
+const results = /*#__PURE__*/ new WeakMap();
+function compareStructure(self, that) {
+	if (hash(self) !== hash(that)) return false;
+	else if (self instanceof Date) {
+		if (!(that instanceof Date)) return false;
+		const selfTime = self.getTime();
+		const thatTime = that.getTime();
+		return selfTime === thatTime || Number.isNaN(selfTime) && Number.isNaN(thatTime);
+	} else if (self instanceof RegExp) return that instanceof RegExp && self.toString() === that.toString();
+	const bothEquals = isEqual(self);
+	if (bothEquals !== isEqual(that) || typeof self === "function" && !bothEquals) return false;
+	else 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 (isArrayBufferLike(self)) {
+		if (!isArrayBufferLike(that) || self instanceof ArrayBuffer !== that instanceof ArrayBuffer) return false;
+		const selfBytes = bufferBytes(self);
+		const thatBytes = bufferBytes(that);
+		return selfBytes !== void 0 && thatBytes !== void 0 && compareTypedArrays(selfBytes, thatBytes);
+	} else if (ArrayBuffer.isView(self)) {
+		const selfIsDataView = self instanceof DataView;
+		if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength || selfIsDataView !== that instanceof DataView) return false;
+		if (selfIsDataView) return compareTypedArrays(viewBytes(self), viewBytes(that));
+		return compareTypedArrays(self, that);
+	} else if (self instanceof Map) {
+		if (!(that instanceof Map) || self.size !== that.size) return false;
+		return compareHashed(self, that, entryHash, equalEntries);
+	} else if (self instanceof Set) {
+		if (!(that instanceof Set) || self.size !== that.size) return false;
+		return compareHashed(self, that, hash, compareBoth);
+	}
+	return compareRecords(self, that);
+}
+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;
+}
+function compareHashed(self, that, hashOf, equivalent) {
+	const groups = /* @__PURE__ */ new Map();
+	let remaining = 0;
+	for (const item of that) {
+		const h = hashOf(item);
+		const group = groups.get(h);
+		if (group) group.push(item);
+		else groups.set(h, [item]);
+		remaining++;
+	}
+	outer: for (const item of self) {
+		const group = groups.get(hashOf(item));
+		if (group) {
+			for (let i = 0; i < group.length; i++) if (equivalent(item, group[i])) {
+				group[i] = group[group.length - 1];
+				group.pop();
+				remaining--;
+				continue outer;
+			}
+		}
+		return false;
+	}
+	return remaining === 0;
+}
+const entryHash = (entry) => hash(entry[0]);
+const equalEntries = (self, that) => compareBoth(self[0], that[0]) && compareBoth(self[1], that[1]);
+/**
+* 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 function keyed by {@link symbol}.
+*   Data that merely carries the key, such as parsed JSON, is not `Equal`.
+* - Acts as a TypeScript type guard, narrowing the input to {@link Equal}.
+*
+* **Example** (Checking Equal values)
+*
+* ```ts import.meta.vitest
+* 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)
+*   }
+* }
+*
+* Equal.isEqual(new Token("abc")) // => true
+* Equal.isEqual({ x: 1 }) // => false
+* Equal.isEqual(42) // => false
+* ```
+*
+* @see {@link Equal} — the interface being checked
+* @see {@link symbol} — the property key that signals `Equal` support
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isEqual = (u) => hasProperty(u, "~effect/Equal") && typeof u["~effect/Equal"] === "function";
+/**
+* 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.meta.vitest
+* import { Array, Equal } from "effect"
+*
+* Array.dedupeWith([1, 2, 2, 3, 1], Equal.asEquivalence<number>()) // => [1, 2, 3]
+* ```
+*
+* @see {@link equals} — the underlying comparison function
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const asEquivalence = () => equals;
+/**
+* Marks an object permanently to use reference equality, without creating a proxy.
+*
+* **When to use**
+*
+* Use when you need reference equality without proxy allocation and accept
+* permanently marking the original object for reference-only equality.
+*
+* **Details**
+*
+* - Adds `obj` to an internal WeakSet. From that point on, {@link equals}
+*   treats it as reference-only.
+* - Returns the **same** object (not a copy or proxy), so
+*   `byReferenceUnsafe(x) === x`.
+* - Does **not** affect the object's prototype, properties, or behavior
+*   beyond equality checks.
+*
+* **Gotchas**
+*
+* The marking is irreversible for the lifetime of the object.
+*
+* **Example** (Marking an object for reference equality)
+*
+* ```ts import.meta.vitest
+* import { Equal } from "effect"
+*
+* const obj1 = { a: 1, b: 2 }
+* const obj2 = { a: 1, b: 2 }
+*
+* const marked = Equal.byReferenceUnsafe(obj1)
+*
+* Equal.equals(obj1, obj2) // => false
+* Equal.equals(obj1, obj1) // => true
+* marked === obj1 // => true
+* ```
+*
+* @see {@link byReference} — safer alternative that creates a proxy
+* @see {@link equals} — the comparison function affected by this opt-out
+* @stability stable
+* @category unsafe
+* @since 4.0.0
+*/
+const byReferenceUnsafe = (obj) => {
+	byReferenceInstances.add(obj);
+	return obj;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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.meta.vitest
+* import { Context, Redactable } from "effect"
+*
+* class ApiKey {
+*   constructor(readonly raw: string) {}
+*
+*   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
+*     return this.raw.slice(0, 4) + "..."
+*   }
+* }
+*
+* Redactable.redact(new ApiKey("secret-key")) // => "secr..."
+* ```
+*
+* @see {@link Redactable} for the interface this symbol belongs to
+* @see {@link isRedactable} to check whether a value has this symbol
+* @stability stable
+* @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
+* @stability stable
+* @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
+* @stability stable
+* @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
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+function getRedacted(redactable) {
+	return redactable[symbolRedactable](globalThis["~effect/Fiber/currentFiber"]?.context ?? emptyContext);
+}
+/** @internal */
+const currentFiberTypeId = "~effect/Fiber/currentFiber";
+const emptyMap = /*#__PURE__*/ new Map();
+const emptyContext = {
+	"~effect/Context": {},
+	base: emptyMap,
+	depth: 0,
+	mapUnsafe: emptyMap,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Formatter.js
+/**
+* Formats JavaScript values into readable strings.
+*
+* `format` is intended for logs, diagnostics, and error messages. It handles
+* primitives, objects, arrays, dates, regular expressions, maps, sets, class
+* instances, errors, circular references, and redactable values. `formatJson`
+* wraps JSON formatting with redaction and circular-reference handling, and the
+* module also includes helpers for property keys, paths, and dates.
+*
+* @stability stable
+* @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.
+* - Failures while inspecting a value are rendered as diagnostic placeholders 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** (Formatting compact output)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* Formatter.format({ a: 1, b: [2, 3] }) // => "{\"a\":1,\"b\":[2,3]}"
+* ```
+*
+* **Example** (Pretty-printed output)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* const output = Formatter.format({ a: 1, b: [2, 3] }, { space: 2 })
+* output // => "{\n  \"a\": 1,\n  \"b\": [\n    2,\n    3\n  ]\n}"
+* ```
+*
+* **Example** (Handling circular references)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* const obj: any = { name: "loop" }
+* obj.self = obj
+* Formatter.format(obj) // => "{\"name\":\"loop\",\"self\":[Circular]}"
+* ```
+*
+* @see {@link formatJson}
+* @see {@link Formatter}
+* @stability stable
+* @category formatting
+* @since 2.0.0
+*/
+function format(input, options) {
+	const space = options?.space ?? 0;
+	const ancestors = /* @__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) {
+		try {
+			return recurUnsafe(v, d);
+		} catch {
+			if (typeof v === "object" && v !== null || typeof v === "function") ancestors.delete(v);
+			return "[inspection threw]";
+		}
+	}
+	function recurUnsafe(v, d = 0) {
+		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 (ancestors.has(v)) return CIRCULAR;
+			ancestors.add(v);
+			let output;
+			if (symbolRedactable in v) output = recur(getRedacted(v), d);
+			else if (Array.isArray(v)) output = !gap || v.length <= 1 ? `[${v.map((x) => recur(x, d)).join(",")}]` : `[\n${ind(d + 1)}${v.map((x) => recur(x, d + 1)).join(",\n" + ind(d + 1))}\n${ind(d)}]`;
+			else if (v instanceof Date) output = formatDate(v);
+			else if (!options?.ignoreToString && hasProperty(v, "toString") && typeof v["toString"] === "function" && v["toString"] !== Object.prototype.toString && v["toString"] !== Array.prototype.toString) {
+				const s = safeToString(v);
+				output = v instanceof Error && v.cause !== void 0 ? `${s} (cause: ${recur(v.cause, d)})` : s;
+			} else if (Symbol.iterator in v) output = `${v.constructor.name}(${recur(Array.from(v), d)})`;
+			else {
+				const keys = ownKeys(v);
+				if (!gap || keys.length <= 1) {
+					const body = `{${keys.map((k) => `${formatPropertyKey(k)}:${recur(safeGet(v, k), d)}`).join(",")}}`;
+					output = wrap(v, body);
+				} else {
+					const body = `{\n${keys.map((k) => `${ind(d + 1)}${formatPropertyKey(k)}: ${recur(safeGet(v, k), d + 1)}`).join(",\n")}\n${ind(d)}}`;
+					output = wrap(v, body);
+				}
+			}
+			ancestors.delete(v);
+			return output;
+		}
+		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]";
+	}
+}
+function safeGet(input, key) {
+	try {
+		return input[key];
+	} catch {
+		return "[property access 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. `BigInt` values are stringified with an `n` suffix.
+* `Error` instances without a `toJSON` property include their enumerable
+* properties plus `name` and `message`. Errors with `toJSON` keep their custom
+* representation. Other values follow standard `JSON.stringify` behavior. The
+* `space` parameter controls indentation and defaults to `0`.
+*
+* **Gotchas**
+*
+* When the root input is `undefined`, a symbol, or a function, `formatJson`
+* returns `"null"` instead of the `undefined` returned by `JSON.stringify`.
+* Nested values retain standard `JSON.stringify` behavior.
+*
+* **Example** (Formatting compact JSON)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* Formatter.formatJson({ name: "Alice", age: 30 }) // => "{\"name\":\"Alice\",\"age\":30}"
+* ```
+*
+* **Example** (Handling circular references)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* const obj: any = { name: "test" }
+* obj.self = obj
+* Formatter.formatJson(obj) // => "{\"name\":\"test\"}"
+* ```
+*
+* **Example** (Pretty-printed JSON)
+*
+* ```ts import.meta.vitest
+* import { Formatter } from "effect"
+*
+* const output = Formatter.formatJson({ name: "Alice", age: 30 }, { space: 2 })
+* output // => "{\n  \"name\": \"Alice\",\n  \"age\": 30\n}"
+* ```
+*
+* @see {@link format}
+* @see {@link Formatter}
+* @stability stable
+* @category serialization
+* @since 4.0.0
+*/
+function formatJson(input, options) {
+	const ancestors = [];
+	const sources = /* @__PURE__ */ new WeakMap();
+	return JSON.stringify(input, function(key, value) {
+		const original = Object.getOwnPropertyDescriptor(sources.get(this) ?? this, key)?.value;
+		const redacted = hasProperty(original, symbolRedactable) ? redact(original) : redact(value);
+		if (typeof redacted === "bigint") return format(redacted);
+		if (typeof redacted !== "object" || redacted === null) return redacted;
+		const current = redacted instanceof Error && !hasProperty(redacted, "toJSON") ? {
+			...redacted,
+			name: redacted.name,
+			message: redacted.message
+		} : redacted;
+		while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop();
+		if (ancestors.includes(redacted)) return;
+		ancestors.push(redacted);
+		if (current !== redacted) ancestors.push(current);
+		if (!hasGetter(current) || isJsonPrimitiveWrapper(current)) return current;
+		const view = redactingView(current);
+		sources.set(view, current);
+		ancestors.push(view);
+		return view;
+	}, options?.space) ?? "null";
+}
+function hasGetter(object) {
+	for (const key of Object.getOwnPropertyNames(object)) if (Object.getOwnPropertyDescriptor(object, key)?.get !== void 0) return true;
+	return false;
+}
+function redactingView(object) {
+	const view = Array.isArray(object) ? [] : {};
+	const keys = Array.isArray(object) ? Array.from({ length: object.length }, (_, i) => String(i)) : Object.keys(object);
+	for (const key of keys) Object.defineProperty(view, key, {
+		enumerable: true,
+		get: () => {
+			const value = Reflect.get(object, key);
+			return Object.getOwnPropertyDescriptor(object, key)?.get !== void 0 ? redact(value) : value;
+		}
+	});
+	return view;
+}
+function isJsonPrimitiveWrapper(object) {
+	for (const valueOf of [
+		Number.prototype.valueOf,
+		Boolean.prototype.valueOf,
+		String.prototype.valueOf
+	]) try {
+		Reflect.apply(valueOf, object, []);
+		return true;
+	} catch {}
+	return false;
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Inspectable.js
+/**
+* Controls how values appear in logs and debugging output.
+*
+* Effect data types use `Inspectable` to provide stable string, JSON, and
+* Node.js inspection output. This keeps custom values readable in logs, REPLs,
+* test failures, and diagnostics. This module defines the Node inspect symbol,
+* the `Inspectable` interface, safe conversion helpers, and shared prototype or
+* class implementations for custom values.
+*
+* @stability stable
+* @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.meta.vitest
+* import { Inspectable } from "effect"
+*
+* class CustomObject {
+*   constructor(private value: string) {}
+*
+*   [Inspectable.NodeInspectSymbol]() {
+*     return `CustomObject(${this.value})`
+*   }
+* }
+*
+* const obj = new CustomObject("hello")
+* obj[Inspectable.NodeInspectSymbol]() // => "CustomObject(hello)"
+* ```
+*
+* @stability stable
+* @category symbols
+* @since 2.0.0
+*/
+const NodeInspectSymbol = /*#__PURE__*/ Symbol.for("nodejs.util.inspect.custom");
+/**
+* Converts a value to its structured inspection representation.
+*
+* **When to use**
+*
+* Use when you need the structured representation of an inspectable value
+* without risking unhandled errors.
+*
+* **Details**
+*
+* This function applies redaction before extracting data from objects that
+* implement `toJSON`, recursively processes arrays, and handles errors
+* gracefully. Plain objects are returned unchanged, so the result is not
+* guaranteed to be accepted by `JSON.stringify`; it may still contain values
+* such as `BigInt`, functions, or circular references.
+*
+* @see {@link toStringUnknown} for converting unknown values to strings
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const toJson = (input) => {
+	try {
+		input = redact(input);
+		if (hasProperty(input, "toJSON") && isFunction(input["toJSON"]) && input["toJSON"].length === 0) return input.toJSON();
+		else if (Array.isArray(input)) return input.map(toJson);
+		return input;
+	} catch {
+		return "[toJSON threw]";
+	}
+};
+/**
+* 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`.
+*
+* @stability stable
+* @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 }) : format(u, { space: whitespace });
+	} 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.meta.vitest
+* import { Inspectable } from "effect"
+*
+* // Use as prototype
+* const myObject = Object.create(Inspectable.BaseProto)
+* myObject.name = "example"
+* myObject.value = 42
+*
+* myObject.toString() // => "\"[toJSON threw]\""
+*
+* // Or extend in a constructor
+* function MyClass(this: any, name: string) {
+*   this.name = name
+* }
+* MyClass.prototype = Object.create(Inspectable.BaseProto)
+* MyClass.prototype.constructor = MyClass
+* ```
+*
+* @stability stable
+* @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.meta.vitest
+* 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")
+* user.toString() // => "{\"_tag\":\"User\",\"id\":1,\"name\":\"Alice\",\"email\":\"alice@example.com\"}"
+* user[Inspectable.NodeInspectSymbol]() // => { _tag: "User", id: 1, name: "Alice", email: "alice@example.com" }
+* ```
+*
+* @stability stable
+* @category models
+* @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());
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/stackTraceLimit.js
+/**
+* Check if `Error.stackTraceLimit` is writable.
+* Returns `false` if the property is frozen, non-writable, or `Error` is non-extensible.
+*
+* @internal
+*/
+const isStackTraceLimitWritable = () => {
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === void 0) return Object.isExtensible(Error);
+	return Object.hasOwn(desc, "writable") ? desc.writable === true : desc.set !== void 0;
+};
+const canWriteStackTraceLimit = /*#__PURE__*/ isStackTraceLimitWritable();
+/**
+* Get the current `Error.stackTraceLimit` value.
+* Returns `undefined` if the property doesn't exist.
+*
+* @internal
+*/
+const getStackTraceLimit = () => Error.stackTraceLimit;
+/**
+* Safely set `Error.stackTraceLimit` if possible, otherwise no-op.
+*
+* Accepts `undefined` so a value read via {@link getStackTraceLimit} can be
+* restored faithfully.
+*
+* @internal
+*/
+const setStackTraceLimit = (value) => {
+	if (canWriteStackTraceLimit) Error.stackTraceLimit = value;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Utils.js
+/**
+* Yields its wrapped value exactly once, then completes with the value sent
+* back in.
+*
+* **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 a fresh `{ value: self, done: false }`.
+* Every subsequent call returns `{ value: a, done: true }` where `a` is the
+* argument passed to `next()`. To keep `yield*` cheap, the completion result
+* is the iterator itself rather than a new object, so only the iterator and
+* the single yielded result are allocated per `yield*`.
+*
+* **Example** (Yielding a wrapped value in a generator)
+*
+* ```ts import.meta.vitest
+* import { Utils } from "effect"
+*
+* const gen = new Utils.SingleShotGen<string, number>("hello")
+*
+* gen.next(0).value // => "hello"
+*
+* gen.next(42).value // => 42
+* ```
+*
+* @see {@link Gen} for the type-level signature that relies on `SingleShotGen`
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+var SingleShotGen = class {
+	constructor(self) {
+		this.value = self;
+		this.done = false;
+	}
+	/**
+	* 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) {
+		if (this.done) {
+			this.value = a;
+			return this;
+		}
+		this.done = true;
+		return {
+			value: this.value,
+			done: false
+		};
+	}
+};
+const pickInternalCall = () => {
+	const InternalTypeId = "~effect/Utils/internal";
+	const standard = { [InternalTypeId]: (body) => {
+		return body();
+	} };
+	const forced = { [InternalTypeId]: (body) => {
+		try {
+			return body();
+		} finally {}
+	} };
+	const limit = getStackTraceLimit();
+	if (limit === 0) return forced[InternalTypeId];
+	setStackTraceLimit(2);
+	const error = standard[InternalTypeId](() => /* @__PURE__ */ new Error());
+	setStackTraceLimit(limit);
+	return error.stack?.includes(InternalTypeId) === true ? standard[InternalTypeId] : forced[InternalTypeId];
+};
+/** @internal */
+const internalCall = /*#__PURE__*/ pickInternalCall();
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/record.js
+/** @internal */
+function assignProperty(self, key, value) {
+	if (key === "__proto__") Object.defineProperty(self, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	else self[key] = value;
+}
+/** @internal */
+function assignProperties(self, source) {
+	if (!Object.hasOwn(source, "__proto__")) {
+		Object.assign(self, source);
+		return;
+	}
+	for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProperty(self, key, source[key]);
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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],
+			..."~effect/Effect/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 {
+	constructor(failures) {
+		this[CauseTypeId] = CauseTypeId;
+		this.reasons = failures;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	toJSON() {
+		return {
+			_id: "Cause",
+			reasons: 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);
+		});
+		if (options?.overwrite !== true && newAnnotations.size === this.annotations.size) return this;
+		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 {
+	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);
+const dedupeReasons = (self, that) => {
+	const buckets = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const reason of self.concat(that)) {
+		const hash$1 = hash(reason);
+		const bucket = buckets.get(hash$1);
+		if (bucket === void 0) buckets.set(hash$1, [reason]);
+		else if (bucket.some((previous) => equals(previous, reason))) continue;
+		else bucket.push(reason);
+		out.push(reason);
+	}
+	return out;
+};
+/** @internal */
+const causeCombine = /*#__PURE__*/ dual(2, (self, that) => {
+	if (self.reasons.length === 0) return that;
+	else if (that.reasons.length === 0) return self;
+	const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
+	return equals(self, newCause) ? self : newCause;
+});
+/**
+* Appends the interrupts from `interrupts` that `self` does not contain yet.
+* Unlike `causeCombine`, it never calls hash or equality methods, which can be
+* user-defined, random, or throwing.
+*
+* @internal
+*/
+const causeAddInterrupts = (self, interrupts) => {
+	const reasons = self.reasons.slice();
+	for (const reason of interrupts.reasons) if (isInterruptReason(reason) && !reasons.some((r) => isInterruptReason(r) && r.fiberId === reason.fiberId && r.annotations === reason.annotations)) reasons.push(reason);
+	return reasons.length === self.reasons.length ? self : new CauseImpl(reasons);
+};
+/** @internal */
+const causeEmpty = /*#__PURE__*/ new CauseImpl([]);
+/** @internal */
+const causeFail = (error) => new CauseImpl([new Fail(error)]);
+/** @internal */
+var Die = class extends ReasonBase {
+	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["~effect/Effect/evaluate"] ?? defaultEvaluate,
+	[contA]: options[contA],
+	[contE]: options[contE],
+	[contAll]: options[contAll]
+});
+/** @internal */
+const makePrimitive = (options) => {
+	const Proto = makePrimitiveProto(options);
+	const PrimitiveImpl = function(value) {
+		this[args] = value;
+	};
+	PrimitiveImpl.prototype = Proto;
+	return function(value) {
+		return new PrimitiveImpl(value);
+	};
+};
+/** @internal */
+const makeExit = (options) => {
+	const Proto = {
+		[ExitTypeId]: ExitTypeId,
+		_tag: options.op,
+		get [options.prop]() {
+			return this[args];
+		},
+		...makePrimitiveProto(options),
+		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["~effect/Effect/args"], that["~effect/Effect/args"]);
+		},
+		[symbol$1]() {
+			return combine(string(options.op), hash(this[args]));
+		}
+	};
+	const ExitPrimitive = function(value) {
+		this[args] = value;
+	};
+	ExitPrimitive.prototype = Proto;
+	return function(value) {
+		return new ExitPrimitive(value);
+	};
+};
+/** @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.cache.stackFrame) {
+			cause = causeAnnotate(cause, { mapUnsafe: /* @__PURE__ */ new Map([[StackTraceKey.key, fiber.cache.stackFrame]]) });
+			annotated = true;
+		}
+		let cont = fiber.getCont(contE);
+		const interruptedCause = fiber._interruptedCause;
+		if (interruptedCause && fiber.interruptible) {
+			let skippedHandler = false;
+			while (cont && fiber.interruptible) {
+				skippedHandler ||= identifier in cont;
+				cont = fiber.getCont(contE);
+			}
+			if (skippedHandler) cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
+			cause = causeAddInterrupts(cause, interruptedCause);
+			annotated = true;
+		}
+		return cont ? cont[contE](cause, fiber, annotated ? void 0 : this) : fiber.yieldWith(annotated ? exitFailCause(cause) : this);
+	}
+});
+/** @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) {
+				assignProperties(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;
+};
+/** @internal */
+const NoSuchElementErrorTypeId = "~effect/Cause/NoSuchElementError";
+/** @internal */
+var NoSuchElementError = class extends (/*#__PURE__*/ TaggedError("NoSuchElementError")) {
+	[NoSuchElementErrorTypeId] = NoSuchElementErrorTypeId;
+	constructor(message) {
+		super({ message });
+	}
+};
+/** @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));
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/option.js
+/**
+* @since 2.0.0
+*/
+const TypeId = "~effect/Option";
+const CommonProto = {
+	[TypeId]: { _A: (_) => _ },
+	...PipeInspectableProto,
+	[Symbol.iterator]() {
+		return new SingleShotGen(this);
+	}
+};
+const SomeProto = /*#__PURE__*/ Object.defineProperty(/*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
+	_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)
+		};
+	}
+}), "valueOrUndefined", { get() {
+	return this.value;
+} });
+const NoneHash = /*#__PURE__*/ hash("None");
+const NoneProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
+	_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);
+/** @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 SomeImpl = function(value) {
+	this.value = value;
+};
+SomeImpl.prototype = SomeProto;
+/** @internal */
+const some$1 = (value) => new SomeImpl(value);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/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.meta.vitest
+* import { Option } from "effect"
+*
+* //      ┌─── Option<never>
+* //      ▼
+* const noValue = Option.none() // => Option.none()
+* ```
+*
+* @see {@link some} for the opposite operation.
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* //      ┌─── Option<number>
+* //      ▼
+* const value = Option.some(1) // => Option.some(1)
+* ```
+*
+* @see {@link none} for the opposite operation.
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.isOption(Option.some(1)) // => true
+* Option.isOption(Option.none()) // => true
+* Option.isOption({}) // => false
+* ```
+*
+* @see {@link isNone} to check for `None` specifically
+* @see {@link isSome} to check for `Some` specifically
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.isNone(Option.some(1)) // => false
+* Option.isNone(Option.none()) // => true
+* ```
+*
+* @see {@link isSome} for the opposite check.
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.isSome(Option.some(1)) // => true
+* Option.isSome(Option.none()) // => false
+* ```
+*
+* @see {@link isNone} for the opposite check.
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.match(Option.some(1), {
+*   onNone: () => "Option is empty",
+*   onSome: (value) => `Option has a value: ${value}`
+* }) // => "Option has a value: 1"
+* ```
+*
+* @see {@link getOrElse} for unwrapping with a default
+*
+* @stability stable
+* @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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.some(1).pipe(Option.getOrElse(() => 0)) // => 1
+* Option.none().pipe(Option.getOrElse(() => 0)) // => 0
+* ```
+*
+* @see {@link getOrNull} to fall back to `null`
+* @see {@link getOrUndefined} to fall back to `undefined`
+* @see {@link getOrThrow} to throw on `None`
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const getOrElse = /*#__PURE__*/ dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);
+/**
+* Returns the fallback `Option` if `self` is `None`; otherwise returns `self`.
+*
+* **When to use**
+*
+* Use when you need a lazy fallback `Option`, such as when building priority
+* chains of optional values.
+*
+* **Details**
+*
+* - `Some` → returns `self` unchanged
+* - `None` → evaluates and returns `that()`
+* - `that` is lazily evaluated
+*
+* **Example** (Providing a fallback Option)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.none().pipe(Option.orElse(() => Option.some("b"))) // => Option.some("b")
+* Option.some("a").pipe(Option.orElse(() => Option.some("b"))) // => Option.some("a")
+* ```
+*
+* @see {@link orElseSome} to wrap the fallback value in `Some` automatically
+* @see {@link firstSomeOf} to pick the first `Some` from a collection
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const orElse = /*#__PURE__*/ dual(2, (self, that) => isNone(self) ? that() : self);
+/**
+* Returns the first `Some` found in an iterable of `Option`s, or `None` if
+* all are `None`.
+*
+* **When to use**
+*
+* Use when you need the first available `Some` value from a priority list.
+*
+* **Details**
+*
+* - Short-circuits on the first `Some`
+* - Returns `None` only when every element is `None`
+*
+* **Example** (Finding the first Some)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.firstSomeOf([
+*   Option.none(),
+*   Option.some(1),
+*   Option.some(2)
+* ]) // => Option.some(1)
+* ```
+*
+* @see {@link orElse} for a two-option fallback
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const firstSomeOf = (collection) => {
+	let out = none();
+	for (out of collection) if (isSome(out)) return out;
+	return out;
+};
+/**
+* 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** (Converting nullable values to an Option)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.fromNullishOr(undefined) // => Option.none()
+* Option.fromNullishOr(null) // => Option.none()
+* Option.fromNullishOr(1) // => Option.some(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
+*
+* @stability stable
+* @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** (Converting possibly undefined values to an Option)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.fromUndefinedOr(undefined) // => Option.none()
+* Option.fromUndefinedOr(null) // => Option.some(null)
+* Option.fromUndefinedOr(42) // => Option.some(42)
+* ```
+*
+* @see {@link fromNullishOr} to treat both `null` and `undefined` as absent
+* @see {@link fromNullOr} to only treat `null` as absent
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const fromUndefinedOr = (a) => a === void 0 ? none() : some(a);
+/**
+* Converts a possibly `null` value into an `Option`, leaving `undefined`
+* as a valid `Some`.
+*
+* **When to use**
+*
+* Use when you want to treat only `null` as absent while preserving
+* `undefined` as a meaningful value.
+*
+* **Details**
+*
+* - `null` → `None`
+* - Any other value (including `undefined`) → `Some`
+*
+* **Example** (Converting possibly null values to an Option)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.fromNullOr(null) // => Option.none()
+* Option.fromNullOr(undefined) // => Option.some(undefined)
+* Option.fromNullOr(42) // => Option.some(42)
+* ```
+*
+* @see {@link fromNullishOr} to treat both `null` and `undefined` as absent
+* @see {@link fromUndefinedOr} to only treat `undefined` as absent
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const fromNullOr = (a) => a === null ? none() : some(a);
+/**
+* Extracts the value from a `Some`, or returns `null` for `None`.
+*
+* **When to use**
+*
+* Use when you need to pass absent `Option` values to APIs that expect `null`.
+*
+* **Details**
+*
+* - `Some` → the inner value
+* - `None` → `null`
+*
+* **Example** (Unwrapping to null)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.getOrNull(Option.some(1)) // => 1
+* Option.getOrNull(Option.none()) // => null
+* ```
+*
+* @see {@link getOrUndefined} to return `undefined` instead
+* @see {@link getOrElse} for a custom fallback
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const getOrNull = /*#__PURE__*/ getOrElse(constNull);
+/**
+* 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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.getOrUndefined(Option.some(1)) // => 1
+* Option.getOrUndefined(Option.none()) // => undefined
+* ```
+*
+* @see {@link getOrNull} to return `null` instead
+* @see {@link getOrElse} for a custom fallback
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const getOrUndefined = /*#__PURE__*/ getOrElse(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.meta.vitest
+* import { Option } from "effect"
+*
+* const parse = Option.liftThrowable(JSON.parse)
+*
+* parse("1") // => Option.some(1)
+* parse("") // => Option.none()
+* ```
+*
+* @see {@link liftNullishOr} for nullable-returning functions
+*
+* @stability stable
+* @category converting
+* @since 2.0.0
+*/
+const liftThrowable = (f) => (...a) => {
+	try {
+		return some(f(...a));
+	} catch {
+		return 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.meta.vitest
+* import { Option } from "effect"
+*
+* Option.map(Option.some(2), (n) => n * 2) // => Option.some(4)
+* Option.map(Option.none(), (n: number) => n * 2) // => Option.none()
+* ```
+*
+* @see {@link flatMap} when `f` returns an `Option`
+* @see {@link as} to replace the value with a constant
+*
+* @stability stable
+* @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.meta.vitest
+* 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") })
+* }
+*
+* user.address.pipe(
+*   Option.flatMap((addr) => addr.street)
+* ) // => Option.some("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>>`
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
+/**
+* Combines {@link flatMap} with {@link fromNullishOr}: applies a function that
+* may return `null`/`undefined` to the value of a `Some`.
+*
+* **When to use**
+*
+* Use when you need to chain optional computations that use `null` or
+* `undefined` instead of `Option`, such as nested property access.
+*
+* **Details**
+*
+* - `None` → `None`
+* - `Some` → applies `f`, then wraps via {@link fromNullishOr}
+*
+* **Example** (Navigating optional properties)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* interface Employee {
+*   company?: { address?: { street?: { name?: string } } }
+* }
+*
+* const emp: Employee = {
+*   company: { address: { street: { name: "high street" } } }
+* }
+*
+* Option.some(emp).pipe(
+*   Option.flatMapNullishOr((e) => e.company?.address?.street?.name)
+* ) // => Option.some("high street")
+* ```
+*
+* @see {@link flatMap} when the function already returns `Option`
+* @see {@link fromNullishOr} for single-value conversion
+*
+* @stability stable
+* @category sequencing
+* @since 4.0.0
+*/
+const flatMapNullishOr = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : fromNullishOr(f(self.value)));
+/**
+* Flattens a nested `Option<Option<A>>` into `Option<A>`.
+*
+* **When to use**
+*
+* Use when you need to remove one layer of nested `Option`.
+*
+* **Details**
+*
+* - `Some(Some(value))` → `Some(value)`
+* - `Some(None)` → `None`
+* - `None` → `None`
+*
+* **Example** (Flattening nested Options)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.flatten(Option.some(Option.some("value"))) // => Option.some("value")
+* Option.flatten(Option.some(Option.none())) // => Option.none()
+* ```
+*
+* @see {@link flatMap} which is `map` + `flatten`
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatten = /*#__PURE__*/ flatMap(identity);
+/**
+* Combines a structure of `Option`s (tuple, struct, or iterable) into a single
+* `Option` containing the unwrapped structure.
+*
+* **When to use**
+*
+* Use when you need to combine multiple `Option` values into one while
+* preserving the input shape, with any `None` making the result `None`.
+*
+* **Details**
+*
+* - Tuple input → `Option` of a tuple with the same length
+* - Struct input → `Option` of a struct with the same keys
+* - Iterable input → `Option` of an `Array`
+* - Any `None` in the input → entire result is `None`
+*
+* **Example** (Combining a tuple and a struct)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* const maybeName: Option.Option<string> = Option.some("John")
+* const maybeAge: Option.Option<number> = Option.some(25)
+*
+* //      ┌─── Option<[string, number]>
+* //      ▼
+* const tuple = Option.all([maybeName, maybeAge]) // => Option.some(["John", 25])
+*
+* //      ┌─── Option<{ name: string; age: number; }>
+* //      ▼
+* const struct = Option.all({ name: maybeName, age: maybeAge }) // => Option.some({ name: "John", age: 25 })
+* ```
+*
+* @see {@link product} for combining exactly two
+* @see {@link productMany} for a homogeneous collection
+*
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const all = (input) => {
+	if (Symbol.iterator in input) {
+		const out = [];
+		for (const o of input) {
+			if (isNone(o)) return none();
+			out.push(o.value);
+		}
+		return some(out);
+	}
+	const out = {};
+	for (const key of Object.keys(input)) {
+		const o = input[key];
+		if (isNone(o)) return none();
+		assignProperty(out, key, o.value);
+	}
+	return some(out);
+};
+/**
+* Converts an `Option` into an `Array`.
+*
+* **When to use**
+*
+* Use when you need to pass an `Option` to array-based APIs or spread optional
+* values into collections.
+*
+* **Details**
+*
+* - `Some` → single-element array `[value]`
+* - `None` → empty array `[]`
+*
+* **Example** (Converting to an array)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.toArray(Option.some(1)) // => [1]
+* Option.toArray(Option.none()) // => []
+* ```
+*
+* @see {@link fromIterable} for the inverse direction
+*
+* @stability stable
+* @category converting
+* @since 2.0.0
+*/
+const toArray = (self) => isNone(self) ? [] : [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.meta.vitest
+* import { Option } from "effect"
+*
+* const removeEmpty = (input: Option.Option<string>) =>
+*   Option.filter(input, (value) => value !== "")
+*
+* removeEmpty(Option.some("hello")) // => Option.some("hello")
+* removeEmpty(Option.some("")) // => Option.none()
+* removeEmpty(Option.none()) // => Option.none()
+* ```
+*
+* @see {@link filterMap} to transform and filter simultaneously
+* @see {@link exists} to test without filtering
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filter = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());
+/**
+* Lifts a `Predicate` or `Refinement` into the `Option` context: returns
+* `Some(value)` when the predicate holds, `None` otherwise.
+*
+* **When to use**
+*
+* Use to convert a boolean check into an `Option`-returning function
+* - Validating input and wrapping it in `Option`
+*
+* **Details**
+*
+* - `predicate(value)` is `true` → `Some(value)`
+* - `predicate(value)` is `false` → `None`
+* - Supports refinements for type narrowing
+*
+* **Example** (Validating positive numbers)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* const parsePositive = Option.liftPredicate((n: number) => n > 0)
+*
+* parsePositive(1) // => Option.some(1)
+* parsePositive(-1) // => Option.none()
+* ```
+*
+* @see {@link filter} to apply a predicate to an existing `Option`
+* @see {@link toRefinement} for the inverse direction
+*
+* @stability stable
+* @category lifting
+* @since 2.0.0
+*/
+const liftPredicate = /*#__PURE__*/ dual(2, (b, predicate) => predicate(b) ? some(b) : none());
+/**
+* Checks whether an `Option` contains a value equivalent to the given one, using a
+* custom `Equivalence`.
+*
+* **When to use**
+*
+* Use when you need to test whether an `Option` contains a value using a
+* custom equality check.
+*
+* **Details**
+*
+* - `Some` where `isEquivalent(value, a)` is `true` → `true`
+* - `Some` where not equivalent, or `None` → `false`
+*
+* **Example** (Checking with custom equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equivalence, Option } from "effect"
+*
+* const check = Option.containsWith(Equivalence.strictEqual<number>())
+*
+* Option.some(2).pipe(check(2)) // => true
+* Option.some(1).pipe(check(2)) // => false
+* Option.none().pipe(check(2)) // => false
+* ```
+*
+* @see {@link contains} for a version using default equality
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const containsWith = (isEquivalent) => dual(2, (self, a) => isNone(self) ? false : isEquivalent(self.value, a));
+/**
+* Checks whether an `Option` contains a value equal to the given one, using default
+* structural equality.
+*
+* **When to use**
+*
+* Use when you need a quick membership test for an `Option` value using
+* standard equality.
+*
+* **Details**
+*
+* - `Some` where `Equal.equals(value, a)` is `true` → `true`
+* - `Some` where not equal, or `None` → `false`
+*
+* **Example** (Checking containment)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.some(2).pipe(Option.contains(2)) // => true
+* Option.some(1).pipe(Option.contains(2)) // => false
+* Option.none().pipe(Option.contains(2)) // => false
+* ```
+*
+* @see {@link containsWith} for custom equality
+* @see {@link exists} to test with a predicate
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const contains = /*#__PURE__*/ containsWith(/*#__PURE__*/ asEquivalence());
+/**
+* Checks whether the value in a `Some` satisfies a predicate or refinement.
+*
+* **When to use**
+*
+* Use to check a condition on an optional value without unwrapping
+*
+* **Details**
+*
+* - `None` → `false`
+* - `Some` where `predicate(value)` is `true` → `true`
+* - `Some` where `predicate(value)` is `false` → `false`
+* - With a refinement, narrows the `Option` type on `true`
+*
+* **Example** (Testing a condition)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* const isEven = (n: number) => n % 2 === 0
+*
+* Option.some(2).pipe(Option.exists(isEven)) // => true
+* Option.some(1).pipe(Option.exists(isEven)) // => false
+* Option.none().pipe(Option.exists(isEven)) // => false
+* ```
+*
+* @see {@link filter} to keep or discard based on a predicate
+* @see {@link contains} to test for a specific value
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const exists = /*#__PURE__*/ dual(2, (self, refinement) => isNone(self) ? false : refinement(self.value));
+export { evaluate as $, isNever as $t, Error$1 as A, formatPropertyKey as At, args as B, hash as Bt, orElse as C, memoize as Cn, NodeInspectSymbol as Ct, CauseImpl as D, Prototype as Dn, formatDate as Dt, isNone$1 as E, Class$1 as En, format as Et, PipeInspectableProto as F, byReferenceUnsafe as Ft, causeEmpty as G, structureKeys as Gt, causeAnnotate as H, optimize as Ht, ReasonBase as I, equals as It, constEmptyAnnotations as J, isBigInt as Jt, causeFail as K, symbol$1 as Kt, StackTraceKey as L, symbol as Lt, Fail as M, redact as Mt, InterruptorStackTrace as N, symbolRedactable as Nt, Die as O, pipeArguments as On, formatJson as Ot, NoSuchElementError as P, asEquivalence as Pt, done as Q, isIterable as Qt, TaggedError as R, array as Rt, none as S, identity as Sn, Class as St, toArray as T, pipe as Tn, toStringUnknown as Tt, causeCombine as U, string as Ut, causeAddInterrupts as V, number as Vt, causeDie as W, structure as Wt, contAll as X, isError as Xt, contA as Y, isBoolean as Yt, contE as Z, isFunction as Zt, isSome as _, constUndefined as _n, SingleShotGen as _t, firstSomeOf as a, isObject as an, isCauseReason as at, map as b, dual as bn, setStackTraceLimit as bt, flatten as c, isString as cn, isEffect as ct, fromUndefinedOr as d, isUndefined as dn, isInterruptReason as dt, isNotNull as en, exitDie as et, getOrElse as f, isUnknown as fn, makePrimitive as ft, isOption as g, constTrue as gn, assignProperty as gt, isNone as h, constFalse as hn, assignProperties as ht, filter as i, isNumber as in, isCause as it, ExitTypeId as j, currentFiberTypeId as jt, Done as k, formatPath as kt, fromNullOr as l, isSymbol as ln, isExit as lt, getOrUndefined as m, backEdges as mn, withFiber as mt, contains as n, isNotUndefined as nn, exitFailCause as nt, flatMap as o, isObjectKeyword as on, isDieReason as ot, getOrNull as p, or as pn, makePrimitiveProto as pt, causeFromReasons as q, hasProperty as qt, exists as r, isNullish as rn, exitSucceed as rt, flatMapNullishOr as s, isPropertyKey as sn, isDone as st, all as t, isNotNullish as tn, exitFail as tt, fromNullishOr as u, isTagged as un, isFailReason as ut, liftPredicate as v, constVoid as vn, internalCall as vt, some as w, memoizeIdempotent as wn, toJson as wt, match as x, flow as xn, BaseProto as xt, liftThrowable as y, constant as yn, getStackTraceLimit as yt, Yield as z, combine as zt };