Add files using upload-large-folder tool

backend/node_modules/effect/dist/dts/BigInt.d.ts

@@ -0,0 +1,1033 @@
+/**
+ * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for
+ * `Equivalence` and `Order`.
+ *
+ * @module BigInt
+ * @since 2.0.0
+ * @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
+ * @see {@link module:Number} for more similar operations on `number` types
+ */
+import * as equivalence from "./Equivalence.js";
+import * as Option from "./Option.js";
+import * as order from "./Order.js";
+import type { Ordering } from "./Ordering.js";
+/**
+ * Tests if a value is a `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isBigInt } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(isBigInt(1n), true)
+ * assert.deepStrictEqual(isBigInt(1), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export declare const isBigInt: (u: unknown) => u is bigint;
+/**
+ * Provides an addition operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sum } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sum(2n, 3n), 5n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const sum: {
+    /**
+     * Provides an addition operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { sum } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(sum(2n, 3n), 5n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Provides an addition operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { sum } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(sum(2n, 3n), 5n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Provides a multiplication operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { multiply } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const multiply: {
+    /**
+     * Provides a multiplication operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { multiply } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Provides a multiplication operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { multiply } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Provides a subtraction operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { subtract } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const subtract: {
+    /**
+     * Provides a subtraction operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { subtract } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Provides a subtraction operation on `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { subtract } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Provides a division operation on `bigint`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Returns `None` if the divisor is `0n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const divide: {
+    /**
+     * Provides a division operation on `bigint`s.
+     *
+     * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+     * which represents the integer division rounded down to the nearest integer.
+     *
+     * Returns `None` if the divisor is `0n`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt, Option } from "effect"
+     *
+     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => Option.Option<bigint>;
+    /**
+     * Provides a division operation on `bigint`s.
+     *
+     * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+     * which represents the integer division rounded down to the nearest integer.
+     *
+     * Returns `None` if the divisor is `0n`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt, Option } from "effect"
+     *
+     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): Option.Option<bigint>;
+};
+/**
+ * Provides a division operation on `bigint`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Throws a `RangeError` if the divisor is `0n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeDivide } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
+ * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const unsafeDivide: {
+    /**
+     * Provides a division operation on `bigint`s.
+     *
+     * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+     * which represents the integer division rounded down to the nearest integer.
+     *
+     * Throws a `RangeError` if the divisor is `0n`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { unsafeDivide } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
+     * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Provides a division operation on `bigint`s.
+     *
+     * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+     * which represents the integer division rounded down to the nearest integer.
+     *
+     * Throws a `RangeError` if the divisor is `0n`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { unsafeDivide } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
+     * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Returns the result of adding `1n` to a given number.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { increment } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(increment(2n), 3n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const increment: (n: bigint) => bigint;
+/**
+ * Decrements a number by `1n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { decrement } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(decrement(3n), 2n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const decrement: (n: bigint) => bigint;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const Equivalence: equivalence.Equivalence<bigint>;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const Order: order.Order<bigint>;
+/**
+ * Returns `true` if the first argument is less than the second, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThan } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lessThan(2n, 3n), true)
+ * assert.deepStrictEqual(lessThan(3n, 3n), false)
+ * assert.deepStrictEqual(lessThan(4n, 3n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export declare const lessThan: {
+    /**
+     * Returns `true` if the first argument is less than the second, otherwise `false`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lessThan } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lessThan(2n, 3n), true)
+     * assert.deepStrictEqual(lessThan(3n, 3n), false)
+     * assert.deepStrictEqual(lessThan(4n, 3n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => boolean;
+    /**
+     * Returns `true` if the first argument is less than the second, otherwise `false`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lessThan } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lessThan(2n, 3n), true)
+     * assert.deepStrictEqual(lessThan(3n, 3n), false)
+     * assert.deepStrictEqual(lessThan(4n, 3n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): boolean;
+};
+/**
+ * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThanOrEqualTo } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lessThanOrEqualTo(2n, 3n), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(4n, 3n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export declare const lessThanOrEqualTo: {
+    /**
+     * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lessThanOrEqualTo } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lessThanOrEqualTo(2n, 3n), true)
+     * assert.deepStrictEqual(lessThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(lessThanOrEqualTo(4n, 3n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => boolean;
+    /**
+     * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lessThanOrEqualTo } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lessThanOrEqualTo(2n, 3n), true)
+     * assert.deepStrictEqual(lessThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(lessThanOrEqualTo(4n, 3n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): boolean;
+};
+/**
+ * Returns `true` if the first argument is greater than the second, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { greaterThan } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(greaterThan(2n, 3n), false)
+ * assert.deepStrictEqual(greaterThan(3n, 3n), false)
+ * assert.deepStrictEqual(greaterThan(4n, 3n), true)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export declare const greaterThan: {
+    /**
+     * Returns `true` if the first argument is greater than the second, otherwise `false`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { greaterThan } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(greaterThan(2n, 3n), false)
+     * assert.deepStrictEqual(greaterThan(3n, 3n), false)
+     * assert.deepStrictEqual(greaterThan(4n, 3n), true)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => boolean;
+    /**
+     * Returns `true` if the first argument is greater than the second, otherwise `false`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { greaterThan } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(greaterThan(2n, 3n), false)
+     * assert.deepStrictEqual(greaterThan(3n, 3n), false)
+     * assert.deepStrictEqual(greaterThan(4n, 3n), true)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): boolean;
+};
+/**
+ * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { greaterThanOrEqualTo } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(greaterThanOrEqualTo(2n, 3n), false)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(4n, 3n), true)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export declare const greaterThanOrEqualTo: {
+    /**
+     * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { greaterThanOrEqualTo } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(greaterThanOrEqualTo(2n, 3n), false)
+     * assert.deepStrictEqual(greaterThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(greaterThanOrEqualTo(4n, 3n), true)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => boolean;
+    /**
+     * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { greaterThanOrEqualTo } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(greaterThanOrEqualTo(2n, 3n), false)
+     * assert.deepStrictEqual(greaterThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(greaterThanOrEqualTo(4n, 3n), true)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): boolean;
+};
+/**
+ * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt } from "effect"
+ *
+ * const between = BigInt.between({ minimum: 0n, maximum: 5n })
+ *
+ * assert.deepStrictEqual(between(3n), true)
+ * assert.deepStrictEqual(between(-1n), false)
+ * assert.deepStrictEqual(between(6n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export declare const between: {
+    /**
+     * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt } from "effect"
+     *
+     * const between = BigInt.between({ minimum: 0n, maximum: 5n })
+     *
+     * assert.deepStrictEqual(between(3n), true)
+     * assert.deepStrictEqual(between(-1n), false)
+     * assert.deepStrictEqual(between(6n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (options: {
+        minimum: bigint;
+        maximum: bigint;
+    }): (self: bigint) => boolean;
+    /**
+     * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt } from "effect"
+     *
+     * const between = BigInt.between({ minimum: 0n, maximum: 5n })
+     *
+     * assert.deepStrictEqual(between(3n), true)
+     * assert.deepStrictEqual(between(-1n), false)
+     * assert.deepStrictEqual(between(6n), false)
+     * ```
+     *
+     * @category predicates
+     * @since 2.0.0
+     */
+    (self: bigint, options: {
+        minimum: bigint;
+        maximum: bigint;
+    }): boolean;
+};
+/**
+ * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.
+ *
+ * - If the `bigint` is less than the `minimum` value, the function returns the `minimum` value.
+ * - If the `bigint` is greater than the `maximum` value, the function returns the `maximum` value.
+ * - Otherwise, it returns the original `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt } from "effect"
+ *
+ * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
+ *
+ * assert.equal(clamp(3n), 3n)
+ * assert.equal(clamp(0n), 1n)
+ * assert.equal(clamp(6n), 5n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const clamp: {
+    /**
+     * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.
+     *
+     * - If the `bigint` is less than the `minimum` value, the function returns the `minimum` value.
+     * - If the `bigint` is greater than the `maximum` value, the function returns the `maximum` value.
+     * - Otherwise, it returns the original `bigint`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt } from "effect"
+     *
+     * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
+     *
+     * assert.equal(clamp(3n), 3n)
+     * assert.equal(clamp(0n), 1n)
+     * assert.equal(clamp(6n), 5n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (options: {
+        minimum: bigint;
+        maximum: bigint;
+    }): (self: bigint) => bigint;
+    /**
+     * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.
+     *
+     * - If the `bigint` is less than the `minimum` value, the function returns the `minimum` value.
+     * - If the `bigint` is greater than the `maximum` value, the function returns the `maximum` value.
+     * - Otherwise, it returns the original `bigint`.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { BigInt } from "effect"
+     *
+     * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
+     *
+     * assert.equal(clamp(3n), 3n)
+     * assert.equal(clamp(0n), 1n)
+     * assert.equal(clamp(6n), 5n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (self: bigint, options: {
+        minimum: bigint;
+        maximum: bigint;
+    }): bigint;
+};
+/**
+ * Returns the minimum between two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { min } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(min(2n, 3n), 2n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const min: {
+    /**
+     * Returns the minimum between two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { min } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(min(2n, 3n), 2n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Returns the minimum between two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { min } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(min(2n, 3n), 2n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Returns the maximum between two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { max } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(max(2n, 3n), 3n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const max: {
+    /**
+     * Returns the maximum between two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { max } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(max(2n, 3n), 3n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Returns the maximum between two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { max } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(max(2n, 3n), 3n)
+     * ```
+     *
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Determines the sign of a given `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sign } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sign(-5n), -1)
+ * assert.deepStrictEqual(sign(0n), 0)
+ * assert.deepStrictEqual(sign(5n), 1)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const sign: (n: bigint) => Ordering;
+/**
+ * Determines the absolute value of a given `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { abs } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(abs(-5n), 5n)
+ * assert.deepStrictEqual(abs(0n), 0n)
+ * assert.deepStrictEqual(abs(5n), 5n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const abs: (n: bigint) => bigint;
+/**
+ * Determines the greatest common divisor of two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { gcd } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const gcd: {
+    /**
+     * Determines the greatest common divisor of two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { gcd } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(gcd(2n, 3n), 1n)
+     * assert.deepStrictEqual(gcd(2n, 4n), 2n)
+     * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Determines the greatest common divisor of two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { gcd } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(gcd(2n, 3n), 1n)
+     * assert.deepStrictEqual(gcd(2n, 4n), 2n)
+     * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Determines the least common multiple of two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lcm } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const lcm: {
+    /**
+     * Determines the least common multiple of two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lcm } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lcm(2n, 3n), 6n)
+     * assert.deepStrictEqual(lcm(2n, 4n), 4n)
+     * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (that: bigint): (self: bigint) => bigint;
+    /**
+     * Determines the least common multiple of two `bigint`s.
+     *
+     * @example
+     * ```ts
+     * import * as assert from "node:assert"
+     * import { lcm } from "effect/BigInt"
+     *
+     * assert.deepStrictEqual(lcm(2n, 3n), 6n)
+     * assert.deepStrictEqual(lcm(2n, 4n), 4n)
+     * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+     * ```
+     *
+     * @category math
+     * @since 2.0.0
+     */
+    (self: bigint, that: bigint): bigint;
+};
+/**
+ * Determines the square root of a given `bigint` unsafely. Throws if the given `bigint` is negative.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeSqrt } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(unsafeSqrt(4n), 2n)
+ * assert.deepStrictEqual(unsafeSqrt(9n), 3n)
+ * assert.deepStrictEqual(unsafeSqrt(16n), 4n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const unsafeSqrt: (n: bigint) => bigint;
+/**
+ * Determines the square root of a given `bigint` safely. Returns `none` if the given `bigint` is negative.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigInt.sqrt(4n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.sqrt(9n), Option.some(3n))
+ * assert.deepStrictEqual(BigInt.sqrt(16n), Option.some(4n))
+ * assert.deepStrictEqual(BigInt.sqrt(-1n), Option.none())
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const sqrt: (n: bigint) => Option.Option<bigint>;
+/**
+ * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sumAll } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const sumAll: (collection: Iterable<bigint>) => bigint;
+/**
+ * Takes an `Iterable` of `bigint`s and returns their multiplication as a single `number`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { multiplyAll } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export declare const multiplyAll: (collection: Iterable<bigint>) => bigint;
+/**
+ * Takes a `bigint` and returns an `Option` of `number`.
+ *
+ * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it converts the `bigint`
+ * to a number and returns `Option.some(number)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.toNumber(BigInt(42)), Option.some(42))
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export declare const toNumber: (b: bigint) => Option.Option<number>;
+/**
+ * Takes a string and returns an `Option` of `bigint`.
+ *
+ * If the string is empty or contains characters that cannot be converted into a `bigint`,
+ * it returns `Option.none()`, otherwise, it returns `Option.some(bigint)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.fromString("42"), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromString(" "), Option.none())
+ * assert.deepStrictEqual(BI.fromString("a"), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+export declare const fromString: (s: string) => Option.Option<bigint>;
+/**
+ * Takes a number and returns an `Option` of `bigint`.
+ *
+ * If the number is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it attempts to
+ * convert the number to a `bigint` and returns `Option.some(bigint)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.fromNumber(42), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
+ * assert.deepStrictEqual(BI.fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+export declare const fromNumber: (n: number) => Option.Option<bigint>;
+//# sourceMappingURL=BigInt.d.ts.map

backend/node_modules/effect/dist/dts/BigInt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigInt.d.ts","sourceRoot":"","sources":["../../src/BigInt.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/ChildExecutorDecision.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export declare const ChildExecutorDecisionTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ChildExecutorDecisionTypeId = typeof ChildExecutorDecisionTypeId;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type ChildExecutorDecision = Continue | Close | Yield;
+/**
+ * @since 2.0.0
+ */
+export declare namespace ChildExecutorDecision {
+    /**
+     * @since 2.0.0
+     * @category models
+     */
+    interface Proto {
+        readonly [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId;
+    }
+}
+/**
+ * Continue executing the current substream
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Continue extends ChildExecutorDecision.Proto {
+    readonly _tag: "Continue";
+}
+/**
+ * Close the current substream with a given value and pass execution to the
+ * next substream
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Close extends ChildExecutorDecision.Proto {
+    readonly _tag: "Close";
+    readonly value: unknown;
+}
+/**
+ * Pass execution to the next substream. This either pulls a new element
+ * from upstream, or yields to an already created active substream.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Yield extends ChildExecutorDecision.Proto {
+    readonly _tag: "Yield";
+}
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Continue: (_: void) => ChildExecutorDecision;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Close: (value: unknown) => ChildExecutorDecision;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Yield: (_: void) => ChildExecutorDecision;
+/**
+ * Returns `true` if the specified value is a `ChildExecutorDecision`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isChildExecutorDecision: (u: unknown) => u is ChildExecutorDecision;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Continue`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isContinue: (self: ChildExecutorDecision) => self is Continue;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Close`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isClose: (self: ChildExecutorDecision) => self is Close;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Yield`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isYield: (self: ChildExecutorDecision) => self is Yield;
+/**
+ * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export declare const match: {
+    /**
+     * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <A>(options: {
+        readonly onContinue: () => A;
+        readonly onClose: (value: unknown) => A;
+        readonly onYield: () => A;
+    }): (self: ChildExecutorDecision) => A;
+    /**
+     * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <A>(self: ChildExecutorDecision, options: {
+        readonly onContinue: () => A;
+        readonly onClose: (value: unknown) => A;
+        readonly onYield: () => A;
+    }): A;
+};
+//# sourceMappingURL=ChildExecutorDecision.d.ts.map

backend/node_modules/effect/dist/dts/ConfigProviderPathPatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigProviderPathPatch.d.ts","sourceRoot":"","sources":["../../src/ConfigProviderPathPatch.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;AAErE;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,SAA0B,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;OAGG;IACH,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IACjD;;;OAGG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;CAC3B,CAAA;AAEpB;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IAC/D;;;OAGG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;CACzC,CAAA;AAEpB;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB;;;OAGG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IAC9C;;;OAGG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CACzB,CAAA;AAEnB;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;OAGG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IAC9C;;;OAGG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CACvB,CAAA"}

backend/node_modules/effect/dist/dts/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/Context.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/Encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Encoding.d.ts","sourceRoot":"","sources":["../../src/Encoding.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/ExecutionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionStrategy.d.ts","sourceRoot":"","sources":["../../src/ExecutionStrategy.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAG5C;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAA;AAEjE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,iBAAuC,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,iBAAqC,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,iBAAsC,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,IAAI,UAAkC,CAAA;AAElG;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,IAAI,QAA8B,CAAA;AAE5F;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,IAAI,SAAgC,CAAA;AAE/F;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;OAMG;IACH,CAAC,CAAC,EACD,OAAO,EAAE;QACP,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,CAAA;KACvC,GACC,CAAC,IAAI,EAAE,iBAAiB,KAAK,CAAC,CAAA;IACjC;;;;;;OAMG;IACH,CAAC,CAAC,EACD,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE;QACP,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,CAAA;KACvC,GACC,CAAC,CAAA;CACY,CAAA"}

backend/node_modules/effect/dist/dts/FiberRefsPatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FiberRefsPatch.d.ts","sourceRoot":"","sources":["../../src/FiberRefsPatch.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAGhD;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAEpE;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;CAC9C;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAChC;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,cAA+B,CAAA;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,SAAS,KAAK,cAA8B,CAAA;AAEnH;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;OAOG;IACH,CAAC,IAAI,EAAE,cAAc,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAA;IAChE;;;;;;;OAOG;IACH,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAAA;CAC1C,CAAA;AAEpB;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;OAMG;IACH,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,SAAS,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,SAAS,CAAC,SAAS,CAAA;IACxG;;;;;;OAMG;IACH,CACC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,QAAQ,EAAE,SAAS,CAAC,SAAS,GAC3B,SAAS,CAAC,SAAS,CAAA;CACN,CAAA"}

backend/node_modules/effect/dist/dts/GlobalValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalValue.d.ts","sourceRoot":"","sources":["../../src/GlobalValue.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,IAAI,OAAO,EAAE,SAAS,MAAM,CAAC,KAAG,CAW9D,CAAA"}

backend/node_modules/effect/dist/dts/Graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Graph.d.ts","sourceRoot":"","sources":["../../src/Graph.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/HashMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../src/HashMap.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/Inspectable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Inspectable.d.ts","sourceRoot":"","sources":["../../src/Inspectable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAIhD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,eAA2C,CAAA;AAEzE;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,IAAI,MAAM,CAAA;IAClB,MAAM,IAAI,OAAO,CAAA;IACjB,CAAC,iBAAiB,CAAC,IAAI,OAAO,CAAA;CAC/B;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,OAcnC,CAAA;AAmHD;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,MAAoC,CAAA;AAExE;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,WAUvB,CAAA;AAED;;GAEG;AACH,8BAAsB,KAAK;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,IAAI,OAAO;IAC1B;;OAEG;IACH,CAAC,iBAAiB,CAAC;IAGnB;;OAEG;IACH,QAAQ;CAGT;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,GAAG,OAAO,EAAE,aAAY,MAAM,GAAG,MAAM,GAAG,SAAa,KAAG,MASzF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,OAAO,EAAE,aAAa,MAAM,GAAG,MAAM,GAAG,SAAS,KAAG,MAgB1F,CAAA;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,KAAK,OAAO,CAAA;CACzE;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAoD,CAAA;AAE1F;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,UACe,CAAA;AAM9D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,SAAS,SAAS,CAAC,SAAS,EAAE,GAAG,MAAM,CAAC,KAAG,CAQnF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,OAKnC,CAAA"}

backend/node_modules/effect/dist/dts/List.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../src/List.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/MetricHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricHook.d.ts","sourceRoot":"","sources":["../../src/MetricHook.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/MetricKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricKey.d.ts","sourceRoot":"","sources":["../../src/MetricKey.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/ModuleVersion.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @since 2.0.0
+ * @category version
+ */
+export declare const getCurrentVersion: () => string;
+/**
+ * @since 2.0.0
+ * @category version
+ */
+export declare const setCurrentVersion: (version: string) => void;
+//# sourceMappingURL=ModuleVersion.d.ts.map

backend/node_modules/effect/dist/dts/MutableHashSet.d.ts

@@ -0,0 +1,547 @@
+import { type Inspectable } from "./Inspectable.js";
+import type { Pipeable } from "./Pipeable.js";
+declare const TypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectable {
+    readonly [TypeId]: TypeId;
+}
+/**
+ * Creates an empty mutable hash set.
+ *
+ * This function initializes and returns an empty `MutableHashSet` instance,
+ * which allows for efficient storage and manipulation of unique elements.
+ *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * type T = unknown // replace with your type
+ *
+ * // in places where the type can't be inferred, replace with your type
+ * const set: MutableHashSet.MutableHashSet<T> = MutableHashSet.empty<T>()
+ * ```
+ *
+ * @template K - The type of the elements to be stored in the hash set. Defaults
+ *   to `never` if not specified.
+ * @returns A new mutable instance of `MutableHashSet` containing no elements
+ *   for the specified type `K`.
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.make} {@link module:MutableHashSet.fromIterable}
+ */
+export declare const empty: <K = never>() => MutableHashSet<K>;
+/**
+ * Creates a new `MutableHashSet` from an iterable collection of values.
+ * Duplicate values are omitted.
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements in the iterable
+ *
+ * Creating a `MutableHashSet` from an {@link Array}
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * const array: Iterable<number> = [1, 2, 3, 4, 5, 1, 2, 3] // Array<T> is also Iterable<T>
+ * const mutableHashSet: MutableHashSet.MutableHashSet<number> =
+ *   MutableHashSet.fromIterable(array)
+ *
+ * console.log(
+ *   // MutableHashSet.MutableHashSet<T> is also an Iterable<T>
+ *   Array.from(mutableHashSet)
+ * ) // Output: [1, 2, 3, 4, 5]
+ * ```
+ *
+ * Creating a `MutableHashSet` from a {@link Set}
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     // Set<string> is an Iterable<string>
+ *     new Set(["apple", "banana", "orange", "apple"]),
+ *     // constructs MutableHashSet from an Iterable Set
+ *     MutableHashSet.fromIterable,
+ *     // since MutableHashSet it is itself an Iterable, we can pass it to other functions expecting an Iterable
+ *     Array.from
+ *   )
+ * ) // Output: ["apple", "banana", "orange"]
+ * ```
+ *
+ * Creating a `MutableHashSet` from a {@link Generator}
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * // Generator functions return iterables
+ * function* fibonacci(n: number): Generator<number, void, never> {
+ *   let [a, b] = [0, 1]
+ *   for (let i = 0; i < n; i++) {
+ *     yield a
+ *     ;[a, b] = [b, a + b]
+ *   }
+ * }
+ *
+ * // Create a MutableHashSet from the first 10 Fibonacci numbers
+ * const fibonacciSet = MutableHashSet.fromIterable(fibonacci(10))
+ *
+ * console.log(Array.from(fibonacciSet))
+ * // Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
+ * ```
+ *
+ * Creating a `MutableHashSet` from another {@link module:MutableHashSet}
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     MutableHashSet.make(1, 2, 3, 4),
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Output: [1, 2, 3, 4]
+ * ```
+ *
+ * Creating a `MutableHashSet` from an {@link module:HashSet}
+ *
+ * ```ts
+ * import { HashSet, MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     HashSet.make(1, 2, 3, 4), // it works also with its immutable HashSet sibling
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Output: [1, 2, 3, 4]
+ * ```
+ *
+ * Creating a `MutableHashSet` from other Effect's data structures like
+ * {@link Chunk}
+ *
+ * ```ts
+ * import { Chunk, MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     Chunk.make(1, 2, 3, 4), //  Chunk is also an Iterable<T>
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Outputs: [1, 2, 3, 4]
+ * ```
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category constructors
+ * @template K - The type of elements to be stored in the resulting
+ *   `MutableHashSet`.
+ * @param keys - An `Iterable` collection containing the keys to be added to the
+ *   `MutableHashSet`.
+ * @returns A new `MutableHashSet` containing just the unique elements from the
+ *   provided iterable.
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.empty} {@link module:MutableHashSet.make}
+ */
+export declare const fromIterable: <K = never>(keys: Iterable<K>) => MutableHashSet<K>;
+/**
+ * Construct a new `MutableHashSet` from a variable number of values.
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { Equal, Hash, MutableHashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * class Character implements Equal.Equal {
+ *   readonly name: string
+ *   readonly trait: string
+ *
+ *   constructor(name: string, trait: string) {
+ *     this.name = name
+ *     this.trait = trait
+ *   }
+ *
+ *   // Define equality based on name, and trait
+ *   [Equal.symbol](that: Equal.Equal): boolean {
+ *     if (that instanceof Character) {
+ *       return (
+ *         Equal.equals(this.name, that.name) &&
+ *         Equal.equals(this.trait, that.trait)
+ *       )
+ *     }
+ *     return false
+ *   }
+ *
+ *   // Generate a hash code based on the sum of the character's name and trait
+ *   [Hash.symbol](): number {
+ *     return Hash.hash(this.name + this.trait)
+ *   }
+ *
+ *   static readonly of = (name: string, trait: string): Character => {
+ *     return new Character(name, trait)
+ *   }
+ * }
+ *
+ * const mutableCharacterHashSet = MutableHashSet.make(
+ *   Character.of("Alice", "Curious"),
+ *   Character.of("Alice", "Curious"),
+ *   Character.of("White Rabbit", "Always late"),
+ *   Character.of("Mad Hatter", "Tea enthusiast")
+ * )
+ *
+ * assert.equal(
+ *   MutableHashSet.has(
+ *     mutableCharacterHashSet,
+ *     Character.of("Alice", "Curious")
+ *   ),
+ *   true
+ * )
+ * assert.equal(
+ *   MutableHashSet.has(
+ *     mutableCharacterHashSet,
+ *     Character.of("Fluffy", "Kind")
+ *   ),
+ *   false
+ * )
+ * ```
+ *
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.fromIterable} {@link module:MutableHashSet.empty}
+ */
+export declare const make: <Keys extends ReadonlyArray<unknown>>(...keys: Keys) => MutableHashSet<Keys[number]>;
+/**
+ * **Checks** whether the `MutableHashSet` contains the given element, and
+ * **adds** it if not.
+ *
+ * Time complexity: **`O(1)`** average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(
+ *   MutableHashSet.empty(),
+ *   MutableHashSet.add(0),
+ *   MutableHashSet.add(0)
+ * )
+ *
+ * // or piped with the pipe function
+ * MutableHashSet.empty().pipe(MutableHashSet.add(0))
+ *
+ * // or with data-first API
+ * MutableHashSet.add(MutableHashSet.empty(), 0)
+ * ```
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear} {@link module:MutableHashSet.has}
+ */
+export declare const add: {
+    /**
+     * `data-last` a.k.a. `pipeable` API
+     *
+     * ```ts
+     * import { MutableHashSet, pipe } from "effect"
+     * import assert from "node:assert/strict"
+     *
+     * const mutableHashSet = pipe(
+     *   MutableHashSet.empty<number>(), // MutableHashSet.MutableHashSet<number>
+     *   MutableHashSet.add(0),
+     *   MutableHashSet.add(1),
+     *   MutableHashSet.add(1),
+     *   MutableHashSet.add(2)
+     * )
+     *
+     * assert.deepStrictEqual(
+     *   Array.from(mutableHashSet), // remember that MutableHashSet is also an Iterable
+     *   Array.of(0, 1, 2)
+     * )
+     * ```
+     *
+     * @template V - The type of elements stored in the `MutableHashSet`.
+     * @param key - The key to be added to the `MutableHashSet` if not already
+     *   present.
+     * @returns A function that accepts a `MutableHashSet` and returns the
+     *   reference of the updated `MutableHashSet` including the key.
+     */
+    <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
+    /**
+     * `data-first` API
+     *
+     * ```ts
+     * import { MutableHashSet } from "effect"
+     * import assert from "node:assert/strict"
+     *
+     * const empty = MutableHashSet.empty<number>()
+     * const withZero = MutableHashSet.add(empty, 0)
+     * const withOne = MutableHashSet.add(withZero, 1)
+     * const withTwo = MutableHashSet.add(withOne, 2)
+     * const withTwoTwo = MutableHashSet.add(withTwo, 2)
+     *
+     * assert(Object.is(withTwoTwo, empty)) // proof that it does mutate the original set
+     *
+     * assert.deepStrictEqual(
+     *   Array.from(withTwoTwo), // remember that MutableHashSet is also an Iterable
+     *   Array.of(0, 1, 2)
+     * )
+     * ```
+     *
+     * @template V - The type of elements stored in the `MutableHashSet`.
+     * @param self - The `MutableHashSet` instance from which the key should be
+     *   added to.
+     * @param key - The key to be added to the `MutableHashSet` if not already
+     *   present.
+     * @returns The reference of the updated `MutableHashSet` including the key.
+     */
+    <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
+};
+/**
+ * Checks if the specified value exists in the `MutableHashSet`.
+ *
+ * Time complexity: `O(1)` average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(
+ *   // with `data-last`, a.k.a. `pipeable` API
+ *   pipe(MutableHashSet.make(0, 1, 2), MutableHashSet.has(3)),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or piped with the pipe function
+ *   MutableHashSet.make(0, 1, 2).pipe(MutableHashSet.has(3)),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or with `data-first` API
+ *   MutableHashSet.has(MutableHashSet.make(0, 1, 2), 3),
+ *   false
+ * )
+ * ```
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear}
+ */
+export declare const has: {
+    /**
+     * `data-last` a.k.a. `pipeable` API
+     *
+     * ```ts
+     * import * as assert from "node:assert/strict"
+     * import { MutableHashSet, pipe } from "effect"
+     *
+     * const set = MutableHashSet.make(0, 1, 2)
+     *
+     * assert.equal(pipe(set, MutableHashSet.has(0)), true)
+     * assert.equal(pipe(set, MutableHashSet.has(1)), true)
+     * assert.equal(pipe(set, MutableHashSet.has(2)), true)
+     * assert.equal(pipe(set, MutableHashSet.has(3)), false)
+     * ```
+     */
+    <V>(key: V): (self: MutableHashSet<V>) => boolean;
+    /**
+     * `data-first` API
+     *
+     * ```ts
+     * import * as assert from "node:assert/strict"
+     * import { MutableHashSet, pipe } from "effect"
+     *
+     * const set = MutableHashSet.make(0, 1, 2)
+     *
+     * assert.equal(MutableHashSet.has(set, 0), true)
+     * assert.equal(MutableHashSet.has(set, 1), true)
+     * assert.equal(MutableHashSet.has(set, 2), true)
+     * assert.equal(MutableHashSet.has(set, 3), false)
+     * ```
+     */
+    <V>(self: MutableHashSet<V>, key: V): boolean;
+};
+/**
+ * Removes a value from the `MutableHashSet`.
+ *
+ * Time complexity: **`O(1)`** average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(
+ *   // with `data-last`, a.k.a. `pipeable` API
+ *   pipe(
+ *     MutableHashSet.make(0, 1, 2),
+ *     MutableHashSet.remove(0),
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or piped with the pipe function
+ *   MutableHashSet.make(0, 1, 2).pipe(
+ *     MutableHashSet.remove(0),
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or with `data-first` API
+ *   MutableHashSet.remove(MutableHashSet.make(0, 1, 2), 0).pipe(
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ * ```
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear}
+ */
+export declare const remove: {
+    /**
+     * `data-last` a.k.a. `pipeable` API
+     *
+     * ```ts
+     * import { MutableHashSet, pipe } from "effect"
+     * import assert from "node:assert/strict"
+     *
+     * const set: MutableHashSet.MutableHashSet<number> = MutableHashSet.make(
+     *   0,
+     *   1,
+     *   2
+     * )
+     * const result: MutableHashSet.MutableHashSet<number> = pipe(
+     *   set,
+     *   MutableHashSet.remove(0)
+     * )
+     *
+     * assert(Object.is(set, result)) // set and result have the same identity
+     * assert.equal(pipe(result, MutableHashSet.has(0)), false) // it has correctly removed 0
+     * assert.equal(pipe(set, MutableHashSet.has(0)), false) // another proof that we are mutating the original MutableHashSet
+     * assert.equal(pipe(result, MutableHashSet.has(1)), true)
+     * assert.equal(pipe(result, MutableHashSet.has(2)), true)
+     * ```
+     *
+     * @template V - The type of the elements in the `MutableHashSet`.
+     * @param key - The key to be removed from the `MutableHashSet`.
+     * @returns A function that takes a `MutableHashSet` as input and returns the
+     *   reference to the same `MutableHashSet` with the specified key removed.
+     */
+    <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
+    /**
+     * `data-first` API
+     *
+     * ```ts
+     * import { MutableHashSet, pipe } from "effect"
+     * import assert from "node:assert/strict"
+     *
+     * const set = MutableHashSet.make(0, 1, 2)
+     * const result = MutableHashSet.remove(set, 0)
+     *
+     * assert(Object.is(set, result)) // set and result have the same identity
+     * assert.equal(MutableHashSet.has(result, 0), false) // it has correctly removed 0
+     * assert.equal(MutableHashSet.has(set, 0), false) // it mutates the original MutableHashSet
+     * assert.equal(MutableHashSet.has(result, 1), true)
+     * assert.equal(MutableHashSet.has(result, 2), true)
+     * ```
+     *
+     * @template V - The type of the elements in the `MutableHashSet`.
+     * @param self - The `MutableHashSet` to which the key will be removed from.
+     * @param key - The value to be removed from the `MutableHashSet` if present.
+     * @returns The reference to the updated `MutableHashSet`.
+     */
+    <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
+};
+/**
+ * Calculates the number of values in the `HashSet`.
+ *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category elements
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(MutableHashSet.size(MutableHashSet.empty()), 0)
+ *
+ * assert.equal(
+ *   MutableHashSet.size(MutableHashSet.make(1, 2, 2, 3, 4, 3)),
+ *   4
+ * )
+ * ```
+ *
+ * @template V - The type of the elements to be stored in the `MutableHashSet`.
+ * @param self - The `MutableHashSet` instance for which the size is to be
+ *   determined.
+ * @returns The total number of elements within the `MutableHashSet`.
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.clear}
+ */
+export declare const size: <V>(self: MutableHashSet<V>) => number;
+/**
+ * Removes all values from the `MutableHashSet`.
+ *
+ * This function operates by delegating the clearing action to the underlying
+ * key map associated with the given `MutableHashSet`. It ensures that the hash
+ * set becomes empty while maintaining its existence and structure.
+ *
+ * @memberof MutableHashSet
+ * @since 2.0.0
+ * @category elements
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     MutableHashSet.make(1, 2, 3, 4),
+ *     MutableHashSet.clear,
+ *     MutableHashSet.size
+ *   ),
+ *   0
+ * )
+ * ```
+ *
+ * @param self - The `MutableHashSet` to clear.
+ * @returns The same `MutableHashSet` after all elements have been removed.
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size}
+ */
+export declare const clear: <V>(self: MutableHashSet<V>) => MutableHashSet<V>;
+export {};
+//# sourceMappingURL=MutableHashSet.d.ts.map

backend/node_modules/effect/dist/dts/MutableList.d.ts

@@ -0,0 +1,150 @@
+import type { Inspectable } from "./Inspectable.js";
+import type { Pipeable } from "./Pipeable.js";
+declare const TypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId;
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface MutableList<out A> extends Iterable<A>, Pipeable, Inspectable {
+    readonly [TypeId]: TypeId;
+}
+/**
+ * Creates an empty `MutableList`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const empty: <A = never>() => MutableList<A>;
+/**
+ * Creates a new `MutableList` from an iterable collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromIterable: <A>(iterable: Iterable<A>) => MutableList<A>;
+/**
+ * Creates a new `MutableList` from the specified elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: <A>(...elements: ReadonlyArray<A>) => MutableList<A>;
+/**
+ * Returns `true` if the list contains zero elements, `false`, otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const isEmpty: <A>(self: MutableList<A>) => boolean;
+/**
+ * Returns the length of the list.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const length: <A>(self: MutableList<A>) => number;
+/**
+ * Returns the last element of the list, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const tail: <A>(self: MutableList<A>) => A | undefined;
+/**
+ * Returns the first element of the list, if it exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const head: <A>(self: MutableList<A>) => A | undefined;
+/**
+ * Executes the specified function `f` for each element in the list.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export declare const forEach: {
+    /**
+     * Executes the specified function `f` for each element in the list.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
+    <A>(f: (element: A) => void): (self: MutableList<A>) => void;
+    /**
+     * Executes the specified function `f` for each element in the list.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
+    <A>(self: MutableList<A>, f: (element: A) => void): void;
+};
+/**
+ * Removes all elements from the doubly-linked list.
+ *
+ * @since 2.0.0
+ */
+export declare const reset: <A>(self: MutableList<A>) => MutableList<A>;
+/**
+ * Appends the specified element to the end of the `MutableList`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export declare const append: {
+    /**
+     * Appends the specified element to the end of the `MutableList`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
+    <A>(value: A): (self: MutableList<A>) => MutableList<A>;
+    /**
+     * Appends the specified element to the end of the `MutableList`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
+    <A>(self: MutableList<A>, value: A): MutableList<A>;
+};
+/**
+ * Removes the first value from the list and returns it, if it exists.
+ *
+ * @since 0.0.1
+ */
+export declare const shift: <A>(self: MutableList<A>) => A | undefined;
+/**
+ * Removes the last value from the list and returns it, if it exists.
+ *
+ * @since 0.0.1
+ */
+export declare const pop: <A>(self: MutableList<A>) => A | undefined;
+/**
+ * Prepends the specified value to the beginning of the list.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export declare const prepend: {
+    /**
+     * Prepends the specified value to the beginning of the list.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
+    <A>(value: A): (self: MutableList<A>) => MutableList<A>;
+    /**
+     * Prepends the specified value to the beginning of the list.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
+    <A>(self: MutableList<A>, value: A): MutableList<A>;
+};
+export {};
+//# sourceMappingURL=MutableList.d.ts.map

backend/node_modules/effect/dist/dts/Order.d.ts

@@ -0,0 +1,260 @@
+import type { TypeLambda } from "./HKT.js";
+/**
+ * @category type class
+ * @since 2.0.0
+ */
+export interface Order<in A> {
+    (self: A, that: A): -1 | 0 | 1;
+}
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export interface OrderTypeLambda extends TypeLambda {
+    readonly type: Order<this["Target"]>;
+}
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const make: <A>(compare: (self: A, that: A) => -1 | 0 | 1) => Order<A>;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const string: Order<string>;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const number: Order<number>;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const boolean: Order<boolean>;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const bigint: Order<bigint>;
+/**
+ * @since 2.0.0
+ */
+export declare const reverse: <A>(O: Order<A>) => Order<A>;
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const combine: {
+    /**
+     * @category combining
+     * @since 2.0.0
+     */
+    <A>(that: Order<A>): (self: Order<A>) => Order<A>;
+    /**
+     * @category combining
+     * @since 2.0.0
+     */
+    <A>(self: Order<A>, that: Order<A>): Order<A>;
+};
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const combineMany: {
+    /**
+     * @category combining
+     * @since 2.0.0
+     */
+    <A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<A>;
+    /**
+     * @category combining
+     * @since 2.0.0
+     */
+    <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<A>;
+};
+/**
+ * @since 2.0.0
+ */
+export declare const empty: <A>() => Order<A>;
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const combineAll: <A>(collection: Iterable<Order<A>>) => Order<A>;
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+export declare const mapInput: {
+    /**
+     * @category mapping
+     * @since 2.0.0
+     */
+    <B, A>(f: (b: B) => A): (self: Order<A>) => Order<B>;
+    /**
+     * @category mapping
+     * @since 2.0.0
+     */
+    <A, B>(self: Order<A>, f: (b: B) => A): Order<B>;
+};
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const Date: Order<Date>;
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const product: {
+    <B>(that: Order<B>): <A>(self: Order<A>) => Order<readonly [A, B]>;
+    <A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]>;
+};
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const all: <A>(collection: Iterable<Order<A>>) => Order<ReadonlyArray<A>>;
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const productMany: {
+    <A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<readonly [A, ...Array<A>]>;
+    <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, ...Array<A>]>;
+};
+/**
+ * Similar to `Promise.all` but operates on `Order`s.
+ *
+ * ```
+ * [Order<A>, Order<B>, ...] -> Order<[A, B, ...]>
+ * ```
+ *
+ * This function creates and returns a new `Order` for a tuple of values based on the given `Order`s for each element in the tuple.
+ * The returned `Order` compares two tuples of the same type by applying the corresponding `Order` to each element in the tuple.
+ * It is useful when you need to compare two tuples of the same type and you have a specific way of comparing each element
+ * of the tuple.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export declare const tuple: <T extends ReadonlyArray<Order<any>>>(...elements: T) => Order<Readonly<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never; }>>;
+/**
+ * This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.
+ * The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays.
+ * If all elements are equal, the arrays are then compared based on their length.
+ * It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export declare const array: <A>(O: Order<A>) => Order<ReadonlyArray<A>>;
+/**
+ * This function creates and returns a new `Order` for a struct of values based on the given `Order`s
+ * for each property in the struct.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export declare const struct: <R extends {
+    readonly [x: string]: Order<any>;
+}>(fields: R) => Order<{ [K in keyof R]: [R[K]] extends [Order<infer A>] ? A : never; }>;
+/**
+ * Test whether one value is _strictly less than_ another.
+ *
+ * @since 2.0.0
+ */
+export declare const lessThan: <A>(O: Order<A>) => {
+    (that: A): (self: A) => boolean;
+    (self: A, that: A): boolean;
+};
+/**
+ * Test whether one value is _strictly greater than_ another.
+ *
+ * @since 2.0.0
+ */
+export declare const greaterThan: <A>(O: Order<A>) => {
+    (that: A): (self: A) => boolean;
+    (self: A, that: A): boolean;
+};
+/**
+ * Test whether one value is _non-strictly less than_ another.
+ *
+ * @since 2.0.0
+ */
+export declare const lessThanOrEqualTo: <A>(O: Order<A>) => {
+    (that: A): (self: A) => boolean;
+    (self: A, that: A): boolean;
+};
+/**
+ * Test whether one value is _non-strictly greater than_ another.
+ *
+ * @since 2.0.0
+ */
+export declare const greaterThanOrEqualTo: <A>(O: Order<A>) => {
+    (that: A): (self: A) => boolean;
+    (self: A, that: A): boolean;
+};
+/**
+ * Take the minimum of two values. If they are considered equal, the first argument is chosen.
+ *
+ * @since 2.0.0
+ */
+export declare const min: <A>(O: Order<A>) => {
+    (that: A): (self: A) => A;
+    (self: A, that: A): A;
+};
+/**
+ * Take the maximum of two values. If they are considered equal, the first argument is chosen.
+ *
+ * @since 2.0.0
+ */
+export declare const max: <A>(O: Order<A>) => {
+    (that: A): (self: A) => A;
+    (self: A, that: A): A;
+};
+/**
+ * Clamp a value between a minimum and a maximum.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Order, Number } from "effect"
+ *
+ * const clamp = Order.clamp(Number.Order)({ minimum: 1, maximum: 5 })
+ *
+ * assert.equal(clamp(3), 3)
+ * assert.equal(clamp(0), 1)
+ * assert.equal(clamp(6), 5)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare const clamp: <A>(O: Order<A>) => {
+    (options: {
+        minimum: A;
+        maximum: A;
+    }): (self: A) => A;
+    (self: A, options: {
+        minimum: A;
+        maximum: A;
+    }): A;
+};
+/**
+ * Test whether a value is between a minimum and a maximum (inclusive).
+ *
+ * @since 2.0.0
+ */
+export declare const between: <A>(O: Order<A>) => {
+    (options: {
+        minimum: A;
+        maximum: A;
+    }): (self: A) => boolean;
+    (self: A, options: {
+        minimum: A;
+        maximum: A;
+    }): boolean;
+};
+//# sourceMappingURL=Order.d.ts.map

backend/node_modules/effect/dist/dts/ParseResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParseResult.d.ts","sourceRoot":"","sources":["../../src/ParseResult.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/PartitionedSemaphore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartitionedSemaphore.d.ts","sourceRoot":"","sources":["../../src/PartitionedSemaphore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAKrC;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAAuC,CAAA;AAE5D;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,8BAA8B,CAAA;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB,CAAC,EAAE,CAAC,CAAC;IACxC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAEzB,QAAQ,CAAC,WAAW,EAAE,CACpB,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,MAAM,KACZ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,OAAO,EAAE,SAAS;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,KAAG,oBAAoB,CAAC,CAAC,CAiHzB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,OAAO,EAAE,SAAS;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,KAAG,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAA8C,CAAA"}

backend/node_modules/effect/dist/dts/Pipeable.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @since 2.0.0
+ */
+import type { Ctor } from "./Types.js";
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+export interface Pipeable {
+    pipe<A>(this: A): A;
+    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+}
+/**
+ * @since 2.0.0
+ */
+export declare const pipeArguments: <A>(self: A, args: IArguments) => unknown;
+/**
+ * @since 3.15.0
+ * @category Models
+ */
+export interface PipeableConstructor {
+    new (...args: Array<any>): Pipeable;
+}
+/**
+ * @since 3.15.0
+ * @category Prototypes
+ */
+export declare const Prototype: Pipeable;
+/**
+ * @since 3.15.0
+ * @category Constructors
+ */
+export declare const Class: {
+    /**
+     * @since 3.15.0
+     * @category Constructors
+     */
+    (): PipeableConstructor;
+    /**
+     * @since 3.15.0
+     * @category Constructors
+     */
+    <TBase extends Ctor>(klass: TBase): TBase & PipeableConstructor;
+};
+//# sourceMappingURL=Pipeable.d.ts.map

backend/node_modules/effect/dist/dts/PubSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PubSub.d.ts","sourceRoot":"","sources":["../../src/PubSub.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/Redacted.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The Redacted module provides functionality for handling sensitive information
+ * securely within your application. By using the `Redacted` data type, you can
+ * ensure that sensitive values are not accidentally exposed in logs or error
+ * messages.
+ *
+ * @since 3.3.0
+ */
+import type * as Equal from "./Equal.js";
+import * as Equivalence from "./Equivalence.js";
+import type { Pipeable } from "./Pipeable.js";
+import type { Covariant } from "./Types.js";
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export declare const RedactedTypeId: unique symbol;
+/**
+ * @since 3.3.0
+ * @category symbols
+ */
+export type RedactedTypeId = typeof RedactedTypeId;
+/**
+ * @since 3.3.0
+ * @category models
+ */
+export interface Redacted<out A = string> extends Redacted.Variance<A>, Equal.Equal, Pipeable {
+}
+/**
+ * @since 3.3.0
+ */
+export declare namespace Redacted {
+    /**
+     * @since 3.3.0
+     * @category models
+     */
+    interface Variance<out A> {
+        readonly [RedactedTypeId]: {
+            readonly _A: Covariant<A>;
+        };
+    }
+    /**
+     * @since 3.3.0
+     * @category type-level
+     */
+    type Value<T extends Redacted<any>> = [T] extends [Redacted<infer _A>] ? _A : never;
+}
+/**
+ * @since 3.3.0
+ * @category refinements
+ */
+export declare const isRedacted: (u: unknown) => u is Redacted<unknown>;
+/**
+ * This function creates a `Redacted<A>` instance from a given value `A`,
+ * securely hiding its content.
+ *
+ * @example
+ * ```ts
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ * ```
+ *
+ * @since 3.3.0
+ * @category constructors
+ */
+export declare const make: <A>(value: A) => Redacted<A>;
+/**
+ * Retrieves the original value from a `Redacted` instance. Use this function
+ * with caution, as it exposes the sensitive data.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ * ```
+ *
+ * @since 3.3.0
+ * @category getters
+ */
+export declare const value: <A>(self: Redacted<A>) => A;
+/**
+ * Erases the underlying value of a `Redacted` instance, rendering it unusable.
+ * This function is intended to ensure that sensitive data does not remain in
+ * memory longer than necessary.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Redacted } from "effect"
+ *
+ * const API_KEY = Redacted.make("1234567890")
+ *
+ * assert.equal(Redacted.value(API_KEY), "1234567890")
+ *
+ * Redacted.unsafeWipe(API_KEY)
+ *
+ * assert.throws(() => Redacted.value(API_KEY), new Error("Unable to get redacted value"))
+ * ```
+ *
+ * @since 3.3.0
+ * @category unsafe
+ */
+export declare const unsafeWipe: <A>(self: Redacted<A>) => boolean;
+/**
+ * Generates an equivalence relation for `Redacted<A>` values based on an
+ * equivalence relation for the underlying values `A`. This function is useful
+ * for comparing `Redacted` instances without exposing their contents.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Redacted, Equivalence } from "effect"
+ *
+ * const API_KEY1 = Redacted.make("1234567890")
+ * const API_KEY2 = Redacted.make("1-34567890")
+ * const API_KEY3 = Redacted.make("1234567890")
+ *
+ * const equivalence = Redacted.getEquivalence(Equivalence.string)
+ *
+ * assert.equal(equivalence(API_KEY1, API_KEY2), false)
+ * assert.equal(equivalence(API_KEY1, API_KEY3), true)
+ * ```
+ *
+ * @category equivalence
+ * @since 3.3.0
+ */
+export declare const getEquivalence: <A>(isEquivalent: Equivalence.Equivalence<A>) => Equivalence.Equivalence<Redacted<A>>;
+//# sourceMappingURL=Redacted.d.ts.map

backend/node_modules/effect/dist/dts/Ref.d.ts

@@ -0,0 +1,250 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js";
+import type * as Option from "./Option.js";
+import type * as Readable from "./Readable.js";
+import type * as Types from "./Types.js";
+import type * as Unify from "./Unify.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export declare const RefTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type RefTypeId = typeof RefTypeId;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Ref<in out A> extends Ref.Variance<A>, Effect.Effect<A>, Readable.Readable<A> {
+    modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>;
+    readonly [Unify.typeSymbol]?: unknown;
+    readonly [Unify.unifySymbol]?: RefUnify<this>;
+    readonly [Unify.ignoreSymbol]?: RefUnifyIgnore;
+}
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnify<A extends {
+    [Unify.typeSymbol]?: any;
+}> extends Effect.EffectUnify<A> {
+    Ref?: () => Extract<A[Unify.typeSymbol], Ref<any>>;
+}
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnifyIgnore extends Effect.EffectUnifyIgnore {
+    Effect?: true;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export declare namespace Ref {
+    /**
+     * @since 2.0.0
+     */
+    interface Variance<in out A> {
+        readonly [RefTypeId]: {
+            readonly _A: Types.Invariant<A>;
+        };
+    }
+}
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: <A>(value: A) => Effect.Effect<Ref<A>>;
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const get: <A>(self: Ref<A>) => Effect.Effect<A>;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const getAndSet: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(value: A): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, value: A): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const getAndUpdate: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const getAndUpdateSome: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const modify: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<B>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const modifySome: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<B>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const set: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(value: A): (self: Ref<A>) => Effect.Effect<void>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, value: A): Effect.Effect<void>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const setAndGet: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(value: A): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, value: A): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const update: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<void>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<void>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const updateAndGet: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const updateSome: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<void>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>;
+};
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export declare const updateSomeAndGet: {
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>;
+    /**
+     * @since 2.0.0
+     * @category utils
+     */
+    <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>;
+};
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export declare const unsafeMake: <A>(value: A) => Ref<A>;
+//# sourceMappingURL=Ref.d.ts.map

backend/node_modules/effect/dist/dts/RequestResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestResolver.d.ts","sourceRoot":"","sources":["../../src/RequestResolver.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/Resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../src/Resource.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/SingleProducerAsyncInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleProducerAsyncInput.d.ts","sourceRoot":"","sources":["../../src/SingleProducerAsyncInput.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AAGtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,wBAAwB,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAC5E,SAAQ,kBAAkB,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,kBAAkB,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;IAEhF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;CACxE;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IAC1D,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACnC,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACzC,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IAC3C,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;CACvD;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI;IAC7D,QAAQ,CAAC,CAAC,EACR,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EACvC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,KAAK,CAAC,EAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,GACzB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,wBAAwB,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAiB,CAAA"}

backend/node_modules/effect/dist/dts/SortedSet.d.ts

@@ -0,0 +1,333 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal.js";
+import type * as Equivalence from "./Equivalence.js";
+import type { Inspectable } from "./Inspectable.js";
+import type { Order } from "./Order.js";
+import type { Pipeable } from "./Pipeable.js";
+import type { Predicate } from "./Predicate.js";
+import type { Invariant, NoInfer } from "./Types.js";
+declare const TypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface SortedSet<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+    readonly [TypeId]: {
+        readonly _A: Invariant<A>;
+    };
+}
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isSortedSet: {
+    /**
+     * @since 2.0.0
+     * @category refinements
+     */
+    <A>(u: Iterable<A>): u is SortedSet<A>;
+    /**
+     * @since 2.0.0
+     * @category refinements
+     */
+    (u: unknown): u is SortedSet<unknown>;
+};
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const empty: <A>(O: Order<A>) => SortedSet<A>;
+/**
+ * Creates a new `SortedSet` from an iterable collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromIterable: {
+    /**
+     * Creates a new `SortedSet` from an iterable collection of values.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
+    <B>(ord: Order<B>): <A extends B>(iterable: Iterable<A>) => SortedSet<A>;
+    /**
+     * Creates a new `SortedSet` from an iterable collection of values.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
+    <A extends B, B>(iterable: Iterable<A>, ord: Order<B>): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: <K>(ord: Order<K>) => <Entries extends ReadonlyArray<K>>(...entries: Entries) => SortedSet<Entries[number]>;
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const add: {
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, value: A): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ */
+export declare const difference: {
+    /**
+     * @since 2.0.0
+     */
+    <A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     */
+    <A, B extends A>(self: SortedSet<A>, that: Iterable<B>): SortedSet<A>;
+};
+/**
+ * Check if a predicate holds true for every `SortedSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const every: {
+    /**
+     * Check if a predicate holds true for every `SortedSet` element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
+    /**
+     * Check if a predicate holds true for every `SortedSet` element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
+};
+/**
+ * @since 2.0.0
+ * @category filtering
+ */
+export declare const filter: {
+    /**
+     * @since 2.0.0
+     * @category filtering
+     */
+    <A, B extends A>(predicate: Predicate<B>): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     * @category filtering
+     */
+    <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+export declare const flatMap: {
+    /**
+     * @since 2.0.0
+     * @category sequencing
+     */
+    <B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>;
+    /**
+     * @since 2.0.0
+     * @category sequencing
+     */
+    <A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>): SortedSet<B>;
+};
+/**
+ * @since 2.0.0
+ * @category traversing
+ */
+export declare const forEach: {
+    /**
+     * @since 2.0.0
+     * @category traversing
+     */
+    <A>(f: (a: A) => void): (self: SortedSet<A>) => void;
+    /**
+     * @since 2.0.0
+     * @category traversing
+     */
+    <A>(self: SortedSet<A>, f: (a: A) => void): void;
+};
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const has: {
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(value: A): (self: SortedSet<A>) => boolean;
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, value: A): boolean;
+};
+/**
+ * @since 2.0.0
+ */
+export declare const intersection: {
+    /**
+     * @since 2.0.0
+     */
+    <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     */
+    <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const isSubset: {
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean;
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, that: SortedSet<A>): boolean;
+};
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export declare const map: {
+    /**
+     * @since 2.0.0
+     * @category mapping
+     */
+    <B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>;
+    /**
+     * @since 2.0.0
+     * @category mapping
+     */
+    <B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B): SortedSet<B>;
+};
+/**
+ * @since 2.0.0
+ * @category filtering
+ */
+export declare const partition: {
+    /**
+     * @since 2.0.0
+     * @category filtering
+     */
+    <A>(predicate: (a: NoInfer<A>) => boolean): (self: SortedSet<A>) => [excluded: SortedSet<A>, satisfying: SortedSet<A>];
+    /**
+     * @since 2.0.0
+     * @category filtering
+     */
+    <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<A>];
+};
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const remove: {
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, value: A): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const size: <A>(self: SortedSet<A>) => number;
+/**
+ * Check if a predicate holds true for some `SortedSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const some: {
+    /**
+     * Check if a predicate holds true for some `SortedSet` element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
+    /**
+     * Check if a predicate holds true for some `SortedSet` element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
+};
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const toggle: {
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: SortedSet<A>, value: A): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ */
+export declare const union: {
+    /**
+     * @since 2.0.0
+     */
+    <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
+    /**
+     * @since 2.0.0
+     */
+    <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
+};
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const values: <A>(self: SortedSet<A>) => IterableIterator<A>;
+/**
+ * @since 2.0.0
+ * @category equivalence
+ */
+export declare const getEquivalence: <A>() => Equivalence.Equivalence<SortedSet<A>>;
+export {};
+//# sourceMappingURL=SortedSet.d.ts.map

backend/node_modules/effect/dist/dts/StreamHaltStrategy.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type HaltStrategy = Left | Right | Both | Either;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type HaltStrategyInput = HaltStrategy | "left" | "right" | "both" | "either";
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Left {
+    readonly _tag: "Left";
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Right {
+    readonly _tag: "Right";
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Both {
+    readonly _tag: "Both";
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Either {
+    readonly _tag: "Either";
+}
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Left: HaltStrategy;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Right: HaltStrategy;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Both: HaltStrategy;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const Either: HaltStrategy;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromInput: (input: HaltStrategyInput) => HaltStrategy;
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isLeft: (self: HaltStrategy) => self is Left;
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isRight: (self: HaltStrategy) => self is Right;
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isBoth: (self: HaltStrategy) => self is Both;
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export declare const isEither: (self: HaltStrategy) => self is Either;
+/**
+ * Folds over the specified `HaltStrategy` using the provided case functions.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export declare const match: {
+    /**
+     * Folds over the specified `HaltStrategy` using the provided case functions.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z>(options: {
+        readonly onLeft: () => Z;
+        readonly onRight: () => Z;
+        readonly onBoth: () => Z;
+        readonly onEither: () => Z;
+    }): (self: HaltStrategy) => Z;
+    /**
+     * Folds over the specified `HaltStrategy` using the provided case functions.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z>(self: HaltStrategy, options: {
+        readonly onLeft: () => Z;
+        readonly onRight: () => Z;
+        readonly onBoth: () => Z;
+        readonly onEither: () => Z;
+    }): Z;
+};
+//# sourceMappingURL=StreamHaltStrategy.d.ts.map

backend/node_modules/effect/dist/dts/TArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TArray.d.ts","sourceRoot":"","sources":["../../src/TArray.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/TSet.d.ts

@@ -0,0 +1,564 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Chunk from "./Chunk.js";
+import type * as HashSet from "./HashSet.js";
+import type * as Option from "./Option.js";
+import type { Predicate } from "./Predicate.js";
+import type * as STM from "./STM.js";
+import type * as Types from "./Types.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export declare const TSetTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TSetTypeId = typeof TSetTypeId;
+/**
+ * Transactional set implemented on top of `TMap`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface TSet<in out A> extends TSet.Variance<A> {
+}
+/**
+ * @since 2.0.0
+ */
+export declare namespace TSet {
+    /**
+     * @since 2.0.0
+     * @category models
+     */
+    interface Variance<in out A> {
+        readonly [TSetTypeId]: {
+            readonly _A: Types.Invariant<A>;
+        };
+    }
+}
+/**
+ * Stores new element in the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const add: {
+    /**
+     * Stores new element in the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(value: A): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Stores new element in the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, value: A): STM.STM<void>;
+};
+/**
+ * Atomically transforms the set into the difference of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const difference: {
+    /**
+     * Atomically transforms the set into the difference of itself and the
+     * provided set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Atomically transforms the set into the difference of itself and the
+     * provided set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>;
+};
+/**
+ * Makes an empty `TSet`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const empty: <A>() => STM.STM<TSet<A>>;
+/**
+ * Atomically performs transactional-effect for each element in set.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const forEach: {
+    /**
+     * Atomically performs transactional-effect for each element in set.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A, R, E>(f: (value: A) => STM.STM<void, E, R>): (self: TSet<A>) => STM.STM<void, E, R>;
+    /**
+     * Atomically performs transactional-effect for each element in set.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A, R, E>(self: TSet<A>, f: (value: A) => STM.STM<void, E, R>): STM.STM<void, E, R>;
+};
+/**
+ * Creates a new `TSet` from an iterable collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TSet<A>>;
+/**
+ * Tests whether or not set contains an element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export declare const has: {
+    /**
+     * Tests whether or not set contains an element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(value: A): (self: TSet<A>) => STM.STM<boolean>;
+    /**
+     * Tests whether or not set contains an element.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
+    <A>(self: TSet<A>, value: A): STM.STM<boolean>;
+};
+/**
+ * Atomically transforms the set into the intersection of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const intersection: {
+    /**
+     * Atomically transforms the set into the intersection of itself and the
+     * provided set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Atomically transforms the set into the intersection of itself and the
+     * provided set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>;
+};
+/**
+ * Tests if the set is empty or not
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const isEmpty: <A>(self: TSet<A>) => STM.STM<boolean>;
+/**
+ * Makes a new `TSet` that is initialized with specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: <Elements extends Array<any>>(...elements: Elements) => STM.STM<TSet<Elements[number]>>;
+/**
+ * Atomically folds using a pure function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export declare const reduce: {
+    /**
+     * Atomically folds using a pure function.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: TSet<A>) => STM.STM<Z>;
+    /**
+     * Atomically folds using a pure function.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z, A>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): STM.STM<Z>;
+};
+/**
+ * Atomically folds using a transactional function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export declare const reduceSTM: {
+    /**
+     * Atomically folds using a transactional function.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): (self: TSet<A>) => STM.STM<Z, E, R>;
+    /**
+     * Atomically folds using a transactional function.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
+    <Z, A, R, E>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): STM.STM<Z, E, R>;
+};
+/**
+ * Removes a single element from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const remove: {
+    /**
+     * Removes a single element from the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(value: A): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Removes a single element from the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, value: A): STM.STM<void>;
+};
+/**
+ * Removes elements from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const removeAll: {
+    /**
+     * Removes elements from the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(iterable: Iterable<A>): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Removes elements from the set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, iterable: Iterable<A>): STM.STM<void>;
+};
+/**
+ * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+ * (or `void` if `discard = true`).
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const removeIf: {
+    /**
+     * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(predicate: Predicate<A>, options: {
+        readonly discard: true;
+    }): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(predicate: Predicate<A>, options?: {
+        readonly discard: false;
+    }): (self: TSet<A>) => STM.STM<Array<A>>;
+    /**
+     * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, predicate: Predicate<A>, options: {
+        readonly discard: true;
+    }): STM.STM<void>;
+    /**
+     * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, predicate: Predicate<A>, options?: {
+        readonly discard: false;
+    }): STM.STM<Array<A>>;
+};
+/**
+ * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+ * (or `void` if `discard = true`).
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const retainIf: {
+    /**
+     * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(predicate: Predicate<A>, options: {
+        readonly discard: true;
+    }): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(predicate: Predicate<A>, options?: {
+        readonly discard: false;
+    }): (self: TSet<A>) => STM.STM<Array<A>>;
+    /**
+     * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, predicate: Predicate<A>, options: {
+        readonly discard: true;
+    }): STM.STM<void>;
+    /**
+     * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+     * (or `void` if `discard = true`).
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, predicate: Predicate<A>, options?: {
+        readonly discard: false;
+    }): STM.STM<Array<A>>;
+};
+/**
+ * Returns the set's cardinality.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export declare const size: <A>(self: TSet<A>) => STM.STM<number>;
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const takeFirst: {
+    /**
+     * Takes the first matching value, or retries until there is one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<B>;
+    /**
+     * Takes the first matching value, or retries until there is one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<B>;
+};
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const takeFirstSTM: {
+    /**
+     * Takes the first matching value, or retries until there is one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<B, E, R>;
+    /**
+     * Takes the first matching value, or retries until there is one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<B, E, R>;
+};
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const takeSome: {
+    /**
+     * Takes all matching values, or retries until there is at least one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<[B, ...Array<B>]>;
+    /**
+     * Takes all matching values, or retries until there is at least one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<[B, ...Array<B>]>;
+};
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const takeSomeSTM: {
+    /**
+     * Takes all matching values, or retries until there is at least one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<[B, ...Array<B>], E, R>;
+    /**
+     * Takes all matching values, or retries until there is at least one.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<[B, ...Array<B>], E, R>;
+};
+/**
+ * Collects all elements into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export declare const toChunk: <A>(self: TSet<A>) => STM.STM<Chunk.Chunk<A>>;
+/**
+ * Collects all elements into a `HashSet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export declare const toHashSet: <A>(self: TSet<A>) => STM.STM<HashSet.HashSet<A>>;
+/**
+ * Collects all elements into a `Array`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export declare const toArray: <A>(self: TSet<A>) => STM.STM<Array<A>>;
+/**
+ * Collects all elements into a `ReadonlySet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export declare const toReadonlySet: <A>(self: TSet<A>) => STM.STM<ReadonlySet<A>>;
+/**
+ * Atomically updates all elements using a pure function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const transform: {
+    /**
+     * Atomically updates all elements using a pure function.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(f: (a: A) => A): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Atomically updates all elements using a pure function.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, f: (a: A) => A): STM.STM<void>;
+};
+/**
+ * Atomically updates all elements using a transactional function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const transformSTM: {
+    /**
+     * Atomically updates all elements using a transactional function.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, R, E>(f: (a: A) => STM.STM<A, E, R>): (self: TSet<A>) => STM.STM<void, E, R>;
+    /**
+     * Atomically updates all elements using a transactional function.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A, R, E>(self: TSet<A>, f: (a: A) => STM.STM<A, E, R>): STM.STM<void, E, R>;
+};
+/**
+ * Atomically transforms the set into the union of itself and the provided
+ * set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export declare const union: {
+    /**
+     * Atomically transforms the set into the union of itself and the provided
+     * set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>;
+    /**
+     * Atomically transforms the set into the union of itself and the provided
+     * set.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
+    <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>;
+};
+//# sourceMappingURL=TSet.d.ts.map

backend/node_modules/effect/dist/dts/Tracer.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Context from "./Context.js";
+import type * as Effect from "./Effect.js";
+import type * as Exit from "./Exit.js";
+import type * as Fiber from "./Fiber.js";
+import type { LazyArg } from "./Function.js";
+import type * as Option from "./Option.js";
+/**
+ * @since 2.0.0
+ */
+export declare const TracerTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ */
+export type TracerTypeId = typeof TracerTypeId;
+/**
+ * @since 2.0.0
+ */
+export interface Tracer {
+    readonly [TracerTypeId]: TracerTypeId;
+    span(name: string, parent: Option.Option<AnySpan>, context: Context.Context<never>, links: ReadonlyArray<SpanLink>, startTime: bigint, kind: SpanKind, options?: SpanOptions): Span;
+    context<X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>): X;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type SpanStatus = {
+    _tag: "Started";
+    startTime: bigint;
+} | {
+    _tag: "Ended";
+    startTime: bigint;
+    endTime: bigint;
+    exit: Exit.Exit<unknown, unknown>;
+};
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type AnySpan = Span | ExternalSpan;
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export interface ParentSpan {
+    readonly _: unique symbol;
+}
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export declare const ParentSpan: Context.Tag<ParentSpan, AnySpan>;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface ExternalSpan {
+    readonly _tag: "ExternalSpan";
+    readonly spanId: string;
+    readonly traceId: string;
+    readonly sampled: boolean;
+    readonly context: Context.Context<never>;
+}
+/**
+ * @since 3.1.0
+ * @category models
+ */
+export interface SpanOptions {
+    readonly attributes?: Record<string, unknown> | undefined;
+    readonly links?: ReadonlyArray<SpanLink> | undefined;
+    readonly parent?: AnySpan | undefined;
+    readonly root?: boolean | undefined;
+    readonly context?: Context.Context<never> | undefined;
+    readonly kind?: SpanKind | undefined;
+    readonly captureStackTrace?: boolean | LazyArg<string | undefined> | undefined;
+}
+/**
+ * @since 3.1.0
+ * @category models
+ */
+export type SpanKind = "internal" | "server" | "client" | "producer" | "consumer";
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Span {
+    readonly _tag: "Span";
+    readonly name: string;
+    readonly spanId: string;
+    readonly traceId: string;
+    readonly parent: Option.Option<AnySpan>;
+    readonly context: Context.Context<never>;
+    readonly status: SpanStatus;
+    readonly attributes: ReadonlyMap<string, unknown>;
+    readonly links: ReadonlyArray<SpanLink>;
+    readonly sampled: boolean;
+    readonly kind: SpanKind;
+    end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void;
+    attribute(key: string, value: unknown): void;
+    event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void;
+    addLinks(links: ReadonlyArray<SpanLink>): void;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface SpanLink {
+    readonly _tag: "SpanLink";
+    readonly span: AnySpan;
+    readonly attributes: Readonly<Record<string, unknown>>;
+}
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export declare const Tracer: Context.Tag<Tracer, Tracer>;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: (options: Omit<Tracer, typeof TracerTypeId>) => Tracer;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const externalSpan: (options: {
+    readonly spanId: string;
+    readonly traceId: string;
+    readonly sampled?: boolean | undefined;
+    readonly context?: Context.Context<never> | undefined;
+}) => ExternalSpan;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const tracerWith: <A, E, R>(f: (tracer: Tracer) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * @since 3.12.0
+ * @category annotations
+ */
+export interface DisablePropagation {
+    readonly _: unique symbol;
+}
+/**
+ * @since 3.12.0
+ * @category annotations
+ */
+export declare const DisablePropagation: Context.Reference<DisablePropagation, boolean>;
+//# sourceMappingURL=Tracer.d.ts.map

backend/node_modules/effect/dist/dts/Unify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Unify.d.ts","sourceRoot":"","sources":["../../src/Unify.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

backend/node_modules/effect/dist/esm/Arbitrary.js

@@ -0,0 +1,798 @@
+/**
+ * @since 3.10.0
+ */
+import * as Arr from "./Array.js";
+import * as FastCheck from "./FastCheck.js";
+import { globalValue } from "./GlobalValue.js";
+import * as errors_ from "./internal/schema/errors.js";
+import * as schemaId_ from "./internal/schema/schemaId.js";
+import * as util_ from "./internal/schema/util.js";
+import * as Option from "./Option.js";
+import * as Predicate from "./Predicate.js";
+import * as SchemaAST from "./SchemaAST.js";
+/**
+ * Returns a LazyArbitrary for the `A` type of the provided schema.
+ *
+ * @category arbitrary
+ * @since 3.10.0
+ */
+export const makeLazy = schema => {
+  const description = getDescription(schema.ast, []);
+  return go(description, {
+    maxDepth: 2
+  });
+};
+/**
+ * Returns a fast-check Arbitrary for the `A` type of the provided schema.
+ *
+ * @category arbitrary
+ * @since 3.10.0
+ */
+export const make = schema => makeLazy(schema)(FastCheck);
+/** @internal */
+export const makeStringConstraints = options => {
+  const out = {
+    _tag: "StringConstraints",
+    constraints: {}
+  };
+  if (Predicate.isNumber(options.minLength)) {
+    out.constraints.minLength = options.minLength;
+  }
+  if (Predicate.isNumber(options.maxLength)) {
+    out.constraints.maxLength = options.maxLength;
+  }
+  if (Predicate.isString(options.pattern)) {
+    out.pattern = options.pattern;
+  }
+  return out;
+};
+/** @internal */
+export const makeNumberConstraints = options => {
+  const out = {
+    _tag: "NumberConstraints",
+    constraints: {},
+    isInteger: options.isInteger ?? false
+  };
+  if (Predicate.isNumber(options.min)) {
+    out.constraints.min = Math.fround(options.min);
+  }
+  if (Predicate.isBoolean(options.minExcluded)) {
+    out.constraints.minExcluded = options.minExcluded;
+  }
+  if (Predicate.isNumber(options.max)) {
+    out.constraints.max = Math.fround(options.max);
+  }
+  if (Predicate.isBoolean(options.maxExcluded)) {
+    out.constraints.maxExcluded = options.maxExcluded;
+  }
+  if (Predicate.isBoolean(options.noNaN)) {
+    out.constraints.noNaN = options.noNaN;
+  }
+  if (Predicate.isBoolean(options.noDefaultInfinity)) {
+    out.constraints.noDefaultInfinity = options.noDefaultInfinity;
+  }
+  return out;
+};
+/** @internal */
+export const makeBigIntConstraints = options => {
+  const out = {
+    _tag: "BigIntConstraints",
+    constraints: {}
+  };
+  if (Predicate.isBigInt(options.min)) {
+    out.constraints.min = options.min;
+  }
+  if (Predicate.isBigInt(options.max)) {
+    out.constraints.max = options.max;
+  }
+  return out;
+};
+/** @internal */
+export const makeArrayConstraints = options => {
+  const out = {
+    _tag: "ArrayConstraints",
+    constraints: {}
+  };
+  if (Predicate.isNumber(options.minLength)) {
+    out.constraints.minLength = options.minLength;
+  }
+  if (Predicate.isNumber(options.maxLength)) {
+    out.constraints.maxLength = options.maxLength;
+  }
+  return out;
+};
+/** @internal */
+export const makeDateConstraints = options => {
+  const out = {
+    _tag: "DateConstraints",
+    constraints: {}
+  };
+  if (Predicate.isDate(options.min)) {
+    out.constraints.min = options.min;
+  }
+  if (Predicate.isDate(options.max)) {
+    out.constraints.max = options.max;
+  }
+  if (Predicate.isBoolean(options.noInvalidDate)) {
+    out.constraints.noInvalidDate = options.noInvalidDate;
+  }
+  return out;
+};
+const getArbitraryAnnotation = /*#__PURE__*/SchemaAST.getAnnotation(SchemaAST.ArbitraryAnnotationId);
+const getASTConstraints = ast => {
+  const TypeAnnotationId = ast.annotations[SchemaAST.SchemaIdAnnotationId];
+  if (Predicate.isPropertyKey(TypeAnnotationId)) {
+    const out = ast.annotations[TypeAnnotationId];
+    if (Predicate.isReadonlyRecord(out)) {
+      return out;
+    }
+  }
+};
+const idMemoMap = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Arbitrary/IdMemoMap"), () => new Map());
+let counter = 0;
+function wrapGetDescription(f, g) {
+  return (ast, path) => f(ast, g(ast, path));
+}
+function parseMeta(ast) {
+  const jsonSchema = SchemaAST.getJSONSchemaAnnotation(ast).pipe(Option.filter(Predicate.isReadonlyRecord), Option.getOrUndefined);
+  const schemaId = Option.getOrElse(SchemaAST.getSchemaIdAnnotation(ast), () => undefined);
+  const schemaParams = Option.fromNullable(schemaId).pipe(Option.map(id => ast.annotations[id]), Option.filter(Predicate.isReadonlyRecord), Option.getOrUndefined);
+  return [schemaId, {
+    ...schemaParams,
+    ...jsonSchema
+  }];
+}
+/** @internal */
+export const getDescription = /*#__PURE__*/wrapGetDescription((ast, description) => {
+  const annotation = getArbitraryAnnotation(ast);
+  if (Option.isSome(annotation)) {
+    return {
+      ...description,
+      annotations: [...description.annotations, annotation.value]
+    };
+  }
+  return description;
+}, (ast, path) => {
+  const [schemaId, meta] = parseMeta(ast);
+  switch (ast._tag) {
+    case "Refinement":
+      {
+        const from = getDescription(ast.from, path);
+        switch (from._tag) {
+          case "StringKeyword":
+            return {
+              ...from,
+              constraints: [...from.constraints, makeStringConstraints(meta)],
+              refinements: [...from.refinements, ast]
+            };
+          case "NumberKeyword":
+            {
+              const c = schemaId === schemaId_.NonNaNSchemaId ? makeNumberConstraints({
+                noNaN: true
+              }) : schemaId === schemaId_.FiniteSchemaId || schemaId === schemaId_.JsonNumberSchemaId ? makeNumberConstraints({
+                noDefaultInfinity: true,
+                noNaN: true
+              }) : makeNumberConstraints({
+                isInteger: "type" in meta && meta.type === "integer",
+                noNaN: undefined,
+                noDefaultInfinity: undefined,
+                min: meta.exclusiveMinimum ?? meta.minimum,
+                minExcluded: "exclusiveMinimum" in meta ? true : undefined,
+                max: meta.exclusiveMaximum ?? meta.maximum,
+                maxExcluded: "exclusiveMaximum" in meta ? true : undefined
+              });
+              return {
+                ...from,
+                constraints: [...from.constraints, c],
+                refinements: [...from.refinements, ast]
+              };
+            }
+          case "BigIntKeyword":
+            {
+              const c = getASTConstraints(ast);
+              return {
+                ...from,
+                constraints: c !== undefined ? [...from.constraints, makeBigIntConstraints(c)] : from.constraints,
+                refinements: [...from.refinements, ast]
+              };
+            }
+          case "TupleType":
+            return {
+              ...from,
+              constraints: [...from.constraints, makeArrayConstraints({
+                minLength: meta.minItems,
+                maxLength: meta.maxItems
+              })],
+              refinements: [...from.refinements, ast]
+            };
+          case "DateFromSelf":
+            return {
+              ...from,
+              constraints: [...from.constraints, makeDateConstraints(meta)],
+              refinements: [...from.refinements, ast]
+            };
+          default:
+            return {
+              ...from,
+              refinements: [...from.refinements, ast]
+            };
+        }
+      }
+    case "Declaration":
+      {
+        if (schemaId === schemaId_.DateFromSelfSchemaId) {
+          return {
+            _tag: "DateFromSelf",
+            constraints: [makeDateConstraints(meta)],
+            path,
+            refinements: [],
+            annotations: []
+          };
+        }
+        return {
+          _tag: "Declaration",
+          typeParameters: ast.typeParameters.map(ast => getDescription(ast, path)),
+          path,
+          refinements: [],
+          annotations: [],
+          ast
+        };
+      }
+    case "Literal":
+      {
+        return {
+          _tag: "Literal",
+          literal: ast.literal,
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+    case "UniqueSymbol":
+      {
+        return {
+          _tag: "UniqueSymbol",
+          symbol: ast.symbol,
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+    case "Enums":
+      {
+        return {
+          _tag: "Enums",
+          enums: ast.enums,
+          path,
+          refinements: [],
+          annotations: [],
+          ast
+        };
+      }
+    case "TemplateLiteral":
+      {
+        return {
+          _tag: "TemplateLiteral",
+          head: ast.head,
+          spans: ast.spans.map(span => ({
+            description: getDescription(span.type, path),
+            literal: span.literal
+          })),
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+    case "StringKeyword":
+      return {
+        _tag: "StringKeyword",
+        constraints: [],
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "NumberKeyword":
+      return {
+        _tag: "NumberKeyword",
+        constraints: [],
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "BigIntKeyword":
+      return {
+        _tag: "BigIntKeyword",
+        constraints: [],
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "TupleType":
+      return {
+        _tag: "TupleType",
+        constraints: [],
+        elements: ast.elements.map((element, i) => ({
+          isOptional: element.isOptional,
+          description: getDescription(element.type, [...path, i])
+        })),
+        rest: ast.rest.map((element, i) => getDescription(element.type, [...path, i])),
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "TypeLiteral":
+      return {
+        _tag: "TypeLiteral",
+        propertySignatures: ast.propertySignatures.map(ps => ({
+          isOptional: ps.isOptional,
+          name: ps.name,
+          value: getDescription(ps.type, [...path, ps.name])
+        })),
+        indexSignatures: ast.indexSignatures.map(is => ({
+          parameter: getDescription(is.parameter, path),
+          value: getDescription(is.type, path)
+        })),
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "Union":
+      return {
+        _tag: "Union",
+        members: ast.types.map((member, i) => getDescription(member, [...path, i])),
+        path,
+        refinements: [],
+        annotations: []
+      };
+    case "Suspend":
+      {
+        const memoId = idMemoMap.get(ast);
+        if (memoId !== undefined) {
+          return {
+            _tag: "Ref",
+            id: memoId,
+            ast,
+            path,
+            refinements: [],
+            annotations: []
+          };
+        }
+        counter++;
+        const id = `__id-${counter}__`;
+        idMemoMap.set(ast, id);
+        return {
+          _tag: "Suspend",
+          id,
+          ast,
+          description: () => getDescription(ast.f(), path),
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+    case "Transformation":
+      return getDescription(ast.to, path);
+    case "NeverKeyword":
+      return {
+        _tag: "NeverKeyword",
+        path,
+        refinements: [],
+        annotations: [],
+        ast
+      };
+    default:
+      {
+        return {
+          _tag: "Keyword",
+          value: ast._tag,
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+  }
+});
+function getMax(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1;
+}
+function getMin(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2;
+}
+const getOr = (a, b) => {
+  return a === undefined ? b : b === undefined ? a : a || b;
+};
+function mergePattern(pattern1, pattern2) {
+  if (pattern1 === undefined) {
+    return pattern2;
+  }
+  if (pattern2 === undefined) {
+    return pattern1;
+  }
+  return `(?:${pattern1})|(?:${pattern2})`;
+}
+function mergeStringConstraints(c1, c2) {
+  return makeStringConstraints({
+    minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
+    maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength),
+    pattern: mergePattern(c1.pattern, c2.pattern)
+  });
+}
+function buildStringConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeStringConstraints);
+}
+function mergeNumberConstraints(c1, c2) {
+  return makeNumberConstraints({
+    isInteger: c1.isInteger || c2.isInteger,
+    min: getMax(c1.constraints.min, c2.constraints.min),
+    minExcluded: getOr(c1.constraints.minExcluded, c2.constraints.minExcluded),
+    max: getMin(c1.constraints.max, c2.constraints.max),
+    maxExcluded: getOr(c1.constraints.maxExcluded, c2.constraints.maxExcluded),
+    noNaN: getOr(c1.constraints.noNaN, c2.constraints.noNaN),
+    noDefaultInfinity: getOr(c1.constraints.noDefaultInfinity, c2.constraints.noDefaultInfinity)
+  });
+}
+function buildNumberConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeNumberConstraints);
+}
+function mergeBigIntConstraints(c1, c2) {
+  return makeBigIntConstraints({
+    min: getMax(c1.constraints.min, c2.constraints.min),
+    max: getMin(c1.constraints.max, c2.constraints.max)
+  });
+}
+function buildBigIntConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeBigIntConstraints);
+}
+function mergeDateConstraints(c1, c2) {
+  return makeDateConstraints({
+    min: getMax(c1.constraints.min, c2.constraints.min),
+    max: getMin(c1.constraints.max, c2.constraints.max),
+    noInvalidDate: getOr(c1.constraints.noInvalidDate, c2.constraints.noInvalidDate)
+  });
+}
+function buildDateConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeDateConstraints);
+}
+const constArrayConstraints = /*#__PURE__*/makeArrayConstraints({});
+function mergeArrayConstraints(c1, c2) {
+  return makeArrayConstraints({
+    minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
+    maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
+  });
+}
+function buildArrayConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeArrayConstraints);
+}
+const arbitraryMemoMap = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Arbitrary/arbitraryMemoMap"), () => new WeakMap());
+function applyFilters(filters, arb) {
+  return fc => filters.reduce((arb, filter) => arb.filter(filter), arb(fc));
+}
+function absurd(message) {
+  return () => {
+    throw new Error(message);
+  };
+}
+function getContextConstraints(description) {
+  switch (description._tag) {
+    case "StringKeyword":
+      return buildStringConstraints(description);
+    case "NumberKeyword":
+      return buildNumberConstraints(description);
+    case "BigIntKeyword":
+      return buildBigIntConstraints(description);
+    case "DateFromSelf":
+      return buildDateConstraints(description);
+    case "TupleType":
+      return buildArrayConstraints(description);
+  }
+}
+function wrapGo(f, g) {
+  return (description, ctx) => f(description, ctx, g(description, ctx));
+}
+const go = /*#__PURE__*/wrapGo((description, ctx, lazyArb) => {
+  const annotation = description.annotations[description.annotations.length - 1];
+  // error handling
+  if (annotation === undefined) {
+    switch (description._tag) {
+      case "Declaration":
+      case "NeverKeyword":
+        throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(description.path, description.ast));
+      case "Enums":
+        if (description.enums.length === 0) {
+          throw new Error(errors_.getArbitraryEmptyEnumErrorMessage(description.path));
+        }
+    }
+  }
+  const filters = description.refinements.map(ast => a => Option.isNone(ast.filter(a, SchemaAST.defaultParseOption, ast)));
+  if (annotation === undefined) {
+    return applyFilters(filters, lazyArb);
+  }
+  const constraints = getContextConstraints(description);
+  if (constraints !== undefined) {
+    ctx = {
+      ...ctx,
+      constraints
+    };
+  }
+  if (description._tag === "Declaration") {
+    return applyFilters(filters, annotation(...description.typeParameters.map(p => go(p, ctx)), ctx));
+  }
+  if (description.refinements.length > 0) {
+    // TODO(4.0): remove the `lazyArb` parameter
+    return applyFilters(filters, annotation(lazyArb, ctx));
+  }
+  return annotation(ctx);
+}, (description, ctx) => {
+  switch (description._tag) {
+    case "DateFromSelf":
+      {
+        const constraints = buildDateConstraints(description);
+        return fc => fc.date(constraints?.constraints);
+      }
+    case "Declaration":
+    case "NeverKeyword":
+      return absurd(`BUG: cannot generate an arbitrary for ${description._tag}`);
+    case "Literal":
+      return fc => fc.constant(description.literal);
+    case "UniqueSymbol":
+      return fc => fc.constant(description.symbol);
+    case "Keyword":
+      {
+        switch (description.value) {
+          case "UndefinedKeyword":
+            return fc => fc.constant(undefined);
+          case "VoidKeyword":
+          case "UnknownKeyword":
+          case "AnyKeyword":
+            return fc => fc.anything();
+          case "BooleanKeyword":
+            return fc => fc.boolean();
+          case "SymbolKeyword":
+            return fc => fc.string().map(s => Symbol.for(s));
+          case "ObjectKeyword":
+            return fc => fc.oneof(fc.object(), fc.array(fc.anything()));
+        }
+      }
+    case "Enums":
+      return fc => fc.oneof(...description.enums.map(([_, value]) => fc.constant(value)));
+    case "TemplateLiteral":
+      {
+        return fc => {
+          const string = fc.string({
+            maxLength: 5
+          });
+          const number = fc.float({
+            noDefaultInfinity: true,
+            noNaN: true
+          });
+          const getTemplateLiteralArb = description => {
+            const components = description.head !== "" ? [fc.constant(description.head)] : [];
+            const getTemplateLiteralSpanTypeArb = description => {
+              switch (description._tag) {
+                case "StringKeyword":
+                  return string;
+                case "NumberKeyword":
+                  return number;
+                case "Literal":
+                  return fc.constant(String(description.literal));
+                case "Union":
+                  return fc.oneof(...description.members.map(getTemplateLiteralSpanTypeArb));
+                case "TemplateLiteral":
+                  return getTemplateLiteralArb(description);
+                default:
+                  return fc.constant("");
+              }
+            };
+            description.spans.forEach(span => {
+              components.push(getTemplateLiteralSpanTypeArb(span.description));
+              if (span.literal !== "") {
+                components.push(fc.constant(span.literal));
+              }
+            });
+            return fc.tuple(...components).map(spans => spans.join(""));
+          };
+          return getTemplateLiteralArb(description);
+        };
+      }
+    case "StringKeyword":
+      {
+        const constraints = buildStringConstraints(description);
+        const pattern = constraints?.pattern;
+        return pattern !== undefined ? fc => fc.stringMatching(new RegExp(pattern)) : fc => fc.string(constraints?.constraints);
+      }
+    case "NumberKeyword":
+      {
+        const constraints = buildNumberConstraints(description);
+        return constraints?.isInteger ? fc => fc.integer(constraints.constraints) : fc => fc.float(constraints?.constraints);
+      }
+    case "BigIntKeyword":
+      {
+        const constraints = buildBigIntConstraints(description);
+        return fc => fc.bigInt(constraints?.constraints ?? {});
+      }
+    case "TupleType":
+      {
+        const elements = [];
+        let hasOptionals = false;
+        for (const element of description.elements) {
+          elements.push(go(element.description, ctx));
+          if (element.isOptional) {
+            hasOptionals = true;
+          }
+        }
+        const rest = description.rest.map(d => go(d, ctx));
+        return fc => {
+          // ---------------------------------------------
+          // handle elements
+          // ---------------------------------------------
+          let output = fc.tuple(...elements.map(arb => arb(fc)));
+          if (hasOptionals) {
+            const indexes = fc.tuple(...description.elements.map(element => element.isOptional ? fc.boolean() : fc.constant(true)));
+            output = output.chain(tuple => indexes.map(booleans => {
+              for (const [i, b] of booleans.reverse().entries()) {
+                if (!b) {
+                  tuple.splice(booleans.length - i, 1);
+                }
+              }
+              return tuple;
+            }));
+          }
+          // ---------------------------------------------
+          // handle rest element
+          // ---------------------------------------------
+          if (Arr.isNonEmptyReadonlyArray(rest)) {
+            const constraints = buildArrayConstraints(description) ?? constArrayConstraints;
+            const [head, ...tail] = rest;
+            const item = head(fc);
+            output = output.chain(as => {
+              const len = as.length;
+              // We must adjust the constraints for the rest element
+              // because the elements might have generated some values
+              const restArrayConstraints = subtractElementsLength(constraints.constraints, len);
+              if (restArrayConstraints.maxLength === 0) {
+                return fc.constant(as);
+              }
+              /*
+                         `getSuspendedArray` is used to generate less values in
+              the context of a recursive schema. Without it, the following schema
+              would generate an big amount of values possibly leading to a stack
+              overflow:
+                         ```ts
+              type A = ReadonlyArray<A | null>
+                         const schema = S.Array(
+                S.NullOr(S.suspend((): S.Schema<A> => schema))
+              )
+              ```
+                       */
+              const arr = ctx.depthIdentifier !== undefined ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, restArrayConstraints) : fc.array(item, restArrayConstraints);
+              if (len === 0) {
+                return arr;
+              }
+              return arr.map(rest => [...as, ...rest]);
+            });
+            // ---------------------------------------------
+            // handle post rest elements
+            // ---------------------------------------------
+            for (let j = 0; j < tail.length; j++) {
+              output = output.chain(as => tail[j](fc).map(a => [...as, a]));
+            }
+          }
+          return output;
+        };
+      }
+    case "TypeLiteral":
+      {
+        const propertySignatures = [];
+        const requiredKeys = [];
+        for (const ps of description.propertySignatures) {
+          if (!ps.isOptional) {
+            requiredKeys.push(ps.name);
+          }
+          propertySignatures.push(go(ps.value, ctx));
+        }
+        const indexSignatures = description.indexSignatures.map(is => [go(is.parameter, ctx), go(is.value, ctx)]);
+        return fc => {
+          const pps = {};
+          for (let i = 0; i < propertySignatures.length; i++) {
+            const ps = description.propertySignatures[i];
+            pps[ps.name] = propertySignatures[i](fc);
+          }
+          let output = fc.record(pps, {
+            requiredKeys
+          });
+          // ---------------------------------------------
+          // handle index signatures
+          // ---------------------------------------------
+          for (let i = 0; i < indexSignatures.length; i++) {
+            const key = indexSignatures[i][0](fc);
+            const value = indexSignatures[i][1](fc);
+            output = output.chain(o => {
+              const item = fc.tuple(key, value);
+              /*
+                         `getSuspendedArray` is used to generate less key/value pairs in
+              the context of a recursive schema. Without it, the following schema
+              would generate an big amount of values possibly leading to a stack
+              overflow:
+                         ```ts
+              type A = { [_: string]: A }
+                         const schema = S.Record({ key: S.String, value: S.suspend((): S.Schema<A> => schema) })
+              ```
+                       */
+              const arr = ctx.depthIdentifier !== undefined ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, {
+                maxLength: 2
+              }) : fc.array(item);
+              return arr.map(tuples => ({
+                ...Object.fromEntries(tuples),
+                ...o
+              }));
+            });
+          }
+          return output;
+        };
+      }
+    case "Union":
+      {
+        const members = description.members.map(member => go(member, ctx));
+        return fc => fc.oneof(...members.map(arb => arb(fc)));
+      }
+    case "Suspend":
+      {
+        const memo = arbitraryMemoMap.get(description.ast);
+        if (memo) {
+          return memo;
+        }
+        if (ctx.depthIdentifier === undefined) {
+          ctx = {
+            ...ctx,
+            depthIdentifier: description.id
+          };
+        }
+        const get = util_.memoizeThunk(() => {
+          return go(description.description(), ctx);
+        });
+        const out = fc => fc.constant(null).chain(() => get()(fc));
+        arbitraryMemoMap.set(description.ast, out);
+        return out;
+      }
+    case "Ref":
+      {
+        const memo = arbitraryMemoMap.get(description.ast);
+        if (memo) {
+          return memo;
+        }
+        throw new Error(`BUG: Ref ${JSON.stringify(description.id)} not found`);
+      }
+  }
+});
+function subtractElementsLength(constraints, len) {
+  if (len === 0 || constraints.minLength === undefined && constraints.maxLength === undefined) {
+    return constraints;
+  }
+  const out = {
+    ...constraints
+  };
+  if (out.minLength !== undefined) {
+    out.minLength = Math.max(out.minLength - len, 0);
+  }
+  if (out.maxLength !== undefined) {
+    out.maxLength = Math.max(out.maxLength - len, 0);
+  }
+  return out;
+}
+const getSuspendedArray = (fc, depthIdentifier, maxDepth, item, constraints) => {
+  // In the context of a recursive schema, we don't want a `maxLength` greater than 2.
+  // The only exception is when `minLength` is also set, in which case we set
+  // `maxLength` to the minimum value, which is `minLength`.
+  const maxLengthLimit = Math.max(2, constraints.minLength ?? 0);
+  if (constraints.maxLength !== undefined && constraints.maxLength > maxLengthLimit) {
+    constraints = {
+      ...constraints,
+      maxLength: maxLengthLimit
+    };
+  }
+  return fc.oneof({
+    maxDepth,
+    depthIdentifier
+  }, fc.constant([]), fc.array(item, constraints));
+};
+//# sourceMappingURL=Arbitrary.js.map

backend/node_modules/effect/dist/esm/Array.js

@@ -0,0 +1,2703 @@
+/**
+ * This module provides utility functions for working with arrays in TypeScript.
+ *
+ * @since 2.0.0
+ */
+import * as Either from "./Either.js";
+import * as Equal from "./Equal.js";
+import * as Equivalence from "./Equivalence.js";
+import { dual, identity } from "./Function.js";
+import * as internalArray from "./internal/array.js";
+import * as internalDoNotation from "./internal/doNotation.js";
+import * as moduleIterable from "./Iterable.js";
+import * as Option from "./Option.js";
+import * as Order from "./Order.js";
+import * as Predicate from "./Predicate.js";
+import * as Record from "./Record.js";
+import * as Tuple from "./Tuple.js";
+/**
+ * Builds a `NonEmptyArray` from an non-empty collection of elements.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.make(1, 2, 3)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const make = (...elements) => elements;
+/**
+ * Creates a new `Array` of the specified length.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.allocate<number>(3)
+ * console.log(result) // [ <3 empty items> ]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const allocate = n => new Array(n);
+/**
+ * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`.
+ *
+ * **Note**. `n` is normalized to an integer >= 1.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { makeBy } from "effect/Array"
+ *
+ * const result = makeBy(5, n => n * 2)
+ * console.log(result) // [0, 2, 4, 6, 8]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const makeBy = /*#__PURE__*/dual(2, (n, f) => {
+  const max = Math.max(1, Math.floor(n));
+  const out = new Array(max);
+  for (let i = 0; i < max; i++) {
+    out[i] = f(i);
+  }
+  return out;
+});
+/**
+ * Return a `NonEmptyArray` containing a range of integers, including both endpoints.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { range } from "effect/Array"
+ *
+ * const result = range(1, 3)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start + i) : [start];
+/**
+ * Return a `NonEmptyArray` containing a value repeated the specified number of times.
+ *
+ * **Note**. `n` is normalized to an integer >= 1.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.replicate("a", 3)
+ * console.log(result) // ["a", "a", "a"]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const replicate = /*#__PURE__*/dual(2, (a, n) => makeBy(n, () => a));
+/**
+ * Creates a new `Array` from an iterable collection of values.
+ * If the input is already an array, it returns the input as-is.
+ * Otherwise, it converts the iterable collection to an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.fromIterable(new Set([1, 2, 3]))
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const fromIterable = collection => Array.isArray(collection) ? collection : Array.from(collection);
+/**
+ * Creates a new `Array` from a value that might not be an iterable.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.ensure("a")) // ["a"]
+ * console.log(Array.ensure(["a"])) // ["a"]
+ * console.log(Array.ensure(["a", "b", "c"])) // ["a", "b", "c"]
+ * ```
+ *
+ * @category constructors
+ * @since 3.3.0
+ */
+export const ensure = self => Array.isArray(self) ? self : [self];
+/**
+ * Takes a record and returns an array of tuples containing its keys and values.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.fromRecord({ a: 1, b: 2, c: 3 })
+ * console.log(result) // [["a", 1], ["b", 2], ["c", 3]]
+ * ```
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export const fromRecord = Record.toEntries;
+/**
+ * Converts an `Option` to an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Option } from "effect"
+ *
+ * console.log(Array.fromOption(Option.some(1))) // [1]
+ * console.log(Array.fromOption(Option.none())) // []
+ * ```
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export const fromOption = Option.toArray;
+/**
+ * Matches the elements of an array, applying functions to cases of empty and non-empty arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const match = Array.match({
+ *   onEmpty: () => "empty",
+ *   onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`
+ * })
+ * console.log(match([])) // "empty"
+ * console.log(match([1, 2, 3])) // "head: 1, tail: 2"
+ * ```
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+export const match = /*#__PURE__*/dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(self) : onEmpty());
+/**
+ * Matches the elements of an array from the left, applying functions to cases of empty and non-empty arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const matchLeft = Array.matchLeft({
+ *   onEmpty: () => "empty",
+ *   onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}`
+ * })
+ * console.log(matchLeft([])) // "empty"
+ * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2"
+ * ```
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+export const matchLeft = /*#__PURE__*/dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());
+/**
+ * Matches the elements of an array from the right, applying functions to cases of empty and non-empty arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const matchRight = Array.matchRight({
+ *   onEmpty: () => "empty",
+ *   onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}`
+ * })
+ * console.log(matchRight([])) // "empty"
+ * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3"
+ * ```
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+export const matchRight = /*#__PURE__*/dual(2, (self, {
+  onEmpty,
+  onNonEmpty
+}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());
+/**
+ * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.prepend([2, 3, 4], 1)
+ * console.log(result) // [1, 2, 3, 4]
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const prepend = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
+/**
+ * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable).
+ * If either array is non-empty, the result is also a non-empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.prependAll([2, 3], [0, 1])
+ * console.log(result) // [0, 1, 2, 3]
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const prependAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(that).concat(fromIterable(self)));
+/**
+ * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.append([1, 2, 3], 4);
+ * console.log(result) // [1, 2, 3, 4]
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const append = /*#__PURE__*/dual(2, (self, last) => [...self, last]);
+/**
+ * Concatenates two arrays (or iterables), combining their elements.
+ * If either array is non-empty, the result is also a non-empty array.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+export const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
+/**
+ * Accumulates values from an `Iterable` starting from the left, storing
+ * each intermediate result in an array. Useful for tracking the progression of
+ * a value through a series of transformations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect";
+ *
+ * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value)
+ * console.log(result) // [0, 1, 3, 6, 10]
+ *
+ * // Explanation:
+ * // This function starts with the initial value (0 in this case)
+ * // and adds each element of the array to this accumulator one by one,
+ * // keeping track of the cumulative sum after each addition.
+ * // Each of these sums is captured in the resulting array.
+ * ```
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+export const scan = /*#__PURE__*/dual(3, (self, b, f) => {
+  const out = [b];
+  let i = 0;
+  for (const a of self) {
+    out[i + 1] = f(out[i], a);
+    i++;
+  }
+  return out;
+});
+/**
+ * Accumulates values from an `Iterable` starting from the right, storing
+ * each intermediate result in an array. Useful for tracking the progression of
+ * a value through a series of transformations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect";
+ *
+ * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value)
+ * console.log(result) // [10, 9, 7, 4, 0]
+ * ```
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+export const scanRight = /*#__PURE__*/dual(3, (self, b, f) => {
+  const input = fromIterable(self);
+  const out = new Array(input.length + 1);
+  out[input.length] = b;
+  for (let i = input.length - 1; i >= 0; i--) {
+    out[i] = f(out[i + 1], input[i]);
+  }
+  return out;
+});
+/**
+ * Determine if `unknown` is an Array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.isArray(null)) // false
+ * console.log(Array.isArray([1, 2, 3])) // true
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isArray = Array.isArray;
+/**
+ * Determine if an `Array` is empty narrowing down the type to `[]`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.isEmptyArray([])) // true
+ * console.log(Array.isEmptyArray([1, 2, 3])) // false
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isEmptyArray = self => self.length === 0;
+/**
+ * Determine if a `ReadonlyArray` is empty narrowing down the type to `readonly []`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.isEmptyReadonlyArray([])) // true
+ * console.log(Array.isEmptyReadonlyArray([1, 2, 3])) // false
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isEmptyReadonlyArray = isEmptyArray;
+/**
+ * Determine if an `Array` is non empty narrowing down the type to `NonEmptyArray`.
+ *
+ * An `Array` is considered to be a `NonEmptyArray` if it contains at least one element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.isNonEmptyArray([])) // false
+ * console.log(Array.isNonEmptyArray([1, 2, 3])) // true
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isNonEmptyArray = internalArray.isNonEmptyArray;
+/**
+ * Determine if a `ReadonlyArray` is non empty narrowing down the type to `NonEmptyReadonlyArray`.
+ *
+ * A `ReadonlyArray` is considered to be a `NonEmptyReadonlyArray` if it contains at least one element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.isNonEmptyReadonlyArray([])) // false
+ * console.log(Array.isNonEmptyReadonlyArray([1, 2, 3])) // true
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isNonEmptyReadonlyArray = internalArray.isNonEmptyArray;
+/**
+ * Return the number of elements in a `ReadonlyArray`.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const length = self => self.length;
+const isOutOfBounds = (i, as) => i < 0 || i >= as.length;
+const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
+/**
+ * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const get = /*#__PURE__*/dual(2, (self, index) => {
+  const i = Math.floor(index);
+  return isOutOfBounds(i, self) ? Option.none() : Option.some(self[i]);
+});
+/**
+ * Gets an element unsafely, will throw on out of bounds.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeGet = /*#__PURE__*/dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBounds(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
+/**
+ * Return a tuple containing the first element, and a new `Array` of the remaining elements, if any.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect";
+ *
+ * const result = Array.unprepend([1, 2, 3, 4])
+ * console.log(result) // [1, [2, 3, 4]]
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const unprepend = self => [headNonEmpty(self), tailNonEmpty(self)];
+/**
+ * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect";
+ *
+ * const result = Array.unappend([1, 2, 3, 4])
+ * console.log(result) // [[1, 2, 3], 4]
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const unappend = self => [initNonEmpty(self), lastNonEmpty(self)];
+/**
+ * Get the first element of a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const head = /*#__PURE__*/get(0);
+/**
+ * Get the first element of a non empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.headNonEmpty([1, 2, 3, 4])
+ * console.log(result) // 1
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const headNonEmpty = /*#__PURE__*/unsafeGet(0);
+/**
+ * Get the last element in a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const last = self => isNonEmptyReadonlyArray(self) ? Option.some(lastNonEmpty(self)) : Option.none();
+/**
+ * Get the last element of a non empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.lastNonEmpty([1, 2, 3, 4])
+ * console.log(result) // 4
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const lastNonEmpty = self => self[self.length - 1];
+/**
+ * Get all but the first element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const tail = self => {
+  const input = fromIterable(self);
+  return isNonEmptyReadonlyArray(input) ? Option.some(tailNonEmpty(input)) : Option.none();
+};
+/**
+ * Get all but the first element of a `NonEmptyReadonlyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.tailNonEmpty([1, 2, 3, 4])
+ * console.log(result) // [2, 3, 4]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const tailNonEmpty = self => self.slice(1);
+/**
+ * Get all but the last element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const init = self => {
+  const input = fromIterable(self);
+  return isNonEmptyReadonlyArray(input) ? Option.some(initNonEmpty(input)) : Option.none();
+};
+/**
+ * Get all but the last element of a non empty array, creating a new array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.initNonEmpty([1, 2, 3, 4])
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const initNonEmpty = self => self.slice(0, -1);
+/**
+ * Keep only a max number of elements from the start of an `Iterable`, creating a new `Array`.
+ *
+ * **Note**. `n` is normalized to a non negative integer.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.take([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const take = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  return input.slice(0, clamp(n, input));
+});
+/**
+ * Keep only a max number of elements from the end of an `Iterable`, creating a new `Array`.
+ *
+ * **Note**. `n` is normalized to a non negative integer.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.takeRight([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [3, 4, 5]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  const i = clamp(n, input);
+  return i === 0 ? [] : input.slice(-i);
+});
+/**
+ * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4)
+ * console.log(result) // [1, 3, 2]
+ *
+ * // Explanation:
+ * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result.
+ * // - The next element (`3`) is also less than `4`, so it adds `3`.
+ * // - The next element (`2`) is again less than `4`, so it adds `2`.
+ * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result.
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => {
+  let i = 0;
+  const out = [];
+  for (const a of self) {
+    if (!predicate(a, i)) {
+      break;
+    }
+    out.push(a);
+    i++;
+  }
+  return out;
+});
+const spanIndex = (self, predicate) => {
+  let i = 0;
+  for (const a of self) {
+    if (!predicate(a, i)) {
+      break;
+    }
+    i++;
+  }
+  return i;
+};
+/**
+ * Split an `Iterable` into two parts:
+ *
+ * 1. the longest initial subarray for which all elements satisfy the specified predicate
+ * 2. the remaining elements
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const span = /*#__PURE__*/dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
+/**
+ * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`.
+ *
+ * **Note**. `n` is normalized to a non negative integer.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.drop([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [3, 4, 5]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const drop = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  return input.slice(clamp(n, input), input.length);
+});
+/**
+ * Drop a max number of elements from the end of an `Iterable`, creating a new `Array`.
+ *
+ * **Note**. `n` is normalized to a non negative integer.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.dropRight([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const dropRight = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  return input.slice(0, input.length - clamp(n, input));
+});
+/**
+ * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.dropWhile([1, 2, 3, 4, 5], x => x < 4)
+ * console.log(result) // [4, 5]
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => fromIterable(self).slice(spanIndex(self, predicate)));
+/**
+ * Return the first index for which a predicate holds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.findFirstIndex([5, 3, 8, 9], x => x > 5)
+ * console.log(result) // Option.some(2)
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
+  let i = 0;
+  for (const a of self) {
+    if (predicate(a, i)) {
+      return Option.some(i);
+    }
+    i++;
+  }
+  return Option.none();
+});
+/**
+ * Return the last index for which a predicate holds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.findLastIndex([1, 3, 8, 9], x => x < 5)
+ * console.log(result) // Option.some(1)
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
+  const input = fromIterable(self);
+  for (let i = input.length - 1; i >= 0; i--) {
+    if (predicate(input[i], i)) {
+      return Option.some(i);
+    }
+  }
+  return Option.none();
+});
+/**
+ * Returns the first element that satisfies the specified
+ * predicate, or `None` if no such element exists.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3)
+ * console.log(result) // Option.some(4)
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findFirst = moduleIterable.findFirst;
+/**
+ * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
+ * Returns an `Option` containing the found element, or `Option.none` if no element matches.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0)
+ * console.log(result) // Option.some(4)
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findLast = /*#__PURE__*/dual(2, (self, f) => {
+  const input = fromIterable(self);
+  for (let i = input.length - 1; i >= 0; i--) {
+    const a = input[i];
+    const o = f(a, i);
+    if (Predicate.isBoolean(o)) {
+      if (o) {
+        return Option.some(a);
+      }
+    } else {
+      if (Option.isSome(o)) {
+        return o;
+      }
+    }
+  }
+  return Option.none();
+});
+/**
+ * Returns a tuple of the first element that satisfies the specified
+ * predicate and its index, or `None` if no such element exists.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3)
+ * console.log(result) // Option.some([4, 3])
+ * ```
+ *
+ * @category elements
+ * @since 3.17.0
+ */
+export const findFirstWithIndex = /*#__PURE__*/dual(2, (self, f) => {
+  let i = 0;
+  for (const a of self) {
+    const o = f(a, i);
+    if (Predicate.isBoolean(o)) {
+      if (o) {
+        return Option.some([a, i]);
+      }
+    } else {
+      if (Option.isSome(o)) {
+        return Option.some([o.value, i]);
+      }
+    }
+    i++;
+  }
+  return Option.none();
+});
+/**
+ * Counts all the element of the given array that pass the given predicate
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+ * console.log(result) // 2
+ * ```
+ *
+ * @category folding
+ * @since 3.16.0
+ */
+export const countBy = /*#__PURE__*/dual(2, (self, f) => {
+  let count = 0;
+  const as = fromIterable(self);
+  for (let i = 0; i < as.length; i++) {
+    const a = as[i];
+    if (f(a, i)) {
+      count++;
+    }
+  }
+  return count;
+});
+/**
+ * Insert an element at the specified index, creating a new `NonEmptyArray`,
+ * or return `None` if the index is out of bounds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.insertAt(['a', 'b', 'c', 'e'], 3, 'd')
+ * console.log(result) // Option.some(['a', 'b', 'c', 'd', 'e'])
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
+  const out = Array.from(self);
+  //             v--- `= self.length` is ok, it means inserting in last position
+  if (i < 0 || i > out.length) {
+    return Option.none();
+  }
+  out.splice(i, 0, b);
+  return Option.some(out);
+});
+/**
+ * Change the element at the specified index, creating a new `Array`,
+ * or return a copy of the input if the index is out of bounds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.replace(['a', 'b', 'c', 'd'], 1, 'z')
+ * console.log(result) // ['a', 'z', 'c', 'd']
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () => b));
+/**
+ * Replaces an element in an array with the given value, returning an option of the updated array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.replaceOption([1, 2, 3], 1, 4)
+ * console.log(result) // Option.some([1, 4, 3])
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const replaceOption = /*#__PURE__*/dual(3, (self, i, b) => modifyOption(self, i, () => b));
+/**
+ * Apply a function to the element at the specified index, creating a new `Array`,
+ * or return a copy of the input if the index is out of bounds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.modify([1, 2, 3, 4], 2, (n) => n * 2)
+ * console.log(result) // [1, 2, 6, 4]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const modify = /*#__PURE__*/dual(3, (self, i, f) => {
+  const out = Array.from(self);
+  if (isOutOfBounds(i, out)) {
+    return out;
+  }
+  const b = f(out[i]);
+  out[i] = b;
+  return out;
+});
+/**
+ * Apply a function to the element at the specified index, creating a new `Array`,
+ * or return `None` if the index is out of bounds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const input = [1, 2, 3, 4]
+ * const result = Array.modifyOption(input, 2, (n) => n * 2)
+ * console.log(result) // Option.some([1, 2, 6, 4])
+ *
+ * const outOfBoundsResult = Array.modifyOption(input, 5, (n) => n * 2)
+ * console.log(outOfBoundsResult) // Option.none()
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const modifyOption = /*#__PURE__*/dual(3, (self, i, f) => {
+  const arr = fromIterable(self);
+  if (isOutOfBounds(i, arr)) {
+    return Option.none();
+  }
+  const out = Array.isArray(self) ? self.slice() : arr;
+  const b = f(arr[i]);
+  out[i] = b;
+  return Option.some(out);
+});
+/**
+ * Delete the element at the specified index, creating a new `Array`,
+ * or return a copy of the input if the index is out of bounds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const input = [1, 2, 3, 4]
+ * const result = Array.remove(input, 2)
+ * console.log(result) // [1, 2, 4]
+ *
+ * const outOfBoundsResult = Array.remove(input, 5)
+ * console.log(outOfBoundsResult) // [1, 2, 3, 4]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const remove = /*#__PURE__*/dual(2, (self, i) => {
+  const out = Array.from(self);
+  if (isOutOfBounds(i, out)) {
+    return out;
+  }
+  out.splice(i, 1);
+  return out;
+});
+/**
+ * Delete the element at the specified index, creating a new `Array`,
+ * or return `None` if the index is out of bounds.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Array, Option } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4]
+ * const result = Array.removeOption(numbers, 2)
+ * assert.deepStrictEqual(result, Option.some([1, 2, 4]))
+ *
+ * const outOfBoundsResult = Array.removeOption(numbers, 5)
+ * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
+ *
+ * @since 3.16.0
+ */
+export const removeOption = /*#__PURE__*/dual(2, (self, i) => {
+  const arr = fromIterable(self);
+  if (isOutOfBounds(i, arr)) {
+    return Option.none();
+  }
+  const out = Array.isArray(self) ? self.slice() : arr;
+  out.splice(i, 1);
+  return Option.some(out);
+});
+/**
+ * Reverse an `Iterable`, creating a new `Array`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.reverse([1, 2, 3, 4])
+ * console.log(result) // [4, 3, 2, 1]
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const reverse = self => Array.from(self).reverse();
+/**
+ * Create a new array with elements sorted in increasing order based on the specified comparator.
+ * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`.
+ *
+ * @category sorting
+ * @since 2.0.0
+ */
+export const sort = /*#__PURE__*/dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
+/**
+ * Sorts an array based on a provided mapping function and order. The mapping
+ * function transforms the elements into a value that can be compared, and the
+ * order defines how those values should be sorted.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Order } from "effect"
+ *
+ * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number)
+ * console.log(result) // ["b", "cc", "aaa"]
+ *
+ * // Explanation:
+ * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length`
+ * // converts each string into its length, and the `Order.number` specifies that the lengths should
+ * // be sorted in ascending order.
+ * ```
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self).map(a => [a, f(a)]).sort(([, a], [, b]) => order(a, b)).map(([_]) => _));
+/**
+ * Sorts the elements of an `Iterable` in increasing order based on the provided
+ * orders. The elements are compared using the first order in `orders`, then the
+ * second order if the first comparison is equal, and so on.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Order, pipe } from "effect"
+ *
+ * const users = [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob", age: 25 },
+ *   { name: "Charlie", age: 30 }
+ * ]
+ *
+ * const result = pipe(
+ *   users,
+ *   Array.sortBy(
+ *     Order.mapInput(Order.number, (user: (typeof users)[number]) => user.age),
+ *     Order.mapInput(Order.string, (user: (typeof users)[number]) => user.name)
+ *   )
+ * )
+ *
+ * console.log(result)
+ * // [
+ * //   { name: "Bob", age: 25 },
+ * //   { name: "Alice", age: 30 },
+ * //   { name: "Charlie", age: 30 }
+ * // ]
+ *
+ * // Explanation:
+ * // The array of users is sorted first by age in ascending order. When ages are equal,
+ * // the users are further sorted by name in ascending order.
+ * ```
+ *
+ * @category sorting
+ * @since 2.0.0
+ */
+export const sortBy = (...orders) => {
+  const sortByAll = sort(Order.combineAll(orders));
+  return self => {
+    const input = fromIterable(self);
+    if (isNonEmptyReadonlyArray(input)) {
+      return sortByAll(input);
+    }
+    return [];
+  };
+};
+/**
+ * Takes two `Iterable`s and returns an `Array` of corresponding pairs.
+ * If one input `Iterable` is short, excess elements of the
+ * longer `Iterable` are discarded.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.zip([1, 2, 3], ['a', 'b'])
+ * console.log(result) // [[1, 'a'], [2, 'b']]
+ * ```
+ *
+ * @category zipping
+ * @since 2.0.0
+ */
+export const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, Tuple.make));
+/**
+ * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
+ * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b)
+ * console.log(result) // [5, 7, 9]
+ * ```
+ *
+ * @category zipping
+ * @since 2.0.0
+ */
+export const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
+  const as = fromIterable(self);
+  const bs = fromIterable(that);
+  if (isNonEmptyReadonlyArray(as) && isNonEmptyReadonlyArray(bs)) {
+    const out = [f(headNonEmpty(as), headNonEmpty(bs))];
+    const len = Math.min(as.length, bs.length);
+    for (let i = 1; i < len; i++) {
+      out[i] = f(as[i], bs[i]);
+    }
+    return out;
+  }
+  return [];
+});
+/**
+ * This function is the inverse of `zip`. Takes an `Iterable` of pairs and return two corresponding `Array`s.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.unzip([[1, "a"], [2, "b"], [3, "c"]])
+ * console.log(result) // [[1, 2, 3], ['a', 'b', 'c']]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const unzip = self => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const fa = [input[0][0]];
+    const fb = [input[0][1]];
+    for (let i = 1; i < input.length; i++) {
+      fa[i] = input[i][0];
+      fb[i] = input[i][1];
+    }
+    return [fa, fb];
+  }
+  return [[], []];
+};
+/**
+ * Places an element in between members of an `Iterable`.
+ * If the input is a non-empty array, the result is also a non-empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.intersperse([1, 2, 3], 0)
+ * console.log(result) // [1, 0, 2, 0, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const intersperse = /*#__PURE__*/dual(2, (self, middle) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const tail = tailNonEmpty(input);
+    for (let i = 0; i < tail.length; i++) {
+      if (i < tail.length) {
+        out.push(middle);
+      }
+      out.push(tail[i]);
+    }
+    return out;
+  }
+  return [];
+});
+/**
+ * Apply a function to the head, creating a new `NonEmptyReadonlyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10)
+ * console.log(result) // [10, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const modifyNonEmptyHead = /*#__PURE__*/dual(2, (self, f) => [f(headNonEmpty(self)), ...tailNonEmpty(self)]);
+/**
+ * Change the head, creating a new `NonEmptyReadonlyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.setNonEmptyHead([1, 2, 3], 10)
+ * console.log(result) // [10, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const setNonEmptyHead = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyHead(self, () => b));
+/**
+ * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2)
+ * console.log(result) // [1, 2, 6]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const modifyNonEmptyLast = /*#__PURE__*/dual(2, (self, f) => append(initNonEmpty(self), f(lastNonEmpty(self))));
+/**
+ * Change the last element, creating a new `NonEmptyReadonlyArray`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.setNonEmptyLast([1, 2, 3], 4)
+ * console.log(result) // [1, 2, 4]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const setNonEmptyLast = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyLast(self, () => b));
+/**
+ * Rotate an `Iterable` by `n` steps.
+ * If the input is a non-empty array, the result is also a non-empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2)
+ * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const rotate = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const len = input.length;
+    const m = Math.round(n) % len;
+    if (isOutOfBounds(Math.abs(m), input) || m === 0) {
+      return copy(input);
+    }
+    if (m < 0) {
+      const [f, s] = splitNonEmptyAt(input, -m);
+      return appendAll(s, f);
+    } else {
+      return rotate(self, m - len);
+    }
+  }
+  return [];
+});
+/**
+ * Returns a function that checks if a `ReadonlyArray` contains a given value using a provided `isEquivalent` function.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const isEquivalent = (a: number, b: number) => a === b
+ * const containsNumber = Array.containsWith(isEquivalent)
+ * const result = pipe([1, 2, 3, 4], containsNumber(3))
+ * console.log(result) // true
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const containsWith = isEquivalent => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
+      return true;
+    }
+  }
+  return false;
+});
+const _equivalence = /*#__PURE__*/Equal.equivalence();
+/**
+ * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const result = pipe(['a', 'b', 'c', 'd'], Array.contains('c'))
+ * console.log(result) // true
+ * ```
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const contains = /*#__PURE__*/containsWith(_equivalence);
+/**
+ * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input
+ * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a
+ * value and the rest of the `Array`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array<number>] => [as[0] * 2, as.slice(1)])
+ * console.log(result) // [2, 4, 6, 8, 10]
+ *
+ * // Explanation:
+ * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array.
+ * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`,
+ * // resulting in a new array `[2, 4, 6, 8, 10]`.
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const chop = /*#__PURE__*/dual(2, (self, f) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const [b, rest] = f(input);
+    const out = [b];
+    let next = rest;
+    while (internalArray.isNonEmptyArray(next)) {
+      const [b, rest] = f(next);
+      out.push(b);
+      next = rest;
+    }
+    return out;
+  }
+  return [];
+});
+/**
+ * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements.
+ * The value of `n` can be `0`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.splitAt([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [[1, 2, 3], [4, 5]]
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const splitAt = /*#__PURE__*/dual(2, (self, n) => {
+  const input = Array.from(self);
+  const _n = Math.floor(n);
+  if (isNonEmptyReadonlyArray(input)) {
+    if (_n >= 1) {
+      return splitNonEmptyAt(input, _n);
+    }
+    return [[], input];
+  }
+  return [input, []];
+});
+/**
+ * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements.
+ * The value of `n` must be `>= 1`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3)
+ * console.log(result) // [["a", "b", "c"], ["d", "e"]]
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const splitNonEmptyAt = /*#__PURE__*/dual(2, (self, n) => {
+  const _n = Math.max(1, Math.floor(n));
+  return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];
+});
+/**
+ * Splits this iterable into `n` equally sized arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3)
+ * console.log(result) // [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * ```
+ *
+ * @since 2.0.0
+ * @category splitting
+ */
+export const split = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  return chunksOf(input, Math.ceil(input.length / Math.floor(n)));
+});
+/**
+ * Splits this iterable on the first element that matches this predicate.
+ * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.splitWhere([1, 2, 3, 4, 5], n => n > 3)
+ * console.log(result) // [[1, 2, 3], [4, 5]]
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const splitWhere = /*#__PURE__*/dual(2, (self, predicate) => span(self, (a, i) => !predicate(a, i)));
+/**
+ * Copies an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.copy([1, 2, 3])
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const copy = self => self.slice();
+/**
+ * Pads an array.
+ * Returns a new array of length `n` with the elements of `array` followed by `fill` elements if `array` is shorter than `n`.
+ * If `array` is longer than `n`, the returned array will be a slice of `array` containing the `n` first elements of `array`.
+ * If `n` is less than or equal to 0, the returned array will be an empty array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.pad([1, 2, 3], 6, 0)
+ * console.log(result) // [1, 2, 3, 0, 0, 0]
+ * ```
+ *
+ * @since 3.8.4
+ */
+export const pad = /*#__PURE__*/dual(3, (self, n, fill) => {
+  if (self.length >= n) {
+    return take(self, n);
+  }
+  return appendAll(self, makeBy(n - self.length, () => fill));
+});
+/**
+ * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
+ * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
+ * definition of `chunksOf`; it satisfies the property that
+ *
+ * ```ts skip-type-checking
+ * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))
+ * ```
+ *
+ * whenever `n` evenly divides the length of `self`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.chunksOf([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [[1, 2], [3, 4], [5]]
+ *
+ * // Explanation:
+ * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`.
+ * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2,
+ * // the last chunk contains the remaining elements.
+ * // The result is `[[1, 2], [3, 4], [5]]`.
+ * ```
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+export const chunksOf = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    return chop(input, splitNonEmptyAt(n));
+  }
+  return [];
+});
+/**
+ * Creates sliding windows of size `n` from an `Iterable`.
+ * If the number of elements is less than `n` or if `n` is not greater than zero,
+ * an empty array is returned.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Array } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5]
+ * assert.deepStrictEqual(Array.window(numbers, 3), [[1, 2, 3], [2, 3, 4], [3, 4, 5]])
+ * assert.deepStrictEqual(Array.window(numbers, 6), [])
+ * ```
+ *
+ * @category splitting
+ * @since 3.13.2
+ */
+export const window = /*#__PURE__*/dual(2, (self, n) => {
+  const input = fromIterable(self);
+  if (n > 0 && isNonEmptyReadonlyArray(input)) {
+    return Array.from({
+      length: input.length - (n - 1)
+    }, (_, index) => input.slice(index, index + n));
+  }
+  return [];
+});
+/**
+ * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y)
+ * console.log(result) // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]]
+ * ```
+ *
+ * @category grouping
+ * @since 2.0.0
+ */
+export const groupWith = /*#__PURE__*/dual(2, (self, isEquivalent) => chop(self, as => {
+  const h = headNonEmpty(as);
+  const out = [h];
+  let i = 1;
+  for (; i < as.length; i++) {
+    const a = as[i];
+    if (isEquivalent(a, h)) {
+      out.push(a);
+    } else {
+      break;
+    }
+  }
+  return [out, as.slice(i)];
+}));
+/**
+ * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.group([1, 1, 2, 2, 2, 3, 1])
+ * console.log(result) // [[1, 1], [2, 2, 2], [3], [1]]
+ * ```
+ *
+ * @category grouping
+ * @since 2.0.0
+ */
+export const group = /*#__PURE__*/groupWith(/*#__PURE__*/Equal.equivalence());
+/**
+ * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
+ * function on each element, and grouping the results according to values returned
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const people = [
+ *   { name: "Alice", group: "A" },
+ *   { name: "Bob", group: "B" },
+ *   { name: "Charlie", group: "A" }
+ * ]
+ *
+ * const result = Array.groupBy(people, person => person.group)
+ * console.log(result)
+ * // {
+ * //  A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
+ * //  B: [{ name: "Bob", group: "B" }]
+ * // }
+ * ```
+ *
+ * @category grouping
+ * @since 2.0.0
+ */
+export const groupBy = /*#__PURE__*/dual(2, (self, f) => {
+  const out = {};
+  for (const a of self) {
+    const k = f(a);
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      out[k].push(a);
+    } else {
+      out[k] = [a];
+    }
+  }
+  return out;
+});
+/**
+ * Calculates the union of two arrays using the provided equivalence relation.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b)
+ * console.log(union) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
+  const a = fromIterable(self);
+  const b = fromIterable(that);
+  if (isNonEmptyReadonlyArray(a)) {
+    if (isNonEmptyReadonlyArray(b)) {
+      const dedupe = dedupeWith(isEquivalent);
+      return dedupe(appendAll(a, b));
+    }
+    return a;
+  }
+  return b;
+});
+/**
+ * Creates a union of two arrays, removing duplicates.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.union([1, 2], [2, 3])
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that, _equivalence));
+/**
+ * Creates an `Array` of unique values that are included in all given `Iterable`s using the provided `isEquivalent` function.
+ * The order and references of result values are determined by the first `Iterable`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * const array2 = [{ id: 3 }, { id: 4 }, { id: 1 }]
+ * const isEquivalent = (a: { id: number }, b: { id: number }) => a.id === b.id
+ * const result = Array.intersectionWith(isEquivalent)(array2)(array1)
+ * console.log(result) // [{ id: 1 }, { id: 3 }]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const intersectionWith = isEquivalent => {
+  const has = containsWith(isEquivalent);
+  return dual(2, (self, that) => {
+    const bs = fromIterable(that);
+    return fromIterable(self).filter(a => has(bs, a));
+  });
+};
+/**
+ * Creates an `Array` of unique values that are included in all given `Iterable`s.
+ * The order and references of result values are determined by the first `Iterable`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.intersection([1, 2, 3], [3, 4, 1])
+ * console.log(result) // [1, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const intersection = /*#__PURE__*/intersectionWith(_equivalence);
+/**
+ * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function.
+ * The order and references of result values are determined by the first `Iterable`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const array1 = [1, 2, 3]
+ * const array2 = [2, 3, 4]
+ * const difference = Array.differenceWith<number>((a, b) => a === b)(array1, array2)
+ * console.log(difference) // [1]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const differenceWith = isEquivalent => {
+  const has = containsWith(isEquivalent);
+  return dual(2, (self, that) => {
+    const bs = fromIterable(that);
+    return fromIterable(self).filter(a => !has(bs, a));
+  });
+};
+/**
+ * Creates a `Array` of values not included in the other given `Iterable`.
+ * The order and references of result values are determined by the first `Iterable`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const difference = Array.difference([1, 2, 3], [2, 3, 4])
+ * console.log(difference) // [1]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const difference = /*#__PURE__*/differenceWith(_equivalence);
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export const empty = () => [];
+/**
+ * Constructs a new `NonEmptyArray<A>` from the specified value.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const of = a => [a];
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+export const map = /*#__PURE__*/dual(2, (self, f) => self.map(f));
+/**
+ * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements.
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+export const flatMap = /*#__PURE__*/dual(2, (self, f) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
+    }
+  }
+  return out;
+});
+/**
+ * Combines multiple arrays into a single array by concatenating all elements
+ * from each nested array. This function ensures that the structure of nested
+ * arrays is collapsed into a single, flat array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.flatten([[1, 2], [], [3, 4], [], [5, 6]])
+ * console.log(result) // [1, 2, 3, 4, 5, 6]
+ * ```
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+export const flatten = /*#__PURE__*/flatMap(identity);
+/**
+ * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`.
+ * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Option } from "effect"
+ *
+ * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none()
+ *
+ * const result = Array.filterMap([1, 2, 3, 4, 5], evenSquares);
+ * console.log(result) // [4, 16]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    const o = f(as[i], i);
+    if (Option.isSome(o)) {
+      out.push(o.value);
+    }
+  }
+  return out;
+});
+/**
+ * Applies a function to each element of the array and filters based on the result, stopping when a condition is not met.
+ * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`.
+ * This is useful when you need to transform an array but only up to the point where a certain condition holds true.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Option } from "effect"
+ *
+ * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none()
+ *
+ * const result = Array.filterMapWhile([2, 4, 5], toSquareTillOdd)
+ * console.log(result) // [4, 16]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const filterMapWhile = /*#__PURE__*/dual(2, (self, f) => {
+  let i = 0;
+  const out = [];
+  for (const a of self) {
+    const b = f(a, i);
+    if (Option.isSome(b)) {
+      out.push(b.value);
+    } else {
+      break;
+    }
+    i++;
+  }
+  return out;
+});
+/**
+ * Applies a function to each element of the `Iterable`, categorizing the results into two separate arrays.
+ * This function is particularly useful for operations where each element can result in two possible types,
+ * and you want to separate these types into different collections. For instance, separating validation results
+ * into successes and failures.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Either } from "effect";
+ *
+ * const isEven = (x: number) => x % 2 === 0
+ *
+ * const result = Array.partitionMap([1, 2, 3, 4, 5], x =>
+ *   isEven(x) ? Either.right(x) : Either.left(x)
+ * )
+ * console.log(result)
+ * // [
+ * //   [1, 3, 5],
+ * //   [2, 4]
+ * // ]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
+  const left = [];
+  const right = [];
+  const as = fromIterable(self);
+  for (let i = 0; i < as.length; i++) {
+    const e = f(as[i], i);
+    if (Either.isLeft(e)) {
+      left.push(e.left);
+    } else {
+      right.push(e.right);
+    }
+  }
+  return [left, right];
+});
+/**
+ * Retrieves the `Some` values from an `Iterable` of `Option`s, collecting them into an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Option } from "effect"
+ *
+ * const result = Array.getSomes([Option.some(1), Option.none(), Option.some(2)])
+ * console.log(result) // [1, 2]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getSomes = /*#__PURE__*/filterMap(identity);
+/**
+ * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Either } from "effect"
+ *
+ * const result = Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)])
+ * console.log(result) // ["err"]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getLefts = self => {
+  const out = [];
+  for (const a of self) {
+    if (Either.isLeft(a)) {
+      out.push(a.left);
+    }
+  }
+  return out;
+};
+/**
+ * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Either } from "effect"
+ *
+ * const result = Array.getRights([Either.right(1), Either.left("err"), Either.right(2)])
+ * console.log(result) // [1, 2]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getRights = self => {
+  const out = [];
+  for (const a of self) {
+    if (Either.isRight(a)) {
+      out.push(a.right);
+    }
+  }
+  return out;
+};
+/**
+ * @category filtering
+ * @since 2.0.0
+ */
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
+    }
+  }
+  return out;
+});
+/**
+ * Separate elements based on a predicate that also exposes the index of the element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0)
+ * console.log(result) // [[1, 3], [2, 4]]
+ * ```
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const partition = /*#__PURE__*/dual(2, (self, predicate) => {
+  const left = [];
+  const right = [];
+  const as = fromIterable(self);
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      right.push(as[i]);
+    } else {
+      left.push(as[i]);
+    }
+  }
+  return [left, right];
+});
+/**
+ * Separates an `Iterable` into two arrays based on a predicate.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const separate = /*#__PURE__*/partitionMap(identity);
+/**
+ * Reduces an array from the left.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n)
+ * console.log(result) // 6
+ * ```
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+export const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
+/**
+ * Reduces an array from the right.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n)
+ * console.log(result) // 6
+ * ```
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+export const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).reduceRight((b, a, i) => f(b, a, i), b));
+/**
+ * Lifts a predicate into an array.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const isEven = (n: number) => n % 2 === 0
+ * const to = Array.liftPredicate(isEven)
+ * console.log(to(1)) // []
+ * console.log(to(2)) // [2]
+ * ```
+ *
+ * @category lifting
+ * @since 2.0.0
+ */
+export const liftPredicate = predicate => b => predicate(b) ? [b] : [];
+/**
+ * @category lifting
+ * @since 2.0.0
+ */
+export const liftOption = f => (...a) => fromOption(f(...a));
+/**
+ * @category conversions
+ * @since 2.0.0
+ */
+export const fromNullable = a => a == null ? empty() : [a];
+/**
+ * @category lifting
+ * @since 2.0.0
+ */
+export const liftNullable = f => (...a) => fromNullable(f(...a));
+/**
+ * Maps over an array and flattens the result, removing null and undefined values.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.flatMapNullable([1, 2, 3], n => (n % 2 === 0 ? null : n))
+ * console.log(result) // [1, 3]
+ *
+ * // Explanation:
+ * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers
+ * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened
+ * // to remove null values, resulting in [1, 3].
+ * ```
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+export const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => fromNullable(f(a))));
+/**
+ * Lifts a function that returns an `Either` into a function that returns an array.
+ * If the `Either` is a left, it returns an empty array.
+ * If the `Either` is a right, it returns an array with the right value.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Either } from "effect"
+ *
+ * const parseNumber = (s: string): Either.Either<number, Error> =>
+ *   isNaN(Number(s)) ? Either.left(new Error("Not a number")) : Either.right(Number(s))
+ *
+ * const liftedParseNumber = Array.liftEither(parseNumber)
+ *
+ * const result1 = liftedParseNumber("42")
+ * console.log(result1) // [42]
+ *
+ * const result2 = liftedParseNumber("not a number")
+ * console.log(result2) // []
+ *
+ * // Explanation:
+ * // The function parseNumber is lifted to return an array.
+ * // When parsing "42", it returns an Either.left with the number 42, resulting in [42].
+ * // When parsing "not a number", it returns an Either.right with an error, resulting in an empty array [].
+ * ```
+ *
+ * @category lifting
+ * @since 2.0.0
+ */
+export const liftEither = f => (...a) => {
+  const e = f(...a);
+  return Either.isLeft(e) ? [] : [e.right];
+};
+/**
+ * Check if a predicate holds true for every `ReadonlyArray` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const every = /*#__PURE__*/dual(2, (self, refinement) => self.every(refinement));
+/**
+ * Check if a predicate holds true for some `ReadonlyArray` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicate));
+/**
+ * Extends an array with a function that maps each subarray to a value.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.extend([1, 2, 3], as => as.length)
+ * console.log(result) // [3, 2, 1]
+ *
+ * // Explanation:
+ * // The function maps each subarray starting from each element to its length.
+ * // The subarrays are: [1, 2, 3], [2, 3], [3].
+ * // The lengths are: 3, 2, 1.
+ * // Therefore, the result is [3, 2, 1].
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const extend = /*#__PURE__*/dual(2, (self, f) => self.map((_, i, as) => f(as.slice(i))));
+/**
+ * Finds the minimum element in an array based on a comparator.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Order } from "effect"
+ *
+ * const result = Array.min([3, 1, 2], Order.number)
+ * console.log(result) // 1
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));
+/**
+ * Finds the maximum element in an array based on a comparator.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, Order } from "effect"
+ *
+ * const result = Array.max([3, 1, 2], Order.number)
+ * console.log(result) // 3
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export const unfold = (b, f) => {
+  const out = [];
+  let next = b;
+  let o;
+  while (Option.isSome(o = f(next))) {
+    const [a, b] = o.value;
+    out.push(a);
+    next = b;
+  }
+  return out;
+};
+/**
+ * This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.
+ * The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays.
+ * If all elements are equal, the arrays are then compared based on their length.
+ * It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.
+ *
+ * @category instances
+ * @since 2.0.0
+ */
+export const getOrder = Order.array;
+/**
+ * Creates an equivalence relation for arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const eq = Array.getEquivalence<number>((a, b) => a === b)
+ * console.log(eq([1, 2, 3], [1, 2, 3])) // true
+ * ```
+ *
+ * @category instances
+ * @since 2.0.0
+ */
+export const getEquivalence = Equivalence.array;
+/**
+ * Performs a side-effect for each element of the `Iterable`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));
+/**
+ * Remove duplicates from an `Iterable` using the provided `isEquivalent` function,
+ * preserving the order of the first occurrence of each element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const dedupeWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every(a => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
+/**
+ * Remove duplicates from an `Iterable`, preserving the order of the first occurrence of each element.
+ * The equivalence used to compare elements is provided by `Equal.equivalence()` from the `Equal` module.
+ *
+ * @since 2.0.0
+ */
+export const dedupe = self => dedupeWith(self, Equal.equivalence());
+/**
+ * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b)
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
+  const out = [];
+  let lastA = Option.none();
+  for (const a of self) {
+    if (Option.isNone(lastA) || !isEquivalent(a, lastA.value)) {
+      out.push(a);
+      lastA = Option.some(a);
+    }
+  }
+  return out;
+});
+/**
+ * Deduplicates adjacent elements that are identical.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.dedupeAdjacent([1, 1, 2, 2, 3, 3])
+ * console.log(result) // [1, 2, 3]
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(/*#__PURE__*/Equal.equivalence());
+/**
+ * Joins the elements together with "sep" in the middle.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const strings = ["a", "b", "c"]
+ * const joined = Array.join(strings, "-")
+ * console.log(joined) // "a-b-c"
+ * ```
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable(self).join(sep));
+/**
+ * Statefully maps over the chunk, producing new elements of type `B`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n])
+ * console.log(result) // [6, [1, 3, 6]]
+ * ```
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
+  let i = 0;
+  let s1 = s;
+  const out = [];
+  for (const a of self) {
+    const r = f(s1, a, i);
+    s1 = r[0];
+    out.push(r[1]);
+    i++;
+  }
+  return [s1, out];
+});
+/**
+ * Zips this chunk crosswise with the specified chunk using the specified combiner.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`)
+ * console.log(result) // ["1-a", "1-b", "2-a", "2-b"]
+ * ```
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(self, a => map(that, b => f(a, b))));
+/**
+ * Zips this chunk crosswise with the specified chunk.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.cartesian([1, 2], ["a", "b"])
+ * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+ * ```
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self, that, (a, b) => [a, b]));
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const doResult = pipe(
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const Do = /*#__PURE__*/of({});
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const doResult = pipe(
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const bind = /*#__PURE__*/internalDoNotation.bind(map, flatMap);
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const doResult = pipe(
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+export const bindTo = /*#__PURE__*/internalDoNotation.bindTo(map);
+const let_ = /*#__PURE__*/internalDoNotation.let_(map);
+export {
+/**
+ * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays.
+ *
+ * It can be used to simulate "array comprehension".
+ * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules.
+ *
+ * Here's how the do simulation works:
+ *
+ * 1. Start the do simulation using the `Do` value
+ * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values
+ * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
+ * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
+ * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array, pipe } from "effect"
+ *
+ * const doResult = pipe(
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
+ * )
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
+ *
+ * // equivalent
+ * const x = [1, 3, 5],
+ *       y = [2, 4, 6],
+ *       result = [];
+ * for(let i = 0; i < x.length; i++) {
+ *   for(let j = 0; j < y.length; j++) {
+ *     const _x = x[i], _y = y[j];
+ *     if(_x < _y) result.push([_x, _y] as const)
+ *   }
+ * }
+ *
+ * ```
+ *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link Do}
+ *
+ * @category do notation
+ * @since 3.2.0
+ */
+let_ as let };
+//# sourceMappingURL=Array.js.map

backend/node_modules/effect/dist/esm/BigDecimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigDecimal.js","names":["Equal","equivalence","dual","pipe","Hash","NodeInspectSymbol","Option","order","pipeArguments","hasProperty","DEFAULT_PRECISION","FINITE_INT_REGEX","TypeId","Symbol","for","BigDecimalProto","symbol","normalized","normalize","hash","value","combine","number","scale","cached","that","isBigDecimal","equals","toString","format","toJSON","_id","String","arguments","u","make","o","Object","create","unsafeMakeNormalized","bigint0","bigint10","RangeError","BigInt","bigint1","zero","self","undefined","digits","trail","i","length","substring","sum","multiply","subtract","divideWithPrecision","num","den","precision","numNegative","denNegative","negateResult","quotient","remainder","count","q","r","roundTerminal","n","pos","Number","divide","none","some","unsafeDivide","Order","scmp","sign","bigint","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","between","clamp","min","max","abs","negate","divisor","Math","unsafeRemainder","Equivalence","fromBigInt","unsafeFromNumber","getOrThrowWith","safeFromNumber","fromNumber","isFinite","string","includes","fromString","lead","split","s","base","exp","seperator","search","slice","isSafeInteger","test","offset","dot","unsafeFromString","Error","toExponential","negative","absolute","before","after","repeat","location","zeros","complete","isZero","head","tail","output","isNegative","unsafeToNumber","isInteger","isPositive","isBigDecimalArgs","args","ceil","truncated","truncate","floor","digitAt","scaled","round","options","mode","halfCeil","halfFloor","digit","sumAll","collection","out"],"sources":["../../src/BigDecimal.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

backend/node_modules/effect/dist/esm/BigInt.js

@@ -0,0 +1,548 @@
+/**
+ * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for
+ * `Equivalence` and `Order`.
+ *
+ * @module BigInt
+ * @since 2.0.0
+ * @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
+ * @see {@link module:Number} for more similar operations on `number` types
+ */
+import * as equivalence from "./Equivalence.js";
+import { dual } from "./Function.js";
+import * as Option from "./Option.js";
+import * as order from "./Order.js";
+import * as predicate from "./Predicate.js";
+const bigint0 = /*#__PURE__*/BigInt(0);
+const bigint1 = /*#__PURE__*/BigInt(1);
+const bigint2 = /*#__PURE__*/BigInt(2);
+/**
+ * Tests if a value is a `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isBigInt } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(isBigInt(1n), true)
+ * assert.deepStrictEqual(isBigInt(1), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isBigInt = predicate.isBigInt;
+/**
+ * Provides an addition operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sum } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sum(2n, 3n), 5n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const sum = /*#__PURE__*/dual(2, (self, that) => self + that);
+/**
+ * Provides a multiplication operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { multiply } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);
+/**
+ * Provides a subtraction operation on `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { subtract } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);
+/**
+ * Provides a division operation on `bigint`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Returns `None` if the divisor is `0n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const divide = /*#__PURE__*/dual(2, (self, that) => that === bigint0 ? Option.none() : Option.some(self / that));
+/**
+ * Provides a division operation on `bigint`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `bigint` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Throws a `RangeError` if the divisor is `0n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeDivide } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(unsafeDivide(6n, 3n), 2n)
+ * assert.deepStrictEqual(unsafeDivide(6n, 4n), 1n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const unsafeDivide = /*#__PURE__*/dual(2, (self, that) => self / that);
+/**
+ * Returns the result of adding `1n` to a given number.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { increment } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(increment(2n), 3n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const increment = n => n + bigint1;
+/**
+ * Decrements a number by `1n`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { decrement } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(decrement(3n), 2n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const decrement = n => n - bigint1;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Equivalence = equivalence.bigint;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Order = order.bigint;
+/**
+ * Returns `true` if the first argument is less than the second, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThan } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lessThan(2n, 3n), true)
+ * assert.deepStrictEqual(lessThan(3n, 3n), false)
+ * assert.deepStrictEqual(lessThan(4n, 3n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export const lessThan = /*#__PURE__*/order.lessThan(Order);
+/**
+ * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThanOrEqualTo } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lessThanOrEqualTo(2n, 3n), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(4n, 3n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export const lessThanOrEqualTo = /*#__PURE__*/order.lessThanOrEqualTo(Order);
+/**
+ * Returns `true` if the first argument is greater than the second, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { greaterThan } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(greaterThan(2n, 3n), false)
+ * assert.deepStrictEqual(greaterThan(3n, 3n), false)
+ * assert.deepStrictEqual(greaterThan(4n, 3n), true)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export const greaterThan = /*#__PURE__*/order.greaterThan(Order);
+/**
+ * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { greaterThanOrEqualTo } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(greaterThanOrEqualTo(2n, 3n), false)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(4n, 3n), true)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export const greaterThanOrEqualTo = /*#__PURE__*/order.greaterThanOrEqualTo(Order);
+/**
+ * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt } from "effect"
+ *
+ * const between = BigInt.between({ minimum: 0n, maximum: 5n })
+ *
+ * assert.deepStrictEqual(between(3n), true)
+ * assert.deepStrictEqual(between(-1n), false)
+ * assert.deepStrictEqual(between(6n), false)
+ * ```
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+export const between = /*#__PURE__*/order.between(Order);
+/**
+ * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.
+ *
+ * - If the `bigint` is less than the `minimum` value, the function returns the `minimum` value.
+ * - If the `bigint` is greater than the `maximum` value, the function returns the `maximum` value.
+ * - Otherwise, it returns the original `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt } from "effect"
+ *
+ * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
+ *
+ * assert.equal(clamp(3n), 3n)
+ * assert.equal(clamp(0n), 1n)
+ * assert.equal(clamp(6n), 5n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const clamp = /*#__PURE__*/order.clamp(Order);
+/**
+ * Returns the minimum between two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { min } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(min(2n, 3n), 2n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const min = /*#__PURE__*/order.min(Order);
+/**
+ * Returns the maximum between two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { max } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(max(2n, 3n), 3n)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const max = /*#__PURE__*/order.max(Order);
+/**
+ * Determines the sign of a given `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sign } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sign(-5n), -1)
+ * assert.deepStrictEqual(sign(0n), 0)
+ * assert.deepStrictEqual(sign(5n), 1)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const sign = n => Order(n, bigint0);
+/**
+ * Determines the absolute value of a given `bigint`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { abs } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(abs(-5n), 5n)
+ * assert.deepStrictEqual(abs(0n), 0n)
+ * assert.deepStrictEqual(abs(5n), 5n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const abs = n => n < bigint0 ? -n : n;
+/**
+ * Determines the greatest common divisor of two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { gcd } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const gcd = /*#__PURE__*/dual(2, (self, that) => {
+  while (that !== bigint0) {
+    const t = that;
+    that = self % that;
+    self = t;
+  }
+  return self;
+});
+/**
+ * Determines the least common multiple of two `bigint`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lcm } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const lcm = /*#__PURE__*/dual(2, (self, that) => self * that / gcd(self, that));
+/**
+ * Determines the square root of a given `bigint` unsafely. Throws if the given `bigint` is negative.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeSqrt } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(unsafeSqrt(4n), 2n)
+ * assert.deepStrictEqual(unsafeSqrt(9n), 3n)
+ * assert.deepStrictEqual(unsafeSqrt(16n), 4n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const unsafeSqrt = n => {
+  if (n < bigint0) {
+    throw new RangeError("Cannot take the square root of a negative number");
+  }
+  if (n < bigint2) {
+    return n;
+  }
+  let x = n / bigint2;
+  while (x * x > n) {
+    x = (n / x + x) / bigint2;
+  }
+  return x;
+};
+/**
+ * Determines the square root of a given `bigint` safely. Returns `none` if the given `bigint` is negative.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigInt.sqrt(4n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.sqrt(9n), Option.some(3n))
+ * assert.deepStrictEqual(BigInt.sqrt(16n), Option.some(4n))
+ * assert.deepStrictEqual(BigInt.sqrt(-1n), Option.none())
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const sqrt = n => greaterThanOrEqualTo(n, bigint0) ? Option.some(unsafeSqrt(n)) : Option.none();
+/**
+ * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sumAll } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const sumAll = collection => {
+  let out = bigint0;
+  for (const n of collection) {
+    out += n;
+  }
+  return out;
+};
+/**
+ * Takes an `Iterable` of `bigint`s and returns their multiplication as a single `number`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { multiplyAll } from "effect/BigInt"
+ *
+ * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const multiplyAll = collection => {
+  let out = bigint1;
+  for (const n of collection) {
+    if (n === bigint0) {
+      return bigint0;
+    }
+    out *= n;
+  }
+  return out;
+};
+/**
+ * Takes a `bigint` and returns an `Option` of `number`.
+ *
+ * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it converts the `bigint`
+ * to a number and returns `Option.some(number)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.toNumber(BigInt(42)), Option.some(42))
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+ * assert.deepStrictEqual(BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export const toNumber = b => {
+  if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
+    return Option.none();
+  }
+  return Option.some(Number(b));
+};
+/**
+ * Takes a string and returns an `Option` of `bigint`.
+ *
+ * If the string is empty or contains characters that cannot be converted into a `bigint`,
+ * it returns `Option.none()`, otherwise, it returns `Option.some(bigint)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.fromString("42"), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromString(" "), Option.none())
+ * assert.deepStrictEqual(BI.fromString("a"), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+export const fromString = s => {
+  try {
+    return s.trim() === "" ? Option.none() : Option.some(BigInt(s));
+  } catch {
+    return Option.none();
+  }
+};
+/**
+ * Takes a number and returns an `Option` of `bigint`.
+ *
+ * If the number is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it attempts to
+ * convert the number to a `bigint` and returns `Option.some(bigint)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigInt as BI, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BI.fromNumber(42), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(BI.fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
+ * assert.deepStrictEqual(BI.fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
+ * ```
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+export const fromNumber = n => {
+  if (n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER) {
+    return Option.none();
+  }
+  try {
+    return Option.some(BigInt(n));
+  } catch {
+    return Option.none();
+  }
+};
+//# sourceMappingURL=BigInt.js.map

backend/node_modules/effect/dist/esm/BigInt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigInt.js","names":["equivalence","dual","Option","order","predicate","bigint0","BigInt","bigint1","bigint2","isBigInt","sum","self","that","multiply","subtract","divide","none","some","unsafeDivide","increment","n","decrement","Equivalence","bigint","Order","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","between","clamp","min","max","sign","abs","gcd","t","lcm","unsafeSqrt","RangeError","x","sqrt","sumAll","collection","out","multiplyAll","toNumber","b","Number","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","fromString","s","trim","fromNumber"],"sources":["../../src/BigInt.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

backend/node_modules/effect/dist/esm/Boolean.js

@@ -0,0 +1,240 @@
+/**
+ * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
+ * It includes functions for basic boolean operations, as well as type class instances for
+ * `Equivalence` and `Order`.
+ *
+ * @since 2.0.0
+ */
+import * as equivalence from "./Equivalence.js";
+import { dual } from "./Function.js";
+import * as order from "./Order.js";
+import * as predicate from "./Predicate.js";
+/**
+ * Tests if a value is a `boolean`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isBoolean } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(isBoolean(true), true)
+ * assert.deepStrictEqual(isBoolean("true"), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+export const isBoolean = predicate.isBoolean;
+/**
+ * This function returns the result of either of the given functions depending on the value of the boolean parameter.
+ * It is useful when you have to run one of two functions depending on the boolean value.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Boolean } from "effect"
+ *
+ * assert.deepStrictEqual(Boolean.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")
+ * ```
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+export const match = /*#__PURE__*/dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Equivalence = equivalence.boolean;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Order = order.boolean;
+/**
+ * Negates the given boolean: `!self`
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { not } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(not(true), false)
+ * assert.deepStrictEqual(not(false), true)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const not = self => !self;
+/**
+ * Combines two boolean using AND: `self && that`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { and } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(and(true, true), true)
+ * assert.deepStrictEqual(and(true, false), false)
+ * assert.deepStrictEqual(and(false, true), false)
+ * assert.deepStrictEqual(and(false, false), false)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const and = /*#__PURE__*/dual(2, (self, that) => self && that);
+/**
+ * Combines two boolean using NAND: `!(self && that)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { nand } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(nand(true, true), false)
+ * assert.deepStrictEqual(nand(true, false), true)
+ * assert.deepStrictEqual(nand(false, true), true)
+ * assert.deepStrictEqual(nand(false, false), true)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const nand = /*#__PURE__*/dual(2, (self, that) => !(self && that));
+/**
+ * Combines two boolean using OR: `self || that`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { or } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(or(true, true), true)
+ * assert.deepStrictEqual(or(true, false), true)
+ * assert.deepStrictEqual(or(false, true), true)
+ * assert.deepStrictEqual(or(false, false), false)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const or = /*#__PURE__*/dual(2, (self, that) => self || that);
+/**
+ * Combines two booleans using NOR: `!(self || that)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { nor } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(nor(true, true), false)
+ * assert.deepStrictEqual(nor(true, false), false)
+ * assert.deepStrictEqual(nor(false, true), false)
+ * assert.deepStrictEqual(nor(false, false), true)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const nor = /*#__PURE__*/dual(2, (self, that) => !(self || that));
+/**
+ * Combines two booleans using XOR: `(!self && that) || (self && !that)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { xor } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(xor(true, true), false)
+ * assert.deepStrictEqual(xor(true, false), true)
+ * assert.deepStrictEqual(xor(false, true), true)
+ * assert.deepStrictEqual(xor(false, false), false)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const xor = /*#__PURE__*/dual(2, (self, that) => !self && that || self && !that);
+/**
+ * Combines two booleans using EQV (aka XNOR): `!xor(self, that)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { eqv } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(eqv(true, true), true)
+ * assert.deepStrictEqual(eqv(true, false), false)
+ * assert.deepStrictEqual(eqv(false, true), false)
+ * assert.deepStrictEqual(eqv(false, false), true)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const eqv = /*#__PURE__*/dual(2, (self, that) => !xor(self, that));
+/**
+ * Combines two booleans using an implication: `(!self || that)`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { implies } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(implies(true, true), true)
+ * assert.deepStrictEqual(implies(true, false), false)
+ * assert.deepStrictEqual(implies(false, true), true)
+ * assert.deepStrictEqual(implies(false, false), true)
+ * ```
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const implies = /*#__PURE__*/dual(2, (self, that) => self ? that : true);
+/**
+ * This utility function is used to check if all the elements in a collection of boolean values are `true`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { every } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(every([true, true, true]), true)
+ * assert.deepStrictEqual(every([true, false, true]), false)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const every = collection => {
+  for (const b of collection) {
+    if (!b) {
+      return false;
+    }
+  }
+  return true;
+};
+/**
+ * This utility function is used to check if at least one of the elements in a collection of boolean values is `true`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { some } from "effect/Boolean"
+ *
+ * assert.deepStrictEqual(some([true, false, true]), true)
+ * assert.deepStrictEqual(some([false, false, false]), false)
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const some = collection => {
+  for (const b of collection) {
+    if (b) {
+      return true;
+    }
+  }
+  return false;
+};
+//# sourceMappingURL=Boolean.js.map

backend/node_modules/effect/dist/esm/Boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Boolean.js","names":["equivalence","dual","order","predicate","isBoolean","match","value","options","onTrue","onFalse","Equivalence","boolean","Order","not","self","and","that","nand","or","nor","xor","eqv","implies","every","collection","b","some"],"sources":["../../src/Boolean.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;AAOA,OAAO,KAAKA,WAAW,MAAM,kBAAkB;AAE/C,SAASC,IAAI,QAAQ,eAAe;AACpC,OAAO,KAAKC,KAAK,MAAM,YAAY;AACnC,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAE3C;;;;;;;;;;;;;;;AAeA,OAAO,MAAMC,SAAS,GAAyCD,SAAS,CAACC,SAAS;AAElF;;;;;;;;;;;;;;;AAeA,OAAO,MAAMC,KAAK,gBA4CdJ,IAAI,CAAC,CAAC,EAAE,CAAOK,KAAc,EAAEC,OAGlC,KAAYD,KAAK,GAAGC,OAAO,CAACC,MAAM,EAAE,GAAGD,OAAO,CAACE,OAAO,EAAE,CAAC;AAE1D;;;;AAIA,OAAO,MAAMC,WAAW,GAAqCV,WAAW,CAACW,OAAO;AAEhF;;;;AAIA,OAAO,MAAMC,KAAK,GAAyBV,KAAK,CAACS,OAAO;AAExD;;;;;;;;;;;;;;;AAeA,OAAO,MAAME,GAAG,GAAIC,IAAa,IAAc,CAACA,IAAI;AAEpD;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMC,GAAG,gBAqCZd,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAcF,IAAI,IAAIE,IAAI,CAAC;AAEpE;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMC,IAAI,gBAqCbhB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAc,EAAEF,IAAI,IAAIE,IAAI,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAME,EAAE,gBAqCXjB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAcF,IAAI,IAAIE,IAAI,CAAC;AAEpE;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMG,GAAG,gBAqCZlB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAc,EAAEF,IAAI,IAAIE,IAAI,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMI,GAAG,gBAqCZnB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAe,CAACF,IAAI,IAAIE,IAAI,IAAMF,IAAI,IAAI,CAACE,IAAK,CAAC;AAE1F;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMK,GAAG,gBAqCZpB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAa,EAAEE,IAAa,KAAc,CAACI,GAAG,CAACN,IAAI,EAAEE,IAAI,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMM,OAAO,gBAqChBrB,IAAI,CAAC,CAAC,EAAE,CAACa,IAAI,EAAEE,IAAI,KAAKF,IAAI,GAAGE,IAAI,GAAG,IAAI,CAAC;AAE/C;;;;;;;;;;;;;;AAcA,OAAO,MAAMO,KAAK,GAAIC,UAA6B,IAAa;EAC9D,KAAK,MAAMC,CAAC,IAAID,UAAU,EAAE;IAC1B,IAAI,CAACC,CAAC,EAAE;MACN,OAAO,KAAK;IACd;EACF;EACA,OAAO,IAAI;AACb,CAAC;AAED;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,IAAI,GAAIF,UAA6B,IAAa;EAC7D,KAAK,MAAMC,CAAC,IAAID,UAAU,EAAE;IAC1B,IAAIC,CAAC,EAAE;MACL,OAAO,IAAI;IACb;EACF;EACA,OAAO,KAAK;AACd,CAAC","ignoreList":[]}

backend/node_modules/effect/dist/esm/Brand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Brand.js","names":["Arr","Either","identity","unsafeCoerce","Option","BrandTypeId","Symbol","for","RefinedConstructorsTypeId","error","message","meta","errors","flatten","refined","args","either","length","unbranded","right","left","match","onNone","onSome","Object","assign","getOrThrowWith","option","getRight","is","isRight","nominal","some","_args","all","brands","result","brand","nextResult","isLeft","onLeft","e","onRight"],"sources":["../../src/Brand.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

backend/node_modules/effect/dist/esm/Cache.js

@@ -0,0 +1,43 @@
+import * as internal from "./internal/cache.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const CacheTypeId = internal.CacheTypeId;
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+export const ConsumerCacheTypeId = internal.ConsumerCacheTypeId;
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = internal.make;
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function, where the time to live can depend on the `Exit` value
+ * returned by the lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeWith = internal.makeWith;
+/**
+ * Constructs a new `CacheStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeCacheStats = internal.makeCacheStats;
+/**
+ * Constructs a new `EntryStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeEntryStats = internal.makeEntryStats;
+//# sourceMappingURL=Cache.js.map

backend/node_modules/effect/dist/esm/Cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.js","names":["internal","CacheTypeId","ConsumerCacheTypeId","make","makeWith","makeCacheStats","makeEntryStats"],"sources":["../../src/Cache.ts"],"sourcesContent":[null],"mappings":"AAOA,OAAO,KAAKA,QAAQ,MAAM,qBAAqB;AAK/C;;;;AAIA,OAAO,MAAMC,WAAW,GAAkBD,QAAQ,CAACC,WAAW;AAQ9D;;;;AAIA,OAAO,MAAMC,mBAAmB,GAAkBF,QAAQ,CAACE,mBAAmB;AAsK9E;;;;;;;AAOA,OAAO,MAAMC,IAAI,GAMkDH,QAAQ,CAACG,IAAI;AAEhF;;;;;;;;AAQA,OAAO,MAAMC,QAAQ,GAM8CJ,QAAQ,CAACI,QAAQ;AAepF;;;;;;AAMA,OAAO,MAAMC,cAAc,GAMTL,QAAQ,CAACK,cAAc;AAYzC;;;;;;AAMA,OAAO,MAAMC,cAAc,GAAyCN,QAAQ,CAACM,cAAc","ignoreList":[]}

backend/node_modules/effect/dist/esm/Cause.js

@@ -0,0 +1,1004 @@
+import * as internal from "./internal/cause.js";
+import * as core from "./internal/core.js";
+/**
+ * A unique symbol identifying the `Cause` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that helps identify instances of the `Cause` data
+ * type. This can be used for advanced operations such as refining types or
+ * building internal utilities that check whether an unknown value is a `Cause`.
+ *
+ * @see {@link isCause} Check if a value is a `Cause`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const CauseTypeId = internal.CauseTypeId;
+/**
+ * A unique symbol identifying the `RuntimeException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies a `RuntimeException`. This is
+ * typically used internally by the library to recognize checked exceptions that
+ * occur during runtime.
+ *
+ * @see {@link RuntimeException} Create or work with a `RuntimeException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const RuntimeExceptionTypeId = core.RuntimeExceptionTypeId;
+/**
+ * A unique symbol identifying the `InterruptedException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `InterruptedException`. This is
+ * typically used internally to recognize when a fiber has been interrupted,
+ * helping the framework handle interruption logic correctly.
+ *
+ * @see {@link InterruptedException} Create or work with an `InterruptedException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const InterruptedExceptionTypeId = core.InterruptedExceptionTypeId;
+/**
+ * A unique symbol identifying the `IllegalArgumentException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `IllegalArgumentException`. This is
+ * often used in scenarios where invalid arguments are supplied to methods that
+ * expect specific input.
+ *
+ * @see {@link IllegalArgumentException} Create or work with an `IllegalArgumentException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const IllegalArgumentExceptionTypeId = core.IllegalArgumentExceptionTypeId;
+/**
+ * A unique symbol identifying the `NoSuchElementException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies a `NoSuchElementException`. It helps
+ * differentiate cases where a required element is missing within a data
+ * structure.
+ *
+ * @see {@link NoSuchElementException} Create or work with a `NoSuchElementException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const NoSuchElementExceptionTypeId = core.NoSuchElementExceptionTypeId;
+/**
+ * A unique symbol identifying the `InvalidPubSubCapacityException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `InvalidPubSubCapacityException`.
+ * It indicates an error related to an invalid capacity passed to a `PubSub`
+ * structure.
+ *
+ * @see {@link InvalidPubSubCapacityException} Create or work with an `InvalidPubSubCapacityException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const InvalidPubSubCapacityExceptionTypeId = core.InvalidPubSubCapacityExceptionTypeId;
+/**
+ * A unique symbol identifying the `ExceededCapacityException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `ExceededCapacityException`. It
+ * denotes situations where a resource has exceeded its configured capacity
+ * limit.
+ *
+ * @see {@link ExceededCapacityException} Create or work with an `ExceededCapacityException`
+ *
+ * @since 3.5.0
+ * @category Symbols
+ */
+export const ExceededCapacityExceptionTypeId = core.ExceededCapacityExceptionTypeId;
+/**
+ * A unique symbol identifying the `TimeoutException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies a `TimeoutException`. It helps the
+ * framework recognize errors related to operations that fail to complete within
+ * a given timeframe.
+ *
+ * @see {@link TimeoutException} Create or work with a `TimeoutException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const TimeoutExceptionTypeId = core.TimeoutExceptionTypeId;
+/**
+ * A unique symbol identifying the `UnknownException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `UnknownException`. It is typically
+ * used for generic or unexpected errors that do not fit other specific
+ * exception categories.
+ *
+ * @see {@link UnknownException} Create or work with an `UnknownException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+export const UnknownExceptionTypeId = core.UnknownExceptionTypeId;
+/**
+ * Creates an error that occurs at runtime, extendable for other exception
+ * types.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const YieldableError = core.YieldableError;
+/**
+ * Creates an `Empty` cause.
+ *
+ * **Details**
+ *
+ * This function returns a cause that signifies "no error." It's commonly used
+ * to represent an absence of failure conditions.
+ *
+ * @see {@link isEmpty} Check if a `Cause` is empty
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const empty = internal.empty;
+/**
+ * Creates a `Fail` cause from an expected error.
+ *
+ * **Details**
+ *
+ * This function constructs a `Cause` carrying an error of type `E`. It's used
+ * when you want to represent a known or anticipated failure in your effectful
+ * computations.
+ *
+ * @see {@link isFailure} Check if a `Cause` contains a failure
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const fail = internal.fail;
+/**
+ * Creates a `Die` cause from an unexpected error.
+ *
+ * **Details**
+ *
+ * This function wraps an unhandled or unknown defect (like a runtime crash)
+ * into a `Cause`. It's useful for capturing unforeseen issues in a structured
+ * way.
+ *
+ * @see {@link isDie} Check if a `Cause` contains a defect
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const die = internal.die;
+/**
+ * Creates an `Interrupt` cause from a `FiberId`.
+ *
+ * **Details**
+ *
+ * This function represents a fiber that has been interrupted. It stores the
+ * identifier of the interrupted fiber, enabling precise tracking of concurrent
+ * cancellations.
+ *
+ * @see {@link isInterrupted} Check if a `Cause` contains an interruption
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const interrupt = internal.interrupt;
+/**
+ * Combines two `Cause`s in parallel.
+ *
+ * **Details**
+ *
+ * This function merges two errors that occurred simultaneously. Instead of
+ * discarding one error, both are retained, allowing for richer error reporting
+ * and debugging.
+ *
+ * @see {@link isParallelType} Check if a `Cause` is a `Parallel`
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const parallel = internal.parallel;
+/**
+ * Combines two `Cause`s sequentially.
+ *
+ * **Details**
+ *
+ * This function merges two errors that occurred in sequence, such as a main
+ * error followed by a finalization error. It preserves both errors for complete
+ * failure information.
+ *
+ * @see {@link isSequentialType} Check if a `Cause` is a `Sequential`
+ *
+ * @since 2.0.0
+ * @category Constructors
+ */
+export const sequential = internal.sequential;
+/**
+ * Checks if a value is a `Cause`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isCause = internal.isCause;
+/**
+ * Checks if a `Cause` is an `Empty` type.
+ *
+ * @see {@link empty} Create a new `Empty` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isEmptyType = internal.isEmptyType;
+/**
+ * Checks if a `Cause` is a `Fail` type.
+ *
+ * @see {@link fail} Create a new `Fail` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isFailType = internal.isFailType;
+/**
+ * Checks if a `Cause` is a `Die` type.
+ *
+ * @see {@link die} Create a new `Die` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isDieType = internal.isDieType;
+/**
+ * Checks if a `Cause` is an `Interrupt` type.
+ *
+ * @see {@link interrupt} Create an `Interrupt` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isInterruptType = internal.isInterruptType;
+/**
+ * Checks if a `Cause` is a `Sequential` type.
+ *
+ * @see {@link sequential} Combine two `Cause`s sequentially
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isSequentialType = internal.isSequentialType;
+/**
+ * Checks if a `Cause` is a `Parallel` type.
+ *
+ * @see {@link parallel} Combine two `Cause`s in parallel
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isParallelType = internal.isParallelType;
+/**
+ * Calculates the size of a `Cause`.
+ *
+ * **Details**
+ *
+ * This function returns the total number of `Cause` nodes in the semiring
+ * structure, reflecting how many individual error elements are recorded.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const size = internal.size;
+/**
+ * Checks if a `Cause` is entirely empty.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` contains no errors, defects, or
+ * interruptions. It's helpful for verifying if a computation truly had no
+ * failures.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const isEmpty = internal.isEmpty;
+/**
+ * Checks if a `Cause` contains a failure.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` includes any `Fail` error. It's
+ * commonly used to confirm whether a workflow encountered an anticipated error
+ * versus just defects or interruptions.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const isFailure = internal.isFailure;
+/**
+ * Checks if a `Cause` contains a defect.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` includes any unexpected or
+ * unhandled errors (`Die`). It's useful for differentiating known failures from
+ * unexpected ones.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const isDie = internal.isDie;
+/**
+ * Checks if a `Cause` contains an interruption.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` includes any fiber interruptions.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const isInterrupted = internal.isInterrupted;
+/**
+ * Checks if a `Cause` contains only interruptions.
+ *
+ * **Details**
+ *
+ * This function returns `true` if the `Cause` has been interrupted but does not
+ * contain any other failures, such as `Fail` or `Die`. It's helpful for
+ * verifying purely "cancellation" scenarios.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const isInterruptedOnly = internal.isInterruptedOnly;
+/**
+ * Extracts all recoverable errors of type `E` from a `Cause`.
+ *
+ * **Details**
+ *
+ * This function returns a chunk of errors, providing a list of all `Fail`
+ * values found in the cause. It's useful for collecting all known failures for
+ * logging or combined error handling.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const failures = internal.failures;
+/**
+ * Extracts all unrecoverable defects from a `Cause`.
+ *
+ * **Details**
+ *
+ * This function returns a chunk of values representing unexpected errors
+ * (`Die`). It's handy for capturing or logging unanticipated failures that
+ * might need special handling, such as bug reports.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const defects = internal.defects;
+/**
+ * Collects all `FiberId`s responsible for interrupting a fiber.
+ *
+ * **Details**
+ *
+ * This function returns a set of IDs indicating which fibers caused
+ * interruptions within this `Cause`. It's useful for debugging concurrency
+ * issues or tracing cancellations.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const interruptors = internal.interruptors;
+/**
+ * Retrieves the first `Fail` error in a `Cause`, if present.
+ *
+ * **Details**
+ *
+ * This function returns an `Option` containing the first recoverable error
+ * (`E`) from the cause. It's often used to quickly check if there's a primary
+ * error to handle or display.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const failureOption = internal.failureOption;
+/**
+ * Splits a `Cause` into either its first `Fail` error or the rest of the cause
+ * (which might only contain `Die` or `Interrupt`).
+ *
+ * **Details**
+ *
+ * This function either returns the checked error (`E`) or the remaining
+ * `Cause<never>` with defects/interruptions. It helps you decide if there's a
+ * recoverable path or if only unhandled issues remain.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const failureOrCause = internal.failureOrCause;
+/**
+ * Strips out failures with an error of `None` from a `Cause<Option<E>>`.
+ *
+ * **Details**
+ *
+ * This function turns a `Cause<Option<E>>` into an `Option<Cause<E>>`. If the
+ * cause only contains failures of `None`, it becomes `None`; otherwise, it
+ * returns a `Cause` of the remaining errors. It's helpful when working with
+ * optional errors and filtering out certain error paths.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const flipCauseOption = internal.flipCauseOption;
+/**
+ * Retrieves the first `Die` defect in a `Cause`, if present.
+ *
+ * **Details**
+ *
+ * This function returns an `Option` containing the first unexpected failure
+ * (`Die`) discovered. It's helpful for diagnosing the primary defect in a chain
+ * of errors.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const dieOption = internal.dieOption;
+/**
+ * Retrieves the first `Interrupt` in a `Cause`, if present.
+ *
+ * **Details**
+ *
+ * This function returns an `Option` with the first fiber interruption
+ * discovered. This is particularly useful for concurrency analysis or debugging
+ * cancellations.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const interruptOption = internal.interruptOption;
+/**
+ * Removes all `Fail` and `Interrupt` nodes, keeping only defects (`Die`) in a
+ * `Cause`.
+ *
+ * **Details**
+ *
+ * This function strips a cause of recoverable errors and interruptions, leaving
+ * only unexpected failures. If no defects remain, it returns `None`. It's
+ * valuable for focusing only on unanticipated problems when both known errors
+ * and defects could occur.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const keepDefects = internal.keepDefects;
+// TODO(4.0): remove? what's the point of this API?
+/**
+ * Linearizes a `Cause` into a set of parallel causes, each containing a
+ * sequential chain of failures.
+ *
+ * **Details**
+ *
+ * This function reorganizes the cause structure so that you can analyze each
+ * parallel branch separately, even if they have multiple sequential errors.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const linearize = internal.linearize;
+/**
+ * Removes `Fail` and `Interrupt` nodes from a `Cause`, keeping only defects
+ * (`Die`).
+ *
+ * **Details**
+ *
+ * This function is similar to `keepDefects` but returns a `Cause<never>`
+ * directly, which can still store `Die` or finalizer-related defects. It's
+ * helpful for analyzing only the irrecoverable portion of the error.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const stripFailures = internal.stripFailures;
+/**
+ * Removes matching defects from a `Cause` using a partial function, returning
+ * the remainder.
+ *
+ * **Details**
+ *
+ * This function applies a user-defined extraction function to each defect
+ * (`Die`). If the function matches the defect, that defect is removed. If all
+ * defects match, the result is `None`. Otherwise, you get a `Cause` with the
+ * unmatched defects.
+ *
+ * @since 2.0.0
+ * @category Getters
+ */
+export const stripSomeDefects = internal.stripSomeDefects;
+/**
+ * Replaces any errors in a `Cause` with a provided constant error.
+ *
+ * **Details**
+ *
+ * This function transforms all `Fail` errors into the specified error value,
+ * preserving the structure of the `Cause`. It's useful when you no longer need
+ * the original error details but still want to keep the cause shape.
+ *
+ * @see {@link map} Apply a custom transformation to `Fail` errors
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+export const as = internal.as;
+/**
+ * Transforms the errors in a `Cause` using a user-provided function.
+ *
+ * **Details**
+ *
+ * This function applies `f` to each `Fail` error while leaving defects (`Die`)
+ * and interruptions untouched. It's useful for changing or simplifying error
+ * types in your effectful workflows.
+ *
+ * @see {@link as} Replace errors with a single constant
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+export const map = internal.map;
+/**
+ * Transforms errors in a `Cause` into new causes.
+ *
+ * **Details**
+ *
+ * This function applies a function `f` to each `Fail` error, converting it into
+ * a new `Cause`. This is especially powerful for merging or restructuring error
+ * types while preserving or combining cause information.
+ *
+ * @see {@link map} Apply a simpler transformation to errors
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+export const flatMap = internal.flatMap;
+/**
+ * Sequences two `Cause`s. The second `Cause` can be dependent on the result of
+ * the first `Cause`.
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+export const andThen = internal.andThen;
+/**
+ * Flattens a nested `Cause` structure.
+ *
+ * **Details**
+ *
+ * This function takes a `Cause<Cause<E>>` and merges the layers into a single
+ * `Cause<E>`. It's useful for eliminating additional nesting created by
+ * repeated transformations or compositions.
+ *
+ * @see {@link flatMap} Compose nested causes
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+export const flatten = internal.flatten;
+/**
+ * Checks if the current `Cause` contains or is equal to another `Cause`.
+ *
+ * **Details**
+ *
+ * This function returns `true` if `that` cause is part of or the same as
+ * the current `Cause`. It's useful when you need to check for specific
+ * error patterns or deduplicate repeated failures.
+ *
+ * @since 2.0.0
+ * @category Elements
+ */
+export const contains = internal.contains;
+/**
+ * Extracts the most "important" defect from a `Cause`.
+ *
+ * **Details**
+ *
+ * This function reduces a `Cause` to a single, prioritized defect. It evaluates
+ * the `Cause` in the following order of priority:
+ *
+ * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it returns
+ *    the raw error value.
+ * 2. If there is no failure, it looks for the first defect (e.g., from
+ *    `Effect.die`).
+ * 3. If neither of the above is present, and the `Cause` stems from an
+ *    interruption, it creates and returns an `InterruptedException`.
+ *
+ * This function ensures you can always extract a meaningful representation of
+ * the primary issue from a potentially complex `Cause` structure.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to extract the most relevant error or defect
+ * from a `Cause`, especially in scenarios where multiple errors or defects may
+ * be present. It's particularly useful for simplifying error reporting or
+ * logging.
+ *
+ * @see {@link squashWith} Allows transforming failures into defects when squashing.
+ *
+ * @since 2.0.0
+ * @category Destructors
+ */
+export const squash = core.causeSquash;
+/**
+ * Extracts the most "important" defect from a `Cause`, transforming failures
+ * into defects using a provided function.
+ *
+ * **Details**
+ *
+ * This function reduces a `Cause` to a single, prioritized defect, while
+ * allowing you to transform recoverable failures into defects through a custom
+ * function. It processes the `Cause` in the following order:
+ *
+ * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it applies
+ *    the provided function `f` to the error to transform it into a defect.
+ * 2. If there is no failure, it looks for the first defect (e.g., from
+ *    `Effect.die`) and returns it.
+ * 3. If neither is present and the `Cause` stems from an interruption, it
+ *    returns an `InterruptedException`.
+ *
+ * This function is particularly useful when you need custom handling or
+ * transformation of errors while processing a `Cause`.
+ *
+ * @see {@link squash} Extracts the most "important" defect without transforming failures.
+ *
+ * @since 2.0.0
+ * @category Destructors
+ */
+export const squashWith = core.causeSquashWith;
+/**
+ * Searches a `Cause` using a partial function to extract information.
+ *
+ * **Details**
+ *
+ * This function allows you to search through a `Cause` using a custom partial
+ * function. The partial function is applied to the `Cause`, and if it matches,
+ * the result is returned wrapped in a `Some`. If no match is found, the result
+ * is `None`.
+ *
+ * This is particularly useful when you are only interested in specific types of
+ * errors, defects, or interruption causes within a potentially complex `Cause`
+ * structure. By leveraging a partial function, you can focus on extracting only
+ * the relevant information you care about.
+ *
+ * The partial function should return an `Option` indicating whether it matched
+ * and the value it extracted.
+ *
+ * @since 2.0.0
+ * @category Elements
+ */
+export const find = internal.find;
+/**
+ * Preserves parts of a `Cause` that match a given predicate.
+ *
+ * **Details**
+ *
+ * This function allows you to retain only the parts of a `Cause` structure that
+ * match a specified predicate or refinement. Any parts of the `Cause` that do
+ * not match the provided condition are excluded from the result.
+ *
+ * You can use this function in two ways:
+ * - With a `Predicate`: A function that evaluates whether a `Cause` should be
+ *   retained based on its value.
+ * - With a `Refinement`: A more specific predicate that can refine the type of
+ *   the `Cause`.
+ *
+ * This is useful when you need to extract specific types of errors, defects, or
+ * interruptions from a `Cause` while discarding unrelated parts.
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+export const filter = internal.filter;
+/**
+ * Transforms a `Cause` into a single value using custom handlers for each
+ * possible case.
+ *
+ * **Details**
+ *
+ * This function processes a `Cause` by applying a set of custom handlers to
+ * each possible type of cause: `Empty`, `Fail`, `Die`, `Interrupt`,
+ * `Sequential`, and `Parallel`. The result of this function is a single value
+ * of type `Z`. This function allows you to define exactly how to handle each
+ * part of a `Cause`, whether it's a failure, defect, interruption, or a
+ * combination of these.
+ *
+ * The options parameter provides handlers for:
+ * - `onEmpty`: Handles the case where the cause is `Empty`, meaning no errors
+ *   occurred.
+ * - `onFail`: Processes a failure with an error of type `E`.
+ * - `onDie`: Processes a defect (unexpected error).
+ * - `onInterrupt`: Handles a fiber interruption, providing the `FiberId` of the
+ *   interruption.
+ * - `onSequential`: Combines two sequential causes into a single value of type
+ *   `Z`.
+ * - `onParallel`: Combines two parallel causes into a single value of type `Z`.
+ *
+ * @since 2.0.0
+ * @category Matching
+ */
+export const match = internal.match;
+/**
+ * Combines all parts of a `Cause` into a single value by starting with an
+ * initial value.
+ *
+ * **Details**
+ *
+ * This function processes a `Cause` by starting with an initial value (`zero`)
+ * and applying a custom function (`pf`) to combine all elements of the `Cause`
+ * into a single result of type `Z`. The custom function determines how each
+ * part of the `Cause` contributes to the final result. The function can return
+ * an `Option` to either continue combining values or skip specific parts of the
+ * `Cause`.
+ *
+ * This function is useful for tasks such as:
+ * - Aggregating error messages from a `Cause` into a single string.
+ * - Summarizing the structure of a `Cause` into a simplified result.
+ * - Filtering or processing only specific parts of a `Cause`.
+ *
+ * The reduction proceeds in a top-down manner, visiting all nodes in the
+ * `Cause` structure. This gives you complete control over how each part of the
+ * `Cause` contributes to the final result.
+ *
+ * @since 2.0.0
+ * @category Reducing
+ */
+export const reduce = internal.reduce;
+/**
+ * Combines all parts of a `Cause` into a single value using a custom reducer
+ * and a context.
+ *
+ * **Details**
+ *
+ * This function allows you to reduce a `Cause` into a single value of type `Z`
+ * using a custom `CauseReducer`. A `CauseReducer` provides methods to handle
+ * specific parts of the `Cause`, such as failures, defects, or interruptions.
+ * Additionally, this function provides access to a `context` value, which can
+ * be used to carry information or maintain state during the reduction process.
+ *
+ * This is particularly useful when the reduction process needs additional
+ * context or configuration, such as:
+ * - Aggregating error details with dynamic formatting.
+ * - Collecting logs or statistics about the `Cause`.
+ * - Performing stateful transformations based on the `context`.
+ *
+ * @see {@link reduce} To reduce a `Cause` without additional context.
+ *
+ * @since 2.0.0
+ * @category Reducing
+ */
+export const reduceWithContext = internal.reduceWithContext;
+/**
+ * Creates an error that indicates a `Fiber` was interrupted.
+ *
+ * **Details**
+ *
+ * This function constructs an `InterruptedException` recognized by the Effect
+ * runtime. It is usually thrown or returned when a fiber's execution is
+ * interrupted by external events or by another fiber. This is particularly
+ * helpful in concurrent programs where fibers may halt each other before
+ * completion.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const InterruptedException = core.InterruptedException;
+/**
+ * Checks if a given unknown value is an `InterruptedException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isInterruptedException = core.isInterruptedException;
+/**
+ * Creates an error indicating an invalid method argument.
+ *
+ * **Details**
+ *
+ * This function constructs an `IllegalArgumentException`. It is typically
+ * thrown or returned when an operation receives improper inputs, such as
+ * out-of-range values or invalid object states.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const IllegalArgumentException = core.IllegalArgumentException;
+/**
+ * Checks if a given unknown value is an `IllegalArgumentException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isIllegalArgumentException = core.isIllegalArgumentException;
+/**
+ * Creates an error indicating a missing element.
+ *
+ * **Details**
+ *
+ * This function constructs a `NoSuchElementException`. It helps you clearly
+ * communicate that a required element is unavailable.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const NoSuchElementException = core.NoSuchElementException;
+/**
+ * Checks if a given unknown value is a `NoSuchElementException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isNoSuchElementException = core.isNoSuchElementException;
+/**
+ * Creates an error for general runtime errors.
+ *
+ * **Details**
+ *
+ * This function constructs a `RuntimeException`, for errors that occur at
+ * runtime but are not specifically typed or categorized as interruptions,
+ * missing elements, or invalid arguments. It helps unify a wide range of
+ * unexpected conditions under a single, recognizable error type.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const RuntimeException = core.RuntimeException;
+/**
+ * Checks if a given unknown value is a `RuntimeException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isRuntimeException = core.isRuntimeException;
+/**
+ * Creates an error for operations that exceed their expected time.
+ *
+ * **Details**
+ *
+ * This function constructs a `TimeoutException`. It is typically used to signal
+ * that an operation or fiber did not complete within a designated time limit,
+ * allowing you to handle slow or hanging processes.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const TimeoutException = core.TimeoutException;
+/**
+ * Checks if a given unknown value is a `TimeoutException`.
+ *
+ * @since 3.15.0
+ * @category Guards
+ */
+export const isTimeoutException = core.isTimeoutException;
+/**
+ * Creates an instance of `UnknownException`, an error object used to handle
+ * unknown errors such as those from rejected promises.
+ *
+ * **Details**
+ *
+ * This function constructs an `UnknownException` with flexible behavior for
+ * managing the error message and cause.
+ *
+ * The required `error` argument is passed as the `cause` to the global `Error`
+ * constructor, ensuring that the original cause is preserved in the error chain
+ * for debugging purposes. This ensures that the origin stack trace is
+ * preserved.
+ *
+ * The `error` argument is always stored in the `error` property of the
+ * `UnknownException` instance for reference, regardless of its type.
+ *
+ * Additionally, if you provide a `message` argument, it is used as the error
+ * message. If no `message` is provided, the error message defaults to `"An
+ * unknown error occurred"`.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to handle unexpected or unknown errors in
+ * your application, particularly when the source of the error might not provide
+ * a clear message. This is useful for wrapping generic errors thrown from
+ * promises or external APIs.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const UnknownException = core.UnknownException;
+/**
+ * Checks if a given unknown value is an `UnknownException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+export const isUnknownException = core.isUnknownException;
+/**
+ * Creates an error indicating resource capacity has been exceeded.
+ *
+ * **Details**
+ *
+ * This function constructs an `ExceededCapacityException`, signifying that an
+ * operation or resource usage surpassed established limits. This can be
+ * essential for concurrency or resource management situations, ensuring your
+ * application doesn't go beyond acceptable thresholds.
+ *
+ * @since 3.5.0
+ * @category Errors
+ */
+export const ExceededCapacityException = core.ExceededCapacityException;
+/**
+ * Checks if a given unknown value is an `ExceededCapacityException`.
+ *
+ * @since 3.5.0
+ * @category Guards
+ */
+export const isExceededCapacityException = core.isExceededCapacityException;
+/**
+ * Converts a `Cause` into a human-readable string.
+ *
+ * **Details**
+ *
+ * This function pretty-prints the entire `Cause`, including any failures,
+ * defects, and interruptions. It can be especially helpful for logging,
+ * debugging, or displaying structured errors to users.
+ *
+ * You can optionally pass `options` to configure how the error cause is
+ * rendered. By default, it includes essential details of all errors in the
+ * `Cause`.
+ *
+ * @see {@link prettyErrors} Get a list of `PrettyError` objects instead of a single string.
+ *
+ * @since 2.0.0
+ * @category Formatting
+ */
+export const pretty = internal.pretty;
+/**
+ * Returns a list of prettified errors (`PrettyError`) from a `Cause`.
+ *
+ * **Details**
+ *
+ * This function inspects the entire `Cause` and produces an array of
+ * `PrettyError` objects. Each object may include additional metadata, such as a
+ * `Span`, to provide deeper insights into where and how the error occurred.
+ *
+ * @since 3.2.0
+ * @category Formatting
+ */
+export const prettyErrors = internal.prettyErrors;
+/**
+ * Retrieves the original, unproxied error instance from an error object.
+ *
+ * **Details**
+ *
+ * This function returns the underlying error object without any
+ * library-specific wrapping or proxying that might occur during error handling.
+ * This can be essential if you need direct access to the error's native
+ * properties, such as stack traces or custom data fields, for detailed
+ * debugging or integration with external systems.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+export const originalError = core.originalInstance;
+//# sourceMappingURL=Cause.js.map

backend/node_modules/effect/dist/esm/Cause.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cause.js","names":["internal","core","CauseTypeId","RuntimeExceptionTypeId","InterruptedExceptionTypeId","IllegalArgumentExceptionTypeId","NoSuchElementExceptionTypeId","InvalidPubSubCapacityExceptionTypeId","ExceededCapacityExceptionTypeId","TimeoutExceptionTypeId","UnknownExceptionTypeId","YieldableError","empty","fail","die","interrupt","parallel","sequential","isCause","isEmptyType","isFailType","isDieType","isInterruptType","isSequentialType","isParallelType","size","isEmpty","isFailure","isDie","isInterrupted","isInterruptedOnly","failures","defects","interruptors","failureOption","failureOrCause","flipCauseOption","dieOption","interruptOption","keepDefects","linearize","stripFailures","stripSomeDefects","as","map","flatMap","andThen","flatten","contains","squash","causeSquash","squashWith","causeSquashWith","find","filter","match","reduce","reduceWithContext","InterruptedException","isInterruptedException","IllegalArgumentException","isIllegalArgumentException","NoSuchElementException","isNoSuchElementException","RuntimeException","isRuntimeException","TimeoutException","isTimeoutException","UnknownException","isUnknownException","ExceededCapacityException","isExceededCapacityException","pretty","prettyErrors","originalError","originalInstance"],"sources":["../../src/Cause.ts"],"sourcesContent":[null],"mappings":"AA+BA,OAAO,KAAKA,QAAQ,MAAM,qBAAqB;AAC/C,OAAO,KAAKC,IAAI,MAAM,oBAAoB;AAS1C;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,WAAW,GAAkBF,QAAQ,CAACE,WAAW;AAQ9D;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,sBAAsB,GAAkBF,IAAI,CAACE,sBAAsB;AAQhF;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,0BAA0B,GAAkBH,IAAI,CAACG,0BAA0B;AAQxF;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,8BAA8B,GAAkBJ,IAAI,CAACI,8BAA8B;AAQhG;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,4BAA4B,GAAkBL,IAAI,CAACK,4BAA4B;AAQ5F;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,oCAAoC,GAAkBN,IAAI,CAACM,oCAAoC;AAQ5G;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,+BAA+B,GAAkBP,IAAI,CAACO,+BAA+B;AAQlG;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,sBAAsB,GAAkBR,IAAI,CAACQ,sBAAsB;AAQhF;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,sBAAsB,GAAkBT,IAAI,CAACS,sBAAsB;AAuFhF;;;;;;;AAOA,OAAO,MAAMC,cAAc,GAAwDV,IAAI,CAACU,cAAc;AA4OtG;;;;;;;;;;;;;AAaA,OAAO,MAAMC,KAAK,GAAiBZ,QAAQ,CAACY,KAAK;AAEjD;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,IAAI,GAA8Bb,QAAQ,CAACa,IAAI;AAE5D;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,GAAG,GAAsCd,QAAQ,CAACc,GAAG;AAElE;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,SAAS,GAA+Cf,QAAQ,CAACe,SAAS;AAEvF;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,QAAQ,GAA+DhB,QAAQ,CAACgB,QAAQ;AAErG;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,UAAU,GAA+DjB,QAAQ,CAACiB,UAAU;AAEzG;;;;;;AAMA,OAAO,MAAMC,OAAO,GAAwClB,QAAQ,CAACkB,OAAO;AAE5E;;;;;;;;AAQA,OAAO,MAAMC,WAAW,GAAyCnB,QAAQ,CAACmB,WAAW;AAErF;;;;;;;;AAQA,OAAO,MAAMC,UAAU,GAA2CpB,QAAQ,CAACoB,UAAU;AAErF;;;;;;;;AAQA,OAAO,MAAMC,SAAS,GAAuCrB,QAAQ,CAACqB,SAAS;AAE/E;;;;;;;;AAQA,OAAO,MAAMC,eAAe,GAA6CtB,QAAQ,CAACsB,eAAe;AAEjG;;;;;;;;AAQA,OAAO,MAAMC,gBAAgB,GAAiDvB,QAAQ,CAACuB,gBAAgB;AAEvG;;;;;;;;AAQA,OAAO,MAAMC,cAAc,GAA+CxB,QAAQ,CAACwB,cAAc;AAEjG;;;;;;;;;;;AAWA,OAAO,MAAMC,IAAI,GAAkCzB,QAAQ,CAACyB,IAAI;AAEhE;;;;;;;;;;;;AAYA,OAAO,MAAMC,OAAO,GAAmC1B,QAAQ,CAAC0B,OAAO;AAEvE;;;;;;;;;;;;AAYA,OAAO,MAAMC,SAAS,GAAmC3B,QAAQ,CAAC2B,SAAS;AAE3E;;;;;;;;;;;;AAYA,OAAO,MAAMC,KAAK,GAAmC5B,QAAQ,CAAC4B,KAAK;AAEnE;;;;;;;;;;AAUA,OAAO,MAAMC,aAAa,GAAmC7B,QAAQ,CAAC6B,aAAa;AAEnF;;;;;;;;;;;;AAYA,OAAO,MAAMC,iBAAiB,GAAmC9B,QAAQ,CAAC8B,iBAAiB;AAE3F;;;;;;;;;;;;AAYA,OAAO,MAAMC,QAAQ,GAA0C/B,QAAQ,CAAC+B,QAAQ;AAEhF;;;;;;;;;;;;AAYA,OAAO,MAAMC,OAAO,GAAgDhC,QAAQ,CAACgC,OAAO;AAEpF;;;;;;;;;;;;AAYA,OAAO,MAAMC,YAAY,GAA4DjC,QAAQ,CAACiC,YAAY;AAE1G;;;;;;;;;;;;AAYA,OAAO,MAAMC,aAAa,GAA4ClC,QAAQ,CAACkC,aAAa;AAE5F;;;;;;;;;;;;;AAaA,OAAO,MAAMC,cAAc,GAA0DnC,QAAQ,CAACmC,cAAc;AAE5G;;;;;;;;;;;;;AAaA,OAAO,MAAMC,eAAe,GAAkEpC,QAAQ,CAACoC,eAAe;AAEtH;;;;;;;;;;;;AAYA,OAAO,MAAMC,SAAS,GAAkDrC,QAAQ,CAACqC,SAAS;AAE1F;;;;;;;;;;;;AAYA,OAAO,MAAMC,eAAe,GAA0DtC,QAAQ,CAACsC,eAAe;AAE9G;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,WAAW,GAAuDvC,QAAQ,CAACuC,WAAW;AAEnG;AACA;;;;;;;;;;;;AAYA,OAAO,MAAMC,SAAS,GAAqDxC,QAAQ,CAACwC,SAAS;AAE7F;;;;;;;;;;;;;AAaA,OAAO,MAAMC,aAAa,GAAwCzC,QAAQ,CAACyC,aAAa;AAExF;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,gBAAgB,GA+BzB1C,QAAQ,CAAC0C,gBAAgB;AAE7B;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,EAAE,GA+BX3C,QAAQ,CAAC2C,EAAE;AAEf;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,GAAG,GA+BZ5C,QAAQ,CAAC4C,GAAG;AAEhB;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,OAAO,GA+BhB7C,QAAQ,CAAC6C,OAAO;AAEpB;;;;;;;AAOA,OAAO,MAAMC,OAAO,GAiChB9C,QAAQ,CAAC8C,OAAO;AAEpB;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,OAAO,GAA2C/C,QAAQ,CAAC+C,OAAO;AAE/E;;;;;;;;;;;;AAYA,OAAO,MAAMC,QAAQ,GA2BjBhD,QAAQ,CAACgD,QAAQ;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMC,MAAM,GAAmChD,IAAI,CAACiD,WAAW;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,UAAU,GAqDnBlD,IAAI,CAACmD,eAAe;AAExB;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,IAAI,GA6CbrD,QAAQ,CAACqD,IAAI;AAEjB;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,MAAM,GAyFftD,QAAQ,CAACsD,MAAM;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAMC,KAAK,GA4EdvD,QAAQ,CAACuD,KAAK;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,MAAM,GAyDfxD,QAAQ,CAACwD,MAAM;AAEnB;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAMC,iBAAiB,GAiD1BzD,QAAQ,CAACyD,iBAAiB;AAE9B;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,oBAAoB,GAA8DzD,IAAI,CAACyD,oBAAoB;AAExH;;;;;;AAMA,OAAO,MAAMC,sBAAsB,GAA8C1D,IAAI,CAAC0D,sBAAsB;AAE5G;;;;;;;;;;;;AAYA,OAAO,MAAMC,wBAAwB,GACnC3D,IAAI,CAAC2D,wBAAwB;AAE/B;;;;;;AAMA,OAAO,MAAMC,0BAA0B,GAAkD5D,IAAI,CAAC4D,0BAA0B;AAExH;;;;;;;;;;;AAWA,OAAO,MAAMC,sBAAsB,GACjC7D,IAAI,CAAC6D,sBAAsB;AAE7B;;;;;;AAMA,OAAO,MAAMC,wBAAwB,GAAgD9D,IAAI,CAAC8D,wBAAwB;AAElH;;;;;;;;;;;;;AAaA,OAAO,MAAMC,gBAAgB,GAA0D/D,IAAI,CAAC+D,gBAAgB;AAE5G;;;;;;AAMA,OAAO,MAAMC,kBAAkB,GAA0ChE,IAAI,CAACgE,kBAAkB;AAEhG;;;;;;;;;;;;AAYA,OAAO,MAAMC,gBAAgB,GAA0DjE,IAAI,CAACiE,gBAAgB;AAE5G;;;;;;AAMA,OAAO,MAAMC,kBAAkB,GAA0ClE,IAAI,CAACkE,kBAAkB;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAMC,gBAAgB,GAC3BnE,IAAI,CAACmE,gBAAgB;AAEvB;;;;;;AAMA,OAAO,MAAMC,kBAAkB,GAA0CpE,IAAI,CAACoE,kBAAkB;AAEhG;;;;;;;;;;;;;AAaA,OAAO,MAAMC,yBAAyB,GACpCrE,IAAI,CAACqE,yBAAyB;AAEhC;;;;;;AAMA,OAAO,MAAMC,2BAA2B,GACtCtE,IAAI,CAACsE,2BAA2B;AAElC;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,MAAM,GAEJxE,QAAQ,CAACwE,MAAM;AAY9B;;;;;;;;;;;;AAYA,OAAO,MAAMC,YAAY,GAA+CzE,QAAQ,CAACyE,YAAY;AAE7F;;;;;;;;;;;;;;AAcA,OAAO,MAAMC,aAAa,GAAqBzE,IAAI,CAAC0E,gBAAgB","ignoreList":[]}

backend/node_modules/effect/dist/esm/Channel.js

@@ -0,0 +1,887 @@
+import * as channel from "./internal/channel.js";
+import * as core from "./internal/core-stream.js";
+import * as sink from "./internal/sink.js";
+import * as stream from "./internal/stream.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ChannelTypeId = core.ChannelTypeId;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ChannelExceptionTypeId = channel.ChannelExceptionTypeId;
+/**
+ * @since 3.5.4
+ * @category refinements
+ */
+export const isChannel = core.isChannel;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const acquireUseRelease = channel.acquireUseRelease;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const acquireReleaseOut = core.acquireReleaseOut;
+/**
+ * Returns a new channel that is the same as this one, except the terminal
+ * value of the channel is the specified constant value.
+ *
+ * This method produces the same result as mapping this channel to the
+ * specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const as = channel.as;
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+export const asVoid = channel.asVoid;
+/**
+ * Creates a channel backed by a buffer. When the buffer is empty, the channel
+ * will simply passthrough its input as output. However, when the buffer is
+ * non-empty, the value inside the buffer will be passed along as output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const buffer = channel.buffer;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const bufferChunk = channel.bufferChunk;
+/**
+ * Returns a new channel that is the same as this one, except if this channel
+ * errors for any typed error, then the returned channel will switch over to
+ * using the fallback channel returned by the specified error handler.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+export const catchAll = channel.catchAll;
+/**
+ * Returns a new channel that is the same as this one, except if this channel
+ * errors for any typed error, then the returned channel will switch over to
+ * using the fallback channel returned by the specified error handler.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+export const catchAllCause = core.catchAllCause;
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const concatAll = core.concatAll;
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const concatAllWith = core.concatAllWith;
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const concatMap = channel.concatMap;
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel. The provided merging function is used to
+ * merge the terminal values of all channels into the single terminal value of
+ * the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const concatMapWith = core.concatMapWith;
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel. The provided merging function is used to
+ * merge the terminal values of all channels into the single terminal value of
+ * the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const concatMapWithCustom = core.concatMapWithCustom;
+/**
+ * Returns a new channel, which is the same as this one, except its outputs
+ * are filtered and transformed by the specified partial function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const collect = channel.collect;
+/**
+ * Returns a new channel, which is the concatenation of all the channels that
+ * are written out by this channel. This method may only be called on channels
+ * that output other channels.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const concatOut = channel.concatOut;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's done value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInput = channel.mapInput;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's done value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInputEffect = channel.mapInputEffect;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's error value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInputError = channel.mapInputError;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's error value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInputErrorEffect = channel.mapInputErrorEffect;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's output elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInputIn = channel.mapInputIn;
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's output elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapInputInEffect = channel.mapInputInEffect;
+/**
+ * Returns a new channel, which is the same as this one, except that all the
+ * outputs are collected and bundled into a tuple together with the terminal
+ * value of this channel.
+ *
+ * As the channel returned from this channel collects all of this channel's
+ * output into an in- memory chunk, it is not safe to call this method on
+ * channels that output a large or unbounded number of values.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const doneCollect = channel.doneCollect;
+/**
+ * Returns a new channel which reads all the elements from upstream's output
+ * channel and ignores them, then terminates with the upstream result value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const drain = channel.drain;
+/**
+ * Returns a new channel which connects the given `AsyncInputProducer` as
+ * this channel's input.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const embedInput = core.embedInput;
+/**
+ * Returns a new channel that collects the output and terminal value of this
+ * channel, which it then writes as output of the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const emitCollect = channel.emitCollect;
+/**
+ * Returns a new channel with an attached finalizer. The finalizer is
+ * guaranteed to be executed so long as the channel begins execution (and
+ * regardless of whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const ensuring = channel.ensuring;
+/**
+ * Returns a new channel with an attached finalizer. The finalizer is
+ * guaranteed to be executed so long as the channel begins execution (and
+ * regardless of whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const ensuringWith = core.ensuringWith;
+/**
+ * Accesses the whole context of the channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const context = channel.context;
+/**
+ * Accesses the context of the channel with the specified function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const contextWith = channel.contextWith;
+/**
+ * Accesses the context of the channel in the context of a channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const contextWithChannel = channel.contextWithChannel;
+/**
+ * Accesses the context of the channel in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const contextWithEffect = channel.contextWithEffect;
+/**
+ * Constructs a channel that fails immediately with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fail = core.fail;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const failSync = core.failSync;
+/**
+ * Constructs a channel that fails immediately with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const failCause = core.failCause;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const failCauseSync = core.failCauseSync;
+/**
+ * Returns a new channel, which sequentially combines this channel, together
+ * with the provided factory function, which creates a second channel based on
+ * the terminal value of this channel. The result is a channel that will first
+ * perform the functions of this channel, before performing the functions of
+ * the created channel (including yielding its terminal value).
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const flatMap = core.flatMap;
+/**
+ * Returns a new channel, which flattens the terminal value of this channel.
+ * This function may only be called if the terminal value of this channel is
+ * another channel of compatible types.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const flatten = channel.flatten;
+/**
+ * Folds over the result of this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const foldChannel = channel.foldChannel;
+/**
+ * Folds over the result of this channel including any cause of termination.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const foldCauseChannel = core.foldCauseChannel;
+/**
+ * Use an effect to end a channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromEffect = core.fromEffect;
+/**
+ * Constructs a channel from an `Either`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromEither = channel.fromEither;
+/**
+ * Construct a `Channel` from an `AsyncInputConsumer`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromInput = channel.fromInput;
+/**
+ * Construct a `Channel` from a `PubSub`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromPubSub = channel.fromPubSub;
+/**
+ * Construct a `Channel` from a `PubSub` within a scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromPubSubScoped = channel.fromPubSubScoped;
+/**
+ * Construct a `Channel` from an `Option`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromOption = channel.fromOption;
+/**
+ * Construct a `Channel` from a `Queue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromQueue = channel.fromQueue;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const identity = channel.identityChannel;
+/**
+ * Returns a new channel, which is the same as this one, except it will be
+ * interrupted when the specified effect completes. If the effect completes
+ * successfully before the underlying channel is done, then the returned
+ * channel will yield the success value of the effect as its terminal value.
+ * On the other hand, if the underlying channel finishes first, then the
+ * returned channel will yield the success value of the underlying channel as
+ * its terminal value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const interruptWhen = channel.interruptWhen;
+/**
+ * Returns a new channel, which is the same as this one, except it will be
+ * interrupted when the specified deferred is completed. If the deferred is
+ * completed before the underlying channel is done, then the returned channel
+ * will yield the value of the deferred. Otherwise, if the underlying channel
+ * finishes first, then the returned channel will yield the value of the
+ * underlying channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const interruptWhenDeferred = channel.interruptWhenDeferred;
+/**
+ * Returns a new channel, which is the same as this one, except the terminal
+ * value of the returned channel is created by applying the specified function
+ * to the terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map = channel.map;
+/**
+ * Returns a new channel, which is the same as this one, except the terminal
+ * value of the returned channel is created by applying the specified
+ * effectful function to the terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapEffect = channel.mapEffect;
+/**
+ * Returns a new channel, which is the same as this one, except the failure
+ * value of the returned channel is created by applying the specified function
+ * to the failure value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapError = channel.mapError;
+/**
+ * A more powerful version of `mapError` which also surfaces the `Cause`
+ * of the channel failure.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapErrorCause = channel.mapErrorCause;
+/**
+ * Maps the output of this channel using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapOut = channel.mapOut;
+/**
+ * Creates a channel that is like this channel but the given effectful function
+ * gets applied to each emitted output element.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapOutEffect = channel.mapOutEffect;
+/**
+ * Creates a channel that is like this channel but the given Effect function gets
+ * applied to each emitted output element, taking `n` elements at once and
+ * mapping them in parallel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mapOutEffectPar = channel.mapOutEffectPar;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeAll = channel.mergeAll;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeAllUnbounded = channel.mergeAllUnbounded;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeAllUnboundedWith = channel.mergeAllUnboundedWith;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeAllWith = channel.mergeAllWith;
+/**
+ * Returns a new channel which creates a new channel for each emitted element
+ * and merges some of them together. Different merge strategies control what
+ * happens if there are more than the given maximum number of channels gets
+ * created. See `Channel.mergeAll`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const mergeMap = channel.mergeMap;
+/**
+ * Returns a new channel which merges a number of channels emitted by this
+ * channel using the back pressuring merge strategy. See `Channel.mergeAll`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeOut = channel.mergeOut;
+/**
+ * Returns a new channel which merges a number of channels emitted by this
+ * channel using the back pressuring merge strategy and uses a given function
+ * to merge each completed subchannel's result value. See
+ * `Channel.mergeAll`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeOutWith = channel.mergeOutWith;
+/**
+ * Returns a new channel, which is the merge of this channel and the specified
+ * channel, where the behavior of the returned channel on left or right early
+ * termination is decided by the specified `leftDone` and `rightDone` merge
+ * decisions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mergeWith = channel.mergeWith;
+/**
+ * Returns a channel that never completes
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const never = channel.never;
+/**
+ * Translates channel failure into death of the fiber, making all failures
+ * unchecked and not a part of the type of the channel.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+export const orDie = channel.orDie;
+/**
+ * Keeps none of the errors, and terminates the fiber with them, using the
+ * specified function to convert the `OutErr` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+export const orDieWith = channel.orDieWith;
+/**
+ * Returns a new channel that will perform the operations of this one, until
+ * failure, and then it will switch over to the operations of the specified
+ * fallback channel.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+export const orElse = channel.orElse;
+/**
+ * Returns a new channel that pipes the output of this channel into the
+ * specified channel. The returned channel has the input type of this channel,
+ * and the output type of the specified channel, terminating with the value of
+ * the specified channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const pipeTo = core.pipeTo;
+/**
+ * Returns a new channel that pipes the output of this channel into the
+ * specified channel and preserves this channel's failures without providing
+ * them to the other channel for observation.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const pipeToOrFail = channel.pipeToOrFail;
+/**
+ * Provides the channel with its required context, which eliminates its
+ * dependency on `Env`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const provideContext = core.provideContext;
+/**
+ * Provides a layer to the channel, which translates it to another level.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const provideLayer = channel.provideLayer;
+/**
+ * Transforms the context being provided to the channel with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const mapInputContext = channel.mapInputContext;
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `Env0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const provideSomeLayer = channel.provideSomeLayer;
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const provideService = channel.provideService;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const read = channel.read;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const readOrFail = core.readOrFail;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const readWith = core.readWith;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const readWithCause = core.readWithCause;
+/**
+ * Creates a channel which repeatedly runs this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const repeated = channel.repeated;
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const run = channel.run;
+/**
+ * Run the channel until it finishes with a done value or fails with an error
+ * and collects its emitted output elements.
+ *
+ * The channel must not read any input.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const runCollect = channel.runCollect;
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const runDrain = channel.runDrain;
+/**
+ * Run the channel until it finishes with a done value or fails with an error.
+ * The channel must not read any input or write any output.
+ *
+ * Closing the channel, which includes execution of all the finalizers
+ * attached to the channel will be added to the current scope as a finalizer.
+ *
+ * @since 3.11.0
+ * @category destructors
+ */
+export const runScoped = channel.runScoped;
+/**
+ * Use a scoped effect to emit an output element.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const scoped = channel.scoped;
+/**
+ * Use a function that receives a scope and returns an effect to emit an output
+ * element. The output element will be the result of the returned effect, if
+ * successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const scopedWith = channel.scopedWith;
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const splitLines = channel.splitLines;
+/**
+ * Constructs a channel that succeeds immediately with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const succeed = core.succeed;
+/**
+ * Lazily constructs a channel from the given side effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const suspend = core.suspend;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sync = core.sync;
+/**
+ * Converts a `Channel` to a `PubSub`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toPubSub = channel.toPubSub;
+/**
+ * Returns a scoped `Effect` that can be used to repeatedly pull elements from
+ * the constructed `Channel`. The pull effect fails with the channel's failure
+ * in case the channel fails, or returns either the channel's done value or an
+ * emitted element.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toPull = channel.toPull;
+/**
+ * Returns an `Effect` that can be used to repeatedly pull elements from the
+ * constructed `Channel` within the provided `Scope`. The pull effect fails
+ * with the channel's failure in case the channel fails, or returns either the
+ * channel's done value or an emitted element.
+ *
+ * @since 3.11.0
+ * @category destructors
+ */
+export const toPullIn = channel.toPullIn;
+/**
+ * Converts a `Channel` to a `Queue`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toQueue = channel.toQueue;
+/** Converts this channel to a `Sink`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toSink = sink.channelToSink;
+/**
+ * Converts this channel to a `Stream`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toStream = stream.channelToStream;
+const void_ = core.void;
+export {
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+void_ as void };
+/**
+ * Constructs a `Channel` from an effect that will result in a `Channel` if
+ * successful.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = channel.unwrap;
+/**
+ * Constructs a `Channel` from a scoped effect that will result in a
+ * `Channel` if successful.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrapScoped = channel.unwrapScoped;
+/**
+ * Constructs a `Channel` from a function which receives a `Scope` and returns
+ * an effect that will result in a `Channel` if successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const unwrapScopedWith = channel.unwrapScopedWith;
+/**
+ * Updates a service in the context of this channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+export const updateService = channel.updateService;
+/**
+ * Wraps the channel with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category tracing
+ */
+export const withSpan = channel.withSpan;
+/**
+ * Writes a single value to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const write = core.write;
+/**
+ * Writes a sequence of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const writeAll = channel.writeAll;
+/**
+ * Writes a `Chunk` of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const writeChunk = channel.writeChunk;
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with a tuple of
+ * the terminal values of both channels.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+export const zip = channel.zip;
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with the
+ * terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+export const zipLeft = channel.zipLeft;
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with the
+ * terminal value of that channel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+export const zipRight = channel.zipRight;
+/**
+ * Represents a generic checked exception which occurs when a `Channel` is
+ * executed.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+export const ChannelException = channel.ChannelException;
+/**
+ * Returns `true` if the specified value is an `ChannelException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isChannelException = channel.isChannelException;
+//# sourceMappingURL=Channel.js.map

backend/node_modules/effect/dist/esm/ChildExecutorDecision.js

@@ -0,0 +1,64 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/channel/childExecutorDecision.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ChildExecutorDecisionTypeId = internal.ChildExecutorDecisionTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Continue = internal.Continue;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Close = internal.Close;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Yield = internal.Yield;
+/**
+ * Returns `true` if the specified value is a `ChildExecutorDecision`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isChildExecutorDecision = internal.isChildExecutorDecision;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Continue`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isContinue = internal.isContinue;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Close`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isClose = internal.isClose;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Yield`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isYield = internal.isYield;
+/**
+ * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const match = internal.match;
+//# sourceMappingURL=ChildExecutorDecision.js.map

backend/node_modules/effect/dist/esm/ChildExecutorDecision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildExecutorDecision.js","names":["internal","ChildExecutorDecisionTypeId","Continue","Close","Yield","isChildExecutorDecision","isContinue","isClose","isYield","match"],"sources":["../../src/ChildExecutorDecision.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,QAAQ,MAAM,6CAA6C;AAEvE;;;;AAIA,OAAO,MAAMC,2BAA2B,GAAkBD,QAAQ,CAACC,2BAA2B;AA4D9F;;;;AAIA,OAAO,MAAMC,QAAQ,GAAuCF,QAAQ,CAACE,QAAQ;AAE7E;;;;AAIA,OAAO,MAAMC,KAAK,GAA8CH,QAAQ,CAACG,KAAK;AAE9E;;;;AAIA,OAAO,MAAMC,KAAK,GAAuCJ,QAAQ,CAACI,KAAK;AAEvE;;;;;;;AAOA,OAAO,MAAMC,uBAAuB,GAA+CL,QAAQ,CAACK,uBAAuB;AAEnH;;;;;;;AAOA,OAAO,MAAMC,UAAU,GAAsDN,QAAQ,CAACM,UAAU;AAEhG;;;;;;;AAOA,OAAO,MAAMC,OAAO,GAAmDP,QAAQ,CAACO,OAAO;AAEvF;;;;;;;AAOA,OAAO,MAAMC,OAAO,GAAmDR,QAAQ,CAACQ,OAAO;AAEvF;;;;;;AAMA,OAAO,MAAMC,KAAK,GA4BdT,QAAQ,CAACS,KAAK","ignoreList":[]}