diff --git a/backend/node_modules/effect/dist/cjs/Arbitrary.js b/backend/node_modules/effect/dist/cjs/Arbitrary.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d009c4bb6e9554f725f2d417e95829f7d7edab2
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Arbitrary.js
@@ -0,0 +1,813 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.makeStringConstraints = exports.makeNumberConstraints = exports.makeLazy = exports.makeDateConstraints = exports.makeBigIntConstraints = exports.makeArrayConstraints = exports.make = exports.getDescription = void 0;
+var Arr = _interopRequireWildcard(require("./Array.js"));
+var FastCheck = _interopRequireWildcard(require("./FastCheck.js"));
+var _GlobalValue = require("./GlobalValue.js");
+var errors_ = _interopRequireWildcard(require("./internal/schema/errors.js"));
+var schemaId_ = _interopRequireWildcard(require("./internal/schema/schemaId.js"));
+var util_ = _interopRequireWildcard(require("./internal/schema/util.js"));
+var Option = _interopRequireWildcard(require("./Option.js"));
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+var SchemaAST = _interopRequireWildcard(require("./SchemaAST.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 3.10.0
+ */
+
+/**
+ * Returns a LazyArbitrary for the `A` type of the provided schema.
+ *
+ * @category arbitrary
+ * @since 3.10.0
+ */
+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
+ */
+exports.makeLazy = makeLazy;
+const make = schema => makeLazy(schema)(FastCheck);
+/** @internal */
+exports.make = make;
+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 */
+exports.makeStringConstraints = makeStringConstraints;
+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 */
+exports.makeNumberConstraints = makeNumberConstraints;
+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 */
+exports.makeBigIntConstraints = makeBigIntConstraints;
+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 */
+exports.makeArrayConstraints = makeArrayConstraints;
+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;
+};
+exports.makeDateConstraints = makeDateConstraints;
+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__*/(0, _GlobalValue.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 */
+const getDescription = exports.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__*/(0, _GlobalValue.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
+ const schema = S.Array(
+ S.NullOr(S.suspend((): S.Schema => 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 => 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
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Array.js b/backend/node_modules/effect/dist/cjs/Array.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0d4a6bc4cc0c41a6fd0f53b02fd838b60c39e0d
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Array.js
@@ -0,0 +1,2695 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.replaceOption = exports.replace = exports.removeOption = exports.remove = exports.reduceRight = exports.reduce = exports.range = exports.prependAll = exports.prepend = exports.partitionMap = exports.partition = exports.pad = exports.of = exports.modifyOption = exports.modifyNonEmptyLast = exports.modifyNonEmptyHead = exports.modify = exports.min = exports.max = exports.matchRight = exports.matchLeft = exports.match = exports.mapAccum = exports.map = exports.makeBy = exports.make = exports.liftPredicate = exports.liftOption = exports.liftNullable = exports.liftEither = exports.let = exports.length = exports.lastNonEmpty = exports.last = exports.join = exports.isNonEmptyReadonlyArray = exports.isNonEmptyArray = exports.isEmptyReadonlyArray = exports.isEmptyArray = exports.isArray = exports.intersperse = exports.intersectionWith = exports.intersection = exports.insertAt = exports.initNonEmpty = exports.init = exports.headNonEmpty = exports.head = exports.groupWith = exports.groupBy = exports.group = exports.getSomes = exports.getRights = exports.getOrder = exports.getLefts = exports.getEquivalence = exports.get = exports.fromRecord = exports.fromOption = exports.fromNullable = exports.fromIterable = exports.forEach = exports.flatten = exports.flatMapNullable = exports.flatMap = exports.findLastIndex = exports.findLast = exports.findFirstWithIndex = exports.findFirstIndex = exports.findFirst = exports.filterMapWhile = exports.filterMap = exports.filter = exports.extend = exports.every = exports.ensure = exports.empty = exports.dropWhile = exports.dropRight = exports.drop = exports.differenceWith = exports.difference = exports.dedupeWith = exports.dedupeAdjacentWith = exports.dedupeAdjacent = exports.dedupe = exports.countBy = exports.copy = exports.containsWith = exports.contains = exports.chunksOf = exports.chop = exports.cartesianWith = exports.cartesian = exports.bindTo = exports.bind = exports.appendAll = exports.append = exports.allocate = exports.Do = void 0;
+exports.zipWith = exports.zip = exports.window = exports.unzip = exports.unsafeGet = exports.unprepend = exports.unionWith = exports.union = exports.unfold = exports.unappend = exports.takeWhile = exports.takeRight = exports.take = exports.tailNonEmpty = exports.tail = exports.splitWhere = exports.splitNonEmptyAt = exports.splitAt = exports.split = exports.span = exports.sortWith = exports.sortBy = exports.sort = exports.some = exports.setNonEmptyLast = exports.setNonEmptyHead = exports.separate = exports.scanRight = exports.scan = exports.rotate = exports.reverse = exports.replicate = void 0;
+var Either = _interopRequireWildcard(require("./Either.js"));
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var Equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var internalArray = _interopRequireWildcard(require("./internal/array.js"));
+var internalDoNotation = _interopRequireWildcard(require("./internal/doNotation.js"));
+var moduleIterable = _interopRequireWildcard(require("./Iterable.js"));
+var Option = _interopRequireWildcard(require("./Option.js"));
+var Order = _interopRequireWildcard(require("./Order.js"));
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+var Record = _interopRequireWildcard(require("./Record.js"));
+var Tuple = _interopRequireWildcard(require("./Tuple.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * This module provides utility functions for working with arrays in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * 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
+ */
+const make = (...elements) => elements;
+/**
+ * Creates a new `Array` of the specified length.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.allocate(3)
+ * console.log(result) // [ <3 empty items> ]
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.make = make;
+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
+ */
+exports.allocate = allocate;
+const makeBy = exports.makeBy = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.range = range;
+const replicate = exports.replicate = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.fromIterable = fromIterable;
+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
+ */
+exports.ensure = ensure;
+const fromRecord = exports.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
+ */
+const fromOption = exports.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
+ */
+const match = exports.match = /*#__PURE__*/(0, _Function.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
+ */
+const matchLeft = exports.matchLeft = /*#__PURE__*/(0, _Function.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
+ */
+const matchRight = exports.matchRight = /*#__PURE__*/(0, _Function.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
+ */
+const prepend = exports.prepend = /*#__PURE__*/(0, _Function.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
+ */
+const prependAll = exports.prependAll = /*#__PURE__*/(0, _Function.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
+ */
+const append = exports.append = /*#__PURE__*/(0, _Function.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
+ */
+const appendAll = exports.appendAll = /*#__PURE__*/(0, _Function.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
+ */
+const scan = exports.scan = /*#__PURE__*/(0, _Function.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
+ */
+const scanRight = exports.scanRight = /*#__PURE__*/(0, _Function.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
+ */
+const isArray = exports.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
+ */
+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
+ */
+exports.isEmptyArray = isEmptyArray;
+const isEmptyReadonlyArray = exports.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
+ */
+const isNonEmptyArray = exports.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
+ */
+const isNonEmptyReadonlyArray = exports.isNonEmptyReadonlyArray = internalArray.isNonEmptyArray;
+/**
+ * Return the number of elements in a `ReadonlyArray`.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const length = self => self.length;
+exports.length = 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
+ */
+const get = exports.get = /*#__PURE__*/(0, _Function.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
+ */
+const unsafeGet = exports.unsafeGet = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.unprepend = unprepend;
+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
+ */
+exports.unappend = unappend;
+const head = exports.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
+ */
+const headNonEmpty = exports.headNonEmpty = /*#__PURE__*/unsafeGet(0);
+/**
+ * Get the last element in a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+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
+ */
+exports.last = last;
+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
+ */
+exports.lastNonEmpty = lastNonEmpty;
+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
+ */
+exports.tail = tail;
+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
+ */
+exports.tailNonEmpty = tailNonEmpty;
+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
+ */
+exports.init = init;
+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
+ */
+exports.initNonEmpty = initNonEmpty;
+const take = exports.take = /*#__PURE__*/(0, _Function.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
+ */
+const takeRight = exports.takeRight = /*#__PURE__*/(0, _Function.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
+ */
+const takeWhile = exports.takeWhile = /*#__PURE__*/(0, _Function.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
+ */
+const span = exports.span = /*#__PURE__*/(0, _Function.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
+ */
+const drop = exports.drop = /*#__PURE__*/(0, _Function.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
+ */
+const dropRight = exports.dropRight = /*#__PURE__*/(0, _Function.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
+ */
+const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.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
+ */
+const findFirstIndex = exports.findFirstIndex = /*#__PURE__*/(0, _Function.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
+ */
+const findLastIndex = exports.findLastIndex = /*#__PURE__*/(0, _Function.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
+ */
+const findFirst = exports.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
+ */
+const findLast = exports.findLast = /*#__PURE__*/(0, _Function.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
+ */
+const findFirstWithIndex = exports.findFirstWithIndex = /*#__PURE__*/(0, _Function.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
+ */
+const countBy = exports.countBy = /*#__PURE__*/(0, _Function.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
+ */
+const insertAt = exports.insertAt = /*#__PURE__*/(0, _Function.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
+ */
+const replace = exports.replace = /*#__PURE__*/(0, _Function.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
+ */
+const replaceOption = exports.replaceOption = /*#__PURE__*/(0, _Function.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
+ */
+const modify = exports.modify = /*#__PURE__*/(0, _Function.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
+ */
+const modifyOption = exports.modifyOption = /*#__PURE__*/(0, _Function.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
+ */
+const remove = exports.remove = /*#__PURE__*/(0, _Function.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
+ */
+const removeOption = exports.removeOption = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.reverse = reverse;
+const sort = exports.sort = /*#__PURE__*/(0, _Function.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
+ */
+const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.sortBy = sortBy;
+const zip = exports.zip = /*#__PURE__*/(0, _Function.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
+ */
+const zipWith = exports.zipWith = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.unzip = unzip;
+const intersperse = exports.intersperse = /*#__PURE__*/(0, _Function.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
+ */
+const modifyNonEmptyHead = exports.modifyNonEmptyHead = /*#__PURE__*/(0, _Function.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
+ */
+const setNonEmptyHead = exports.setNonEmptyHead = /*#__PURE__*/(0, _Function.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
+ */
+const modifyNonEmptyLast = exports.modifyNonEmptyLast = /*#__PURE__*/(0, _Function.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
+ */
+const setNonEmptyLast = exports.setNonEmptyLast = /*#__PURE__*/(0, _Function.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
+ */
+const rotate = exports.rotate = /*#__PURE__*/(0, _Function.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
+ */
+const containsWith = isEquivalent => (0, _Function.dual)(2, (self, a) => {
+ for (const i of self) {
+ if (isEquivalent(a, i)) {
+ return true;
+ }
+ }
+ return false;
+});
+exports.containsWith = containsWith;
+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
+ */
+const contains = exports.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] => [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
+ */
+const chop = exports.chop = /*#__PURE__*/(0, _Function.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
+ */
+const splitAt = exports.splitAt = /*#__PURE__*/(0, _Function.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
+ */
+const splitNonEmptyAt = exports.splitNonEmptyAt = /*#__PURE__*/(0, _Function.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
+ */
+const split = exports.split = /*#__PURE__*/(0, _Function.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
+ */
+const splitWhere = exports.splitWhere = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.copy = copy;
+const pad = exports.pad = /*#__PURE__*/(0, _Function.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
+ */
+const chunksOf = exports.chunksOf = /*#__PURE__*/(0, _Function.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
+ */
+const window = exports.window = /*#__PURE__*/(0, _Function.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
+ */
+const groupWith = exports.groupWith = /*#__PURE__*/(0, _Function.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
+ */
+const group = exports.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
+ */
+const groupBy = exports.groupBy = /*#__PURE__*/(0, _Function.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
+ */
+const unionWith = exports.unionWith = /*#__PURE__*/(0, _Function.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
+ */
+const union = exports.union = /*#__PURE__*/(0, _Function.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
+ */
+const intersectionWith = isEquivalent => {
+ const has = containsWith(isEquivalent);
+ return (0, _Function.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
+ */
+exports.intersectionWith = intersectionWith;
+const intersection = exports.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((a, b) => a === b)(array1, array2)
+ * console.log(difference) // [1]
+ * ```
+ *
+ * @since 2.0.0
+ */
+const differenceWith = isEquivalent => {
+ const has = containsWith(isEquivalent);
+ return (0, _Function.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
+ */
+exports.differenceWith = differenceWith;
+const difference = exports.difference = /*#__PURE__*/differenceWith(_equivalence);
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+const empty = () => [];
+/**
+ * Constructs a new `NonEmptyArray` from the specified value.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.empty = empty;
+const of = a => [a];
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+exports.of = of;
+const map = exports.map = /*#__PURE__*/(0, _Function.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
+ */
+const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.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
+ */
+const flatten = exports.flatten = /*#__PURE__*/flatMap(_Function.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
+ */
+const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.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
+ */
+const filterMapWhile = exports.filterMapWhile = /*#__PURE__*/(0, _Function.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
+ */
+const partitionMap = exports.partitionMap = /*#__PURE__*/(0, _Function.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
+ */
+const getSomes = exports.getSomes = /*#__PURE__*/filterMap(_Function.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
+ */
+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
+ */
+exports.getLefts = getLefts;
+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
+ */
+exports.getRights = getRights;
+const filter = exports.filter = /*#__PURE__*/(0, _Function.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
+ */
+const partition = exports.partition = /*#__PURE__*/(0, _Function.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
+ */
+const separate = exports.separate = /*#__PURE__*/partitionMap(_Function.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
+ */
+const reduce = exports.reduce = /*#__PURE__*/(0, _Function.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
+ */
+const reduceRight = exports.reduceRight = /*#__PURE__*/(0, _Function.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
+ */
+const liftPredicate = predicate => b => predicate(b) ? [b] : [];
+/**
+ * @category lifting
+ * @since 2.0.0
+ */
+exports.liftPredicate = liftPredicate;
+const liftOption = f => (...a) => fromOption(f(...a));
+/**
+ * @category conversions
+ * @since 2.0.0
+ */
+exports.liftOption = liftOption;
+const fromNullable = a => a == null ? empty() : [a];
+/**
+ * @category lifting
+ * @since 2.0.0
+ */
+exports.fromNullable = fromNullable;
+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
+ */
+exports.liftNullable = liftNullable;
+const flatMapNullable = exports.flatMapNullable = /*#__PURE__*/(0, _Function.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 =>
+ * 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
+ */
+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
+ */
+exports.liftEither = liftEither;
+const every = exports.every = /*#__PURE__*/(0, _Function.dual)(2, (self, refinement) => self.every(refinement));
+/**
+ * Check if a predicate holds true for some `ReadonlyArray` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const some = exports.some = /*#__PURE__*/(0, _Function.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
+ */
+const extend = exports.extend = /*#__PURE__*/(0, _Function.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
+ */
+const min = exports.min = /*#__PURE__*/(0, _Function.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
+ */
+const max = exports.max = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => self.reduce(Order.max(O)));
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+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
+ */
+exports.unfold = unfold;
+const getOrder = exports.getOrder = Order.array;
+/**
+ * Creates an equivalence relation for arrays.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const eq = Array.getEquivalence((a, b) => a === b)
+ * console.log(eq([1, 2, 3], [1, 2, 3])) // true
+ * ```
+ *
+ * @category instances
+ * @since 2.0.0
+ */
+const getEquivalence = exports.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
+ */
+const forEach = exports.forEach = /*#__PURE__*/(0, _Function.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
+ */
+const dedupeWith = exports.dedupeWith = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.dedupe = dedupe;
+const dedupeAdjacentWith = exports.dedupeAdjacentWith = /*#__PURE__*/(0, _Function.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
+ */
+const dedupeAdjacent = exports.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
+ */
+const join = exports.join = /*#__PURE__*/(0, _Function.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
+ */
+const mapAccum = exports.mapAccum = /*#__PURE__*/(0, _Function.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
+ */
+const cartesianWith = exports.cartesianWith = /*#__PURE__*/(0, _Function.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
+ */
+const cartesian = exports.cartesian = /*#__PURE__*/(0, _Function.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
+ */
+const Do = exports.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
+ */
+const bind = exports.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
+ */
+const bindTo = exports.bindTo = /*#__PURE__*/internalDoNotation.bindTo(map);
+const let_ = exports.let = /*#__PURE__*/internalDoNotation.let_(map);
+//# sourceMappingURL=Array.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/BigDecimal.js b/backend/node_modules/effect/dist/cjs/BigDecimal.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6e0d8b3f7a8d0d34e8c22a91695a9f688773d63
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/BigDecimal.js
@@ -0,0 +1,1116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeToNumber = exports.unsafeRemainder = exports.unsafeMakeNormalized = exports.unsafeFromString = exports.unsafeFromNumber = exports.unsafeDivide = exports.truncate = exports.toExponential = exports.sumAll = exports.sum = exports.subtract = exports.sign = exports.scale = exports.safeFromNumber = exports.roundTerminal = exports.round = exports.remainder = exports.normalize = exports.negate = exports.multiply = exports.min = exports.max = exports.make = exports.lessThanOrEqualTo = exports.lessThan = exports.isZero = exports.isPositive = exports.isNegative = exports.isInteger = exports.isBigDecimal = exports.greaterThanOrEqualTo = exports.greaterThan = exports.fromString = exports.fromNumber = exports.fromBigInt = exports.format = exports.floor = exports.equals = exports.divide = exports.digitAt = exports.clamp = exports.ceil = exports.between = exports.abs = exports.TypeId = exports.Order = exports.Equivalence = void 0;
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Inspectable = require("./Inspectable.js");
+var Option = _interopRequireWildcard(require("./Option.js"));
+var order = _interopRequireWildcard(require("./Order.js"));
+var _Pipeable = require("./Pipeable.js");
+var _Predicate = require("./Predicate.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
+ *
+ * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
+ * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
+ *
+ * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
+ * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 263 decimal places.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
+ * may be unexpected.
+ *
+ * @module BigDecimal
+ * @since 2.0.0
+ * @see {@link module:BigInt} for more similar operations on `bigint` types
+ * @see {@link module:Number} for more similar operations on `number` types
+ */
+
+const DEFAULT_PRECISION = 100;
+const FINITE_INT_REGEX = /^[+-]?\d+$/;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/BigDecimal");
+const BigDecimalProto = {
+ [TypeId]: TypeId,
+ [Hash.symbol]() {
+ const normalized = normalize(this);
+ return (0, _Function.pipe)(Hash.hash(normalized.value), Hash.combine(Hash.number(normalized.scale)), Hash.cached(this));
+ },
+ [Equal.symbol](that) {
+ return isBigDecimal(that) && equals(this, that);
+ },
+ toString() {
+ return `BigDecimal(${format(this)})`;
+ },
+ toJSON() {
+ return {
+ _id: "BigDecimal",
+ value: String(this.value),
+ scale: this.scale
+ };
+ },
+ [_Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+/**
+ * Checks if a given value is a `BigDecimal`.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+const isBigDecimal = u => (0, _Predicate.hasProperty)(u, TypeId);
+/**
+ * Creates a `BigDecimal` from a `bigint` value and a scale.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.isBigDecimal = isBigDecimal;
+const make = (value, scale) => {
+ const o = Object.create(BigDecimalProto);
+ o.value = value;
+ o.scale = scale;
+ return o;
+};
+/**
+ * Internal function used to create pre-normalized `BigDecimal`s.
+ *
+ * @internal
+ */
+exports.make = make;
+const unsafeMakeNormalized = (value, scale) => {
+ if (value !== bigint0 && value % bigint10 === bigint0) {
+ throw new RangeError("Value must be normalized");
+ }
+ const o = make(value, scale);
+ o.normalized = o;
+ return o;
+};
+exports.unsafeMakeNormalized = unsafeMakeNormalized;
+const bigint0 = /*#__PURE__*/BigInt(0);
+const bigint1 = /*#__PURE__*/BigInt(1);
+const bigint10 = /*#__PURE__*/BigInt(10);
+const zero = /*#__PURE__*/unsafeMakeNormalized(bigint0, 0);
+/**
+ * Normalizes a given `BigDecimal` by removing trailing zeros.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { normalize, make, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(normalize(unsafeFromString("123.00000")), normalize(make(123n, 0)))
+ * assert.deepStrictEqual(normalize(unsafeFromString("12300000")), normalize(make(123n, -5)))
+ * ```
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+const normalize = self => {
+ if (self.normalized === undefined) {
+ if (self.value === bigint0) {
+ self.normalized = zero;
+ } else {
+ const digits = `${self.value}`;
+ let trail = 0;
+ for (let i = digits.length - 1; i >= 0; i--) {
+ if (digits[i] === "0") {
+ trail++;
+ } else {
+ break;
+ }
+ }
+ if (trail === 0) {
+ self.normalized = self;
+ }
+ const value = BigInt(digits.substring(0, digits.length - trail));
+ const scale = self.scale - trail;
+ self.normalized = unsafeMakeNormalized(value, scale);
+ }
+ }
+ return self.normalized;
+};
+/**
+ * Scales a given `BigDecimal` to the specified scale.
+ *
+ * If the given scale is smaller than the current scale, the value will be rounded down to
+ * the nearest integer.
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+exports.normalize = normalize;
+const scale = exports.scale = /*#__PURE__*/(0, _Function.dual)(2, (self, scale) => {
+ if (scale > self.scale) {
+ return make(self.value * bigint10 ** BigInt(scale - self.scale), scale);
+ }
+ if (scale < self.scale) {
+ return make(self.value / bigint10 ** BigInt(self.scale - scale), scale);
+ }
+ return self;
+});
+/**
+ * Provides an addition operation on `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sum, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const sum = exports.sum = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (that.value === bigint0) {
+ return self;
+ }
+ if (self.value === bigint0) {
+ return that;
+ }
+ if (self.scale > that.scale) {
+ return make(scale(that, self.scale).value + self.value, self.scale);
+ }
+ if (self.scale < that.scale) {
+ return make(scale(self, that.scale).value + that.value, that.scale);
+ }
+ return make(self.value + that.value, self.scale);
+});
+/**
+ * Provides a multiplication operation on `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { multiply, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const multiply = exports.multiply = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (that.value === bigint0 || self.value === bigint0) {
+ return zero;
+ }
+ return make(self.value * that.value, self.scale + that.scale);
+});
+/**
+ * Provides a subtraction operation on `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { subtract, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const subtract = exports.subtract = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (that.value === bigint0) {
+ return self;
+ }
+ if (self.value === bigint0) {
+ return make(-that.value, that.scale);
+ }
+ if (self.scale > that.scale) {
+ return make(self.value - scale(that, self.scale).value, self.scale);
+ }
+ if (self.scale < that.scale) {
+ return make(scale(self, that.scale).value - that.value, that.scale);
+ }
+ return make(self.value - that.value, self.scale);
+});
+/**
+ * Internal function used for arbitrary precision division.
+ */
+const divideWithPrecision = (num, den, scale, precision) => {
+ const numNegative = num < bigint0;
+ const denNegative = den < bigint0;
+ const negateResult = numNegative !== denNegative;
+ num = numNegative ? -num : num;
+ den = denNegative ? -den : den;
+ // Shift digits until numerator is larger than denominator (set scale appropriately).
+ while (num < den) {
+ num *= bigint10;
+ scale++;
+ }
+ // First division.
+ let quotient = num / den;
+ let remainder = num % den;
+ if (remainder === bigint0) {
+ // No remainder, return immediately.
+ return make(negateResult ? -quotient : quotient, scale);
+ }
+ // The quotient is guaranteed to be non-negative at this point. No need to consider sign.
+ let count = `${quotient}`.length;
+ // Shift the remainder by 1 decimal; The quotient will be 1 digit upon next division.
+ remainder *= bigint10;
+ while (remainder !== bigint0 && count < precision) {
+ const q = remainder / den;
+ const r = remainder % den;
+ quotient = quotient * bigint10 + q;
+ remainder = r * bigint10;
+ count++;
+ scale++;
+ }
+ if (remainder !== bigint0) {
+ // Round final number with remainder.
+ quotient += roundTerminal(remainder / den);
+ }
+ return make(negateResult ? -quotient : quotient, scale);
+};
+/**
+ * Internal function used for rounding.
+ *
+ * Returns 1 if the most significant digit is >= 5, otherwise 0.
+ *
+ * This is used after dividing a number by a power of ten and rounding the last digit.
+ *
+ * @internal
+ */
+const roundTerminal = n => {
+ const pos = n >= bigint0 ? 0 : 1;
+ return Number(`${n}`[pos]) < 5 ? bigint0 : bigint1;
+};
+/**
+ * Provides a division operation on `BigDecimal`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * If the divisor is `0`, the result will be `None`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("3")), Option.some(BigDecimal.unsafeFromString("2")))
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("4")), Option.some(BigDecimal.unsafeFromString("1.5")))
+ * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("0")), Option.none())
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+exports.roundTerminal = roundTerminal;
+const divide = exports.divide = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (that.value === bigint0) {
+ return Option.none();
+ }
+ if (self.value === bigint0) {
+ return Option.some(zero);
+ }
+ const scale = self.scale - that.scale;
+ if (self.value === that.value) {
+ return Option.some(make(bigint1, scale));
+ }
+ return Option.some(divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION));
+});
+/**
+ * Provides an unsafe division operation on `BigDecimal`s.
+ *
+ * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
+ * which represents the integer division rounded down to the nearest integer.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2"))
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const unsafeDivide = exports.unsafeDivide = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (that.value === bigint0) {
+ throw new RangeError("Division by zero");
+ }
+ if (self.value === bigint0) {
+ return zero;
+ }
+ const scale = self.scale - that.scale;
+ if (self.value === that.value) {
+ return make(bigint1, scale);
+ }
+ return divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION);
+});
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+const Order = exports.Order = /*#__PURE__*/order.make((self, that) => {
+ const scmp = order.number(sign(self), sign(that));
+ if (scmp !== 0) {
+ return scmp;
+ }
+ if (self.scale > that.scale) {
+ return order.bigint(self.value, scale(that, self.scale).value);
+ }
+ if (self.scale < that.scale) {
+ return order.bigint(scale(self, that.scale).value, that.value);
+ }
+ return order.bigint(self.value, that.value);
+});
+/**
+ * Returns `true` if the first argument is less than the second, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThan, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThan = exports.lessThan = /*#__PURE__*/order.lessThan(Order);
+/**
+ * Checks if a given `BigDecimal` is less than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThanOrEqualTo = exports.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, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThan = exports.greaterThan = /*#__PURE__*/order.greaterThan(Order);
+/**
+ * Checks if a given `BigDecimal` is greater than or equal to the provided one.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThanOrEqualTo = exports.greaterThanOrEqualTo = /*#__PURE__*/order.greaterThanOrEqualTo(Order);
+/**
+ * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal } from "effect"
+ *
+ * const between = BigDecimal.between({
+ * minimum: BigDecimal.unsafeFromString("1"),
+ * maximum: BigDecimal.unsafeFromString("5") }
+ * )
+ *
+ * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("3")), true)
+ * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("0")), false)
+ * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("6")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const between = exports.between = /*#__PURE__*/order.between(Order);
+/**
+ * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
+ *
+ * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value.
+ * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value.
+ * - Otherwise, it returns the original `BigDecimal`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal } from "effect"
+ *
+ * const clamp = BigDecimal.clamp({
+ * minimum: BigDecimal.unsafeFromString("1"),
+ * maximum: BigDecimal.unsafeFromString("5") }
+ * )
+ *
+ * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("3")), BigDecimal.unsafeFromString("3"))
+ * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("0")), BigDecimal.unsafeFromString("1"))
+ * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("6")), BigDecimal.unsafeFromString("5"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const clamp = exports.clamp = /*#__PURE__*/order.clamp(Order);
+/**
+ * Returns the minimum between two `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { min, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const min = exports.min = /*#__PURE__*/order.min(Order);
+/**
+ * Returns the maximum between two `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { max, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const max = exports.max = /*#__PURE__*/order.max(Order);
+/**
+ * Determines the sign of a given `BigDecimal`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { sign, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sign(unsafeFromString("-5")), -1)
+ * assert.deepStrictEqual(sign(unsafeFromString("0")), 0)
+ * assert.deepStrictEqual(sign(unsafeFromString("5")), 1)
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const sign = n => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;
+/**
+ * Determines the absolute value of a given `BigDecimal`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { abs, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(abs(unsafeFromString("-5")), unsafeFromString("5"))
+ * assert.deepStrictEqual(abs(unsafeFromString("0")), unsafeFromString("0"))
+ * assert.deepStrictEqual(abs(unsafeFromString("5")), unsafeFromString("5"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+exports.sign = sign;
+const abs = n => n.value < bigint0 ? make(-n.value, n.scale) : n;
+/**
+ * Provides a negate operation on `BigDecimal`s.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { negate, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(negate(unsafeFromString("3")), unsafeFromString("-3"))
+ * assert.deepStrictEqual(negate(unsafeFromString("-6")), unsafeFromString("6"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+exports.abs = abs;
+const negate = n => make(-n.value, n.scale);
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * If the divisor is `0`, the result will be `None`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("2"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0")))
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("3"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("1")))
+ * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("-4"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0")))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+exports.negate = negate;
+const remainder = exports.remainder = /*#__PURE__*/(0, _Function.dual)(2, (self, divisor) => {
+ if (divisor.value === bigint0) {
+ return Option.none();
+ }
+ const max = Math.max(self.scale, divisor.scale);
+ return Option.some(make(scale(self, max).value % scale(divisor, max).value, max));
+});
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category math
+ */
+const unsafeRemainder = exports.unsafeRemainder = /*#__PURE__*/(0, _Function.dual)(2, (self, divisor) => {
+ if (divisor.value === bigint0) {
+ throw new RangeError("Division by zero");
+ }
+ const max = Math.max(self.scale, divisor.scale);
+ return make(scale(self, max).value % scale(divisor, max).value, max);
+});
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Equivalence = exports.Equivalence = /*#__PURE__*/equivalence.make((self, that) => {
+ if (self.scale > that.scale) {
+ return scale(that, self.scale).value === self.value;
+ }
+ if (self.scale < that.scale) {
+ return scale(self, that.scale).value === that.value;
+ }
+ return self.value === that.value;
+});
+/**
+ * Checks if two `BigDecimal`s are equal.
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const equals = exports.equals = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => Equivalence(self, that));
+/**
+ * Creates a `BigDecimal` from a `bigint` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromBigInt = n => make(n, 0);
+/**
+ * Creates a `BigDecimal` from a `number` value.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly,
+ * as the floating point representation may be unexpected.
+ *
+ * Throws a `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`).
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeFromNumber, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeFromNumber(123), make(123n, 0))
+ * assert.deepStrictEqual(unsafeFromNumber(123.456), make(123456n, 3))
+ * ```
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+exports.fromBigInt = fromBigInt;
+const unsafeFromNumber = n => Option.getOrThrowWith(safeFromNumber(n), () => new RangeError(`Number must be finite, got ${n}`));
+/**
+ * Creates a `BigDecimal` from a `number` value.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly,
+ * as the floating point representation may be unexpected.
+ *
+ * Throws a `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`).
+ *
+ * @since 2.0.0
+ * @category constructors
+ * @deprecated Use {@link unsafeFromNumber} instead.
+ */
+exports.unsafeFromNumber = unsafeFromNumber;
+const fromNumber = exports.fromNumber = unsafeFromNumber;
+// TODO(4.0): Rename this to `fromNumber` after removing the current, unsafe implementation of `fromNumber`.
+/**
+ * Creates a `BigDecimal` from a `number` value.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly,
+ * as the floating point representation may be unexpected.
+ *
+ * Returns `None` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`).
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigDecimal.safeFromNumber(123), Option.some(BigDecimal.make(123n, 0)))
+ * assert.deepStrictEqual(BigDecimal.safeFromNumber(123.456), Option.some(BigDecimal.make(123456n, 3)))
+ * assert.deepStrictEqual(BigDecimal.safeFromNumber(Infinity), Option.none())
+ * ```
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+const safeFromNumber = n => {
+ if (!Number.isFinite(n)) {
+ return Option.none();
+ }
+ const string = `${n}`;
+ if (string.includes("e")) {
+ return fromString(string);
+ }
+ const [lead, trail = ""] = string.split(".");
+ return Option.some(make(BigInt(`${lead}${trail}`), trail.length));
+};
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { BigDecimal, Option } from "effect"
+ *
+ * assert.deepStrictEqual(BigDecimal.fromString("123"), Option.some(BigDecimal.make(123n, 0)))
+ * assert.deepStrictEqual(BigDecimal.fromString("123.456"), Option.some(BigDecimal.make(123456n, 3)))
+ * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), Option.none())
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.safeFromNumber = safeFromNumber;
+const fromString = s => {
+ if (s === "") {
+ return Option.some(zero);
+ }
+ let base;
+ let exp;
+ const seperator = s.search(/[eE]/);
+ if (seperator !== -1) {
+ const trail = s.slice(seperator + 1);
+ base = s.slice(0, seperator);
+ exp = Number(trail);
+ if (base === "" || !Number.isSafeInteger(exp) || !FINITE_INT_REGEX.test(trail)) {
+ return Option.none();
+ }
+ } else {
+ base = s;
+ exp = 0;
+ }
+ let digits;
+ let offset;
+ const dot = base.search(/\./);
+ if (dot !== -1) {
+ const lead = base.slice(0, dot);
+ const trail = base.slice(dot + 1);
+ digits = `${lead}${trail}`;
+ offset = trail.length;
+ } else {
+ digits = base;
+ offset = 0;
+ }
+ if (!FINITE_INT_REGEX.test(digits)) {
+ return Option.none();
+ }
+ const scale = offset - exp;
+ if (!Number.isSafeInteger(scale)) {
+ return Option.none();
+ }
+ return Option.some(make(BigInt(digits), scale));
+};
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeFromString, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeFromString("123"), make(123n, 0))
+ * assert.deepStrictEqual(unsafeFromString("123.456"), make(123456n, 3))
+ * assert.throws(() => unsafeFromString("123.abc"))
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.fromString = fromString;
+const unsafeFromString = s => Option.getOrThrowWith(fromString(s), () => new Error("Invalid numerical string"));
+/**
+ * Formats a given `BigDecimal` as a `string`.
+ *
+ * If the scale of the `BigDecimal` is greater than or equal to 16, the `BigDecimal` will
+ * be formatted in scientific notation.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { format, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(format(unsafeFromString("-5")), "-5")
+ * assert.deepStrictEqual(format(unsafeFromString("123.456")), "123.456")
+ * assert.deepStrictEqual(format(unsafeFromString("-0.00000123")), "-0.00000123")
+ * ```
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+exports.unsafeFromString = unsafeFromString;
+const format = n => {
+ const normalized = normalize(n);
+ if (Math.abs(normalized.scale) >= 16) {
+ return toExponential(normalized);
+ }
+ const negative = normalized.value < bigint0;
+ const absolute = negative ? `${normalized.value}`.substring(1) : `${normalized.value}`;
+ let before;
+ let after;
+ if (normalized.scale >= absolute.length) {
+ before = "0";
+ after = "0".repeat(normalized.scale - absolute.length) + absolute;
+ } else {
+ const location = absolute.length - normalized.scale;
+ if (location > absolute.length) {
+ const zeros = location - absolute.length;
+ before = `${absolute}${"0".repeat(zeros)}`;
+ after = "";
+ } else {
+ after = absolute.slice(location);
+ before = absolute.slice(0, location);
+ }
+ }
+ const complete = after === "" ? before : `${before}.${after}`;
+ return negative ? `-${complete}` : complete;
+};
+/**
+ * Formats a given `BigDecimal` as a `string` in scientific notation.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { toExponential, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(toExponential(make(123456n, -5)), "1.23456e+10")
+ * ```
+ *
+ * @since 3.11.0
+ * @category conversions
+ */
+exports.format = format;
+const toExponential = n => {
+ if (isZero(n)) {
+ return "0e+0";
+ }
+ const normalized = normalize(n);
+ const digits = `${abs(normalized).value}`;
+ const head = digits.slice(0, 1);
+ const tail = digits.slice(1);
+ let output = `${isNegative(normalized) ? "-" : ""}${head}`;
+ if (tail !== "") {
+ output += `.${tail}`;
+ }
+ const exp = tail.length - normalized.scale;
+ return `${output}e${exp >= 0 ? "+" : ""}${exp}`;
+};
+/**
+ * Converts a `BigDecimal` to a `number`.
+ *
+ * This function will produce incorrect results if the `BigDecimal` exceeds the 64-bit range of a `number`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeToNumber, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeToNumber(unsafeFromString("123.456")), 123.456)
+ * ```
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+exports.toExponential = toExponential;
+const unsafeToNumber = n => Number(format(n));
+/**
+ * Checks if a given `BigDecimal` is an integer.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isInteger, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isInteger(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1.1")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+exports.unsafeToNumber = unsafeToNumber;
+const isInteger = n => normalize(n).scale <= 0;
+/**
+ * Checks if a given `BigDecimal` is `0`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isZero, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isZero(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isZero(unsafeFromString("1")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+exports.isInteger = isInteger;
+const isZero = n => n.value === bigint0;
+/**
+ * Checks if a given `BigDecimal` is negative.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isNegative, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isNegative(unsafeFromString("-1")), true)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("1")), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+exports.isZero = isZero;
+const isNegative = n => n.value < bigint0;
+/**
+ * Checks if a given `BigDecimal` is positive.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isPositive, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isPositive(unsafeFromString("-1")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("1")), true)
+ * ```
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+exports.isNegative = isNegative;
+const isPositive = n => n.value > bigint0;
+exports.isPositive = isPositive;
+const isBigDecimalArgs = args => isBigDecimal(args[0]);
+/**
+ * Calculate the ceiling of a `BigDecimal` at the given scale.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { ceil, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150"))
+ * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+const ceil = exports.ceil = /*#__PURE__*/(0, _Function.dual)(isBigDecimalArgs, (self, scale = 0) => {
+ const truncated = truncate(self, scale);
+ if (isPositive(self) && lessThan(truncated, self)) {
+ return sum(truncated, make(1n, scale));
+ }
+ return truncated;
+});
+/**
+ * Calculate the floor of a `BigDecimal` at the given scale.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { floor, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140"))
+ * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+const floor = exports.floor = /*#__PURE__*/(0, _Function.dual)(isBigDecimalArgs, (self, scale = 0) => {
+ const truncated = truncate(self, scale);
+ if (isNegative(self) && greaterThan(truncated, self)) {
+ return sum(truncated, make(-1n, scale));
+ }
+ return truncated;
+});
+/**
+ * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { truncate, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140"))
+ * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+const truncate = exports.truncate = /*#__PURE__*/(0, _Function.dual)(isBigDecimalArgs, (self, scale = 0) => {
+ if (self.scale <= scale) {
+ return self;
+ }
+ // BigInt division truncates towards zero
+ return make(self.value / 10n ** BigInt(self.scale - scale), scale);
+});
+/**
+ * Internal function used by `round` for `half-even` and `half-odd` rounding modes.
+ *
+ * Returns the digit at the position of the given `scale` within the `BigDecimal`.
+ *
+ * @internal
+ */
+const digitAt = exports.digitAt = /*#__PURE__*/(0, _Function.dual)(2, (self, scale) => {
+ if (self.scale < scale) {
+ return 0n;
+ }
+ const scaled = self.value / 10n ** BigInt(self.scale - scale);
+ return scaled % 10n;
+});
+/**
+ * Rounds a `BigDecimal` at the given scale with the specified rounding mode.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { round, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150"))
+ * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+const round = exports.round = /*#__PURE__*/(0, _Function.dual)(isBigDecimalArgs, (self, options) => {
+ const mode = options?.mode ?? "half-from-zero";
+ const scale = options?.scale ?? 0;
+ switch (mode) {
+ case "ceil":
+ return ceil(self, scale);
+ case "floor":
+ return floor(self, scale);
+ case "to-zero":
+ return truncate(self, scale);
+ case "from-zero":
+ return isPositive(self) ? ceil(self, scale) : floor(self, scale);
+ case "half-ceil":
+ return floor(sum(self, make(5n, scale + 1)), scale);
+ case "half-floor":
+ return ceil(sum(self, make(-5n, scale + 1)), scale);
+ case "half-to-zero":
+ return isNegative(self) ? floor(sum(self, make(5n, scale + 1)), scale) : ceil(sum(self, make(-5n, scale + 1)), scale);
+ case "half-from-zero":
+ return isNegative(self) ? ceil(sum(self, make(-5n, scale + 1)), scale) : floor(sum(self, make(5n, scale + 1)), scale);
+ }
+ const halfCeil = floor(sum(self, make(5n, scale + 1)), scale);
+ const halfFloor = ceil(sum(self, make(-5n, scale + 1)), scale);
+ const digit = digitAt(halfCeil, scale);
+ switch (mode) {
+ case "half-even":
+ return equals(halfCeil, halfFloor) ? halfCeil : digit % 2n === 0n ? halfCeil : halfFloor;
+ case "half-odd":
+ return equals(halfCeil, halfFloor) ? halfCeil : digit % 2n === 0n ? halfFloor : halfCeil;
+ }
+});
+/**
+ * Takes an `Iterable` of `BigDecimal`s and returns their sum as a single `BigDecimal`
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeFromString, sumAll } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sumAll([unsafeFromString("2"), unsafeFromString("3"), unsafeFromString("4")]), unsafeFromString("9"))
+ * ```
+ *
+ * @category math
+ * @since 3.16.0
+ */
+const sumAll = collection => {
+ let out = zero;
+ for (const n of collection) {
+ out = sum(out, n);
+ }
+ return out;
+};
+exports.sumAll = sumAll;
+//# sourceMappingURL=BigDecimal.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/BigDecimal.js.map b/backend/node_modules/effect/dist/cjs/BigDecimal.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..db821eb28acd38a6562386eb97b37d01b3920447
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/BigDecimal.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"BigDecimal.js","names":["Equal","_interopRequireWildcard","require","equivalence","_Function","Hash","_Inspectable","Option","order","_Pipeable","_Predicate","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","DEFAULT_PRECISION","FINITE_INT_REGEX","TypeId","exports","Symbol","for","BigDecimalProto","symbol","normalized","normalize","pipe","hash","value","combine","number","scale","cached","that","isBigDecimal","equals","toString","format","toJSON","_id","String","NodeInspectSymbol","pipeArguments","arguments","u","hasProperty","make","create","unsafeMakeNormalized","bigint0","bigint10","RangeError","BigInt","bigint1","zero","self","undefined","digits","trail","length","substring","dual","sum","multiply","subtract","divideWithPrecision","num","den","precision","numNegative","denNegative","negateResult","quotient","remainder","count","q","roundTerminal","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":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/BigInt.js b/backend/node_modules/effect/dist/cjs/BigInt.js
new file mode 100644
index 0000000000000000000000000000000000000000..d32b5dffaa9c61da9fc8704f3b45f6221dd582e4
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/BigInt.js
@@ -0,0 +1,567 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeSqrt = exports.unsafeDivide = exports.toNumber = exports.sumAll = exports.sum = exports.subtract = exports.sqrt = exports.sign = exports.multiplyAll = exports.multiply = exports.min = exports.max = exports.lessThanOrEqualTo = exports.lessThan = exports.lcm = exports.isBigInt = exports.increment = exports.greaterThanOrEqualTo = exports.greaterThan = exports.gcd = exports.fromString = exports.fromNumber = exports.divide = exports.decrement = exports.clamp = exports.between = exports.abs = exports.Order = exports.Equivalence = void 0;
+var equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var Option = _interopRequireWildcard(require("./Option.js"));
+var order = _interopRequireWildcard(require("./Order.js"));
+var predicate = _interopRequireWildcard(require("./Predicate.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * 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
+ */
+
+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
+ */
+const isBigInt = exports.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
+ */
+const sum = exports.sum = /*#__PURE__*/(0, _Function.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
+ */
+const multiply = exports.multiply = /*#__PURE__*/(0, _Function.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
+ */
+const subtract = exports.subtract = /*#__PURE__*/(0, _Function.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
+ */
+const divide = exports.divide = /*#__PURE__*/(0, _Function.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
+ */
+const unsafeDivide = exports.unsafeDivide = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.increment = increment;
+const decrement = n => n - bigint1;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+exports.decrement = decrement;
+const Equivalence = exports.Equivalence = equivalence.bigint;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Order = exports.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
+ */
+const lessThan = exports.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
+ */
+const lessThanOrEqualTo = exports.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
+ */
+const greaterThan = exports.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
+ */
+const greaterThanOrEqualTo = exports.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
+ */
+const between = exports.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
+ */
+const clamp = exports.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
+ */
+const min = exports.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
+ */
+const max = exports.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
+ */
+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
+ */
+exports.sign = sign;
+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
+ */
+exports.abs = abs;
+const gcd = exports.gcd = /*#__PURE__*/(0, _Function.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
+ */
+const lcm = exports.lcm = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.unsafeSqrt = unsafeSqrt;
+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
+ */
+exports.sqrt = sqrt;
+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
+ */
+exports.sumAll = sumAll;
+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
+ */
+exports.multiplyAll = multiplyAll;
+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
+ */
+exports.toNumber = toNumber;
+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
+ */
+exports.fromString = fromString;
+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();
+ }
+};
+exports.fromNumber = fromNumber;
+//# sourceMappingURL=BigInt.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/BigInt.js.map b/backend/node_modules/effect/dist/cjs/BigInt.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..ea94d1234e46a401e31bee0b9e236a9266cbc18a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/BigInt.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"BigInt.js","names":["equivalence","_interopRequireWildcard","require","_Function","Option","order","predicate","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","bigint0","BigInt","bigint1","bigint2","isBigInt","exports","sum","dual","self","that","multiply","subtract","divide","none","some","unsafeDivide","increment","decrement","Equivalence","bigint","Order","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","between","clamp","min","max","sign","abs","gcd","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":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Boolean.js b/backend/node_modules/effect/dist/cjs/Boolean.js
new file mode 100644
index 0000000000000000000000000000000000000000..2fe5ba260a8c2e5fd28d915c398b460b74703d55
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Boolean.js
@@ -0,0 +1,251 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.xor = exports.some = exports.or = exports.not = exports.nor = exports.nand = exports.match = exports.isBoolean = exports.implies = exports.every = exports.eqv = exports.and = exports.Order = exports.Equivalence = void 0;
+var equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var order = _interopRequireWildcard(require("./Order.js"));
+var predicate = _interopRequireWildcard(require("./Predicate.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * 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
+ */
+
+/**
+ * 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
+ */
+const isBoolean = exports.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
+ */
+const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (value, options) => value ? options.onTrue() : options.onFalse());
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Equivalence = exports.Equivalence = equivalence.boolean;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Order = exports.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
+ */
+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
+ */
+exports.not = not;
+const and = exports.and = /*#__PURE__*/(0, _Function.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
+ */
+const nand = exports.nand = /*#__PURE__*/(0, _Function.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
+ */
+const or = exports.or = /*#__PURE__*/(0, _Function.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
+ */
+const nor = exports.nor = /*#__PURE__*/(0, _Function.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
+ */
+const xor = exports.xor = /*#__PURE__*/(0, _Function.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
+ */
+const eqv = exports.eqv = /*#__PURE__*/(0, _Function.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
+ */
+const implies = exports.implies = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+exports.every = every;
+const some = collection => {
+ for (const b of collection) {
+ if (b) {
+ return true;
+ }
+ }
+ return false;
+};
+exports.some = some;
+//# sourceMappingURL=Boolean.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Boolean.js.map b/backend/node_modules/effect/dist/cjs/Boolean.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..f5cb30313829c6b16f4c1a36b92170a51f962126
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Boolean.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Boolean.js","names":["equivalence","_interopRequireWildcard","require","_Function","order","predicate","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","isBoolean","exports","match","dual","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":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Brand.js.map b/backend/node_modules/effect/dist/cjs/Brand.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..186cbfe354e7c99ee6a25454042ccb966b800d2a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Brand.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Brand.js","names":["Arr","_interopRequireWildcard","require","Either","_Function","Option","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","BrandTypeId","exports","Symbol","for","RefinedConstructorsTypeId","error","message","meta","errors","flatten","refined","args","either","length","unbranded","right","left","match","onNone","onSome","assign","getOrThrowWith","identity","option","getRight","is","isRight","nominal","some","_args","all","brands","result","brand","nextResult","isLeft","onLeft","onRight","unsafeCoerce"],"sources":["../../src/Brand.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cache.js b/backend/node_modules/effect/dist/cjs/Cache.js
new file mode 100644
index 0000000000000000000000000000000000000000..163dfdc4d3c2b5860ecfc0e5137d0a9db9f7825e
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cache.js
@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.makeWith = exports.makeEntryStats = exports.makeCacheStats = exports.make = exports.ConsumerCacheTypeId = exports.CacheTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/cache.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const CacheTypeId = exports.CacheTypeId = internal.CacheTypeId;
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+const ConsumerCacheTypeId = exports.ConsumerCacheTypeId = internal.ConsumerCacheTypeId;
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = exports.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
+ */
+const makeWith = exports.makeWith = internal.makeWith;
+/**
+ * Constructs a new `CacheStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeCacheStats = exports.makeCacheStats = internal.makeCacheStats;
+/**
+ * Constructs a new `EntryStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeEntryStats = exports.makeEntryStats = internal.makeEntryStats;
+//# sourceMappingURL=Cache.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cache.js.map b/backend/node_modules/effect/dist/cjs/Cache.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..5b37ff8eb87ba49d53de6ea350afc5f1e5f52c66
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cache.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Cache.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","CacheTypeId","exports","ConsumerCacheTypeId","make","makeWith","makeCacheStats","makeEntryStats"],"sources":["../../src/Cache.ts"],"sourcesContent":[null],"mappings":";;;;;;AAOA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAA+C,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAK/C;;;;AAIO,MAAMkB,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAkBtB,QAAQ,CAACsB,WAAW;AAQ9D;;;;AAIO,MAAME,mBAAmB,GAAAD,OAAA,CAAAC,mBAAA,GAAkBxB,QAAQ,CAACwB,mBAAmB;AAsK9E;;;;;;;AAOO,MAAMC,IAAI,GAAAF,OAAA,CAAAE,IAAA,GAMkDzB,QAAQ,CAACyB,IAAI;AAEhF;;;;;;;;AAQO,MAAMC,QAAQ,GAAAH,OAAA,CAAAG,QAAA,GAM8C1B,QAAQ,CAAC0B,QAAQ;AAepF;;;;;;AAMO,MAAMC,cAAc,GAAAJ,OAAA,CAAAI,cAAA,GAMT3B,QAAQ,CAAC2B,cAAc;AAYzC;;;;;;AAMO,MAAMC,cAAc,GAAAL,OAAA,CAAAK,cAAA,GAAyC5B,QAAQ,CAAC4B,cAAc","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cause.js b/backend/node_modules/effect/dist/cjs/Cause.js
new file mode 100644
index 0000000000000000000000000000000000000000..e39f0dc7dc9ae87cb4de3eff9fa50e60453b6a2b
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cause.js
@@ -0,0 +1,1011 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.stripSomeDefects = exports.stripFailures = exports.squashWith = exports.squash = exports.size = exports.sequential = exports.reduceWithContext = exports.reduce = exports.prettyErrors = exports.pretty = exports.parallel = exports.originalError = exports.match = exports.map = exports.linearize = exports.keepDefects = exports.isUnknownException = exports.isTimeoutException = exports.isSequentialType = exports.isRuntimeException = exports.isParallelType = exports.isNoSuchElementException = exports.isInterruptedOnly = exports.isInterruptedException = exports.isInterrupted = exports.isInterruptType = exports.isIllegalArgumentException = exports.isFailure = exports.isFailType = exports.isExceededCapacityException = exports.isEmptyType = exports.isEmpty = exports.isDieType = exports.isDie = exports.isCause = exports.interruptors = exports.interruptOption = exports.interrupt = exports.flipCauseOption = exports.flatten = exports.flatMap = exports.find = exports.filter = exports.failures = exports.failureOrCause = exports.failureOption = exports.fail = exports.empty = exports.dieOption = exports.die = exports.defects = exports.contains = exports.as = exports.andThen = exports.YieldableError = exports.UnknownExceptionTypeId = exports.UnknownException = exports.TimeoutExceptionTypeId = exports.TimeoutException = exports.RuntimeExceptionTypeId = exports.RuntimeException = exports.NoSuchElementExceptionTypeId = exports.NoSuchElementException = exports.InvalidPubSubCapacityExceptionTypeId = exports.InterruptedExceptionTypeId = exports.InterruptedException = exports.IllegalArgumentExceptionTypeId = exports.IllegalArgumentException = exports.ExceededCapacityExceptionTypeId = exports.ExceededCapacityException = exports.CauseTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/cause.js"));
+var core = _interopRequireWildcard(require("./internal/core.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * 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
+ */
+const CauseTypeId = exports.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
+ */
+const RuntimeExceptionTypeId = exports.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
+ */
+const InterruptedExceptionTypeId = exports.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
+ */
+const IllegalArgumentExceptionTypeId = exports.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
+ */
+const NoSuchElementExceptionTypeId = exports.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
+ */
+const InvalidPubSubCapacityExceptionTypeId = exports.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
+ */
+const ExceededCapacityExceptionTypeId = exports.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
+ */
+const TimeoutExceptionTypeId = exports.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
+ */
+const UnknownExceptionTypeId = exports.UnknownExceptionTypeId = core.UnknownExceptionTypeId;
+/**
+ * Creates an error that occurs at runtime, extendable for other exception
+ * types.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+const YieldableError = exports.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
+ */
+const empty = exports.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
+ */
+const fail = exports.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
+ */
+const die = exports.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
+ */
+const interrupt = exports.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
+ */
+const parallel = exports.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
+ */
+const sequential = exports.sequential = internal.sequential;
+/**
+ * Checks if a value is a `Cause`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isCause = exports.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
+ */
+const isEmptyType = exports.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
+ */
+const isFailType = exports.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
+ */
+const isDieType = exports.isDieType = internal.isDieType;
+/**
+ * Checks if a `Cause` is an `Interrupt` type.
+ *
+ * @see {@link interrupt} Create an `Interrupt` cause
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isInterruptType = exports.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
+ */
+const isSequentialType = exports.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
+ */
+const isParallelType = exports.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
+ */
+const size = exports.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
+ */
+const isEmpty = exports.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
+ */
+const isFailure = exports.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
+ */
+const isDie = exports.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
+ */
+const isInterrupted = exports.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
+ */
+const isInterruptedOnly = exports.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
+ */
+const failures = exports.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
+ */
+const defects = exports.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
+ */
+const interruptors = exports.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
+ */
+const failureOption = exports.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` 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
+ */
+const failureOrCause = exports.failureOrCause = internal.failureOrCause;
+/**
+ * Strips out failures with an error of `None` from a `Cause>`.
+ *
+ * **Details**
+ *
+ * This function turns a `Cause>` into an `Option>`. 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
+ */
+const flipCauseOption = exports.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
+ */
+const dieOption = exports.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
+ */
+const interruptOption = exports.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
+ */
+const keepDefects = exports.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
+ */
+const linearize = exports.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`
+ * 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
+ */
+const stripFailures = exports.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
+ */
+const stripSomeDefects = exports.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
+ */
+const as = exports.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
+ */
+const map = exports.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
+ */
+const flatMap = exports.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
+ */
+const andThen = exports.andThen = internal.andThen;
+/**
+ * Flattens a nested `Cause` structure.
+ *
+ * **Details**
+ *
+ * This function takes a `Cause>` and merges the layers into a single
+ * `Cause`. 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
+ */
+const flatten = exports.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
+ */
+const contains = exports.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
+ */
+const squash = exports.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
+ */
+const squashWith = exports.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
+ */
+const find = exports.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
+ */
+const filter = exports.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
+ */
+const match = exports.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
+ */
+const reduce = exports.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
+ */
+const reduceWithContext = exports.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
+ */
+const InterruptedException = exports.InterruptedException = core.InterruptedException;
+/**
+ * Checks if a given unknown value is an `InterruptedException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isInterruptedException = exports.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
+ */
+const IllegalArgumentException = exports.IllegalArgumentException = core.IllegalArgumentException;
+/**
+ * Checks if a given unknown value is an `IllegalArgumentException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isIllegalArgumentException = exports.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
+ */
+const NoSuchElementException = exports.NoSuchElementException = core.NoSuchElementException;
+/**
+ * Checks if a given unknown value is a `NoSuchElementException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isNoSuchElementException = exports.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
+ */
+const RuntimeException = exports.RuntimeException = core.RuntimeException;
+/**
+ * Checks if a given unknown value is a `RuntimeException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isRuntimeException = exports.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
+ */
+const TimeoutException = exports.TimeoutException = core.TimeoutException;
+/**
+ * Checks if a given unknown value is a `TimeoutException`.
+ *
+ * @since 3.15.0
+ * @category Guards
+ */
+const isTimeoutException = exports.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
+ */
+const UnknownException = exports.UnknownException = core.UnknownException;
+/**
+ * Checks if a given unknown value is an `UnknownException`.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isUnknownException = exports.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
+ */
+const ExceededCapacityException = exports.ExceededCapacityException = core.ExceededCapacityException;
+/**
+ * Checks if a given unknown value is an `ExceededCapacityException`.
+ *
+ * @since 3.5.0
+ * @category Guards
+ */
+const isExceededCapacityException = exports.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
+ */
+const pretty = exports.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
+ */
+const prettyErrors = exports.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
+ */
+const originalError = exports.originalError = core.originalInstance;
+//# sourceMappingURL=Cause.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cause.js.map b/backend/node_modules/effect/dist/cjs/Cause.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..f87cd4ca180a2aa9cc0d4e290d55a0414e5d4842
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cause.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Cause.js","names":["internal","_interopRequireWildcard","require","core","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","CauseTypeId","exports","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,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,IAAA,GAAAF,uBAAA,CAAAC,OAAA;AAA0C,SAAAD,wBAAAG,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAL,uBAAA,YAAAA,CAAAG,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAS1C;;;;;;;;;;;;;;AAcO,MAAMkB,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAkBvB,QAAQ,CAACuB,WAAW;AAQ9D;;;;;;;;;;;;;;AAcO,MAAME,sBAAsB,GAAAD,OAAA,CAAAC,sBAAA,GAAkBtB,IAAI,CAACsB,sBAAsB;AAQhF;;;;;;;;;;;;;;AAcO,MAAMC,0BAA0B,GAAAF,OAAA,CAAAE,0BAAA,GAAkBvB,IAAI,CAACuB,0BAA0B;AAQxF;;;;;;;;;;;;;;AAcO,MAAMC,8BAA8B,GAAAH,OAAA,CAAAG,8BAAA,GAAkBxB,IAAI,CAACwB,8BAA8B;AAQhG;;;;;;;;;;;;;;AAcO,MAAMC,4BAA4B,GAAAJ,OAAA,CAAAI,4BAAA,GAAkBzB,IAAI,CAACyB,4BAA4B;AAQ5F;;;;;;;;;;;;;;AAcO,MAAMC,oCAAoC,GAAAL,OAAA,CAAAK,oCAAA,GAAkB1B,IAAI,CAAC0B,oCAAoC;AAQ5G;;;;;;;;;;;;;;AAcO,MAAMC,+BAA+B,GAAAN,OAAA,CAAAM,+BAAA,GAAkB3B,IAAI,CAAC2B,+BAA+B;AAQlG;;;;;;;;;;;;;;AAcO,MAAMC,sBAAsB,GAAAP,OAAA,CAAAO,sBAAA,GAAkB5B,IAAI,CAAC4B,sBAAsB;AAQhF;;;;;;;;;;;;;;AAcO,MAAMC,sBAAsB,GAAAR,OAAA,CAAAQ,sBAAA,GAAkB7B,IAAI,CAAC6B,sBAAsB;AAuFhF;;;;;;;AAOO,MAAMC,cAAc,GAAAT,OAAA,CAAAS,cAAA,GAAwD9B,IAAI,CAAC8B,cAAc;AA4OtG;;;;;;;;;;;;;AAaO,MAAMC,KAAK,GAAAV,OAAA,CAAAU,KAAA,GAAiBlC,QAAQ,CAACkC,KAAK;AAEjD;;;;;;;;;;;;;;AAcO,MAAMC,IAAI,GAAAX,OAAA,CAAAW,IAAA,GAA8BnC,QAAQ,CAACmC,IAAI;AAE5D;;;;;;;;;;;;;;AAcO,MAAMC,GAAG,GAAAZ,OAAA,CAAAY,GAAA,GAAsCpC,QAAQ,CAACoC,GAAG;AAElE;;;;;;;;;;;;;;AAcO,MAAMC,SAAS,GAAAb,OAAA,CAAAa,SAAA,GAA+CrC,QAAQ,CAACqC,SAAS;AAEvF;;;;;;;;;;;;;;AAcO,MAAMC,QAAQ,GAAAd,OAAA,CAAAc,QAAA,GAA+DtC,QAAQ,CAACsC,QAAQ;AAErG;;;;;;;;;;;;;;AAcO,MAAMC,UAAU,GAAAf,OAAA,CAAAe,UAAA,GAA+DvC,QAAQ,CAACuC,UAAU;AAEzG;;;;;;AAMO,MAAMC,OAAO,GAAAhB,OAAA,CAAAgB,OAAA,GAAwCxC,QAAQ,CAACwC,OAAO;AAE5E;;;;;;;;AAQO,MAAMC,WAAW,GAAAjB,OAAA,CAAAiB,WAAA,GAAyCzC,QAAQ,CAACyC,WAAW;AAErF;;;;;;;;AAQO,MAAMC,UAAU,GAAAlB,OAAA,CAAAkB,UAAA,GAA2C1C,QAAQ,CAAC0C,UAAU;AAErF;;;;;;;;AAQO,MAAMC,SAAS,GAAAnB,OAAA,CAAAmB,SAAA,GAAuC3C,QAAQ,CAAC2C,SAAS;AAE/E;;;;;;;;AAQO,MAAMC,eAAe,GAAApB,OAAA,CAAAoB,eAAA,GAA6C5C,QAAQ,CAAC4C,eAAe;AAEjG;;;;;;;;AAQO,MAAMC,gBAAgB,GAAArB,OAAA,CAAAqB,gBAAA,GAAiD7C,QAAQ,CAAC6C,gBAAgB;AAEvG;;;;;;;;AAQO,MAAMC,cAAc,GAAAtB,OAAA,CAAAsB,cAAA,GAA+C9C,QAAQ,CAAC8C,cAAc;AAEjG;;;;;;;;;;;AAWO,MAAMC,IAAI,GAAAvB,OAAA,CAAAuB,IAAA,GAAkC/C,QAAQ,CAAC+C,IAAI;AAEhE;;;;;;;;;;;;AAYO,MAAMC,OAAO,GAAAxB,OAAA,CAAAwB,OAAA,GAAmChD,QAAQ,CAACgD,OAAO;AAEvE;;;;;;;;;;;;AAYO,MAAMC,SAAS,GAAAzB,OAAA,CAAAyB,SAAA,GAAmCjD,QAAQ,CAACiD,SAAS;AAE3E;;;;;;;;;;;;AAYO,MAAMC,KAAK,GAAA1B,OAAA,CAAA0B,KAAA,GAAmClD,QAAQ,CAACkD,KAAK;AAEnE;;;;;;;;;;AAUO,MAAMC,aAAa,GAAA3B,OAAA,CAAA2B,aAAA,GAAmCnD,QAAQ,CAACmD,aAAa;AAEnF;;;;;;;;;;;;AAYO,MAAMC,iBAAiB,GAAA5B,OAAA,CAAA4B,iBAAA,GAAmCpD,QAAQ,CAACoD,iBAAiB;AAE3F;;;;;;;;;;;;AAYO,MAAMC,QAAQ,GAAA7B,OAAA,CAAA6B,QAAA,GAA0CrD,QAAQ,CAACqD,QAAQ;AAEhF;;;;;;;;;;;;AAYO,MAAMC,OAAO,GAAA9B,OAAA,CAAA8B,OAAA,GAAgDtD,QAAQ,CAACsD,OAAO;AAEpF;;;;;;;;;;;;AAYO,MAAMC,YAAY,GAAA/B,OAAA,CAAA+B,YAAA,GAA4DvD,QAAQ,CAACuD,YAAY;AAE1G;;;;;;;;;;;;AAYO,MAAMC,aAAa,GAAAhC,OAAA,CAAAgC,aAAA,GAA4CxD,QAAQ,CAACwD,aAAa;AAE5F;;;;;;;;;;;;;AAaO,MAAMC,cAAc,GAAAjC,OAAA,CAAAiC,cAAA,GAA0DzD,QAAQ,CAACyD,cAAc;AAE5G;;;;;;;;;;;;;AAaO,MAAMC,eAAe,GAAAlC,OAAA,CAAAkC,eAAA,GAAkE1D,QAAQ,CAAC0D,eAAe;AAEtH;;;;;;;;;;;;AAYO,MAAMC,SAAS,GAAAnC,OAAA,CAAAmC,SAAA,GAAkD3D,QAAQ,CAAC2D,SAAS;AAE1F;;;;;;;;;;;;AAYO,MAAMC,eAAe,GAAApC,OAAA,CAAAoC,eAAA,GAA0D5D,QAAQ,CAAC4D,eAAe;AAE9G;;;;;;;;;;;;;;AAcO,MAAMC,WAAW,GAAArC,OAAA,CAAAqC,WAAA,GAAuD7D,QAAQ,CAAC6D,WAAW;AAEnG;AACA;;;;;;;;;;;;AAYO,MAAMC,SAAS,GAAAtC,OAAA,CAAAsC,SAAA,GAAqD9D,QAAQ,CAAC8D,SAAS;AAE7F;;;;;;;;;;;;;AAaO,MAAMC,aAAa,GAAAvC,OAAA,CAAAuC,aAAA,GAAwC/D,QAAQ,CAAC+D,aAAa;AAExF;;;;;;;;;;;;;;AAcO,MAAMC,gBAAgB,GAAAxC,OAAA,CAAAwC,gBAAA,GA+BzBhE,QAAQ,CAACgE,gBAAgB;AAE7B;;;;;;;;;;;;;;AAcO,MAAMC,EAAE,GAAAzC,OAAA,CAAAyC,EAAA,GA+BXjE,QAAQ,CAACiE,EAAE;AAEf;;;;;;;;;;;;;;AAcO,MAAMC,GAAG,GAAA1C,OAAA,CAAA0C,GAAA,GA+BZlE,QAAQ,CAACkE,GAAG;AAEhB;;;;;;;;;;;;;;AAcO,MAAMC,OAAO,GAAA3C,OAAA,CAAA2C,OAAA,GA+BhBnE,QAAQ,CAACmE,OAAO;AAEpB;;;;;;;AAOO,MAAMC,OAAO,GAAA5C,OAAA,CAAA4C,OAAA,GAiChBpE,QAAQ,CAACoE,OAAO;AAEpB;;;;;;;;;;;;;;AAcO,MAAMC,OAAO,GAAA7C,OAAA,CAAA6C,OAAA,GAA2CrE,QAAQ,CAACqE,OAAO;AAE/E;;;;;;;;;;;;AAYO,MAAMC,QAAQ,GAAA9C,OAAA,CAAA8C,QAAA,GA2BjBtE,QAAQ,CAACsE,QAAQ;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BO,MAAMC,MAAM,GAAA/C,OAAA,CAAA+C,MAAA,GAAmCpE,IAAI,CAACqE,WAAW;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,MAAMC,UAAU,GAAAjD,OAAA,CAAAiD,UAAA,GAqDnBtE,IAAI,CAACuE,eAAe;AAExB;;;;;;;;;;;;;;;;;;;;;AAqBO,MAAMC,IAAI,GAAAnD,OAAA,CAAAmD,IAAA,GA6Cb3E,QAAQ,CAAC2E,IAAI;AAEjB;;;;;;;;;;;;;;;;;;;;;AAqBO,MAAMC,MAAM,GAAApD,OAAA,CAAAoD,MAAA,GAyFf5E,QAAQ,CAAC4E,MAAM;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BO,MAAMC,KAAK,GAAArD,OAAA,CAAAqD,KAAA,GA4Ed7E,QAAQ,CAAC6E,KAAK;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,MAAMC,MAAM,GAAAtD,OAAA,CAAAsD,MAAA,GAyDf9E,QAAQ,CAAC8E,MAAM;AAEnB;;;;;;;;;;;;;;;;;;;;;;;AAuBO,MAAMC,iBAAiB,GAAAvD,OAAA,CAAAuD,iBAAA,GAiD1B/E,QAAQ,CAAC+E,iBAAiB;AAE9B;;;;;;;;;;;;;;AAcO,MAAMC,oBAAoB,GAAAxD,OAAA,CAAAwD,oBAAA,GAA8D7E,IAAI,CAAC6E,oBAAoB;AAExH;;;;;;AAMO,MAAMC,sBAAsB,GAAAzD,OAAA,CAAAyD,sBAAA,GAA8C9E,IAAI,CAAC8E,sBAAsB;AAE5G;;;;;;;;;;;;AAYO,MAAMC,wBAAwB,GAAA1D,OAAA,CAAA0D,wBAAA,GACnC/E,IAAI,CAAC+E,wBAAwB;AAE/B;;;;;;AAMO,MAAMC,0BAA0B,GAAA3D,OAAA,CAAA2D,0BAAA,GAAkDhF,IAAI,CAACgF,0BAA0B;AAExH;;;;;;;;;;;AAWO,MAAMC,sBAAsB,GAAA5D,OAAA,CAAA4D,sBAAA,GACjCjF,IAAI,CAACiF,sBAAsB;AAE7B;;;;;;AAMO,MAAMC,wBAAwB,GAAA7D,OAAA,CAAA6D,wBAAA,GAAgDlF,IAAI,CAACkF,wBAAwB;AAElH;;;;;;;;;;;;;AAaO,MAAMC,gBAAgB,GAAA9D,OAAA,CAAA8D,gBAAA,GAA0DnF,IAAI,CAACmF,gBAAgB;AAE5G;;;;;;AAMO,MAAMC,kBAAkB,GAAA/D,OAAA,CAAA+D,kBAAA,GAA0CpF,IAAI,CAACoF,kBAAkB;AAEhG;;;;;;;;;;;;AAYO,MAAMC,gBAAgB,GAAAhE,OAAA,CAAAgE,gBAAA,GAA0DrF,IAAI,CAACqF,gBAAgB;AAE5G;;;;;;AAMO,MAAMC,kBAAkB,GAAAjE,OAAA,CAAAiE,kBAAA,GAA0CtF,IAAI,CAACsF,kBAAkB;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAMC,gBAAgB,GAAAlE,OAAA,CAAAkE,gBAAA,GAC3BvF,IAAI,CAACuF,gBAAgB;AAEvB;;;;;;AAMO,MAAMC,kBAAkB,GAAAnE,OAAA,CAAAmE,kBAAA,GAA0CxF,IAAI,CAACwF,kBAAkB;AAEhG;;;;;;;;;;;;;AAaO,MAAMC,yBAAyB,GAAApE,OAAA,CAAAoE,yBAAA,GACpCzF,IAAI,CAACyF,yBAAyB;AAEhC;;;;;;AAMO,MAAMC,2BAA2B,GAAArE,OAAA,CAAAqE,2BAAA,GACtC1F,IAAI,CAAC0F,2BAA2B;AAElC;;;;;;;;;;;;;;;;;;AAkBO,MAAMC,MAAM,GAAAtE,OAAA,CAAAsE,MAAA,GAEJ9F,QAAQ,CAAC8F,MAAM;AAY9B;;;;;;;;;;;;AAYO,MAAMC,YAAY,GAAAvE,OAAA,CAAAuE,YAAA,GAA+C/F,QAAQ,CAAC+F,YAAY;AAE7F;;;;;;;;;;;;;;AAcO,MAAMC,aAAa,GAAAxE,OAAA,CAAAwE,aAAA,GAAqB7F,IAAI,CAAC8F,gBAAgB","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Channel.js b/backend/node_modules/effect/dist/cjs/Channel.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba35eb41f4be19cb5b34d4cbd7ef306d1b960dc1
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Channel.js
@@ -0,0 +1,889 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.toSink = exports.toQueue = exports.toPullIn = exports.toPull = exports.toPubSub = exports.sync = exports.suspend = exports.succeed = exports.splitLines = exports.scopedWith = exports.scoped = exports.runScoped = exports.runDrain = exports.runCollect = exports.run = exports.repeated = exports.readWithCause = exports.readWith = exports.readOrFail = exports.read = exports.provideSomeLayer = exports.provideService = exports.provideLayer = exports.provideContext = exports.pipeToOrFail = exports.pipeTo = exports.orElse = exports.orDieWith = exports.orDie = exports.never = exports.mergeWith = exports.mergeOutWith = exports.mergeOut = exports.mergeMap = exports.mergeAllWith = exports.mergeAllUnboundedWith = exports.mergeAllUnbounded = exports.mergeAll = exports.mapOutEffectPar = exports.mapOutEffect = exports.mapOut = exports.mapInputInEffect = exports.mapInputIn = exports.mapInputErrorEffect = exports.mapInputError = exports.mapInputEffect = exports.mapInputContext = exports.mapInput = exports.mapErrorCause = exports.mapError = exports.mapEffect = exports.map = exports.isChannelException = exports.isChannel = exports.interruptWhenDeferred = exports.interruptWhen = exports.identity = exports.fromQueue = exports.fromPubSubScoped = exports.fromPubSub = exports.fromOption = exports.fromInput = exports.fromEither = exports.fromEffect = exports.foldChannel = exports.foldCauseChannel = exports.flatten = exports.flatMap = exports.failSync = exports.failCauseSync = exports.failCause = exports.fail = exports.ensuringWith = exports.ensuring = exports.emitCollect = exports.embedInput = exports.drain = exports.doneCollect = exports.contextWithEffect = exports.contextWithChannel = exports.contextWith = exports.context = exports.concatOut = exports.concatMapWithCustom = exports.concatMapWith = exports.concatMap = exports.concatAllWith = exports.concatAll = exports.collect = exports.catchAllCause = exports.catchAll = exports.bufferChunk = exports.buffer = exports.asVoid = exports.as = exports.acquireUseRelease = exports.acquireReleaseOut = exports.ChannelTypeId = exports.ChannelExceptionTypeId = exports.ChannelException = void 0;
+exports.zipRight = exports.zipLeft = exports.zip = exports.writeChunk = exports.writeAll = exports.write = exports.withSpan = exports.void = exports.updateService = exports.unwrapScopedWith = exports.unwrapScoped = exports.unwrap = exports.toStream = void 0;
+var channel = _interopRequireWildcard(require("./internal/channel.js"));
+var core = _interopRequireWildcard(require("./internal/core-stream.js"));
+var sink = _interopRequireWildcard(require("./internal/sink.js"));
+var stream = _interopRequireWildcard(require("./internal/stream.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ChannelTypeId = exports.ChannelTypeId = core.ChannelTypeId;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ChannelExceptionTypeId = exports.ChannelExceptionTypeId = channel.ChannelExceptionTypeId;
+/**
+ * @since 3.5.4
+ * @category refinements
+ */
+const isChannel = exports.isChannel = core.isChannel;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireUseRelease = exports.acquireUseRelease = channel.acquireUseRelease;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireReleaseOut = exports.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
+ */
+const as = exports.as = channel.as;
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+const asVoid = exports.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
+ */
+const buffer = exports.buffer = channel.buffer;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const bufferChunk = exports.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
+ */
+const catchAll = exports.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
+ */
+const catchAllCause = exports.catchAllCause = core.catchAllCause;
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAll = exports.concatAll = core.concatAll;
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAllWith = exports.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
+ */
+const concatMap = exports.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
+ */
+const concatMapWith = exports.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
+ */
+const concatMapWithCustom = exports.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
+ */
+const collect = exports.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
+ */
+const concatOut = exports.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
+ */
+const mapInput = exports.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
+ */
+const mapInputEffect = exports.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
+ */
+const mapInputError = exports.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
+ */
+const mapInputErrorEffect = exports.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
+ */
+const mapInputIn = exports.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
+ */
+const mapInputInEffect = exports.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
+ */
+const doneCollect = exports.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
+ */
+const drain = exports.drain = channel.drain;
+/**
+ * Returns a new channel which connects the given `AsyncInputProducer` as
+ * this channel's input.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const embedInput = exports.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
+ */
+const emitCollect = exports.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
+ */
+const ensuring = exports.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
+ */
+const ensuringWith = exports.ensuringWith = core.ensuringWith;
+/**
+ * Accesses the whole context of the channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const context = exports.context = channel.context;
+/**
+ * Accesses the context of the channel with the specified function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWith = exports.contextWith = channel.contextWith;
+/**
+ * Accesses the context of the channel in the context of a channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithChannel = exports.contextWithChannel = channel.contextWithChannel;
+/**
+ * Accesses the context of the channel in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithEffect = exports.contextWithEffect = channel.contextWithEffect;
+/**
+ * Constructs a channel that fails immediately with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = exports.fail = core.fail;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = exports.failSync = core.failSync;
+/**
+ * Constructs a channel that fails immediately with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = exports.failCause = core.failCause;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = exports.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
+ */
+const flatMap = exports.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
+ */
+const flatten = exports.flatten = channel.flatten;
+/**
+ * Folds over the result of this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const foldChannel = exports.foldChannel = channel.foldChannel;
+/**
+ * Folds over the result of this channel including any cause of termination.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const foldCauseChannel = exports.foldCauseChannel = core.foldCauseChannel;
+/**
+ * Use an effect to end a channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = exports.fromEffect = core.fromEffect;
+/**
+ * Constructs a channel from an `Either`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEither = exports.fromEither = channel.fromEither;
+/**
+ * Construct a `Channel` from an `AsyncInputConsumer`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromInput = exports.fromInput = channel.fromInput;
+/**
+ * Construct a `Channel` from a `PubSub`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPubSub = exports.fromPubSub = channel.fromPubSub;
+/**
+ * Construct a `Channel` from a `PubSub` within a scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPubSubScoped = exports.fromPubSubScoped = channel.fromPubSubScoped;
+/**
+ * Construct a `Channel` from an `Option`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromOption = exports.fromOption = channel.fromOption;
+/**
+ * Construct a `Channel` from a `Queue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = exports.fromQueue = channel.fromQueue;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const identity = exports.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
+ */
+const interruptWhen = exports.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
+ */
+const interruptWhenDeferred = exports.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
+ */
+const map = exports.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
+ */
+const mapEffect = exports.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
+ */
+const mapError = exports.mapError = channel.mapError;
+/**
+ * A more powerful version of `mapError` which also surfaces the `Cause`
+ * of the channel failure.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapErrorCause = exports.mapErrorCause = channel.mapErrorCause;
+/**
+ * Maps the output of this channel using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapOut = exports.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
+ */
+const mapOutEffect = exports.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
+ */
+const mapOutEffectPar = exports.mapOutEffectPar = channel.mapOutEffectPar;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAll = exports.mergeAll = channel.mergeAll;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllUnbounded = exports.mergeAllUnbounded = channel.mergeAllUnbounded;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllUnboundedWith = exports.mergeAllUnboundedWith = channel.mergeAllUnboundedWith;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllWith = exports.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
+ */
+const mergeMap = exports.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
+ */
+const mergeOut = exports.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
+ */
+const mergeOutWith = exports.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
+ */
+const mergeWith = exports.mergeWith = channel.mergeWith;
+/**
+ * Returns a channel that never completes
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = exports.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
+ */
+const orDie = exports.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
+ */
+const orDieWith = exports.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
+ */
+const orElse = exports.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
+ */
+const pipeTo = exports.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
+ */
+const pipeToOrFail = exports.pipeToOrFail = channel.pipeToOrFail;
+/**
+ * Provides the channel with its required context, which eliminates its
+ * dependency on `Env`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = exports.provideContext = core.provideContext;
+/**
+ * Provides a layer to the channel, which translates it to another level.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideLayer = exports.provideLayer = channel.provideLayer;
+/**
+ * Transforms the context being provided to the channel with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = exports.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
+ */
+const provideSomeLayer = exports.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
+ */
+const provideService = exports.provideService = channel.provideService;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const read = exports.read = channel.read;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readOrFail = exports.readOrFail = core.readOrFail;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readWith = exports.readWith = core.readWith;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readWithCause = exports.readWithCause = core.readWithCause;
+/**
+ * Creates a channel which repeatedly runs this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeated = exports.repeated = channel.repeated;
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = exports.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
+ */
+const runCollect = exports.runCollect = channel.runCollect;
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runDrain = exports.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
+ */
+const runScoped = exports.runScoped = channel.runScoped;
+/**
+ * Use a scoped effect to emit an output element.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = exports.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
+ */
+const scopedWith = exports.scopedWith = channel.scopedWith;
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const splitLines = exports.splitLines = channel.splitLines;
+/**
+ * Constructs a channel that succeeds immediately with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = exports.succeed = core.succeed;
+/**
+ * Lazily constructs a channel from the given side effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = exports.suspend = core.suspend;
+/**
+ * Constructs a channel that succeeds immediately with the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = exports.sync = core.sync;
+/**
+ * Converts a `Channel` to a `PubSub`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toPubSub = exports.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
+ */
+const toPull = exports.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
+ */
+const toPullIn = exports.toPullIn = channel.toPullIn;
+/**
+ * Converts a `Channel` to a `Queue`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueue = exports.toQueue = channel.toQueue;
+/** Converts this channel to a `Sink`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toSink = exports.toSink = sink.channelToSink;
+/**
+ * Converts this channel to a `Stream`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toStream = exports.toStream = stream.channelToStream;
+const void_ = exports.void = core.void;
+/**
+ * Constructs a `Channel` from an effect that will result in a `Channel` if
+ * successful.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = exports.unwrap = channel.unwrap;
+/**
+ * Constructs a `Channel` from a scoped effect that will result in a
+ * `Channel` if successful.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = exports.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
+ */
+const unwrapScopedWith = exports.unwrapScopedWith = channel.unwrapScopedWith;
+/**
+ * Updates a service in the context of this channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const updateService = exports.updateService = channel.updateService;
+/**
+ * Wraps the channel with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category tracing
+ */
+const withSpan = exports.withSpan = channel.withSpan;
+/**
+ * Writes a single value to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const write = exports.write = core.write;
+/**
+ * Writes a sequence of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const writeAll = exports.writeAll = channel.writeAll;
+/**
+ * Writes a `Chunk` of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const writeChunk = exports.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
+ */
+const zip = exports.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
+ */
+const zipLeft = exports.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
+ */
+const zipRight = exports.zipRight = channel.zipRight;
+/**
+ * Represents a generic checked exception which occurs when a `Channel` is
+ * executed.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const ChannelException = exports.ChannelException = channel.ChannelException;
+/**
+ * Returns `true` if the specified value is an `ChannelException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isChannelException = exports.isChannelException = channel.isChannelException;
+//# sourceMappingURL=Channel.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js b/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c3cbdb48b85f1e4ec001c7bf29a5f64e93ffe46
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js
@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.match = exports.isYield = exports.isContinue = exports.isClose = exports.isChildExecutorDecision = exports.Yield = exports.Continue = exports.Close = exports.ChildExecutorDecisionTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/channel/childExecutorDecision.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ChildExecutorDecisionTypeId = exports.ChildExecutorDecisionTypeId = internal.ChildExecutorDecisionTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const Continue = exports.Continue = internal.Continue;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const Close = exports.Close = internal.Close;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const Yield = exports.Yield = internal.Yield;
+/**
+ * Returns `true` if the specified value is a `ChildExecutorDecision`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isChildExecutorDecision = exports.isChildExecutorDecision = internal.isChildExecutorDecision;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Continue`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isContinue = exports.isContinue = internal.isContinue;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Close`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isClose = exports.isClose = internal.isClose;
+/**
+ * Returns `true` if the specified `ChildExecutorDecision` is a `Yield`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isYield = exports.isYield = internal.isYield;
+/**
+ * Folds over a `ChildExecutorDecision` to produce a value of type `A`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = exports.match = internal.match;
+//# sourceMappingURL=ChildExecutorDecision.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js.map b/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..07634069e9f6950552d3d61482181416a597789c
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ChildExecutorDecision.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ChildExecutorDecision.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ChildExecutorDecisionTypeId","exports","Continue","Close","Yield","isChildExecutorDecision","isContinue","isClose","isYield","match"],"sources":["../../src/ChildExecutorDecision.ts"],"sourcesContent":[null],"mappings":";;;;;;AAGA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAuE,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAHvE;;;;AAKA;;;;AAIO,MAAMkB,2BAA2B,GAAAC,OAAA,CAAAD,2BAAA,GAAkBtB,QAAQ,CAACsB,2BAA2B;AA4D9F;;;;AAIO,MAAME,QAAQ,GAAAD,OAAA,CAAAC,QAAA,GAAuCxB,QAAQ,CAACwB,QAAQ;AAE7E;;;;AAIO,MAAMC,KAAK,GAAAF,OAAA,CAAAE,KAAA,GAA8CzB,QAAQ,CAACyB,KAAK;AAE9E;;;;AAIO,MAAMC,KAAK,GAAAH,OAAA,CAAAG,KAAA,GAAuC1B,QAAQ,CAAC0B,KAAK;AAEvE;;;;;;;AAOO,MAAMC,uBAAuB,GAAAJ,OAAA,CAAAI,uBAAA,GAA+C3B,QAAQ,CAAC2B,uBAAuB;AAEnH;;;;;;;AAOO,MAAMC,UAAU,GAAAL,OAAA,CAAAK,UAAA,GAAsD5B,QAAQ,CAAC4B,UAAU;AAEhG;;;;;;;AAOO,MAAMC,OAAO,GAAAN,OAAA,CAAAM,OAAA,GAAmD7B,QAAQ,CAAC6B,OAAO;AAEvF;;;;;;;AAOO,MAAMC,OAAO,GAAAP,OAAA,CAAAO,OAAA,GAAmD9B,QAAQ,CAAC8B,OAAO;AAEvF;;;;;;AAMO,MAAMC,KAAK,GAAAR,OAAA,CAAAQ,KAAA,GA4Bd/B,QAAQ,CAAC+B,KAAK","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Chunk.js b/backend/node_modules/effect/dist/cjs/Chunk.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f22a8ed45952aae1a00dd690b6c858b3fa5d86b
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Chunk.js
@@ -0,0 +1,1114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zipWith = exports.zip = exports.unzip = exports.unsafeLast = exports.unsafeHead = exports.unsafeGet = exports.unsafeFromNonEmptyArray = exports.unsafeFromArray = exports.union = exports.toReadonlyArray = exports.toArray = exports.takeWhile = exports.takeRight = exports.take = exports.tailNonEmpty = exports.tail = exports.splitWhere = exports.splitNonEmptyAt = exports.splitAt = exports.split = exports.sortWith = exports.sort = exports.some = exports.size = exports.separate = exports.reverse = exports.replaceOption = exports.replace = exports.removeOption = exports.remove = exports.reduceRight = exports.reduce = exports.range = exports.prependAll = exports.prepend = exports.partitionMap = exports.partition = exports.of = exports.modifyOption = exports.modify = exports.mapAccum = exports.map = exports.makeBy = exports.make = exports.lastNonEmpty = exports.last = exports.join = exports.isNonEmpty = exports.isEmpty = exports.isChunk = exports.intersection = exports.headNonEmpty = exports.head = exports.getEquivalence = exports.get = exports.fromIterable = exports.forEach = exports.flatten = exports.flatMap = exports.findLastIndex = exports.findLast = exports.findFirstIndex = exports.findFirst = exports.filterMapWhile = exports.filterMap = exports.filter = exports.every = exports.empty = exports.dropWhile = exports.dropRight = exports.drop = exports.differenceWith = exports.difference = exports.dedupeAdjacent = exports.dedupe = exports.containsWith = exports.contains = exports.compact = exports.chunksOf = exports.appendAll = exports.append = void 0;
+var RA = _interopRequireWildcard(require("./Array.js"));
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var Equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Inspectable = require("./Inspectable.js");
+var O = _interopRequireWildcard(require("./Option.js"));
+var Order = _interopRequireWildcard(require("./Order.js"));
+var _Pipeable = require("./Pipeable.js");
+var _Predicate = require("./Predicate.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+const TypeId = /*#__PURE__*/Symbol.for("effect/Chunk");
+function copy(src, srcPos, dest, destPos, len) {
+ for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
+ dest[destPos + i - srcPos] = src[i];
+ }
+ return dest;
+}
+const emptyArray = [];
+/**
+ * Compares the two chunks of equal length using the specified function
+ *
+ * @category equivalence
+ * @since 2.0.0
+ */
+const getEquivalence = isEquivalent => Equivalence.make((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
+exports.getEquivalence = getEquivalence;
+const _equivalence = /*#__PURE__*/getEquivalence(Equal.equals);
+const ChunkProto = {
+ [TypeId]: {
+ _A: _ => _
+ },
+ toString() {
+ return (0, _Inspectable.format)(this.toJSON());
+ },
+ toJSON() {
+ return {
+ _id: "Chunk",
+ values: toReadonlyArray(this).map(_Inspectable.toJSON)
+ };
+ },
+ [_Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ [Equal.symbol](that) {
+ return isChunk(that) && _equivalence(this, that);
+ },
+ [Hash.symbol]() {
+ return Hash.cached(this, Hash.array(toReadonlyArray(this)));
+ },
+ [Symbol.iterator]() {
+ switch (this.backing._tag) {
+ case "IArray":
+ {
+ return this.backing.array[Symbol.iterator]();
+ }
+ case "IEmpty":
+ {
+ return emptyArray[Symbol.iterator]();
+ }
+ default:
+ {
+ return toReadonlyArray(this)[Symbol.iterator]();
+ }
+ }
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+const makeChunk = backing => {
+ const chunk = Object.create(ChunkProto);
+ chunk.backing = backing;
+ switch (backing._tag) {
+ case "IEmpty":
+ {
+ chunk.length = 0;
+ chunk.depth = 0;
+ chunk.left = chunk;
+ chunk.right = chunk;
+ break;
+ }
+ case "IConcat":
+ {
+ chunk.length = backing.left.length + backing.right.length;
+ chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
+ chunk.left = backing.left;
+ chunk.right = backing.right;
+ break;
+ }
+ case "IArray":
+ {
+ chunk.length = backing.array.length;
+ chunk.depth = 0;
+ chunk.left = _empty;
+ chunk.right = _empty;
+ break;
+ }
+ case "ISingleton":
+ {
+ chunk.length = 1;
+ chunk.depth = 0;
+ chunk.left = _empty;
+ chunk.right = _empty;
+ break;
+ }
+ case "ISlice":
+ {
+ chunk.length = backing.length;
+ chunk.depth = backing.chunk.depth + 1;
+ chunk.left = _empty;
+ chunk.right = _empty;
+ break;
+ }
+ }
+ return chunk;
+};
+/**
+ * Checks if `u` is a `Chunk`
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const isChunk = u => (0, _Predicate.hasProperty)(u, TypeId);
+exports.isChunk = isChunk;
+const _empty = /*#__PURE__*/makeChunk({
+ _tag: "IEmpty"
+});
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+const empty = () => _empty;
+/**
+ * Builds a `NonEmptyChunk` from an non-empty collection of elements.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.empty = empty;
+const make = (...as) => unsafeFromNonEmptyArray(as);
+/**
+ * Builds a `NonEmptyChunk` from a single element.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.make = make;
+const of = a => makeChunk({
+ _tag: "ISingleton",
+ a
+});
+/**
+ * Creates a new `Chunk` from an iterable collection of values.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.of = of;
+const fromIterable = self => isChunk(self) ? self : unsafeFromArray(RA.fromIterable(self));
+exports.fromIterable = fromIterable;
+const copyToArray = (self, array, initial) => {
+ switch (self.backing._tag) {
+ case "IArray":
+ {
+ copy(self.backing.array, 0, array, initial, self.length);
+ break;
+ }
+ case "IConcat":
+ {
+ copyToArray(self.left, array, initial);
+ copyToArray(self.right, array, initial + self.left.length);
+ break;
+ }
+ case "ISingleton":
+ {
+ array[initial] = self.backing.a;
+ break;
+ }
+ case "ISlice":
+ {
+ let i = 0;
+ let j = initial;
+ while (i < self.length) {
+ array[j] = unsafeGet(self, i);
+ i += 1;
+ j += 1;
+ }
+ break;
+ }
+ }
+};
+const toArray_ = self => toReadonlyArray(self).slice();
+/**
+ * Converts a `Chunk` into an `Array`. If the provided `Chunk` is non-empty
+ * (`NonEmptyChunk`), the function will return a `NonEmptyArray`, ensuring the
+ * non-empty property is preserved.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toArray = exports.toArray = toArray_;
+const toReadonlyArray_ = self => {
+ switch (self.backing._tag) {
+ case "IEmpty":
+ {
+ return emptyArray;
+ }
+ case "IArray":
+ {
+ return self.backing.array;
+ }
+ default:
+ {
+ const arr = new Array(self.length);
+ copyToArray(self, arr, 0);
+ self.backing = {
+ _tag: "IArray",
+ array: arr
+ };
+ self.left = _empty;
+ self.right = _empty;
+ self.depth = 0;
+ return arr;
+ }
+ }
+};
+/**
+ * Converts a `Chunk` into a `ReadonlyArray`. If the provided `Chunk` is
+ * non-empty (`NonEmptyChunk`), the function will return a
+ * `NonEmptyReadonlyArray`, ensuring the non-empty property is preserved.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toReadonlyArray = exports.toReadonlyArray = toReadonlyArray_;
+const reverseChunk = self => {
+ switch (self.backing._tag) {
+ case "IEmpty":
+ case "ISingleton":
+ return self;
+ case "IArray":
+ {
+ return makeChunk({
+ _tag: "IArray",
+ array: RA.reverse(self.backing.array)
+ });
+ }
+ case "IConcat":
+ {
+ return makeChunk({
+ _tag: "IConcat",
+ left: reverse(self.backing.right),
+ right: reverse(self.backing.left)
+ });
+ }
+ case "ISlice":
+ return unsafeFromArray(RA.reverse(toReadonlyArray(self)));
+ }
+};
+/**
+ * Reverses the order of elements in a `Chunk`.
+ * Importantly, if the input chunk is a `NonEmptyChunk`, the reversed chunk will also be a `NonEmptyChunk`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Chunk } from "effect"
+ *
+ * const chunk = Chunk.make(1, 2, 3)
+ * const result = Chunk.reverse(chunk)
+ *
+ * console.log(result)
+ * // { _id: 'Chunk', values: [ 3, 2, 1 ] }
+ * ```
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const reverse = exports.reverse = reverseChunk;
+/**
+ * This function provides a safe way to read a value at a particular index from a `Chunk`.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const get = exports.get = /*#__PURE__*/(0, _Function.dual)(2, (self, index) => index < 0 || index >= self.length ? O.none() : O.some(unsafeGet(self, index)));
+/**
+ * Wraps an array into a chunk without copying, unsafe on mutable arrays
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeFromArray = self => self.length === 0 ? empty() : self.length === 1 ? of(self[0]) : makeChunk({
+ _tag: "IArray",
+ array: self
+});
+/**
+ * Wraps an array into a chunk without copying, unsafe on mutable arrays
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+exports.unsafeFromArray = unsafeFromArray;
+const unsafeFromNonEmptyArray = self => unsafeFromArray(self);
+/**
+ * Gets an element unsafely, will throw on out of bounds
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+exports.unsafeFromNonEmptyArray = unsafeFromNonEmptyArray;
+const unsafeGet = exports.unsafeGet = /*#__PURE__*/(0, _Function.dual)(2, (self, index) => {
+ switch (self.backing._tag) {
+ case "IEmpty":
+ {
+ throw new Error(`Index out of bounds`);
+ }
+ case "ISingleton":
+ {
+ if (index !== 0) {
+ throw new Error(`Index out of bounds`);
+ }
+ return self.backing.a;
+ }
+ case "IArray":
+ {
+ if (index >= self.length || index < 0) {
+ throw new Error(`Index out of bounds`);
+ }
+ return self.backing.array[index];
+ }
+ case "IConcat":
+ {
+ return index < self.left.length ? unsafeGet(self.left, index) : unsafeGet(self.right, index - self.left.length);
+ }
+ case "ISlice":
+ {
+ return unsafeGet(self.backing.chunk, index + self.backing.offset);
+ }
+ }
+});
+/**
+ * Appends the specified element to the end of the `Chunk`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const append = exports.append = /*#__PURE__*/(0, _Function.dual)(2, (self, a) => appendAll(self, of(a)));
+/**
+ * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prepend = exports.prepend = /*#__PURE__*/(0, _Function.dual)(2, (self, elem) => appendAll(of(elem), self));
+/**
+ * Takes the first up to `n` elements from the chunk
+ *
+ * @since 2.0.0
+ */
+const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
+ if (n <= 0) {
+ return _empty;
+ } else if (n >= self.length) {
+ return self;
+ } else {
+ switch (self.backing._tag) {
+ case "ISlice":
+ {
+ return makeChunk({
+ _tag: "ISlice",
+ chunk: self.backing.chunk,
+ length: n,
+ offset: self.backing.offset
+ });
+ }
+ case "IConcat":
+ {
+ if (n > self.left.length) {
+ return makeChunk({
+ _tag: "IConcat",
+ left: self.left,
+ right: take(self.right, n - self.left.length)
+ });
+ }
+ return take(self.left, n);
+ }
+ default:
+ {
+ return makeChunk({
+ _tag: "ISlice",
+ chunk: self,
+ offset: 0,
+ length: n
+ });
+ }
+ }
+ }
+});
+/**
+ * Drops the first up to `n` elements from the chunk
+ *
+ * @since 2.0.0
+ */
+const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
+ if (n <= 0) {
+ return self;
+ } else if (n >= self.length) {
+ return _empty;
+ } else {
+ switch (self.backing._tag) {
+ case "ISlice":
+ {
+ return makeChunk({
+ _tag: "ISlice",
+ chunk: self.backing.chunk,
+ offset: self.backing.offset + n,
+ length: self.backing.length - n
+ });
+ }
+ case "IConcat":
+ {
+ if (n > self.left.length) {
+ return drop(self.right, n - self.left.length);
+ }
+ return makeChunk({
+ _tag: "IConcat",
+ left: drop(self.left, n),
+ right: self.right
+ });
+ }
+ default:
+ {
+ return makeChunk({
+ _tag: "ISlice",
+ chunk: self,
+ offset: n,
+ length: self.length - n
+ });
+ }
+ }
+ }
+});
+/**
+ * Drops the last `n` elements.
+ *
+ * @since 2.0.0
+ */
+const dropRight = exports.dropRight = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => take(self, Math.max(0, self.length - n)));
+/**
+ * Drops all elements so long as the predicate returns true.
+ *
+ * @since 2.0.0
+ */
+const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => {
+ const arr = toReadonlyArray(self);
+ const len = arr.length;
+ let i = 0;
+ while (i < len && predicate(arr[i])) {
+ i++;
+ }
+ return drop(self, i);
+});
+/**
+ * Prepends the specified prefix chunk to the beginning of the specified chunk.
+ * If either chunk is non-empty, the result is also a non-empty chunk.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Chunk } from "effect"
+ *
+ * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray)
+ *
+ * console.log(result)
+ * // [ "a", "b", 1, 2 ]
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prependAll = exports.prependAll = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => appendAll(that, self));
+/**
+ * Concatenates two chunks, combining their elements.
+ * If either chunk is non-empty, the result is also a non-empty chunk.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Chunk } from "effect"
+ *
+ * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray)
+ *
+ * console.log(result)
+ * // [ 1, 2, "a", "b" ]
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAll = exports.appendAll = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
+ if (self.backing._tag === "IEmpty") {
+ return that;
+ }
+ if (that.backing._tag === "IEmpty") {
+ return self;
+ }
+ const diff = that.depth - self.depth;
+ if (Math.abs(diff) <= 1) {
+ return makeChunk({
+ _tag: "IConcat",
+ left: self,
+ right: that
+ });
+ } else if (diff < -1) {
+ if (self.left.depth >= self.right.depth) {
+ const nr = appendAll(self.right, that);
+ return makeChunk({
+ _tag: "IConcat",
+ left: self.left,
+ right: nr
+ });
+ } else {
+ const nrr = appendAll(self.right.right, that);
+ if (nrr.depth === self.depth - 3) {
+ const nr = makeChunk({
+ _tag: "IConcat",
+ left: self.right.left,
+ right: nrr
+ });
+ return makeChunk({
+ _tag: "IConcat",
+ left: self.left,
+ right: nr
+ });
+ } else {
+ const nl = makeChunk({
+ _tag: "IConcat",
+ left: self.left,
+ right: self.right.left
+ });
+ return makeChunk({
+ _tag: "IConcat",
+ left: nl,
+ right: nrr
+ });
+ }
+ }
+ } else {
+ if (that.right.depth >= that.left.depth) {
+ const nl = appendAll(self, that.left);
+ return makeChunk({
+ _tag: "IConcat",
+ left: nl,
+ right: that.right
+ });
+ } else {
+ const nll = appendAll(self, that.left.left);
+ if (nll.depth === that.depth - 3) {
+ const nl = makeChunk({
+ _tag: "IConcat",
+ left: nll,
+ right: that.left.right
+ });
+ return makeChunk({
+ _tag: "IConcat",
+ left: nl,
+ right: that.right
+ });
+ } else {
+ const nr = makeChunk({
+ _tag: "IConcat",
+ left: that.left.right,
+ right: that.right
+ });
+ return makeChunk({
+ _tag: "IConcat",
+ left: nll,
+ right: nr
+ });
+ }
+ }
+ }
+});
+/**
+ * Returns a filtered and mapped subset of the elements.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => unsafeFromArray(RA.filterMap(self, f)));
+/**
+ * Returns a filtered and mapped subset of the elements.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filter = exports.filter = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => unsafeFromArray(RA.filter(self, predicate)));
+/**
+ * Transforms all elements of the chunk for as long as the specified function returns some value
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterMapWhile = exports.filterMapWhile = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => unsafeFromArray(RA.filterMapWhile(self, f)));
+/**
+ * Filter out optional values
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const compact = self => filterMap(self, _Function.identity);
+/**
+ * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+exports.compact = compact;
+const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
+ if (self.backing._tag === "ISingleton") {
+ return f(self.backing.a, 0);
+ }
+ let out = _empty;
+ let i = 0;
+ for (const k of self) {
+ out = appendAll(out, f(k, i++));
+ }
+ return out;
+});
+/**
+ * Iterates over each element of a `Chunk` and applies a function to it.
+ *
+ * **Details**
+ *
+ * This function processes every element of the given `Chunk`, calling the
+ * provided function `f` on each element. It does not return a new value;
+ * instead, it is primarily used for side effects, such as logging or
+ * accumulating data in an external variable.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const forEach = exports.forEach = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => toReadonlyArray(self).forEach(f));
+/**
+ * Flattens a chunk of chunks into a single chunk by concatenating all chunks.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = exports.flatten = /*#__PURE__*/flatMap(_Function.identity);
+/**
+ * Groups elements in chunks of up to `n` elements.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const chunksOf = exports.chunksOf = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
+ const gr = [];
+ let current = [];
+ toReadonlyArray(self).forEach(a => {
+ current.push(a);
+ if (current.length >= n) {
+ gr.push(unsafeFromArray(current));
+ current = [];
+ }
+ });
+ if (current.length > 0) {
+ gr.push(unsafeFromArray(current));
+ }
+ return unsafeFromArray(gr);
+});
+/**
+ * Creates a Chunk of unique values that are included in all given Chunks.
+ *
+ * The order and references of result values are determined by the Chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const intersection = exports.intersection = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => unsafeFromArray(RA.intersection(toReadonlyArray(self), toReadonlyArray(that))));
+/**
+ * Determines if the chunk is empty.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const isEmpty = self => self.length === 0;
+/**
+ * Determines if the chunk is not empty.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.isEmpty = isEmpty;
+const isNonEmpty = self => self.length > 0;
+/**
+ * Returns the first element of this chunk if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.isNonEmpty = isNonEmpty;
+const head = exports.head = /*#__PURE__*/get(0);
+/**
+ * Returns the first element of this chunk.
+ *
+ * It will throw an error if the chunk is empty.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeHead = self => unsafeGet(self, 0);
+/**
+ * Returns the first element of this non empty chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.unsafeHead = unsafeHead;
+const headNonEmpty = exports.headNonEmpty = unsafeHead;
+/**
+ * Returns the last element of this chunk if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const last = self => get(self, self.length - 1);
+/**
+ * Returns the last element of this chunk.
+ *
+ * It will throw an error if the chunk is empty.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+exports.last = last;
+const unsafeLast = self => unsafeGet(self, self.length - 1);
+/**
+ * Returns the last element of this non empty chunk.
+ *
+ * @since 3.4.0
+ * @category elements
+ */
+exports.unsafeLast = unsafeLast;
+const lastNonEmpty = exports.lastNonEmpty = unsafeLast;
+/**
+ * Transforms the elements of a chunk using the specified mapping function.
+ * If the input chunk is non-empty, the resulting chunk will also be non-empty.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Chunk } from "effect"
+ *
+ * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)
+ *
+ * console.log(result)
+ * // { _id: 'Chunk', values: [ 2, 3 ] }
+ * ```
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray((0, _Function.pipe)(toReadonlyArray(self), RA.map((a, i) => f(a, i)))));
+/**
+ * Statefully maps over the chunk, producing new elements of type `B`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const mapAccum = exports.mapAccum = /*#__PURE__*/(0, _Function.dual)(3, (self, s, f) => {
+ const [s1, as] = RA.mapAccum(self, s, f);
+ return [s1, unsafeFromArray(as)];
+});
+/**
+ * Separate elements based on a predicate that also exposes the index of the element.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partition = exports.partition = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => (0, _Function.pipe)(RA.partition(toReadonlyArray(self), predicate), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]));
+/**
+ * Partitions the elements of this chunk into two chunks using f.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partitionMap = exports.partitionMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => (0, _Function.pipe)(RA.partitionMap(toReadonlyArray(self), f), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]));
+/**
+ * Partitions the elements of this chunk into two chunks.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const separate = self => (0, _Function.pipe)(RA.separate(toReadonlyArray(self)), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]);
+/**
+ * Retireves the size of the chunk
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.separate = separate;
+const size = self => self.length;
+/**
+ * Sort the elements of a Chunk in increasing order, creating a new Chunk.
+ *
+ * @since 2.0.0
+ * @category sorting
+ */
+exports.size = size;
+const sort = exports.sort = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => unsafeFromArray(RA.sort(toReadonlyArray(self), O)));
+/**
+ * @since 2.0.0
+ * @category sorting
+ */
+const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.dual)(3, (self, f, order) => sort(self, Order.mapInput(order, f)));
+/**
+ * Returns two splits of this chunk at the specified index.
+ *
+ * @since 2.0.0
+ * @category splitting
+ */
+const splitAt = exports.splitAt = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => [take(self, n), drop(self, n)]);
+/**
+ * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements.
+ * The value of `n` must be `>= 1`.
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+const splitNonEmptyAt = exports.splitNonEmptyAt = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
+ const _n = Math.max(1, Math.floor(n));
+ return _n >= self.length ? [self, empty()] : [take(self, _n), drop(self, _n)];
+});
+/**
+ * Splits this chunk into `n` equally sized chunks.
+ *
+ * @since 2.0.0
+ * @category splitting
+ */
+const split = exports.split = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => chunksOf(self, Math.ceil(self.length / Math.floor(n))));
+/**
+ * Splits this chunk on the first element that matches this predicate.
+ * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward.
+ *
+ * @category splitting
+ * @since 2.0.0
+ */
+const splitWhere = exports.splitWhere = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => {
+ let i = 0;
+ for (const a of toReadonlyArray(self)) {
+ if (predicate(a)) {
+ break;
+ } else {
+ i++;
+ }
+ }
+ return splitAt(self, i);
+});
+/**
+ * Returns every elements after the first.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const tail = self => self.length > 0 ? O.some(drop(self, 1)) : O.none();
+/**
+ * Returns every elements after the first.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.tail = tail;
+const tailNonEmpty = self => drop(self, 1);
+/**
+ * Takes the last `n` elements.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.tailNonEmpty = tailNonEmpty;
+const takeRight = exports.takeRight = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => drop(self, self.length - n));
+/**
+ * Takes all elements so long as the predicate returns true.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const takeWhile = exports.takeWhile = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => {
+ const out = [];
+ for (const a of toReadonlyArray(self)) {
+ if (predicate(a)) {
+ out.push(a);
+ } else {
+ break;
+ }
+ }
+ return unsafeFromArray(out);
+});
+/**
+ * Creates a Chunks of unique values, in order, from all given Chunks.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const union = exports.union = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => unsafeFromArray(RA.union(toReadonlyArray(self), toReadonlyArray(that))));
+/**
+ * Remove duplicates from an array, keeping the first occurrence of an element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const dedupe = self => unsafeFromArray(RA.dedupe(toReadonlyArray(self)));
+/**
+ * Deduplicates adjacent elements that are identical.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+exports.dedupe = dedupe;
+const dedupeAdjacent = self => unsafeFromArray(RA.dedupeAdjacent(self));
+/**
+ * Takes a `Chunk` of pairs and return two corresponding `Chunk`s.
+ *
+ * Note: The function is reverse of `zip`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+exports.dedupeAdjacent = dedupeAdjacent;
+const unzip = self => {
+ const [left, right] = RA.unzip(self);
+ return [unsafeFromArray(left), unsafeFromArray(right)];
+};
+/**
+ * Zips this chunk pointwise with the specified chunk using the specified combiner.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+exports.unzip = unzip;
+const zipWith = exports.zipWith = /*#__PURE__*/(0, _Function.dual)(3, (self, that, f) => unsafeFromArray(RA.zipWith(self, that, f)));
+/**
+ * Zips this chunk pointwise with the specified chunk.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = exports.zip = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => zipWith(self, that, (a, b) => [a, b]));
+/**
+ * Delete the element at the specified index, creating a new `Chunk`.
+ *
+ * @since 2.0.0
+ */
+const remove = exports.remove = /*#__PURE__*/(0, _Function.dual)(2, (self, i) => {
+ if (i < 0 || i >= self.length) return self;
+ return unsafeFromArray(RA.remove(toReadonlyArray(self), i));
+});
+/**
+ * @since 3.16.0
+ */
+const removeOption = exports.removeOption = /*#__PURE__*/(0, _Function.dual)(2, (self, i) => {
+ if (i < 0 || i >= self.length) return O.none();
+ return O.some(unsafeFromArray(RA.remove(toReadonlyArray(self), i)));
+});
+/**
+ * @since 2.0.0
+ */
+const modifyOption = exports.modifyOption = /*#__PURE__*/(0, _Function.dual)(3, (self, i, f) => {
+ if (i < 0 || i >= self.length) return O.none();
+ return O.some(unsafeFromArray(RA.modify(toReadonlyArray(self), i, f)));
+});
+/**
+ * Apply a function to the element at the specified index, creating a new `Chunk`,
+ * or returning the input if the index is out of bounds.
+ *
+ * @since 2.0.0
+ */
+const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(3, (self, i, f) => O.getOrElse(modifyOption(self, i, f), () => self));
+/**
+ * Change the element at the specified index, creating a new `Chunk`,
+ * or returning the input if the index is out of bounds.
+ *
+ * @since 2.0.0
+ */
+const replace = exports.replace = /*#__PURE__*/(0, _Function.dual)(3, (self, i, b) => modify(self, i, () => b));
+/**
+ * @since 2.0.0
+ */
+const replaceOption = exports.replaceOption = /*#__PURE__*/(0, _Function.dual)(3, (self, i, b) => modifyOption(self, i, () => b));
+/**
+ * Return a Chunk of length n with element i initialized with f(i).
+ *
+ * **Note**. `n` is normalized to an integer >= 1.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const makeBy = exports.makeBy = /*#__PURE__*/(0, _Function.dual)(2, (n, f) => fromIterable(RA.makeBy(n, f)));
+/**
+ * Create a non empty `Chunk` containing a range of integers, including both endpoints.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start + i) : of(start);
+// -------------------------------------------------------------------------------------
+// re-exports from ReadonlyArray
+// -------------------------------------------------------------------------------------
+/**
+ * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+exports.range = range;
+const contains = exports.contains = RA.contains;
+/**
+ * Returns a function that checks if a `Chunk` contains a given value using a provided `isEquivalent` function.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const containsWith = exports.containsWith = RA.containsWith;
+/**
+ * Returns the first element that satisfies the specified
+ * predicate, or `None` if no such element exists.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findFirst = exports.findFirst = RA.findFirst;
+/**
+ * Return the first index for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findFirstIndex = exports.findFirstIndex = RA.findFirstIndex;
+/**
+ * Find the last element for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findLast = exports.findLast = RA.findLast;
+/**
+ * Return the last index for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findLastIndex = exports.findLastIndex = RA.findLastIndex;
+/**
+ * Check if a predicate holds true for every `Chunk` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const every = exports.every = /*#__PURE__*/(0, _Function.dual)(2, (self, refinement) => RA.fromIterable(self).every(refinement));
+/**
+ * Check if a predicate holds true for some `Chunk` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const some = exports.some = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate) => RA.fromIterable(self).some(predicate));
+/**
+ * Joins the elements together with "sep" in the middle.
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+const join = exports.join = RA.join;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+const reduce = exports.reduce = RA.reduce;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+const reduceRight = exports.reduceRight = RA.reduceRight;
+/**
+ * Creates a `Chunk` of values not included in the other given `Chunk` using the provided `isEquivalent` function.
+ * The order and references of result values are determined by the first `Chunk`.
+ *
+ * @since 3.2.0
+ */
+const differenceWith = isEquivalent => {
+ return (0, _Function.dual)(2, (self, that) => unsafeFromArray(RA.differenceWith(isEquivalent)(that, self)));
+};
+/**
+ * Creates a `Chunk` of values not included in the other given `Chunk`.
+ * The order and references of result values are determined by the first `Chunk`.
+ *
+ * @since 3.2.0
+ */
+exports.differenceWith = differenceWith;
+const difference = exports.difference = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => unsafeFromArray(RA.difference(that, self)));
+//# sourceMappingURL=Chunk.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Clock.js b/backend/node_modules/effect/dist/cjs/Clock.js
new file mode 100644
index 0000000000000000000000000000000000000000..f21e5d45840a51fd7d8f2ae15638e8f539fdcc9c
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Clock.js
@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.sleep = exports.make = exports.currentTimeNanos = exports.currentTimeMillis = exports.clockWith = exports.ClockTypeId = exports.Clock = void 0;
+var internal = _interopRequireWildcard(require("./internal/clock.js"));
+var defaultServices = _interopRequireWildcard(require("./internal/defaultServices.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ClockTypeId = exports.ClockTypeId = internal.ClockTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = exports.make = internal.make;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const sleep = exports.sleep = defaultServices.sleep;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const currentTimeMillis = exports.currentTimeMillis = defaultServices.currentTimeMillis;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const currentTimeNanos = exports.currentTimeNanos = defaultServices.currentTimeNanos;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const clockWith = exports.clockWith = defaultServices.clockWith;
+/**
+ * @since 2.0.0
+ * @category context
+ */
+const Clock = exports.Clock = internal.clockTag;
+//# sourceMappingURL=Clock.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Clock.js.map b/backend/node_modules/effect/dist/cjs/Clock.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..ef23919c2988489acdf16be7c29ed9c2cdeb542c
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Clock.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Clock.js","names":["internal","_interopRequireWildcard","require","defaultServices","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ClockTypeId","exports","make","sleep","currentTimeMillis","currentTimeNanos","clockWith","Clock","clockTag"],"sources":["../../src/Clock.ts"],"sourcesContent":[null],"mappings":";;;;;;AAMA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,eAAA,GAAAF,uBAAA,CAAAC,OAAA;AAAgE,SAAAD,wBAAAG,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAL,uBAAA,YAAAA,CAAAG,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAEhE;;;;AAIO,MAAMkB,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAkBvB,QAAQ,CAACuB,WAAW;AA8D9D;;;;AAIO,MAAME,IAAI,GAAAD,OAAA,CAAAC,IAAA,GAAuBzB,QAAQ,CAACyB,IAAI;AAErD;;;;AAIO,MAAMC,KAAK,GAAAF,OAAA,CAAAE,KAAA,GAA8DvB,eAAe,CAACuB,KAAK;AAErG;;;;AAIO,MAAMC,iBAAiB,GAAAH,OAAA,CAAAG,iBAAA,GAA0BxB,eAAe,CAACwB,iBAAiB;AAEzF;;;;AAIO,MAAMC,gBAAgB,GAAAJ,OAAA,CAAAI,gBAAA,GAA0BzB,eAAe,CAACyB,gBAAgB;AAEvF;;;;AAIO,MAAMC,SAAS,GAAAL,OAAA,CAAAK,SAAA,GACpB1B,eAAe,CAAC0B,SAAS;AAE3B;;;;AAIO,MAAMC,KAAK,GAAAN,OAAA,CAAAM,KAAA,GAA8B9B,QAAQ,CAAC+B,QAAQ","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Config.js b/backend/node_modules/effect/dist/cjs/Config.js
new file mode 100644
index 0000000000000000000000000000000000000000..81e2d141ea04bdc355d44d57dd1127fe8a319030
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Config.js
@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zipWith = exports.zip = exports.withDescription = exports.withDefault = exports.validate = exports.url = exports.unwrap = exports.sync = exports.suspend = exports.succeed = exports.string = exports.secret = exports.repeat = exports.redacted = exports.primitive = exports.port = exports.orElseIf = exports.orElse = exports.option = exports.number = exports.nonEmptyString = exports.nested = exports.mapOrFail = exports.mapAttempt = exports.map = exports.logLevel = exports.literal = exports.isConfig = exports.integer = exports.hashSet = exports.hashMap = exports.fail = exports.duration = exports.date = exports.chunk = exports.branded = exports.boolean = exports.array = exports.all = exports.ConfigTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/config.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ConfigTypeId = exports.ConfigTypeId = internal.ConfigTypeId;
+/**
+ * Constructs a config from a tuple / struct / arguments of configs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = exports.all = internal.all;
+/**
+ * Constructs a config for an array of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const array = exports.array = internal.array;
+/**
+ * Constructs a config for a boolean value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const boolean = exports.boolean = internal.boolean;
+/**
+ * Constructs a config for a network port [1, 65535].
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+const port = exports.port = internal.port;
+/**
+ * Constructs a config for an URL value.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+const url = exports.url = internal.url;
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const chunk = exports.chunk = internal.chunk;
+/**
+ * Constructs a config for a date value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const date = exports.date = internal.date;
+/**
+ * Constructs a config that fails with the specified message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = exports.fail = internal.fail;
+/**
+ * Constructs a config for a float value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const number = exports.number = internal.number;
+/**
+ * Constructs a config for a integer value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const integer = exports.integer = internal.integer;
+/**
+ * Constructs a config for a literal value.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Config } from "effect"
+ *
+ * const config = Config.literal("http", "https")("PROTOCOL")
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const literal = exports.literal = internal.literal;
+/**
+ * Constructs a config for a `LogLevel` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const logLevel = exports.logLevel = internal.logLevel;
+/**
+ * Constructs a config for a duration value.
+ *
+ * @since 2.5.0
+ * @category constructors
+ */
+const duration = exports.duration = internal.duration;
+/**
+ * This function returns `true` if the specified value is an `Config` value,
+ * `false` otherwise.
+ *
+ * This function can be useful for checking the type of a value before
+ * attempting to operate on it as an `Config` value. For example, you could
+ * use `isConfig` to check the type of a value before using it as an
+ * argument to a function that expects an `Config` value.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isConfig = exports.isConfig = internal.isConfig;
+/**
+ * Returns a config whose structure is the same as this one, but which produces
+ * a different value, constructed using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = exports.map = internal.map;
+/**
+ * Returns a config whose structure is the same as this one, but which may
+ * produce a different value, constructed using the specified function, which
+ * may throw exceptions that will be translated into validation errors.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapAttempt = exports.mapAttempt = internal.mapAttempt;
+/**
+ * Returns a new config whose structure is the samea as this one, but which
+ * may produce a different value, constructed using the specified fallible
+ * function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapOrFail = exports.mapOrFail = internal.mapOrFail;
+/**
+ * Returns a config that has this configuration nested as a property of the
+ * specified name.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const nested = exports.nested = internal.nested;
+/**
+ * Returns a config whose structure is preferentially described by this
+ * config, but which falls back to the specified config if there is an issue
+ * reading from this config.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const orElse = exports.orElse = internal.orElse;
+/**
+ * Returns configuration which reads from this configuration, but which falls
+ * back to the specified configuration if reading from this configuration
+ * fails with an error satisfying the specified predicate.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const orElseIf = exports.orElseIf = internal.orElseIf;
+/**
+ * Returns an optional version of this config, which will be `None` if the
+ * data is missing from configuration, and `Some` otherwise.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const option = exports.option = internal.option;
+/**
+ * Constructs a new primitive config.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const primitive = exports.primitive = internal.primitive;
+/**
+ * Returns a config that describes a sequence of values, each of which has the
+ * structure of this config.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeat = exports.repeat = internal.repeat;
+/**
+ * Constructs a config for a secret value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ * @deprecated
+ */
+const secret = exports.secret = internal.secret;
+/**
+ * Constructs a config for a redacted value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const redacted = exports.redacted = internal.redacted;
+/**
+ * Constructs a config for a branded value.
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+const branded = exports.branded = internal.branded;
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashSet = exports.hashSet = internal.hashSet;
+/**
+ * Constructs a config for a string value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const string = exports.string = internal.string;
+/**
+ * Constructs a config for a non-empty string value.
+ *
+ * @since 3.7.0
+ * @category constructors
+ */
+const nonEmptyString = exports.nonEmptyString = internal.nonEmptyString;
+/**
+ * Constructs a config which contains the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = exports.succeed = internal.succeed;
+/**
+ * Lazily constructs a config.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = exports.suspend = internal.suspend;
+/**
+ * Constructs a config which contains the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = exports.sync = internal.sync;
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashMap = exports.hashMap = internal.hashMap;
+/**
+ * Constructs a config from some configuration wrapped with the `Wrap` utility type.
+ *
+ * For example:
+ *
+ * ```
+ * import { Config, unwrap } from "./Config"
+ *
+ * interface Options { key: string }
+ *
+ * const makeConfig = (config: Config.Wrap): Config => unwrap(config)
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = exports.unwrap = internal.unwrap;
+/**
+ * Returns a config that describes the same structure as this one, but which
+ * performs validation during loading.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const validate = exports.validate = internal.validate;
+/**
+ * Returns a config that describes the same structure as this one, but has the
+ * specified default value in case the information cannot be found.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const withDefault = exports.withDefault = internal.withDefault;
+/**
+ * Adds a description to this configuration, which is intended for humans.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const withDescription = exports.withDescription = internal.withDescription;
+/**
+ * Returns a config that is the composition of this config and the specified
+ * config.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = exports.zip = internal.zip;
+/**
+ * Returns a config that is the composes this config and the specified config
+ * using the provided function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = exports.zipWith = internal.zipWith;
+//# sourceMappingURL=Config.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Config.js.map b/backend/node_modules/effect/dist/cjs/Config.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..d56fccf44da19d73dd4d690ae7589dbfb85e63bb
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Config.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Config.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ConfigTypeId","exports","all","array","boolean","port","url","chunk","date","fail","number","integer","literal","logLevel","duration","isConfig","map","mapAttempt","mapOrFail","nested","orElse","orElseIf","option","primitive","repeat","secret","redacted","branded","hashSet","string","nonEmptyString","succeed","suspend","sync","hashMap","unwrap","validate","withDefault","withDescription","zip","zipWith"],"sources":["../../src/Config.ts"],"sourcesContent":[null],"mappings":";;;;;;AAYA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAgD,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAQhD;;;;AAIO,MAAMkB,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAkBtB,QAAQ,CAACsB,YAAY;AAwEhE;;;;;;AAMO,MAAME,GAAG,GAAAD,OAAA,CAAAC,GAAA,GAWZxB,QAAQ,CAACwB,GAAG;AAEhB;;;;;;AAMO,MAAMC,KAAK,GAAAF,OAAA,CAAAE,KAAA,GAA8DzB,QAAQ,CAACyB,KAAK;AAE9F;;;;;;AAMO,MAAMC,OAAO,GAAAH,OAAA,CAAAG,OAAA,GAAuC1B,QAAQ,CAAC0B,OAAO;AAE3E;;;;;;AAMO,MAAMC,IAAI,GAAAJ,OAAA,CAAAI,IAAA,GAAsC3B,QAAQ,CAAC2B,IAAI;AAEpE;;;;;;AAMO,MAAMC,GAAG,GAAAL,OAAA,CAAAK,GAAA,GAAmC5B,QAAQ,CAAC4B,GAAG;AAE/D;;;;;;AAMO,MAAMC,KAAK,GAAAN,OAAA,CAAAM,KAAA,GAAoE7B,QAAQ,CAAC6B,KAAK;AAEpG;;;;;;AAMO,MAAMC,IAAI,GAAAP,OAAA,CAAAO,IAAA,GAAoC9B,QAAQ,CAAC8B,IAAI;AAElE;;;;;;AAMO,MAAMC,IAAI,GAAAR,OAAA,CAAAQ,IAAA,GAAuC/B,QAAQ,CAAC+B,IAAI;AAErE;;;;;;AAMO,MAAMC,MAAM,GAAAT,OAAA,CAAAS,MAAA,GAAsChC,QAAQ,CAACgC,MAAM;AAExE;;;;;;AAMO,MAAMC,OAAO,GAAAV,OAAA,CAAAU,OAAA,GAAsCjC,QAAQ,CAACiC,OAAO;AAE1E;;;;;;;;;;;;;;AAcO,MAAMC,OAAO,GAAAX,OAAA,CAAAW,OAAA,GAEYlC,QAAQ,CAACkC,OAAO;AAEhD;;;;;;AAMO,MAAMC,QAAQ,GAAAZ,OAAA,CAAAY,QAAA,GAAiDnC,QAAQ,CAACmC,QAAQ;AAEvF;;;;;;AAMO,MAAMC,QAAQ,GAAAb,OAAA,CAAAa,QAAA,GAAiDpC,QAAQ,CAACoC,QAAQ;AAEvF;;;;;;;;;;;;AAYO,MAAMC,QAAQ,GAAAd,OAAA,CAAAc,QAAA,GAAyCrC,QAAQ,CAACqC,QAAQ;AAE/E;;;;;;;AAOO,MAAMC,GAAG,GAAAf,OAAA,CAAAe,GAAA,GAiBZtC,QAAQ,CAACsC,GAAG;AAEhB;;;;;;;;AAQO,MAAMC,UAAU,GAAAhB,OAAA,CAAAgB,UAAA,GAmBnBvC,QAAQ,CAACuC,UAAU;AAEvB;;;;;;;;AAQO,MAAMC,SAAS,GAAAjB,OAAA,CAAAiB,SAAA,GAmBlBxC,QAAQ,CAACwC,SAAS;AAEtB;;;;;;;AAOO,MAAMC,MAAM,GAAAlB,OAAA,CAAAkB,MAAA,GAiBfzC,QAAQ,CAACyC,MAAM;AAEnB;;;;;;;;AAQO,MAAMC,MAAM,GAAAnB,OAAA,CAAAmB,MAAA,GAmBf1C,QAAQ,CAAC0C,MAAM;AAEnB;;;;;;;;AAQO,MAAMC,QAAQ,GAAApB,OAAA,CAAAoB,QAAA,GA8BjB3C,QAAQ,CAAC2C,QAAQ;AAErB;;;;;;;AAOO,MAAMC,MAAM,GAAArB,OAAA,CAAAqB,MAAA,GAAqD5C,QAAQ,CAAC4C,MAAM;AAEvF;;;;;;AAMO,MAAMC,SAAS,GAAAtB,OAAA,CAAAsB,SAAA,GAGL7C,QAAQ,CAAC6C,SAAS;AAEnC;;;;;;;AAOO,MAAMC,MAAM,GAAAvB,OAAA,CAAAuB,MAAA,GAA6C9C,QAAQ,CAAC8C,MAAM;AAE/E;;;;;;;AAOO,MAAMC,MAAM,GAAAxB,OAAA,CAAAwB,MAAA,GAA6C/C,QAAQ,CAAC+C,MAAM;AAE/E;;;;;;AAMO,MAAMC,QAAQ,GAAAzB,OAAA,CAAAyB,QAAA,GAejBhD,QAAQ,CAACgD,QAAQ;AAErB;;;;;;AAMO,MAAMC,OAAO,GAAA1B,OAAA,CAAA0B,OAAA,GAsBhBjD,QAAQ,CAACiD,OAAO;AAEpB;;;;;;AAMO,MAAMC,OAAO,GAAA3B,OAAA,CAAA2B,OAAA,GAAwElD,QAAQ,CAACkD,OAAO;AAE5G;;;;;;AAMO,MAAMC,MAAM,GAAA5B,OAAA,CAAA4B,MAAA,GAAsCnD,QAAQ,CAACmD,MAAM;AAExE;;;;;;AAMO,MAAMC,cAAc,GAAA7B,OAAA,CAAA6B,cAAA,GAAsCpD,QAAQ,CAACoD,cAAc;AAExF;;;;;;AAMO,MAAMC,OAAO,GAAA9B,OAAA,CAAA8B,OAAA,GAA+BrD,QAAQ,CAACqD,OAAO;AAEnE;;;;;;AAMO,MAAMC,OAAO,GAAA/B,OAAA,CAAA+B,OAAA,GAAiDtD,QAAQ,CAACsD,OAAO;AAErF;;;;;;AAMO,MAAMC,IAAI,GAAAhC,OAAA,CAAAgC,IAAA,GAAwCvD,QAAQ,CAACuD,IAAI;AAEtE;;;;;;AAMO,MAAMC,OAAO,GAAAjC,OAAA,CAAAiC,OAAA,GAAgFxD,QAAQ,CAACwD,OAAO;AAEpH;;;;;;;;;;;;;;;;AAgBO,MAAMC,MAAM,GAAAlC,OAAA,CAAAkC,MAAA,GAA8CzD,QAAQ,CAACyD,MAAM;AAEhF;;;;;;;AAOO,MAAMC,QAAQ,GAAAnC,OAAA,CAAAmC,QAAA,GAuDjB1D,QAAQ,CAAC0D,QAAQ;AAErB;;;;;;;AAOO,MAAMC,WAAW,GAAApC,OAAA,CAAAoC,WAAA,GAiBpB3D,QAAQ,CAAC2D,WAAW;AAExB;;;;;;AAMO,MAAMC,eAAe,GAAArC,OAAA,CAAAqC,eAAA,GAexB5D,QAAQ,CAAC4D,eAAe;AAE5B;;;;;;;AAOO,MAAMC,GAAG,GAAAtC,OAAA,CAAAsC,GAAA,GAiBZ7D,QAAQ,CAAC6D,GAAG;AAEhB;;;;;;;AAOO,MAAMC,OAAO,GAAAvC,OAAA,CAAAuC,OAAA,GAiBhB9D,QAAQ,CAAC8D,OAAO","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ConfigError.js b/backend/node_modules/effect/dist/cjs/ConfigError.js
new file mode 100644
index 0000000000000000000000000000000000000000..576d9d01d2075924fe447cbaf85c6b023a58dcd4
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ConfigError.js
@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.reduceWithContext = exports.prefixed = exports.isUnsupported = exports.isSourceUnavailable = exports.isOr = exports.isMissingDataOnly = exports.isMissingData = exports.isInvalidData = exports.isConfigError = exports.isAnd = exports.Unsupported = exports.SourceUnavailable = exports.Or = exports.MissingData = exports.InvalidData = exports.ConfigErrorTypeId = exports.And = void 0;
+var internal = _interopRequireWildcard(require("./internal/configError.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ConfigErrorTypeId = exports.ConfigErrorTypeId = internal.ConfigErrorTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const And = exports.And = internal.And;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const Or = exports.Or = internal.Or;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const MissingData = exports.MissingData = internal.MissingData;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const InvalidData = exports.InvalidData = internal.InvalidData;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const SourceUnavailable = exports.SourceUnavailable = internal.SourceUnavailable;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const Unsupported = exports.Unsupported = internal.Unsupported;
+/**
+ * Returns `true` if the specified value is a `ConfigError`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isConfigError = exports.isConfigError = internal.isConfigError;
+/**
+ * Returns `true` if the specified `ConfigError` is an `And`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isAnd = exports.isAnd = internal.isAnd;
+/**
+ * Returns `true` if the specified `ConfigError` is an `Or`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isOr = exports.isOr = internal.isOr;
+/**
+ * Returns `true` if the specified `ConfigError` is an `InvalidData`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isInvalidData = exports.isInvalidData = internal.isInvalidData;
+/**
+ * Returns `true` if the specified `ConfigError` is an `MissingData`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isMissingData = exports.isMissingData = internal.isMissingData;
+/**
+ * Returns `true` if the specified `ConfigError` contains only `MissingData` errors, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @categer getters
+ */
+const isMissingDataOnly = exports.isMissingDataOnly = internal.isMissingDataOnly;
+/**
+ * Returns `true` if the specified `ConfigError` is a `SourceUnavailable`,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSourceUnavailable = exports.isSourceUnavailable = internal.isSourceUnavailable;
+/**
+ * Returns `true` if the specified `ConfigError` is an `Unsupported`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isUnsupported = exports.isUnsupported = internal.isUnsupported;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const prefixed = exports.prefixed = internal.prefixed;
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+const reduceWithContext = exports.reduceWithContext = internal.reduceWithContext;
+//# sourceMappingURL=ConfigError.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ConfigError.js.map b/backend/node_modules/effect/dist/cjs/ConfigError.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..3cc6cf6fc43bcc56d98b880111cd254aa3be8df8
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ConfigError.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ConfigError.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ConfigErrorTypeId","exports","And","Or","MissingData","InvalidData","SourceUnavailable","Unsupported","isConfigError","isAnd","isOr","isInvalidData","isMissingData","isMissingDataOnly","isSourceUnavailable","isUnsupported","prefixed","reduceWithContext"],"sources":["../../src/ConfigError.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ConfigProvider.js.map b/backend/node_modules/effect/dist/cjs/ConfigProvider.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..1d28e56f3d5dc8ce214d8790b30f383b7e5c204e
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ConfigProvider.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ConfigProvider.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ConfigProviderTypeId","exports","FlatConfigProviderTypeId","ConfigProvider","configProviderTag","make","makeFlat","fromEnv","fromFlat","fromJson","fromMap","constantCase","mapInputPath","kebabCase","lowerCase","nested","orElse","unnested","snakeCase","upperCase","within"],"sources":["../../src/ConfigProvider.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js b/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js
new file mode 100644
index 0000000000000000000000000000000000000000..92942e340c662406b4e640ec792f8dc9d532906f
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js
@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unnested = exports.nested = exports.mapName = exports.empty = exports.andThen = void 0;
+var internal = _interopRequireWildcard(require("./internal/configProvider/pathPatch.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = exports.empty = internal.empty;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const andThen = exports.andThen = internal.andThen;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const mapName = exports.mapName = internal.mapName;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const nested = exports.nested = internal.nested;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unnested = exports.unnested = internal.unnested;
+//# sourceMappingURL=ConfigProviderPathPatch.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js.map b/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..f385baf9931e08d5ab731dd1b9b17a187ea221d3
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ConfigProviderPathPatch.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ConfigProviderPathPatch.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","empty","exports","andThen","mapName","nested","unnested"],"sources":["../../src/ConfigProviderPathPatch.ts"],"sourcesContent":[null],"mappings":";;;;;;AAGA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAkE,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAHlE;;;;AA2DA;;;;AAIO,MAAMkB,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAActB,QAAQ,CAACsB,KAAK;AAE9C;;;;AAIO,MAAME,OAAO,GAAAD,OAAA,CAAAC,OAAA,GAWhBxB,QAAQ,CAACwB,OAAO;AAEpB;;;;AAIO,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAWhBzB,QAAQ,CAACyB,OAAO;AAEpB;;;;AAIO,MAAMC,MAAM,GAAAH,OAAA,CAAAG,MAAA,GAWf1B,QAAQ,CAAC0B,MAAM;AAEnB;;;;AAIO,MAAMC,QAAQ,GAAAJ,OAAA,CAAAI,QAAA,GAWjB3B,QAAQ,CAAC2B,QAAQ","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Console.js b/backend/node_modules/effect/dist/cjs/Console.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1508f182a1f3d86972746325386d01f54a972b8
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Console.js
@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.withTime = exports.withGroup = exports.withConsole = exports.warn = exports.trace = exports.timeLog = exports.time = exports.table = exports.setConsole = exports.log = exports.info = exports.group = exports.error = exports.dirxml = exports.dir = exports.debug = exports.countReset = exports.count = exports.consoleWith = exports.clear = exports.assert = exports.TypeId = exports.Console = void 0;
+var internal = _interopRequireWildcard(require("./internal/console.js"));
+var defaultConsole = _interopRequireWildcard(require("./internal/defaultServices/console.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+const TypeId = exports.TypeId = defaultConsole.TypeId;
+/**
+ * @since 2.0.0
+ * @category context
+ */
+const Console = exports.Console = defaultConsole.consoleTag;
+/**
+ * @since 2.0.0
+ * @category default services
+ */
+const withConsole = exports.withConsole = internal.withConsole;
+/**
+ * @since 2.0.0
+ * @category default services
+ */
+const setConsole = exports.setConsole = internal.setConsole;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const consoleWith = exports.consoleWith = internal.consoleWith;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const assert = exports.assert = internal.assert;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const clear = exports.clear = internal.clear;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const count = exports.count = internal.count;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const countReset = exports.countReset = internal.countReset;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const debug = exports.debug = internal.debug;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const dir = exports.dir = internal.dir;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const dirxml = exports.dirxml = internal.dirxml;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const error = exports.error = internal.error;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const group = exports.group = internal.group;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const info = exports.info = internal.info;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const log = exports.log = internal.log;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const table = exports.table = internal.table;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const time = exports.time = internal.time;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const timeLog = exports.timeLog = internal.timeLog;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const trace = exports.trace = internal.trace;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const warn = exports.warn = internal.warn;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const withGroup = exports.withGroup = internal.withGroup;
+/**
+ * @since 2.0.0
+ * @category accessor
+ */
+const withTime = exports.withTime = internal.withTime;
+//# sourceMappingURL=Console.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Console.js.map b/backend/node_modules/effect/dist/cjs/Console.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..7ea0283cdb8457a9b62338ae575f6e5bae5ec487
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Console.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Console.js","names":["internal","_interopRequireWildcard","require","defaultConsole","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","Console","consoleTag","withConsole","setConsole","consoleWith","assert","clear","count","countReset","debug","dir","dirxml","error","group","info","log","table","time","timeLog","trace","warn","withGroup","withTime"],"sources":["../../src/Console.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cron.js b/backend/node_modules/effect/dist/cjs/Cron.js
new file mode 100644
index 0000000000000000000000000000000000000000..a75db63226eab1ff5fa28a6375f827da23f36d1e
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cron.js
@@ -0,0 +1,679 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeParse = exports.sequenceReverse = exports.sequence = exports.prev = exports.parse = exports.next = exports.match = exports.make = exports.isParseError = exports.isCron = exports.equals = exports.TypeId = exports.ParseErrorTypeId = exports.ParseError = exports.Equivalence = void 0;
+var Arr = _interopRequireWildcard(require("./Array.js"));
+var Data = _interopRequireWildcard(require("./Data.js"));
+var Either = _interopRequireWildcard(require("./Either.js"));
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Inspectable = require("./Inspectable.js");
+var dateTime = _interopRequireWildcard(require("./internal/dateTime.js"));
+var N = _interopRequireWildcard(require("./Number.js"));
+var Option = _interopRequireWildcard(require("./Option.js"));
+var _Pipeable = require("./Pipeable.js");
+var _Predicate = require("./Predicate.js");
+var String = _interopRequireWildcard(require("./String.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/Cron");
+const CronProto = {
+ [TypeId]: TypeId,
+ [Equal.symbol](that) {
+ return isCron(that) && equals(this, that);
+ },
+ [Hash.symbol]() {
+ return (0, _Function.pipe)(Hash.hash(this.tz), Hash.combine(Hash.array(Arr.fromIterable(this.seconds))), Hash.combine(Hash.array(Arr.fromIterable(this.minutes))), Hash.combine(Hash.array(Arr.fromIterable(this.hours))), Hash.combine(Hash.array(Arr.fromIterable(this.days))), Hash.combine(Hash.array(Arr.fromIterable(this.months))), Hash.combine(Hash.array(Arr.fromIterable(this.weekdays))), Hash.cached(this));
+ },
+ toString() {
+ return (0, _Inspectable.format)(this.toJSON());
+ },
+ toJSON() {
+ return {
+ _id: "Cron",
+ tz: this.tz,
+ seconds: Arr.fromIterable(this.seconds),
+ minutes: Arr.fromIterable(this.minutes),
+ hours: Arr.fromIterable(this.hours),
+ days: Arr.fromIterable(this.days),
+ months: Arr.fromIterable(this.months),
+ weekdays: Arr.fromIterable(this.weekdays)
+ };
+ },
+ [_Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+/**
+ * Checks if a given value is a `Cron` instance.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+const isCron = u => (0, _Predicate.hasProperty)(u, TypeId);
+/**
+ * Creates a `Cron` instance.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.isCron = isCron;
+const make = values => {
+ const o = Object.create(CronProto);
+ o.seconds = new Set(Arr.sort(values.seconds ?? [0], N.Order));
+ o.minutes = new Set(Arr.sort(values.minutes, N.Order));
+ o.hours = new Set(Arr.sort(values.hours, N.Order));
+ o.days = new Set(Arr.sort(values.days, N.Order));
+ o.months = new Set(Arr.sort(values.months, N.Order));
+ o.weekdays = new Set(Arr.sort(values.weekdays, N.Order));
+ o.tz = Option.fromNullable(values.tz);
+ const seconds = Array.from(o.seconds);
+ const minutes = Array.from(o.minutes);
+ const hours = Array.from(o.hours);
+ const days = Array.from(o.days);
+ const months = Array.from(o.months);
+ const weekdays = Array.from(o.weekdays);
+ o.first = {
+ second: seconds[0] ?? 0,
+ minute: minutes[0] ?? 0,
+ hour: hours[0] ?? 0,
+ day: days[0] ?? 1,
+ month: (months[0] ?? 1) - 1,
+ weekday: weekdays[0] ?? 0
+ };
+ o.last = {
+ second: seconds[seconds.length - 1] ?? 59,
+ minute: minutes[minutes.length - 1] ?? 59,
+ hour: hours[hours.length - 1] ?? 23,
+ day: days[days.length - 1] ?? 31,
+ month: (months[months.length - 1] ?? 12) - 1,
+ weekday: weekdays[weekdays.length - 1] ?? 6
+ };
+ o.next = {
+ second: lookupTable(seconds, 60, "next"),
+ minute: lookupTable(minutes, 60, "next"),
+ hour: lookupTable(hours, 24, "next"),
+ day: lookupTable(days, 32, "next"),
+ month: lookupTable(months, 13, "next"),
+ weekday: lookupTable(weekdays, 7, "next")
+ };
+ o.prev = {
+ second: lookupTable(seconds, 60, "prev"),
+ minute: lookupTable(minutes, 60, "prev"),
+ hour: lookupTable(hours, 24, "prev"),
+ day: lookupTable(days, 32, "prev"),
+ month: lookupTable(months, 13, "prev"),
+ weekday: lookupTable(weekdays, 7, "prev")
+ };
+ return o;
+};
+exports.make = make;
+const lookupTable = (values, size, dir) => {
+ const result = new Array(size).fill(undefined);
+ if (values.length === 0) {
+ return result;
+ }
+ let current = undefined;
+ if (dir === "next") {
+ let index = values.length - 1;
+ for (let i = size - 1; i >= 0; i--) {
+ while (index >= 0 && values[index] >= i) {
+ current = values[index--];
+ }
+ result[i] = current;
+ }
+ } else {
+ let index = 0;
+ for (let i = 0; i < size; i++) {
+ while (index < values.length && values[index] <= i) {
+ current = values[index++];
+ }
+ result[i] = current;
+ }
+ }
+ return result;
+};
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+const ParseErrorTypeId = exports.ParseErrorTypeId = /*#__PURE__*/Symbol.for("effect/Cron/errors/ParseError");
+/**
+ * Represents a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+class ParseError extends /*#__PURE__*/Data.TaggedError("CronParseError") {
+ /**
+ * @since 2.0.0
+ */
+ [ParseErrorTypeId] = ParseErrorTypeId;
+}
+/**
+ * Returns `true` if the specified value is an `ParseError`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+exports.ParseError = ParseError;
+const isParseError = u => (0, _Predicate.hasProperty)(u, ParseErrorTypeId);
+/**
+ * Parses a cron expression into a `Cron` instance.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Cron, Either } from "effect"
+ *
+ * // At 04:00 on every day-of-month from 8 through 14.
+ * assert.deepStrictEqual(Cron.parse("0 0 4 8-14 * *"), Either.right(Cron.make({
+ * seconds: [0],
+ * minutes: [0],
+ * hours: [4],
+ * days: [8, 9, 10, 11, 12, 13, 14],
+ * months: [],
+ * weekdays: []
+ * })))
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.isParseError = isParseError;
+const parse = (cron, tz) => {
+ const segments = cron.split(" ").filter(String.isNonEmpty);
+ if (segments.length !== 5 && segments.length !== 6) {
+ return Either.left(new ParseError({
+ message: `Invalid number of segments in cron expression`,
+ input: cron
+ }));
+ }
+ if (segments.length === 5) {
+ segments.unshift("0");
+ }
+ const [seconds, minutes, hours, days, months, weekdays] = segments;
+ const zone = tz === undefined || dateTime.isTimeZone(tz) ? Either.right(tz) : Either.fromOption(dateTime.zoneFromString(tz), () => new ParseError({
+ message: `Invalid time zone in cron expression`,
+ input: tz
+ }));
+ return Either.all({
+ tz: zone,
+ seconds: parseSegment(seconds, secondOptions),
+ minutes: parseSegment(minutes, minuteOptions),
+ hours: parseSegment(hours, hourOptions),
+ days: parseSegment(days, dayOptions),
+ months: parseSegment(months, monthOptions),
+ weekdays: parseSegment(weekdays, weekdayOptions)
+ }).pipe(Either.map(make));
+};
+/**
+ * Parses a cron expression into a `Cron` instance.
+ *
+ * **Details**
+ *
+ * This function takes a cron expression as a string and attempts to parse it
+ * into a `Cron` instance. If the expression is valid, the resulting `Cron`
+ * instance will represent the schedule defined by the cron expression.
+ *
+ * If the expression is invalid, the function throws a `ParseError`.
+ *
+ * You can optionally provide a time zone (`tz`) to interpret the cron
+ * expression in a specific time zone. If no time zone is provided, the cron
+ * expression will use the default time zone.
+ *
+ * @example
+ * ```ts
+ * import { Cron } from "effect"
+ *
+ * // At 04:00 on every day-of-month from 8 through 14.
+ * console.log(Cron.unsafeParse("0 4 8-14 * *"))
+ * // Output:
+ * // {
+ * // _id: 'Cron',
+ * // tz: { _id: 'Option', _tag: 'None' },
+ * // seconds: [ 0 ],
+ * // minutes: [ 0 ],
+ * // hours: [ 4 ],
+ * // days: [
+ * // 8, 9, 10, 11,
+ * // 12, 13, 14
+ * // ],
+ * // months: [],
+ * // weekdays: []
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.parse = parse;
+const unsafeParse = (cron, tz) => Either.getOrThrowWith(parse(cron, tz), _Function.identity);
+/**
+ * Checks if a given `Date` falls within an active `Cron` time window.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Cron, Either } from "effect"
+ *
+ * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *"))
+ * assert.deepStrictEqual(Cron.match(cron, new Date("2021-01-08 04:00:00")), true)
+ * assert.deepStrictEqual(Cron.match(cron, new Date("2021-01-08 05:00:00")), false)
+ * ```
+ *
+ * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid.
+ *
+ * @since 2.0.0
+ */
+exports.unsafeParse = unsafeParse;
+const match = (cron, date) => {
+ const parts = dateTime.unsafeMakeZoned(date, {
+ timeZone: Option.getOrUndefined(cron.tz)
+ }).pipe(dateTime.toParts);
+ if (cron.seconds.size !== 0 && !cron.seconds.has(parts.seconds)) {
+ return false;
+ }
+ if (cron.minutes.size !== 0 && !cron.minutes.has(parts.minutes)) {
+ return false;
+ }
+ if (cron.hours.size !== 0 && !cron.hours.has(parts.hours)) {
+ return false;
+ }
+ if (cron.months.size !== 0 && !cron.months.has(parts.month)) {
+ return false;
+ }
+ if (cron.days.size === 0 && cron.weekdays.size === 0) {
+ return true;
+ }
+ if (cron.weekdays.size === 0) {
+ return cron.days.has(parts.day);
+ }
+ if (cron.days.size === 0) {
+ return cron.weekdays.has(parts.weekDay);
+ }
+ return cron.days.has(parts.day) || cron.weekdays.has(parts.weekDay);
+};
+exports.match = match;
+const daysInMonth = date => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 0)).getUTCDate();
+/**
+ * Returns the next run `Date` for the given `Cron` instance.
+ *
+ * Uses the current time as a starting point if no value is provided for `startFrom`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Cron, Either } from "effect"
+ *
+ * const after = new Date("2021-01-01 00:00:00")
+ * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *"))
+ * assert.deepStrictEqual(Cron.next(cron, after), new Date("2021-01-08 04:00:00"))
+ * ```
+ *
+ * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid.
+ * @throws `Error` if the next run date cannot be found within 10,000 iterations.
+ *
+ * @since 2.0.0
+ */
+const next = (cron, startFrom) => {
+ return stepCron(cron, startFrom, "next");
+};
+/**
+ * Returns the previous run `Date` for the given `Cron` instance.
+ *
+ * Uses the current time as a starting point if no value is provided for `startFrom`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Cron, Either } from "effect"
+ *
+ * const before = new Date("2021-01-15 00:00:00")
+ * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *"))
+ * assert.deepStrictEqual(Cron.prev(cron, before), new Date("2021-01-14 04:00:00"))
+ * ```
+ *
+ * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid.
+ * @throws `Error` if the previous run date cannot be found within 10,000 iterations.
+ *
+ * @since 3.20.0
+ */
+exports.next = next;
+const prev = (cron, startFrom) => {
+ return stepCron(cron, startFrom, "prev");
+};
+/** @internal */
+exports.prev = prev;
+const stepCron = (cron, startFrom, direction) => {
+ const tz = Option.getOrUndefined(cron.tz);
+ const zoned = dateTime.unsafeMakeZoned(startFrom ?? new Date(), {
+ timeZone: tz
+ });
+ const prev = direction === "prev";
+ const tick = prev ? -1 : 1;
+ const table = cron[direction];
+ const boundary = prev ? cron.last : cron.first;
+ const needsStep = prev ? (next, current) => next < current : (next, current) => next > current;
+ const utc = tz !== undefined && dateTime.isTimeZoneNamed(tz) && tz.id === "UTC";
+ const adjustDst = utc ? _Function.constVoid : current => {
+ const adjusted = dateTime.unsafeMakeZoned(current, {
+ timeZone: zoned.zone,
+ adjustForTimeZone: true,
+ disambiguation: prev ? "later" : undefined
+ }).pipe(dateTime.toDate);
+ const drift = current.getTime() - adjusted.getTime();
+ if (prev ? drift !== 0 : drift > 0) {
+ current.setTime(adjusted.getTime());
+ }
+ };
+ const result = dateTime.mutate(zoned, current => {
+ current.setUTCSeconds(current.getUTCSeconds() + tick, 0);
+ for (let i = 0; i < 10_000; i++) {
+ if (cron.seconds.size !== 0) {
+ const currentSecond = current.getUTCSeconds();
+ const nextSecond = table.second[currentSecond];
+ if (nextSecond === undefined) {
+ current.setUTCMinutes(current.getUTCMinutes() + tick, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ if (needsStep(nextSecond, currentSecond)) {
+ current.setUTCSeconds(nextSecond);
+ adjustDst(current);
+ continue;
+ }
+ }
+ if (cron.minutes.size !== 0) {
+ const currentMinute = current.getUTCMinutes();
+ const nextMinute = table.minute[currentMinute];
+ if (nextMinute === undefined) {
+ current.setUTCHours(current.getUTCHours() + tick, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ if (needsStep(nextMinute, currentMinute)) {
+ current.setUTCMinutes(nextMinute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ }
+ if (cron.hours.size !== 0) {
+ const currentHour = current.getUTCHours();
+ const nextHour = table.hour[currentHour];
+ if (nextHour === undefined) {
+ current.setUTCDate(current.getUTCDate() + tick);
+ current.setUTCHours(boundary.hour, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ if (needsStep(nextHour, currentHour)) {
+ current.setUTCHours(nextHour, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ }
+ if (cron.weekdays.size !== 0 || cron.days.size !== 0) {
+ let a = prev ? -Infinity : Infinity;
+ let b = prev ? -Infinity : Infinity;
+ if (cron.weekdays.size !== 0) {
+ const currentWeekday = current.getUTCDay();
+ const nextWeekday = table.weekday[currentWeekday];
+ if (nextWeekday === undefined) {
+ a = prev ? currentWeekday - 7 + boundary.weekday : 7 - currentWeekday + boundary.weekday;
+ } else {
+ a = nextWeekday - currentWeekday;
+ }
+ }
+ // Only check day-of-month if weekday constraint not already satisfied (they're OR'd)
+ if (cron.days.size !== 0 && a !== 0) {
+ const currentDay = current.getUTCDate();
+ const nextDay = table.day[currentDay];
+ if (nextDay === undefined) {
+ if (prev) {
+ // When wrapping to previous month, calculate days back:
+ // Current day offset + gap from end of prev month to target day
+ // Example: June 3 → May 20 with boundary.day=20: -(3 + (31 - 20)) = -14
+ const prevMonthDays = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), 0)));
+ b = -(currentDay + (prevMonthDays - boundary.day));
+ } else {
+ b = daysInMonth(current) - currentDay + boundary.day;
+ }
+ } else {
+ b = nextDay - currentDay;
+ }
+ }
+ const addDays = prev ? Math.max(a, b) : Math.min(a, b);
+ if (addDays !== 0) {
+ current.setUTCDate(current.getUTCDate() + addDays);
+ current.setUTCHours(boundary.hour, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ }
+ if (cron.months.size !== 0) {
+ const currentMonth = current.getUTCMonth() + 1;
+ const nextMonth = table.month[currentMonth];
+ const clampBoundaryDay = targetMonthIndex => {
+ if (cron.days.size !== 0) {
+ return boundary.day;
+ }
+ const maxDayInMonth = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), targetMonthIndex, 1)));
+ return Math.min(boundary.day, maxDayInMonth);
+ };
+ if (nextMonth === undefined) {
+ current.setUTCFullYear(current.getUTCFullYear() + tick);
+ current.setUTCMonth(boundary.month, clampBoundaryDay(boundary.month));
+ current.setUTCHours(boundary.hour, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ if (needsStep(nextMonth, currentMonth)) {
+ const targetMonthIndex = nextMonth - 1;
+ current.setUTCMonth(targetMonthIndex, clampBoundaryDay(targetMonthIndex));
+ current.setUTCHours(boundary.hour, boundary.minute, boundary.second);
+ adjustDst(current);
+ continue;
+ }
+ }
+ return;
+ }
+ throw new Error("Unable to find next cron date");
+ });
+ return dateTime.toDateUtc(result);
+};
+/**
+ * Returns an `IterableIterator` which yields the sequence of `Date`s that match the `Cron` instance.
+ *
+ * @since 2.0.0
+ */
+const sequence = function* (cron, startFrom) {
+ while (true) {
+ yield startFrom = next(cron, startFrom);
+ }
+};
+/**
+ * Returns an `IterableIterator` which yields the sequence of `Date`s that match the `Cron` instance,
+ * in reverse direction.
+ *
+ * @since 3.20.0
+ */
+exports.sequence = sequence;
+const sequenceReverse = function* (cron, startFrom) {
+ while (true) {
+ yield startFrom = prev(cron, startFrom);
+ }
+};
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+exports.sequenceReverse = sequenceReverse;
+const Equivalence = exports.Equivalence = /*#__PURE__*/equivalence.make((self, that) => restrictionsEquals(self.seconds, that.seconds) && restrictionsEquals(self.minutes, that.minutes) && restrictionsEquals(self.hours, that.hours) && restrictionsEquals(self.days, that.days) && restrictionsEquals(self.months, that.months) && restrictionsEquals(self.weekdays, that.weekdays));
+const restrictionsArrayEquals = /*#__PURE__*/equivalence.array(equivalence.number);
+const restrictionsEquals = (self, that) => restrictionsArrayEquals(Arr.fromIterable(self), Arr.fromIterable(that));
+/**
+ * Checks if two `Cron`s are equal.
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+const equals = exports.equals = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => Equivalence(self, that));
+const secondOptions = {
+ min: 0,
+ max: 59
+};
+const minuteOptions = {
+ min: 0,
+ max: 59
+};
+const hourOptions = {
+ min: 0,
+ max: 23
+};
+const dayOptions = {
+ min: 1,
+ max: 31
+};
+const monthOptions = {
+ min: 1,
+ max: 12,
+ aliases: {
+ jan: 1,
+ feb: 2,
+ mar: 3,
+ apr: 4,
+ may: 5,
+ jun: 6,
+ jul: 7,
+ aug: 8,
+ sep: 9,
+ oct: 10,
+ nov: 11,
+ dec: 12
+ }
+};
+const weekdayOptions = {
+ min: 0,
+ max: 6,
+ aliases: {
+ sun: 0,
+ mon: 1,
+ tue: 2,
+ wed: 3,
+ thu: 4,
+ fri: 5,
+ sat: 6
+ }
+};
+const parseSegment = (input, options) => {
+ const capacity = options.max - options.min + 1;
+ const values = new Set();
+ const fields = input.split(",");
+ for (const field of fields) {
+ const [raw, step] = splitStep(field);
+ if (raw === "*" && step === undefined) {
+ return Either.right(new Set());
+ }
+ if (step !== undefined) {
+ if (!Number.isInteger(step)) {
+ return Either.left(new ParseError({
+ message: `Expected step value to be a positive integer`,
+ input
+ }));
+ }
+ if (step < 1) {
+ return Either.left(new ParseError({
+ message: `Expected step value to be greater than 0`,
+ input
+ }));
+ }
+ if (step > options.max) {
+ return Either.left(new ParseError({
+ message: `Expected step value to be less than ${options.max}`,
+ input
+ }));
+ }
+ }
+ if (raw === "*") {
+ for (let i = options.min; i <= options.max; i += step ?? 1) {
+ values.add(i);
+ }
+ } else {
+ const [left, right] = splitRange(raw, options.aliases);
+ if (!Number.isInteger(left)) {
+ return Either.left(new ParseError({
+ message: `Expected a positive integer`,
+ input
+ }));
+ }
+ if (left < options.min || left > options.max) {
+ return Either.left(new ParseError({
+ message: `Expected a value between ${options.min} and ${options.max}`,
+ input
+ }));
+ }
+ if (right === undefined) {
+ values.add(left);
+ } else {
+ if (!Number.isInteger(right)) {
+ return Either.left(new ParseError({
+ message: `Expected a positive integer`,
+ input
+ }));
+ }
+ if (right < options.min || right > options.max) {
+ return Either.left(new ParseError({
+ message: `Expected a value between ${options.min} and ${options.max}`,
+ input
+ }));
+ }
+ if (left > right) {
+ return Either.left(new ParseError({
+ message: `Invalid value range`,
+ input
+ }));
+ }
+ for (let i = left; i <= right; i += step ?? 1) {
+ values.add(i);
+ }
+ }
+ }
+ if (values.size >= capacity) {
+ return Either.right(new Set());
+ }
+ }
+ return Either.right(values);
+};
+const splitStep = input => {
+ const seperator = input.indexOf("/");
+ if (seperator !== -1) {
+ return [input.slice(0, seperator), Number(input.slice(seperator + 1))];
+ }
+ return [input, undefined];
+};
+const splitRange = (input, aliases) => {
+ const seperator = input.indexOf("-");
+ if (seperator !== -1) {
+ return [aliasOrValue(input.slice(0, seperator), aliases), aliasOrValue(input.slice(seperator + 1), aliases)];
+ }
+ return [aliasOrValue(input, aliases), undefined];
+};
+function aliasOrValue(field, aliases) {
+ return aliases?.[field.toLocaleLowerCase()] ?? Number(field);
+}
+//# sourceMappingURL=Cron.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Cron.js.map b/backend/node_modules/effect/dist/cjs/Cron.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..3e7d0a8ff84a794f5978b2b20872073cf8e76c91
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Cron.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Cron.js","names":["Arr","_interopRequireWildcard","require","Data","Either","Equal","equivalence","_Function","Hash","_Inspectable","dateTime","N","Option","_Pipeable","_Predicate","String","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","Symbol","for","CronProto","symbol","that","isCron","equals","pipe","hash","tz","combine","array","fromIterable","seconds","minutes","hours","days","months","weekdays","cached","toString","format","toJSON","_id","NodeInspectSymbol","pipeArguments","arguments","u","hasProperty","make","values","create","Set","sort","Order","fromNullable","Array","from","first","second","minute","hour","day","month","weekday","last","length","next","lookupTable","prev","size","dir","result","fill","undefined","current","index","ParseErrorTypeId","ParseError","TaggedError","isParseError","parse","cron","segments","split","filter","isNonEmpty","left","message","input","unshift","zone","isTimeZone","right","fromOption","zoneFromString","all","parseSegment","secondOptions","minuteOptions","hourOptions","dayOptions","monthOptions","weekdayOptions","map","unsafeParse","getOrThrowWith","identity","match","date","parts","unsafeMakeZoned","timeZone","getOrUndefined","toParts","weekDay","daysInMonth","Date","UTC","getUTCFullYear","getUTCMonth","getUTCDate","startFrom","stepCron","direction","zoned","tick","table","boundary","needsStep","utc","isTimeZoneNamed","id","adjustDst","constVoid","adjusted","adjustForTimeZone","disambiguation","toDate","drift","getTime","setTime","mutate","setUTCSeconds","getUTCSeconds","currentSecond","nextSecond","setUTCMinutes","getUTCMinutes","currentMinute","nextMinute","setUTCHours","getUTCHours","currentHour","nextHour","setUTCDate","a","Infinity","b","currentWeekday","getUTCDay","nextWeekday","currentDay","nextDay","prevMonthDays","addDays","Math","max","min","currentMonth","nextMonth","clampBoundaryDay","targetMonthIndex","maxDayInMonth","setUTCFullYear","setUTCMonth","Error","toDateUtc","sequence","sequenceReverse","Equivalence","self","restrictionsEquals","restrictionsArrayEquals","number","dual","aliases","jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec","sun","mon","tue","wed","thu","fri","sat","options","capacity","fields","field","raw","step","splitStep","Number","isInteger","add","splitRange","seperator","indexOf","slice","aliasOrValue","toLocaleLowerCase"],"sources":["../../src/Cron.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Data.js b/backend/node_modules/effect/dist/cjs/Data.js
new file mode 100644
index 0000000000000000000000000000000000000000..e74ffee42cff5dab31f8c21b32d5ef6107f27204
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Data.js
@@ -0,0 +1,291 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeStruct = exports.unsafeArray = exports.tuple = exports.taggedEnum = exports.tagged = exports.struct = exports.case = exports.array = exports.TaggedError = exports.TaggedClass = exports.Structural = exports.Error = exports.Class = void 0;
+var core = _interopRequireWildcard(require("./internal/core.js"));
+var internal = _interopRequireWildcard(require("./internal/data.js"));
+var _effectable = require("./internal/effectable.js");
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data, Equal } from "effect"
+ *
+ * const alice = Data.struct({ name: "Alice", age: 30 })
+ *
+ * const bob = Data.struct({ name: "Bob", age: 40 })
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, alice), true)
+ * assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false)
+ * assert.deepStrictEqual(Equal.equals(alice, bob), false)
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const struct = exports.struct = internal.struct;
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+const unsafeStruct = as => Object.setPrototypeOf(as, _effectable.StructuralPrototype);
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data, Equal } from "effect"
+ *
+ * const alice = Data.tuple("Alice", 30)
+ *
+ * const bob = Data.tuple("Bob", 40)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, alice), true)
+ * assert.deepStrictEqual(Equal.equals(alice, Data.tuple("Alice", 30)), true)
+ *
+ * assert.deepStrictEqual(Equal.equals(alice, ["Alice", 30]), false)
+ * assert.deepStrictEqual(Equal.equals(alice, bob), false)
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.unsafeStruct = unsafeStruct;
+const tuple = (...as) => unsafeArray(as);
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data, Equal } from "effect"
+ *
+ * const alice = Data.struct({ name: "Alice", age: 30 })
+ * const bob = Data.struct({ name: "Bob", age: 40 })
+ *
+ * const persons = Data.array([alice, bob])
+ *
+ * assert.deepStrictEqual(
+ * Equal.equals(
+ * persons,
+ * Data.array([
+ * Data.struct({ name: "Alice", age: 30 }),
+ * Data.struct({ name: "Bob", age: 40 })
+ * ])
+ * ),
+ * true
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.tuple = tuple;
+const array = as => unsafeArray(as.slice(0));
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.array = array;
+const unsafeArray = as => Object.setPrototypeOf(as, internal.ArrayProto);
+exports.unsafeArray = unsafeArray;
+const _case = () => args => args === undefined ? Object.create(_effectable.StructuralPrototype) : struct(args);
+exports.case = _case;
+/**
+ * Provides a tagged constructor for the specified `Case`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data } from "effect"
+ *
+ * interface Person {
+ * readonly _tag: "Person" // the tag
+ * readonly name: string
+ * }
+ *
+ * const Person = Data.tagged("Person")
+ *
+ * const mike = Person({ name: "Mike" })
+ *
+ * assert.deepEqual(mike, { _tag: "Person", name: "Mike" })
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const tagged = tag => args => {
+ const value = args === undefined ? Object.create(_effectable.StructuralPrototype) : struct(args);
+ value._tag = tag;
+ return value;
+};
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data, Equal } from "effect"
+ *
+ * class Person extends Data.Class<{ readonly name: string }> {}
+ *
+ * // Creating instances of Person
+ * const mike1 = new Person({ name: "Mike" })
+ * const mike2 = new Person({ name: "Mike" })
+ * const john = new Person({ name: "John" })
+ *
+ * // Checking equality
+ * assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
+ * assert.deepStrictEqual(Equal.equals(mike1, john), false)
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.tagged = tagged;
+const Class = exports.Class = internal.Structural;
+/**
+ * Provides a Tagged constructor for a Case Class.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Data, Equal } from "effect"
+ *
+ * class Person extends Data.TaggedClass("Person")<{ readonly name: string }> {}
+ *
+ * // Creating instances of Person
+ * const mike1 = new Person({ name: "Mike" })
+ * const mike2 = new Person({ name: "Mike" })
+ * const john = new Person({ name: "John" })
+ *
+ * // Checking equality
+ * assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
+ * assert.deepStrictEqual(Equal.equals(mike1, john), false)
+ *
+ * assert.deepStrictEqual(mike1._tag, "Person")
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const TaggedClass = tag => {
+ class Base extends Class {
+ _tag = tag;
+ }
+ return Base;
+};
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.TaggedClass = TaggedClass;
+const Structural = exports.Structural = internal.Structural;
+/**
+ * Create a constructor for a tagged union of `Data` structs.
+ *
+ * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to
+ * the constructor.
+ *
+ * @example
+ * ```ts
+ * import { Data } from "effect"
+ *
+ * const { BadRequest, NotFound } = Data.taggedEnum<
+ * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string }
+ * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string }
+ * >()
+ *
+ * const notFound = NotFound({ status: 404, message: "Not Found" })
+ * ```
+ *
+ * @example
+ * import { Data } from "effect"
+ *
+ * type MyResult = Data.TaggedEnum<{
+ * Failure: { readonly error: E }
+ * Success: { readonly value: A }
+ * }>
+ * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
+ * readonly taggedEnum: MyResult
+ * }
+ * const { Failure, Success } = Data.taggedEnum()
+ *
+ * const success = Success({ value: 1 })
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const taggedEnum = () => new Proxy({}, {
+ get(_target, tag, _receiver) {
+ if (tag === "$is") {
+ return Predicate.isTagged;
+ } else if (tag === "$match") {
+ return taggedMatch;
+ }
+ return tagged(tag);
+ }
+});
+exports.taggedEnum = taggedEnum;
+function taggedMatch() {
+ if (arguments.length === 1) {
+ const cases = arguments[0];
+ return function (value) {
+ return cases[value._tag](value);
+ };
+ }
+ const value = arguments[0];
+ const cases = arguments[1];
+ return cases[value._tag](value);
+}
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const Error = exports.Error = /*#__PURE__*/function () {
+ const plainArgsSymbol = /*#__PURE__*/Symbol.for("effect/Data/Error/plainArgs");
+ const O = {
+ BaseEffectError: class extends core.YieldableError {
+ constructor(args) {
+ super(args?.message, args?.cause ? {
+ cause: args.cause
+ } : undefined);
+ if (args) {
+ Object.assign(this, args);
+ // @effect-diagnostics-next-line floatingEffect:off
+ Object.defineProperty(this, plainArgsSymbol, {
+ value: args,
+ enumerable: false
+ });
+ }
+ }
+ toJSON() {
+ return {
+ ...this[plainArgsSymbol],
+ ...this
+ };
+ }
+ }
+ };
+ return O.BaseEffectError;
+}();
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const TaggedError = tag => {
+ const O = {
+ BaseEffectError: class extends Error {
+ _tag = tag;
+ }
+ };
+ O.BaseEffectError.prototype.name = tag;
+ return O.BaseEffectError;
+};
+exports.TaggedError = TaggedError;
+//# sourceMappingURL=Data.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Data.js.map b/backend/node_modules/effect/dist/cjs/Data.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..049c415bb5cb4176e674acb95994fad20e3289a1
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Data.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Data.js","names":["core","_interopRequireWildcard","require","internal","_effectable","Predicate","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","struct","exports","unsafeStruct","as","setPrototypeOf","StructuralPrototype","tuple","unsafeArray","array","slice","ArrayProto","_case","args","undefined","create","case","tagged","tag","value","_tag","Class","Structural","TaggedClass","Base","taggedEnum","Proxy","_target","_receiver","isTagged","taggedMatch","arguments","length","cases","Error","plainArgsSymbol","Symbol","for","O","BaseEffectError","YieldableError","constructor","message","cause","assign","enumerable","toJSON","TaggedError","prototype","name"],"sources":["../../src/Data.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/DateTime.js b/backend/node_modules/effect/dist/cjs/DateTime.js
new file mode 100644
index 0000000000000000000000000000000000000000..b86f6391230f5964950c9fdc3f10618936b901a6
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/DateTime.js
@@ -0,0 +1,1084 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zonedOffsetIso = exports.zonedOffset = exports.zoneUnsafeMakeNamed = exports.zoneToString = exports.zoneMakeOffset = exports.zoneMakeNamedEffect = exports.zoneMakeNamed = exports.zoneMakeLocal = exports.zoneFromString = exports.withDateUtc = exports.withDate = exports.withCurrentZoneOffset = exports.withCurrentZoneNamed = exports.withCurrentZoneLocal = exports.withCurrentZone = exports.unsafeSetZoneNamed = exports.unsafeNow = exports.unsafeMakeZoned = exports.unsafeMake = exports.unsafeIsPast = exports.unsafeIsFuture = exports.unsafeFromDate = exports.toUtc = exports.toPartsUtc = exports.toParts = exports.toEpochMillis = exports.toDateUtc = exports.toDate = exports.subtractDuration = exports.subtract = exports.startOf = exports.setZoneOffset = exports.setZoneNamed = exports.setZoneCurrent = exports.setZone = exports.setPartsUtc = exports.setParts = exports.removeTime = exports.nowInCurrentZone = exports.nowAsDate = exports.now = exports.nearest = exports.mutateUtc = exports.mutate = exports.min = exports.max = exports.match = exports.mapEpochMillis = exports.makeZonedFromString = exports.makeZoned = exports.make = exports.lessThanOrEqualTo = exports.lessThan = exports.layerCurrentZoneOffset = exports.layerCurrentZoneNamed = exports.layerCurrentZoneLocal = exports.layerCurrentZone = exports.isZoned = exports.isUtc = exports.isTimeZoneOffset = exports.isTimeZoneNamed = exports.isTimeZone = exports.isPast = exports.isFuture = exports.isDateTime = exports.greaterThanOrEqualTo = exports.greaterThan = exports.getPartUtc = exports.getPart = exports.formatUtc = exports.formatLocal = exports.formatIsoZoned = exports.formatIsoOffset = exports.formatIsoDateUtc = exports.formatIsoDate = exports.formatIso = exports.formatIntl = exports.format = exports.endOf = exports.distanceDurationEither = exports.distanceDuration = exports.distance = exports.clamp = exports.between = exports.addDuration = exports.add = exports.TypeId = exports.TimeZoneTypeId = exports.Order = exports.Equivalence = exports.CurrentTimeZone = void 0;
+var Context = _interopRequireWildcard(require("./Context.js"));
+var Effect = _interopRequireWildcard(require("./Effect.js"));
+var _Function = require("./Function.js");
+var Internal = _interopRequireWildcard(require("./internal/dateTime.js"));
+var Layer = _interopRequireWildcard(require("./Layer.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 3.6.0
+ * @category type ids
+ */
+const TypeId = exports.TypeId = Internal.TypeId;
+/**
+ * @since 3.6.0
+ * @category type ids
+ */
+const TimeZoneTypeId = exports.TimeZoneTypeId = Internal.TimeZoneTypeId;
+// =============================================================================
+// guards
+// =============================================================================
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isDateTime = exports.isDateTime = Internal.isDateTime;
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isTimeZone = exports.isTimeZone = Internal.isTimeZone;
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isTimeZoneOffset = exports.isTimeZoneOffset = Internal.isTimeZoneOffset;
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isTimeZoneNamed = exports.isTimeZoneNamed = Internal.isTimeZoneNamed;
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isUtc = exports.isUtc = Internal.isUtc;
+/**
+ * @since 3.6.0
+ * @category guards
+ */
+const isZoned = exports.isZoned = Internal.isZoned;
+// =============================================================================
+// instances
+// =============================================================================
+/**
+ * @since 3.6.0
+ * @category instances
+ */
+const Equivalence = exports.Equivalence = Internal.Equivalence;
+/**
+ * @since 3.6.0
+ * @category instances
+ */
+const Order = exports.Order = Internal.Order;
+/**
+ * @since 3.6.0
+ */
+const clamp = exports.clamp = Internal.clamp;
+// =============================================================================
+// constructors
+// =============================================================================
+/**
+ * Create a `DateTime` from a `Date`.
+ *
+ * If the `Date` is invalid, an `IllegalArgumentException` will be thrown.
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+const unsafeFromDate = exports.unsafeFromDate = Internal.unsafeFromDate;
+/**
+ * Create a `DateTime` from one of the following:
+ *
+ * - A `DateTime`
+ * - A `Date` instance (invalid dates will throw an `IllegalArgumentException`)
+ * - The `number` of milliseconds since the Unix epoch
+ * - An object with the parts of a date
+ * - A `string` that can be parsed by `Date.parse`
+ *
+ * @since 3.6.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // from Date
+ * DateTime.unsafeMake(new Date())
+ *
+ * // from parts
+ * DateTime.unsafeMake({ year: 2024 })
+ *
+ * // from string
+ * DateTime.unsafeMake("2024-01-01")
+ * ```
+ */
+const unsafeMake = exports.unsafeMake = Internal.unsafeMake;
+/**
+ * Create a `DateTime.Zoned` using `DateTime.unsafeMake` and a time zone.
+ *
+ * The input is treated as UTC and then the time zone is attached, unless
+ * `adjustForTimeZone` is set to `true`. In that case, the input is treated as
+ * already in the time zone.
+ *
+ * When `adjustForTimeZone` is true and ambiguous times occur during DST transitions,
+ * the `disambiguation` option controls how to resolve the ambiguity:
+ * - `compatible` (default): Choose earlier time for repeated times, later for gaps
+ * - `earlier`: Always choose the earlier of two possible times
+ * - `later`: Always choose the later of two possible times
+ * - `reject`: Throw an error when ambiguous times are encountered
+ *
+ * @since 3.6.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * DateTime.unsafeMakeZoned(new Date(), { timeZone: "Europe/London" })
+ * ```
+ */
+const unsafeMakeZoned = exports.unsafeMakeZoned = Internal.unsafeMakeZoned;
+/**
+ * Create a `DateTime.Zoned` using `DateTime.make` and a time zone.
+ *
+ * The input is treated as UTC and then the time zone is attached, unless
+ * `adjustForTimeZone` is set to `true`. In that case, the input is treated as
+ * already in the time zone.
+ *
+ * When `adjustForTimeZone` is true and ambiguous times occur during DST transitions,
+ * the `disambiguation` option controls how to resolve the ambiguity:
+ * - `compatible` (default): Choose earlier time for repeated times, later for gaps
+ * - `earlier`: Always choose the earlier of two possible times
+ * - `later`: Always choose the later of two possible times
+ * - `reject`: Throw an error when ambiguous times are encountered
+ *
+ * If the date time input or time zone is invalid, `None` will be returned.
+ *
+ * @since 3.6.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * DateTime.makeZoned(new Date(), { timeZone: "Europe/London" })
+ * ```
+ */
+const makeZoned = exports.makeZoned = Internal.makeZoned;
+/**
+ * Create a `DateTime` from one of the following:
+ *
+ * - A `DateTime`
+ * - A `Date` instance (invalid dates will throw an `IllegalArgumentException`)
+ * - The `number` of milliseconds since the Unix epoch
+ * - An object with the parts of a date
+ * - A `string` that can be parsed by `Date.parse`
+ *
+ * If the input is invalid, `None` will be returned.
+ *
+ * @since 3.6.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // from Date
+ * DateTime.make(new Date())
+ *
+ * // from parts
+ * DateTime.make({ year: 2024 })
+ *
+ * // from string
+ * DateTime.make("2024-01-01")
+ * ```
+ */
+const make = exports.make = Internal.make;
+/**
+ * Create a `DateTime.Zoned` from a string.
+ *
+ * It uses the format: `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`.
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+const makeZonedFromString = exports.makeZonedFromString = Internal.makeZonedFromString;
+/**
+ * Get the current time using the `Clock` service and convert it to a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * })
+ * ```
+ */
+const now = exports.now = Internal.now;
+/**
+ * Get the current time using the `Clock` service.
+ *
+ * @since 3.14.0
+ * @category constructors
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.nowAsDate
+ * })
+ * ```
+ */
+const nowAsDate = exports.nowAsDate = Internal.nowAsDate;
+/**
+ * Get the current time using `Date.now`.
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+const unsafeNow = exports.unsafeNow = Internal.unsafeNow;
+// =============================================================================
+// time zones
+// =============================================================================
+/**
+ * For a `DateTime` returns a new `DateTime.Utc`.
+ *
+ * @since 3.13.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
+ *
+ * // set as UTC
+ * const utc: DateTime.Utc = DateTime.toUtc(now)
+ * ```
+ */
+const toUtc = exports.toUtc = Internal.toUtc;
+/**
+ * Set the time zone of a `DateTime`, returning a new `DateTime.Zoned`.
+ *
+ * @since 3.6.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
+ *
+ * // set the time zone
+ * const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
+ * })
+ * ```
+ */
+const setZone = exports.setZone = Internal.setZone;
+/**
+ * Add a fixed offset time zone to a `DateTime`.
+ *
+ * The offset is in milliseconds.
+ *
+ * @since 3.6.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ *
+ * // set the offset time zone in milliseconds
+ * const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
+ * })
+ * ```
+ */
+const setZoneOffset = exports.setZoneOffset = Internal.setZoneOffset;
+/**
+ * Attempt to create a named time zone from a IANA time zone identifier.
+ *
+ * If the time zone is invalid, an `IllegalArgumentException` will be thrown.
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneUnsafeMakeNamed = exports.zoneUnsafeMakeNamed = Internal.zoneUnsafeMakeNamed;
+/**
+ * Create a fixed offset time zone.
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneMakeOffset = exports.zoneMakeOffset = Internal.zoneMakeOffset;
+/**
+ * Create a named time zone from a IANA time zone identifier. If the time zone
+ * is invalid, `None` will be returned.
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneMakeNamed = exports.zoneMakeNamed = Internal.zoneMakeNamed;
+/**
+ * Create a named time zone from a IANA time zone identifier. If the time zone
+ * is invalid, it will fail with an `IllegalArgumentException`.
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneMakeNamedEffect = exports.zoneMakeNamedEffect = Internal.zoneMakeNamedEffect;
+/**
+ * Create a named time zone from the system's local time zone.
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneMakeLocal = exports.zoneMakeLocal = Internal.zoneMakeLocal;
+/**
+ * Try parse a TimeZone from a string
+ *
+ * @since 3.6.0
+ * @category time zones
+ */
+const zoneFromString = exports.zoneFromString = Internal.zoneFromString;
+/**
+ * Format a `TimeZone` as a string.
+ *
+ * @since 3.6.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * // Outputs "+03:00"
+ * DateTime.zoneToString(DateTime.zoneMakeOffset(3 * 60 * 60 * 1000))
+ *
+ * // Outputs "Europe/London"
+ * DateTime.zoneToString(DateTime.zoneUnsafeMakeNamed("Europe/London"))
+ * ```
+ */
+const zoneToString = exports.zoneToString = Internal.zoneToString;
+/**
+ * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
+ * time zone is invalid, `None` will be returned.
+ *
+ * @since 3.6.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * // set the time zone, returns an Option
+ * DateTime.setZoneNamed(now, "Europe/London")
+ * })
+ * ```
+ */
+const setZoneNamed = exports.setZoneNamed = Internal.setZoneNamed;
+/**
+ * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
+ * time zone is invalid, an `IllegalArgumentException` will be thrown.
+ *
+ * @since 3.6.0
+ * @category time zones
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * // set the time zone
+ * DateTime.unsafeSetZoneNamed(now, "Europe/London")
+ * })
+ * ```
+ */
+const unsafeSetZoneNamed = exports.unsafeSetZoneNamed = Internal.unsafeSetZoneNamed;
+// =============================================================================
+// comparisons
+// =============================================================================
+/**
+ * Calulate the difference between two `DateTime` values, returning the number
+ * of milliseconds the `other` DateTime is from `self`.
+ *
+ * If `other` is *after* `self`, the result will be a positive number.
+ *
+ * @since 3.6.0
+ * @category comparisons
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * const other = DateTime.add(now, { minutes: 1 })
+ *
+ * // returns 60000
+ * DateTime.distance(now, other)
+ * })
+ * ```
+ */
+const distance = exports.distance = Internal.distance;
+/**
+ * Calulate the difference between two `DateTime` values.
+ *
+ * If the `other` DateTime is before `self`, the result will be a negative
+ * `Duration`, returned as a `Left`.
+ *
+ * If the `other` DateTime is after `self`, the result will be a positive
+ * `Duration`, returned as a `Right`.
+ *
+ * @since 3.6.0
+ * @category comparisons
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * const other = DateTime.add(now, { minutes: 1 })
+ *
+ * // returns Either.right(Duration.minutes(1))
+ * DateTime.distanceDurationEither(now, other)
+ *
+ * // returns Either.left(Duration.minutes(1))
+ * DateTime.distanceDurationEither(other, now)
+ * })
+ * ```
+ */
+const distanceDurationEither = exports.distanceDurationEither = Internal.distanceDurationEither;
+/**
+ * Calulate the distance between two `DateTime` values.
+ *
+ * @since 3.6.0
+ * @category comparisons
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ * const other = DateTime.add(now, { minutes: 1 })
+ *
+ * // returns Duration.minutes(1)
+ * DateTime.distanceDuration(now, other)
+ * })
+ * ```
+ */
+const distanceDuration = exports.distanceDuration = Internal.distanceDuration;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const min = exports.min = Internal.min;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const max = exports.max = Internal.max;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const greaterThan = exports.greaterThan = Internal.greaterThan;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const greaterThanOrEqualTo = exports.greaterThanOrEqualTo = Internal.greaterThanOrEqualTo;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const lessThan = exports.lessThan = Internal.lessThan;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const lessThanOrEqualTo = exports.lessThanOrEqualTo = Internal.lessThanOrEqualTo;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const between = exports.between = Internal.between;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const isFuture = exports.isFuture = Internal.isFuture;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const unsafeIsFuture = exports.unsafeIsFuture = Internal.unsafeIsFuture;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const isPast = exports.isPast = Internal.isPast;
+/**
+ * @since 3.6.0
+ * @category comparisons
+ */
+const unsafeIsPast = exports.unsafeIsPast = Internal.unsafeIsPast;
+// =============================================================================
+// conversions
+// =============================================================================
+/**
+ * Get the UTC `Date` of a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category conversions
+ */
+const toDateUtc = exports.toDateUtc = Internal.toDateUtc;
+/**
+ * Convert a `DateTime` to a `Date`, applying the time zone first.
+ *
+ * @since 3.6.0
+ * @category conversions
+ */
+const toDate = exports.toDate = Internal.toDate;
+/**
+ * Calculate the time zone offset of a `DateTime.Zoned` in milliseconds.
+ *
+ * @since 3.6.0
+ * @category conversions
+ */
+const zonedOffset = exports.zonedOffset = Internal.zonedOffset;
+/**
+ * Calculate the time zone offset of a `DateTime` in milliseconds.
+ *
+ * The offset is formatted as "±HH:MM".
+ *
+ * @since 3.6.0
+ * @category conversions
+ */
+const zonedOffsetIso = exports.zonedOffsetIso = Internal.zonedOffsetIso;
+/**
+ * Get the milliseconds since the Unix epoch of a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category conversions
+ */
+const toEpochMillis = exports.toEpochMillis = Internal.toEpochMillis;
+/**
+ * Remove the time aspect of a `DateTime`, first adjusting for the time
+ * zone. It will return a `DateTime.Utc` only containing the date.
+ *
+ * @since 3.6.0
+ * @category conversions
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // returns "2024-01-01T00:00:00Z"
+ * DateTime.unsafeMakeZoned("2024-01-01T05:00:00Z", {
+ * timeZone: "Pacific/Auckland",
+ * adjustForTimeZone: true
+ * }).pipe(
+ * DateTime.removeTime,
+ * DateTime.formatIso
+ * )
+ * ```
+ */
+const removeTime = exports.removeTime = Internal.removeTime;
+// =============================================================================
+// parts
+// =============================================================================
+/**
+ * Get the different parts of a `DateTime` as an object.
+ *
+ * The parts will be time zone adjusted.
+ *
+ * @since 3.6.0
+ * @category parts
+ */
+const toParts = exports.toParts = Internal.toParts;
+/**
+ * Get the different parts of a `DateTime` as an object.
+ *
+ * The parts will be in UTC.
+ *
+ * @since 3.6.0
+ * @category parts
+ */
+const toPartsUtc = exports.toPartsUtc = Internal.toPartsUtc;
+/**
+ * Get a part of a `DateTime` as a number.
+ *
+ * The part will be in the UTC time zone.
+ *
+ * @since 3.6.0
+ * @category parts
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { DateTime } from "effect"
+ *
+ * const now = DateTime.unsafeMake({ year: 2024 })
+ * const year = DateTime.getPartUtc(now, "year")
+ * assert.strictEqual(year, 2024)
+ * ```
+ */
+const getPartUtc = exports.getPartUtc = Internal.getPartUtc;
+/**
+ * Get a part of a `DateTime` as a number.
+ *
+ * The part will be time zone adjusted.
+ *
+ * @since 3.6.0
+ * @category parts
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { DateTime } from "effect"
+ *
+ * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
+ * const year = DateTime.getPart(now, "year")
+ * assert.strictEqual(year, 2024)
+ * ```
+ */
+const getPart = exports.getPart = Internal.getPart;
+/**
+ * Set the different parts of a `DateTime` as an object.
+ *
+ * The Date will be time zone adjusted.
+ *
+ * @since 3.6.0
+ * @category parts
+ */
+const setParts = exports.setParts = Internal.setParts;
+/**
+ * Set the different parts of a `DateTime` as an object.
+ *
+ * @since 3.6.0
+ * @category parts
+ */
+const setPartsUtc = exports.setPartsUtc = Internal.setPartsUtc;
+// =============================================================================
+// current time zone
+// =============================================================================
+/**
+ * @since 3.11.0
+ * @category current time zone
+ */
+class CurrentTimeZone extends /*#__PURE__*/Context.Tag("effect/DateTime/CurrentTimeZone")() {}
+/**
+ * Set the time zone of a `DateTime` to the current time zone, which is
+ * determined by the `CurrentTimeZone` service.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.now
+ *
+ * // set the time zone to "Europe/London"
+ * const zoned = yield* DateTime.setZoneCurrent(now)
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * ```
+ */
+exports.CurrentTimeZone = CurrentTimeZone;
+const setZoneCurrent = self => Effect.map(CurrentTimeZone, zone => setZone(self, zone));
+/**
+ * Provide the `CurrentTimeZone` to an effect.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
+ *
+ * Effect.gen(function* () {
+ * const now = yield* DateTime.nowInCurrentZone
+ * }).pipe(DateTime.withCurrentZone(zone))
+ * ```
+ */
+exports.setZoneCurrent = setZoneCurrent;
+const withCurrentZone = exports.withCurrentZone = /*#__PURE__*/(0, _Function.dual)(2, (effect, zone) => Effect.provideService(effect, CurrentTimeZone, zone));
+/**
+ * Provide the `CurrentTimeZone` to an effect, using the system's local time
+ * zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * // will use the system's local time zone
+ * const now = yield* DateTime.nowInCurrentZone
+ * }).pipe(DateTime.withCurrentZoneLocal)
+ * ```
+ */
+const withCurrentZoneLocal = effect => Effect.provideServiceEffect(effect, CurrentTimeZone, Effect.sync(zoneMakeLocal));
+/**
+ * Provide the `CurrentTimeZone` to an effect, using a offset.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * // will use the system's local time zone
+ * const now = yield* DateTime.nowInCurrentZone
+ * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
+ * ```
+ */
+exports.withCurrentZoneLocal = withCurrentZoneLocal;
+const withCurrentZoneOffset = exports.withCurrentZoneOffset = /*#__PURE__*/(0, _Function.dual)(2, (effect, offset) => Effect.provideService(effect, CurrentTimeZone, zoneMakeOffset(offset)));
+/**
+ * Provide the `CurrentTimeZone` to an effect using an IANA time zone
+ * identifier.
+ *
+ * If the time zone is invalid, it will fail with an `IllegalArgumentException`.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * // will use the "Europe/London" time zone
+ * const now = yield* DateTime.nowInCurrentZone
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * ```
+ */
+const withCurrentZoneNamed = exports.withCurrentZoneNamed = /*#__PURE__*/(0, _Function.dual)(2, (effect, zone) => Effect.provideServiceEffect(effect, CurrentTimeZone, zoneMakeNamedEffect(zone)));
+/**
+ * Get the current time as a `DateTime.Zoned`, using the `CurrentTimeZone`.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ * @example
+ * ```ts
+ * import { DateTime, Effect } from "effect"
+ *
+ * Effect.gen(function* () {
+ * // will use the "Europe/London" time zone
+ * const now = yield* DateTime.nowInCurrentZone
+ * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
+ * ```
+ */
+const nowInCurrentZone = exports.nowInCurrentZone = /*#__PURE__*/Effect.flatMap(now, setZoneCurrent);
+// =============================================================================
+// mapping
+// =============================================================================
+/**
+ * Modify a `DateTime` by applying a function to a cloned `Date` instance.
+ *
+ * The `Date` will first have the time zone applied if possible, and then be
+ * converted back to a `DateTime` within the same time zone.
+ *
+ * Supports `disambiguation` when the new wall clock time is ambiguous.
+ *
+ * @since 3.6.0
+ * @category mapping
+ */
+const mutate = exports.mutate = Internal.mutate;
+/**
+ * Modify a `DateTime` by applying a function to a cloned UTC `Date` instance.
+ *
+ * @since 3.6.0
+ * @category mapping
+ */
+const mutateUtc = exports.mutateUtc = Internal.mutateUtc;
+/**
+ * Transform a `DateTime` by applying a function to the number of milliseconds
+ * since the Unix epoch.
+ *
+ * @since 3.6.0
+ * @category mapping
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // add 10 milliseconds
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.mapEpochMillis((millis) => millis + 10)
+ * )
+ * ```
+ */
+const mapEpochMillis = exports.mapEpochMillis = Internal.mapEpochMillis;
+/**
+ * Using the time zone adjusted `Date`, apply a function to the `Date` and
+ * return the result.
+ *
+ * @since 3.6.0
+ * @category mapping
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // get the time zone adjusted date in milliseconds
+ * DateTime.unsafeMakeZoned(0, { timeZone: "Europe/London" }).pipe(
+ * DateTime.withDate((date) => date.getTime())
+ * )
+ * ```
+ */
+const withDate = exports.withDate = Internal.withDate;
+/**
+ * Using the time zone adjusted `Date`, apply a function to the `Date` and
+ * return the result.
+ *
+ * @since 3.6.0
+ * @category mapping
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // get the date in milliseconds
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.withDateUtc((date) => date.getTime())
+ * )
+ * ```
+ */
+const withDateUtc = exports.withDateUtc = Internal.withDateUtc;
+/**
+ * @since 3.6.0
+ * @category mapping
+ */
+const match = exports.match = Internal.match;
+// =============================================================================
+// math
+// =============================================================================
+/**
+ * Add the given `Duration` to a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // add 5 minutes
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.addDuration("5 minutes")
+ * )
+ * ```
+ */
+const addDuration = exports.addDuration = Internal.addDuration;
+/**
+ * Subtract the given `Duration` from a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // subtract 5 minutes
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.subtractDuration("5 minutes")
+ * )
+ * ```
+ */
+const subtractDuration = exports.subtractDuration = Internal.subtractDuration;
+/**
+ * Add the given `amount` of `unit`'s to a `DateTime`.
+ *
+ * The time zone is taken into account when adding days, weeks, months, and
+ * years.
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // add 5 minutes
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.add({ minutes: 5 })
+ * )
+ * ```
+ */
+const add = exports.add = Internal.add;
+/**
+ * Subtract the given `amount` of `unit`'s from a `DateTime`.
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // subtract 5 minutes
+ * DateTime.unsafeMake(0).pipe(
+ * DateTime.subtract({ minutes: 5 })
+ * )
+ * ```
+ */
+const subtract = exports.subtract = Internal.subtract;
+/**
+ * Converts a `DateTime` to the start of the given `part`.
+ *
+ * If the part is `week`, the `weekStartsOn` option can be used to specify the
+ * day of the week that the week starts on. The default is 0 (Sunday).
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // returns "2024-01-01T00:00:00Z"
+ * DateTime.unsafeMake("2024-01-01T12:00:00Z").pipe(
+ * DateTime.startOf("day"),
+ * DateTime.formatIso
+ * )
+ * ```
+ */
+const startOf = exports.startOf = Internal.startOf;
+/**
+ * Converts a `DateTime` to the end of the given `part`.
+ *
+ * If the part is `week`, the `weekStartsOn` option can be used to specify the
+ * day of the week that the week starts on. The default is 0 (Sunday).
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // returns "2024-01-01T23:59:59.999Z"
+ * DateTime.unsafeMake("2024-01-01T12:00:00Z").pipe(
+ * DateTime.endOf("day"),
+ * DateTime.formatIso
+ * )
+ * ```
+ */
+const endOf = exports.endOf = Internal.endOf;
+/**
+ * Converts a `DateTime` to the nearest given `part`.
+ *
+ * If the part is `week`, the `weekStartsOn` option can be used to specify the
+ * day of the week that the week starts on. The default is 0 (Sunday).
+ *
+ * @since 3.6.0
+ * @category math
+ * @example
+ * ```ts
+ * import { DateTime } from "effect"
+ *
+ * // returns "2024-01-02T00:00:00Z"
+ * DateTime.unsafeMake("2024-01-01T12:01:00Z").pipe(
+ * DateTime.nearest("day"),
+ * DateTime.formatIso
+ * )
+ * ```
+ */
+const nearest = exports.nearest = Internal.nearest;
+// =============================================================================
+// formatting
+// =============================================================================
+/**
+ * Format a `DateTime` as a string using the `DateTimeFormat` API.
+ *
+ * The `timeZone` option is set to the offset of the time zone.
+ *
+ * Note: On Node versions < 22, fixed "Offset" zones will set the time zone to
+ * "UTC" and use the adjusted `Date`.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const format = exports.format = Internal.format;
+/**
+ * Format a `DateTime` as a string using the `DateTimeFormat` API.
+ *
+ * It will use the system's local time zone & locale.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatLocal = exports.formatLocal = Internal.formatLocal;
+/**
+ * Format a `DateTime` as a string using the `DateTimeFormat` API.
+ *
+ * This forces the time zone to be UTC.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatUtc = exports.formatUtc = Internal.formatUtc;
+/**
+ * Format a `DateTime` as a string using the `DateTimeFormat` API.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIntl = exports.formatIntl = Internal.formatIntl;
+/**
+ * Format a `DateTime` as a UTC ISO string.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIso = exports.formatIso = Internal.formatIso;
+/**
+ * Format a `DateTime` as a time zone adjusted ISO date string.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIsoDate = exports.formatIsoDate = Internal.formatIsoDate;
+/**
+ * Format a `DateTime` as a UTC ISO date string.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIsoDateUtc = exports.formatIsoDateUtc = Internal.formatIsoDateUtc;
+/**
+ * Format a `DateTime.Zoned` as a ISO string with an offset.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIsoOffset = exports.formatIsoOffset = Internal.formatIsoOffset;
+/**
+ * Format a `DateTime.Zoned` as a string.
+ *
+ * It uses the format: `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`.
+ *
+ * @since 3.6.0
+ * @category formatting
+ */
+const formatIsoZoned = exports.formatIsoZoned = Internal.formatIsoZoned;
+/**
+ * Create a Layer from the given time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+const layerCurrentZone = zone => Layer.succeed(CurrentTimeZone, zone);
+/**
+ * Create a Layer from the given time zone offset.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+exports.layerCurrentZone = layerCurrentZone;
+const layerCurrentZoneOffset = offset => Layer.succeed(CurrentTimeZone, Internal.zoneMakeOffset(offset));
+/**
+ * Create a Layer from the given IANA time zone identifier.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+exports.layerCurrentZoneOffset = layerCurrentZoneOffset;
+const layerCurrentZoneNamed = zoneId => Layer.effect(CurrentTimeZone, Internal.zoneMakeNamedEffect(zoneId));
+/**
+ * Create a Layer from the systems local time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+exports.layerCurrentZoneNamed = layerCurrentZoneNamed;
+const layerCurrentZoneLocal = exports.layerCurrentZoneLocal = /*#__PURE__*/Layer.sync(CurrentTimeZone, zoneMakeLocal);
+//# sourceMappingURL=DateTime.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/DateTime.js.map b/backend/node_modules/effect/dist/cjs/DateTime.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..f084382b820b8c4334de6b2f872d4fd224f30a4c
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/DateTime.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"DateTime.js","names":["Context","_interopRequireWildcard","require","Effect","_Function","Internal","Layer","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","TimeZoneTypeId","isDateTime","isTimeZone","isTimeZoneOffset","isTimeZoneNamed","isUtc","isZoned","Equivalence","Order","clamp","unsafeFromDate","unsafeMake","unsafeMakeZoned","makeZoned","make","makeZonedFromString","now","nowAsDate","unsafeNow","toUtc","setZone","setZoneOffset","zoneUnsafeMakeNamed","zoneMakeOffset","zoneMakeNamed","zoneMakeNamedEffect","zoneMakeLocal","zoneFromString","zoneToString","setZoneNamed","unsafeSetZoneNamed","distance","distanceDurationEither","distanceDuration","min","max","greaterThan","greaterThanOrEqualTo","lessThan","lessThanOrEqualTo","between","isFuture","unsafeIsFuture","isPast","unsafeIsPast","toDateUtc","toDate","zonedOffset","zonedOffsetIso","toEpochMillis","removeTime","toParts","toPartsUtc","getPartUtc","getPart","setParts","setPartsUtc","CurrentTimeZone","Tag","setZoneCurrent","self","map","zone","withCurrentZone","dual","effect","provideService","withCurrentZoneLocal","provideServiceEffect","sync","withCurrentZoneOffset","offset","withCurrentZoneNamed","nowInCurrentZone","flatMap","mutate","mutateUtc","mapEpochMillis","withDate","withDateUtc","match","addDuration","subtractDuration","add","subtract","startOf","endOf","nearest","format","formatLocal","formatUtc","formatIntl","formatIso","formatIsoDate","formatIsoDateUtc","formatIsoOffset","formatIsoZoned","layerCurrentZone","succeed","layerCurrentZoneOffset","layerCurrentZoneNamed","zoneId","layerCurrentZoneLocal"],"sources":["../../src/DateTime.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Deferred.js.map b/backend/node_modules/effect/dist/cjs/Deferred.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..7dc857f15543f62e27629b1539021b1137960d91
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Deferred.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Deferred.js","names":["core","_interopRequireWildcard","require","internal","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","DeferredTypeId","exports","make","deferredMake","makeAs","deferredMakeAs","_await","await","deferredAwait","complete","deferredComplete","completeWith","deferredCompleteWith","done","deferredDone","fail","deferredFail","failSync","deferredFailSync","failCause","deferredFailCause","failCauseSync","deferredFailCauseSync","die","deferredDie","dieSync","deferredDieSync","interrupt","deferredInterrupt","interruptWith","deferredInterruptWith","isDone","deferredIsDone","poll","deferredPoll","succeed","deferredSucceed","sync","deferredSync","unsafeMake","deferredUnsafeMake","unsafeDone","deferredUnsafeDone"],"sources":["../../src/Deferred.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Differ.js b/backend/node_modules/effect/dist/cjs/Differ.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3db9c4655c39af420cf7f43bb2bbcad8181569a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Differ.js
@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zip = exports.updateWith = exports.update = exports.transform = exports.readonlyArray = exports.patch = exports.orElseEither = exports.make = exports.hashSet = exports.hashMap = exports.environment = exports.empty = exports.diff = exports.combine = exports.chunk = exports.TypeId = void 0;
+var Dual = _interopRequireWildcard(require("./Function.js"));
+var internal = _interopRequireWildcard(require("./internal/differ.js"));
+var ChunkPatch = _interopRequireWildcard(require("./internal/differ/chunkPatch.js"));
+var ContextPatch = _interopRequireWildcard(require("./internal/differ/contextPatch.js"));
+var HashMapPatch = _interopRequireWildcard(require("./internal/differ/hashMapPatch.js"));
+var HashSetPatch = _interopRequireWildcard(require("./internal/differ/hashSetPatch.js"));
+var OrPatch = _interopRequireWildcard(require("./internal/differ/orPatch.js"));
+var ReadonlyArrayPatch = _interopRequireWildcard(require("./internal/differ/readonlyArrayPatch.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+const TypeId = exports.TypeId = internal.DifferTypeId;
+const ChunkPatchTypeId = ChunkPatch.ChunkPatchTypeId;
+const ContextPatchTypeId = ContextPatch.ContextPatchTypeId;
+const HashMapPatchTypeId = HashMapPatch.HashMapPatchTypeId;
+const HashSetPatchTypeId = HashSetPatch.HashSetPatchTypeId;
+const OrPatchTypeId = OrPatch.OrPatchTypeId;
+const ReadonlyArrayPatchTypeId = ReadonlyArrayPatch.ReadonlyArrayPatchTypeId;
+/**
+ * An empty patch that describes no changes.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const empty = self => self.empty;
+/**
+ * @since 2.0.0
+ * @category patch
+ */
+exports.empty = empty;
+const diff = exports.diff = /*#__PURE__*/Dual.dual(3, (self, oldValue, newValue) => self.diff(oldValue, newValue));
+/**
+ * Combines two patches to produce a new patch that describes the updates of
+ * the first patch and then the updates of the second patch. The combine
+ * operation should be associative. In addition, if the combine operation is
+ * commutative then joining multiple fibers concurrently will result in
+ * deterministic `FiberRef` values.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const combine = exports.combine = /*#__PURE__*/Dual.dual(3, (self, first, second) => self.combine(first, second));
+/**
+ * Applies a patch to an old value to produce a new value that is equal to the
+ * old value with the updates described by the patch.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const patch = exports.patch = /*#__PURE__*/Dual.dual(3, (self, patch, oldValue) => self.patch(patch, oldValue));
+/**
+ * Constructs a new `Differ`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = exports.make = internal.make;
+/**
+ * Constructs a differ that knows how to diff `Env` values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const environment = exports.environment = internal.environment;
+/**
+ * Constructs a differ that knows how to diff a `Chunk` of values given a
+ * differ that knows how to diff the values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const chunk = exports.chunk = internal.chunk;
+/**
+ * Constructs a differ that knows how to diff a `HashMap` of keys and values given
+ * a differ that knows how to diff the values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashMap = exports.hashMap = internal.hashMap;
+/**
+ * Constructs a differ that knows how to diff a `HashSet` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashSet = exports.hashSet = internal.hashSet;
+/**
+ * Combines this differ and the specified differ to produce a differ that
+ * knows how to diff the sum of their values.
+ *
+ * @since 2.0.0
+ */
+const orElseEither = exports.orElseEither = internal.orElseEither;
+/**
+ * Constructs a differ that knows how to diff a `ReadonlyArray` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const readonlyArray = exports.readonlyArray = internal.readonlyArray;
+/**
+ * Transforms the type of values that this differ knows how to differ using
+ * the specified functions that map the new and old value types to each other.
+ *
+ * @since 2.0.0
+ */
+const transform = exports.transform = internal.transform;
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ *
+ * @since 2.0.0
+ */
+const update = exports.update = internal.update;
+/**
+ * A variant of `update` that allows specifying the function that will be used
+ * to combine old values with new values.
+ *
+ * @since 2.0.0
+ */
+const updateWith = exports.updateWith = internal.updateWith;
+/**
+ * Combines this differ and the specified differ to produce a new differ that
+ * knows how to diff the product of their values.
+ *
+ * @since 2.0.0
+ */
+const zip = exports.zip = internal.zip;
+//# sourceMappingURL=Differ.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Duration.js b/backend/node_modules/effect/dist/cjs/Duration.js
new file mode 100644
index 0000000000000000000000000000000000000000..95e8439ff319034c40b407dcbd11b58c491f61f6
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Duration.js
@@ -0,0 +1,737 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zero = exports.weeks = exports.unsafeToNanos = exports.unsafeFormatIso = exports.unsafeDivide = exports.toWeeks = exports.toSeconds = exports.toNanos = exports.toMinutes = exports.toMillis = exports.toHrTime = exports.toHours = exports.toDays = exports.times = exports.sum = exports.subtract = exports.seconds = exports.parts = exports.nanos = exports.minutes = exports.min = exports.millis = exports.micros = exports.max = exports.matchWith = exports.match = exports.lessThanOrEqualTo = exports.lessThan = exports.isZero = exports.isFinite = exports.isDuration = exports.infinity = exports.hours = exports.greaterThanOrEqualTo = exports.greaterThan = exports.fromIso = exports.formatIso = exports.format = exports.equals = exports.divide = exports.decodeUnknown = exports.decode = exports.days = exports.clamp = exports.between = exports.Order = exports.Equivalence = void 0;
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var _Function = require("./Function.js");
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Inspectable = require("./Inspectable.js");
+var Option = _interopRequireWildcard(require("./Option.js"));
+var order = _interopRequireWildcard(require("./Order.js"));
+var _Pipeable = require("./Pipeable.js");
+var _Predicate = require("./Predicate.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+const TypeId = /*#__PURE__*/Symbol.for("effect/Duration");
+const bigint0 = /*#__PURE__*/BigInt(0);
+const bigint24 = /*#__PURE__*/BigInt(24);
+const bigint60 = /*#__PURE__*/BigInt(60);
+const bigint1e3 = /*#__PURE__*/BigInt(1_000);
+const bigint1e6 = /*#__PURE__*/BigInt(1_000_000);
+const bigint1e9 = /*#__PURE__*/BigInt(1_000_000_000);
+const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;
+/**
+ * @since 2.0.0
+ */
+const decode = input => {
+ if (isDuration(input)) {
+ return input;
+ } else if ((0, _Predicate.isNumber)(input)) {
+ return millis(input);
+ } else if ((0, _Predicate.isBigInt)(input)) {
+ return nanos(input);
+ } else if (Array.isArray(input) && input.length === 2 && input.every(_Predicate.isNumber)) {
+ if (input[0] === -Infinity || input[1] === -Infinity || Number.isNaN(input[0]) || Number.isNaN(input[1])) {
+ return zero;
+ }
+ if (input[0] === Infinity || input[1] === Infinity) {
+ return infinity;
+ }
+ return nanos(BigInt(Math.round(input[0] * 1_000_000_000)) + BigInt(Math.round(input[1])));
+ } else if ((0, _Predicate.isString)(input)) {
+ const match = DURATION_REGEX.exec(input);
+ if (match) {
+ const [_, valueStr, unit] = match;
+ const value = Number(valueStr);
+ switch (unit) {
+ case "nano":
+ case "nanos":
+ return nanos(BigInt(valueStr));
+ case "micro":
+ case "micros":
+ return micros(BigInt(valueStr));
+ case "milli":
+ case "millis":
+ return millis(value);
+ case "second":
+ case "seconds":
+ return seconds(value);
+ case "minute":
+ case "minutes":
+ return minutes(value);
+ case "hour":
+ case "hours":
+ return hours(value);
+ case "day":
+ case "days":
+ return days(value);
+ case "week":
+ case "weeks":
+ return weeks(value);
+ }
+ }
+ }
+ throw new Error("Invalid DurationInput");
+};
+/**
+ * @since 2.5.0
+ */
+exports.decode = decode;
+const decodeUnknown = exports.decodeUnknown = /*#__PURE__*/Option.liftThrowable(decode);
+const zeroValue = {
+ _tag: "Millis",
+ millis: 0
+};
+const infinityValue = {
+ _tag: "Infinity"
+};
+const DurationProto = {
+ [TypeId]: TypeId,
+ [Hash.symbol]() {
+ return Hash.cached(this, Hash.structure(this.value));
+ },
+ [Equal.symbol](that) {
+ return isDuration(that) && equals(this, that);
+ },
+ toString() {
+ return `Duration(${format(this)})`;
+ },
+ toJSON() {
+ switch (this.value._tag) {
+ case "Millis":
+ return {
+ _id: "Duration",
+ _tag: "Millis",
+ millis: this.value.millis
+ };
+ case "Nanos":
+ return {
+ _id: "Duration",
+ _tag: "Nanos",
+ hrtime: toHrTime(this)
+ };
+ case "Infinity":
+ return {
+ _id: "Duration",
+ _tag: "Infinity"
+ };
+ }
+ },
+ [_Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+const make = input => {
+ const duration = Object.create(DurationProto);
+ if ((0, _Predicate.isNumber)(input)) {
+ if (isNaN(input) || input <= 0) {
+ duration.value = zeroValue;
+ } else if (!Number.isFinite(input)) {
+ duration.value = infinityValue;
+ } else if (!Number.isInteger(input)) {
+ duration.value = {
+ _tag: "Nanos",
+ nanos: BigInt(Math.round(input * 1_000_000))
+ };
+ } else {
+ duration.value = {
+ _tag: "Millis",
+ millis: input
+ };
+ }
+ } else if (input <= bigint0) {
+ duration.value = zeroValue;
+ } else {
+ duration.value = {
+ _tag: "Nanos",
+ nanos: input
+ };
+ }
+ return duration;
+};
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+const isDuration = u => (0, _Predicate.hasProperty)(u, TypeId);
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+exports.isDuration = isDuration;
+const isFinite = self => self.value._tag !== "Infinity";
+/**
+ * @since 3.5.0
+ * @category guards
+ */
+exports.isFinite = isFinite;
+const isZero = self => {
+ switch (self.value._tag) {
+ case "Millis":
+ {
+ return self.value.millis === 0;
+ }
+ case "Nanos":
+ {
+ return self.value.nanos === bigint0;
+ }
+ case "Infinity":
+ {
+ return false;
+ }
+ }
+};
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.isZero = isZero;
+const zero = exports.zero = /*#__PURE__*/make(0);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const infinity = exports.infinity = /*#__PURE__*/make(Infinity);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const nanos = nanos => make(nanos);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.nanos = nanos;
+const micros = micros => make(micros * bigint1e3);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.micros = micros;
+const millis = millis => make(millis);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.millis = millis;
+const seconds = seconds => make(seconds * 1000);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.seconds = seconds;
+const minutes = minutes => make(minutes * 60_000);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.minutes = minutes;
+const hours = hours => make(hours * 3_600_000);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.hours = hours;
+const days = days => make(days * 86_400_000);
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.days = days;
+const weeks = weeks => make(weeks * 604_800_000);
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+exports.weeks = weeks;
+const toMillis = self => match(self, {
+ onMillis: millis => millis,
+ onNanos: nanos => Number(nanos) / 1_000_000
+});
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+exports.toMillis = toMillis;
+const toSeconds = self => match(self, {
+ onMillis: millis => millis / 1_000,
+ onNanos: nanos => Number(nanos) / 1_000_000_000
+});
+/**
+ * @since 3.8.0
+ * @category getters
+ */
+exports.toSeconds = toSeconds;
+const toMinutes = self => match(self, {
+ onMillis: millis => millis / 60_000,
+ onNanos: nanos => Number(nanos) / 60_000_000_000
+});
+/**
+ * @since 3.8.0
+ * @category getters
+ */
+exports.toMinutes = toMinutes;
+const toHours = self => match(self, {
+ onMillis: millis => millis / 3_600_000,
+ onNanos: nanos => Number(nanos) / 3_600_000_000_000
+});
+/**
+ * @since 3.8.0
+ * @category getters
+ */
+exports.toHours = toHours;
+const toDays = self => match(self, {
+ onMillis: millis => millis / 86_400_000,
+ onNanos: nanos => Number(nanos) / 86_400_000_000_000
+});
+/**
+ * @since 3.8.0
+ * @category getters
+ */
+exports.toDays = toDays;
+const toWeeks = self => match(self, {
+ onMillis: millis => millis / 604_800_000,
+ onNanos: nanos => Number(nanos) / 604_800_000_000_000
+});
+/**
+ * Get the duration in nanoseconds as a bigint.
+ *
+ * If the duration is infinite, returns `Option.none()`
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+exports.toWeeks = toWeeks;
+const toNanos = self => {
+ const _self = decode(self);
+ switch (_self.value._tag) {
+ case "Infinity":
+ return Option.none();
+ case "Nanos":
+ return Option.some(_self.value.nanos);
+ case "Millis":
+ return Option.some(BigInt(Math.round(_self.value.millis * 1_000_000)));
+ }
+};
+/**
+ * Get the duration in nanoseconds as a bigint.
+ *
+ * If the duration is infinite, it throws an error.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+exports.toNanos = toNanos;
+const unsafeToNanos = self => {
+ const _self = decode(self);
+ switch (_self.value._tag) {
+ case "Infinity":
+ throw new Error("Cannot convert infinite duration to nanos");
+ case "Nanos":
+ return _self.value.nanos;
+ case "Millis":
+ return BigInt(Math.round(_self.value.millis * 1_000_000));
+ }
+};
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+exports.unsafeToNanos = unsafeToNanos;
+const toHrTime = self => {
+ const _self = decode(self);
+ switch (_self.value._tag) {
+ case "Infinity":
+ return [Infinity, 0];
+ case "Nanos":
+ return [Number(_self.value.nanos / bigint1e9), Number(_self.value.nanos % bigint1e9)];
+ case "Millis":
+ return [Math.floor(_self.value.millis / 1000), Math.round(_self.value.millis % 1000 * 1_000_000)];
+ }
+};
+/**
+ * @since 2.0.0
+ * @category pattern matching
+ */
+exports.toHrTime = toHrTime;
+const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => {
+ const _self = decode(self);
+ switch (_self.value._tag) {
+ case "Nanos":
+ return options.onNanos(_self.value.nanos);
+ case "Infinity":
+ return options.onMillis(Infinity);
+ case "Millis":
+ return options.onMillis(_self.value.millis);
+ }
+});
+/**
+ * @since 2.0.0
+ * @category pattern matching
+ */
+const matchWith = exports.matchWith = /*#__PURE__*/(0, _Function.dual)(3, (self, that, options) => {
+ const _self = decode(self);
+ const _that = decode(that);
+ if (_self.value._tag === "Infinity" || _that.value._tag === "Infinity") {
+ return options.onMillis(toMillis(_self), toMillis(_that));
+ } else if (_self.value._tag === "Nanos" || _that.value._tag === "Nanos") {
+ const selfNanos = _self.value._tag === "Nanos" ? _self.value.nanos : BigInt(Math.round(_self.value.millis * 1_000_000));
+ const thatNanos = _that.value._tag === "Nanos" ? _that.value.nanos : BigInt(Math.round(_that.value.millis * 1_000_000));
+ return options.onNanos(selfNanos, thatNanos);
+ }
+ return options.onMillis(_self.value.millis, _that.value.millis);
+});
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Order = exports.Order = /*#__PURE__*/order.make((self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self < that ? -1 : self > that ? 1 : 0,
+ onNanos: (self, that) => self < that ? -1 : self > that ? 1 : 0
+}));
+/**
+ * Checks if a `Duration` is between a `minimum` and `maximum` value.
+ *
+ * @category predicates
+ * @since 2.0.0
+ */
+const between = exports.between = /*#__PURE__*/order.between(/*#__PURE__*/order.mapInput(Order, decode));
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Equivalence = (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self === that,
+ onNanos: (self, that) => self === that
+});
+exports.Equivalence = Equivalence;
+const _min = /*#__PURE__*/order.min(Order);
+/**
+ * @since 2.0.0
+ */
+const min = exports.min = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => _min(decode(self), decode(that)));
+const _max = /*#__PURE__*/order.max(Order);
+/**
+ * @since 2.0.0
+ * @category order
+ */
+const max = exports.max = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => _max(decode(self), decode(that)));
+const _clamp = /*#__PURE__*/order.clamp(Order);
+/**
+ * @since 2.0.0
+ * @category order
+ */
+const clamp = exports.clamp = /*#__PURE__*/(0, _Function.dual)(2, (self, options) => _clamp(decode(self), {
+ minimum: decode(options.minimum),
+ maximum: decode(options.maximum)
+}));
+/**
+ * @since 2.4.19
+ * @category math
+ */
+const divide = exports.divide = /*#__PURE__*/(0, _Function.dual)(2, (self, by) => match(self, {
+ onMillis: millis => {
+ if (by === 0 || isNaN(by) || !Number.isFinite(by)) {
+ return Option.none();
+ }
+ return Option.some(make(millis / by));
+ },
+ onNanos: nanos => {
+ if (isNaN(by) || by <= 0 || !Number.isFinite(by)) {
+ return Option.none();
+ }
+ try {
+ return Option.some(make(nanos / BigInt(by)));
+ } catch {
+ return Option.none();
+ }
+ }
+}));
+/**
+ * @since 2.4.19
+ * @category math
+ */
+const unsafeDivide = exports.unsafeDivide = /*#__PURE__*/(0, _Function.dual)(2, (self, by) => match(self, {
+ onMillis: millis => make(millis / by),
+ onNanos: nanos => {
+ if (isNaN(by) || by < 0 || Object.is(by, -0)) {
+ return zero;
+ } else if (Object.is(by, 0) || !Number.isFinite(by)) {
+ return infinity;
+ }
+ return make(nanos / BigInt(by));
+ }
+}));
+/**
+ * @since 2.0.0
+ * @category math
+ */
+const times = exports.times = /*#__PURE__*/(0, _Function.dual)(2, (self, times) => match(self, {
+ onMillis: millis => make(millis * times),
+ onNanos: nanos => make(nanos * BigInt(times))
+}));
+/**
+ * @since 2.0.0
+ * @category math
+ */
+const subtract = exports.subtract = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => make(self - that),
+ onNanos: (self, that) => make(self - that)
+}));
+/**
+ * @since 2.0.0
+ * @category math
+ */
+const sum = exports.sum = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => make(self + that),
+ onNanos: (self, that) => make(self + that)
+}));
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThan = exports.lessThan = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self < that,
+ onNanos: (self, that) => self < that
+}));
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+const lessThanOrEqualTo = exports.lessThanOrEqualTo = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self <= that,
+ onNanos: (self, that) => self <= that
+}));
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThan = exports.greaterThan = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self > that,
+ onNanos: (self, that) => self > that
+}));
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+const greaterThanOrEqualTo = exports.greaterThanOrEqualTo = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => matchWith(self, that, {
+ onMillis: (self, that) => self >= that,
+ onNanos: (self, that) => self >= that
+}));
+/**
+ * @since 2.0.0
+ * @category predicates
+ */
+const equals = exports.equals = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => Equivalence(decode(self), decode(that)));
+/**
+ * Converts a `Duration` to its parts.
+ *
+ * @since 3.8.0
+ * @category conversions
+ */
+const parts = self => {
+ const duration = decode(self);
+ if (duration.value._tag === "Infinity") {
+ return {
+ days: Infinity,
+ hours: Infinity,
+ minutes: Infinity,
+ seconds: Infinity,
+ millis: Infinity,
+ nanos: Infinity
+ };
+ }
+ const nanos = unsafeToNanos(duration);
+ const ms = nanos / bigint1e6;
+ const sec = ms / bigint1e3;
+ const min = sec / bigint60;
+ const hr = min / bigint60;
+ const days = hr / bigint24;
+ return {
+ days: Number(days),
+ hours: Number(hr % bigint24),
+ minutes: Number(min % bigint60),
+ seconds: Number(sec % bigint60),
+ millis: Number(ms % bigint1e3),
+ nanos: Number(nanos % bigint1e6)
+ };
+};
+/**
+ * Converts a `Duration` to a human readable string.
+ *
+ * @since 2.0.0
+ * @category conversions
+ * @example
+ * ```ts
+ * import { Duration } from "effect"
+ *
+ * Duration.format(Duration.millis(1000)) // "1s"
+ * Duration.format(Duration.millis(1001)) // "1s 1ms"
+ * ```
+ */
+exports.parts = parts;
+const format = self => {
+ const duration = decode(self);
+ if (duration.value._tag === "Infinity") {
+ return "Infinity";
+ }
+ if (isZero(duration)) {
+ return "0";
+ }
+ const fragments = parts(duration);
+ const pieces = [];
+ if (fragments.days !== 0) {
+ pieces.push(`${fragments.days}d`);
+ }
+ if (fragments.hours !== 0) {
+ pieces.push(`${fragments.hours}h`);
+ }
+ if (fragments.minutes !== 0) {
+ pieces.push(`${fragments.minutes}m`);
+ }
+ if (fragments.seconds !== 0) {
+ pieces.push(`${fragments.seconds}s`);
+ }
+ if (fragments.millis !== 0) {
+ pieces.push(`${fragments.millis}ms`);
+ }
+ if (fragments.nanos !== 0) {
+ pieces.push(`${fragments.nanos}ns`);
+ }
+ return pieces.join(" ");
+};
+/**
+ * Formats a Duration into an ISO8601 duration string.
+ *
+ * Months are assumed to be 30 days and years are assumed to be 365 days.
+ *
+ * Milliseconds and nanoseconds are expressed as fractional seconds.
+ *
+ * @example
+ * ```ts
+ * import { Duration } from "effect"
+ *
+ * Duration.unsafeFormatIso(Duration.days(1)) // => "P1D"
+ * Duration.unsafeFormatIso(Duration.minutes(90)) // => "PT1H30M"
+ * Duration.unsafeFormatIso(Duration.millis(1500)) // => "PT1.5S"
+ * ```
+ *
+ * @throws `RangeError` If the duration is not finite.
+ *
+ * @since 3.13.0
+ * @category conversions
+ */
+exports.format = format;
+const unsafeFormatIso = self => {
+ const duration = decode(self);
+ if (!isFinite(duration)) {
+ throw new RangeError("Cannot format infinite duration");
+ }
+ const fragments = [];
+ const {
+ days,
+ hours,
+ millis,
+ minutes,
+ nanos,
+ seconds
+ } = parts(duration);
+ let rest = days;
+ if (rest >= 365) {
+ const years = Math.floor(rest / 365);
+ rest %= 365;
+ fragments.push(`${years}Y`);
+ }
+ if (rest >= 30) {
+ const months = Math.floor(rest / 30);
+ rest %= 30;
+ fragments.push(`${months}M`);
+ }
+ if (rest >= 7) {
+ const weeks = Math.floor(rest / 7);
+ rest %= 7;
+ fragments.push(`${weeks}W`);
+ }
+ if (rest > 0) {
+ fragments.push(`${rest}D`);
+ }
+ if (hours !== 0 || minutes !== 0 || seconds !== 0 || millis !== 0 || nanos !== 0) {
+ fragments.push("T");
+ if (hours !== 0) {
+ fragments.push(`${hours}H`);
+ }
+ if (minutes !== 0) {
+ fragments.push(`${minutes}M`);
+ }
+ if (seconds !== 0 || millis !== 0 || nanos !== 0) {
+ const total = BigInt(seconds) * bigint1e9 + BigInt(millis) * bigint1e6 + BigInt(nanos);
+ const str = (Number(total) / 1e9).toFixed(9).replace(/\.?0+$/, "");
+ fragments.push(`${str}S`);
+ }
+ }
+ return `P${fragments.join("") || "T0S"}`;
+};
+/**
+ * Formats a Duration into an ISO8601 duration string.
+ *
+ * Months are assumed to be 30 days and years are assumed to be 365 days.
+ *
+ * Returns `Option.none()` if the duration is infinite.
+ *
+ * @example
+ * ```ts
+ * import { Duration, Option } from "effect"
+ *
+ * Duration.formatIso(Duration.days(1)) // => Option.some("P1D")
+ * Duration.formatIso(Duration.minutes(90)) // => Option.some("PT1H30M")
+ * Duration.formatIso(Duration.millis(1500)) // => Option.some("PT1.5S")
+ * Duration.formatIso(Duration.infinity) // => Option.none()
+ * ```
+ *
+ * @since 3.13.0
+ * @category conversions
+ */
+exports.unsafeFormatIso = unsafeFormatIso;
+const formatIso = self => {
+ const duration = decode(self);
+ return isFinite(duration) ? Option.some(unsafeFormatIso(duration)) : Option.none();
+};
+/**
+ * Parses an ISO8601 duration string into a `Duration`.
+ *
+ * Months are assumed to be 30 days and years are assumed to be 365 days.
+ *
+ * @example
+ * ```ts
+ * import { Duration, Option } from "effect"
+ *
+ * Duration.fromIso("P1D") // => Option.some(Duration.days(1))
+ * Duration.fromIso("PT1H") // => Option.some(Duration.hours(1))
+ * Duration.fromIso("PT1M") // => Option.some(Duration.minutes(1))
+ * Duration.fromIso("PT1.5S") // => Option.some(Duration.seconds(1.5))
+ * ```
+ *
+ * @since 3.13.0
+ * @category conversions
+ */
+exports.formatIso = formatIso;
+const fromIso = iso => {
+ const result = DURATION_ISO_REGEX.exec(iso);
+ if (result == null) {
+ return Option.none();
+ }
+ const [years, months, weeks, days, hours, mins, secs] = result.slice(1, 8).map(_ => _ ? Number(_) : 0);
+ const value = years * 365 * 24 * 60 * 60 + months * 30 * 24 * 60 * 60 + weeks * 7 * 24 * 60 * 60 + days * 24 * 60 * 60 + hours * 60 * 60 + mins * 60 + secs;
+ return Option.some(seconds(value));
+};
+exports.fromIso = fromIso;
+const DURATION_ISO_REGEX = /^P(?!$)(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?!$)(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+//# sourceMappingURL=Duration.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Duration.js.map b/backend/node_modules/effect/dist/cjs/Duration.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..6fbb5f5c815596aa326911e2978b6f10b1974f04
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Duration.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Duration.js","names":["Equal","_interopRequireWildcard","require","_Function","Hash","_Inspectable","Option","order","_Pipeable","_Predicate","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","Symbol","for","bigint0","BigInt","bigint24","bigint60","bigint1e3","bigint1e6","bigint1e9","DURATION_REGEX","decode","input","isDuration","isNumber","millis","isBigInt","nanos","Array","isArray","length","every","Infinity","Number","isNaN","zero","infinity","Math","round","isString","match","exec","_","valueStr","unit","value","micros","seconds","minutes","hours","days","weeks","Error","exports","decodeUnknown","liftThrowable","zeroValue","_tag","infinityValue","DurationProto","symbol","cached","structure","that","equals","toString","format","toJSON","_id","hrtime","toHrTime","NodeInspectSymbol","pipe","pipeArguments","arguments","make","duration","create","isFinite","isInteger","u","hasProperty","self","isZero","toMillis","onMillis","onNanos","toSeconds","toMinutes","toHours","toDays","toWeeks","toNanos","_self","none","some","unsafeToNanos","floor","dual","options","matchWith","_that","selfNanos","thatNanos","Order","between","mapInput","Equivalence","_min","min","_max","max","_clamp","clamp","minimum","maximum","divide","by","unsafeDivide","is","times","subtract","sum","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","parts","ms","sec","hr","fragments","pieces","push","join","unsafeFormatIso","RangeError","rest","years","months","total","str","toFixed","replace","formatIso","fromIso","iso","result","DURATION_ISO_REGEX","mins","secs","slice","map"],"sources":["../../src/Duration.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Effect.js b/backend/node_modules/effect/dist/cjs/Effect.js
new file mode 100644
index 0000000000000000000000000000000000000000..65089579aa7e9fb92f3793212ba7f5ef93b8c75f
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Effect.js
@@ -0,0 +1,10722 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.flip = exports.flatten = exports.flatMap = exports.firstSuccessOf = exports.findFirst = exports.finalizersMask = exports.filterOrFail = exports.filterOrElse = exports.filterOrDieMessage = exports.filterOrDie = exports.filterMap = exports.filterEffectOrFail = exports.filterEffectOrElse = exports.filter = exports.fiberIdWith = exports.fiberId = exports.failSync = exports.failCauseSync = exports.failCause = exports.fail = exports.exit = exports.exists = exports.every = exports.eventually = exports.ensuringChildren = exports.ensuringChild = exports.ensuring = exports.ensureSuccessType = exports.ensureRequirementsType = exports.ensureErrorType = exports.either = exports.dropWhile = exports.dropUntil = exports.disconnect = exports.diffFiberRefs = exports.dieSync = exports.dieMessage = exports.die = exports.descriptorWith = exports.descriptor = exports.delay = exports.daemonChildren = exports.custom = exports.currentSpan = exports.currentPropagatedSpan = exports.currentParentSpan = exports.contextWithEffect = exports.contextWith = exports.context = exports.consoleWith = exports.console = exports.configProviderWith = exports.clockWith = exports.clock = exports.checkInterruptible = exports.cause = exports.catchTags = exports.catchTag = exports.catchSomeDefect = exports.catchSomeCause = exports.catchSome = exports.catchIf = exports.catchAllDefect = exports.catchAllCause = exports.catchAll = exports.catch = exports.cachedWithTTL = exports.cachedInvalidateWithTTL = exports.cachedFunction = exports.cached = exports.cacheRequestResult = exports.blocked = exports.bindTo = exports.bindAll = exports.bind = exports.awaitAllChildren = exports.asyncEffect = exports.async = exports.asVoid = exports.asSomeError = exports.asSome = exports.as = exports.ap = exports.annotateSpans = exports.annotateLogsScoped = exports.annotateLogs = exports.annotateCurrentSpan = exports.andThen = exports.allowInterrupt = exports.allWith = exports.allSuccesses = exports.all = exports.addFinalizer = exports.acquireUseRelease = exports.acquireReleaseInterruptible = exports.acquireRelease = exports.Tag = exports.Service = exports.EffectTypeId = exports.Do = void 0;
+exports.reduceEffect = exports.reduce = exports.randomWith = exports.random = exports.raceWith = exports.raceFirst = exports.raceAll = exports.race = exports.provideServiceEffect = exports.provideService = exports.provide = exports.promise = exports.patchRuntimeFlags = exports.patchFiberRefs = exports.partition = exports.parallelFinalizers = exports.parallelErrors = exports.orElseSucceed = exports.orElseFail = exports.orElse = exports.orDieWith = exports.orDie = exports.optionFromOptional = exports.option = exports.once = exports.onInterrupt = exports.onExit = exports.onError = exports.none = exports.never = exports.negate = exports.metricLabels = exports.mergeAll = exports.merge = exports.matchEffect = exports.matchCauseEffect = exports.matchCause = exports.match = exports.mapInputContext = exports.mapErrorCause = exports.mapError = exports.mapBoth = exports.mapAccum = exports.map = exports.makeSpanScoped = exports.makeSpan = exports.makeSemaphore = exports.makeLatch = exports.loop = exports.logWithLevel = exports.logWarning = exports.logTrace = exports.logInfo = exports.logFatal = exports.logError = exports.logDebug = exports.logAnnotations = exports.log = exports.locallyWith = exports.locallyScopedWith = exports.locallyScoped = exports.locally = exports.linkSpans = exports.linkSpanCurrent = exports.liftPredicate = exports.let = exports.labelMetricsScoped = exports.labelMetrics = exports.iterate = exports.isSuccess = exports.isFailure = exports.isEffect = exports.intoDeferred = exports.interruptibleMask = exports.interruptible = exports.interruptWith = exports.interrupt = exports.inheritFiberRefs = exports.ignoreLogged = exports.ignore = exports.if = exports.head = exports.getRuntimeFlags = exports.getFiberRefs = exports.gen = exports.functionWithSpan = exports.fromNullable = exports.fromFiberEffect = exports.fromFiber = exports.forkWithErrorHandler = exports.forkScoped = exports.forkIn = exports.forkDaemon = exports.forkAll = exports.fork = exports.forever = exports.forEach = exports.fnUntraced = exports.fn = exports.flipWith = void 0;
+exports.withConsole = exports.withConfigProviderScoped = exports.withConfigProvider = exports.withConcurrency = exports.withClockScoped = exports.withClock = exports.whileLoop = exports.whenRef = exports.whenLogLevel = exports.whenFiberRef = exports.whenEffect = exports.when = exports.void = exports.validateWith = exports.validateFirst = exports.validateAll = exports.validate = exports.using = exports.useSpan = exports.updateService = exports.updateFiberRefs = exports.unsandbox = exports.unsafeMakeSemaphore = exports.unsafeMakeLatch = exports.unlessEffect = exports.unless = exports.uninterruptibleMask = exports.uninterruptible = exports.tryPromise = exports.tryMapPromise = exports.tryMap = exports.try = exports.transposeOption = exports.transposeMapOption = exports.transplant = exports.tracerWith = exports.tracer = exports.timeoutTo = exports.timeoutOption = exports.timeoutFailCause = exports.timeoutFail = exports.timeout = exports.timedWith = exports.timed = exports.tapErrorTag = exports.tapErrorCause = exports.tapError = exports.tapDefect = exports.tapBoth = exports.tap = exports.takeWhile = exports.takeUntil = exports.tagMetricsScoped = exports.tagMetrics = exports.sync = exports.suspend = exports.supervised = exports.summarized = exports.succeedSome = exports.succeedNone = exports.succeed = exports.step = exports.spanLinks = exports.spanAnnotations = exports.sleep = exports.setFiberRefs = exports.serviceOptional = exports.serviceOption = exports.serviceMembers = exports.serviceFunctions = exports.serviceFunctionEffect = exports.serviceFunction = exports.serviceConstants = exports.sequentialFinalizers = exports.scopedWith = exports.scoped = exports.scopeWith = exports.scope = exports.scheduleFrom = exports.scheduleForked = exports.schedule = exports.sandbox = exports.runtime = exports.runSyncExit = exports.runSync = exports.runRequestBlock = exports.runPromiseExit = exports.runPromise = exports.runFork = exports.runCallback = exports.retryOrElse = exports.retry = exports.request = exports.replicateEffect = exports.replicate = exports.repeatOrElse = exports.repeatN = exports.repeat = exports.reduceWhile = exports.reduceRight = void 0;
+exports.zipWith = exports.zipRight = exports.zipLeft = exports.zip = exports.yieldNow = exports.withUnhandledErrorLogLevel = exports.withTracerTiming = exports.withTracerScoped = exports.withTracerEnabled = exports.withTracer = exports.withSpanScoped = exports.withSpan = exports.withSchedulingPriority = exports.withScheduler = exports.withRuntimeFlagsPatchScoped = exports.withRuntimeFlagsPatch = exports.withRequestCaching = exports.withRequestCache = exports.withRequestBatching = exports.withRandomScoped = exports.withRandomFixed = exports.withRandom = exports.withParentSpan = exports.withMetric = exports.withMaxOpsBeforeYield = exports.withLogSpan = exports.withFiberRuntime = exports.withExecutionPlan = exports.withEarlyRelease = exports.withConsoleScoped = void 0;
+var _Function = require("./Function.js");
+var internalCause = _interopRequireWildcard(require("./internal/cause.js"));
+var console_ = _interopRequireWildcard(require("./internal/console.js"));
+var _context = require("./internal/context.js");
+var effect = _interopRequireWildcard(require("./internal/core-effect.js"));
+var core = _interopRequireWildcard(require("./internal/core.js"));
+var defaultServices = _interopRequireWildcard(require("./internal/defaultServices.js"));
+var circular = _interopRequireWildcard(require("./internal/effect/circular.js"));
+var internalExecutionPlan = _interopRequireWildcard(require("./internal/executionPlan.js"));
+var fiberRuntime = _interopRequireWildcard(require("./internal/fiberRuntime.js"));
+var layer = _interopRequireWildcard(require("./internal/layer.js"));
+var option_ = _interopRequireWildcard(require("./internal/option.js"));
+var query = _interopRequireWildcard(require("./internal/query.js"));
+var runtime_ = _interopRequireWildcard(require("./internal/runtime.js"));
+var schedule_ = _interopRequireWildcard(require("./internal/schedule.js"));
+var internalTracer = _interopRequireWildcard(require("./internal/tracer.js"));
+var Random = _interopRequireWildcard(require("./Random.js"));
+var Request = _interopRequireWildcard(require("./Request.js"));
+var Scheduler = _interopRequireWildcard(require("./Scheduler.js"));
+var _Utils = require("./Utils.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category Symbols
+ */
+const EffectTypeId = exports.EffectTypeId = core.EffectTypeId;
+/**
+ * Checks if a given value is an `Effect` value.
+ *
+ * **When to Use**
+ *
+ * This function can be useful for checking the type of a value before
+ * attempting to operate on it as an `Effect` value. For example, you could use
+ * `Effect.isEffect` to check the type of a value before using it as an argument
+ * to a function that expects an `Effect` value.
+ *
+ * @since 2.0.0
+ * @category Guards
+ */
+const isEffect = exports.isEffect = core.isEffect;
+/**
+ * Returns an effect that caches its result for a specified `Duration`,
+ * known as "timeToLive" (TTL).
+ *
+ * **Details**
+ *
+ * This function is used to cache the result of an effect for a specified amount
+ * of time. This means that the first time the effect is evaluated, its result
+ * is computed and stored.
+ *
+ * If the effect is evaluated again within the specified `timeToLive`, the
+ * cached result will be used, avoiding recomputation.
+ *
+ * After the specified duration has passed, the cache expires, and the effect
+ * will be recomputed upon the next evaluation.
+ *
+ * **When to Use**
+ *
+ * Use this function when you have an effect that involves costly operations or
+ * computations, and you want to avoid repeating them within a short time frame.
+ *
+ * It's ideal for scenarios where the result of an effect doesn't change
+ * frequently and can be reused for a specified duration.
+ *
+ * By caching the result, you can improve efficiency and reduce unnecessary
+ * computations, especially in performance-critical applications.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * let i = 1
+ * const expensiveTask = Effect.promise(() => {
+ * console.log("expensive task...")
+ * return new Promise((resolve) => {
+ * setTimeout(() => {
+ * resolve(`result ${i++}`)
+ * }, 100)
+ * })
+ * })
+ *
+ * const program = Effect.gen(function* () {
+ * const cached = yield* Effect.cachedWithTTL(expensiveTask, "150 millis")
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * yield* Effect.sleep("100 millis")
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // expensive task...
+ * // result 1
+ * // result 1
+ * // expensive task...
+ * // result 2
+ * ```
+ *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
+ *
+ * @since 2.0.0
+ * @category Caching
+ */
+const cachedWithTTL = exports.cachedWithTTL = circular.cached;
+/**
+ * Caches an effect's result for a specified duration and allows manual
+ * invalidation before expiration.
+ *
+ * **Details**
+ *
+ * This function behaves similarly to {@link cachedWithTTL} by caching the
+ * result of an effect for a specified period of time. However, it introduces an
+ * additional feature: it provides an effect that allows you to manually
+ * invalidate the cached result before it naturally expires.
+ *
+ * This gives you more control over the cache, allowing you to refresh the
+ * result when needed, even if the original cache has not yet expired.
+ *
+ * Once the cache is invalidated, the next time the effect is evaluated, the
+ * result will be recomputed, and the cache will be refreshed.
+ *
+ * **When to Use**
+ *
+ * Use this function when you have an effect whose result needs to be cached for
+ * a certain period, but you also want the option to refresh the cache manually
+ * before the expiration time.
+ *
+ * This is useful when you need to ensure that the cached data remains valid for
+ * a certain period but still want to invalidate it if the underlying data
+ * changes or if you want to force a recomputation.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * let i = 1
+ * const expensiveTask = Effect.promise(() => {
+ * console.log("expensive task...")
+ * return new Promise((resolve) => {
+ * setTimeout(() => {
+ * resolve(`result ${i++}`)
+ * }, 100)
+ * })
+ * })
+ *
+ * const program = Effect.gen(function* () {
+ * const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(
+ * expensiveTask,
+ * "1 hour"
+ * )
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * yield* invalidate
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // expensive task...
+ * // result 1
+ * // result 1
+ * // expensive task...
+ * // result 2
+ * ```
+ *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedWithTTL} for a similar function that caches the result for
+ * a specified duration but does not include an effect for manual invalidation.
+ *
+ * @since 2.0.0
+ * @category Caching
+ */
+const cachedInvalidateWithTTL = exports.cachedInvalidateWithTTL = circular.cachedInvalidateWithTTL;
+/**
+ * Returns an effect that lazily computes a result and caches it for subsequent
+ * evaluations.
+ *
+ * **Details**
+ *
+ * This function wraps an effect and ensures that its result is computed only
+ * once. Once the result is computed, it is cached, meaning that subsequent
+ * evaluations of the same effect will return the cached result without
+ * re-executing the logic.
+ *
+ * **When to Use**
+ *
+ * Use this function when you have an expensive or time-consuming operation that
+ * you want to avoid repeating. The first evaluation will compute the result,
+ * and all following evaluations will immediately return the cached value,
+ * improving performance and reducing unnecessary work.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * let i = 1
+ * const expensiveTask = Effect.promise(() => {
+ * console.log("expensive task...")
+ * return new Promise((resolve) => {
+ * setTimeout(() => {
+ * resolve(`result ${i++}`)
+ * }, 100)
+ * })
+ * })
+ *
+ * const program = Effect.gen(function* () {
+ * console.log("non-cached version:")
+ * yield* expensiveTask.pipe(Effect.andThen(Console.log))
+ * yield* expensiveTask.pipe(Effect.andThen(Console.log))
+ * console.log("cached version:")
+ * const cached = yield* Effect.cached(expensiveTask)
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * yield* cached.pipe(Effect.andThen(Console.log))
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // non-cached version:
+ * // expensive task...
+ * // result 1
+ * // expensive task...
+ * // result 2
+ * // cached version:
+ * // expensive task...
+ * // result 3
+ * // result 3
+ * ```
+ *
+ * @see {@link cachedWithTTL} for a similar function that includes a
+ * time-to-live duration for the cached value.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
+ *
+ * @since 2.0.0
+ * @category Caching
+ */
+const cached = exports.cached = effect.memoize;
+/**
+ * Returns a memoized version of a function with effects, reusing results for
+ * the same inputs.
+ *
+ * **Details**
+ *
+ * This function creates a memoized version of a given function that performs an
+ * effect. Memoization ensures that once a result is computed for a specific
+ * input, it is stored and reused for subsequent calls with the same input,
+ * reducing the need to recompute the result.
+ *
+ * The function can optionally take an `Equivalence` parameter to
+ * determine how inputs are compared for caching purposes.
+ *
+ * **When to Use**
+ *
+ * Use this function when you have a function that performs an effect and you
+ * want to avoid recomputing the result for the same input multiple times.
+ *
+ * It's ideal for functions that produce deterministic results based on their
+ * inputs, and you want to improve performance by caching the output.
+ *
+ * This is particularly useful in scenarios where the function involves
+ * expensive calculations or operations that should be avoided after the first
+ * execution with the same parameters.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function* () {
+ * const randomNumber = (n: number) => Random.nextIntBetween(1, n)
+ * console.log("non-memoized version:")
+ * console.log(yield* randomNumber(10))
+ * console.log(yield* randomNumber(10))
+ *
+ * console.log("memoized version:")
+ * const memoized = yield* Effect.cachedFunction(randomNumber)
+ * console.log(yield* memoized(10))
+ * console.log(yield* memoized(10))
+ * })
+ *
+ * Effect.runFork(program)
+ * // Example Output:
+ * // non-memoized version:
+ * // 2
+ * // 8
+ * // memoized version:
+ * // 5
+ * // 5
+ * ```
+ *
+ * @since 2.0.0
+ * @category Caching
+ */
+const cachedFunction = exports.cachedFunction = circular.cachedFunction;
+/**
+ * Returns an effect that executes only once, regardless of how many times it's
+ * called.
+ *
+ * **Details**
+ *
+ * This function ensures that a specific effect is executed only a single time,
+ * no matter how many times it is invoked. The result of the effect will be
+ * cached, and subsequent calls to the effect will immediately return the cached
+ * result without re-executing the original logic.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to perform a task only once, regardless of
+ * how many times the effect is triggered. It's particularly useful when you
+ * have initialization tasks, logging, or other one-time actions that should not
+ * be repeated. This can help optimize performance and avoid redundant actions.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const program = Effect.gen(function* () {
+ * const task1 = Console.log("task1")
+ * yield* Effect.repeatN(task1, 2)
+ * const task2 = yield* Effect.once(Console.log("task2"))
+ * yield* Effect.repeatN(task2, 2)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task1
+ * // task1
+ * // task1
+ * // task2
+ * ```
+ *
+ * @since 2.0.0
+ * @category Caching
+ */
+const once = exports.once = effect.once;
+/**
+ * Combines multiple effects into one, returning results based on the input
+ * structure.
+ *
+ * **Details**
+ *
+ * Use this function when you need to run multiple effects and combine their
+ * results into a single output. It supports tuples, iterables, structs, and
+ * records, making it flexible for different input types.
+ *
+ * For instance, if the input is a tuple:
+ *
+ * ```ts skip-type-checking
+ * // ┌─── a tuple of effects
+ * // ▼
+ * Effect.all([effect1, effect2, ...])
+ * ```
+ *
+ * the effects are executed sequentially, and the result is a new effect
+ * containing the results as a tuple. The results in the tuple match the order
+ * of the effects passed to `Effect.all`.
+ *
+ * **Concurrency**
+ *
+ * You can control the execution order (e.g., sequential vs. concurrent) using
+ * the `concurrency` option.
+ *
+ * **Short-Circuiting Behavior**
+ *
+ * This function stops execution on the first error it encounters, this is
+ * called "short-circuiting". If any effect in the collection fails, the
+ * remaining effects will not run, and the error will be propagated. To change
+ * this behavior, you can use the `mode` option, which allows all effects to run
+ * and collect results as `Either` or `Option`.
+ *
+ * **The `mode` option**
+ *
+ * The `{ mode: "either" }` option changes the behavior of `Effect.all` to
+ * ensure all effects run, even if some fail. Instead of stopping on the first
+ * failure, this mode collects both successes and failures, returning an array
+ * of `Either` instances where each result is either a `Right` (success) or a
+ * `Left` (failure).
+ *
+ * Similarly, the `{ mode: "validate" }` option uses `Option` to indicate
+ * success or failure. Each effect returns `None` for success and `Some` with
+ * the error for failure.
+ *
+ * **Example** (Combining Effects in Tuples)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const tupleOfEffects = [
+ * Effect.succeed(42).pipe(Effect.tap(Console.log)),
+ * Effect.succeed("Hello").pipe(Effect.tap(Console.log))
+ * ] as const
+ *
+ * // ┌─── Effect<[number, string], never, never>
+ * // ▼
+ * const resultsAsTuple = Effect.all(tupleOfEffects)
+ *
+ * Effect.runPromise(resultsAsTuple).then(console.log)
+ * // Output:
+ * // 42
+ * // Hello
+ * // [ 42, 'Hello' ]
+ * ```
+ *
+ * **Example** (Combining Effects in Iterables)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const iterableOfEffects: Iterable> = [1, 2, 3].map(
+ * (n) => Effect.succeed(n).pipe(Effect.tap(Console.log))
+ * )
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const resultsAsArray = Effect.all(iterableOfEffects)
+ *
+ * Effect.runPromise(resultsAsArray).then(console.log)
+ * // Output:
+ * // 1
+ * // 2
+ * // 3
+ * // [ 1, 2, 3 ]
+ * ```
+ *
+ * **Example** (Combining Effects in Structs)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const structOfEffects = {
+ * a: Effect.succeed(42).pipe(Effect.tap(Console.log)),
+ * b: Effect.succeed("Hello").pipe(Effect.tap(Console.log))
+ * }
+ *
+ * // ┌─── Effect<{ a: number; b: string; }, never, never>
+ * // ▼
+ * const resultsAsStruct = Effect.all(structOfEffects)
+ *
+ * Effect.runPromise(resultsAsStruct).then(console.log)
+ * // Output:
+ * // 42
+ * // Hello
+ * // { a: 42, b: 'Hello' }
+ * ```
+ *
+ * **Example** (Combining Effects in Records)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const recordOfEffects: Record> = {
+ * key1: Effect.succeed(1).pipe(Effect.tap(Console.log)),
+ * key2: Effect.succeed(2).pipe(Effect.tap(Console.log))
+ * }
+ *
+ * // ┌─── Effect<{ [x: string]: number; }, never, never>
+ * // ▼
+ * const resultsAsRecord = Effect.all(recordOfEffects)
+ *
+ * Effect.runPromise(resultsAsRecord).then(console.log)
+ * // Output:
+ * // 1
+ * // 2
+ * // { key1: 1, key2: 2 }
+ * ```
+ *
+ * **Example** (Short-Circuiting Behavior)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const program = Effect.all([
+ * Effect.succeed("Task1").pipe(Effect.tap(Console.log)),
+ * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)),
+ * // Won't execute due to earlier failure
+ * Effect.succeed("Task3").pipe(Effect.tap(Console.log))
+ * ])
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // Task1
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Task2: Oh no!' }
+ * // }
+ * ```
+ *
+ * **Example** (Collecting Results with `mode: "either"`)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const effects = [
+ * Effect.succeed("Task1").pipe(Effect.tap(Console.log)),
+ * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)),
+ * Effect.succeed("Task3").pipe(Effect.tap(Console.log))
+ * ]
+ *
+ * const program = Effect.all(effects, { mode: "either" })
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // Task1
+ * // Task3
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Success',
+ * // value: [
+ * // { _id: 'Either', _tag: 'Right', right: 'Task1' },
+ * // { _id: 'Either', _tag: 'Left', left: 'Task2: Oh no!' },
+ * // { _id: 'Either', _tag: 'Right', right: 'Task3' }
+ * // ]
+ * // }
+ * ```
+ *
+ * **Example** (Collecting Results with `mode: "validate"`)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const effects = [
+ * Effect.succeed("Task1").pipe(Effect.tap(Console.log)),
+ * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)),
+ * Effect.succeed("Task3").pipe(Effect.tap(Console.log))
+ * ]
+ *
+ * const program = Effect.all(effects, { mode: "validate" })
+ *
+ * Effect.runPromiseExit(program).then((result) => console.log("%o", result))
+ * // Output:
+ * // Task1
+ * // Task3
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: [
+ * // { _id: 'Option', _tag: 'None' },
+ * // { _id: 'Option', _tag: 'Some', value: 'Task2: Oh no!' },
+ * // { _id: 'Option', _tag: 'None' }
+ * // ]
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link forEach} for iterating over elements and applying an effect.
+ * @see {@link allWith} for a data-last version of this function.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const all = exports.all = fiberRuntime.all;
+/**
+ * A data-last version of {@link all}, designed for use in pipelines.
+ *
+ * **When to Use**
+ *
+ * This function enables you to combine multiple effects and customize execution
+ * options such as concurrency levels. This version is useful in functional
+ * pipelines where you first define your data and then apply operations to it.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ *
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * const program = pipe(
+ * [task1, task2],
+ * // Run both effects concurrently using the concurrent option
+ * Effect.allWith({ concurrency: 2 })
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#3 message="task2 done"
+ * // timestamp=... level=INFO fiber=#2 message="task1 done"
+ * // [ 1, 'hello' ]
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const allWith = exports.allWith = fiberRuntime.allWith;
+/**
+ * Evaluates and runs each effect in the iterable, collecting only the
+ * successful results while discarding failures.
+ *
+ * **Details**
+ *
+ * This function function processes an iterable of effects and runs each one. If
+ * an effect is successful, its result is collected; if it fails, the result is
+ * discarded. This ensures that only successful outcomes are kept.
+ *
+ * **Options**
+ *
+ * The function also allows you to customize how the effects are handled by
+ * specifying options such as concurrency, batching, and how finalizers behave.
+ * These options provide flexibility in running the effects concurrently or
+ * adjusting other execution details.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const tasks = [
+ * Effect.succeed(1),
+ * Effect.fail("Error 1"),
+ * Effect.succeed(2),
+ * Effect.fail("Error 2")
+ * ]
+ *
+ * const program = Effect.gen(function*() {
+ * const successfulResults = yield* Effect.allSuccesses(tasks)
+ * console.log(successfulResults)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [1, 2]
+ *
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const allSuccesses = exports.allSuccesses = fiberRuntime.allSuccesses;
+/**
+ * Drops elements until the effectful predicate returns `true`.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and uses an effectful
+ * predicate to determine when to stop dropping elements. It drops elements from
+ * the beginning of the collection until the predicate returns `true`.
+ *
+ * The predicate is a function that takes an element and its index in the
+ * collection and returns an effect that evaluates to a boolean.
+ *
+ * Once the predicate returns `true`, the remaining elements of the collection
+ * are returned.
+ *
+ * **Note**: The first element for which the predicate returns `true` is also
+ * dropped.
+ *
+ * **When to Use**
+ *
+ * This function allows you to conditionally skip over a part of the collection
+ * based on some criteria defined in the predicate.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const predicate = (n: number, i: number) => Effect.succeed(n > 3)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.dropUntil(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [5, 6]
+ * ```
+ *
+ * @see {@link dropWhile} for a similar function that drops elements while the
+ * predicate returns `true`.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const dropUntil = exports.dropUntil = effect.dropUntil;
+/**
+ * Drops elements as long as the predicate returns `true`.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and uses a predicate to
+ * decide whether to drop an element.
+ *
+ * The predicate is a function that takes an element and its index, and it
+ * returns an effect that evaluates to a boolean.
+ *
+ * As long as the predicate returns `true`, elements will continue to be dropped
+ * from the collection.
+ *
+ * Once the predicate returns `false`, the remaining elements are kept.
+ *
+ * **When to Use**
+ *
+ * This function allows you to discard elements from the start of a collection
+ * based on a condition, and only keep the rest when the condition no longer
+ * holds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const predicate = (n: number, i: number) => Effect.succeed(n <= 3)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.dropWhile(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [4, 5, 6]
+ * ```
+ *
+ * @see {@link dropUntil} for a similar function that drops elements until the
+ * predicate returns `true`.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const dropWhile = exports.dropWhile = effect.dropWhile;
+/**
+ * Takes elements from a collection until the effectful predicate returns
+ * `true`.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and uses an effectful
+ * predicate to decide when to stop taking elements. The elements are taken from
+ * the beginning of the collection until the predicate returns `true`.
+ *
+ * The predicate is a function that takes an element and its index in the
+ * collection, and returns an effect that resolves to a boolean.
+ *
+ * Once the predicate returns `true`, the remaining elements of the collection
+ * are discarded, and the function stops taking more elements.
+ *
+ * **Note**: The first element for which the predicate returns `true` is also
+ * included in the result.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to conditionally take elements from a
+ * collection based on a dynamic condition. For example, you may want to collect
+ * numbers from a list until a certain threshold is reached, or gather items
+ * until a specific condition is met.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const predicate = (n: number, i: number) => Effect.succeed(n > 3)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.takeUntil(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [ 1, 2, 3, 4 ]
+ * ```
+ *
+ * @see {@link takeWhile} for a similar function that takes elements while the
+ * predicate returns `true`.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const takeUntil = exports.takeUntil = effect.takeUntil;
+/**
+ * Takes elements as long as the predicate returns `true`.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and uses a predicate to
+ * decide whether to take an element.
+ *
+ * The predicate is a function that takes an element and its index, and it
+ * returns an effect that evaluates to a boolean.
+ *
+ * As long as the predicate returns `true`, elements will continue to be taken
+ * from the collection.
+ *
+ * Once the predicate returns `false`, the remaining elements are discarded.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const predicate = (n: number, i: number) => Effect.succeed(n <= 3)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.takeWhile(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [1, 2, 3]
+ * ```
+ *
+ * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const takeWhile = exports.takeWhile = effect.takeWhile;
+/**
+ * Determines whether all elements of the iterable satisfy the effectful
+ * predicate.
+ *
+ * **Details**
+ *
+ * This function checks whether every element in a given collection (an
+ * iterable) satisfies a condition defined by an effectful predicate.
+ *
+ * The predicate is a function that takes an element and its index, and it
+ * returns an effect that evaluates to a boolean.
+ *
+ * The function will process each element and return `true` if all elements
+ * satisfy the predicate; otherwise, it returns `false`.
+ *
+ * **When to Use**
+ *
+ * This function is useful when you need to verify that all items in a
+ * collection meet certain criteria, even when the evaluation of each item
+ * involves effects, such as asynchronous checks or complex computations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [2, 4, 6, 8]
+ * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0)
+ *
+ * const program = Effect.gen(function*() {
+ * const allEven = yield* Effect.every(numbers, predicate)
+ * console.log(allEven)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: true
+ * ```
+ *
+ * @see {@link exists} for a similar function that returns a boolean indicating
+ * whether **any** element satisfies the predicate.
+ *
+ * @since 2.0.0
+ * @category Condition Checking
+ */
+const every = exports.every = effect.every;
+/**
+ * Determines whether any element of the iterable satisfies the effectual
+ * predicate.
+ *
+ * **Details**
+ *
+ * This function checks whether any element in a given collection (an iterable)
+ * satisfies a condition defined by an effectful predicate.
+ *
+ * The predicate is a function that takes an element and its index, and it
+ * returns an effect that evaluates to a boolean.
+ *
+ * The function will process each element, and if any element satisfies the
+ * predicate (returns `true`), the function will immediately return `true`.
+ *
+ * If none of the elements satisfy the condition, it will return `false`.
+ *
+ * **When to Use**
+ *
+ * This function allows you to quickly check for a condition in a collection
+ * without having to manually iterate over it.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4]
+ * const predicate = (n: number, i: number) => Effect.succeed(n > 2)
+ *
+ * const program = Effect.gen(function*() {
+ * const hasLargeNumber = yield* Effect.exists(numbers, predicate)
+ * console.log(hasLargeNumber)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: true
+ * ```
+ *
+ * @see {@link every} for a similar function that checks if **all** elements
+ * satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category Condition Checking
+ */
+const exists = exports.exists = fiberRuntime.exists;
+/**
+ * Filters an iterable using the specified effectful predicate.
+ *
+ * **Details**
+ *
+ * This function filters a collection (an iterable) by applying an effectful
+ * predicate.
+ *
+ * The predicate is a function that takes an element and its index, and it
+ * returns an effect that evaluates to a boolean.
+ *
+ * The function processes each element in the collection and keeps only those
+ * that satisfy the condition defined by the predicate.
+ *
+ * **Options**
+ *
+ * You can also adjust the behavior with options such as concurrency, batching,
+ * or whether to negate the condition.
+ *
+ * **When to Use**
+ *
+ * This function allows you to selectively keep or remove elements based on a
+ * condition that may involve asynchronous or side-effect-causing operations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5]
+ * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.filter(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: [2, 4]
+ * ```
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filter = exports.filter = fiberRuntime.filter;
+/**
+ * Filters and maps elements sequentially in one operation.
+ *
+ * This function processes each element one by one. It applies a function that
+ * returns an `Option` to each element. If the function returns `Some`, the
+ * element is kept; if it returns `None`, the element is removed. The operation
+ * is done sequentially for each element.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect, Option } from "effect"
+ *
+ * const task = (n: number) =>
+ * Effect.succeed(n).pipe(
+ * Effect.delay(1000 - (n * 100)),
+ * Effect.tap(Console.log(`task${n} done`))
+ * )
+ *
+ * const program = Effect.filterMap(
+ * [task(1), task(2), task(3), task(4)],
+ * (n) => n % 2 === 0 ? Option.some(n) : Option.none()
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // task1 done
+ * // task2 done
+ * // task3 done
+ * // task4 done
+ * // [ 2, 4 ]
+ * ```
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filterMap = exports.filterMap = effect.filterMap;
+/**
+ * Returns the first element that satisfies the effectful predicate.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and applies an effectful
+ * predicate to each element.
+ *
+ * The predicate is a function that takes an element and its index in the
+ * collection, and it returns an effect that evaluates to a boolean.
+ *
+ * The function stops as soon as it finds the first element for which the
+ * predicate returns `true` and returns that element wrapped in an `Option`.
+ *
+ * If no element satisfies the predicate, the result will be `None`.
+ *
+ * **When to Use**
+ *
+ * This function allows you to efficiently find an element that meets a specific
+ * condition, even when the evaluation involves effects like asynchronous
+ * operations or side effects.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4, 5]
+ * const predicate = (n: number, i: number) => Effect.succeed(n > 3)
+ *
+ * const program = Effect.gen(function*() {
+ * const result = yield* Effect.findFirst(numbers, predicate)
+ * console.log(result)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: { _id: 'Option', _tag: 'Some', value: 4 }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const findFirst = exports.findFirst = effect.findFirst;
+/**
+ * Executes an effectful operation for each element in an `Iterable`.
+ *
+ * **Details**
+ *
+ * This function applies a provided operation to each element in the iterable,
+ * producing a new effect that returns an array of results.
+ *
+ * If any effect fails, the iteration stops immediately (short-circuiting), and
+ * the error is propagated.
+ *
+ * **Concurrency**
+ *
+ * The `concurrency` option controls how many operations are performed
+ * concurrently. By default, the operations are performed sequentially.
+ *
+ * **Discarding Results**
+ *
+ * If the `discard` option is set to `true`, the intermediate results are not
+ * collected, and the final result of the operation is `void`.
+ *
+ * **Example** (Applying Effects to Iterable Elements)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) =>
+ * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2))
+ * )
+ *
+ * Effect.runPromise(result).then(console.log)
+ * // Output:
+ * // Currently at index 0
+ * // Currently at index 1
+ * // Currently at index 2
+ * // Currently at index 3
+ * // Currently at index 4
+ * // [ 2, 4, 6, 8, 10 ]
+ * ```
+ *
+ * **Example** (Discarding Results)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // Apply effects but discard the results
+ * const result = Effect.forEach(
+ * [1, 2, 3, 4, 5],
+ * (n, index) =>
+ * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)),
+ * { discard: true }
+ * )
+ *
+ * Effect.runPromise(result).then(console.log)
+ * // Output:
+ * // Currently at index 0
+ * // Currently at index 1
+ * // Currently at index 2
+ * // Currently at index 3
+ * // Currently at index 4
+ * // undefined
+ * ```
+ *
+ * @see {@link all} for combining multiple effects into one.
+ *
+ * @since 2.0.0
+ * @category Looping
+ */
+const forEach = exports.forEach = fiberRuntime.forEach;
+/**
+ * Returns the first element of the iterable if the collection is non-empty, or
+ * fails with the error `NoSuchElementException` if the collection is empty.
+ *
+ * **When to Use**
+ *
+ * This function is useful when you need to retrieve the first item from a
+ * collection and want to handle the case where the collection might be empty
+ * without causing an unhandled exception.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Simulate an async operation
+ * const fetchNumbers = Effect.succeed([1, 2, 3]).pipe(Effect.delay("100 millis"))
+ *
+ * const program = Effect.gen(function*() {
+ * const firstElement = yield* Effect.head(fetchNumbers)
+ * console.log(firstElement)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: 1
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const head = exports.head = effect.head;
+/**
+ * Merges an `Iterable>` to a single effect.
+ *
+ * **Details**
+ *
+ * This function takes an iterable of effects and combines them into a single
+ * effect. It does this by iterating over each effect in the collection and
+ * applying a function that accumulates results into a "zero" value, which
+ * starts with an initial value and is updated with each effect's success.
+ *
+ * The provided function `f` is called for each element in the iterable,
+ * allowing you to specify how to combine the results.
+ *
+ * **Options**
+ *
+ * The function also allows you to customize how the effects are handled by
+ * specifying options such as concurrency, batching, and how finalizers behave.
+ * These options provide flexibility in running the effects concurrently or
+ * adjusting other execution details.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const numbers = [Effect.succeed(1), Effect.succeed(2), Effect.succeed(3)]
+ * const add = (sum: number, value: number, i: number) => sum + value
+ * const zero = 0
+ *
+ * const program = Effect.gen(function*() {
+ * const total = yield* Effect.mergeAll(numbers, zero, add)
+ * console.log(total)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: 6
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const mergeAll = exports.mergeAll = fiberRuntime.mergeAll;
+/**
+ * Processes an iterable and applies an effectful function to each element,
+ * categorizing the results into successes and failures.
+ *
+ * **Details**
+ *
+ * This function processes each element in the provided iterable by applying an
+ * effectful function to it. The results are then categorized into two separate
+ * lists: one for failures and another for successes. This separation allows you
+ * to handle the two categories differently. Failures are collected in a list
+ * without interrupting the processing of the remaining elements, so the
+ * operation continues even if some elements fail. This is particularly useful
+ * when you need to handle both successful and failed results separately,
+ * without stopping the entire process on encountering a failure.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to process a collection of items and handle
+ * errors or failures without interrupting the processing of other items. It's
+ * useful when you need to distinguish between successful and failed results and
+ * process them separately, for example, when logging errors while continuing to
+ * work with valid data. The function ensures that failures are captured, while
+ * successes are processed normally.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect<[string[], number[]], never, never>
+ * // ▼
+ * const program = Effect.partition([0, 1, 2, 3, 4], (n) => {
+ * if (n % 2 === 0) {
+ * return Effect.succeed(n)
+ * } else {
+ * return Effect.fail(`${n} is not even`)
+ * }
+ * })
+ *
+ * Effect.runPromise(program).then(console.log, console.error)
+ * // Output:
+ * // [ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ]
+ * ```
+ *
+ * @see {@link validateAll} for a function that either collects all failures or all successes.
+ * @see {@link validateFirst} for a function that stops at the first success.
+ *
+ * @since 2.0.0
+ * @category Error Accumulation
+ */
+const partition = exports.partition = fiberRuntime.partition;
+/**
+ * Reduces an `Iterable` using an effectual function `f`, working
+ * sequentially from left to right.
+ *
+ * **Details**
+ *
+ * This function takes an iterable and applies a function `f` to each element in
+ * the iterable. The function works sequentially, starting with an initial value
+ * `zero` and then combining it with each element in the collection. The
+ * provided function `f` is called for each element in the iterable, allowing
+ * you to accumulate a result based on the current value and the element being
+ * processed.
+ *
+ * **When to Use**
+ *
+ * The function is often used for operations like summing a collection of
+ * numbers or combining results from multiple tasks. It ensures that operations
+ * are performed one after the other, maintaining the order of the elements.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const processOrder = (id: number) =>
+ * Effect.succeed({ id, price: 100 * id })
+ * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100)))
+ *
+ * const program = Effect.reduce(
+ * [1, 2, 3, 4],
+ * 0,
+ * (acc, id, i) =>
+ * processOrder(id)
+ * .pipe(Effect.map((order) => acc + order.price))
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // Order 1 processed
+ * // Order 2 processed
+ * // Order 3 processed
+ * // Order 4 processed
+ * // 1000
+ * ```
+ *
+ * @see {@link reduceWhile} for a similar function that stops the process based on a predicate.
+ * @see {@link reduceRight} for a similar function that works from right to left.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const reduce = exports.reduce = effect.reduce;
+/**
+ * Reduces an `Iterable` using an effectual function `body`, working
+ * sequentially from left to right, stopping the process early when the
+ * predicate `while` is not satisfied.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements, applying a function `body`
+ * to reduce them to a single value, starting from the first element. It checks
+ * the value of the accumulator against a predicate (`while`). If at any point
+ * the predicate returns `false`, the reduction stops, and the accumulated
+ * result is returned.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to reduce a collection of elements, but only
+ * continue the process as long as a certain condition holds true. For example,
+ * if you want to sum values in a list but stop as soon as the sum exceeds a
+ * certain threshold, you can use this function.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const processOrder = (id: number) =>
+ * Effect.succeed({ id, price: 100 * id })
+ * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100)))
+ *
+ * const program = Effect.reduceWhile(
+ * [1, 2, 3, 4],
+ * 0,
+ * {
+ * body: (acc, id, i) =>
+ * processOrder(id)
+ * .pipe(Effect.map((order) => acc + order.price)),
+ * while: (acc) => acc < 500
+ * }
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // Order 1 processed
+ * // Order 2 processed
+ * // Order 3 processed
+ * // 600
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const reduceWhile = exports.reduceWhile = effect.reduceWhile;
+/**
+ * Reduces an `Iterable` using an effectual function `f`, working
+ * sequentially from right to left.
+ *
+ * **Details**
+ *
+ * This function takes an iterable and applies a function `f` to each element in
+ * the iterable. The function works sequentially, starting with an initial value
+ * `zero` and then combining it with each element in the collection. The
+ * provided function `f` is called for each element in the iterable, allowing
+ * you to accumulate a result based on the current value and the element being
+ * processed.
+ *
+ * **When to Use**
+ *
+ * The function is often used for operations like summing a collection of
+ * numbers or combining results from multiple tasks. It ensures that operations
+ * are performed one after the other, maintaining the order of the elements.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const processOrder = (id: number) =>
+ * Effect.succeed({ id, price: 100 * id })
+ * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100)))
+ *
+ * const program = Effect.reduceRight(
+ * [1, 2, 3, 4],
+ * 0,
+ * (id, acc, i) =>
+ * processOrder(id)
+ * .pipe(Effect.map((order) => acc + order.price))
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // Order 4 processed
+ * // Order 3 processed
+ * // Order 2 processed
+ * // Order 1 processed
+ * // 1000
+ * ```
+ *
+ * @see {@link reduce} for a similar function that works from left to right.
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const reduceRight = exports.reduceRight = effect.reduceRight;
+/**
+ * Reduces an `Iterable>` to a single effect.
+ *
+ * **Details**
+ *
+ * This function processes a collection of effects and combines them into one
+ * single effect. It starts with an initial effect (`zero`) and applies a
+ * function `f` to each element in the collection.
+ *
+ * **Options**
+ *
+ * The function also allows you to customize how the effects are handled by
+ * specifying options such as concurrency, batching, and how finalizers behave.
+ * These options provide flexibility in running the effects concurrently or
+ * adjusting other execution details.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const processOrder = (id: number) =>
+ * Effect.succeed({ id, price: 100 * id })
+ * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100)))
+ *
+ * const program = Effect.reduceEffect(
+ * [processOrder(1), processOrder(2), processOrder(3), processOrder(4)],
+ * Effect.succeed(0),
+ * (acc, order, i) => acc + order.price
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // Order 1 processed
+ * // Order 2 processed
+ * // Order 3 processed
+ * // Order 4 processed
+ * // 1000
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const reduceEffect = exports.reduceEffect = fiberRuntime.reduceEffect;
+/**
+ * Replicates the given effect `n` times.
+ *
+ * **Details**
+ *
+ * This function takes an effect and replicates it a specified number of times
+ * (`n`). The result is an array of `n` effects, each of which is identical to
+ * the original effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const task = Effect.succeed("Hello, World!").pipe(
+ * Effect.tap(Console.log)
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ * // Replicate the task 3 times
+ * const tasks = Effect.replicate(task, 3)
+ * for (const t of tasks) {
+ * // Run each task
+ * yield* t
+ * }
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // Hello, World!
+ * // Hello, World!
+ * // Hello, World!
+ * ```
+ *
+ * @since 2.0.0
+ */
+const replicate = exports.replicate = fiberRuntime.replicate;
+/**
+ * Performs this effect the specified number of times and collects the results.
+ *
+ * **Details**
+ *
+ * This function repeats an effect multiple times and collects the results into
+ * an array. You specify how many times to execute the effect, and it runs that
+ * many times, either in sequence or concurrently depending on the provided
+ * options.
+ *
+ * **Options**
+ *
+ * If the `discard` option is set to `true`, the intermediate results are not
+ * collected, and the final result of the operation is `void`.
+ *
+ * The function also allows you to customize how the effects are handled by
+ * specifying options such as concurrency, batching, and how finalizers behave.
+ * These options provide flexibility in running the effects concurrently or
+ * adjusting other execution details.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * let counter = 0
+ *
+ * const task = Effect.sync(() => ++counter).pipe(
+ * Effect.tap(() => Console.log(`Task completed`))
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ * // Replicate the task 3 times and collect the results
+ * const results = yield* Effect.replicateEffect(task, 3)
+ * yield* Console.log(`Results: ${results.join(", ")}`)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // Task completed
+ * // Task completed
+ * // Task completed
+ * // Results: 1, 2, 3
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+const replicateEffect = exports.replicateEffect = fiberRuntime.replicateEffect;
+/**
+ * Applies an effectful operation to each element in a collection while
+ * collecting both successes and failures.
+ *
+ * **Details**
+ *
+ * This function allows you to apply an effectful operation to every item in a
+ * collection.
+ *
+ * Unlike {@link forEach}, which would stop at the first error, this function
+ * continues processing all elements, accumulating both successes and failures.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to process every item in a collection, even
+ * if some items fail. This is particularly useful when you need to perform
+ * operations on all elements without halting due to an error.
+ *
+ * Keep in mind that if there are any failures, **all successes will be lost**,
+ * so this function is not suitable when you need to keep the successful results
+ * in case of errors.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => {
+ * if (n < 4) {
+ * return Console.log(`item ${n}`).pipe(Effect.as(n))
+ * } else {
+ * return Effect.fail(`${n} is not less that 4`)
+ * }
+ * })
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // item 1
+ * // item 2
+ * // item 3
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: [ '4 is not less that 4', '5 is not less that 4' ]
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link forEach} for a similar function that stops at the first error.
+ * @see {@link partition} when you need to separate successes and failures
+ * instead of losing successes with errors.
+ *
+ * @since 2.0.0
+ * @category Error Accumulation
+ */
+const validateAll = exports.validateAll = fiberRuntime.validateAll;
+/**
+ * This function is similar to {@link validateAll} but with a key difference: it
+ * returns the first successful result or all errors if none of the operations
+ * succeed.
+ *
+ * **Details**
+ *
+ * This function processes a collection of elements and applies an effectful
+ * operation to each. Unlike {@link validateAll}, which accumulates both
+ * successes and failures, `Effect.validateFirst` stops and returns the first
+ * success it encounters. If no success occurs, it returns all accumulated
+ * errors. This can be useful when you are interested in the first successful
+ * result and want to avoid processing further once a valid result is found.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.validateFirst([1, 2, 3, 4, 5], (n) => {
+ * if (n < 4) {
+ * return Effect.fail(`${n} is not less that 4`)
+ * } else {
+ * return Console.log(`item ${n}`).pipe(Effect.as(n))
+ * }
+ * })
+ *
+ * Effect.runPromise(program).then(console.log, console.error)
+ * // Output:
+ * // item 4
+ * // 4
+ * ```
+ *
+ * @see {@link validateAll} for a similar function that accumulates all results.
+ * @see {@link firstSuccessOf} for a similar function that processes multiple
+ * effects and returns the first successful one or the last error.
+ *
+ * @since 2.0.0
+ * @category Error Accumulation
+ */
+const validateFirst = exports.validateFirst = fiberRuntime.validateFirst;
+/**
+ * Creates an `Effect` from a callback-based asynchronous function.
+ *
+ * **Details**
+ *
+ * The `resume` function:
+ * - Must be called exactly once. Any additional calls will be ignored.
+ * - Can return an optional `Effect` that will be run if the `Fiber` executing
+ * this `Effect` is interrupted. This can be useful in scenarios where you
+ * need to handle resource cleanup if the operation is interrupted.
+ * - Can receive an `AbortSignal` to handle interruption if needed.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may also be
+ * specified using the `blockingOn` argument. This is called the "blocking
+ * fiber" because it suspends the fiber executing the `async` effect (i.e.
+ * semantically blocks the fiber from making progress). Specifying this fiber id
+ * in cases where it is known will improve diagnostics, but not affect the
+ * behavior of the returned effect.
+ *
+ * **When to Use**
+ *
+ * Use `Effect.async` when dealing with APIs that use callback-style instead of
+ * `async/await` or `Promise`.
+ *
+ * **Example** (Wrapping a Callback API)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as NodeFS from "node:fs"
+ *
+ * const readFile = (filename: string) =>
+ * Effect.async((resume) => {
+ * NodeFS.readFile(filename, (error, data) => {
+ * if (error) {
+ * // Resume with a failed Effect if an error occurs
+ * resume(Effect.fail(error))
+ * } else {
+ * // Resume with a succeeded Effect if successful
+ * resume(Effect.succeed(data))
+ * }
+ * })
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = readFile("example.txt")
+ * ```
+ *
+ * **Example** (Handling Interruption with Cleanup)
+ *
+ * ```ts
+ * import { Effect, Fiber } from "effect"
+ * import * as NodeFS from "node:fs"
+ *
+ * // Simulates a long-running operation to write to a file
+ * const writeFileWithCleanup = (filename: string, data: string) =>
+ * Effect.async((resume) => {
+ * const writeStream = NodeFS.createWriteStream(filename)
+ *
+ * // Start writing data to the file
+ * writeStream.write(data)
+ *
+ * // When the stream is finished, resume with success
+ * writeStream.on("finish", () => resume(Effect.void))
+ *
+ * // In case of an error during writing, resume with failure
+ * writeStream.on("error", (err) => resume(Effect.fail(err)))
+ *
+ * // Handle interruption by returning a cleanup effect
+ * return Effect.sync(() => {
+ * console.log(`Cleaning up ${filename}`)
+ * NodeFS.unlinkSync(filename)
+ * })
+ * })
+ *
+ * const program = Effect.gen(function* () {
+ * const fiber = yield* Effect.fork(
+ * writeFileWithCleanup("example.txt", "Some long data...")
+ * )
+ * // Simulate interrupting the fiber after 1 second
+ * yield* Effect.sleep("1 second")
+ * yield* Fiber.interrupt(fiber) // This will trigger the cleanup
+ * })
+ *
+ * // Run the program
+ * Effect.runPromise(program)
+ * // Output:
+ * // Cleaning up example.txt
+ * ```
+ *
+ * **Example** (Handling Interruption with AbortSignal)
+ *
+ * ```ts
+ * import { Effect, Fiber } from "effect"
+ *
+ * // A task that supports interruption using AbortSignal
+ * const interruptibleTask = Effect.async((resume, signal) => {
+ * // Handle interruption
+ * signal.addEventListener("abort", () => {
+ * console.log("Abort signal received")
+ * clearTimeout(timeoutId)
+ * })
+ *
+ * // Simulate a long-running task
+ * const timeoutId = setTimeout(() => {
+ * console.log("Operation completed")
+ * resume(Effect.void)
+ * }, 2000)
+ * })
+ *
+ * const program = Effect.gen(function* () {
+ * const fiber = yield* Effect.fork(interruptibleTask)
+ * // Simulate interrupting the fiber after 1 second
+ * yield* Effect.sleep("1 second")
+ * yield* Fiber.interrupt(fiber)
+ * })
+ *
+ * // Run the program
+ * Effect.runPromise(program)
+ * // Output:
+ * // Abort signal received
+ * ```
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const async = exports.async = core.async;
+/**
+ * A variant of {@link async} where the registration function may return an `Effect`.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const asyncEffect = exports.asyncEffect = runtime_.asyncEffect;
+/**
+ * Low level constructor that enables for custom stack tracing cutpoints.
+ *
+ * It is meant to be called with a bag of instructions that become available in
+ * the "this" of the effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const throwingFunction = () => { throw new Error() }
+ * const blowUp = Effect.custom(throwingFunction, function() {
+ * return Effect.succeed(this.effect_instruction_i0())
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const custom = exports.custom = core.custom;
+/**
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const withFiberRuntime = exports.withFiberRuntime = core.withFiberRuntime;
+/**
+ * Creates an `Effect` that represents a recoverable error.
+ *
+ * **When to Use**
+ *
+ * Use this function to explicitly signal an error in an `Effect`. The error
+ * will keep propagating unless it is handled. You can handle the error with
+ * functions like {@link catchAll} or {@link catchTag}.
+ *
+ * **Example** (Creating a Failed Effect)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const failure = Effect.fail(
+ * new Error("Operation failed due to network error")
+ * )
+ * ```
+ *
+ * @see {@link succeed} to create an effect that represents a successful value.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const fail = exports.fail = core.fail;
+/**
+ * Creates an `Effect` that fails with the specified error, evaluated lazily.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const failSync = exports.failSync = core.failSync;
+/**
+ * Creates an `Effect` that fails with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const failCause = exports.failCause = core.failCause;
+/**
+ * Creates an `Effect` that fails with the specified `Cause`, evaluated lazily.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const failCauseSync = exports.failCauseSync = core.failCauseSync;
+/**
+ * Creates an effect that terminates a fiber with a specified error.
+ *
+ * **Details**
+ *
+ * This function is used to signal a defect, which represents a critical and
+ * unexpected error in the code. When invoked, it produces an effect that does
+ * not handle the error and instead terminates the fiber.
+ *
+ * The error channel of the resulting effect is of type `never`, indicating that
+ * it cannot recover from this failure.
+ *
+ * **When to Use**
+ *
+ * Use this function when encountering unexpected conditions in your code that
+ * should not be handled as regular errors but instead represent unrecoverable
+ * defects.
+ *
+ * **Example** (Terminating on Division by Zero with a Specified Error)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const divide = (a: number, b: number) =>
+ * b === 0
+ * ? Effect.die(new Error("Cannot divide by zero"))
+ * : Effect.succeed(a / b)
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = divide(1, 0)
+ *
+ * Effect.runPromise(program).catch(console.error)
+ * // Output:
+ * // (FiberFailure) Error: Cannot divide by zero
+ * // ...stack trace...
+ * ```
+ *
+ * @see {@link dieSync} for a variant that throws a specified error, evaluated
+ * lazily.
+ * @see {@link dieMessage} for a variant that throws a `RuntimeException` with a
+ * message.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const die = exports.die = core.die;
+/**
+ * Creates an effect that terminates a fiber with a `RuntimeException`
+ * containing the specified message.
+ *
+ * **Details**
+ *
+ * This function is used to signal a defect, representing a critical and
+ * unexpected error in the code. When invoked, it produces an effect that
+ * terminates the fiber with a `RuntimeException` carrying the given message.
+ *
+ * The resulting effect has an error channel of type `never`, indicating it does
+ * not handle or recover from the error.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to terminate a fiber due to an unrecoverable
+ * defect and include a clear explanation in the message.
+ *
+ * **Example** (Terminating on Division by Zero with a Specified Message)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const divide = (a: number, b: number) =>
+ * b === 0
+ * ? Effect.dieMessage("Cannot divide by zero")
+ * : Effect.succeed(a / b)
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = divide(1, 0)
+ *
+ * Effect.runPromise(program).catch(console.error)
+ * // Output:
+ * // (FiberFailure) RuntimeException: Cannot divide by zero
+ * // ...stack trace...
+ * ```
+ *
+ * @see {@link die} for a variant that throws a specified error.
+ * @see {@link dieSync} for a variant that throws a specified error, evaluated
+ * lazily.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const dieMessage = exports.dieMessage = core.dieMessage;
+/**
+ * Creates an effect that dies with the specified error, evaluated lazily.
+ *
+ * **Details**
+ *
+ * This function allows you to create an effect that will terminate with a fatal error.
+ * The error is provided as a lazy argument, meaning it will only be evaluated when the effect runs.
+ *
+ * @see {@link die} if you don't need to evaluate the error lazily.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const dieSync = exports.dieSync = core.dieSync;
+/**
+ * Provides a way to write effectful code using generator functions, simplifying
+ * control flow and error handling.
+ *
+ * **When to Use**
+ *
+ * `Effect.gen` allows you to write code that looks and behaves like synchronous
+ * code, but it can handle asynchronous tasks, errors, and complex control flow
+ * (like loops and conditions). It helps make asynchronous code more readable
+ * and easier to manage.
+ *
+ * The generator functions work similarly to `async/await` but with more
+ * explicit control over the execution of effects. You can `yield*` values from
+ * effects and return the final result at the end.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const addServiceCharge = (amount: number) => amount + 1
+ *
+ * const applyDiscount = (
+ * total: number,
+ * discountRate: number
+ * ): Effect.Effect =>
+ * discountRate === 0
+ * ? Effect.fail(new Error("Discount rate cannot be zero"))
+ * : Effect.succeed(total - (total * discountRate) / 100)
+ *
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))
+ *
+ * export const program = Effect.gen(function* () {
+ * const transactionAmount = yield* fetchTransactionAmount
+ * const discountRate = yield* fetchDiscountRate
+ * const discountedAmount = yield* applyDiscount(
+ * transactionAmount,
+ * discountRate
+ * )
+ * const finalAmount = addServiceCharge(discountedAmount)
+ * return `Final amount to charge: ${finalAmount}`
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const gen = exports.gen = core.gen;
+/**
+ * An effect that that runs indefinitely and never produces any result. The
+ * moral equivalent of `while(true) {}`, only without the wasted CPU cycles.
+ *
+ * **When to Use**
+ *
+ * It could be useful for long-running background tasks or to simulate waiting
+ * behavior without actually consuming resources. This effect is ideal for cases
+ * where you want to keep the program alive or in a certain state without
+ * performing any active work.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const never = exports.never = core.never;
+/**
+ * Ensures the `Option` is `None`, returning `void`. Otherwise, raises a
+ * `NoSuchElementException`.
+ *
+ * **Details**
+ *
+ * This function checks if the provided `Option` is `None`. If it is, it returns
+ * an effect that produces no result (i.e., `void`). If the `Option` is not
+ * `None` (i.e., it contains a value), the function will raise a
+ * `NoSuchElementException` error.
+ *
+ * **When to Use**
+ *
+ * This is useful when you want to ensure that a certain value is absent (i.e.,
+ * `None`) before continuing execution, and to handle cases where the value is
+ * unexpectedly present.
+ *
+ * @since 2.0.0
+ */
+const none = exports.none = effect.none;
+/**
+ * Creates an `Effect` that represents an asynchronous computation guaranteed to
+ * succeed.
+ *
+ * **Details**
+ *
+ * The provided function (`thunk`) returns a `Promise` that should never reject; if it does, the error
+ * will be treated as a "defect".
+ *
+ * This defect is not a standard error but indicates a flaw in the logic that
+ * was expected to be error-free. You can think of it similar to an unexpected
+ * crash in the program, which can be further managed or logged using tools like
+ * {@link catchAllDefect}.
+ *
+ * **Interruptions**
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped `Promise` API.
+ *
+ * **When to Use**
+ *
+ * Use this function when you are sure the operation will not reject.
+ *
+ * **Example** (Delayed Message)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const delay = (message: string) =>
+ * Effect.promise(
+ * () =>
+ * new Promise((resolve) => {
+ * setTimeout(() => {
+ * resolve(message)
+ * }, 2000)
+ * })
+ * )
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = delay("Async operation completed successfully!")
+ * ```
+ *
+ * @see {@link tryPromise} for a version that can handle failures.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const promise = exports.promise = effect.promise;
+/**
+ * Creates an `Effect` that always succeeds with a given value.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need an effect that completes successfully with a
+ * specific value without any errors or external dependencies.
+ *
+ * **Example** (Creating a Successful Effect)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Creating an effect that represents a successful scenario
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const success = Effect.succeed(42)
+ * ```
+ *
+ * @see {@link fail} to create an effect that represents a failure.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const succeed = exports.succeed = core.succeed;
+/**
+ * Returns an effect which succeeds with `None`.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to represent the absence of a value in your
+ * code, especially when working with optional data. This can be helpful when
+ * you want to indicate that no result is available without throwing an error or
+ * performing additional logic.
+ *
+ * @see {@link succeedSome} to create an effect that succeeds with a `Some` value.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const succeedNone = exports.succeedNone = effect.succeedNone;
+/**
+ * Returns an effect which succeeds with the value wrapped in a `Some`.
+ *
+ * @see {@link succeedNone} for a similar function that returns `None` when the value is absent.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const succeedSome = exports.succeedSome = effect.succeedSome;
+/**
+ * Delays the creation of an `Effect` until it is actually needed.
+ *
+ * **Details**
+ *
+ * The `Effect.suspend` function takes a thunk that represents the effect and
+ * wraps it in a suspended effect. This means the effect will not be created
+ * until it is explicitly needed, which is helpful in various scenarios:
+ * - **Lazy Evaluation**: Helps optimize performance by deferring computations,
+ * especially when the effect might not be needed, or when its computation is
+ * expensive. This also ensures that any side effects or scoped captures are
+ * re-executed on each invocation.
+ * - **Handling Circular Dependencies**: Useful in managing circular
+ * dependencies, such as recursive functions that need to avoid eager
+ * evaluation to prevent stack overflow.
+ * - **Unifying Return Types**: Can help TypeScript unify return types in
+ * situations where multiple branches of logic return different effects,
+ * simplifying type inference.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to defer the evaluation of an effect until it
+ * is required. This is particularly useful for optimizing expensive
+ * computations, managing circular dependencies, or resolving type inference
+ * issues.
+ *
+ * **Example** (Lazy Evaluation with Side Effects)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * let i = 0
+ *
+ * const bad = Effect.succeed(i++)
+ *
+ * const good = Effect.suspend(() => Effect.succeed(i++))
+ *
+ * console.log(Effect.runSync(bad)) // Output: 0
+ * console.log(Effect.runSync(bad)) // Output: 0
+ *
+ * console.log(Effect.runSync(good)) // Output: 1
+ * console.log(Effect.runSync(good)) // Output: 2
+ * ```
+ *
+ * **Example** (Recursive Fibonacci)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const blowsUp = (n: number): Effect.Effect =>
+ * n < 2
+ * ? Effect.succeed(1)
+ * : Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)
+ *
+ * console.log(Effect.runSync(blowsUp(32)))
+ * // crash: JavaScript heap out of memory
+ *
+ * const allGood = (n: number): Effect.Effect =>
+ * n < 2
+ * ? Effect.succeed(1)
+ * : Effect.zipWith(
+ * Effect.suspend(() => allGood(n - 1)),
+ * Effect.suspend(() => allGood(n - 2)),
+ * (a, b) => a + b
+ * )
+ *
+ * console.log(Effect.runSync(allGood(32)))
+ * // Output: 3524578
+ * ```
+ *
+ * **Example** (Using Effect.suspend to Help TypeScript Infer Types)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Without suspend, TypeScript may struggle with type inference.
+ * // Inferred type:
+ * // (a: number, b: number) =>
+ * // Effect | Effect
+ * const withoutSuspend = (a: number, b: number) =>
+ * b === 0
+ * ? Effect.fail(new Error("Cannot divide by zero"))
+ * : Effect.succeed(a / b)
+ *
+ * // Using suspend to unify return types.
+ * // Inferred type:
+ * // (a: number, b: number) => Effect
+ * const withSuspend = (a: number, b: number) =>
+ * Effect.suspend(() =>
+ * b === 0
+ * ? Effect.fail(new Error("Cannot divide by zero"))
+ * : Effect.succeed(a / b)
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const suspend = exports.suspend = core.suspend;
+/**
+ * Creates an `Effect` that represents a synchronous side-effectful computation.
+ *
+ * **Details**
+ *
+ * The provided function (`thunk`) must not throw errors; if it does, the error
+ * will be treated as a "defect".
+ *
+ * This defect is not a standard error but indicates a flaw in the logic that
+ * was expected to be error-free. You can think of it similar to an unexpected
+ * crash in the program, which can be further managed or logged using tools like
+ * {@link catchAllDefect}.
+ *
+ * **When to Use**
+ *
+ * Use this function when you are sure the operation will not fail.
+ *
+ * **Example** (Logging a Message)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const log = (message: string) =>
+ * Effect.sync(() => {
+ * console.log(message) // side effect
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = log("Hello, World!")
+ * ```
+ *
+ * @see {@link try_ | try} for a version that can handle failures.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const sync = exports.sync = core.sync;
+const _void = exports.void = core.void;
+/**
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const yieldNow = exports.yieldNow = core.yieldNow;
+const _catch = exports.catch = effect._catch;
+/**
+ * Handles all errors in an effect by providing a fallback effect.
+ *
+ * **Details**
+ *
+ * This function catches any errors that may occur during the execution of an
+ * effect and allows you to handle them by specifying a fallback effect. This
+ * ensures that the program continues without failing by recovering from errors
+ * using the provided fallback logic.
+ *
+ * **Note**: This function only handles recoverable errors. It will not recover
+ * from unrecoverable defects.
+ *
+ * **Example** (Providing Recovery Logic for Recoverable Errors)
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = program.pipe(
+ * Effect.catchAll((error) =>
+ * Effect.succeed(`Recovering from ${error._tag}`)
+ * )
+ * )
+ * ```
+ *
+ * @see {@link catchAllCause} for a version that can recover from both
+ * recoverable and unrecoverable errors.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchAll = exports.catchAll = core.catchAll;
+/**
+ * Handles both recoverable and unrecoverable errors by providing a recovery
+ * effect.
+ *
+ * **When to Use**
+ *
+ * The `catchAllCause` function allows you to handle all errors, including
+ * unrecoverable defects, by providing a recovery effect. The recovery logic is
+ * based on the `Cause` of the error, which provides detailed information about
+ * the failure.
+ *
+ * **When to Recover from Defects**
+ *
+ * Defects are unexpected errors that typically shouldn't be recovered from, as
+ * they often indicate serious issues. However, in some cases, such as
+ * dynamically loaded plugins, controlled recovery might be needed.
+ *
+ * **Example** (Recovering from All Errors)
+ *
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ *
+ * // Define an effect that may fail with a recoverable or unrecoverable error
+ * const program = Effect.fail("Something went wrong!")
+ *
+ * // Recover from all errors by examining the cause
+ * const recovered = program.pipe(
+ * Effect.catchAllCause((cause) =>
+ * Cause.isFailure(cause)
+ * ? Effect.succeed("Recovered from a regular error")
+ * : Effect.succeed("Recovered from a defect")
+ * )
+ * )
+ *
+ * Effect.runPromise(recovered).then(console.log)
+ * // Output: "Recovered from a regular error"
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchAllCause = exports.catchAllCause = core.catchAllCause;
+/**
+ * Recovers from all defects using a provided recovery function.
+ *
+ * **When to Use**
+ *
+ * There is no sensible way to recover from defects. This method should be used
+ * only at the boundary between Effect and an external system, to transmit
+ * information on a defect for diagnostic or explanatory purposes.
+ *
+ * **Details**
+ *
+ * `catchAllDefect` allows you to handle defects, which are unexpected errors
+ * that usually cause the program to terminate. This function lets you recover
+ * from these defects by providing a function that handles the error. However,
+ * it does not handle expected errors (like those from {@link fail}) or
+ * execution interruptions (like those from {@link interrupt}).
+ *
+ * **When to Recover from Defects**
+ *
+ * Defects are unexpected errors that typically shouldn't be recovered from, as
+ * they often indicate serious issues. However, in some cases, such as
+ * dynamically loaded plugins, controlled recovery might be needed.
+ *
+ * **Example** (Handling All Defects)
+ *
+ * ```ts
+ * import { Effect, Cause, Console } from "effect"
+ *
+ * // Simulating a runtime error
+ * const task = Effect.dieMessage("Boom!")
+ *
+ * const program = Effect.catchAllDefect(task, (defect) => {
+ * if (Cause.isRuntimeException(defect)) {
+ * return Console.log(
+ * `RuntimeException defect caught: ${defect.message}`
+ * )
+ * }
+ * return Console.log("Unknown defect caught.")
+ * })
+ *
+ * // We get an Exit.Success because we caught all defects
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // RuntimeException defect caught: Boom!
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Success",
+ * // value: undefined
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchAllDefect = exports.catchAllDefect = effect.catchAllDefect;
+/**
+ * Recovers from specific errors based on a predicate.
+ *
+ * **When to Use**
+ *
+ * `catchIf` works similarly to {@link catchSome}, but it allows you to
+ * recover from errors by providing a predicate function. If the predicate
+ * matches the error, the recovery effect is applied. This function doesn't
+ * alter the error type, so the resulting effect still carries the original
+ * error type unless a user-defined type guard is used to narrow the type.
+ *
+ * **Example** (Catching Specific Errors with a Predicate)
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = program.pipe(
+ * Effect.catchIf(
+ * // Only handle HttpError errors
+ * (error) => error._tag === "HttpError",
+ * () => Effect.succeed("Recovering from HttpError")
+ * )
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchIf = exports.catchIf = core.catchIf;
+/**
+ * Catches and recovers from specific types of errors, allowing you to attempt
+ * recovery only for certain errors.
+ *
+ * **Details**
+ *
+ * `catchSome` lets you selectively catch and handle errors of certain
+ * types by providing a recovery effect for specific errors. If the error
+ * matches a condition, recovery is attempted; if not, it doesn't affect the
+ * program. This function doesn't alter the error type, meaning the error type
+ * remains the same as in the original effect.
+ *
+ * **Example** (Handling Specific Errors with Effect.catchSome)
+ *
+ * ```ts
+ * import { Effect, Random, Option } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = program.pipe(
+ * Effect.catchSome((error) => {
+ * // Only handle HttpError errors
+ * if (error._tag === "HttpError") {
+ * return Option.some(Effect.succeed("Recovering from HttpError"))
+ * } else {
+ * return Option.none()
+ * }
+ * })
+ * )
+ * ```
+ *
+ * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchSome = exports.catchSome = core.catchSome;
+/**
+ * Recovers from specific causes using a provided partial function.
+ *
+ * @see {@link catchSome} for a version that allows you to recover from errors.
+ * @see {@link catchSomeDefect} for a version that allows you to recover from defects.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchSomeCause = exports.catchSomeCause = effect.catchSomeCause;
+/**
+ * Recovers from specific defects using a provided partial function.
+ *
+ * **Details**
+ *
+ * `catchSomeDefect` allows you to handle specific defects, which are
+ * unexpected errors that can cause the program to stop. It uses a partial
+ * function to catch only certain defects and ignores others. The function does
+ * not handle expected errors (such as those caused by {@link fail}) or
+ * interruptions in execution (like those caused by {@link interrupt}).
+ *
+ * This function provides a way to handle certain types of defects while
+ * allowing others to propagate and cause failure in the program.
+ *
+ * **Note**: There is no sensible way to recover from defects. This method
+ * should be used only at the boundary between Effect and an external system, to
+ * transmit information on a defect for diagnostic or explanatory purposes.
+ *
+ * **How the Partial Function Works**
+ *
+ * The function provided to `catchSomeDefect` acts as a filter and a handler for defects:
+ * - It receives the defect as an input.
+ * - If the defect matches a specific condition (e.g., a certain error type), the function returns
+ * an `Option.some` containing the recovery logic.
+ * - If the defect does not match, the function returns `Option.none`, allowing the defect to propagate.
+ *
+ * **Example** (Handling Specific Defects)
+ *
+ * ```ts
+ * import { Effect, Cause, Option, Console } from "effect"
+ *
+ * // Simulating a runtime error
+ * const task = Effect.dieMessage("Boom!")
+ *
+ * const program = Effect.catchSomeDefect(task, (defect) => {
+ * if (Cause.isIllegalArgumentException(defect)) {
+ * return Option.some(
+ * Console.log(
+ * `Caught an IllegalArgumentException defect: ${defect.message}`
+ * )
+ * )
+ * }
+ * return Option.none()
+ * })
+ *
+ * // Since we are only catching IllegalArgumentException
+ * // we will get an Exit.Failure because we simulated a runtime error.
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Die',
+ * // defect: { _tag: 'RuntimeException' }
+ * // }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchSomeDefect = exports.catchSomeDefect = effect.catchSomeDefect;
+/**
+ * Catches and handles specific errors by their `_tag` field, which is used as a
+ * discriminator.
+ *
+ * **When to Use**
+ *
+ * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
+ * that identifies the error type. You can use this function to handle specific
+ * error types by matching the `_tag` value. This allows for precise error
+ * handling, ensuring that only specific errors are caught and handled.
+ *
+ * The error type must have a readonly `_tag` field to use `catchTag`. This
+ * field is used to identify and match errors.
+ *
+ * **Example** (Handling Errors by Tag)
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = program.pipe(
+ * // Only handle HttpError errors
+ * Effect.catchTag("HttpError", (_HttpError) =>
+ * Effect.succeed("Recovering from HttpError")
+ * )
+ * )
+ * ```
+ *
+ * @see {@link catchTags} for a version that allows you to handle multiple error
+ * types at once.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchTag = exports.catchTag = effect.catchTag;
+/**
+ * Handles multiple errors in a single block of code using their `_tag` field.
+ *
+ * **When to Use**
+ *
+ * `catchTags` is a convenient way to handle multiple error types at
+ * once. Instead of using {@link catchTag} multiple times, you can pass an
+ * object where each key is an error type's `_tag`, and the value is the handler
+ * for that specific error. This allows you to catch and recover from multiple
+ * error types in a single call.
+ *
+ * The error type must have a readonly `_tag` field to use `catchTag`. This
+ * field is used to identify and match errors.
+ *
+ * **Example** (Handling Multiple Tagged Error Types at Once)
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = program.pipe(
+ * Effect.catchTags({
+ * HttpError: (_HttpError) =>
+ * Effect.succeed(`Recovering from HttpError`),
+ * ValidationError: (_ValidationError) =>
+ * Effect.succeed(`Recovering from ValidationError`)
+ * })
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const catchTags = exports.catchTags = effect.catchTags;
+/**
+ * Retrieves the cause of a failure in an effect.
+ *
+ * **Details**
+ *
+ * This function allows you to expose the detailed cause of an effect, which
+ * includes a more precise representation of failures, such as error messages
+ * and defects.
+ *
+ * **When to Use**
+ *
+ * This function is helpful when you need to inspect the cause of a failure in
+ * an effect, giving you more information than just the error message. It can be
+ * used to log, handle, or analyze failures in more detail, including
+ * distinguishing between different types of defects (e.g., runtime exceptions,
+ * interruptions, etc.).
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.fail("Oh uh!").pipe(Effect.as(2))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = Effect.gen(function* () {
+ * const cause = yield* Effect.cause(program)
+ * yield* Console.log(cause)
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const cause = exports.cause = effect.cause;
+/**
+ * Runs an effect repeatedly until it succeeds, ignoring errors.
+ *
+ * **Details**
+ *
+ * This function takes an effect and runs it repeatedly until the effect
+ * successfully completes. If the effect fails, it will ignore the error and
+ * retry the operation. This is useful when you need to perform a task that may
+ * fail occasionally, but you want to keep trying until it eventually succeeds.
+ * It works by repeatedly executing the effect until it no longer throws an
+ * error.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to retry an operation multiple times until it
+ * succeeds. It is helpful in cases where the operation may fail temporarily
+ * (e.g., a network request), and you want to keep trying without handling or
+ * worrying about the errors.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * let counter = 0
+ *
+ * const effect = Effect.try(() => {
+ * counter++
+ * if (counter < 3) {
+ * console.log("running effect")
+ * throw new Error("error")
+ * } else {
+ * console.log("effect done")
+ * return "some result"
+ * }
+ * })
+ *
+ * const program = Effect.eventually(effect)
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // running effect
+ * // running effect
+ * // effect done
+ * // some result
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const eventually = exports.eventually = effect.eventually;
+/**
+ * Discards both the success and failure values of an effect.
+ *
+ * **When to Use**
+ *
+ * `ignore` allows you to run an effect without caring about its result, whether
+ * it succeeds or fails. This is useful when you only care about the side
+ * effects of the effect and do not need to handle or process its outcome.
+ *
+ * **Example** (Using Effect.ignore to Discard Values)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const task = Effect.fail("Uh oh!").pipe(Effect.as(5))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.ignore(task)
+ * ```
+ *
+ * @see {@link ignoreLogged} to log failures while ignoring them.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const ignore = exports.ignore = effect.ignore;
+/**
+ * Ignores the result of an effect but logs any failures.
+ *
+ * **Details**
+ *
+ * This function takes an effect and returns a new effect that ignores whether
+ * the original effect succeeds or fails. However, if the effect fails, it will
+ * log the failure at the Debug level, so you can keep track of any issues that
+ * arise.
+ *
+ * **When to Use**
+ *
+ * This is useful in scenarios where you want to continue with your program
+ * regardless of the result of the effect, but you still want to be aware of
+ * potential failures that may need attention later.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const ignoreLogged = exports.ignoreLogged = effect.ignoreLogged;
+/**
+ * Combines all errors from concurrent operations into a single error.
+ *
+ * **Details**
+ *
+ * This function is used when you have multiple operations running at the same
+ * time, and you want to capture all the errors that occur across those
+ * operations. Instead of handling each error separately, it combines all the
+ * errors into one unified error.
+ *
+ * **When to Use**
+ *
+ * When using this function, any errors that occur in the concurrently running
+ * operations will be grouped together into a single error. This helps simplify
+ * error handling in cases where you don't need to differentiate between each
+ * failure, but simply want to know that multiple failures occurred.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const fail1 = Effect.fail("Oh uh!")
+ * const fail2 = Effect.fail("Oh no!")
+ * const die = Effect.dieMessage("Boom!")
+ *
+ * // Run all effects concurrently and capture all errors
+ * const program = Effect.all([fail1, fail2, die], {
+ * concurrency: "unbounded"
+ * }).pipe(Effect.asVoid, Effect.parallelErrors)
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: [ 'Oh uh!', 'Oh no!' ] }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const parallelErrors = exports.parallelErrors = effect.parallelErrors;
+/**
+ * Transforms an effect to expose detailed error causes.
+ *
+ * **Details**
+ *
+ * This function enhances an effect by providing detailed information about any
+ * error, defect, or interruption that may occur during its execution. It
+ * modifies the error channel of the effect so that it includes a full cause of
+ * the failure, wrapped in a `Cause` type.
+ *
+ * After applying this function, you can use operators like {@link catchAll} and
+ * {@link catchTags} to handle specific types of errors.
+ *
+ * If you no longer need the detailed cause information, you can revert the
+ * changes using {@link unsandbox} to return to the original error-handling
+ * behavior.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const task = Effect.fail(new Error("Oh uh!")).pipe(
+ * Effect.as("primary result")
+ * )
+ *
+ * // ┌─── Effect, never>
+ * // ▼
+ * const sandboxed = Effect.sandbox(task)
+ *
+ * const program = Effect.catchTags(sandboxed, {
+ * Die: (cause) =>
+ * Console.log(`Caught a defect: ${cause.defect}`).pipe(
+ * Effect.as("fallback result on defect")
+ * ),
+ * Interrupt: (cause) =>
+ * Console.log(`Caught a defect: ${cause.fiberId}`).pipe(
+ * Effect.as("fallback result on fiber interruption")
+ * ),
+ * Fail: (cause) =>
+ * Console.log(`Caught a defect: ${cause.error}`).pipe(
+ * Effect.as("fallback result on failure")
+ * )
+ * })
+ *
+ * // Restore the original error handling with unsandbox
+ * const main = Effect.unsandbox(program)
+ *
+ * Effect.runPromise(main).then(console.log)
+ * // Output:
+ * // Caught a defect: Oh uh!
+ * // fallback result on failure
+ * ```
+ *
+ * @see {@link unsandbox} to restore the original error handling.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const sandbox = exports.sandbox = effect.sandbox;
+/**
+ * Retries a failing effect based on a defined retry policy.
+ *
+ * **Details**
+ *
+ * The `Effect.retry` function takes an effect and a {@link Schedule} policy,
+ * and will automatically retry the effect if it fails, following the rules of
+ * the policy.
+ *
+ * If the effect ultimately succeeds, the result will be returned.
+ *
+ * If the maximum retries are exhausted and the effect still fails, the failure
+ * is propagated.
+ *
+ * **When to Use**
+ *
+ * This can be useful when dealing with intermittent failures, such as network
+ * issues or temporary resource unavailability. By defining a retry policy, you
+ * can control the number of retries, the delay between them, and when to stop
+ * retrying.
+ *
+ * **Example** (Retrying with a Fixed Delay)
+ *
+ * ```ts
+ * import { Effect, Schedule } from "effect"
+ *
+ * let count = 0
+ *
+ * // Simulates an effect with possible failures
+ * const task = Effect.async((resume) => {
+ * if (count <= 2) {
+ * count++
+ * console.log("failure")
+ * resume(Effect.fail(new Error()))
+ * } else {
+ * console.log("success")
+ * resume(Effect.succeed("yay!"))
+ * }
+ * })
+ *
+ * // Define a repetition policy using a fixed delay between retries
+ * const policy = Schedule.fixed("100 millis")
+ *
+ * const repeated = Effect.retry(task, policy)
+ *
+ * Effect.runPromise(repeated).then(console.log)
+ * // Output:
+ * // failure
+ * // failure
+ * // failure
+ * // success
+ * // yay!
+ * ```
+ *
+ * **Example** (Retrying a Task up to 5 times)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * let count = 0
+ *
+ * // Simulates an effect with possible failures
+ * const task = Effect.async((resume) => {
+ * if (count <= 2) {
+ * count++
+ * console.log("failure")
+ * resume(Effect.fail(new Error()))
+ * } else {
+ * console.log("success")
+ * resume(Effect.succeed("yay!"))
+ * }
+ * })
+ *
+ * // Retry the task up to 5 times
+ * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log)
+ * // Output:
+ * // failure
+ * // failure
+ * // failure
+ * // success
+ * ```
+ *
+ * **Example** (Retrying Until a Specific Condition is Met)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * let count = 0
+ *
+ * // Define an effect that simulates varying error on each invocation
+ * const action = Effect.failSync(() => {
+ * console.log(`Action called ${++count} time(s)`)
+ * return `Error ${count}`
+ * })
+ *
+ * // Retry the action until a specific condition is met
+ * const program = Effect.retry(action, {
+ * until: (err) => err === "Error 3"
+ * })
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // Action called 1 time(s)
+ * // Action called 2 time(s)
+ * // Action called 3 time(s)
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' }
+ * // }
+ * ```
+ *
+ * @see {@link retryOrElse} for a version that allows you to run a fallback.
+ * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const retry = exports.retry = schedule_.retry_combined;
+/**
+ * Apply an `ExecutionPlan` to the effect, which allows you to fallback to
+ * different resources in case of failure.
+ *
+ * @since 3.16.0
+ * @category Error handling
+ * @experimental
+ */
+const withExecutionPlan = exports.withExecutionPlan = internalExecutionPlan.withExecutionPlan;
+/**
+ * Retries a failing effect and runs a fallback effect if retries are exhausted.
+ *
+ * **Details**
+ *
+ * The `Effect.retryOrElse` function attempts to retry a failing effect multiple
+ * times according to a defined {@link Schedule} policy.
+ *
+ * If the retries are exhausted and the effect still fails, it runs a fallback
+ * effect instead.
+ *
+ * **When to Use**
+ *
+ * This function is useful when you want to handle failures gracefully by
+ * specifying an alternative action after repeated failures.
+ *
+ * **Example** (Retrying with Fallback)
+ *
+ * ```ts
+ * import { Effect, Schedule, Console } from "effect"
+ *
+ * let count = 0
+ *
+ * // Simulates an effect with possible failures
+ * const task = Effect.async((resume) => {
+ * if (count <= 2) {
+ * count++
+ * console.log("failure")
+ * resume(Effect.fail(new Error()))
+ * } else {
+ * console.log("success")
+ * resume(Effect.succeed("yay!"))
+ * }
+ * })
+ *
+ * // Retry the task with a delay between retries and a maximum of 2 retries
+ * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
+ *
+ * // If all retries fail, run the fallback effect
+ * const repeated = Effect.retryOrElse(
+ * task,
+ * policy,
+ * // fallback
+ * () => Console.log("orElse").pipe(Effect.as("default value"))
+ * )
+ *
+ * Effect.runPromise(repeated).then(console.log)
+ * // Output:
+ * // failure
+ * // failure
+ * // failure
+ * // orElse
+ * // default value
+ * ```
+ *
+ * @see {@link retry} for a version that does not run a fallback effect.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const retryOrElse = exports.retryOrElse = schedule_.retryOrElse_Effect;
+const try_ = exports.try = effect.try_;
+/**
+ * Returns an effect that maps its success using the specified side-effecting
+ * `try` function, converting any errors into typed failed effects using the
+ * `catch` function.
+ *
+ * @see {@link tryPromise} for a version that works with asynchronous computations.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const tryMap = exports.tryMap = effect.tryMap;
+/**
+ * Returns an effect that maps its success using the specified side-effecting
+ * `try` function, converting any promise rejections into typed failed effects
+ * using the `catch` function.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped `Promise` API.
+ *
+ * @see {@link tryMap} for a version that works with synchronous computations.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const tryMapPromise = exports.tryMapPromise = effect.tryMapPromise;
+/**
+ * Creates an `Effect` that represents an asynchronous computation that might
+ * fail.
+ *
+ * **When to Use**
+ *
+ * In situations where you need to perform asynchronous operations that might
+ * fail, such as fetching data from an API, you can use the `tryPromise`
+ * constructor. This constructor is designed to handle operations that could
+ * throw exceptions by capturing those exceptions and transforming them into
+ * manageable errors.
+ *
+ * **Error Handling**
+ *
+ * There are two ways to handle errors with `tryPromise`:
+ *
+ * 1. If you don't provide a `catch` function, the error is caught and the
+ * effect fails with an `UnknownException`.
+ * 2. If you provide a `catch` function, the error is caught and the `catch`
+ * function maps it to an error of type `E`.
+ *
+ * **Interruptions**
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped `Promise` API.
+ *
+ * **Example** (Fetching a TODO Item)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const getTodo = (id: number) =>
+ * // Will catch any errors and propagate them as UnknownException
+ * Effect.tryPromise(() =>
+ * fetch(`https://jsonplaceholder.typicode.com/todos/${id}`)
+ * )
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = getTodo(1)
+ * ```
+ *
+ * **Example** (Custom Error Handling)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const getTodo = (id: number) =>
+ * Effect.tryPromise({
+ * try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`),
+ * // remap the error
+ * catch: (unknown) => new Error(`something went wrong ${unknown}`)
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = getTodo(1)
+ * ```
+ *
+ * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const tryPromise = exports.tryPromise = effect.tryPromise;
+/**
+ * The `unsandbox` function is used to revert an effect that has been
+ * sandboxed by {@link sandbox}. When you apply `unsandbox`, the
+ * effect's error channel is restored to its original state, without the
+ * detailed `Cause` information. This means that any underlying causes of
+ * errors, defects, or fiber interruptions are no longer exposed in the error
+ * channel.
+ *
+ * This function is useful when you want to remove the detailed error tracking
+ * provided by `sandbox` and return to the standard error handling for
+ * your effect. Once unsandboxed, the effect behaves as if `sandbox` was
+ * never applied.
+ *
+ * @see {@link sandbox} to expose the full cause of failures, defects, or interruptions.
+ *
+ * @since 2.0.0
+ * @category Error handling
+ */
+const unsandbox = exports.unsandbox = effect.unsandbox;
+/**
+ * Allows interruption of the current fiber, even in uninterruptible regions.
+ *
+ * **Details**
+ *
+ * This effect checks whether any other fibers are attempting to interrupt the
+ * current fiber. If so, it allows the current fiber to perform a
+ * self-interruption.
+ *
+ * **When to Use**
+ *
+ * This is useful in situations where you want to allow interruption to happen
+ * even in regions of the code that are normally uninterruptible.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const allowInterrupt = exports.allowInterrupt = effect.allowInterrupt;
+/**
+ * Checks if interruption is allowed and executes a callback accordingly.
+ *
+ * **Details**
+ *
+ * This function checks the current interrupt status of the running fiber. It
+ * then calls the provided callback, passing a boolean indicating whether
+ * interruption is allowed.
+ *
+ * **When to Use**
+ *
+ * This is useful for handling specific logic based on whether the current
+ * operation can be interrupted, such as when performing asynchronous operations
+ * or handling cancellation.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * yield* Effect.checkInterruptible((isInterruptible) => {
+ * if (isInterruptible) {
+ * return Console.log("You can interrupt this operation.")
+ * } else {
+ * return Console.log("This operation cannot be interrupted.")
+ * }
+ * })
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: You can interrupt this operation.
+ *
+ * Effect.runPromise(program.pipe(Effect.uninterruptible))
+ * // Output: This operation cannot be interrupted.
+ *
+ * ```
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const checkInterruptible = exports.checkInterruptible = core.checkInterruptible;
+/**
+ * Provides a way to handle timeouts in uninterruptible effects, allowing them
+ * to continue in the background while the main control flow proceeds with the
+ * timeout error.
+ *
+ * **Details**
+ *
+ * The `disconnect` function allows an uninterruptible effect to continue
+ * running in the background, while enabling the main control flow to
+ * immediately recognize a timeout condition. This is useful when you want to
+ * avoid blocking the program due to long-running tasks, especially when those
+ * tasks do not need to affect the flow of the rest of the program.
+ *
+ * Without `disconnect`, an uninterruptible effect will ignore the
+ * timeout and continue executing until it completes. The timeout error will
+ * only be assessed after the effect finishes, which can cause delays in
+ * recognizing a timeout.
+ *
+ * With `disconnect`, the uninterruptible effect proceeds in the
+ * background while the main program flow can immediately handle the timeout
+ * error or trigger alternative logic. This enables faster timeout handling
+ * without waiting for the completion of the long-running task.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const longRunningTask = Effect.gen(function* () {
+ * console.log("Start heavy processing...")
+ * yield* Effect.sleep("5 seconds") // Simulate a long process
+ * console.log("Heavy processing done.")
+ * return "Data processed"
+ * })
+ *
+ * const timedEffect = longRunningTask.pipe(
+ * Effect.uninterruptible,
+ * // Allows the task to finish in the background if it times out
+ * Effect.disconnect,
+ * Effect.timeout("1 second")
+ * )
+ *
+ * Effect.runPromiseExit(timedEffect).then(console.log)
+ * // Output:
+ * // Start heavy processing...
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: { _tag: 'TimeoutException' }
+ * // }
+ * // }
+ * // Heavy processing done.
+ * ```
+ *
+ * @see {@link timeout} for a version that interrupts the effect.
+ * @see {@link uninterruptible} for creating an uninterruptible effect.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const disconnect = exports.disconnect = fiberRuntime.disconnect;
+/**
+ * Represents an effect that interrupts the current fiber.
+ *
+ * **Details**
+ *
+ * This effect models the explicit interruption of the fiber in which it runs.
+ * When executed, it causes the fiber to stop its operation immediately,
+ * capturing the interruption details such as the fiber's ID and its start time.
+ * The resulting interruption can be observed in the `Exit` type if the effect
+ * is run with functions like {@link runPromiseExit}.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function* () {
+ * console.log("start")
+ * yield* Effect.sleep("2 seconds")
+ * yield* Effect.interrupt
+ * console.log("done")
+ * return "some result"
+ * })
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // start
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Interrupt',
+ * // fiberId: {
+ * // _id: 'FiberId',
+ * // _tag: 'Runtime',
+ * // id: 0,
+ * // startTimeMillis: ...
+ * // }
+ * // }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const interrupt = exports.interrupt = core.interrupt;
+/**
+ * @since 2.0.0
+ * @category Interruption
+ */
+const interruptWith = exports.interruptWith = core.interruptWith;
+/**
+ * Marks an effect as interruptible.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const interruptible = exports.interruptible = core.interruptible;
+/**
+ * This function behaves like {@link interruptible}, but it also provides a
+ * `restore` function. This function can be used to restore the interruptibility
+ * of any specific region of code.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const interruptibleMask = exports.interruptibleMask = core.interruptibleMask;
+/**
+ * Registers a cleanup effect to run when an effect is interrupted.
+ *
+ * **Details**
+ *
+ * This function allows you to specify an effect to run when the fiber is
+ * interrupted. This effect will be executed when the fiber is interrupted,
+ * allowing you to perform cleanup or other actions.
+ *
+ * **Example** (Running a Cleanup Action on Interruption)
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * // This handler is executed when the fiber is interrupted
+ * const handler = Effect.onInterrupt((_fibers) => Console.log("Cleanup completed"))
+ *
+ * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler)
+ *
+ * Effect.runFork(success)
+ * // Output:
+ * // Task completed
+ *
+ * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler)
+ *
+ * Effect.runFork(failure)
+ * // Output:
+ * // Task failed
+ *
+ * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler)
+ *
+ * Effect.runFork(interruption)
+ * // Output:
+ * // Task interrupted
+ * // Cleanup completed
+ * ```
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const onInterrupt = exports.onInterrupt = core.onInterrupt;
+/**
+ * Marks an effect as uninterruptible.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const uninterruptible = exports.uninterruptible = core.uninterruptible;
+/**
+ * This function behaves like {@link uninterruptible}, but it also provides a
+ * `restore` function. This function can be used to restore the interruptibility
+ * of any specific region of code.
+ *
+ * @since 2.0.0
+ * @category Interruption
+ */
+const uninterruptibleMask = exports.uninterruptibleMask = core.uninterruptibleMask;
+/**
+ * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
+ * or failing with specified error if the predicate fails
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const isPositive = (n: number): boolean => n > 0
+ *
+ * // succeeds with `1`
+ * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`)
+ *
+ * // fails with `"0 is not positive"`
+ * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`)
+ * ```
+ *
+ * @category Condition Checking
+ * @since 3.4.0
+ */
+const liftPredicate = exports.liftPredicate = effect.liftPredicate;
+/**
+ * Replaces the value inside an effect with a constant value.
+ *
+ * **Details**
+ *
+ * This function allows you to ignore the original value inside an effect and
+ * replace it with a constant value.
+ *
+ * **When to Use**
+ *
+ * It is useful when you no longer need the value produced by an effect but want
+ * to ensure that the effect completes successfully with a specific constant
+ * result instead. For instance, you can replace the value produced by a
+ * computation with a predefined value, ignoring what was calculated before.
+ *
+ * **Example** (Replacing a Value)
+ *
+ * ```ts
+ * import { pipe, Effect } from "effect"
+ *
+ * // Replaces the value 5 with the constant "new value"
+ * const program = pipe(Effect.succeed(5), Effect.as("new value"))
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output: "new value"
+ * ```
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const as = exports.as = core.as;
+/**
+ * This function maps the success value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value fails, the returned
+ * `Effect` value will also fail.
+ *
+ * @category Mapping
+ * @since 2.0.0
+ */
+const asSome = exports.asSome = effect.asSome;
+/**
+ * This function maps the error value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value succeeds, the returned
+ * `Effect` value will also succeed.
+ *
+ * @category Mapping
+ * @since 2.0.0
+ */
+const asSomeError = exports.asSomeError = effect.asSomeError;
+/**
+ * This function maps the success value of an `Effect` value to `void`. If the
+ * original `Effect` value succeeds, the returned `Effect` value will also
+ * succeed. If the original `Effect` value fails, the returned `Effect` value
+ * will fail with the same error.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const asVoid = exports.asVoid = core.asVoid;
+/**
+ * Swaps the success and error channels of an effect.
+ *
+ * **Details**
+ *
+ * This function reverses the flow of an effect by swapping its success and
+ * error channels. The success value becomes an error, and the error value
+ * becomes a success.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.fail("Oh uh!").pipe(Effect.as(2))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const flipped = Effect.flip(program)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const flip = exports.flip = core.flip;
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const flipWith = exports.flipWith = effect.flipWith;
+/**
+ * Transforms the value inside an effect by applying a function to it.
+ *
+ * **Syntax**
+ *
+ * ```ts skip-type-checking
+ * const mappedEffect = pipe(myEffect, Effect.map(transformation))
+ * // or
+ * const mappedEffect = Effect.map(myEffect, transformation)
+ * // or
+ * const mappedEffect = myEffect.pipe(Effect.map(transformation))
+ * ```
+ *
+ * **Details**
+ *
+ * `map` takes a function and applies it to the value contained within an
+ * effect, creating a new effect with the transformed value.
+ *
+ * It's important to note that effects are immutable, meaning that the original
+ * effect is not modified. Instead, a new effect is returned with the updated
+ * value.
+ *
+ * **Example** (Adding a Service Charge)
+ *
+ * ```ts
+ * import { pipe, Effect } from "effect"
+ *
+ * const addServiceCharge = (amount: number) => amount + 1
+ *
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * const finalAmount = pipe(
+ * fetchTransactionAmount,
+ * Effect.map(addServiceCharge)
+ * )
+ *
+ * Effect.runPromise(finalAmount).then(console.log)
+ * // Output: 101
+ * ```
+ *
+ * @see {@link mapError} for a version that operates on the error channel.
+ * @see {@link mapBoth} for a version that operates on both channels.
+ * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const map = exports.map = core.map;
+/**
+ * Applies a stateful transformation to each element of a collection, producing
+ * new elements along with an updated state.
+ *
+ * **When to Use**
+ *
+ * Use `mapAccum` when you need to process each element of a collection while
+ * keeping track of some state across iterations.
+ *
+ * **Details**
+ *
+ * `mapAccum` takes an initial state (`initial`) and a function (`f`) that is
+ * applied to each element. This function returns a new state and a transformed
+ * element. The final effect produces both the accumulated state and the
+ * transformed collection.
+ *
+ * If the input collection is a non-empty array, the return type will match the
+ * input collection type.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Define an initial state and a transformation function
+ * const initialState = 0
+ *
+ * const transformation = (state: number, element: string) =>
+ * Effect.succeed<[number, string]>([state + element.length, element.toUpperCase()])
+ *
+ * // Apply mapAccum to transform an array of strings
+ * const program = Effect.mapAccum(["a", "bb", "ccc"], initialState, transformation)
+ *
+ * Effect.runPromise(program).then(([finalState, transformedCollection]) => {
+ * console.log(finalState)
+ * console.log(transformedCollection)
+ * })
+ * // Output:
+ * // 6
+ * // [ 'A', 'BB', 'CCC' ]
+ * ```
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const mapAccum = exports.mapAccum = effect.mapAccum;
+/**
+ * Applies transformations to both the success and error channels of an effect.
+ *
+ * **Details**
+ *
+ * This function takes two map functions as arguments: one for the error channel
+ * and one for the success channel. You can use it when you want to modify both
+ * the error and the success values without altering the overall success or
+ * failure status of the effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const modified = Effect.mapBoth(simulatedTask, {
+ * onFailure: (message) => new Error(message),
+ * onSuccess: (n) => n > 0
+ * })
+ * ```
+ *
+ * @see {@link map} for a version that operates on the success channel.
+ * @see {@link mapError} for a version that operates on the error channel.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const mapBoth = exports.mapBoth = core.mapBoth;
+/**
+ * Transforms or modifies the error produced by an effect without affecting its
+ * success value.
+ *
+ * **When to Use**
+ *
+ * This function is helpful when you want to enhance the error with additional
+ * information, change the error type, or apply custom error handling while
+ * keeping the original behavior of the effect's success values intact. It only
+ * operates on the error channel and leaves the success channel unchanged.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const mapped = Effect.mapError(
+ * simulatedTask,
+ * (message) => new Error(message)
+ * )
+ * ```
+ *
+ * @see {@link map} for a version that operates on the success channel.
+ * @see {@link mapBoth} for a version that operates on both channels.
+ * @see {@link orElseFail} if you want to replace the error with a new one.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const mapError = exports.mapError = core.mapError;
+/**
+ * Maps the cause of failure of an effect using a specified function.
+ *
+ * @see {@link sandbox} for a version that exposes the full cause of failures, defects, or interruptions.
+ * @see {@link catchAllCause} for a version that can recover from all types of defects.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const mapErrorCause = exports.mapErrorCause = effect.mapErrorCause;
+/**
+ * Combines both success and error channels of an effect into a single outcome.
+ *
+ * **Details**
+ *
+ * This function transforms an effect that may fail into one that always returns
+ * a value, where both success and failure outcomes are handled as values in the
+ * success channel.
+ *
+ * **When to Use**
+ *
+ * This can be useful when you want to continue execution regardless of the
+ * error type and still capture both successful results and errors as part of
+ * the outcome.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.fail("Oh uh!").pipe(Effect.as(2))
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = Effect.merge(program)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const merge = exports.merge = effect.merge;
+/**
+ * Returns a new effect with the boolean value of this effect negated.
+ *
+ * @since 2.0.0
+ * @category Mapping
+ */
+const negate = exports.negate = effect.negate;
+/**
+ * Creates a scoped resource using an `acquire` and `release` effect.
+ *
+ * **Details**
+ *
+ * This function helps manage resources by combining two `Effect` values: one
+ * for acquiring the resource and one for releasing it.
+ *
+ * `acquireRelease` does the following:
+ *
+ * 1. Ensures that the effect that acquires the resource will not be
+ * interrupted. Note that acquisition may still fail due to internal
+ * reasons (such as an uncaught exception).
+ * 2. Ensures that the `release` effect will not be interrupted, and will be
+ * executed as long as the acquisition effect successfully acquires the
+ * resource.
+ *
+ * If the `acquire` function succeeds, the `release` function is added to the
+ * list of finalizers for the scope. This ensures that the release will happen
+ * automatically when the scope is closed.
+ *
+ * Both `acquire` and `release` run uninterruptibly, meaning they cannot be
+ * interrupted while they are executing.
+ *
+ * Additionally, the `release` function can be influenced by the exit value when
+ * the scope closes, allowing for custom handling of how the resource is
+ * released based on the execution outcome.
+ *
+ * **When to Use**
+ *
+ * This function is used to ensure that an effect that represents the
+ * acquisition of a resource (for example, opening a file, launching a thread,
+ * etc.) will not be interrupted, and that the resource will always be released
+ * when the `Effect` completes execution.
+ *
+ * **Example** (Defining a Simple Resource)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Define an interface for a resource
+ * interface MyResource {
+ * readonly contents: string
+ * readonly close: () => Promise
+ * }
+ *
+ * // Simulate resource acquisition
+ * const getMyResource = (): Promise =>
+ * Promise.resolve({
+ * contents: "lorem ipsum",
+ * close: () =>
+ * new Promise((resolve) => {
+ * console.log("Resource released")
+ * resolve()
+ * })
+ * })
+ *
+ * // Define how the resource is acquired
+ * const acquire = Effect.tryPromise({
+ * try: () =>
+ * getMyResource().then((res) => {
+ * console.log("Resource acquired")
+ * return res
+ * }),
+ * catch: () => new Error("getMyResourceError")
+ * })
+ *
+ * // Define how the resource is released
+ * const release = (res: MyResource) => Effect.promise(() => res.close())
+ *
+ * // Create the resource management workflow
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const resource = Effect.acquireRelease(acquire, release)
+ * ```
+ *
+ * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const acquireRelease = exports.acquireRelease = fiberRuntime.acquireRelease;
+/**
+ * Creates a scoped resource with an interruptible acquire action.
+ *
+ * **Details**
+ *
+ * This function is similar to {@link acquireRelease}, but it allows the
+ * acquisition of the resource to be interrupted. The `acquire` effect, which
+ * represents the process of obtaining the resource, can be interrupted if
+ * necessary.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const acquireReleaseInterruptible = exports.acquireReleaseInterruptible = fiberRuntime.acquireReleaseInterruptible;
+/**
+ * Many real-world operations involve working with resources that must be released when no longer needed, such as:
+ *
+ * - Database connections
+ * - File handles
+ * - Network requests
+ *
+ * This function ensures that a resource is:
+ *
+ * 1. **Acquired** properly.
+ * 2. **Used** for its intended purpose.
+ * 3. **Released** even if an error occurs.
+ *
+ * **Example** (Automatically Managing Resource Lifetime)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // Define an interface for a resource
+ * interface MyResource {
+ * readonly contents: string
+ * readonly close: () => Promise
+ * }
+ *
+ * // Simulate resource acquisition
+ * const getMyResource = (): Promise =>
+ * Promise.resolve({
+ * contents: "lorem ipsum",
+ * close: () =>
+ * new Promise((resolve) => {
+ * console.log("Resource released")
+ * resolve()
+ * })
+ * })
+ *
+ * // Define how the resource is acquired
+ * const acquire = Effect.tryPromise({
+ * try: () =>
+ * getMyResource().then((res) => {
+ * console.log("Resource acquired")
+ * return res
+ * }),
+ * catch: () => new Error("getMyResourceError")
+ * })
+ *
+ * // Define how the resource is released
+ * const release = (res: MyResource) => Effect.promise(() => res.close())
+ *
+ * const use = (res: MyResource) => Console.log(`content is ${res.contents}`)
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.acquireUseRelease(acquire, use, release)
+ *
+ * Effect.runPromise(program)
+ * // Output:
+ * // Resource acquired
+ * // content is lorem ipsum
+ * // Resource released
+ * ```
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
+/**
+ * Ensures a finalizer is added to the scope of the calling effect, guaranteeing
+ * it runs when the scope is closed.
+ *
+ * **Details**
+ *
+ * This function adds a finalizer that will execute whenever the scope of the
+ * effect is closed, regardless of whether the effect succeeds, fails, or is
+ * interrupted. The finalizer receives the `Exit` value of the effect's scope,
+ * allowing it to react differently depending on how the effect concludes.
+ *
+ * Finalizers are a reliable way to manage resource cleanup, ensuring that
+ * resources such as file handles, network connections, or database transactions
+ * are properly closed even in the event of an unexpected interruption or error.
+ *
+ * Finalizers operate in conjunction with Effect's scoped resources. If an
+ * effect with a finalizer is wrapped in a scope, the finalizer will execute
+ * automatically when the scope ends.
+ *
+ * **Example** (Adding a Finalizer on Success)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * yield* Effect.addFinalizer((exit) =>
+ * Console.log(`Finalizer executed. Exit status: ${exit._tag}`)
+ * )
+ * return "some result"
+ * })
+ *
+ * // Wrapping the effect in a scope
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const runnable = Effect.scoped(program)
+ *
+ * Effect.runPromiseExit(runnable).then(console.log)
+ * // Output:
+ * // Finalizer executed. Exit status: Success
+ * // { _id: 'Exit', _tag: 'Success', value: 'some result' }
+ * ```
+ *
+ * **Example** (Adding a Finalizer on Failure)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * yield* Effect.addFinalizer((exit) =>
+ * Console.log(`Finalizer executed. Exit status: ${exit._tag}`)
+ * )
+ * return yield* Effect.fail("Uh oh!")
+ * })
+ *
+ * // Wrapping the effect in a scope
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const runnable = Effect.scoped(program)
+ *
+ * Effect.runPromiseExit(runnable).then(console.log)
+ * // Output:
+ * // Finalizer executed. Exit status: Failure
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Uh oh!' }
+ * // }
+ * ```
+ *
+ * **Example** (Adding a Finalizer on Interruption)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * yield* Effect.addFinalizer((exit) =>
+ * Console.log(`Finalizer executed. Exit status: ${exit._tag}`)
+ * )
+ * return yield* Effect.interrupt
+ * })
+ *
+ * // Wrapping the effect in a scope
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const runnable = Effect.scoped(program)
+ *
+ * Effect.runPromiseExit(runnable).then(console.log)
+ * // Output:
+ * // Finalizer executed. Exit status: Failure
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Interrupt',
+ * // fiberId: {
+ * // _id: 'FiberId',
+ * // _tag: 'Runtime',
+ * // id: 0,
+ * // startTimeMillis: ...
+ * // }
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link onExit} for attaching a finalizer directly to an effect.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const addFinalizer = exports.addFinalizer = fiberRuntime.addFinalizer;
+/**
+ * Guarantees the execution of a finalizer when an effect starts execution.
+ *
+ * **Details**
+ *
+ * This function allows you to specify a `finalizer` effect that will always be
+ * run once the effect starts execution, regardless of whether the effect
+ * succeeds, fails, or is interrupted.
+ *
+ * **When to Use**
+ *
+ * This is useful when you need to ensure that certain cleanup or final steps
+ * are executed in all cases, such as releasing resources or performing
+ * necessary logging.
+ *
+ * While this function provides strong guarantees about executing the finalizer,
+ * it is considered a low-level tool, which may not be ideal for more complex
+ * resource management. For higher-level resource management with automatic
+ * acquisition and release, see the {@link acquireRelease} family of functions.
+ * For use cases where you need access to the result of an effect, consider
+ * using {@link onExit}.
+ *
+ * **Example** (Running a Finalizer in All Outcomes)
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * // Define a cleanup effect
+ * const handler = Effect.ensuring(Console.log("Cleanup completed"))
+ *
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ * Effect.as("some result"),
+ * handler
+ * )
+ *
+ * Effect.runFork(success)
+ * // Output:
+ * // Task completed
+ * // Cleanup completed
+ *
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ * Effect.andThen(Effect.fail("some error")),
+ * handler
+ * )
+ *
+ * Effect.runFork(failure)
+ * // Output:
+ * // Task failed
+ * // Cleanup completed
+ *
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ * Effect.andThen(Effect.interrupt),
+ * handler
+ * )
+ *
+ * Effect.runFork(interruption)
+ * // Output:
+ * // Task interrupted
+ * // Cleanup completed
+ * ```
+ *
+ * @see {@link onExit} for a version that provides access to the result of an
+ * effect.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const ensuring = exports.ensuring = fiberRuntime.ensuring;
+/**
+ * Ensures a cleanup effect runs whenever the calling effect fails, providing
+ * the failure cause to the cleanup effect.
+ *
+ * **Details**
+ *
+ * This function allows you to attach a cleanup effect that runs whenever the
+ * calling effect fails. The cleanup effect receives the cause of the failure,
+ * allowing you to perform actions such as logging, releasing resources, or
+ * executing additional recovery logic based on the error. The cleanup effect
+ * will execute even if the failure is due to interruption.
+ *
+ * Importantly, the cleanup effect itself is uninterruptible, ensuring that it
+ * completes regardless of external interruptions.
+ *
+ * **Example** (Running Cleanup Only on Failure)
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * // This handler logs the failure cause when the effect fails
+ * const handler = Effect.onError((cause) =>
+ * Console.log(`Cleanup completed: ${cause}`)
+ * )
+ *
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ * Effect.as("some result"),
+ * handler
+ * )
+ *
+ * Effect.runFork(success)
+ * // Output:
+ * // Task completed
+ *
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ * Effect.andThen(Effect.fail("some error")),
+ * handler
+ * )
+ *
+ * Effect.runFork(failure)
+ * // Output:
+ * // Task failed
+ * // Cleanup completed: Error: some error
+ *
+ * // Define a failing effect
+ * const defect = Console.log("Task failed with defect").pipe(
+ * Effect.andThen(Effect.die("Boom!")),
+ * handler
+ * )
+ *
+ * Effect.runFork(defect)
+ * // Output:
+ * // Task failed with defect
+ * // Cleanup completed: Error: Boom!
+ *
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ * Effect.andThen(Effect.interrupt),
+ * handler
+ * )
+ *
+ * Effect.runFork(interruption)
+ * // Output:
+ * // Task interrupted
+ * // Cleanup completed: All fibers interrupted without errors.
+ * ```
+ *
+ * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure.
+ * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const onError = exports.onError = core.onError;
+/**
+ * Guarantees that a cleanup function runs regardless of whether the effect
+ * succeeds, fails, or is interrupted.
+ *
+ * **Details**
+ *
+ * This function ensures that a provided cleanup function is executed after the
+ * effect completes, regardless of the outcome. The cleanup function is given
+ * the `Exit` value of the effect, which provides detailed information about the
+ * result:
+ * - If the effect succeeds, the `Exit` contains the success value.
+ * - If the effect fails, the `Exit` contains the error or failure cause.
+ * - If the effect is interrupted, the `Exit` reflects the interruption.
+ *
+ * The cleanup function is guaranteed to run uninterruptibly, ensuring reliable
+ * resource management even in complex or high-concurrency scenarios.
+ *
+ * **Example** (Running a Cleanup Function with the Effect’s Result)
+ *
+ * ```ts
+ * import { Console, Effect, Exit } from "effect"
+ *
+ * // Define a cleanup effect that logs the result
+ * const handler = Effect.onExit((exit) =>
+ * Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`)
+ * )
+ *
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ * Effect.as("some result"),
+ * handler
+ * )
+ *
+ * Effect.runFork(success)
+ * // Output:
+ * // Task completed
+ * // Cleanup completed: some result
+ *
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ * Effect.andThen(Effect.fail("some error")),
+ * handler
+ * )
+ *
+ * Effect.runFork(failure)
+ * // Output:
+ * // Task failed
+ * // Cleanup completed: Error: some error
+ *
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ * Effect.andThen(Effect.interrupt),
+ * handler
+ * )
+ *
+ * Effect.runFork(interruption)
+ * // Output:
+ * // Task interrupted
+ * // Cleanup completed: All fibers interrupted without errors.
+ * ```
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const onExit = exports.onExit = core.onExit;
+/**
+ * Ensures that finalizers are run concurrently when the scope of an effect is
+ * closed.
+ *
+ * **Details**
+ *
+ * This function modifies the behavior of finalizers within a scoped workflow to
+ * allow them to run concurrently when the scope is closed.
+ *
+ * By default, finalizers are executed sequentially in reverse order of their
+ * addition, but this function changes that behavior to execute all finalizers
+ * concurrently.
+ *
+ * **When to Use**
+ *
+ * Running finalizers concurrently can improve performance when multiple
+ * independent cleanup tasks need to be performed. However, it requires that
+ * these tasks do not depend on the order of execution or introduce race
+ * conditions.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * // Define a program that adds multiple finalizers
+ * const program = Effect.gen(function*() {
+ * yield* Effect.addFinalizer(() => Console.log("Finalizer 1 executed").pipe(Effect.delay("300 millis")))
+ * yield* Effect.addFinalizer(() => Console.log("Finalizer 2 executed").pipe(Effect.delay("100 millis")))
+ * yield* Effect.addFinalizer(() => Console.log("Finalizer 3 executed").pipe(Effect.delay("200 millis")))
+ * return "some result"
+ * })
+ *
+ * // Modify the program to ensure finalizers run in parallel
+ * const modified = program.pipe(Effect.parallelFinalizers)
+ *
+ * const runnable = Effect.scoped(modified)
+ *
+ * Effect.runFork(runnable)
+ * // Output:
+ * // Finalizer 2 executed
+ * // Finalizer 3 executed
+ * // Finalizer 1 executed
+ * ```
+ *
+ * @see {@link sequentialFinalizers} for a version that ensures finalizers are run sequentially.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const parallelFinalizers = exports.parallelFinalizers = fiberRuntime.parallelFinalizers;
+/**
+ * Ensures that finalizers are run sequentially in reverse order of their
+ * addition.
+ *
+ * **Details**
+ *
+ * This function modifies the behavior of finalizers within a scoped workflow to
+ * ensure they are run sequentially in reverse order when the scope is closed.
+ *
+ * By default, finalizers are executed sequentially, so this only changes the
+ * behavior if the scope is configured to run finalizers concurrently.
+ *
+ * @see {@link parallelFinalizers} for a version that ensures finalizers are run concurrently.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const sequentialFinalizers = exports.sequentialFinalizers = fiberRuntime.sequentialFinalizers;
+/**
+ * Applies a custom execution strategy to finalizers within a scoped workflow.
+ *
+ * **Details**
+ *
+ * This function allows you to control how finalizers are executed in a scope by
+ * applying a specified `ExecutionStrategy`. The `strategy` can dictate whether
+ * finalizers run (e.g., sequentially or in parallel).
+ *
+ * Additionally, the function provides a `restore` operation, which ensures that
+ * the effect passed to it is executed under the default execution strategy.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const finalizersMask = exports.finalizersMask = fiberRuntime.finalizersMask;
+/**
+ * Provides access to the current scope in a scoped workflow.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const scope = exports.scope = fiberRuntime.scope;
+/**
+ * Accesses the current scope and uses it to perform the specified effect.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const scopeWith = exports.scopeWith = fiberRuntime.scopeWith;
+/**
+ * Creates a `Scope`, passes it to the specified effectful function, and closes
+ * the scope when the effect completes (whether through success, failure, or
+ * interruption).
+ *
+ * @since 3.11.0
+ * @category Scoping, Resources & Finalization
+ */
+const scopedWith = exports.scopedWith = fiberRuntime.scopedWith;
+/**
+ * Scopes all resources used in an effect to the lifetime of the effect.
+ *
+ * **Details**
+ *
+ * This function ensures that all resources used within an effect are tied to
+ * its lifetime. Finalizers for these resources are executed automatically when
+ * the effect completes, whether through success, failure, or interruption. This
+ * guarantees proper resource cleanup without requiring explicit management.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const scoped = exports.scoped = fiberRuntime.scopedEffect;
+/**
+ * Scopes all resources acquired by one effect to the lifetime of another
+ * effect.
+ *
+ * **Details**
+ *
+ * This function allows you to scope the resources acquired by one effect
+ * (`self`) to the lifetime of another effect (`use`). This ensures that the
+ * resources are cleaned up as soon as the `use` effect completes, regardless of
+ * how the `use` effect ends (success, failure, or interruption).
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const acquire = Console.log("Acquiring resource").pipe(
+ * Effect.as(1),
+ * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource")))
+ * )
+ * const use = (resource: number) => Console.log(`Using resource: ${resource}`)
+ *
+ * const program = acquire.pipe(Effect.using(use))
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // Acquiring resource
+ * // Using resource: 1
+ * // Releasing resource
+ * ```
+ *
+ * @see {@link scopedWith} Manage scoped operations with a temporary scope.
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const using = exports.using = fiberRuntime.using;
+/**
+ * Returns the result of the effect and a finalizer to close its scope.
+ *
+ * **Details**
+ *
+ * This function allows you to retrieve both the result of an effect and a
+ * finalizer that can be used to manually close its scope. This is useful for
+ * workflows where you need early access to the result while retaining control
+ * over the resource cleanup process.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const acquire = Console.log("Acquiring resource").pipe(
+ * Effect.as(1),
+ * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource")))
+ * )
+ * const program = Effect.gen(function*() {
+ * const [finalizer, resource] = yield* Effect.withEarlyRelease(acquire)
+ * console.log(`Using resource: ${resource}`)
+ * yield* Effect.sleep("1 second")
+ * yield* finalizer
+ * })
+ *
+ * Effect.runFork(program.pipe(Effect.scoped))
+ * // Output:
+ * // Acquiring resource
+ * // Using resource: 1
+ * // Releasing resource
+ * ```
+ *
+ * @since 2.0.0
+ * @category Scoping, Resources & Finalization
+ */
+const withEarlyRelease = exports.withEarlyRelease = fiberRuntime.withEarlyRelease;
+/**
+ * Returns a new effect that will not succeed with its value before first
+ * waiting for the end of all child fibers forked by the effect.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const awaitAllChildren = exports.awaitAllChildren = circular.awaitAllChildren;
+/**
+ * Returns a new workflow that will not supervise any fibers forked by this
+ * workflow.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const daemonChildren = exports.daemonChildren = fiberRuntime.daemonChildren;
+/**
+ * Constructs an effect with information about the current `Fiber`.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const descriptor = exports.descriptor = effect.descriptor;
+/**
+ * Constructs an effect based on information about the current `Fiber`.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const descriptorWith = exports.descriptorWith = effect.descriptorWith;
+/**
+ * Returns a new workflow that executes this one and captures the changes in
+ * `FiberRef` values.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const diffFiberRefs = exports.diffFiberRefs = effect.diffFiberRefs;
+/**
+ * Acts on the children of this fiber (collected into a single fiber),
+ * guaranteeing the specified callback will be invoked, whether or not this
+ * effect succeeds.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const ensuringChild = exports.ensuringChild = circular.ensuringChild;
+/**
+ * Acts on the children of this fiber, guaranteeing the specified callback
+ * will be invoked, whether or not this effect succeeds.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const ensuringChildren = exports.ensuringChildren = circular.ensuringChildren;
+/**
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const fiberId = exports.fiberId = core.fiberId;
+/**
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const fiberIdWith = exports.fiberIdWith = core.fiberIdWith;
+/**
+ * Creates a new fiber to run an effect concurrently.
+ *
+ * **Details**
+ *
+ * This function takes an effect and forks it into a separate fiber, allowing it
+ * to run concurrently without blocking the original effect. The new fiber
+ * starts execution immediately after being created, and the fiber object is
+ * returned immediately without waiting for the effect to begin. This is useful
+ * when you want to run tasks concurrently while continuing other tasks in the
+ * parent fiber.
+ *
+ * The forked fiber is attached to the parent fiber's scope. This means that
+ * when the parent fiber terminates, the child fiber will also be terminated
+ * automatically. This feature, known as "auto supervision," ensures that no
+ * fibers are left running unintentionally. If you prefer not to have this auto
+ * supervision behavior, you can use {@link forkDaemon} or {@link forkIn}.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to run an effect concurrently without
+ * blocking the current execution flow. For example, you might use it to launch
+ * background tasks or concurrent computations. However, working with fibers can
+ * be complex, so before using this function directly, you might want to explore
+ * higher-level functions like {@link raceWith}, {@link zip}, or others that can
+ * manage concurrency for you.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const fib = (n: number): Effect.Effect =>
+ * n < 2
+ * ? Effect.succeed(n)
+ * : Effect.zipWith(fib(n - 1), fib(n - 2), (a, b) => a + b)
+ *
+ * // ┌─── Effect, never, never>
+ * // ▼
+ * const fib10Fiber = Effect.fork(fib(10))
+ * ```
+ *
+ * @see {@link forkWithErrorHandler} for a version that allows you to handle errors.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const fork = exports.fork = fiberRuntime.fork;
+/**
+ * Creates a long-running background fiber that is independent of its parent.
+ *
+ * **Details**
+ *
+ * This function creates a "daemon" fiber that runs in the background and is not
+ * tied to the lifecycle of its parent fiber. Unlike normal fibers that stop
+ * when the parent fiber terminates, a daemon fiber will continue running until
+ * the global scope closes or the fiber completes naturally. This makes it
+ * useful for tasks that need to run in the background independently, such as
+ * periodic logging, monitoring, or background data processing.
+ *
+ * **Example** (Creating a Daemon Fiber)
+ *
+ * ```ts
+ * import { Effect, Console, Schedule } from "effect"
+ *
+ * // Daemon fiber that logs a message repeatedly every second
+ * const daemon = Effect.repeat(
+ * Console.log("daemon: still running!"),
+ * Schedule.fixed("1 second")
+ * )
+ *
+ * const parent = Effect.gen(function* () {
+ * console.log("parent: started!")
+ * // Daemon fiber running independently
+ * yield* Effect.forkDaemon(daemon)
+ * yield* Effect.sleep("3 seconds")
+ * console.log("parent: finished!")
+ * })
+ *
+ * Effect.runFork(parent)
+ * // Output:
+ * // parent: started!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // parent: finished!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // daemon: still running!
+ * // ...etc...
+ * ```
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const forkDaemon = exports.forkDaemon = fiberRuntime.forkDaemon;
+/**
+ * Returns an effect that forks all of the specified values, and returns a
+ * composite fiber that produces a list of their results, in order.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const forkAll = exports.forkAll = circular.forkAll;
+/**
+ * Forks an effect in a specific scope, allowing finer control over its
+ * execution.
+ *
+ * **Details**
+ *
+ * There are some cases where we need more fine-grained control, so we want to
+ * fork a fiber in a specific scope. We can use the `Effect.forkIn` operator
+ * which takes the target scope as an argument.
+ *
+ * The fiber will be interrupted when the scope is closed.
+ *
+ * **Example** (Forking a Fiber in a Specific Scope)
+ *
+ * In this example, the child fiber is forked into the outerScope,
+ * allowing it to outlive the inner scope but still be terminated
+ * when the outerScope is closed.
+ *
+ * ```ts
+ * import { Console, Effect, Schedule } from "effect"
+ *
+ * // Child fiber that logs a message repeatedly every second
+ * const child = Effect.repeat(
+ * Console.log("child: still running!"),
+ * Schedule.fixed("1 second")
+ * )
+ *
+ * const program = Effect.scoped(
+ * Effect.gen(function* () {
+ * yield* Effect.addFinalizer(() =>
+ * Console.log("The outer scope is about to be closed!")
+ * )
+ *
+ * // Capture the outer scope
+ * const outerScope = yield* Effect.scope
+ *
+ * // Create an inner scope
+ * yield* Effect.scoped(
+ * Effect.gen(function* () {
+ * yield* Effect.addFinalizer(() =>
+ * Console.log("The inner scope is about to be closed!")
+ * )
+ * // Fork the child fiber in the outer scope
+ * yield* Effect.forkIn(child, outerScope)
+ * yield* Effect.sleep("3 seconds")
+ * })
+ * )
+ *
+ * yield* Effect.sleep("5 seconds")
+ * })
+ * )
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // The inner scope is about to be closed!
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // The outer scope is about to be closed!
+ * ```
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const forkIn = exports.forkIn = circular.forkIn;
+/**
+ * Forks a fiber in a local scope, ensuring it outlives its parent.
+ *
+ * **Details**
+ *
+ * This function is used to create fibers that are tied to a local scope,
+ * meaning they are not dependent on their parent fiber's lifecycle. Instead,
+ * they will continue running until the scope they were created in is closed.
+ * This is particularly useful when you need a fiber to run independently of the
+ * parent fiber, but still want it to be terminated when the scope ends.
+ *
+ * Fibers created with this function are isolated from the parent fiber’s
+ * termination, so they can run for a longer period. This behavior is different
+ * from fibers created with {@link fork}, which are terminated when the parent fiber
+ * terminates. With `forkScoped`, the child fiber will keep running until the
+ * local scope ends, regardless of the state of the parent fiber.
+ *
+ * **Example** (Forking a Fiber in a Local Scope)
+ *
+ * In this example, the child fiber continues to run beyond the lifetime of the parent fiber.
+ * The child fiber is tied to the local scope and will be terminated only when the scope ends.
+ *
+ * ```ts
+ * import { Effect, Console, Schedule } from "effect"
+ *
+ * // Child fiber that logs a message repeatedly every second
+ * const child = Effect.repeat(
+ * Console.log("child: still running!"),
+ * Schedule.fixed("1 second")
+ * )
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const parent = Effect.gen(function* () {
+ * console.log("parent: started!")
+ * // Child fiber attached to local scope
+ * yield* Effect.forkScoped(child)
+ * yield* Effect.sleep("3 seconds")
+ * console.log("parent: finished!")
+ * })
+ *
+ * // Program runs within a local scope
+ * const program = Effect.scoped(
+ * Effect.gen(function* () {
+ * console.log("Local scope started!")
+ * yield* Effect.fork(parent)
+ * // Scope lasts for 5 seconds
+ * yield* Effect.sleep("5 seconds")
+ * console.log("Leaving the local scope!")
+ * })
+ * )
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // Local scope started!
+ * // parent: started!
+ * // child: still running!
+ * // child: still running!
+ * // child: still running!
+ * // parent: finished!
+ * // child: still running!
+ * // child: still running!
+ * // Leaving the local scope!
+ * ```
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const forkScoped = exports.forkScoped = circular.forkScoped;
+/**
+ * Like {@link fork} but handles an error with the provided handler.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const forkWithErrorHandler = exports.forkWithErrorHandler = fiberRuntime.forkWithErrorHandler;
+/**
+ * Creates an `Effect` value that represents the exit value of the specified
+ * fiber.
+ *
+ * @see {@link fromFiberEffect} for creating an effect from a fiber obtained from an effect.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const fromFiber = exports.fromFiber = circular.fromFiber;
+/**
+ * Creates an `Effect` value that represents the exit value of a fiber obtained
+ * from an effect.
+ *
+ * @see {@link fromFiber} for creating an effect from a fiber.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const fromFiberEffect = exports.fromFiberEffect = circular.fromFiberEffect;
+/**
+ * Supervises child fibers by reporting them to a specified supervisor.
+ *
+ * **Details**
+ *
+ * This function takes a supervisor as an argument and returns an effect where
+ * all child fibers forked within it are supervised by the provided supervisor.
+ * This enables you to capture detailed information about these child fibers,
+ * such as their status, through the supervisor.
+ *
+ * **Example** (Monitoring Fiber Count)
+ *
+ * ```ts
+ * import { Effect, Supervisor, Schedule, Fiber, FiberStatus } from "effect"
+ *
+ * // Main program that monitors fibers while calculating a Fibonacci number
+ * const program = Effect.gen(function* () {
+ * // Create a supervisor to track child fibers
+ * const supervisor = yield* Supervisor.track
+ *
+ * // Start a Fibonacci calculation, supervised by the supervisor
+ * const fibFiber = yield* fib(20).pipe(
+ * Effect.supervised(supervisor),
+ * // Fork the Fibonacci effect into a fiber
+ * Effect.fork
+ * )
+ *
+ * // Define a schedule to periodically monitor the fiber count every 500ms
+ * const policy = Schedule.spaced("500 millis").pipe(
+ * Schedule.whileInputEffect((_) =>
+ * Fiber.status(fibFiber).pipe(
+ * // Continue while the Fibonacci fiber is not done
+ * Effect.andThen((status) => status !== FiberStatus.done)
+ * )
+ * )
+ * )
+ *
+ * // Start monitoring the fibers, using the supervisor to track the count
+ * const monitorFiber = yield* monitorFibers(supervisor).pipe(
+ * // Repeat the monitoring according to the schedule
+ * Effect.repeat(policy),
+ * // Fork the monitoring into its own fiber
+ * Effect.fork
+ * )
+ *
+ * // Join the monitor and Fibonacci fibers to ensure they complete
+ * yield* Fiber.join(monitorFiber)
+ * const result = yield* Fiber.join(fibFiber)
+ *
+ * console.log(`fibonacci result: ${result}`)
+ * })
+ *
+ * // Function to monitor and log the number of active fibers
+ * const monitorFibers = (
+ * supervisor: Supervisor.Supervisor>>
+ * ): Effect.Effect =>
+ * Effect.gen(function* () {
+ * const fibers = yield* supervisor.value // Get the current set of fibers
+ * console.log(`number of fibers: ${fibers.length}`)
+ * })
+ *
+ * // Recursive Fibonacci calculation, spawning fibers for each recursive step
+ * const fib = (n: number): Effect.Effect =>
+ * Effect.gen(function* () {
+ * if (n <= 1) {
+ * return 1
+ * }
+ * yield* Effect.sleep("500 millis") // Simulate work by delaying
+ *
+ * // Fork two fibers for the recursive Fibonacci calls
+ * const fiber1 = yield* Effect.fork(fib(n - 2))
+ * const fiber2 = yield* Effect.fork(fib(n - 1))
+ *
+ * // Join the fibers to retrieve their results
+ * const v1 = yield* Fiber.join(fiber1)
+ * const v2 = yield* Fiber.join(fiber2)
+ *
+ * return v1 + v2 // Combine the results
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output:
+ * // number of fibers: 0
+ * // number of fibers: 2
+ * // number of fibers: 6
+ * // number of fibers: 14
+ * // number of fibers: 30
+ * // number of fibers: 62
+ * // number of fibers: 126
+ * // number of fibers: 254
+ * // number of fibers: 510
+ * // number of fibers: 1022
+ * // number of fibers: 2034
+ * // number of fibers: 3795
+ * // number of fibers: 5810
+ * // number of fibers: 6474
+ * // number of fibers: 4942
+ * // number of fibers: 2515
+ * // number of fibers: 832
+ * // number of fibers: 170
+ * // number of fibers: 18
+ * // number of fibers: 0
+ * // fibonacci result: 10946
+ * ```
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const supervised = exports.supervised = circular.supervised;
+/**
+ * Transplants specified effects so that when those effects fork other
+ * effects, the forked effects will be governed by the scope of the fiber that
+ * executes this effect.
+ *
+ * This can be used to "graft" deep grandchildren onto a higher-level scope,
+ * effectively extending their lifespans into the parent scope.
+ *
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const transplant = exports.transplant = core.transplant;
+/**
+ * @since 2.0.0
+ * @category Supervision & Fibers
+ */
+const withConcurrency = exports.withConcurrency = core.withConcurrency;
+/**
+ * Sets the provided scheduler for usage in the wrapped effect
+ *
+ * @since 2.0.0
+ * @category Scheduler
+ */
+const withScheduler = exports.withScheduler = Scheduler.withScheduler;
+/**
+ * Sets the scheduling priority used when yielding
+ *
+ * @since 2.0.0
+ * @category Scheduler
+ */
+const withSchedulingPriority = exports.withSchedulingPriority = core.withSchedulingPriority;
+/**
+ * Sets the maximum number of operations before yield by the default schedulers
+ *
+ * @since 2.0.0
+ * @category Scheduler
+ */
+const withMaxOpsBeforeYield = exports.withMaxOpsBeforeYield = core.withMaxOpsBeforeYield;
+/**
+ * Retrieves the `Clock` service from the context.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * const clock = yield* Effect.clock
+ * const currentTime = yield* clock.currentTimeMillis
+ * console.log(`Current time in milliseconds: ${currentTime}`)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Example Output:
+ * // Current time in milliseconds: 1735484796134
+ * ```
+ *
+ * @since 2.0.0
+ * @category Clock
+ */
+const clock = exports.clock = effect.clock;
+/**
+ * Retrieves the `Clock` service from the context and provides it to the
+ * specified effectful function.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const program = Effect.clockWith((clock) =>
+ * clock.currentTimeMillis.pipe(
+ * Effect.map((currentTime) => `Current time is: ${currentTime}`),
+ * Effect.tap(Console.log)
+ * )
+ * )
+ *
+ * Effect.runFork(program)
+ * // Example Output:
+ * // Current time is: 1735484929744
+ * ```
+ *
+ * @since 2.0.0
+ * @category Clock
+ */
+const clockWith = exports.clockWith = effect.clockWith;
+/**
+ * Sets the implementation of the `Clock` service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category Clock
+ */
+const withClockScoped = exports.withClockScoped = fiberRuntime.withClockScoped;
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * `Clock` service.
+ *
+ * @since 2.0.0
+ * @category Clock
+ */
+const withClock = exports.withClock = defaultServices.withClock;
+/**
+ * Retreives the `Console` service from the context
+ *
+ * @since 2.0.0
+ * @category Console
+ */
+const console = exports.console = console_.console;
+/**
+ * Retreives the `Console` service from the context and provides it to the
+ * specified effectful function.
+ *
+ * @since 2.0.0
+ * @category Console
+ */
+const consoleWith = exports.consoleWith = console_.consoleWith;
+/**
+ * Sets the implementation of the console service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category Creating Effects
+ */
+const withConsoleScoped = exports.withConsoleScoped = console_.withConsoleScoped;
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * console service.
+ *
+ * @since 2.0.0
+ * @category Console
+ */
+const withConsole = exports.withConsole = console_.withConsole;
+/**
+ * Delays the execution of an effect by a specified `Duration`.
+ *
+ * **Details
+ *
+ * This function postpones the execution of the provided effect by the specified
+ * duration. The duration can be provided in various formats supported by the
+ * `Duration` module.
+ *
+ * Internally, this function does not block the thread; instead, it uses an
+ * efficient, non-blocking mechanism to introduce the delay.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const task = Console.log("Task executed")
+ *
+ * const program = Console.log("start").pipe(
+ * Effect.andThen(
+ * // Delays the log message by 2 seconds
+ * task.pipe(Effect.delay("2 seconds"))
+ * )
+ * )
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // start
+ * // Task executed
+ * ```
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const delay = exports.delay = effect.delay;
+/**
+ * Suspends the execution of an effect for a specified `Duration`.
+ *
+ * **Details**
+ *
+ * This function pauses the execution of an effect for a given duration. It is
+ * asynchronous, meaning that it does not block the fiber executing the effect.
+ * Instead, the fiber is suspended during the delay period and can resume once
+ * the specified time has passed.
+ *
+ * The duration can be specified using various formats supported by the
+ * `Duration` module, such as a string (`"2 seconds"`) or numeric value
+ * representing milliseconds.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * console.log("Starting task...")
+ * yield* Effect.sleep("3 seconds") // Waits for 3 seconds
+ * console.log("Task completed!")
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // Starting task...
+ * // Task completed!
+ * ```
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const sleep = exports.sleep = effect.sleep;
+/**
+ * Executes an effect and measures the time it takes to complete.
+ *
+ * **Details**
+ *
+ * This function wraps the provided effect and returns a new effect that, when
+ * executed, performs the original effect and calculates its execution duration.
+ *
+ * The result of the new effect includes both the execution time (as a
+ * `Duration`) and the original effect's result. This is useful for monitoring
+ * performance or gaining insights into the time taken by specific operations.
+ *
+ * The original effect's behavior (success, failure, or interruption) remains
+ * unchanged, and the timing information is provided alongside the result in a
+ * tuple.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Duration, Effect } from "effect"
+ *
+ * const task = Effect.gen(function*() {
+ * yield* Effect.sleep("2 seconds") // Simulates some work
+ * return "some result"
+ * })
+ *
+ * const timedTask = task.pipe(Effect.timed)
+ *
+ * const program = Effect.gen(function*() {
+ * const [duration, result] = yield* timedTask
+ * console.log(`Task completed in ${Duration.toMillis(duration)} ms with result: ${result}`)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: Task completed in 2003.749125 ms with result: some result
+ * ```
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timed = exports.timed = effect.timed;
+/**
+ * Executes an effect and measures its execution time using a custom clock.
+ *
+ * **Details**
+ *
+ * This function extends the functionality of {@link timed} by allowing you to
+ * specify a custom clock for measuring the execution duration. The provided
+ * effect (`nanoseconds`) represents the clock and should return the current
+ * time in nanoseconds. The timing information is computed using this custom
+ * clock instead of the default system clock.
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timedWith = exports.timedWith = effect.timedWith;
+/**
+ * Adds a time limit to an effect, triggering a timeout if the effect exceeds
+ * the duration.
+ *
+ * **Details**
+ *
+ * This function allows you to enforce a time limit on the execution of an
+ * effect. If the effect does not complete within the given duration, it fails
+ * with a `TimeoutException`. This is useful for preventing tasks from hanging
+ * indefinitely, especially in scenarios where responsiveness or resource limits
+ * are critical.
+ *
+ * The returned effect will either:
+ * - Succeed with the original effect's result if it completes within the
+ * specified duration.
+ * - Fail with a `TimeoutException` if the time limit is exceeded.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task = Effect.gen(function* () {
+ * console.log("Start processing...")
+ * yield* Effect.sleep("2 seconds") // Simulates a delay in processing
+ * console.log("Processing complete.")
+ * return "Result"
+ * })
+ *
+ * // Output will show a TimeoutException as the task takes longer
+ * // than the specified timeout duration
+ * const timedEffect = task.pipe(Effect.timeout("1 second"))
+ *
+ * Effect.runPromiseExit(timedEffect).then(console.log)
+ * // Output:
+ * // Start processing...
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: { _tag: 'TimeoutException' }
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timeout = exports.timeout = circular.timeout;
+/**
+ * Gracefully handles timeouts by returning an `Option` that represents either
+ * the result or a timeout.
+ *
+ * **Details**
+ *
+ * This function wraps the outcome of an effect in an `Option` type. If the
+ * effect completes within the specified duration, it returns a `Some`
+ * containing the result. If the effect times out, it returns a `None`. Unlike
+ * other timeout methods, this approach does not raise errors or exceptions;
+ * instead, it allows you to treat timeouts as a regular outcome, simplifying
+ * the logic for handling delays.
+ *
+ * **When to Use**
+ *
+ * This is useful when you want to handle timeouts without causing the program
+ * to fail, making it easier to manage situations where you expect tasks might
+ * take too long but want to continue executing other tasks.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task = Effect.gen(function* () {
+ * console.log("Start processing...")
+ * yield* Effect.sleep("2 seconds") // Simulates a delay in processing
+ * console.log("Processing complete.")
+ * return "Result"
+ * })
+ *
+ * const timedOutEffect = Effect.all([
+ * task.pipe(Effect.timeoutOption("3 seconds")),
+ * task.pipe(Effect.timeoutOption("1 second"))
+ * ])
+ *
+ * Effect.runPromise(timedOutEffect).then(console.log)
+ * // Output:
+ * // Start processing...
+ * // Processing complete.
+ * // Start processing...
+ * // [
+ * // { _id: 'Option', _tag: 'Some', value: 'Result' },
+ * // { _id: 'Option', _tag: 'None' }
+ * // ]
+ * ```
+ *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
+ * @since 3.1.0
+ * @category Delays & Timeouts
+ */
+const timeoutOption = exports.timeoutOption = circular.timeoutOption;
+/**
+ * Specifies a custom error to be produced when a timeout occurs.
+ *
+ * **Details**
+ *
+ * This function allows you to handle timeouts in a customized way by defining a
+ * specific error to be raised when an effect exceeds the given duration. Unlike
+ * default timeout behaviors that use generic exceptions, this function gives
+ * you the flexibility to specify a meaningful error type that aligns with your
+ * application's needs.
+ *
+ * When you apply this function, you provide:
+ * - A `duration`: The time limit for the effect.
+ * - An `onTimeout` function: A lazy evaluation function that generates the
+ * custom error if the timeout occurs.
+ *
+ * If the effect completes within the time limit, its result is returned
+ * normally. Otherwise, the `onTimeout` function is triggered, and its output is
+ * used as the error for the effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task = Effect.gen(function* () {
+ * console.log("Start processing...")
+ * yield* Effect.sleep("2 seconds") // Simulates a delay in processing
+ * console.log("Processing complete.")
+ * return "Result"
+ * })
+ *
+ * class MyTimeoutError {
+ * readonly _tag = "MyTimeoutError"
+ * }
+ *
+ * const program = task.pipe(
+ * Effect.timeoutFail({
+ * duration: "1 second",
+ * onTimeout: () => new MyTimeoutError() // Custom timeout error
+ * })
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // Start processing...
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: MyTimeoutError { _tag: 'MyTimeoutError' }
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timeoutFail = exports.timeoutFail = circular.timeoutFail;
+/**
+ * Specifies a custom defect to be thrown when a timeout occurs.
+ *
+ * **Details**
+ *
+ * This function allows you to handle timeouts as exceptional cases by
+ * generating a custom defect when an effect exceeds the specified duration. You
+ * provide:
+ * - A `duration`: The time limit for the effect.
+ * - An `onTimeout` function: A lazy evaluation function that generates the
+ * custom defect (typically created using `Cause.die`).
+ *
+ * If the effect completes within the time limit, its result is returned
+ * normally. Otherwise, the custom defect is triggered, and the effect fails
+ * with that defect.
+ *
+ * **When to Use**
+ *
+ * This is especially useful when you need to treat timeouts as critical
+ * failures in your application and wish to include meaningful information in
+ * the defect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Cause } from "effect"
+ *
+ * const task = Effect.gen(function* () {
+ * console.log("Start processing...")
+ * yield* Effect.sleep("2 seconds") // Simulates a delay in processing
+ * console.log("Processing complete.")
+ * return "Result"
+ * })
+ *
+ * const program = task.pipe(
+ * Effect.timeoutFailCause({
+ * duration: "1 second",
+ * onTimeout: () => Cause.die("Timed out!") // Custom defect for timeout
+ * })
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // Start processing...
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Timed out!' }
+ * // }
+ * ```
+ *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timeoutFailCause = exports.timeoutFailCause = circular.timeoutFailCause;
+/**
+ * Provides custom behavior for successful and timed-out operations.
+ *
+ * **Details**
+ *
+ * This function allows you to define distinct outcomes for an effect depending
+ * on whether it completes within a specified time frame or exceeds the timeout
+ * duration. You can provide:
+ * - `onSuccess`: A handler for processing the result of the effect if it
+ * completes successfully within the time limit.
+ * - `onTimeout`: A handler for generating a result when the effect times out.
+ * - `duration`: The maximum allowed time for the effect to complete.
+ *
+ * **When to Use**
+ *
+ * Unlike {@link timeout}, which raises an exception for timeouts, this function
+ * gives you full control over the behavior for both success and timeout
+ * scenarios. It is particularly useful when you want to encapsulate timeouts
+ * and successes into a specific data structure, like an `Either` type, to
+ * represent these outcomes in a meaningful way.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Either } from "effect"
+ *
+ * const task = Effect.gen(function* () {
+ * console.log("Start processing...")
+ * yield* Effect.sleep("2 seconds") // Simulates a delay in processing
+ * console.log("Processing complete.")
+ * return "Result"
+ * })
+ *
+ * const program = task.pipe(
+ * Effect.timeoutTo({
+ * duration: "1 second",
+ * onSuccess: (result): Either.Either =>
+ * Either.right(result),
+ * onTimeout: (): Either.Either =>
+ * Either.left("Timed out!")
+ * })
+ * )
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // Start processing...
+ * // {
+ * // _id: "Either",
+ * // _tag: "Left",
+ * // left: "Timed out!"
+ * // }
+ * ```
+ *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ *
+ * @since 2.0.0
+ * @category Delays & Timeouts
+ */
+const timeoutTo = exports.timeoutTo = circular.timeoutTo;
+/**
+ * Allows working with the default configuration provider.
+ *
+ * **Details**
+ *
+ * This function retrieves the default configuration provider and passes it to
+ * the provided function, which can use it to perform computations or retrieve
+ * configuration values. The function can return an effect that leverages the
+ * configuration provider for its operations.
+ *
+ * @since 2.0.0
+ * @category Config
+ */
+const configProviderWith = exports.configProviderWith = defaultServices.configProviderWith;
+/**
+ * Executes an effect using a specific configuration provider.
+ *
+ * **Details**
+ *
+ * This function lets you run an effect with a specified configuration provider.
+ * The custom provider will override the default configuration provider for the
+ * duration of the effect's execution.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful when you need to use a different set of
+ * configuration values or sources for specific parts of your application.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Config, ConfigProvider, Effect } from "effect"
+ *
+ * const customProvider: ConfigProvider.ConfigProvider = ConfigProvider.fromMap(
+ * new Map([["custom-key", "custom-value"]])
+ * )
+ *
+ * const program = Effect.withConfigProvider(customProvider)(
+ * Effect.gen(function*() {
+ * const value = yield* Config.string("custom-key")
+ * console.log(`Config value: ${value}`)
+ * })
+ * )
+ *
+ * Effect.runPromise(program)
+ * // Output:
+ * // Config value: custom-value
+ * ```
+ *
+ * @since 2.0.0
+ * @category Config
+ */
+const withConfigProvider = exports.withConfigProvider = defaultServices.withConfigProvider;
+/**
+ * Sets a configuration provider within a scope.
+ *
+ * **Details**
+ *
+ * This function sets the configuration provider to a specified value and
+ * ensures that it is restored to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category Config
+ */
+const withConfigProviderScoped = exports.withConfigProviderScoped = fiberRuntime.withConfigProviderScoped;
+/**
+ * Accesses the full context of the effect.
+ *
+ * **Details**
+ *
+ * This function provides the ability to access the entire context required by
+ * an effect. The context is a container that holds dependencies or environment
+ * values needed by an effect to run. By using this function, you can retrieve
+ * and work with the context directly within an effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const context = exports.context = core.context;
+/**
+ * Accesses the context and applies a transformation function.
+ *
+ * **Details**
+ *
+ * This function retrieves the context of the effect and applies a pure
+ * transformation function to it. The result of the transformation is then
+ * returned within the effect.
+ *
+ * @see {@link contextWithEffect} for a version that allows effectful transformations.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const contextWith = exports.contextWith = effect.contextWith;
+/**
+ * Accesses the context and performs an effectful transformation.
+ *
+ * **Details**
+ *
+ * This function retrieves the context and allows you to transform it
+ * effectually using another effect. It is useful when the transformation
+ * involves asynchronous or effectful operations.
+ *
+ * @see {@link contextWith} for a version that allows pure transformations.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const contextWithEffect = exports.contextWithEffect = core.contextWithEffect;
+/**
+ * Provides part of the required context while leaving the rest unchanged.
+ *
+ * **Details**
+ *
+ * This function allows you to transform the context required by an effect,
+ * providing part of the context and leaving the rest to be fulfilled later.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Context, Effect } from "effect"
+ *
+ * class Service1 extends Context.Tag("Service1")() {}
+ * class Service2 extends Context.Tag("Service2")() {}
+ *
+ * const program = Effect.gen(function*() {
+ * const service1 = yield* Service1
+ * console.log(service1.port)
+ * const service2 = yield* Service2
+ * console.log(service2.connection)
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const programWithService1 = Effect.mapInputContext(
+ * program,
+ * (ctx: Context.Context) => Context.add(ctx, Service1, { port: 3000 })
+ * )
+ *
+ * const runnable = programWithService1.pipe(
+ * Effect.provideService(Service2, { connection: "localhost" }),
+ * Effect.provideService(Service1, { port: 3001 })
+ * )
+ *
+ * Effect.runPromise(runnable)
+ * // Output:
+ * // 3000
+ * // localhost
+ * ```
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const mapInputContext = exports.mapInputContext = core.mapInputContext;
+/**
+ * Provides necessary dependencies to an effect, removing its environmental
+ * requirements.
+ *
+ * **Details**
+ *
+ * This function allows you to supply the required environment for an effect.
+ * The environment can be provided in the form of one or more `Layer`s, a
+ * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is
+ * provided, the effect can run without requiring external dependencies.
+ *
+ * You can compose layers to create a modular and reusable way of setting up the
+ * environment for effects. For example, layers can be used to configure
+ * databases, logging services, or any other required dependencies.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Context, Effect, Layer } from "effect"
+ *
+ * class Database extends Context.Tag("Database")<
+ * Database,
+ * { readonly query: (sql: string) => Effect.Effect> }
+ * >() {}
+ *
+ * const DatabaseLive = Layer.succeed(
+ * Database,
+ * {
+ * // Simulate a database query
+ * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([]))
+ * }
+ * )
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function*() {
+ * const database = yield* Database
+ * const result = yield* database.query("SELECT * FROM users")
+ * return result
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const runnable = Effect.provide(program, DatabaseLive)
+ *
+ * Effect.runPromise(runnable).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users"
+ * // []
+ * ```
+ *
+ * @see {@link provideService} for providing a service to an effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const provide = exports.provide = layer.effect_provide;
+/**
+ * Provides an implementation for a service in the context of an effect.
+ *
+ * **Details**
+ *
+ * This function allows you to supply a specific implementation for a service
+ * required by an effect. Services are typically defined using `Context.Tag`,
+ * which acts as a unique identifier for the service. By using this function,
+ * you link the service to its concrete implementation, enabling the effect to
+ * execute successfully without additional requirements.
+ *
+ * For example, you can use this function to provide a random number generator,
+ * a logger, or any other service your effect depends on. Once the service is
+ * provided, all parts of the effect that rely on the service will automatically
+ * use the implementation you supplied.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Context } from "effect"
+ *
+ * // Declaring a tag for a service that generates random numbers
+ * class Random extends Context.Tag("MyRandomService")<
+ * Random,
+ * { readonly next: Effect.Effect }
+ * >() {}
+ *
+ * // Using the service
+ * const program = Effect.gen(function* () {
+ * const random = yield* Random
+ * const randomNumber = yield* random.next
+ * console.log(`random number: ${randomNumber}`)
+ * })
+ *
+ * // Providing the implementation
+ * //
+ * // ┌─── Effect
+ * // ▼
+ * const runnable = Effect.provideService(program, Random, {
+ * next: Effect.sync(() => Math.random())
+ * })
+ *
+ * // Run successfully
+ * Effect.runPromise(runnable)
+ * // Example Output:
+ * // random number: 0.8241872233134417
+ * ```
+ *
+ * @see {@link provide} for providing multiple layers to an effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const provideService = exports.provideService = effect.provideService;
+/**
+ * Dynamically provides an implementation for a service using an effect.
+ *
+ * **Details**
+ *
+ * This function allows you to provide an implementation for a service
+ * dynamically by using another effect. The provided effect is executed to
+ * produce the service implementation, which is then made available to the
+ * consuming effect. This is particularly useful when the service implementation
+ * itself requires asynchronous or resource-intensive initialization.
+ *
+ * For example, you can use this function to lazily initialize a database
+ * connection or fetch configuration values from an external source before
+ * making the service available to your effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const provideServiceEffect = exports.provideServiceEffect = effect.provideServiceEffect;
+/**
+ * Creates a function that uses a service from the context to produce a value.
+ *
+ * @see {@link serviceFunctionEffect} for a version that returns an effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceFunction = exports.serviceFunction = effect.serviceFunction;
+/**
+ * Creates a function that uses a service from the context to produce an effect.
+ *
+ * @see {@link serviceFunction} for a version that returns a value.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceFunctionEffect = exports.serviceFunctionEffect = effect.serviceFunctionEffect;
+/**
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceFunctions = exports.serviceFunctions = effect.serviceFunctions;
+/**
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceConstants = exports.serviceConstants = effect.serviceConstants;
+/**
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceMembers = exports.serviceMembers = effect.serviceMembers;
+/**
+ * Retrieves an optional service from the context as an `Option`.
+ *
+ * **Details**
+ *
+ * This function retrieves a service from the context and wraps it in an
+ * `Option`. If the service is available, it returns a `Some` containing the
+ * service. If the service is not found, it returns a `None`. This approach is
+ * useful when you want to handle the absence of a service gracefully without
+ * causing an error.
+ *
+ * **When to Use**
+ *
+ * Use this function when:
+ * - You need to access a service that may or may not be present in the context.
+ * - You want to handle the absence of a service using the `Option` type instead
+ * of throwing an error.
+ *
+ * @see {@link serviceOptional} for a version that throws an error if the service is missing.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceOption = exports.serviceOption = effect.serviceOption;
+/**
+ * Retrieves a service from the context, throwing an error if it is missing.
+ *
+ * **Details**
+ *
+ * This function retrieves a required service from the context. If the service
+ * is available, it returns the service. If the service is missing, it throws a
+ * `NoSuchElementException`, which can be handled using Effect's error-handling
+ * mechanisms. This is useful for services that are critical to the execution of
+ * your effect.
+ *
+ * @see {@link serviceOption} for a version that returns an `Option` instead of throwing an error.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const serviceOptional = exports.serviceOptional = effect.serviceOptional;
+/**
+ * Updates a service in the context with a new implementation.
+ *
+ * **Details**
+ *
+ * This function modifies the existing implementation of a service in the
+ * context. It retrieves the current service, applies the provided
+ * transformation function `f`, and replaces the old service with the
+ * transformed one.
+ *
+ * **When to Use**
+ *
+ * This is useful for adapting or extending a service's behavior during the
+ * execution of an effect.
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const updateService = exports.updateService = effect.updateService;
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Effect` 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
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Effect, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Effect.Do,
+ * Effect.bind("x", () => Effect.succeed(2)),
+ * Effect.bind("y", () => Effect.succeed(3)),
+ * Effect.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
+ * ```
+ *
+ * @see {@link bind}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
+ * @category Do notation
+ * @since 2.0.0
+ */
+const Do = exports.Do = effect.Do;
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Effect` 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
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Effect, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Effect.Do,
+ * Effect.bind("x", () => Effect.succeed(2)),
+ * Effect.bind("y", () => Effect.succeed(3)),
+ * Effect.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
+ * ```
+ *
+ * @see {@link Do}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
+ * @category Do notation
+ * @since 2.0.0
+ */
+const bind = exports.bind = effect.bind;
+/**
+ * `bindAll` combines `all` with `bind`. It is useful
+ * when you want to concurrently run multiple effects and then combine their
+ * results in a Do notation pipeline.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Effect, Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Effect.Do,
+ * Effect.bind("x", () => Effect.succeed(2)),
+ * Effect.bindAll(({ x }) => ({
+ * a: Effect.succeed(x),
+ * b: Effect.fail("oops"),
+ * }), { concurrency: 2, mode: "either" })
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") })
+ * ```
+ *
+ * @category Do notation
+ * @since 3.7.0
+ */
+const bindAll = exports.bindAll = circular.bindAll;
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Effect` 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
+ *
+ * **Example**
+ *
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Effect, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Effect.Do,
+ * Effect.bind("x", () => Effect.succeed(2)),
+ * Effect.bind("y", () => Effect.succeed(3)),
+ * Effect.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
+ * ```
+ *
+ * @see {@link Do}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
+ * @category Do notation
+ * @since 2.0.0
+ */
+const bindTo = exports.bindTo = effect.bindTo;
+const let_ = exports.let = effect.let_;
+/**
+ * Encapsulates the result of an effect in an `Option`.
+ *
+ * **Details**
+ *
+ * This function wraps the outcome of an effect in an `Option` type. If the
+ * original effect succeeds, the success value is wrapped in `Option.some`. If
+ * the effect fails, the failure is converted to `Option.none`.
+ *
+ * This is particularly useful for scenarios where you want to represent the
+ * absence of a value explicitly, without causing the resulting effect to fail.
+ * The resulting effect has an error type of `never`, meaning it cannot fail
+ * directly. However, unrecoverable errors, also referred to as defects, are
+ * not captured and will still result in failure.
+ *
+ * **Example** (Using Effect.option to Handle Errors)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const maybe1 = Effect.option(Effect.succeed(1))
+ *
+ * Effect.runPromiseExit(maybe1).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Success',
+ * // value: { _id: 'Option', _tag: 'Some', value: 1 }
+ * // }
+ *
+ * const maybe2 = Effect.option(Effect.fail("Uh oh!"))
+ *
+ * Effect.runPromiseExit(maybe2).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Success',
+ * // value: { _id: 'Option', _tag: 'None' }
+ * // }
+ *
+ * const maybe3 = Effect.option(Effect.die("Boom!"))
+ *
+ * Effect.runPromiseExit(maybe3).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Boom!' }
+ * // }
+ * ```
+ *
+ * @see {@link either} for a version that uses `Either` instead.
+ * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ *
+ * @since 2.0.0
+ * @category Outcome Encapsulation
+ */
+const option = exports.option = effect.option;
+/**
+ * Encapsulates both success and failure of an `Effect` into an `Either` type.
+ *
+ * **Details**
+ *
+ * This function converts an effect that may fail into an effect that always
+ * succeeds, wrapping the outcome in an `Either` type. The result will be
+ * `Either.Left` if the effect fails, containing the recoverable error, or
+ * `Either.Right` if it succeeds, containing the result.
+ *
+ * Using this function, you can handle recoverable errors explicitly without
+ * causing the effect to fail. This is particularly useful in scenarios where
+ * you want to chain effects and manage both success and failure in the same
+ * logical flow.
+ *
+ * It's important to note that unrecoverable errors, often referred to as
+ * "defects," are still thrown and not captured within the `Either` type. Only
+ * failures that are explicitly represented as recoverable errors in the effect
+ * are encapsulated.
+ *
+ * The resulting effect cannot fail directly because all recoverable failures
+ * are represented inside the `Either` type.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Either, Random } from "effect"
+ *
+ * class HttpError {
+ * readonly _tag = "HttpError"
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.gen(function* () {
+ * const n1 = yield* Random.next
+ * const n2 = yield* Random.next
+ * if (n1 < 0.5) {
+ * yield* Effect.fail(new HttpError())
+ * }
+ * if (n2 < 0.5) {
+ * yield* Effect.fail(new ValidationError())
+ * }
+ * return "some result"
+ * })
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const recovered = Effect.gen(function* () {
+ * // ┌─── Either
+ * // ▼
+ * const failureOrSuccess = yield* Effect.either(program)
+ * return Either.match(failureOrSuccess, {
+ * onLeft: (error) => `Recovering from ${error._tag}`,
+ * onRight: (value) => value // Do nothing in case of success
+ * })
+ * })
+ * ```
+ *
+ * @see {@link option} for a version that uses `Option` instead.
+ * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ *
+ * @since 2.0.0
+ * @category Outcome Encapsulation
+ */
+const either = exports.either = core.either;
+/**
+ * Encapsulates both success and failure of an `Effect` using the `Exit` type.
+ *
+ * **Details**
+ *
+ * This function converts an effect into one that always succeeds, wrapping its
+ * outcome in the `Exit` type. The `Exit` type provides explicit handling of
+ * both success (`Exit.Success`) and failure (`Exit.Failure`) cases, including
+ * defects (unrecoverable errors).
+ *
+ * Unlike {@link either} or {@link option}, this function also encapsulates
+ * defects, which are typically unrecoverable and would otherwise terminate the
+ * effect. With the `Exit` type, defects are represented in `Exit.Failure`,
+ * allowing for detailed introspection and structured error handling.
+ *
+ * This makes the resulting effect robust and incapable of direct failure (its
+ * error type is `never`). It is particularly useful for workflows where all
+ * outcomes, including unexpected defects, must be managed and analyzed.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Cause, Console, Exit } from "effect"
+ *
+ * // Simulating a runtime error
+ * const task = Effect.dieMessage("Boom!")
+ *
+ * const program = Effect.gen(function* () {
+ * const exit = yield* Effect.exit(task)
+ * if (Exit.isFailure(exit)) {
+ * const cause = exit.cause
+ * if (
+ * Cause.isDieType(cause) &&
+ * Cause.isRuntimeException(cause.defect)
+ * ) {
+ * yield* Console.log(
+ * `RuntimeException defect caught: ${cause.defect.message}`
+ * )
+ * } else {
+ * yield* Console.log("Unknown failure caught.")
+ * }
+ * }
+ * })
+ *
+ * // We get an Exit.Success because we caught all failures
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // RuntimeException defect caught: Boom!
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Success",
+ * // value: undefined
+ * // }
+ * ```
+ *
+ * @see {@link option} for a version that uses `Option` instead.
+ * @see {@link either} for a version that uses `Either` instead.
+ *
+ * @since 2.0.0
+ * @category Outcome Encapsulation
+ */
+const exit = exports.exit = core.exit;
+/**
+ * Converts an `Effect` into an operation that completes a `Deferred` with its result.
+ *
+ * **Details**
+ *
+ * The `intoDeferred` function takes an effect and a `Deferred` and ensures that the `Deferred`
+ * is completed based on the outcome of the effect. If the effect succeeds, the `Deferred` is
+ * completed with the success value. If the effect fails, the `Deferred` is completed with the
+ * failure. Additionally, if the effect is interrupted, the `Deferred` will also be interrupted.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Deferred, Effect } from "effect"
+ *
+ * // Define an effect that succeeds
+ * const successEffect = Effect.succeed(42)
+ *
+ * const program = Effect.gen(function*() {
+ * // Create a deferred
+ * const deferred = yield* Deferred.make()
+ *
+ * // Complete the deferred using the successEffect
+ * const isCompleted = yield* Effect.intoDeferred(successEffect, deferred)
+ *
+ * // Access the value of the deferred
+ * const value = yield* Deferred.await(deferred)
+ * console.log(value)
+ *
+ * return isCompleted
+ * })
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // 42
+ * // true
+ * ```
+ *
+ * @since 2.0.0
+ * @category Synchronization Utilities
+ */
+const intoDeferred = exports.intoDeferred = core.intoDeferred;
+const if_ = exports.if = core.if_;
+/**
+ * Filters an effect, dying with a custom defect if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function applies a predicate to the result of an effect. If the
+ * predicate evaluates to `false`, the effect dies with a custom defect
+ * generated by the `orDieWith` function.
+ *
+ * **When to Use**
+ *
+ * This is useful for enforcing constraints on values and treating violations as
+ * fatal program errors.
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filterOrDie = exports.filterOrDie = effect.filterOrDie;
+/**
+ * Filters an effect, dying with a custom message if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function works like {@link filterOrDie} but allows you to specify a
+ * custom error message to describe the reason for the failure. The message is
+ * included in the defect when the predicate evaluates to `false`.
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filterOrDieMessage = exports.filterOrDieMessage = effect.filterOrDieMessage;
+/**
+ * Filters an effect, providing an alternative effect if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function applies a predicate to the result of an effect. If the
+ * predicate evaluates to `false`, it executes the `orElse` effect instead. The
+ * `orElse` effect can produce an alternative value or perform additional
+ * computations.
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filterOrElse = exports.filterOrElse = effect.filterOrElse;
+/**
+ * Filters an effect, failing with a custom error if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function applies a predicate to the result of an effect. If the
+ * predicate evaluates to `false`, the effect fails with a custom error
+ * generated by the `orFailWith` function.
+ *
+ * **When to Use**
+ *
+ * This is useful for enforcing constraints and treating violations as
+ * recoverable errors.
+ *
+ * **Providing a Guard**
+ *
+ * In addition to the filtering capabilities discussed earlier, you have the
+ * option to further refine and narrow down the type of the success channel by
+ * providing a [user-defined type
+ * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
+ * Let's explore this concept through an example:
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * // Define a user interface
+ * interface User {
+ * readonly name: string
+ * }
+ *
+ * // Simulate an asynchronous authentication function
+ * declare const auth: () => Promise
+ *
+ * const program = pipe(
+ * Effect.promise(() => auth()),
+ * // Use filterOrFail with a custom type guard to ensure user is not null
+ * Effect.filterOrFail(
+ * (user): user is User => user !== null, // Type guard
+ * () => new Error("Unauthorized")
+ * ),
+ * // 'user' now has the type `User` (not `User | null`)
+ * Effect.andThen((user) => user.name)
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category Filtering
+ */
+const filterOrFail = exports.filterOrFail = effect.filterOrFail;
+/**
+ * Filters an effect with an effectful predicate, falling back to an alternative
+ * effect if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function applies a predicate to the result of an effect. If the
+ * predicate evaluates to `false`, the effect falls back to the `orElse`
+ * effect. The `orElse` effect can produce an alternative value or perform
+ * additional computations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * // Define a user interface
+ * interface User {
+ * readonly name: string
+ * }
+ *
+ * // Simulate an asynchronous authentication function
+ * declare const auth: () => Promise
+ *
+ * const program = pipe(
+ * Effect.promise(() => auth()),
+ * // Use filterEffectOrElse with an effectful predicate
+ * Effect.filterEffectOrElse({
+ * predicate: (user) => Effect.succeed(user !== null),
+ * orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`))
+ * }),
+ * )
+ * ```
+ *
+ * @since 3.13.0
+ * @category Filtering
+ */
+const filterEffectOrElse = exports.filterEffectOrElse = core.filterEffectOrElse;
+/**
+ * Filters an effect with an effectful predicate, failing with a custom error if the predicate fails.
+ *
+ * **Details**
+ *
+ * This function applies a predicate to the result of an effect. If the
+ * predicate evaluates to `false`, the effect fails with a custom error
+ * generated by the `orFailWith` function.
+ *
+ * **When to Use**
+ *
+ * This is useful for enforcing constraints and treating violations as
+ * recoverable errors.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * // Define a user interface
+ * interface User {
+ * readonly name: string
+ * }
+ *
+ * // Simulate an asynchronous authentication function
+ * declare const auth: () => Promise
+ *
+ * const program = pipe(
+ * Effect.promise(() => auth()),
+ * // Use filterEffectOrFail with an effectful predicate
+ * Effect.filterEffectOrFail({
+ * predicate: (user) => Effect.succeed(user !== null),
+ * orFailWith: () => new Error("Unauthorized")
+ * }),
+ * )
+ * ```
+ *
+ * @since 3.13.0
+ * @category Filtering
+ */
+const filterEffectOrFail = exports.filterEffectOrFail = core.filterEffectOrFail;
+/**
+ * Executes an effect only if the condition is `false`.
+ *
+ * @see {@link unlessEffect} for a version that allows the condition to be an effect.
+ * @see {@link when} for a version that executes the effect when the condition is `true`.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const unless = exports.unless = effect.unless;
+/**
+ * Conditionally execute an effect based on the result of another effect.
+ *
+ * @see {@link unless} for a version that allows the condition to be a boolean.
+ * @see {@link whenEffect} for a version that executes the effect when the condition is `true`.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const unlessEffect = exports.unlessEffect = effect.unlessEffect;
+/**
+ * Conditionally executes an effect based on a boolean condition.
+ *
+ * **Details**
+ *
+ * This function allows you to run an effect only if a given condition evaluates
+ * to `true`. If the condition is `true`, the effect is executed, and its result
+ * is wrapped in an `Option.some`. If the condition is `false`, the effect is
+ * skipped, and the result is `Option.none`.
+ *
+ * **When to Use**
+ *
+ * This function is useful for scenarios where you need to dynamically decide
+ * whether to execute an effect based on runtime logic, while also representing
+ * the skipped case explicitly.
+ *
+ * **Example** (Conditional Effect Execution)
+ *
+ * ```ts
+ * import { Effect, Option } from "effect"
+ *
+ * const validateWeightOption = (
+ * weight: number
+ * ): Effect.Effect> =>
+ * // Conditionally execute the effect if the weight is non-negative
+ * Effect.succeed(weight).pipe(Effect.when(() => weight >= 0))
+ *
+ * // Run with a valid weight
+ * Effect.runPromise(validateWeightOption(100)).then(console.log)
+ * // Output:
+ * // {
+ * // _id: "Option",
+ * // _tag: "Some",
+ * // value: 100
+ * // }
+ *
+ * // Run with an invalid weight
+ * Effect.runPromise(validateWeightOption(-5)).then(console.log)
+ * // Output:
+ * // {
+ * // _id: "Option",
+ * // _tag: "None"
+ * // }
+ * ```
+ *
+ * @see {@link whenEffect} for a version that allows the condition to be an effect.
+ * @see {@link unless} for a version that executes the effect when the condition is `false`.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const when = exports.when = effect.when;
+/**
+ * Conditionally executes an effect based on the result of another effect.
+ *
+ * **Details**
+ *
+ * This function allows you to run an effect only if a conditional effect
+ * evaluating to a boolean resolves to `true`. If the conditional effect
+ * evaluates to `true`, the specified effect is executed, and its result is
+ * wrapped in `Option.some`. If the conditional effect evaluates to `false`, the
+ * effect is skipped, and the result is `Option.none`.
+ *
+ * **When to Use**
+ *
+ * This function is particularly useful when the decision to execute an effect
+ * depends on the result of another effect, such as a random value, a
+ * user-provided input, or a network request result.
+ *
+ * **Example** (Using an Effect as a Condition)
+ *
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const randomIntOption = Random.nextInt.pipe(
+ * Effect.whenEffect(Random.nextBoolean)
+ * )
+ *
+ * console.log(Effect.runSync(randomIntOption))
+ * // Example Output:
+ * // { _id: 'Option', _tag: 'Some', value: 8609104974198840 }
+ * ```
+ *
+ * @see {@link when} for a version that allows the condition to be a boolean.
+ * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const whenEffect = exports.whenEffect = core.whenEffect;
+/**
+ * Executes an effect conditionally based on the value of a `FiberRef` that
+ * satisfies a predicate.
+ *
+ * **Details**
+ *
+ * This function enables you to execute an effect only when the value of a
+ * specified `FiberRef` meets a certain condition defined by a predicate. If the
+ * value satisfies the predicate, the effect is executed, and the result is
+ * wrapped in an `Option.some`. If the predicate is not satisfied, the effect is
+ * skipped, and the result is `Option.none`. In both cases, the current value of
+ * the `FiberRef` is included in the result.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const whenFiberRef = exports.whenFiberRef = effect.whenFiberRef;
+/**
+ * Executes an effect conditionally based on the value of a `Ref` that satisfies
+ * a predicate.
+ *
+ * **Details**
+ *
+ * This function allows you to execute an effect only when the value of a
+ * specified `Ref` meets a condition defined by a predicate. If the value
+ * satisfies the predicate, the effect is executed, and the result is wrapped in
+ * an `Option.some`. If the predicate is not satisfied, the effect is skipped,
+ * and the result is `Option.none`. In both cases, the current value of the
+ * `Ref` is included in the result.
+ *
+ * @since 2.0.0
+ * @category Conditional Operators
+ */
+const whenRef = exports.whenRef = effect.whenRef;
+/**
+ * Chains effects to produce new `Effect` instances, useful for combining
+ * operations that depend on previous results.
+ *
+ * **Syntax**
+ *
+ * ```ts skip-type-checking
+ * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation))
+ * // or
+ * const flatMappedEffect = Effect.flatMap(myEffect, transformation)
+ * // or
+ * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation))
+ * ```
+ *
+ * **Details**
+ *
+ * `flatMap` lets you sequence effects so that the result of one effect can be
+ * used in the next step. It is similar to `flatMap` used with arrays but works
+ * specifically with `Effect` instances, allowing you to avoid deeply nested
+ * effect structures.
+ *
+ * Since effects are immutable, `flatMap` always returns a new effect instead of
+ * changing the original one.
+ *
+ * **When to Use**
+ *
+ * Use `flatMap` when you need to chain multiple effects, ensuring that each
+ * step produces a new `Effect` while flattening any nested effects that may
+ * occur.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { pipe, Effect } from "effect"
+ *
+ * // Function to apply a discount safely to a transaction amount
+ * const applyDiscount = (
+ * total: number,
+ * discountRate: number
+ * ): Effect.Effect =>
+ * discountRate === 0
+ * ? Effect.fail(new Error("Discount rate cannot be zero"))
+ * : Effect.succeed(total - (total * discountRate) / 100)
+ *
+ * // Simulated asynchronous task to fetch a transaction amount from database
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * // Chaining the fetch and discount application using `flatMap`
+ * const finalAmount = pipe(
+ * fetchTransactionAmount,
+ * Effect.flatMap((amount) => applyDiscount(amount, 5))
+ * )
+ *
+ * Effect.runPromise(finalAmount).then(console.log)
+ * // Output: 95
+ * ```
+ *
+ * @see {@link tap} for a version that ignores the result of the effect.
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const flatMap = exports.flatMap = core.flatMap;
+/**
+ * Chains two actions, where the second action can depend on the result of the
+ * first.
+ *
+ * **Syntax**
+ *
+ * ```ts skip-type-checking
+ * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
+ * // or
+ * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
+ * // or
+ * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
+ * ```
+ *
+ * **When to Use**
+ *
+ * Use `andThen` when you need to run multiple actions in sequence, with the
+ * second action depending on the result of the first. This is useful for
+ * combining effects or handling computations that must happen in order.
+ *
+ * **Details**
+ *
+ * The second action can be:
+ *
+ * - A constant value (similar to {@link as})
+ * - A function returning a value (similar to {@link map})
+ * - A `Promise`
+ * - A function returning a `Promise`
+ * - An `Effect`
+ * - A function returning an `Effect` (similar to {@link flatMap})
+ *
+ * **Note:** `andThen` works well with both `Option` and `Either` types,
+ * treating them as effects.
+ *
+ * **Example** (Applying a Discount Based on Fetched Amount)
+ *
+ * ```ts
+ * import { pipe, Effect } from "effect"
+ *
+ * // Function to apply a discount safely to a transaction amount
+ * const applyDiscount = (
+ * total: number,
+ * discountRate: number
+ * ): Effect.Effect =>
+ * discountRate === 0
+ * ? Effect.fail(new Error("Discount rate cannot be zero"))
+ * : Effect.succeed(total - (total * discountRate) / 100)
+ *
+ * // Simulated asynchronous task to fetch a transaction amount from database
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * // Using Effect.map and Effect.flatMap
+ * const result1 = pipe(
+ * fetchTransactionAmount,
+ * Effect.map((amount) => amount * 2),
+ * Effect.flatMap((amount) => applyDiscount(amount, 5))
+ * )
+ *
+ * Effect.runPromise(result1).then(console.log)
+ * // Output: 190
+ *
+ * // Using Effect.andThen
+ * const result2 = pipe(
+ * fetchTransactionAmount,
+ * Effect.andThen((amount) => amount * 2),
+ * Effect.andThen((amount) => applyDiscount(amount, 5))
+ * )
+ *
+ * Effect.runPromise(result2).then(console.log)
+ * // Output: 190
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const andThen = exports.andThen = core.andThen;
+/**
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const flatten = exports.flatten = core.flatten;
+/**
+ * Races two effects and returns the result of the first successful one.
+ *
+ * **Details**
+ *
+ * This function takes two effects and runs them concurrently. The first effect
+ * that successfully completes will determine the result of the race, and the
+ * other effect will be interrupted.
+ *
+ * If neither effect succeeds, the function will fail with a `Cause`
+ * containing all the errors.
+ *
+ * **When to Use**
+ *
+ * This is useful when you want to run two effects concurrently, but only care
+ * about the first one to succeed. It is commonly used in cases like timeouts,
+ * retries, or when you want to optimize for the faster response without
+ * worrying about the other effect.
+ *
+ * **Handling Success or Failure with Either**
+ *
+ * If you want to handle the result of whichever task completes first, whether
+ * it succeeds or fails, you can use the `Effect.either` function. This function
+ * wraps the result in an `Either` type, allowing you to see if the result
+ * was a success (`Right`) or a failure (`Left`).
+ *
+ * **Example** (Both Tasks Succeed)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.succeed("task1").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const program = Effect.race(task1, task2)
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task1 done
+ * // task2 interrupted
+ * ```
+ *
+ * **Example** (One Task Fails, One Succeeds)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const program = Effect.race(task1, task2)
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task2 done
+ * ```
+ *
+ * **Example** (Both Tasks Fail)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.fail("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const program = Effect.race(task1, task2)
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Parallel',
+ * // left: { _id: 'Cause', _tag: 'Fail', failure: 'task1' },
+ * // right: { _id: 'Cause', _tag: 'Fail', failure: 'task2' }
+ * // }
+ * // }
+ * ```
+ *
+ * **Example** (Handling Success or Failure with Either)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * // Run both tasks concurrently, wrapping the result
+ * // in Either to capture success or failure
+ * const program = Effect.race(Effect.either(task1), Effect.either(task2))
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // task2 interrupted
+ * // { _id: 'Either', _tag: 'Left', left: 'task1' }
+ * ```
+ *
+ * @see {@link raceAll} for a version that handles multiple effects.
+ * @see {@link raceFirst} for a version that returns the result of the first effect to complete.
+ *
+ * @since 2.0.0
+ * @category Racing
+ */
+const race = exports.race = fiberRuntime.race;
+/**
+ * Races multiple effects and returns the first successful result.
+ *
+ * **Details**
+ *
+ * This function runs multiple effects concurrently and returns the result of
+ * the first one to succeed. If one effect succeeds, the others will be
+ * interrupted.
+ *
+ * If none of the effects succeed, the function will fail with the last error
+ * encountered.
+ *
+ * **When to Use**
+ *
+ * This is useful when you want to race multiple effects, but only care about
+ * the first one to succeed. It is commonly used in cases like timeouts,
+ * retries, or when you want to optimize for the faster response without
+ * worrying about the other effects.
+ *
+ * **Example** (All Tasks Succeed)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.succeed("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const task3 = Effect.succeed("task3").pipe(
+ * Effect.delay("150 millis"),
+ * Effect.tap(Console.log("task3 done")),
+ * Effect.onInterrupt(() => Console.log("task3 interrupted"))
+ * )
+ *
+ * const program = Effect.raceAll([task1, task2, task3])
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task1 done
+ * // task2 interrupted
+ * // task3 interrupted
+ * ```
+ *
+ * **Example** (One Task Fails, Two Tasks Succeed)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const task3 = Effect.succeed("task3").pipe(
+ * Effect.delay("150 millis"),
+ * Effect.tap(Console.log("task3 done")),
+ * Effect.onInterrupt(() => Console.log("task3 interrupted"))
+ * )
+ *
+ * const program = Effect.raceAll([task1, task2, task3])
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task3 done
+ * // task2 interrupted
+ * ```
+ *
+ * **Example** (All Tasks Fail)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() => Console.log("task1 interrupted"))
+ * )
+ * const task2 = Effect.fail("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() => Console.log("task2 interrupted"))
+ * )
+ *
+ * const task3 = Effect.fail("task3").pipe(
+ * Effect.delay("150 millis"),
+ * Effect.tap(Console.log("task3 done")),
+ * Effect.onInterrupt(() => Console.log("task3 interrupted"))
+ * )
+ *
+ * const program = Effect.raceAll([task1, task2, task3])
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task2' }
+ * // }
+ * ```
+ *
+ * @see {@link race} for a version that handles only two effects.
+ *
+ * @since 2.0.0
+ * @category Racing
+ */
+const raceAll = exports.raceAll = fiberRuntime.raceAll;
+/**
+ * Races two effects and returns the result of the first one to complete.
+ *
+ * **Details**
+ *
+ * This function takes two effects and runs them concurrently, returning the
+ * result of the first one that completes, regardless of whether it succeeds or
+ * fails.
+ *
+ * **When to Use**
+ *
+ * This function is useful when you want to race two operations, and you want to
+ * proceed with whichever one finishes first, regardless of whether it succeeds
+ * or fails.
+ *
+ * **Disconnecting Effects**
+ *
+ * The `Effect.raceFirst` function safely interrupts the “loser” effect once the other completes, but it will not resume until the loser is cleanly terminated.
+ *
+ * If you want a quicker return, you can disconnect the interrupt signal for both effects. Instead of calling:
+ *
+ * ```ts skip-type-checking
+ * Effect.raceFirst(task1, task2)
+ * ```
+ *
+ * You can use:
+ *
+ * ```ts skip-type-checking
+ * Effect.raceFirst(Effect.disconnect(task1), Effect.disconnect(task2))
+ * ```
+ *
+ * This allows both effects to complete independently while still terminating the losing effect in the background.
+ *
+ * **Example** (Both Tasks Succeed)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.succeed("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task1 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task2 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ *
+ * const program = Effect.raceFirst(task1, task2).pipe(
+ * Effect.tap(Console.log("more work..."))
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // task1 done
+ * // task2 interrupted
+ * // more work...
+ * // { _id: 'Exit', _tag: 'Success', value: 'task1' }
+ * ```
+ *
+ * **Example** (One Task Fails, One Succeeds)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.fail("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task1 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task2 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ *
+ * const program = Effect.raceFirst(task1, task2).pipe(
+ * Effect.tap(Console.log("more work..."))
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // task2 interrupted
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task1' }
+ * // }
+ * ```
+ *
+ * **Example** (Using Effect.disconnect for Quicker Return)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.succeed("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task1 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task2 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ *
+ * // Race the two tasks with disconnect to allow quicker return
+ * const program = Effect.raceFirst(
+ * Effect.disconnect(task1),
+ * Effect.disconnect(task2)
+ * ).pipe(Effect.tap(Console.log("more work...")))
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // task1 done
+ * // more work...
+ * // { _id: 'Exit', _tag: 'Success', value: 'task1' }
+ * // task2 interrupted
+ * ```
+ *
+ * @since 2.0.0
+ * @category Racing
+ */
+const raceFirst = exports.raceFirst = circular.raceFirst;
+/**
+ * Races two effects and calls a finisher when the first one completes.
+ *
+ * **Details**
+ *
+ * This function runs two effects concurrently and calls a specified “finisher”
+ * function once one of the effects completes, regardless of whether it succeeds
+ * or fails.
+ *
+ * The finisher functions for each effect allow you to handle the results of
+ * each effect as soon as they complete.
+ *
+ * The function takes two finisher callbacks, one for each effect, and allows
+ * you to specify how to handle the result of the race.
+ *
+ * **When to Use**
+ *
+ * This function is useful when you need to react to the completion of either
+ * effect without waiting for both to finish. It can be used whenever you want
+ * to take action based on the first available result.
+ *
+ * **Example** (Handling Results of Concurrent Tasks)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Effect.succeed("task1").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Console.log("task1 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task1 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ * const task2 = Effect.succeed("task2").pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Console.log("task2 done")),
+ * Effect.onInterrupt(() =>
+ * Console.log("task2 interrupted").pipe(Effect.delay("100 millis"))
+ * )
+ * )
+ *
+ * const program = Effect.raceWith(task1, task2, {
+ * onSelfDone: (exit) => Console.log(`task1 exited with ${exit}`),
+ * onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`)
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // task1 done
+ * // task1 exited with {
+ * // "_id": "Exit",
+ * // "_tag": "Success",
+ * // "value": "task1"
+ * // }
+ * // task2 interrupted
+ * ```
+ *
+ * @since 2.0.0
+ * @category Racing
+ */
+const raceWith = exports.raceWith = fiberRuntime.raceWith;
+/**
+ * Summarizes a effect by computing some value before and after execution, and
+ * then combining the values to produce a summary, together with the result of
+ * execution.
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const summarized = exports.summarized = effect.summarized;
+/**
+ * Runs a side effect with the result of an effect without changing the original
+ * value.
+ *
+ * **Details**
+ *
+ * This function works similarly to `flatMap`, but it ignores the result of the
+ * function passed to it. The value from the previous effect remains available
+ * for the next part of the chain. Note that if the side effect fails, the
+ * entire chain will fail too.
+ *
+ * **When to Use**
+ *
+ * Use this function when you want to perform a side effect, like logging or
+ * tracking, without modifying the main value. This is useful when you need to
+ * observe or record an action but want the original value to be passed to the
+ * next step.
+ *
+ * **Example** (Logging a step in a pipeline)
+ *
+ * ```ts
+ * import { Console, Effect, pipe } from "effect"
+ *
+ * // Function to apply a discount safely to a transaction amount
+ * const applyDiscount = (
+ * total: number,
+ * discountRate: number
+ * ): Effect.Effect =>
+ * discountRate === 0
+ * ? Effect.fail(new Error("Discount rate cannot be zero"))
+ * : Effect.succeed(total - (total * discountRate) / 100)
+ *
+ * // Simulated asynchronous task to fetch a transaction amount from database
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * const finalAmount = pipe(
+ * fetchTransactionAmount,
+ * // Log the fetched transaction amount
+ * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)),
+ * // `amount` is still available!
+ * Effect.flatMap((amount) => applyDiscount(amount, 5))
+ * )
+ *
+ * Effect.runPromise(finalAmount).then(console.log)
+ * // Output:
+ * // Apply a discount to: 100
+ * // 95
+ * ```
+ *
+ * @see {@link flatMap} for a version that allows you to change the value.
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tap = exports.tap = core.tap;
+/**
+ * Allows you to inspect both success and failure outcomes of an effect and
+ * perform side effects for each.
+ *
+ * **Details**
+ *
+ * This function enables you to handle both success and failure cases
+ * separately, without modifying the main effect's result. It is particularly
+ * useful for scenarios where you need to log, monitor, or perform additional
+ * actions depending on whether the effect succeeded or failed.
+ *
+ * When the effect succeeds, the `onSuccess` handler is executed with the
+ * success value. When the effect fails, the `onFailure` handler is executed
+ * with the failure value. Both handlers can include side effects such as
+ * logging or analytics, and neither modifies the original effect's output.
+ *
+ * If either the success or failure handler fails, the overall effect will also
+ * fail.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Random, Console } from "effect"
+ *
+ * // Simulate a task that might fail
+ * const task = Effect.filterOrFail(
+ * Random.nextRange(-1, 1),
+ * (n) => n >= 0,
+ * () => "random number is negative"
+ * )
+ *
+ * // Use tapBoth to log both success and failure outcomes
+ * const tapping = Effect.tapBoth(task, {
+ * onFailure: (error) => Console.log(`failure: ${error}`),
+ * onSuccess: (randomNumber) =>
+ * Console.log(`random number: ${randomNumber}`)
+ * })
+ *
+ * Effect.runFork(tapping)
+ * // Example Output:
+ * // failure: random number is negative
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tapBoth = exports.tapBoth = effect.tapBoth;
+/**
+ * Inspect severe errors or defects (non-recoverable failures) in an effect.
+ *
+ * **Details**
+ *
+ * This function is specifically designed to handle and inspect defects, which
+ * are critical failures in your program, such as unexpected runtime exceptions
+ * or system-level errors. Unlike normal recoverable errors, defects typically
+ * indicate serious issues that cannot be addressed through standard error
+ * handling.
+ *
+ * When a defect occurs in an effect, the function you provide to this function
+ * will be executed, allowing you to log, monitor, or handle the defect in some
+ * way. Importantly, this does not alter the main result of the effect. If no
+ * defect occurs, the effect behaves as if this function was not used.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // Simulate a task that fails with a recoverable error
+ * const task1: Effect.Effect = Effect.fail("NetworkError")
+ *
+ * // tapDefect won't log anything because NetworkError is not a defect
+ * const tapping1 = Effect.tapDefect(task1, (cause) =>
+ * Console.log(`defect: ${cause}`)
+ * )
+ *
+ * Effect.runFork(tapping1)
+ * // No Output
+ *
+ * // Simulate a severe failure in the system
+ * const task2: Effect.Effect = Effect.dieMessage(
+ * "Something went wrong"
+ * )
+ *
+ * // Log the defect using tapDefect
+ * const tapping2 = Effect.tapDefect(task2, (cause) =>
+ * Console.log(`defect: ${cause}`)
+ * )
+ *
+ * Effect.runFork(tapping2)
+ * // Output:
+ * // defect: RuntimeException: Something went wrong
+ * // ... stack trace ...
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tapDefect = exports.tapDefect = effect.tapDefect;
+/**
+ * Execute a side effect on failure without modifying the original effect.
+ *
+ * **Details**
+ *
+ * This function allows you to inspect and react to the failure of an effect by
+ * executing an additional effect. The failure value is passed to the provided
+ * function, enabling you to log it, track it, or perform any other operation.
+ * Importantly, the original failure remains intact and is re-propagated, so the
+ * effect's behavior is unchanged.
+ *
+ * The side effect you provide is only executed when the effect fails. If the
+ * effect succeeds, the function is ignored, and the success value is propagated
+ * as usual.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // Simulate a task that fails with an error
+ * const task: Effect.Effect = Effect.fail("NetworkError")
+ *
+ * // Use tapError to log the error message when the task fails
+ * const tapping = Effect.tapError(task, (error) =>
+ * Console.log(`expected error: ${error}`)
+ * )
+ *
+ * Effect.runFork(tapping)
+ * // Output:
+ * // expected error: NetworkError
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tapError = exports.tapError = effect.tapError;
+/**
+ * Inspect errors matching a specific tag without altering the original effect.
+ *
+ * **Details**
+ *
+ * This function allows you to inspect and handle specific error types based on
+ * their `_tag` property. It is particularly useful in applications where errors
+ * are modeled with tagged types (e.g., union types with discriminating tags).
+ * By targeting errors with a specific `_tag`, you can log or perform actions on
+ * them while leaving the error channel and overall effect unchanged.
+ *
+ * If the error doesn't match the specified tag, this function does nothing, and
+ * the effect proceeds as usual.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * class NetworkError {
+ * readonly _tag = "NetworkError"
+ * constructor(readonly statusCode: number) {}
+ * }
+ *
+ * class ValidationError {
+ * readonly _tag = "ValidationError"
+ * constructor(readonly field: string) {}
+ * }
+ *
+ * // Create a task that fails with a NetworkError
+ * const task: Effect.Effect =
+ * Effect.fail(new NetworkError(504))
+ *
+ * // Use tapErrorTag to inspect only NetworkError types and log the status code
+ * const tapping = Effect.tapErrorTag(task, "NetworkError", (error) =>
+ * Console.log(`expected error: ${error.statusCode}`)
+ * )
+ *
+ * Effect.runFork(tapping)
+ * // Output:
+ * // expected error: 504
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tapErrorTag = exports.tapErrorTag = effect.tapErrorTag;
+/**
+ * Inspect the complete cause of an error, including failures and defects.
+ *
+ * **Details**
+ *
+ * This function provides access to the full cause of an error, including both
+ * recoverable failures and irrecoverable defects. It allows you to handle, log,
+ * or monitor specific error causes without modifying the result of the effect.
+ * The full `Cause` object encapsulates the error and its contextual
+ * information, making it useful for debugging and understanding failure
+ * scenarios in complex workflows.
+ *
+ * The effect itself is not modified, and any errors or defects remain in the
+ * error channel of the original effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * // Create a task that fails with a NetworkError
+ * const task1: Effect.Effect = Effect.fail("NetworkError")
+ *
+ * const tapping1 = Effect.tapErrorCause(task1, (cause) =>
+ * Console.log(`error cause: ${cause}`)
+ * )
+ *
+ * Effect.runFork(tapping1)
+ * // Output:
+ * // error cause: Error: NetworkError
+ *
+ * // Simulate a severe failure in the system
+ * const task2: Effect.Effect = Effect.dieMessage(
+ * "Something went wrong"
+ * )
+ *
+ * const tapping2 = Effect.tapErrorCause(task2, (cause) =>
+ * Console.log(`error cause: ${cause}`)
+ * )
+ *
+ * Effect.runFork(tapping2)
+ * // Output:
+ * // error cause: RuntimeException: Something went wrong
+ * // ... stack trace ...
+ * ```
+ *
+ * @since 2.0.0
+ * @category Sequencing
+ */
+const tapErrorCause = exports.tapErrorCause = effect.tapErrorCause;
+/**
+ * Repeats an effect indefinitely until an error occurs.
+ *
+ * **Details**
+ *
+ * This function executes an effect repeatedly in an infinite loop. Each
+ * iteration is executed sequentially, and the loop continues until the first
+ * error occurs. If the effect succeeds, it starts over from the beginning. If
+ * the effect fails, the error is propagated, and the loop stops.
+ *
+ * Be cautious when using this function, as it will run indefinitely unless an
+ * error interrupts it. This makes it suitable for long-running processes or
+ * continuous polling tasks, but you should ensure proper error handling or
+ * combine it with other operators like `timeout` or `schedule` to prevent
+ * unintentional infinite loops.
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const forever = exports.forever = effect.forever;
+/**
+ * Repeatedly updates a state through an effectful operation until a condition
+ * is no longer met.
+ *
+ * **Details**
+ *
+ * This function provides a way to implement effectful loops, similar to a
+ * `while` loop in JavaScript.
+ *
+ * ```ts skip-type-checking
+ * let result = initial
+ *
+ * while (options.while(result)) {
+ * result = options.body(result)
+ * }
+ *
+ * return result
+ * ```
+ *
+ * It starts with an initial state, checks a
+ * condition (`while`), and executes a body operation to update the state if the
+ * condition evaluates to `true`. The process repeats until the condition
+ * returns `false`.
+ *
+ * The state is passed between iterations, allowing the body operation to modify
+ * it dynamically. The final state after the loop ends is returned as the result
+ * of the effect.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful for scenarios where looping logic involves
+ * asynchronous or side-effectful operations, such as polling or iterative
+ * computations that depend on external factors.
+ *
+ * **Example** (Effectful Iteration)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const result = Effect.iterate(
+ * // Initial result
+ * 1,
+ * {
+ * // Condition to continue iterating
+ * while: (result) => result <= 5,
+ * // Operation to change the result
+ * body: (result) => Effect.succeed(result + 1)
+ * }
+ * )
+ *
+ * Effect.runPromise(result).then(console.log)
+ * // Output: 6
+ * ```
+ *
+ * @since 2.0.0
+ * @category Looping
+ */
+const iterate = exports.iterate = effect.iterate;
+/**
+ * Repeatedly executes a loop with a state, collecting results or discarding
+ * them based on configuration.
+ *
+ * **Details**
+ *
+ * This function performs an effectful loop, starting with an initial state and
+ * iterating as long as the `while` condition evaluates to `true`, similar to a
+ * `while` loop in JavaScript.
+ *
+ * ```ts skip-type-checking
+ * let state = initial
+ * const result = []
+ *
+ * while (options.while(state)) {
+ * result.push(options.body(state)) // Perform the effectful operation
+ * state = options.step(state) // Update the state
+ * }
+ *
+ * return result
+ * ```
+ *
+ * During each iteration, the `step` function updates the state, and the `body`
+ * effect is executed.
+ *
+ * The results of the body effect can be collected in an array or discarded
+ * based on the `discard` option.
+ *
+ * **Discarding Intermediate Results**
+ *
+ * - If `discard` is `false` or not provided, the intermediate results are
+ * collected into an array and returned as the final result.
+ * - If `discard` is `true`, the intermediate results are ignored, and the
+ * effect returns `void`.
+ *
+ * **When to Use**
+ *
+ * This is useful for implementing loops where you need to perform effectful
+ * computations repeatedly, such as processing items in a list, generating
+ * values, or performing iterative updates.
+ *
+ * **Example** (Looping with Collected Results)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // A loop that runs 5 times, collecting each iteration's result
+ * const result = Effect.loop(
+ * // Initial state
+ * 1,
+ * {
+ * // Condition to continue looping
+ * while: (state) => state <= 5,
+ * // State update function
+ * step: (state) => state + 1,
+ * // Effect to be performed on each iteration
+ * body: (state) => Effect.succeed(state)
+ * }
+ * )
+ *
+ * Effect.runPromise(result).then(console.log)
+ * // Output: [1, 2, 3, 4, 5]
+ * ```
+ *
+ * **Example** (Loop with Discarded Results)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const result = Effect.loop(
+ * // Initial state
+ * 1,
+ * {
+ * // Condition to continue looping
+ * while: (state) => state <= 5,
+ * // State update function
+ * step: (state) => state + 1,
+ * // Effect to be performed on each iteration
+ * body: (state) => Console.log(`Currently at state ${state}`),
+ * // Discard intermediate results
+ * discard: true
+ * }
+ * )
+ *
+ * Effect.runPromise(result).then(console.log)
+ * // Output:
+ * // Currently at state 1
+ * // Currently at state 2
+ * // Currently at state 3
+ * // Currently at state 4
+ * // Currently at state 5
+ * // undefined
+ * ```
+ *
+ * @since 2.0.0
+ * @category Looping
+ */
+const loop = exports.loop = effect.loop;
+/**
+ * Repeats an effect based on a specified schedule or until the first failure.
+ *
+ * **Details**
+ *
+ * This function executes an effect repeatedly according to the given schedule.
+ * Each repetition occurs after the initial execution of the effect, meaning
+ * that the schedule determines the number of additional repetitions. For
+ * example, using `Schedule.once` will result in the effect being executed twice
+ * (once initially and once as part of the repetition).
+ *
+ * If the effect succeeds, it is repeated according to the schedule. If it
+ * fails, the repetition stops immediately, and the failure is returned.
+ *
+ * The schedule can also specify delays between repetitions, making it useful
+ * for tasks like retrying operations with backoff, periodic execution, or
+ * performing a series of dependent actions.
+ *
+ * You can combine schedules for more advanced repetition logic, such as adding
+ * delays, limiting recursions, or dynamically adjusting based on the outcome of
+ * each execution.
+ *
+ * **Example** (Success Example)
+ *
+ * ```ts
+ * import { Effect, Schedule, Console } from "effect"
+ *
+ * const action = Console.log("success")
+ * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
+ * const program = Effect.repeat(action, policy)
+ *
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
+ * ```
+ *
+ * **Example** (Failure Example)
+ *
+ * ```ts
+ * import { Effect, Schedule } from "effect"
+ *
+ * let count = 0
+ *
+ * // Define an async effect that simulates an action with possible failures
+ * const action = Effect.async((resume) => {
+ * if (count > 1) {
+ * console.log("failure")
+ * resume(Effect.fail("Uh oh!"))
+ * } else {
+ * count++
+ * console.log("success")
+ * resume(Effect.succeed("yay!"))
+ * }
+ * })
+ *
+ * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
+ * const program = Effect.repeat(action, policy)
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const repeat = exports.repeat = schedule_.repeat_combined;
+/**
+ * Repeats an effect a specified number of times or until the first failure.
+ *
+ * **Details**
+ *
+ * This function executes an effect initially and then repeats it the specified
+ * number of times, as long as it succeeds. For example, calling
+ * `repeatN(action, 2)` will execute `action` once initially and then repeat it
+ * two additional times if there are no failures.
+ *
+ * If the effect fails during any repetition, the failure is returned, and no
+ * further repetitions are attempted.
+ *
+ * **When to Use**
+ *
+ * This function is useful for tasks that need to be retried a fixed number of
+ * times or for performing repeated actions without requiring a schedule.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const action = Console.log("success")
+ * const program = Effect.repeatN(action, 2)
+ *
+ * Effect.runPromise(program)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const repeatN = exports.repeatN = effect.repeatN;
+/**
+ * Repeats an effect with a schedule, handling failures using a custom handler.
+ *
+ * **Details**
+ *
+ * This function allows you to execute an effect repeatedly based on a specified
+ * schedule. If the effect fails at any point, a custom failure handler is
+ * invoked. The handler is provided with both the failure value and the output
+ * of the schedule at the time of failure. This enables advanced error recovery
+ * or alternative fallback logic while maintaining flexibility in how
+ * repetitions are handled.
+ *
+ * For example, using a schedule with `recurs(2)` will allow for two additional
+ * repetitions after the initial execution, provided the effect succeeds. If a
+ * failure occurs during any iteration, the failure handler is invoked to handle
+ * the situation.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schedule } from "effect"
+ *
+ * let count = 0
+ *
+ * // Define an async effect that simulates an action with possible failures
+ * const action = Effect.async((resume) => {
+ * if (count > 1) {
+ * console.log("failure")
+ * resume(Effect.fail("Uh oh!"))
+ * } else {
+ * count++
+ * console.log("success")
+ * resume(Effect.succeed("yay!"))
+ * }
+ * })
+ *
+ * const policy = Schedule.addDelay(
+ * Schedule.recurs(2), // Repeat for a maximum of 2 times
+ * () => "100 millis" // Add a delay of 100 milliseconds between repetitions
+ * )
+ *
+ * const program = Effect.repeatOrElse(action, policy, () =>
+ * Effect.sync(() => {
+ * console.log("orElse")
+ * return count - 1
+ * })
+ * )
+ *
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
+ * ```
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const repeatOrElse = exports.repeatOrElse = schedule_.repeatOrElse_Effect;
+/**
+ * Repeats an effect based on a specified schedule.
+ *
+ * **Details**
+ *
+ * This function allows you to execute an effect repeatedly according to a given
+ * schedule. The schedule determines the timing and number of repetitions. Each
+ * repetition can also depend on the decision of the schedule, providing
+ * flexibility for complex workflows. This function does not modify the effect's
+ * success or failure; it only controls its repetition.
+ *
+ * For example, you can use a schedule that recurs a specific number of times,
+ * adds delays between repetitions, or customizes repetition behavior based on
+ * external inputs. The effect runs initially and is repeated according to the
+ * schedule.
+ *
+ * @see {@link scheduleFrom} for a variant that allows the schedule's decision
+ * to depend on the result of this effect.
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const schedule = exports.schedule = schedule_.schedule_Effect;
+/**
+ * Runs an effect repeatedly on a new fiber according to a given schedule.
+ *
+ * **Details**
+ *
+ * This function starts the provided effect on a new fiber and runs it
+ * repeatedly based on the specified schedule. The repetitions are managed by
+ * the schedule's rules, which define the timing and number of iterations. The
+ * fiber is attached to the current scope, meaning it is automatically managed
+ * and cleaned up when the scope is closed.
+ *
+ * The function returns a `RuntimeFiber` that allows you to monitor or interact
+ * with the running fiber.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful for concurrent execution of scheduled tasks or
+ * when you want to continue processing without waiting for the repetitions to
+ * complete.
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const scheduleForked = exports.scheduleForked = schedule_.scheduleForked;
+/**
+ * Runs an effect repeatedly according to a schedule, starting from a specified
+ * input value.
+ *
+ * **Details**
+ *
+ * This function allows you to repeatedly execute an effect based on a schedule.
+ * The schedule starts with the given `initial` input value, which is passed to
+ * the first execution. Subsequent executions of the effect are controlled by
+ * the schedule's rules, using the output of the previous iteration as the input
+ * for the next one.
+ *
+ * The returned effect will complete when the schedule ends or the effect fails,
+ * propagating the error.
+ *
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const scheduleFrom = exports.scheduleFrom = schedule_.scheduleFrom_Effect;
+/**
+ * @since 2.0.0
+ * @category Repetition / Recursion
+ */
+const whileLoop = exports.whileLoop = core.whileLoop;
+/**
+ * Returns a collection of all `FiberRef` values for the fiber running this
+ * effect.
+ *
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const getFiberRefs = exports.getFiberRefs = effect.fiberRefs;
+/**
+ * Inherits values from all `FiberRef` instances into current fiber.
+ *
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const inheritFiberRefs = exports.inheritFiberRefs = effect.inheritFiberRefs;
+/**
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const locally = exports.locally = core.fiberRefLocally;
+/**
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const locallyWith = exports.locallyWith = core.fiberRefLocallyWith;
+/**
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const locallyScoped = exports.locallyScoped = fiberRuntime.fiberRefLocallyScoped;
+/**
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const locallyScopedWith = exports.locallyScopedWith = fiberRuntime.fiberRefLocallyScopedWith;
+/**
+ * Applies the specified changes to the `FiberRef` values for the fiber
+ * running this workflow.
+ *
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const patchFiberRefs = exports.patchFiberRefs = effect.patchFiberRefs;
+/**
+ * Sets the `FiberRef` values for the fiber running this effect to the values
+ * in the specified collection of `FiberRef` values.
+ *
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const setFiberRefs = exports.setFiberRefs = effect.setFiberRefs;
+/**
+ * Updates the `FiberRef` values for the fiber running this effect using the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category Fiber Refs
+ */
+const updateFiberRefs = exports.updateFiberRefs = effect.updateFiberRefs;
+/**
+ * Checks if an effect has failed.
+ *
+ * **Details**
+ *
+ * This function evaluates whether an effect has resulted in a failure. It
+ * returns a boolean value wrapped in an effect, with `true` indicating the
+ * effect failed and `false` otherwise.
+ *
+ * The resulting effect cannot fail (`never` in the error channel) but retains
+ * the context of the original effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const failure = Effect.fail("Uh oh!")
+ *
+ * console.log(Effect.runSync(Effect.isFailure(failure)))
+ * // Output: true
+ *
+ * const defect = Effect.dieMessage("BOOM!")
+ *
+ * Effect.runSync(Effect.isFailure(defect))
+ * // throws: BOOM!
+ * ```
+ *
+ * @since 2.0.0
+ * @category Condition Checking
+ */
+const isFailure = exports.isFailure = effect.isFailure;
+/**
+ * Checks if an effect has succeeded.
+ *
+ * **Details**
+ *
+ * This function evaluates whether an effect has resulted in a success. It
+ * returns a boolean value wrapped in an effect, with `true` indicating the
+ * effect succeeded and `false` otherwise.
+ *
+ * The resulting effect cannot fail (`never` in the error channel) but retains
+ * the context of the original effect.
+ *
+ * @since 2.0.0
+ * @category Condition Checking
+ */
+const isSuccess = exports.isSuccess = effect.isSuccess;
+/**
+ * Handles both success and failure cases of an effect without performing side
+ * effects.
+ *
+ * **Details**
+ *
+ * `match` lets you define custom handlers for both success and failure
+ * scenarios. You provide separate functions to handle each case, allowing you
+ * to process the result if the effect succeeds, or handle the error if the
+ * effect fails.
+ *
+ * **When to Use**
+ *
+ * This is useful for structuring your code to respond differently to success or
+ * failure without triggering side effects.
+ *
+ * **Example** (Handling Both Success and Failure Cases)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const success: Effect.Effect = Effect.succeed(42)
+ *
+ * const program1 = Effect.match(success, {
+ * onFailure: (error) => `failure: ${error.message}`,
+ * onSuccess: (value) => `success: ${value}`
+ * })
+ *
+ * // Run and log the result of the successful effect
+ * Effect.runPromise(program1).then(console.log)
+ * // Output: "success: 42"
+ *
+ * const failure: Effect.Effect = Effect.fail(
+ * new Error("Uh oh!")
+ * )
+ *
+ * const program2 = Effect.match(failure, {
+ * onFailure: (error) => `failure: ${error.message}`,
+ * onSuccess: (value) => `success: ${value}`
+ * })
+ *
+ * // Run and log the result of the failed effect
+ * Effect.runPromise(program2).then(console.log)
+ * // Output: "failure: Uh oh!"
+ * ```
+ *
+ * @see {@link matchEffect} if you need to perform side effects in the handlers.
+ *
+ * @since 2.0.0
+ * @category Matching
+ */
+const match = exports.match = effect.match;
+/**
+ * Handles failures by matching the cause of failure.
+ *
+ * **Details**
+ *
+ * The `matchCause` function allows you to handle failures with access to the
+ * full cause of the failure within a fiber.
+ *
+ * **When to Use**
+ *
+ * This is useful for differentiating between different types of errors, such as
+ * regular failures, defects, or interruptions. You can provide specific
+ * handling logic for each failure type based on the cause.
+ *
+ * **Example** (Handling Different Failure Causes)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task: Effect.Effect = Effect.die("Uh oh!")
+ *
+ * const program = Effect.matchCause(task, {
+ * onFailure: (cause) => {
+ * switch (cause._tag) {
+ * case "Fail":
+ * // Handle standard failure
+ * return `Fail: ${cause.error.message}`
+ * case "Die":
+ * // Handle defects (unexpected errors)
+ * return `Die: ${cause.defect}`
+ * case "Interrupt":
+ * // Handle interruption
+ * return `${cause.fiberId} interrupted!`
+ * }
+ * // Fallback for other causes
+ * return "failed due to other causes"
+ * },
+ * onSuccess: (value) =>
+ * // task completes successfully
+ * `succeeded with ${value} value`
+ * })
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output: "Die: Uh oh!"
+ * ```
+ *
+ * @see {@link matchCauseEffect} if you need to perform side effects in the
+ * handlers.
+ * @see {@link match} if you don't need to handle the cause of the failure.
+ *
+ * @since 2.0.0
+ * @category Matching
+ */
+const matchCause = exports.matchCause = core.matchCause;
+/**
+ * Handles failures with access to the cause and allows performing side effects.
+ *
+ * **Details**
+ *
+ * The `matchCauseEffect` function works similarly to {@link matchCause}, but it
+ * also allows you to perform additional side effects based on the failure
+ * cause. This function provides access to the complete cause of the failure,
+ * making it possible to differentiate between various failure types, and allows
+ * you to respond accordingly while performing side effects (like logging or
+ * other operations).
+ *
+ * **Example** (Handling Different Failure Causes with Side Effects)
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task: Effect.Effect = Effect.die("Uh oh!")
+ *
+ * const program = Effect.matchCauseEffect(task, {
+ * onFailure: (cause) => {
+ * switch (cause._tag) {
+ * case "Fail":
+ * // Handle standard failure with a logged message
+ * return Console.log(`Fail: ${cause.error.message}`)
+ * case "Die":
+ * // Handle defects (unexpected errors) by logging the defect
+ * return Console.log(`Die: ${cause.defect}`)
+ * case "Interrupt":
+ * // Handle interruption and log the fiberId that was interrupted
+ * return Console.log(`${cause.fiberId} interrupted!`)
+ * }
+ * // Fallback for other causes
+ * return Console.log("failed due to other causes")
+ * },
+ * onSuccess: (value) =>
+ * // Log success if the task completes successfully
+ * Console.log(`succeeded with ${value} value`)
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: "Die: Uh oh!"
+ * ```
+ *
+ * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure.
+ * @see {@link matchEffect} if you don't need to handle the cause of the failure.
+ *
+ * @since 2.0.0
+ * @category Matching
+ */
+const matchCauseEffect = exports.matchCauseEffect = core.matchCauseEffect;
+/**
+ * Handles both success and failure cases of an effect, allowing for additional
+ * side effects.
+ *
+ * **Details**
+ *
+ * The `matchEffect` function is similar to {@link match}, but it enables you to
+ * perform side effects in the handlers for both success and failure outcomes.
+ *
+ * **When to Use**
+ *
+ * This is useful when you need to execute additional actions, like logging or
+ * notifying users, based on whether an effect succeeds or fails.
+ *
+ * **Example** (Handling Both Success and Failure Cases with Side Effects)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const success: Effect.Effect = Effect.succeed(42)
+ * const failure: Effect.Effect = Effect.fail(
+ * new Error("Uh oh!")
+ * )
+ *
+ * const program1 = Effect.matchEffect(success, {
+ * onFailure: (error) =>
+ * Effect.succeed(`failure: ${error.message}`).pipe(
+ * Effect.tap(Effect.log)
+ * ),
+ * onSuccess: (value) =>
+ * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log))
+ * })
+ *
+ * console.log(Effect.runSync(program1))
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="success: 42"
+ * // success: 42
+ *
+ * const program2 = Effect.matchEffect(failure, {
+ * onFailure: (error) =>
+ * Effect.succeed(`failure: ${error.message}`).pipe(
+ * Effect.tap(Effect.log)
+ * ),
+ * onSuccess: (value) =>
+ * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log))
+ * })
+ *
+ * console.log(Effect.runSync(program2))
+ * // Output:
+ * // timestamp=... level=INFO fiber=#1 message="failure: Uh oh!"
+ * // failure: Uh oh!
+ * ```
+ *
+ * @see {@link match} if you don't need side effects and only want to handle the
+ * result or failure.
+ *
+ * @since 2.0.0
+ * @category Matching
+ */
+const matchEffect = exports.matchEffect = core.matchEffect;
+/**
+ * Logs one or more messages or error causes at the current log level.
+ *
+ * **Details**
+ *
+ * This function provides a simple way to log messages or error causes during
+ * the execution of your effects. By default, logs are recorded at the `INFO`
+ * level, but this can be adjusted using other logging utilities
+ * (`Logger.withMinimumLogLevel`). Multiple items, including `Cause` instances,
+ * can be logged in a single call. When logging `Cause` instances, detailed
+ * error information is included in the log output.
+ *
+ * The log output includes useful metadata like the current timestamp, log
+ * level, and fiber ID, making it suitable for debugging and tracking purposes.
+ * This function does not interrupt or alter the effect's execution flow.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ *
+ * const program = Effect.log(
+ * "message1",
+ * "message2",
+ * Cause.die("Oh no!"),
+ * Cause.die("Oh uh!")
+ * )
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 cause="Error: Oh no!
+ * // Error: Oh uh!"
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const log = exports.log = effect.log;
+/**
+ * Logs messages or error causes at a specified log level.
+ *
+ * **Details**
+ *
+ * This function allows you to log one or more messages or error causes while
+ * specifying the desired log level (e.g., DEBUG, INFO, ERROR). It provides
+ * flexibility in categorizing logs based on their importance or severity,
+ * making it easier to filter logs during debugging or production monitoring.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Cause, Effect, LogLevel } from "effect"
+ *
+ * const program = Effect.logWithLevel(
+ * LogLevel.Error,
+ * "Critical error encountered",
+ * Cause.die("System failure!")
+ * )
+ *
+ * Effect.runFork(program)
+ * // Output:
+ * // timestamp=... level=ERROR fiber=#0 message=Critical error encountered cause="Error: System failure!"
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logWithLevel = (level, ...message) => effect.logWithLevel(level)(...message);
+/**
+ * Logs messages at the TRACE log level.
+ *
+ * **Details**
+ *
+ * This function logs the specified messages at the TRACE level. TRACE logs are
+ * typically used for very detailed diagnostic information. These messages are
+ * not displayed by default. To view them, you must adjust the logging
+ * configuration by setting the minimum log level to `LogLevel.Trace` using
+ * `Logger.withMinimumLogLevel`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.logTrace("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Trace))
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=TRACE fiber=#0 message=message1
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+exports.logWithLevel = logWithLevel;
+const logTrace = exports.logTrace = effect.logTrace;
+/**
+ * Logs messages at the DEBUG log level.
+ *
+ * **Details**
+ *
+ * This function logs messages at the DEBUG level, which is typically used for
+ * diagnosing application behavior during development. DEBUG messages provide
+ * less detailed information than TRACE logs but are still not shown by default.
+ * To view these logs, adjust the log level using `Logger.withMinimumLogLevel`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug))
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=DEBUG fiber=#0 message=message1
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logDebug = exports.logDebug = effect.logDebug;
+/**
+ * Logs messages at the INFO log level.
+ *
+ * **Details**
+ *
+ * This function logs messages at the INFO level, suitable for general
+ * application events or operational messages. INFO logs are shown by default
+ * and are commonly used for highlighting normal, non-error operations.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logInfo = exports.logInfo = effect.logInfo;
+/**
+ * Logs messages at the WARNING log level.
+ *
+ * **Details**
+ *
+ * This function logs messages at the WARNING level, suitable for highlighting
+ * potential issues that are not errors but may require attention. These
+ * messages indicate that something unexpected occurred or might lead to errors
+ * in the future.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logWarning = exports.logWarning = effect.logWarning;
+/**
+ * Logs messages at the ERROR log level.
+ *
+ * **Details**
+ *
+ * This function logs messages at the ERROR level, suitable for reporting
+ * application errors or failures. These logs are typically used for unexpected
+ * issues that need immediate attention.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logError = exports.logError = effect.logError;
+/**
+ * Logs messages at the FATAL log level.
+ *
+ * **Details**
+ *
+ * This function logs messages at the FATAL level, suitable for reporting
+ * critical errors that cause the application to terminate or stop functioning.
+ * These logs are typically used for unrecoverable errors that require immediate
+ * attention.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logFatal = exports.logFatal = effect.logFatal;
+/**
+ * Adds a log span to an effect for tracking and logging its execution duration.
+ *
+ * **Details**
+ *
+ * This function wraps an effect with a log span, providing performance
+ * monitoring and debugging capabilities. The log span tracks the duration of
+ * the wrapped effect and logs it with the specified label. This is particularly
+ * useful when analyzing time-sensitive operations or understanding the
+ * execution time of specific tasks in your application.
+ *
+ * The logged output will include the label and the total time taken for the
+ * operation. The span information is included in the log metadata, making it
+ * easy to trace performance metrics in logs.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * yield* Effect.sleep("1 second")
+ * yield* Effect.log("The job is finished!")
+ * }).pipe(Effect.withLogSpan("myspan"))
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const withLogSpan = exports.withLogSpan = effect.withLogSpan;
+/**
+ * Adds custom annotations to log entries generated within an effect.
+ *
+ * **Details**
+ *
+ * This function allows you to enhance log messages by appending additional
+ * context in the form of key-value pairs. These annotations are included in
+ * every log message created during the execution of the effect, making the logs
+ * more informative and easier to trace.
+ *
+ * The annotations can be specified as a single key-value pair or as a record of
+ * multiple key-value pairs. This is particularly useful for tracking
+ * operations, debugging, or associating specific metadata with logs for better
+ * observability.
+ *
+ * The annotated key-value pairs will appear alongside the log message in the
+ * output.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * yield* Effect.log("message1")
+ * yield* Effect.log("message2")
+ * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234
+ * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234
+ * ```
+ *
+ * @see {@link annotateLogsScoped} to add log annotations with a limited scope.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const annotateLogs = exports.annotateLogs = effect.annotateLogs;
+/**
+ * Adds log annotations with a limited scope to enhance contextual logging.
+ *
+ * **Details**
+ *
+ * This function allows you to apply key-value annotations to log entries
+ * generated within a specific scope of your effect computations. The
+ * annotations are restricted to the defined `Scope`, ensuring that they are
+ * only applied to logs produced during that scope. Once the scope ends, the
+ * annotations are automatically removed, making it easier to manage
+ * context-specific logging without affecting other parts of your application.
+ *
+ * The annotations can be provided as a single key-value pair or as a record of
+ * multiple key-value pairs. This flexibility enables fine-grained control over
+ * the additional metadata included in logs for specific tasks or operations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * yield* Effect.log("no annotations")
+ * yield* Effect.annotateLogsScoped({ key: "value" })
+ * yield* Effect.log("message1") // Annotation is applied to this log
+ * yield* Effect.log("message2") // Annotation is applied to this log
+ * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again")))
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message="no annotations"
+ * // timestamp=... level=INFO fiber=#0 message=message1 key=value
+ * // timestamp=... level=INFO fiber=#0 message=message2 key=value
+ * // timestamp=... level=INFO fiber=#0 message="no annotations again"
+ * ```
+ *
+ * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect.
+ *
+ * @since 3.1.0
+ * @category Logging
+ */
+const annotateLogsScoped = exports.annotateLogsScoped = fiberRuntime.annotateLogsScoped;
+/**
+ * Retrieves the current log annotations for the current scope.
+ *
+ * **Details**
+ *
+ * This function provides access to the log annotations associated with the
+ * current scope. Log annotations are key-value pairs that provide additional
+ * context to log entries. They are often used to add metadata such as tags,
+ * identifiers, or extra debugging information to logs.
+ *
+ * By using this function, you can inspect or utilize the annotations applied to
+ * the current scope, making it easier to trace and debug specific sections of
+ * your application.
+ *
+ * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect.
+ * @see {@link annotateLogsScoped} to add log annotations with a limited scope.
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const logAnnotations = exports.logAnnotations = effect.logAnnotations;
+/**
+ * Configures whether child fibers will log unhandled errors and at what log
+ * level.
+ *
+ * **Details**
+ *
+ * This function allows you to control whether unhandled errors from child
+ * fibers are logged and to specify the log level for these errors. By default,
+ * unhandled errors are reported via the logger. However, using this function,
+ * you can choose to suppress these logs by passing `Option.none` or adjust the
+ * log level to a specific severity, such as `Error`, `Warning`, or `Info`.
+ *
+ * This configuration is scoped to the effect it is applied to, meaning the
+ * changes only apply to the child fibers created within that effect's context.
+ * It is especially useful when you want to reduce noise in logs or prioritize
+ * certain types of errors.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Fiber, LogLevel, Option } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * const fiber = yield* Effect.fork(Effect.fail("Unhandled error!"))
+ * yield* Fiber.join(fiber)
+ * })
+ *
+ * Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error))))
+ * // Output:
+ * // timestamp=... level=ERROR fiber=#1 message="Fiber terminated with an unhandled error" cause="Error: Unhandled error!"
+ * ```
+ *
+ * @since 2.0.0
+ * @category Logging
+ */
+const withUnhandledErrorLogLevel = exports.withUnhandledErrorLogLevel = core.withUnhandledErrorLogLevel;
+/**
+ * Conditionally executes an effect based on the specified log level and currently enabled log level.
+ *
+ * **Details**
+ *
+ * This function runs the provided effect only if the specified log level is
+ * enabled. If the log level is enabled, the effect is executed and its result
+ * is wrapped in `Some`. If the log level is not enabled, the effect is not
+ * executed and `None` is returned.
+ *
+ * This function is useful for conditionally executing logging-related effects
+ * or other operations that depend on the current log level configuration.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Logger, LogLevel } from "effect"
+ *
+ * const program = Effect.gen(function* () {
+ * yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None`
+ * yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some`
+ * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug));
+ *
+ * Effect.runFork(program)
+ * // timestamp=... level=DEBUG fiber=#0 message=message2
+ * ```
+ *
+ * @see {@link FiberRef.currentMinimumLogLevel} to retrieve the current minimum log level.
+ *
+ * @since 3.13.0
+ * @category Logging
+ */
+const whenLogLevel = exports.whenLogLevel = fiberRuntime.whenLogLevel;
+/**
+ * Converts an effect's failure into a fiber termination, removing the error
+ * from the effect's type.
+ *
+ * **Details**
+ *
+ * The `orDie` function is used when you encounter errors that you do not want
+ * to handle or recover from. It removes the error type from the effect and
+ * ensures that any failure will terminate the fiber. This is useful for
+ * propagating failures as defects, signaling that they should not be handled
+ * within the effect.
+ *
+ * **When to Use*
+ *
+ * Use `orDie` when failures should be treated as unrecoverable defects and no
+ * error handling is required.
+ *
+ * **Example** (Propagating an Error as a Defect)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const divide = (a: number, b: number) =>
+ * b === 0
+ * ? Effect.fail(new Error("Cannot divide by zero"))
+ * : Effect.succeed(a / b)
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.orDie(divide(1, 0))
+ *
+ * Effect.runPromise(program).catch(console.error)
+ * // Output:
+ * // (FiberFailure) Error: Cannot divide by zero
+ * // ...stack trace...
+ * ```
+ *
+ * @see {@link orDieWith} if you need to customize the error.
+ *
+ * @since 2.0.0
+ * @category Converting Failures to Defects
+ */
+const orDie = exports.orDie = core.orDie;
+/**
+ * Converts an effect's failure into a fiber termination with a custom error.
+ *
+ * **Details**
+ *
+ * The `orDieWith` function behaves like {@link orDie}, but it allows you to provide a mapping
+ * function to transform the error before terminating the fiber. This is useful for cases where
+ * you want to include a more detailed or user-friendly error when the failure is propagated
+ * as a defect.
+ *
+ * **When to Use**
+ *
+ * Use `orDieWith` when failures should terminate the fiber as defects, and you want to customize
+ * the error for clarity or debugging purposes.
+ *
+ * **Example** (Customizing Defect)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const divide = (a: number, b: number) =>
+ * b === 0
+ * ? Effect.fail(new Error("Cannot divide by zero"))
+ * : Effect.succeed(a / b)
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.orDieWith(
+ * divide(1, 0),
+ * (error) => new Error(`defect: ${error.message}`)
+ * )
+ *
+ * Effect.runPromise(program).catch(console.error)
+ * // Output:
+ * // (FiberFailure) Error: defect: Cannot divide by zero
+ * // ...stack trace...
+ * ```
+ *
+ * @see {@link orDie} if you don't need to customize the error.
+ *
+ * @since 2.0.0
+ * @category Converting Failures to Defects
+ */
+const orDieWith = exports.orDieWith = core.orDieWith;
+/**
+ * Attempts one effect, and if it fails, falls back to another effect.
+ *
+ * **Details**
+ *
+ * This function allows you to try executing an effect, and if it fails
+ * (produces an error), a fallback effect is executed instead. The fallback
+ * effect is defined as a lazy argument, meaning it will only be evaluated if
+ * the first effect fails. This provides a way to recover from errors by
+ * specifying an alternative path of execution.
+ *
+ * The error type of the resulting effect will be that of the fallback effect,
+ * as the first effect's error is replaced when the fallback is executed.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const success = Effect.succeed("success")
+ * const failure = Effect.fail("failure")
+ * const fallback = Effect.succeed("fallback")
+ *
+ * // Try the success effect first, fallback is not used
+ * const program1 = Effect.orElse(success, () => fallback)
+ * console.log(Effect.runSync(program1))
+ * // Output: "success"
+ *
+ * // Try the failure effect first, fallback is used
+ * const program2 = Effect.orElse(failure, () => fallback)
+ * console.log(Effect.runSync(program2))
+ * // Output: "fallback"
+ * ```
+ *
+ * @see {@link catchAll} if you need to access the error in the fallback effect.
+ *
+ * @since 2.0.0
+ * @category Fallback
+ */
+const orElse = exports.orElse = core.orElse;
+/**
+ * Replaces the failure of an effect with a custom failure value.
+ *
+ * **Details**
+ *
+ * This function allows you to handle the failure of an effect by replacing it
+ * with a predefined failure value. If the effect fails, the new failure value
+ * provided by the `evaluate` function will be returned instead of the original
+ * failure. If the effect succeeds, the original success value is returned
+ * unchanged.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful when you want to standardize error handling or
+ * provide a consistent failure value for specific operations. It simplifies
+ * error management by ensuring that all failures are replaced with a controlled
+ * alternative.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const validate = (age: number): Effect.Effect => {
+ * if (age < 0) {
+ * return Effect.fail("NegativeAgeError")
+ * } else if (age < 18) {
+ * return Effect.fail("IllegalAgeError")
+ * } else {
+ * return Effect.succeed(age)
+ * }
+ * }
+ *
+ * const program = Effect.orElseFail(validate(-1), () => "invalid age")
+ *
+ * console.log(Effect.runSyncExit(program))
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'invalid age' }
+ * // }
+ * ```
+ *
+ * @see {@link mapError} if you need to access the error to transform it.
+ *
+ * @since 2.0.0
+ * @category Fallback
+ */
+const orElseFail = exports.orElseFail = effect.orElseFail;
+/**
+ * Ensures the effect always succeeds by replacing failures with a default
+ * success value.
+ *
+ * **Details**
+ *
+ * This function transforms an effect that may fail into one that cannot fail by
+ * replacing any failure with a provided success value. If the original effect
+ * fails, the failure is "swallowed," and the specified success value is
+ * returned instead. If the original effect succeeds, its value remains
+ * unchanged.
+ *
+ * **When to Use**
+ *
+ * This is especially useful for providing default values in case of failure,
+ * ensuring that an effect always completes successfully. By using this
+ * function, you can avoid the need for complex error handling and guarantee a
+ * fallback result.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const validate = (age: number): Effect.Effect => {
+ * if (age < 0) {
+ * return Effect.fail("NegativeAgeError")
+ * } else if (age < 18) {
+ * return Effect.fail("IllegalAgeError")
+ * } else {
+ * return Effect.succeed(age)
+ * }
+ * }
+ *
+ * const program = Effect.orElseSucceed(validate(-1), () => 18)
+ *
+ * console.log(Effect.runSyncExit(program))
+ * // Output:
+ * // { _id: 'Exit', _tag: 'Success', value: 18 }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Fallback
+ */
+const orElseSucceed = exports.orElseSucceed = effect.orElseSucceed;
+/**
+ * Runs a sequence of effects and returns the result of the first successful
+ * one.
+ *
+ * **Details**
+ *
+ * This function allows you to execute a collection of effects in sequence,
+ * stopping at the first success. If an effect succeeds, its result is
+ * immediately returned, and no further effects in the sequence are executed.
+ * However, if all the effects fail, the function will return the error of the
+ * last effect.
+ *
+ * The execution is sequential, meaning that effects are evaluated one at a time
+ * in the order they are provided. This ensures predictable behavior and avoids
+ * unnecessary computations.
+ *
+ * If the collection of effects is empty, an `IllegalArgumentException` is
+ * thrown, indicating that the operation is invalid without any effects to try.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful when you have multiple fallback strategies or
+ * alternative sources to obtain a result, such as attempting multiple APIs,
+ * retrieving configurations, or accessing resources in a prioritized manner.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * interface Config {
+ * host: string
+ * port: number
+ * apiKey: string
+ * }
+ *
+ * // Create a configuration object with sample values
+ * const makeConfig = (name: string): Config => ({
+ * host: `${name}.example.com`,
+ * port: 8080,
+ * apiKey: "12345-abcde"
+ * })
+ *
+ * // Simulate retrieving configuration from a remote node
+ * const remoteConfig = (name: string): Effect.Effect =>
+ * Effect.gen(function* () {
+ * // Simulate node3 being the only one with available config
+ * if (name === "node3") {
+ * yield* Console.log(`Config for ${name} found`)
+ * return makeConfig(name)
+ * } else {
+ * yield* Console.log(`Unavailable config for ${name}`)
+ * return yield* Effect.fail(new Error(`Config not found for ${name}`))
+ * }
+ * })
+ *
+ * // Define the master configuration and potential fallback nodes
+ * const masterConfig = remoteConfig("master")
+ * const nodeConfigs = ["node1", "node2", "node3", "node4"].map(remoteConfig)
+ *
+ * // Attempt to find a working configuration,
+ * // starting with the master and then falling back to other nodes
+ * const config = Effect.firstSuccessOf([masterConfig, ...nodeConfigs])
+ *
+ * // Run the effect to retrieve the configuration
+ * const result = Effect.runSync(config)
+ *
+ * console.log(result)
+ * // Output:
+ * // Unavailable config for master
+ * // Unavailable config for node1
+ * // Unavailable config for node2
+ * // Config for node3 found
+ * // { host: 'node3.example.com', port: 8080, apiKey: '12345-abcde' }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Fallback
+ */
+const firstSuccessOf = exports.firstSuccessOf = effect.firstSuccessOf;
+/**
+ * Retrieves the `Random` service from the context.
+ *
+ * @since 2.0.0
+ * @category Random
+ */
+const random = exports.random = effect.random;
+/**
+ * Retrieves the `Random` service from the context and uses it to run the
+ * specified effect.
+ *
+ * @since 2.0.0
+ * @category Random
+ */
+const randomWith = exports.randomWith = defaultServices.randomWith;
+/**
+ * Executes the specified effect with the specified implementation of the
+ * `Random` service.
+ *
+ * @since 2.0.0
+ * @category Random
+ */
+const withRandom = exports.withRandom = defaultServices.withRandom;
+/**
+ * Executes the specified effect with a `Random` service that cycles through
+ * a provided array of values.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * Effect.gen(function*() {
+ * console.log(yield* Random.next) // 0.2
+ * console.log(yield* Random.next) // 0.5
+ * console.log(yield* Random.next) // 0.8
+ * }).pipe(Effect.withRandomFixed([0.2, 0.5, 0.8]))
+ * ```
+ *
+ * @since 3.11.0
+ * @category Random
+ */
+const withRandomFixed = exports.withRandomFixed = /*#__PURE__*/(0, _Function.dual)(2, (effect, values) => withRandom(effect, Random.fixed(values)));
+/**
+ * Sets the implementation of the `Random` service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 2.0.0
+ * @category Random
+ */
+const withRandomScoped = exports.withRandomScoped = fiberRuntime.withRandomScoped;
+/**
+ * Returns an effect that accesses the runtime, which can be used to (unsafely)
+ * execute tasks.
+ *
+ * **When to Use**
+ *
+ * This is useful for integration with legacy code that must call back into
+ * Effect code.
+ *
+ * @since 2.0.0
+ * @category Runtime
+ */
+const runtime = exports.runtime = runtime_.runtime;
+/**
+ * Retrieves an effect that succeeds with the current runtime flags, which
+ * govern behavior and features of the runtime system.
+ *
+ * @since 2.0.0
+ * @category Runtime
+ */
+const getRuntimeFlags = exports.getRuntimeFlags = core.runtimeFlags;
+/**
+ * @since 2.0.0
+ * @category Runtime
+ */
+const patchRuntimeFlags = exports.patchRuntimeFlags = core.updateRuntimeFlags;
+/**
+ * @since 2.0.0
+ * @category Runtime
+ */
+const withRuntimeFlagsPatch = exports.withRuntimeFlagsPatch = core.withRuntimeFlags;
+/**
+ * @since 2.0.0
+ * @category Runtime
+ */
+const withRuntimeFlagsPatchScoped = exports.withRuntimeFlagsPatchScoped = fiberRuntime.withRuntimeFlagsScoped;
+/**
+ * Tags each metric in an effect with specific key-value pairs.
+ *
+ * **Details**
+ *
+ * This function allows you to tag all metrics in an effect with a set of
+ * key-value pairs or a single key-value pair. Tags help you add metadata to
+ * metrics, making it easier to filter and categorize them in monitoring
+ * systems. The provided tags will apply to all metrics generated within the
+ * effect's scope.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const tagMetrics = exports.tagMetrics = effect.tagMetrics;
+/**
+ * Adds labels to metrics within an effect using `MetricLabel` objects.
+ *
+ * **Details**
+ *
+ * This function allows you to label metrics using `MetricLabel` objects. Labels
+ * help add structured metadata to metrics for categorization and filtering in
+ * monitoring systems. The provided labels will apply to all metrics within the
+ * effect's execution.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const labelMetrics = exports.labelMetrics = effect.labelMetrics;
+/**
+ * Tags metrics within a scope with a specific key-value pair.
+ *
+ * **Details**
+ *
+ * This function tags all metrics within a scope with the provided key-value
+ * pair. Once the scope is closed, the tag is automatically removed. This is
+ * useful for applying temporary context-specific tags to metrics during scoped
+ * operations.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const tagMetricsScoped = exports.tagMetricsScoped = fiberRuntime.tagMetricsScoped;
+/**
+ * Adds labels to metrics within a scope using `MetricLabel` objects.
+ *
+ * **Details**
+ *
+ * This function allows you to apply labels to all metrics generated within a
+ * specific scope using an array of `MetricLabel` objects. These labels provide
+ * additional metadata to metrics, which can be used for categorization,
+ * filtering, or monitoring purposes. The labels are scoped and will be removed
+ * automatically once the scope is closed, ensuring they are only applied
+ * temporarily within the defined context.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const labelMetricsScoped = exports.labelMetricsScoped = fiberRuntime.labelMetricsScoped;
+/**
+ * Retrieves the metric labels associated with the current scope.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const metricLabels = exports.metricLabels = core.metricLabels;
+/**
+ * Associates a metric with the current effect, updating it as the effect progresses.
+ *
+ * @since 2.0.0
+ * @category Metrics
+ */
+const withMetric = exports.withMetric = effect.withMetric;
+/**
+ * Unsafely creates a new Semaphore.
+ *
+ * @since 2.0.0
+ * @category Semaphore
+ */
+const unsafeMakeSemaphore = exports.unsafeMakeSemaphore = circular.unsafeMakeSemaphore;
+/**
+ * Creates a new semaphore with the specified number of permits.
+ *
+ * **Details**
+ *
+ * This function initializes a semaphore that controls concurrent access to a
+ * shared resource. The number of permits determines how many tasks can access
+ * the resource concurrently.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Create a semaphore with 3 permits
+ * const mutex = Effect.makeSemaphore(3)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Semaphore
+ */
+const makeSemaphore = exports.makeSemaphore = circular.makeSemaphore;
+/**
+ * @category Latch
+ * @since 3.8.0
+ */
+const unsafeMakeLatch = exports.unsafeMakeLatch = circular.unsafeMakeLatch;
+/**
+ * Creates a new `Latch`, starting in the specified state.
+ *
+ * **Details**
+ *
+ * This function initializes a `Latch` safely, ensuring proper runtime
+ * guarantees. By default, the latch starts in the closed state.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Console, Effect } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ * // Create a latch, starting in the closed state
+ * const latch = yield* Effect.makeLatch(false)
+ *
+ * // Fork a fiber that logs "open sesame" when the latch is opened
+ * const fiber = yield* Console.log("open sesame").pipe(
+ * latch.whenOpen,
+ * Effect.fork
+ * )
+ *
+ * yield* Effect.sleep("1 second")
+ *
+ * // Open the latch
+ * yield* latch.open
+ * yield* fiber.await
+ * })
+ *
+ * Effect.runFork(program)
+ * // Output: open sesame (after 1 second)
+ * ```
+ *
+ * @category Latch
+ * @since 3.8.0
+ */
+const makeLatch = exports.makeLatch = circular.makeLatch;
+/**
+ * Runs an effect in the background, returning a fiber that can be observed or
+ * interrupted.
+ *
+ * Unless you specifically need a `Promise` or synchronous operation, `runFork`
+ * is a good default choice.
+ *
+ * **Details**
+ *
+ * This function is the foundational way to execute an effect in the background.
+ * It creates a "fiber," a lightweight, cooperative thread of execution that can
+ * be observed (to access its result), interrupted, or joined. Fibers are useful
+ * for concurrent programming and allow effects to run independently of the main
+ * program flow.
+ *
+ * Once the effect is running in a fiber, you can monitor its progress, cancel
+ * it if necessary, or retrieve its result when it completes. If the effect
+ * fails, the fiber will propagate the failure, which you can observe and
+ * handle.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to run an effect in the background,
+ * especially if the effect is long-running or performs periodic tasks. It's
+ * suitable for tasks that need to run independently but might still need
+ * observation or management, like logging, monitoring, or scheduled tasks.
+ *
+ * This function is ideal if you don't need the result immediately or if the
+ * effect is part of a larger concurrent workflow.
+ *
+ * **Example** (Running an Effect in the Background)
+ *
+ * ```ts
+ * import { Effect, Console, Schedule, Fiber } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const program = Effect.repeat(
+ * Console.log("running..."),
+ * Schedule.spaced("200 millis")
+ * )
+ *
+ * // ┌─── RuntimeFiber
+ * // ▼
+ * const fiber = Effect.runFork(program)
+ *
+ * setTimeout(() => {
+ * Effect.runFork(Fiber.interrupt(fiber))
+ * }, 500)
+ * ```
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runFork = exports.runFork = runtime_.unsafeForkEffect;
+/**
+ * Executes an effect asynchronously and handles the result using a callback.
+ *
+ * **Details**
+ *
+ * This function runs an effect asynchronously and passes the result (`Exit`) to
+ * a specified callback. The callback is invoked with the outcome of the effect:
+ * - On success, the callback receives the successful result.
+ * - On failure, the callback receives the failure information.
+ *
+ * **When to Use**
+ *
+ * This function is effectful and should only be invoked at the edges of your
+ * program.
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runCallback = exports.runCallback = runtime_.unsafeRunEffect;
+/**
+ * Executes an effect and returns the result as a `Promise`.
+ *
+ * **Details**
+ *
+ * This function runs an effect and converts its result into a `Promise`. If the
+ * effect succeeds, the `Promise` will resolve with the successful result. If
+ * the effect fails, the `Promise` will reject with an error, which includes the
+ * failure details of the effect.
+ *
+ * The optional `options` parameter allows you to pass an `AbortSignal` for
+ * cancellation, enabling more fine-grained control over asynchronous tasks.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to execute an effect and work with its result
+ * in a promise-based system, such as when integrating with third-party
+ * libraries that expect `Promise` results.
+ *
+ * **Example** (Running a Successful Effect as a Promise)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * Effect.runPromise(Effect.succeed(1)).then(console.log)
+ * // Output: 1
+ * ```
+ *
+ * **Example** (Handling a Failing Effect as a Rejected Promise)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * Effect.runPromise(Effect.fail("my error")).catch(console.error)
+ * // Output:
+ * // (FiberFailure) Error: my error
+ * ```
+ *
+ * @see {@link runPromiseExit} for a version that returns an `Exit` type instead
+ * of rejecting.
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runPromise = exports.runPromise = runtime_.unsafeRunPromiseEffect;
+/**
+ * Runs an effect and returns a `Promise` that resolves to an `Exit`,
+ * representing the outcome.
+ *
+ * **Details**
+ *
+ * This function executes an effect and resolves to an `Exit` object. The `Exit`
+ * type provides detailed information about the result of the effect:
+ * - If the effect succeeds, the `Exit` will be of type `Success` and include
+ * the value produced by the effect.
+ * - If the effect fails, the `Exit` will be of type `Failure` and contain a
+ * `Cause` object, detailing the failure.
+ *
+ * Using this function allows you to examine both successful results and failure
+ * cases in a unified way, while still leveraging `Promise` for handling the
+ * asynchronous behavior of the effect.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to understand the outcome of an effect,
+ * whether it succeeded or failed, and want to work with this result using
+ * `Promise` syntax. This is particularly useful when integrating with systems
+ * that rely on promises but need more detailed error handling than a simple
+ * rejection.
+ *
+ * **Example** (Handling Results as Exit)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // Execute a successful effect and get the Exit result as a Promise
+ * Effect.runPromiseExit(Effect.succeed(1)).then(console.log)
+ * // Output:
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Success",
+ * // value: 1
+ * // }
+ *
+ * // Execute a failing effect and get the Exit result as a Promise
+ * Effect.runPromiseExit(Effect.fail("my error")).then(console.log)
+ * // Output:
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Failure",
+ * // cause: {
+ * // _id: "Cause",
+ * // _tag: "Fail",
+ * // failure: "my error"
+ * // }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runPromiseExit = exports.runPromiseExit = runtime_.unsafeRunPromiseExitEffect;
+/**
+ * Executes an effect synchronously, running it immediately and returning the
+ * result.
+ *
+ * **Details**
+ *
+ * This function evaluates the provided effect synchronously, returning its
+ * result directly. It is ideal for effects that do not fail or include
+ * asynchronous operations. If the effect does fail or involves async tasks, it
+ * will throw an error. Execution stops at the point of failure or asynchronous
+ * operation, making it unsuitable for effects that require asynchronous
+ * handling.
+ *
+ * **Important**: Attempting to run effects that involve asynchronous operations
+ * or failures will result in exceptions being thrown, so use this function with
+ * care for purely synchronous and error-free effects.
+ *
+ * **When to Use**
+ *
+ * Use this function when:
+ * - You are sure that the effect will not fail or involve asynchronous
+ * operations.
+ * - You need a direct, synchronous result from the effect.
+ * - You are working within a context where asynchronous effects are not
+ * allowed.
+ *
+ * Avoid using this function for effects that can fail or require asynchronous
+ * handling. For such cases, consider using {@link runPromise} or
+ * {@link runSyncExit}.
+ *
+ * **Example** (Synchronous Logging)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.sync(() => {
+ * console.log("Hello, World!")
+ * return 1
+ * })
+ *
+ * const result = Effect.runSync(program)
+ * // Output: Hello, World!
+ *
+ * console.log(result)
+ * // Output: 1
+ * ```
+ *
+ * **Example** (Incorrect Usage with Failing or Async Effects)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * try {
+ * // Attempt to run an effect that fails
+ * Effect.runSync(Effect.fail("my error"))
+ * } catch (e) {
+ * console.error(e)
+ * }
+ * // Output:
+ * // (FiberFailure) Error: my error
+ *
+ * try {
+ * // Attempt to run an effect that involves async work
+ * Effect.runSync(Effect.promise(() => Promise.resolve(1)))
+ * } catch (e) {
+ * console.error(e)
+ * }
+ * // Output:
+ * // (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work
+ * ```
+ *
+ * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
+ * throwing an error.
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runSync = exports.runSync = runtime_.unsafeRunSyncEffect;
+/**
+ * Runs an effect synchronously and returns the result as an `Exit` type.
+ *
+ * **Details**
+ *
+ * This function executes the provided effect synchronously and returns an `Exit`
+ * type that encapsulates the outcome of the effect:
+ * - If the effect succeeds, the result is wrapped in a `Success`.
+ * - If the effect fails, it returns a `Failure` containing a `Cause` that explains
+ * the failure.
+ *
+ * If the effect involves asynchronous operations, this function will return a `Failure`
+ * with a `Die` cause, indicating that it cannot resolve the effect synchronously.
+ * This makes the function suitable for use only with effects that are synchronous
+ * in nature.
+ *
+ * **When to Use**
+ *
+ * Use this function when:
+ * - You want to handle both success and failure outcomes in a structured way using the `Exit` type.
+ * - You are working with effects that are purely synchronous and do not involve asynchronous operations.
+ * - You need to debug or inspect failures, including their causes, in a detailed manner.
+ *
+ * Avoid using this function for effects that involve asynchronous operations, as it will fail with a `Die` cause.
+ *
+ * **Example** (Handling Results as Exit)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * console.log(Effect.runSyncExit(Effect.succeed(1)))
+ * // Output:
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Success",
+ * // value: 1
+ * // }
+ *
+ * console.log(Effect.runSyncExit(Effect.fail("my error")))
+ * // Output:
+ * // {
+ * // _id: "Exit",
+ * // _tag: "Failure",
+ * // cause: {
+ * // _id: "Cause",
+ * // _tag: "Fail",
+ * // failure: "my error"
+ * // }
+ * // }
+ * ```
+ *
+ * **Example** (Asynchronous Operation Resulting in Die)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * console.log(Effect.runSyncExit(Effect.promise(() => Promise.resolve(1))))
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Die',
+ * // defect: [Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work] {
+ * // fiber: [FiberRuntime],
+ * // _tag: 'AsyncFiberException',
+ * // name: 'AsyncFiberException'
+ * // }
+ * // }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runSyncExit = exports.runSyncExit = runtime_.unsafeRunSyncExitEffect;
+/**
+ * Combines multiple effects and accumulates both successes and failures.
+ *
+ * **Details**
+ *
+ * This function allows you to combine multiple effects, continuing through all
+ * effects even if some of them fail. Unlike other functions that stop execution
+ * upon encountering an error, this function collects all errors into a `Cause`.
+ * The final result includes all successes and the accumulated failures.
+ *
+ * By default, effects are executed sequentially, but you can control
+ * concurrency and batching behavior using the `options` parameter. This
+ * provides flexibility in scenarios where you want to maximize performance or
+ * ensure specific ordering.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Console } from "effect"
+ *
+ * const task1 = Console.log("task1").pipe(Effect.as(1))
+ * const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2))
+ * const task3 = Console.log("task2").pipe(Effect.as(3))
+ * const task4 = Effect.fail("Oh no!").pipe(Effect.as(4))
+ *
+ * const program = task1.pipe(
+ * Effect.validate(task2),
+ * Effect.validate(task3),
+ * Effect.validate(task4)
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // Output:
+ * // task1
+ * // task2
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Sequential',
+ * // left: { _id: 'Cause', _tag: 'Fail', failure: 'Oh uh!' },
+ * // right: { _id: 'Cause', _tag: 'Fail', failure: 'Oh no!' }
+ * // }
+ * // }
+ * ```
+ *
+ * @see {@link zip} for a version that stops at the first error.
+ *
+ * @since 2.0.0
+ * @category Error Accumulation
+ */
+const validate = exports.validate = fiberRuntime.validate;
+/**
+ * Sequentially combines two effects using a specified combiner function while
+ * accumulating errors.
+ *
+ * **Details**
+ *
+ * This function combines two effects, `self` and `that`, into a single effect
+ * by applying the provided combiner function to their results. If both effects
+ * succeed, the combiner function is applied to their results to produce the
+ * final value. If either effect fails, the failures are accumulated into a
+ * combined `Cause`.
+ *
+ * By default, effects are executed sequentially. However, the execution mode
+ * can be controlled using the `options` parameter to enable concurrency,
+ * batching, or customized finalizer behavior.
+ *
+ * @since 2.0.0
+ * @category Error Accumulation
+ */
+const validateWith = exports.validateWith = fiberRuntime.validateWith;
+/**
+ * Combines two effects into a single effect, producing a tuple of their
+ * results.
+ *
+ * **Details**
+ *
+ * This function combines two effects, `self` and `that`, into one. It executes
+ * the first effect (`self`) and then the second effect (`that`), collecting
+ * their results into a tuple. Both effects must succeed for the resulting
+ * effect to succeed. If either effect fails, the entire operation fails.
+ *
+ * By default, the effects are executed sequentially. If the `concurrent` option
+ * is set to `true`, the effects will run concurrently, potentially improving
+ * performance for independent operations.
+ *
+ * **Example** (Combining Two Effects Sequentially)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * // Combine the two effects together
+ * //
+ * // ┌─── Effect<[number, string], never, never>
+ * // ▼
+ * const program = Effect.zip(task1, task2)
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="task1 done"
+ * // timestamp=... level=INFO fiber=#0 message="task2 done"
+ * // [ 1, 'hello' ]
+ * ```
+ *
+ * **Example** (Combining Two Effects Concurrently)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * // Run both effects concurrently using the concurrent option
+ * const program = Effect.zip(task1, task2, { concurrent: true })
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="task2 done"
+ * // timestamp=... level=INFO fiber=#0 message="task1 done"
+ * // [ 1, 'hello' ]
+ * ```
+ *
+ * @see {@link zipWith} for a version that combines the results with a custom
+ * function.
+ * @see {@link validate} for a version that accumulates errors.
+ *
+ * @since 2.0.0
+ * @category Zipping
+ */
+const zip = exports.zip = fiberRuntime.zipOptions;
+/**
+ * Executes two effects sequentially, returning the result of the first effect
+ * and ignoring the result of the second.
+ *
+ * **Details**
+ *
+ * This function allows you to run two effects in sequence, where the result of
+ * the first effect is preserved, and the result of the second effect is
+ * discarded. By default, the two effects are executed sequentially. If you need
+ * them to run concurrently, you can pass the `{ concurrent: true }` option.
+ *
+ * The second effect will always be executed, even though its result is ignored.
+ * This makes it useful for cases where you want to execute an effect for its
+ * side effects while keeping the result of another effect.
+ *
+ * **When to Use**
+ *
+ * Use this function when you are only interested in the result of the first
+ * effect but still need to run the second effect for its side effects, such as
+ * logging or performing a cleanup action.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * const program = Effect.zipLeft(task1, task2)
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="task1 done"
+ * // timestamp=... level=INFO fiber=#0 message="task2 done"
+ * // 1
+ * ```
+ *
+ * @see {@link zipRight} for a version that returns the result of the second
+ * effect.
+ *
+ * @since 2.0.0
+ * @category Zipping
+ */
+const zipLeft = exports.zipLeft = fiberRuntime.zipLeftOptions;
+/**
+ * Executes two effects sequentially, returning the result of the second effect
+ * while ignoring the result of the first.
+ *
+ * **Details**
+ *
+ * This function allows you to run two effects in sequence, keeping the result
+ * of the second effect and discarding the result of the first. By default, the
+ * two effects are executed sequentially. If you need them to run concurrently,
+ * you can pass the `{ concurrent: true }` option.
+ *
+ * The first effect will always be executed, even though its result is ignored.
+ * This makes it useful for scenarios where the first effect is needed for its
+ * side effects, but only the result of the second effect is important.
+ *
+ * **When to Use**
+ *
+ * Use this function when you are only interested in the result of the second
+ * effect but still need to run the first effect for its side effects, such as
+ * initialization or setup tasks.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * const program = Effect.zipRight(task1, task2)
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#0 message="task1 done"
+ * // timestamp=... level=INFO fiber=#0 message="task2 done"
+ * // hello
+ * ```
+ *
+ * @see {@link zipLeft} for a version that returns the result of the first
+ * effect.
+ *
+ * @since 2.0.0
+ * @category Zipping
+ */
+const zipRight = exports.zipRight = fiberRuntime.zipRightOptions;
+/**
+ * Combines two effects sequentially and applies a function to their results to
+ * produce a single value.
+ *
+ * **Details**
+ *
+ * This function runs two effects in sequence (or concurrently, if the `{
+ * concurrent: true }` option is provided) and combines their results using a
+ * provided function. Unlike {@link zip}, which returns a tuple of the results,
+ * this function processes the results with a custom function to produce a
+ * single output.
+ *
+ * **Example** (Combining Effects with a Custom Function)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const task1 = Effect.succeed(1).pipe(
+ * Effect.delay("200 millis"),
+ * Effect.tap(Effect.log("task1 done"))
+ * )
+ * const task2 = Effect.succeed("hello").pipe(
+ * Effect.delay("100 millis"),
+ * Effect.tap(Effect.log("task2 done"))
+ * )
+ *
+ * const task3 = Effect.zipWith(
+ * task1,
+ * task2,
+ * // Combines results into a single value
+ * (number, string) => number + string.length
+ * )
+ *
+ * Effect.runPromise(task3).then(console.log)
+ * // Output:
+ * // timestamp=... level=INFO fiber=#3 message="task1 done"
+ * // timestamp=... level=INFO fiber=#2 message="task2 done"
+ * // 6
+ * ```
+ *
+ * @since 2.0.0
+ * @category Zipping
+ */
+const zipWith = exports.zipWith = fiberRuntime.zipWithOptions;
+/**
+ * Applies the function produced by one effect to the value produced by another effect.
+ *
+ * **Details**
+ *
+ * This function combines two effects:
+ * - The first effect produces a function of type `(a: A) => B`.
+ * - The second effect produces a value of type `A`.
+ *
+ * Once both effects complete successfully, the function is applied to the value, resulting in an effect that produces a value of type `B`.
+ *
+ * @since 2.0.0
+ */
+const ap = exports.ap = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
+/**
+ * @category Requests & Batching
+ * @since 2.0.0
+ */
+const blocked = exports.blocked = core.blocked;
+/**
+ * @category Requests & Batching
+ * @since 2.0.0
+ */
+const runRequestBlock = exports.runRequestBlock = core.runRequestBlock;
+/**
+ * @category Requests & Batching
+ * @since 2.0.0
+ */
+const step = exports.step = core.step;
+/**
+ * @since 2.0.0
+ * @category Requests & Batching
+ */
+const request = exports.request = /*#__PURE__*/(0, _Function.dual)(args => Request.isRequest(args[0]), query.fromRequest);
+/**
+ * @since 2.0.0
+ * @category Requests & Batching
+ */
+const cacheRequestResult = exports.cacheRequestResult = query.cacheRequest;
+/**
+ * @since 2.0.0
+ * @category Requests & Batching
+ */
+const withRequestBatching = exports.withRequestBatching = core.withRequestBatching;
+/**
+ * @since 2.0.0
+ * @category Requests & Batching
+ */
+const withRequestCaching = exports.withRequestCaching = query.withRequestCaching;
+/**
+ * @since 2.0.0
+ * @category Requests & Batching
+ */
+const withRequestCache = exports.withRequestCache = query.withRequestCache;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const tracer = exports.tracer = effect.tracer;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const tracerWith = exports.tracerWith = defaultServices.tracerWith;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withTracer = exports.withTracer = defaultServices.withTracer;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withTracerScoped = exports.withTracerScoped = fiberRuntime.withTracerScoped;
+/**
+ * Disable the tracer for the given Effect.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * Effect.succeed(42).pipe(
+ * Effect.withSpan("my-span"),
+ * // the span will not be registered with the tracer
+ * Effect.withTracerEnabled(false)
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withTracerEnabled = exports.withTracerEnabled = core.withTracerEnabled;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withTracerTiming = exports.withTracerTiming = core.withTracerTiming;
+/**
+ * Adds annotations to each span in the effect for enhanced traceability.
+ *
+ * **Details**
+ *
+ * This function lets you attach key-value annotations to all spans generated
+ * during the execution of an effect. Annotations provide additional context,
+ * such as metadata or labels, which can help you understand and debug
+ * asynchronous workflows more effectively.
+ *
+ * You can either pass a single key-value pair or a record of key-value pairs to
+ * annotate the spans. These annotations can then be visualized in tracing tools
+ * that support span annotations.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const annotateSpans = exports.annotateSpans = effect.annotateSpans;
+/**
+ * Adds annotations to the currently active span for traceability.
+ *
+ * **Details**
+ *
+ * This function adds key-value annotations to the currently active span in the
+ * effect's trace. These annotations help provide more context about the
+ * operation being executed at a specific point in time. Unlike
+ * {@link annotateSpans}, which applies to all spans in an effect, this function
+ * focuses solely on the active span.
+ *
+ * You can either pass a single key-value pair or a record of key-value pairs to
+ * annotate the span. These annotations are useful for adding metadata to
+ * operations, especially in systems with detailed observability requirements.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const annotateCurrentSpan = exports.annotateCurrentSpan = effect.annotateCurrentSpan;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const currentSpan = exports.currentSpan = effect.currentSpan;
+/**
+ * @since 3.20.0
+ * @category Tracing
+ */
+const currentPropagatedSpan = exports.currentPropagatedSpan = effect.currentPropagatedSpan;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const currentParentSpan = exports.currentParentSpan = effect.currentParentSpan;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const spanAnnotations = exports.spanAnnotations = effect.spanAnnotations;
+/**
+ * @since 2.0.0
+ * @category Tracing
+ */
+const spanLinks = exports.spanLinks = effect.spanLinks;
+/**
+ * For all spans in this effect, add a link with the provided span.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const linkSpans = exports.linkSpans = effect.linkSpans;
+/**
+ * Add span links to the current span.
+ *
+ * @since 3.14.0
+ * @category Tracing
+ */
+const linkSpanCurrent = exports.linkSpanCurrent = effect.linkSpanCurrent;
+/**
+ * Create a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const makeSpan = exports.makeSpan = effect.makeSpan;
+/**
+ * Create a new span for tracing, and automatically close it when the Scope
+ * finalizes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const makeSpanScoped = exports.makeSpanScoped = fiberRuntime.makeSpanScoped;
+/**
+ * Create a new span for tracing, and automatically close it when the effect
+ * completes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const useSpan = exports.useSpan = effect.useSpan;
+/**
+ * Wraps the effect with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withSpan = exports.withSpan = effect.withSpan;
+/**
+ * Wraps a function that returns an effect with a new span for tracing.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const getTodo = Effect.functionWithSpan({
+ * body: (id: number) => Effect.succeed(`Got todo ${id}!`),
+ * options: (id) => ({
+ * name: `getTodo-${id}`,
+ * attributes: { id }
+ * })
+ * })
+ * ```
+ *
+ * @since 3.2.0
+ * @category Tracing
+ */
+const functionWithSpan = exports.functionWithSpan = effect.functionWithSpan;
+/**
+ * Wraps the effect with a new span for tracing.
+ *
+ * The span is ended when the Scope is finalized.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withSpanScoped = exports.withSpanScoped = fiberRuntime.withSpanScoped;
+/**
+ * Adds the provided span to the current span stack.
+ *
+ * @since 2.0.0
+ * @category Tracing
+ */
+const withParentSpan = exports.withParentSpan = effect.withParentSpan;
+/**
+ * Safely handles nullable values by creating an effect that fails for `null` or
+ * `undefined`.
+ *
+ * **Details**
+ *
+ * This function ensures that an input value is non-null and non-undefined
+ * before processing it. If the value is valid, the effect succeeds with the
+ * value. If the value is `null` or `undefined`, the effect fails with a
+ * `NoSuchElementException`. This is particularly useful for avoiding
+ * null-related errors by clearly separating valid values from invalid ones in
+ * effectful computations.
+ *
+ * The failure with `NoSuchElementException` allows you to explicitly handle
+ * cases where a value is expected but not provided, leading to safer and more
+ * predictable code.
+ *
+ * **When to Use**
+ *
+ * Use this function when working with values that may be `null` or `undefined`
+ * and you want to ensure that only non-null values are processed. It helps
+ * enforce null-safety and makes error handling more explicit.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const maybe1 = Effect.fromNullable(1)
+ *
+ * Effect.runPromiseExit(maybe1).then(console.log)
+ * // Output:
+ * // { _id: 'Exit', _tag: 'Success', value: 1 }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const maybe2 = Effect.fromNullable(null as number | null)
+ *
+ * Effect.runPromiseExit(maybe2).then(console.log)
+ * // Output:
+ * // {
+ * // _id: 'Exit',
+ * // _tag: 'Failure',
+ * // cause: {
+ * // _id: 'Cause',
+ * // _tag: 'Fail',
+ * // failure: { _tag: 'NoSuchElementException' }
+ * // }
+ * // }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Optional Wrapping & Unwrapping
+ */
+const fromNullable = exports.fromNullable = effect.fromNullable;
+/**
+ * Converts an effect that may fail with a `NoSuchElementException` into an
+ * effect that succeeds with an `Option`.
+ *
+ * **Details**
+ *
+ * This function transforms an effect that might fail with
+ * `Cause.NoSuchElementException` into an effect that succeeds with an `Option`
+ * type. If the original effect succeeds, its value is wrapped in `Option.some`.
+ * If it fails specifically due to a `NoSuchElementException`, the failure is
+ * mapped to `Option.none`. Other types of failures remain unchanged and are
+ * passed through as they are.
+ *
+ * This is useful when working with effects where you want to gracefully handle
+ * the absence of a value while preserving other potential failures.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to handle missing values as `Option.none`
+ * rather than throwing or propagating errors like `NoSuchElementException`.
+ * It’s ideal for scenarios where you want to explicitly represent optionality
+ * in a type-safe way while retaining other failure information.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const maybe1 = Effect.fromNullable(1)
+ *
+ * // ┌─── Effect, never, never>
+ * // ▼
+ * const option1 = Effect.optionFromOptional(maybe1)
+ *
+ * Effect.runPromise(option1).then(console.log)
+ * // Output: { _id: 'Option', _tag: 'Some', value: 1 }
+ *
+ * // ┌─── Effect
+ * // ▼
+ * const maybe2 = Effect.fromNullable(null as number | null)
+ *
+ * // ┌─── Effect, never, never>
+ * // ▼
+ * const option2 = Effect.optionFromOptional(maybe2)
+ *
+ * Effect.runPromise(option2).then(console.log)
+ * // Output: { _tag: 'None' }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Optional Wrapping & Unwrapping
+ */
+const optionFromOptional = exports.optionFromOptional = effect.optionFromOptional;
+/**
+ * Converts an `Option` of an `Effect` into an `Effect` of an `Option`.
+ *
+ * **Details**
+ *
+ * This function transforms an `Option>` into an
+ * `Effect, E, R>`. If the `Option` is `None`, the resulting `Effect`
+ * will immediately succeed with a `None` value. If the `Option` is `Some`, the
+ * inner `Effect` will be executed, and its result wrapped in a `Some`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Option } from "effect"
+ *
+ * // ┌─── Option>
+ * // ▼
+ * const maybe = Option.some(Effect.succeed(42))
+ *
+ * // ┌─── Effect, never, never>
+ * // ▼
+ * const result = Effect.transposeOption(maybe)
+ *
+ * console.log(Effect.runSync(result))
+ * // Output: { _id: 'Option', _tag: 'Some', value: 42 }
+ * ```
+ *
+ * @since 3.13.0
+ * @category Optional Wrapping & Unwrapping
+ */
+const transposeOption = self => {
+ return option_.isNone(self) ? succeedNone : map(self.value, option_.some);
+};
+/**
+ * Applies an `Effect` on an `Option` and transposes the result.
+ *
+ * **Details**
+ *
+ * If the `Option` is `None`, the resulting `Effect` will immediately succeed with a `None` value.
+ * If the `Option` is `Some`, the effectful operation will be executed on the inner value, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, pipe } from "effect"
+ *
+ * // ┌─── Effect, never, never>>
+ * // ▼
+ * const noneResult = pipe(
+ * Option.none(),
+ * Effect.transposeMapOption(() => Effect.succeed(42)) // will not be executed
+ * )
+ * console.log(Effect.runSync(noneResult))
+ * // Output: { _id: 'Option', _tag: 'None' }
+ *
+ * // ┌─── Effect, never, never>>
+ * // ▼
+ * const someSuccessResult = pipe(
+ * Option.some(42),
+ * Effect.transposeMapOption((value) => Effect.succeed(value * 2))
+ * )
+ * console.log(Effect.runSync(someSuccessResult))
+ * // Output: { _id: 'Option', _tag: 'Some', value: 84 }
+ * ```
+ *
+ * @since 3.14.0
+ * @category Optional Wrapping & Unwrapping
+ */
+exports.transposeOption = transposeOption;
+const transposeMapOption = exports.transposeMapOption = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => option_.isNone(self) ? succeedNone : map(f(self.value), option_.some));
+const makeTagProxy = TagClass => {
+ const cache = new Map();
+ return new Proxy(TagClass, {
+ get(target, prop, receiver) {
+ if (prop in target) {
+ return Reflect.get(target, prop, receiver);
+ }
+ if (cache.has(prop)) {
+ return cache.get(prop);
+ }
+ const fn = (...args) => core.andThen(target, s => {
+ if (typeof s[prop] === "function") {
+ cache.set(prop, (...args) => core.andThen(target, s => s[prop](...args)));
+ return s[prop](...args);
+ }
+ cache.set(prop, core.andThen(target, s => s[prop]));
+ return s[prop];
+ });
+ const cn = core.andThen(target, s => s[prop]);
+ // @effect-diagnostics-next-line floatingEffect:off
+ Object.assign(fn, cn);
+ const apply = fn.apply;
+ const bind = fn.bind;
+ const call = fn.call;
+ const proto = Object.setPrototypeOf({}, Object.getPrototypeOf(cn));
+ proto.apply = apply;
+ proto.bind = bind;
+ proto.call = call;
+ Object.setPrototypeOf(fn, proto);
+ cache.set(prop, fn);
+ return fn;
+ }
+ });
+};
+/**
+ * Creates a unique tag for a dependency, embedding the service's methods as
+ * static properties.
+ *
+ * **Details**
+ *
+ * This function allows you to define a `Tag` for a service or dependency in
+ * your application. The `Tag` not only acts as an identifier but also provides
+ * direct access to the service's methods via static properties. This makes it
+ * easier to access and use the service in your code without manually managing
+ * contexts.
+ *
+ * In the example below, the fields of the service (in this case, the `notify`
+ * method) are turned into static properties of the Notifications class, making
+ * it easier to access them.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * class Notifications extends Effect.Tag("Notifications")<
+ * Notifications,
+ * { readonly notify: (message: string) => Effect.Effect }
+ * >() {}
+ *
+ * // Create an effect that depends on the Notifications service
+ * const action = Notifications.notify("Hello, world!")
+ * ```
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+const Tag = id => () => {
+ const limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 2;
+ const creationError = new Error();
+ Error.stackTraceLimit = limit;
+ function TagClass() {}
+ Object.setPrototypeOf(TagClass, _context.TagProto);
+ TagClass.key = id;
+ Object.defineProperty(TagClass, "use", {
+ get() {
+ return body => core.andThen(this, body);
+ }
+ });
+ Object.defineProperty(TagClass, "stack", {
+ get() {
+ return creationError.stack;
+ }
+ });
+ return makeTagProxy(TagClass);
+};
+/**
+ * Simplifies the creation and management of services in Effect by defining both
+ * a `Tag` and a `Layer`.
+ *
+ * **Details**
+ *
+ * This function allows you to streamline the creation of services by combining
+ * the definition of a `Context.Tag` and a `Layer` in a single step. It supports
+ * various ways of providing the service implementation:
+ * - Using an `effect` to define the service dynamically.
+ * - Using `sync` or `succeed` to define the service statically.
+ * - Using `scoped` to create services with lifecycle management.
+ *
+ * It also allows you to specify dependencies for the service, which will be
+ * provided automatically when the service is used. Accessors can be optionally
+ * generated for the service, making it more convenient to use.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from 'effect';
+ *
+ * class Prefix extends Effect.Service()("Prefix", {
+ * sync: () => ({ prefix: "PRE" })
+ * }) {}
+ *
+ * class Logger extends Effect.Service()("Logger", {
+ * accessors: true,
+ * effect: Effect.gen(function* () {
+ * const { prefix } = yield* Prefix
+ * return {
+ * info: (message: string) =>
+ * Effect.sync(() => {
+ * console.log(`[${prefix}][${message}]`)
+ * })
+ * }
+ * }),
+ * dependencies: [Prefix.Default]
+ * }) {}
+ * ```
+ *
+ * @since 3.9.0
+ * @category Context
+ * @experimental might be up for breaking changes
+ */
+exports.Tag = Tag;
+const Service = function () {
+ return function () {
+ const [id, maker] = arguments;
+ const proxy = "accessors" in maker ? maker["accessors"] : false;
+ const limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 2;
+ const creationError = new Error();
+ Error.stackTraceLimit = limit;
+ let patchState = "unchecked";
+ const TagClass = function (service) {
+ if (patchState === "unchecked") {
+ const proto = Object.getPrototypeOf(service);
+ if (proto === Object.prototype || proto === null) {
+ patchState = "plain";
+ } else {
+ const selfProto = Object.getPrototypeOf(this);
+ Object.setPrototypeOf(selfProto, proto);
+ patchState = "patched";
+ }
+ }
+ if (patchState === "plain") {
+ Object.assign(this, service);
+ } else if (patchState === "patched") {
+ Object.setPrototypeOf(service, Object.getPrototypeOf(this));
+ return service;
+ }
+ };
+ TagClass.prototype._tag = id;
+ Object.defineProperty(TagClass, "make", {
+ get() {
+ return service => new this(service);
+ }
+ });
+ Object.defineProperty(TagClass, "use", {
+ get() {
+ return body => core.andThen(this, body);
+ }
+ });
+ TagClass.key = id;
+ Object.assign(TagClass, _context.TagProto);
+ Object.defineProperty(TagClass, "stack", {
+ get() {
+ return creationError.stack;
+ }
+ });
+ const hasDeps = "dependencies" in maker && maker.dependencies.length > 0;
+ const layerName = hasDeps ? "DefaultWithoutDependencies" : "Default";
+ let layerCache;
+ let isFunction = false;
+ if ("effect" in maker) {
+ isFunction = typeof maker.effect === "function";
+ Object.defineProperty(TagClass, layerName, {
+ get() {
+ if (isFunction) {
+ return function () {
+ return layer.fromEffect(TagClass, map(maker.effect.apply(null, arguments), _ => new this(_)));
+ }.bind(this);
+ }
+ return layerCache ??= layer.fromEffect(TagClass, map(maker.effect, _ => new this(_)));
+ }
+ });
+ } else if ("scoped" in maker) {
+ isFunction = typeof maker.scoped === "function";
+ Object.defineProperty(TagClass, layerName, {
+ get() {
+ if (isFunction) {
+ return function () {
+ return layer.scoped(TagClass, map(maker.scoped.apply(null, arguments), _ => new this(_)));
+ }.bind(this);
+ }
+ return layerCache ??= layer.scoped(TagClass, map(maker.scoped, _ => new this(_)));
+ }
+ });
+ } else if ("sync" in maker) {
+ Object.defineProperty(TagClass, layerName, {
+ get() {
+ return layerCache ??= layer.sync(TagClass, () => new this(maker.sync()));
+ }
+ });
+ } else {
+ Object.defineProperty(TagClass, layerName, {
+ get() {
+ return layerCache ??= layer.succeed(TagClass, new this(maker.succeed));
+ }
+ });
+ }
+ if (hasDeps) {
+ let layerWithDepsCache;
+ Object.defineProperty(TagClass, "Default", {
+ get() {
+ if (isFunction) {
+ return function () {
+ return layer.provide(this.DefaultWithoutDependencies.apply(null, arguments), maker.dependencies);
+ };
+ }
+ return layerWithDepsCache ??= layer.provide(this.DefaultWithoutDependencies, maker.dependencies);
+ }
+ });
+ }
+ return proxy === true ? makeTagProxy(TagClass) : TagClass;
+ };
+};
+/**
+ * The `Effect.fn` function allows you to create traced functions that return an
+ * effect. It provides two key features:
+ *
+ * - **Stack traces with location details** if an error occurs.
+ * - **Automatic span creation** for tracing when a span name is provided.
+ *
+ * If a span name is passed as the first argument, the function's execution is
+ * tracked using that name. If no name is provided, stack tracing still works,
+ * but spans are not created.
+ *
+ * A function can be defined using either:
+ *
+ * - A generator function, allowing the use of `yield*` for effect composition.
+ * - A regular function that returns an `Effect`.
+ *
+ * **Example** (Creating a Traced Function with a Span Name)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const myfunc = Effect.fn("myspan")(function* (n: N) {
+ * yield* Effect.annotateCurrentSpan("n", n) // Attach metadata to the span
+ * console.log(`got: ${n}`)
+ * yield* Effect.fail(new Error("Boom!")) // Simulate failure
+ * })
+ *
+ * Effect.runFork(myfunc(100).pipe(Effect.catchAllCause(Effect.logError)))
+ * // Output:
+ * // got: 100
+ * // timestamp=... level=ERROR fiber=#0 cause="Error: Boom!
+ * // at (/.../index.ts:6:22) <= Raise location
+ * // at myspan (/.../index.ts:3:23) <= Definition location
+ * // at myspan (/.../index.ts:9:16)" <= Call location
+ * ```
+ *
+ * `Effect.fn` automatically creates spans. The spans capture information about
+ * the function execution, including metadata and error details.
+ *
+ * **Example** (Exporting Spans to the Console)
+ *
+ * ```ts skip-type-checking
+ * import { Effect } from "effect"
+ * import { NodeSdk } from "@effect/opentelemetry"
+ * import {
+ * ConsoleSpanExporter,
+ * BatchSpanProcessor
+ * } from "@opentelemetry/sdk-trace-base"
+ *
+ * const myfunc = Effect.fn("myspan")(function* (n: N) {
+ * yield* Effect.annotateCurrentSpan("n", n)
+ * console.log(`got: ${n}`)
+ * yield* Effect.fail(new Error("Boom!"))
+ * })
+ *
+ * const program = myfunc(100)
+ *
+ * const NodeSdkLive = NodeSdk.layer(() => ({
+ * resource: { serviceName: "example" },
+ * // Export span data to the console
+ * spanProcessor: new BatchSpanProcessor(new ConsoleSpanExporter())
+ * }))
+ *
+ * Effect.runFork(program.pipe(Effect.provide(NodeSdkLive)))
+ * // Output:
+ * // got: 100
+ * // {
+ * // resource: {
+ * // attributes: {
+ * // 'service.name': 'example',
+ * // 'telemetry.sdk.language': 'nodejs',
+ * // 'telemetry.sdk.name': '@effect/opentelemetry',
+ * // 'telemetry.sdk.version': '1.30.1'
+ * // }
+ * // },
+ * // instrumentationScope: { name: 'example', version: undefined, schemaUrl: undefined },
+ * // traceId: '22801570119e57a6e2aacda3dec9665b',
+ * // parentId: undefined,
+ * // traceState: undefined,
+ * // name: 'myspan',
+ * // id: '7af530c1e01bc0cb',
+ * // kind: 0,
+ * // timestamp: 1741182277518402.2,
+ * // duration: 4300.416,
+ * // attributes: {
+ * // n: 100,
+ * // 'code.stacktrace': 'at (/.../index.ts:8:23)\n' +
+ * // 'at (/.../index.ts:14:17)'
+ * // },
+ * // status: { code: 2, message: 'Boom!' },
+ * // events: [
+ * // {
+ * // name: 'exception',
+ * // attributes: {
+ * // 'exception.type': 'Error',
+ * // 'exception.message': 'Boom!',
+ * // 'exception.stacktrace': 'Error: Boom!\n' +
+ * // ' at (/.../index.ts:11:22)\n' +
+ * // ' at myspan (/.../index.ts:8:23)\n' +
+ * // ' at myspan (/.../index.ts:14:17)'
+ * // },
+ * // time: [ 1741182277, 522702583 ],
+ * // droppedAttributesCount: 0
+ * // }
+ * // ],
+ * // links: []
+ * // }
+ * ```
+ *
+ * `Effect.fn` also acts as a pipe function, allowing you to create a pipeline
+ * after the function definition using the effect returned by the generator
+ * function as the starting value of the pipeline.
+ *
+ * **Example** (Creating a Traced Function with a Delay)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const myfunc = Effect.fn(
+ * function* (n: number) {
+ * console.log(`got: ${n}`)
+ * yield* Effect.fail(new Error("Boom!"))
+ * },
+ * // You can access both the created effect and the original arguments
+ * (effect, n) => Effect.delay(effect, `${n / 100} seconds`)
+ * )
+ *
+ * Effect.runFork(myfunc(100).pipe(Effect.catchAllCause(Effect.logError)))
+ * // Output:
+ * // got: 100
+ * // timestamp=... level=ERROR fiber=#0 cause="Error: Boom! (<= after 1 second)
+ * ```
+ *
+ * @see {@link fnUntraced} for a version of this function that doesn't add a span.
+ *
+ * @since 3.11.0
+ * @category Tracing
+ */
+exports.Service = Service;
+const fn = function (nameOrBody, ...pipeables) {
+ const limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 2;
+ const errorDef = new Error();
+ Error.stackTraceLimit = limit;
+ if (typeof nameOrBody !== "string") {
+ return defineLength(nameOrBody.length, function (...args) {
+ const limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 2;
+ const errorCall = new Error();
+ Error.stackTraceLimit = limit;
+ return fnApply({
+ self: this,
+ body: nameOrBody,
+ args,
+ pipeables,
+ spanName: "",
+ spanOptions: {
+ context: internalTracer.DisablePropagation.context(true)
+ },
+ errorDef,
+ errorCall
+ });
+ });
+ }
+ const name = nameOrBody;
+ const options = pipeables[0];
+ return (body, ...pipeables) => defineLength(body.length, {
+ [name](...args) {
+ const limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 2;
+ const errorCall = new Error();
+ Error.stackTraceLimit = limit;
+ return fnApply({
+ self: this,
+ body,
+ args,
+ pipeables,
+ spanName: name,
+ spanOptions: options,
+ errorDef,
+ errorCall
+ });
+ }
+ }[name]);
+};
+exports.fn = fn;
+function defineLength(length, fn) {
+ return Object.defineProperty(fn, "length", {
+ value: length,
+ configurable: true
+ });
+}
+function fnApply(options) {
+ let effect;
+ let fnError = undefined;
+ if ((0, _Utils.isGeneratorFunction)(options.body)) {
+ effect = core.fromIterator(() => options.body.apply(options.self, options.args));
+ } else {
+ try {
+ effect = options.body.apply(options.self, options.args);
+ } catch (error) {
+ fnError = error;
+ effect = die(error);
+ }
+ }
+ if (options.pipeables.length > 0) {
+ try {
+ for (const x of options.pipeables) {
+ effect = x(effect, ...options.args);
+ }
+ } catch (error) {
+ effect = fnError ? failCause(internalCause.sequential(internalCause.die(fnError), internalCause.die(error))) : die(error);
+ }
+ }
+ let cache = false;
+ const captureStackTrace = () => {
+ if (cache !== false) {
+ return cache;
+ }
+ if (options.errorCall.stack) {
+ const stackDef = options.errorDef.stack.trim().split("\n");
+ const stackCall = options.errorCall.stack.trim().split("\n");
+ let endStackDef = stackDef.slice(2).join("\n").trim();
+ if (!endStackDef.includes(`(`)) {
+ endStackDef = endStackDef.replace(/at (.*)/, "at ($1)");
+ }
+ let endStackCall = stackCall.slice(2).join("\n").trim();
+ if (!endStackCall.includes(`(`)) {
+ endStackCall = endStackCall.replace(/at (.*)/, "at ($1)");
+ }
+ cache = `${endStackDef}\n${endStackCall}`;
+ return cache;
+ }
+ };
+ const opts = options.spanOptions && "captureStackTrace" in options.spanOptions ? options.spanOptions : {
+ captureStackTrace,
+ ...options.spanOptions
+ };
+ return withSpan(effect, options.spanName, opts);
+}
+/**
+ * Same as {@link fn}, but allows you to create a function that is not traced, for when performance is critical.
+ *
+ * @see {@link fn} for a version that includes tracing.
+ *
+ * @since 3.12.0
+ * @category Tracing
+ */
+const fnUntraced = exports.fnUntraced = core.fnUntraced;
+// -----------------------------------------------------------------------------
+// Type constraints
+// -----------------------------------------------------------------------------
+/**
+ * A no-op type constraint that enforces the success channel of an Effect conforms to
+ * the specified success type `A`.
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * // Ensure that the program does not expose any unhandled errors.
+ * const program = Effect.succeed(42).pipe(Effect.ensureSuccessType())
+ *
+ * @since 3.17.0
+ * @category Type constraints
+ */
+const ensureSuccessType = () => effect => effect;
+/**
+ * A no-op type constraint that enforces the error channel of an Effect conforms to
+ * the specified error type `E`.
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * // Ensure that the program does not expose any unhandled errors.
+ * const program = Effect.succeed(42).pipe(Effect.ensureErrorType())
+ *
+ * @since 3.17.0
+ * @category Type constraints
+ */
+exports.ensureSuccessType = ensureSuccessType;
+const ensureErrorType = () => effect => effect;
+/**
+ * A no-op type constraint that enforces the requirements channel of an Effect conforms to
+ * the specified requirements type `R`.
+ *
+ * @example
+ * import { Effect } from "effect"
+ *
+ * // Ensure that the program does not have any requirements.
+ * const program = Effect.succeed(42).pipe(Effect.ensureRequirementsType())
+ *
+ * @since 3.17.0
+ * @category Type constraints
+ */
+exports.ensureErrorType = ensureErrorType;
+const ensureRequirementsType = () => effect => effect;
+exports.ensureRequirementsType = ensureRequirementsType;
+//# sourceMappingURL=Effect.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Effect.js.map b/backend/node_modules/effect/dist/cjs/Effect.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..bf75b724f4d496f1874d5bc5e590ad3a31b44277
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Effect.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Effect.js","names":["_Function","require","internalCause","_interopRequireWildcard","console_","_context","effect","core","defaultServices","circular","internalExecutionPlan","fiberRuntime","layer","option_","query","runtime_","schedule_","internalTracer","Random","Request","Scheduler","_Utils","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","EffectTypeId","exports","isEffect","cachedWithTTL","cached","cachedInvalidateWithTTL","memoize","cachedFunction","once","all","allWith","allSuccesses","dropUntil","dropWhile","takeUntil","takeWhile","every","exists","filter","filterMap","findFirst","forEach","head","mergeAll","partition","reduce","reduceWhile","reduceRight","reduceEffect","replicate","replicateEffect","validateAll","validateFirst","async","asyncEffect","custom","withFiberRuntime","fail","failSync","failCause","failCauseSync","die","dieMessage","dieSync","gen","never","none","promise","succeed","succeedNone","succeedSome","suspend","sync","_void","void","yieldNow","_catch","catch","catchAll","catchAllCause","catchAllDefect","catchIf","catchSome","catchSomeCause","catchSomeDefect","catchTag","catchTags","cause","eventually","ignore","ignoreLogged","parallelErrors","sandbox","retry","retry_combined","withExecutionPlan","retryOrElse","retryOrElse_Effect","try_","try","tryMap","tryMapPromise","tryPromise","unsandbox","allowInterrupt","checkInterruptible","disconnect","interrupt","interruptWith","interruptible","interruptibleMask","onInterrupt","uninterruptible","uninterruptibleMask","liftPredicate","as","asSome","asSomeError","asVoid","flip","flipWith","map","mapAccum","mapBoth","mapError","mapErrorCause","merge","negate","acquireRelease","acquireReleaseInterruptible","acquireUseRelease","addFinalizer","ensuring","onError","onExit","parallelFinalizers","sequentialFinalizers","finalizersMask","scope","scopeWith","scopedWith","scoped","scopedEffect","using","withEarlyRelease","awaitAllChildren","daemonChildren","descriptor","descriptorWith","diffFiberRefs","ensuringChild","ensuringChildren","fiberId","fiberIdWith","fork","forkDaemon","forkAll","forkIn","forkScoped","forkWithErrorHandler","fromFiber","fromFiberEffect","supervised","transplant","withConcurrency","withScheduler","withSchedulingPriority","withMaxOpsBeforeYield","clock","clockWith","withClockScoped","withClock","console","consoleWith","withConsoleScoped","withConsole","delay","sleep","timed","timedWith","timeout","timeoutOption","timeoutFail","timeoutFailCause","timeoutTo","configProviderWith","withConfigProvider","withConfigProviderScoped","context","contextWith","contextWithEffect","mapInputContext","provide","effect_provide","provideService","provideServiceEffect","serviceFunction","serviceFunctionEffect","serviceFunctions","serviceConstants","serviceMembers","serviceOption","serviceOptional","updateService","Do","bind","bindAll","bindTo","let_","let","option","either","exit","intoDeferred","if_","if","filterOrDie","filterOrDieMessage","filterOrElse","filterOrFail","filterEffectOrElse","filterEffectOrFail","unless","unlessEffect","when","whenEffect","whenFiberRef","whenRef","flatMap","andThen","flatten","race","raceAll","raceFirst","raceWith","summarized","tap","tapBoth","tapDefect","tapError","tapErrorTag","tapErrorCause","forever","iterate","loop","repeat","repeat_combined","repeatN","repeatOrElse","repeatOrElse_Effect","schedule","schedule_Effect","scheduleForked","scheduleFrom","scheduleFrom_Effect","whileLoop","getFiberRefs","fiberRefs","inheritFiberRefs","locally","fiberRefLocally","locallyWith","fiberRefLocallyWith","locallyScoped","fiberRefLocallyScoped","locallyScopedWith","fiberRefLocallyScopedWith","patchFiberRefs","setFiberRefs","updateFiberRefs","isFailure","isSuccess","match","matchCause","matchCauseEffect","matchEffect","log","logWithLevel","level","message","logTrace","logDebug","logInfo","logWarning","logError","logFatal","withLogSpan","annotateLogs","annotateLogsScoped","logAnnotations","withUnhandledErrorLogLevel","whenLogLevel","orDie","orDieWith","orElse","orElseFail","orElseSucceed","firstSuccessOf","random","randomWith","withRandom","withRandomFixed","dual","values","fixed","withRandomScoped","runtime","getRuntimeFlags","runtimeFlags","patchRuntimeFlags","updateRuntimeFlags","withRuntimeFlagsPatch","withRuntimeFlags","withRuntimeFlagsPatchScoped","withRuntimeFlagsScoped","tagMetrics","labelMetrics","tagMetricsScoped","labelMetricsScoped","metricLabels","withMetric","unsafeMakeSemaphore","makeSemaphore","unsafeMakeLatch","makeLatch","runFork","unsafeForkEffect","runCallback","unsafeRunEffect","runPromise","unsafeRunPromiseEffect","runPromiseExit","unsafeRunPromiseExitEffect","runSync","unsafeRunSyncEffect","runSyncExit","unsafeRunSyncExitEffect","validate","validateWith","zip","zipOptions","zipLeft","zipLeftOptions","zipRight","zipRightOptions","zipWith","zipWithOptions","ap","self","that","a","blocked","runRequestBlock","step","request","args","isRequest","fromRequest","cacheRequestResult","cacheRequest","withRequestBatching","withRequestCaching","withRequestCache","tracer","tracerWith","withTracer","withTracerScoped","withTracerEnabled","withTracerTiming","annotateSpans","annotateCurrentSpan","currentSpan","currentPropagatedSpan","currentParentSpan","spanAnnotations","spanLinks","linkSpans","linkSpanCurrent","makeSpan","makeSpanScoped","useSpan","withSpan","functionWithSpan","withSpanScoped","withParentSpan","fromNullable","optionFromOptional","transposeOption","isNone","value","some","transposeMapOption","makeTagProxy","TagClass","cache","Map","Proxy","target","prop","receiver","Reflect","fn","s","cn","assign","apply","proto","setPrototypeOf","getPrototypeOf","Tag","id","limit","Error","stackTraceLimit","creationError","TagProto","key","body","stack","Service","maker","arguments","proxy","patchState","service","prototype","selfProto","_tag","hasDeps","dependencies","length","layerName","layerCache","isFunction","fromEffect","_","layerWithDepsCache","DefaultWithoutDependencies","nameOrBody","pipeables","errorDef","defineLength","errorCall","fnApply","spanName","spanOptions","DisablePropagation","name","options","configurable","fnError","undefined","isGeneratorFunction","fromIterator","error","x","sequential","captureStackTrace","stackDef","trim","split","stackCall","endStackDef","slice","join","includes","replace","endStackCall","opts","fnUntraced","ensureSuccessType","ensureErrorType","ensureRequirementsType"],"sources":["../../src/Effect.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Effectable.js b/backend/node_modules/effect/dist/cjs/Effectable.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e1420fa9e62737acf8b849c4b67bb340208a00b
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Effectable.js
@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.StructuralCommitPrototype = exports.StructuralClass = exports.StreamTypeId = exports.SinkTypeId = exports.EffectTypeId = exports.EffectPrototype = exports.CommitPrototype = exports.Class = exports.ChannelTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/effectable.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+const EffectTypeId = exports.EffectTypeId = internal.EffectTypeId;
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+const StreamTypeId = exports.StreamTypeId = internal.StreamTypeId;
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+const SinkTypeId = exports.SinkTypeId = internal.SinkTypeId;
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+const ChannelTypeId = exports.ChannelTypeId = internal.ChannelTypeId;
+/**
+ * @since 2.0.0
+ * @category prototypes
+ */
+const EffectPrototype = exports.EffectPrototype = internal.EffectPrototype;
+/**
+ * @since 2.0.0
+ * @category prototypes
+ */
+const CommitPrototype = exports.CommitPrototype = internal.CommitPrototype;
+/**
+ * @since 2.0.0
+ * @category prototypes
+ */
+const StructuralCommitPrototype = exports.StructuralCommitPrototype = internal.StructuralCommitPrototype;
+const Base = internal.Base;
+const StructuralBase = internal.StructuralBase;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+class Class extends Base {}
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+exports.Class = Class;
+class StructuralClass extends StructuralBase {}
+exports.StructuralClass = StructuralClass;
+//# sourceMappingURL=Effectable.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Effectable.js.map b/backend/node_modules/effect/dist/cjs/Effectable.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..85473fd382688f5b1486564479f5d9de15e2ec6a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Effectable.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Effectable.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","EffectTypeId","exports","StreamTypeId","SinkTypeId","ChannelTypeId","EffectPrototype","CommitPrototype","StructuralCommitPrototype","Base","StructuralBase","Class","StructuralClass"],"sources":["../../src/Effectable.ts"],"sourcesContent":[null],"mappings":";;;;;;AAKA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAoD,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAIpD;;;;AAIO,MAAMkB,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAwBtB,QAAQ,CAACsB,YAAY;AAQtE;;;;AAIO,MAAME,YAAY,GAAAD,OAAA,CAAAC,YAAA,GAAwBxB,QAAQ,CAACwB,YAAY;AAQtE;;;;AAIO,MAAMC,UAAU,GAAAF,OAAA,CAAAE,UAAA,GAAoBzB,QAAQ,CAACyB,UAAU;AAQ9D;;;;AAIO,MAAMC,aAAa,GAAAH,OAAA,CAAAG,aAAA,GAA0B1B,QAAQ,CAAC0B,aAAa;AAgB1E;;;;AAIO,MAAMC,eAAe,GAAAJ,OAAA,CAAAI,eAAA,GAAyB3B,QAAQ,CAAC2B,eAAe;AAE7E;;;;AAIO,MAAMC,eAAe,GAAAL,OAAA,CAAAK,eAAA,GAAyB5B,QAAQ,CAAC4B,eAAe;AAE7E;;;;AAIO,MAAMC,yBAAyB,GAAAN,OAAA,CAAAM,yBAAA,GAAyB7B,QAAQ,CAAC6B,yBAAyB;AAEjG,MAAMC,IAAI,GAAoB9B,QAAQ,CAAC8B,IAAI;AAC3C,MAAMC,cAAc,GAAoB/B,QAAQ,CAAC+B,cAAc;AAE/D;;;;AAIM,MAAgBC,KAA+B,SAAQF,IAAa;AAO1E;;;;AAAAP,OAAA,CAAAS,KAAA,GAAAA,KAAA;AAIM,MAAgBC,eAAyC,SAAQF,cAAuB;AAAAR,OAAA,CAAAU,eAAA,GAAAA,eAAA","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Either.js b/backend/node_modules/effect/dist/cjs/Either.js
new file mode 100644
index 0000000000000000000000000000000000000000..987a04e76ef329d92ed0c230171147cc77398146
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Either.js
@@ -0,0 +1,654 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zipWith = exports.void = exports.try = exports.transposeOption = exports.transposeMapOption = exports.right = exports.orElse = exports.merge = exports.match = exports.mapLeft = exports.mapBoth = exports.map = exports.liftPredicate = exports.let = exports.left = exports.isRight = exports.isLeft = exports.isEither = exports.getRight = exports.getOrUndefined = exports.getOrThrowWith = exports.getOrThrow = exports.getOrNull = exports.getOrElse = exports.getLeft = exports.getEquivalence = exports.gen = exports.fromOption = exports.fromNullable = exports.flip = exports.flatMap = exports.filterOrLeft = exports.bindTo = exports.bind = exports.ap = exports.andThen = exports.all = exports.TypeId = exports.Do = void 0;
+var Equivalence = _interopRequireWildcard(require("./Equivalence.js"));
+var _Function = require("./Function.js");
+var doNotation = _interopRequireWildcard(require("./internal/doNotation.js"));
+var either = _interopRequireWildcard(require("./internal/either.js"));
+var option_ = _interopRequireWildcard(require("./internal/option.js"));
+var _Predicate = require("./Predicate.js");
+var Gen = _interopRequireWildcard(require("./Utils.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category symbols
+ * @since 2.0.0
+ */
+const TypeId = exports.TypeId = either.TypeId;
+/**
+ * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias
+ * of this structure.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const right = exports.right = either.right;
+const void_ = exports.void = /*#__PURE__*/right(void 0);
+/**
+ * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this
+ * structure.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const left = exports.left = either.left;
+/**
+ * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use
+ * the provided default as a `Left`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
+ * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback'))
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const fromNullable = exports.fromNullable = /*#__PURE__*/(0, _Function.dual)(2, (self, onNullable) => self == null ? left(onNullable(self)) : right(self));
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, Option } from "effect"
+ *
+ * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
+ * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error'))
+ * ```
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const fromOption = exports.fromOption = either.fromOption;
+const try_ = evaluate => {
+ if ((0, _Predicate.isFunction)(evaluate)) {
+ try {
+ return right(evaluate());
+ } catch (e) {
+ return left(e);
+ }
+ } else {
+ try {
+ return right(evaluate.try());
+ } catch (e) {
+ return left(evaluate.catch(e));
+ }
+ }
+};
+exports.try = try_;
+/**
+ * Tests if a value is a `Either`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.isEither(Either.right(1)), true)
+ * assert.deepStrictEqual(Either.isEither(Either.left("a")), true)
+ * assert.deepStrictEqual(Either.isEither({ right: 1 }), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isEither = exports.isEither = either.isEither;
+/**
+ * Determine if a `Either` is a `Left`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.isLeft(Either.right(1)), false)
+ * assert.deepStrictEqual(Either.isLeft(Either.left("a")), true)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isLeft = exports.isLeft = either.isLeft;
+/**
+ * Determine if a `Either` is a `Right`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.isRight(Either.right(1)), true)
+ * assert.deepStrictEqual(Either.isRight(Either.left("a")), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isRight = exports.isRight = either.isRight;
+/**
+ * Converts a `Either` to an `Option` discarding the `Left`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, Option } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getRight(Either.right('ok')), Option.some('ok'))
+ * assert.deepStrictEqual(Either.getRight(Either.left('err')), Option.none())
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getRight = exports.getRight = either.getRight;
+/**
+ * Converts a `Either` to an `Option` discarding the value.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, Option } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getLeft(Either.right('ok')), Option.none())
+ * assert.deepStrictEqual(Either.getLeft(Either.left('err')), Option.some('err'))
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getLeft = exports.getLeft = either.getLeft;
+/**
+ * @category equivalence
+ * @since 2.0.0
+ */
+const getEquivalence = ({
+ left,
+ right
+}) => Equivalence.make((x, y) => isLeft(x) ? isLeft(y) && left(x.left, y.left) : isRight(y) && right(x.right, y.right));
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+exports.getEquivalence = getEquivalence;
+const mapBoth = exports.mapBoth = /*#__PURE__*/(0, _Function.dual)(2, (self, {
+ onLeft,
+ onRight
+}) => isLeft(self) ? left(onLeft(self.left)) : right(onRight(self.right)));
+/**
+ * Maps the `Left` side of an `Either` value to a new `Either` value.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+const mapLeft = exports.mapLeft = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => isLeft(self) ? left(f(self.left)) : right(self.right));
+/**
+ * Maps the `Right` side of an `Either` value to a new `Either` value.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => isRight(self) ? right(f(self.right)) : left(self.left));
+/**
+ * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function,
+ * if the value is a `Right` the inner value is applied to the `onRight` function.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Either } from "effect"
+ *
+ * const onLeft = (strings: ReadonlyArray): string => `strings: ${strings.join(', ')}`
+ *
+ * const onRight = (value: number): string => `Ok: ${value}`
+ *
+ * assert.deepStrictEqual(pipe(Either.right(1), Either.match({ onLeft, onRight })), 'Ok: 1')
+ * assert.deepStrictEqual(
+ * pipe(Either.left(['string 1', 'string 2']), Either.match({ onLeft, onRight })),
+ * 'strings: string 1, string 2'
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 2.0.0
+ */
+const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, {
+ onLeft,
+ onRight
+}) => isLeft(self) ? onLeft(self.left) : onRight(self.right));
+/**
+ * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
+ * or `Left` of the result of the provided function if the predicate returns false
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Either } from "effect"
+ *
+ * const isPositive = (n: number): boolean => n > 0
+ * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`)
+ *
+ * assert.deepStrictEqual(
+ * isPositiveEither(1),
+ * Either.right(1)
+ * )
+ * assert.deepStrictEqual(
+ * isPositiveEither(0),
+ * Either.left("0 is not positive")
+ * )
+ * ```
+ *
+ * @category lifting
+ * @since 3.4.0
+ */
+const liftPredicate = exports.liftPredicate = /*#__PURE__*/(0, _Function.dual)(3, (a, predicate, orLeftWith) => predicate(a) ? right(a) : left(orLeftWith(a)));
+/**
+ * Filter the right value with the provided function.
+ * If the predicate fails, set the left value with the result of the provided function.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, Either } from "effect"
+ *
+ * const isPositive = (n: number): boolean => n > 0
+ *
+ * assert.deepStrictEqual(
+ * pipe(
+ * Either.right(1),
+ * Either.filterOrLeft(isPositive, n => `${n} is not positive`)
+ * ),
+ * Either.right(1)
+ * )
+ * assert.deepStrictEqual(
+ * pipe(
+ * Either.right(0),
+ * Either.filterOrLeft(isPositive, n => `${n} is not positive`)
+ * ),
+ * Either.left("0 is not positive")
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category filtering & conditionals
+ */
+const filterOrLeft = exports.filterOrLeft = /*#__PURE__*/(0, _Function.dual)(3, (self, predicate, orLeftWith) => flatMap(self, r => predicate(r) ? right(r) : left(orLeftWith(r))));
+/**
+ * @category getters
+ * @since 2.0.0
+ */
+const merge = exports.merge = /*#__PURE__*/match({
+ onLeft: _Function.identity,
+ onRight: _Function.identity
+});
+/**
+ * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
+ * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!")
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrElse = exports.getOrElse = /*#__PURE__*/(0, _Function.dual)(2, (self, onLeft) => isLeft(self) ? onLeft(self.left) : self.right);
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getOrNull(Either.right(1)), 1)
+ * assert.deepStrictEqual(Either.getOrNull(Either.left("a")), null)
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrNull = exports.getOrNull = /*#__PURE__*/getOrElse(_Function.constNull);
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1)
+ * assert.deepStrictEqual(Either.getOrUndefined(Either.left("a")), undefined)
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrUndefined = exports.getOrUndefined = /*#__PURE__*/getOrElse(_Function.constUndefined);
+/**
+ * Extracts the value of an `Either` or throws if the `Either` is `Left`.
+ *
+ * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(
+ * Either.getOrThrowWith(Either.right(1), () => new Error('Unexpected Left')),
+ * 1
+ * )
+ * assert.throws(() => Either.getOrThrowWith(Either.left("error"), () => new Error('Unexpected Left')))
+ * ```
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrThrowWith = exports.getOrThrowWith = /*#__PURE__*/(0, _Function.dual)(2, (self, onLeft) => {
+ if (isRight(self)) {
+ return self.right;
+ }
+ throw onLeft(self.left);
+});
+// TODO(4.0): by default should throw `L` (i.e getOrThrowWith with the identity function)
+/**
+ * Extracts the value of an `Either` or throws if the `Either` is `Left`.
+ *
+ * The thrown error is a default error. To configure the error thrown, see {@link getOrThrowWith}.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.getOrThrow(Either.right(1)), 1)
+ * assert.throws(() => Either.getOrThrow(Either.left("error")))
+ * ```
+ *
+ * @throws `Error("getOrThrow called on a Left")`
+ *
+ * @category getters
+ * @since 2.0.0
+ */
+const getOrThrow = exports.getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error("getOrThrow called on a Left"));
+/**
+ * Returns `self` if it is a `Right` or `that` otherwise.
+ *
+ * @category error handling
+ * @since 2.0.0
+ */
+const orElse = exports.orElse = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => isLeft(self) ? that(self.left) : right(self.right));
+/**
+ * @category sequencing
+ * @since 2.0.0
+ */
+const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => isLeft(self) ? left(self.left) : f(self.right));
+/**
+ * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+const andThen = exports.andThen = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => flatMap(self, a => {
+ const b = (0, _Predicate.isFunction)(f) ? f(a) : f;
+ return isEither(b) ? b : right(b);
+}));
+/**
+ * @category zipping
+ * @since 2.0.0
+ */
+const zipWith = exports.zipWith = /*#__PURE__*/(0, _Function.dual)(3, (self, that, f) => flatMap(self, r => map(that, r2 => f(r, r2))));
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const ap = exports.ap = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
+/**
+ * Takes a structure of `Either`s and returns an `Either` of values with the same structure.
+ *
+ * - If a tuple is supplied, then the returned `Either` will contain a tuple with the same length.
+ * - If a struct is supplied, then the returned `Either` will contain a struct with the same keys.
+ * - If an iterable is supplied, then the returned `Either` will contain an array.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either } from "effect"
+ *
+ * assert.deepStrictEqual(Either.all([Either.right(1), Either.right(2)]), Either.right([1, 2]))
+ * assert.deepStrictEqual(Either.all({ right: Either.right(1), b: Either.right("hello") }), Either.right({ right: 1, b: "hello" }))
+ * assert.deepStrictEqual(Either.all({ right: Either.right(1), b: Either.left("error") }), Either.left("error"))
+ * ```
+ *
+ * @category combining
+ * @since 2.0.0
+ */
+// @ts-expect-error
+const all = input => {
+ if (Symbol.iterator in input) {
+ const out = [];
+ for (const e of input) {
+ if (isLeft(e)) {
+ return e;
+ }
+ out.push(e.right);
+ }
+ return right(out);
+ }
+ const out = {};
+ for (const key of Object.keys(input)) {
+ const e = input[key];
+ if (isLeft(e)) {
+ return e;
+ }
+ out[key] = e.right;
+ }
+ return right(out);
+};
+/**
+ * Returns an `Either` that swaps the error/success cases. This allows you to
+ * use all methods on the error channel, possibly before flipping back.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+exports.all = all;
+const flip = self => isLeft(self) ? right(self.left) : left(self.right);
+exports.flip = flip;
+const adapter = /*#__PURE__*/Gen.adapter();
+/**
+ * @category generators
+ * @since 2.0.0
+ */
+const gen = (...args) => {
+ const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
+ const iterator = f(adapter);
+ let state = iterator.next();
+ while (!state.done) {
+ const current = Gen.isGenKind(state.value) ? state.value.value : Gen.yieldWrapGet(state.value);
+ if (isLeft(current)) {
+ return current;
+ }
+ state = iterator.next(current.right);
+ }
+ return right(state.value);
+};
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Either` 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
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Either.Do,
+ * Either.bind("x", () => Either.right(2)),
+ * Either.bind("y", () => Either.right(3)),
+ * Either.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 }))
+ * ```
+ *
+ * @see {@link bind}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 2.0.0
+ */
+exports.gen = gen;
+const Do = exports.Do = /*#__PURE__*/right({});
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Either` 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
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Either.Do,
+ * Either.bind("x", () => Either.right(2)),
+ * Either.bind("y", () => Either.right(3)),
+ * Either.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 }))
+ * ```
+ *
+ * @see {@link Do}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 2.0.0
+ */
+const bind = exports.bind = /*#__PURE__*/doNotation.bind(map, flatMap);
+/**
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ *
+ * 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 `Either` 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
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Either, pipe } from "effect"
+ *
+ * const result = pipe(
+ * Either.Do,
+ * Either.bind("x", () => Either.right(2)),
+ * Either.bind("y", () => Either.right(3)),
+ * Either.let("sum", ({ x, y }) => x + y)
+ * )
+ * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 }))
+ * ```
+ *
+ * @see {@link Do}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
+ * @category do notation
+ * @since 2.0.0
+ */
+const bindTo = exports.bindTo = /*#__PURE__*/doNotation.bindTo(map);
+const let_ = exports.let = /*#__PURE__*/doNotation.let_(map);
+/**
+ * Converts an `Option` of an `Either` into an `Either` of an `Option`.
+ *
+ * **Details**
+ *
+ * This function transforms an `Option>` into an
+ * `Either, E>`. If the `Option` is `None`, the resulting `Either`
+ * will be a `Right` with a `None` value. If the `Option` is `Some`, the
+ * inner `Either` will be executed, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Either, Option } from "effect"
+ *
+ * // ┌─── Option>
+ * // ▼
+ * const maybe = Option.some(Either.right(42))
+ *
+ * // ┌─── Either, never, never>
+ * // ▼
+ * const result = Either.transposeOption(maybe)
+ *
+ * console.log(Effect.runSync(result))
+ * // Output: { _id: 'Option', _tag: 'Some', value: 42 }
+ * ```
+ *
+ * @since 3.14.0
+ * @category Optional Wrapping & Unwrapping
+ */
+const transposeOption = self => {
+ return option_.isNone(self) ? right(option_.none) : map(self.value, option_.some);
+};
+/**
+ * Applies an `Either` on an `Option` and transposes the result.
+ *
+ * **Details**
+ *
+ * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+ * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Either, Option, pipe } from "effect"
+ *
+ * // ┌─── Either, never>>
+ * // ▼
+ * const noneResult = pipe(
+ * Option.none(),
+ * Either.transposeMapOption(() => Either.right(42)) // will not be executed
+ * )
+ * console.log(noneResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+ *
+ * // ┌─── Either, never>>
+ * // ▼
+ * const someRightResult = pipe(
+ * Option.some(42),
+ * Either.transposeMapOption((value) => Either.right(value * 2))
+ * )
+ * console.log(someRightResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+ * ```
+ *
+ * @since 3.15.0
+ * @category Optional Wrapping & Unwrapping
+ */
+exports.transposeOption = transposeOption;
+const transposeMapOption = exports.transposeMapOption = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => option_.isNone(self) ? right(option_.none) : map(f(self.value), option_.some));
+//# sourceMappingURL=Either.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Encoding.js b/backend/node_modules/effect/dist/cjs/Encoding.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fde178e6e2bea498e8634581da5d53a917d0f4d
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Encoding.js
@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.isEncodeException = exports.isDecodeException = exports.encodeUriComponent = exports.encodeHex = exports.encodeBase64Url = exports.encodeBase64 = exports.decodeUriComponent = exports.decodeHexString = exports.decodeHex = exports.decodeBase64UrlString = exports.decodeBase64Url = exports.decodeBase64String = exports.decodeBase64 = exports.EncodeExceptionTypeId = exports.EncodeException = exports.DecodeExceptionTypeId = exports.DecodeException = void 0;
+var Either = _interopRequireWildcard(require("./Either.js"));
+var Base64 = _interopRequireWildcard(require("./internal/encoding/base64.js"));
+var Base64Url = _interopRequireWildcard(require("./internal/encoding/base64Url.js"));
+var Common = _interopRequireWildcard(require("./internal/encoding/common.js"));
+var Hex = _interopRequireWildcard(require("./internal/encoding/hex.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * This module provides encoding & decoding functionality for:
+ *
+ * - base64 (RFC4648)
+ * - base64 (URL)
+ * - hex
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Encodes the given value into a base64 (RFC4648) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+const encodeBase64 = input => typeof input === "string" ? Base64.encode(Common.encoder.encode(input)) : Base64.encode(input);
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.encodeBase64 = encodeBase64;
+const decodeBase64 = str => Base64.decode(str);
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.decodeBase64 = decodeBase64;
+const decodeBase64String = str => Either.map(decodeBase64(str), _ => Common.decoder.decode(_));
+/**
+ * Encodes the given value into a base64 (URL) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+exports.decodeBase64String = decodeBase64String;
+const encodeBase64Url = input => typeof input === "string" ? Base64Url.encode(Common.encoder.encode(input)) : Base64Url.encode(input);
+/**
+ * Decodes a base64 (URL) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.encodeBase64Url = encodeBase64Url;
+const decodeBase64Url = str => Base64Url.decode(str);
+/**
+ * Decodes a base64 (URL) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.decodeBase64Url = decodeBase64Url;
+const decodeBase64UrlString = str => Either.map(decodeBase64Url(str), _ => Common.decoder.decode(_));
+/**
+ * Encodes the given value into a hex `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+exports.decodeBase64UrlString = decodeBase64UrlString;
+const encodeHex = input => typeof input === "string" ? Hex.encode(Common.encoder.encode(input)) : Hex.encode(input);
+/**
+ * Decodes a hex encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.encodeHex = encodeHex;
+const decodeHex = str => Hex.decode(str);
+/**
+ * Decodes a hex encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+exports.decodeHex = decodeHex;
+const decodeHexString = str => Either.map(decodeHex(str), _ => Common.decoder.decode(_));
+/**
+ * Encodes a UTF-8 `string` into a URI component `string`.
+ *
+ * @category encoding
+ * @since 3.12.0
+ */
+exports.decodeHexString = decodeHexString;
+const encodeUriComponent = str => Either.try({
+ try: () => encodeURIComponent(str),
+ catch: e => EncodeException(str, e instanceof Error ? e.message : "Invalid input")
+});
+/**
+ * Decodes a URI component `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 3.12.0
+ */
+exports.encodeUriComponent = encodeUriComponent;
+const decodeUriComponent = str => Either.try({
+ try: () => decodeURIComponent(str),
+ catch: e => DecodeException(str, e instanceof Error ? e.message : "Invalid input")
+});
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+exports.decodeUriComponent = decodeUriComponent;
+const DecodeExceptionTypeId = exports.DecodeExceptionTypeId = Common.DecodeExceptionTypeId;
+/**
+ * Creates a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const DecodeException = exports.DecodeException = Common.DecodeException;
+/**
+ * Returns `true` if the specified value is an `DecodeException`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isDecodeException = exports.isDecodeException = Common.isDecodeException;
+/**
+ * @since 3.12.0
+ * @category symbols
+ */
+const EncodeExceptionTypeId = exports.EncodeExceptionTypeId = Common.EncodeExceptionTypeId;
+/**
+ * Creates a checked exception which occurs when encoding fails.
+ *
+ * @since 3.12.0
+ * @category errors
+ */
+const EncodeException = exports.EncodeException = Common.EncodeException;
+/**
+ * Returns `true` if the specified value is an `EncodeException`, `false` otherwise.
+ *
+ * @since 3.12.0
+ * @category refinements
+ */
+const isEncodeException = exports.isEncodeException = Common.isEncodeException;
+//# sourceMappingURL=Encoding.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Encoding.js.map b/backend/node_modules/effect/dist/cjs/Encoding.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..ec3cd16ae04e366f836837613012dad484decd7d
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Encoding.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Encoding.js","names":["Either","_interopRequireWildcard","require","Base64","Base64Url","Common","Hex","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","encodeBase64","input","encode","encoder","exports","decodeBase64","str","decode","decodeBase64String","map","_","decoder","encodeBase64Url","decodeBase64Url","decodeBase64UrlString","encodeHex","decodeHex","decodeHexString","encodeUriComponent","try","encodeURIComponent","catch","EncodeException","Error","message","decodeUriComponent","decodeURIComponent","DecodeException","DecodeExceptionTypeId","isDecodeException","EncodeExceptionTypeId","isEncodeException"],"sources":["../../src/Encoding.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Equal.js b/backend/node_modules/effect/dist/cjs/Equal.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d65ed256b89614b0df670db452d1f403530c984
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Equal.js
@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.equals = equals;
+exports.symbol = exports.isEqual = exports.equivalence = void 0;
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Predicate = require("./Predicate.js");
+var _Utils = require("./Utils.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const symbol = exports.symbol = /*#__PURE__*/Symbol.for("effect/Equal");
+function equals() {
+ if (arguments.length === 1) {
+ return self => compareBoth(self, arguments[0]);
+ }
+ return compareBoth(arguments[0], arguments[1]);
+}
+function compareBoth(self, that) {
+ if (self === that) {
+ return true;
+ }
+ const selfType = typeof self;
+ if (selfType !== typeof that) {
+ return false;
+ }
+ if (selfType === "object" || selfType === "function") {
+ if (self !== null && that !== null) {
+ if (isEqual(self) && isEqual(that)) {
+ if (Hash.hash(self) === Hash.hash(that) && self[symbol](that)) {
+ return true;
+ } else {
+ return _Utils.structuralRegionState.enabled && _Utils.structuralRegionState.tester ? _Utils.structuralRegionState.tester(self, that) : false;
+ }
+ } else if (self instanceof Date && that instanceof Date) {
+ const t1 = self.getTime();
+ const t2 = that.getTime();
+ return t1 === t2 || Number.isNaN(t1) && Number.isNaN(t2);
+ } else if (self instanceof URL && that instanceof URL) {
+ return self.href === that.href;
+ }
+ }
+ if (_Utils.structuralRegionState.enabled) {
+ if (self === null || that === null) {
+ return false;
+ }
+ if (Array.isArray(self) && Array.isArray(that)) {
+ return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
+ }
+ if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(that) === Object.prototype) {
+ const keysSelf = Object.keys(self);
+ const keysThat = Object.keys(that);
+ if (keysSelf.length === keysThat.length) {
+ for (const key of keysSelf) {
+ // @ts-expect-error
+ if (!(key in that && compareBoth(self[key], that[key]))) {
+ return _Utils.structuralRegionState.tester ? _Utils.structuralRegionState.tester(self, that) : false;
+ }
+ }
+ return true;
+ }
+ }
+ return _Utils.structuralRegionState.tester ? _Utils.structuralRegionState.tester(self, that) : false;
+ }
+ }
+ return _Utils.structuralRegionState.enabled && _Utils.structuralRegionState.tester ? _Utils.structuralRegionState.tester(self, that) : false;
+}
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+const isEqual = u => (0, _Predicate.hasProperty)(u, symbol);
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+exports.isEqual = isEqual;
+const equivalence = () => equals;
+exports.equivalence = equivalence;
+//# sourceMappingURL=Equal.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Equal.js.map b/backend/node_modules/effect/dist/cjs/Equal.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..4a34c3c998f14d11f1ae67e5594b741730e4b8f2
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Equal.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Equal.js","names":["Hash","_interopRequireWildcard","require","_Predicate","_Utils","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","symbol","exports","Symbol","for","equals","arguments","length","self","compareBoth","that","selfType","isEqual","hash","structuralRegionState","enabled","tester","Date","t1","getTime","t2","Number","isNaN","URL","href","Array","isArray","every","v","getPrototypeOf","prototype","keysSelf","keys","keysThat","key","u","hasProperty","equivalence"],"sources":["../../src/Equal.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Equivalence.js b/backend/node_modules/effect/dist/cjs/Equivalence.js
new file mode 100644
index 0000000000000000000000000000000000000000..e391e4791d6857ad9bbfcfa3545a17b7665d1146
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Equivalence.js
@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.tuple = exports.symbol = exports.struct = exports.string = exports.strict = exports.productMany = exports.product = exports.number = exports.mapInput = exports.make = exports.combineMany = exports.combineAll = exports.combine = exports.boolean = exports.bigint = exports.array = exports.all = exports.Date = void 0;
+var _Function = require("./Function.js");
+/**
+ * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
+ * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
+ * These properties are also known in mathematics as an "equivalence relation".
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+const make = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
+exports.make = make;
+const isStrictEquivalent = (x, y) => x === y;
+/**
+ * Return an `Equivalence` that uses strict equality (===) to compare values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const strict = () => isStrictEquivalent;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+exports.strict = strict;
+const string = exports.string = /*#__PURE__*/strict();
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const number = exports.number = /*#__PURE__*/strict();
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const boolean = exports.boolean = /*#__PURE__*/strict();
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const bigint = exports.bigint = /*#__PURE__*/strict();
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const symbol = exports.symbol = /*#__PURE__*/strict();
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const combine = exports.combine = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => make((x, y) => self(x, y) && that(x, y)));
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const combineMany = exports.combineMany = /*#__PURE__*/(0, _Function.dual)(2, (self, collection) => make((x, y) => {
+ if (!self(x, y)) {
+ return false;
+ }
+ for (const equivalence of collection) {
+ if (!equivalence(x, y)) {
+ return false;
+ }
+ }
+ return true;
+}));
+const isAlwaysEquivalent = (_x, _y) => true;
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const combineAll = collection => combineMany(isAlwaysEquivalent, collection);
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+exports.combineAll = combineAll;
+const mapInput = exports.mapInput = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => make((x, y) => self(f(x), f(y))));
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+const Date = exports.Date = /*#__PURE__*/mapInput(number, date => date.getTime());
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const product = exports.product = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => make(([xa, xb], [ya, yb]) => self(xa, ya) && that(xb, yb)));
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const all = collection => {
+ return make((x, y) => {
+ const len = Math.min(x.length, y.length);
+ let collectionLength = 0;
+ for (const equivalence of collection) {
+ if (collectionLength >= len) {
+ break;
+ }
+ if (!equivalence(x[collectionLength], y[collectionLength])) {
+ return false;
+ }
+ collectionLength++;
+ }
+ return true;
+ });
+};
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+exports.all = all;
+const productMany = (self, collection) => {
+ const equivalence = all(collection);
+ return make((x, y) => !self(x[0], y[0]) ? false : equivalence(x.slice(1), y.slice(1)));
+};
+/**
+ * Similar to `Promise.all` but operates on `Equivalence`s.
+ *
+ * ```ts skip-type-checking
+ * [Equivalence, Equivalence, ...] -> Equivalence<[A, B, ...]>
+ * ```
+ *
+ * Given a tuple of `Equivalence`s returns a new `Equivalence` that compares values of a tuple
+ * by applying each `Equivalence` to the corresponding element of the tuple.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+exports.productMany = productMany;
+const tuple = (...elements) => all(elements);
+/**
+ * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+exports.tuple = tuple;
+const array = item => make((self, that) => {
+ if (self.length !== that.length) {
+ return false;
+ }
+ for (let i = 0; i < self.length; i++) {
+ const isEq = item(self[i], that[i]);
+ if (!isEq) {
+ return false;
+ }
+ }
+ return true;
+});
+/**
+ * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
+ * by applying each `Equivalence` to the corresponding property of the struct.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+exports.array = array;
+const struct = fields => {
+ const keys = Object.keys(fields);
+ return make((self, that) => {
+ for (const key of keys) {
+ if (!fields[key](self[key], that[key])) {
+ return false;
+ }
+ }
+ return true;
+ });
+};
+exports.struct = struct;
+//# sourceMappingURL=Equivalence.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ExecutionPlan.js.map b/backend/node_modules/effect/dist/cjs/ExecutionPlan.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..421427bf53221512a9eeafcccffcf3fa746f3d80
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ExecutionPlan.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionPlan.js","names":["Effect","_interopRequireWildcard","require","internal","Layer","_Pipeable","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","isExecutionPlan","make","steps","makeProto","map","options","attempts","Error","schedule","while","input","suspend","result","succeed","undefined","provide","Proto","withRequirements","self","contextWith","context","step","isLayer","succeedContext","pipe","pipeArguments","arguments","create","merge","plans","flatMap","plan"],"sources":["../../src/ExecutionPlan.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js b/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9fae8d52a708ea9e37efaeb86e57d741f1f4777
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js
@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.sequential = exports.parallelN = exports.parallel = exports.match = exports.isSequential = exports.isParallelN = exports.isParallel = void 0;
+var internal = _interopRequireWildcard(require("./internal/executionStrategy.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Execute effects sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sequential = exports.sequential = internal.sequential;
+/**
+ * Execute effects in parallel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const parallel = exports.parallel = internal.parallel;
+/**
+ * Execute effects in parallel, up to the specified number of concurrent fibers.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const parallelN = exports.parallelN = internal.parallelN;
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSequential = exports.isSequential = internal.isSequential;
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isParallel = exports.isParallel = internal.isParallel;
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isParallelN = exports.isParallelN = internal.isParallelN;
+/**
+ * Folds over the specified `ExecutionStrategy` using the provided case
+ * functions.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = exports.match = internal.match;
+//# sourceMappingURL=ExecutionStrategy.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js.map b/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..67a058f2f1a7f30c41b42713150f80b34ac7016d
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/ExecutionStrategy.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionStrategy.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","sequential","exports","parallel","parallelN","isSequential","isParallel","isParallelN","match"],"sources":["../../src/ExecutionStrategy.ts"],"sourcesContent":[null],"mappings":";;;;;;AAIA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAA2D,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AA6C3D;;;;;;AAMO,MAAMkB,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAsBtB,QAAQ,CAACsB,UAAU;AAEhE;;;;;;AAMO,MAAME,QAAQ,GAAAD,OAAA,CAAAC,QAAA,GAAsBxB,QAAQ,CAACwB,QAAQ;AAE5D;;;;;;AAMO,MAAMC,SAAS,GAAAF,OAAA,CAAAE,SAAA,GAA+CzB,QAAQ,CAACyB,SAAS;AAEvF;;;;;;;AAOO,MAAMC,YAAY,GAAAH,OAAA,CAAAG,YAAA,GAAoD1B,QAAQ,CAAC0B,YAAY;AAElG;;;;;;;AAOO,MAAMC,UAAU,GAAAJ,OAAA,CAAAI,UAAA,GAAkD3B,QAAQ,CAAC2B,UAAU;AAE5F;;;;;;;AAOO,MAAMC,WAAW,GAAAL,OAAA,CAAAK,WAAA,GAAmD5B,QAAQ,CAAC4B,WAAW;AAE/F;;;;;;;AAOO,MAAMC,KAAK,GAAAN,OAAA,CAAAM,KAAA,GA8Bd7B,QAAQ,CAAC6B,KAAK","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Exit.js b/backend/node_modules/effect/dist/cjs/Exit.js
new file mode 100644
index 0000000000000000000000000000000000000000..8731a2b239b6d8b664e8adebcbf6b4d5cfadb909
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Exit.js
@@ -0,0 +1,256 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zipWith = exports.zipRight = exports.zipParRight = exports.zipParLeft = exports.zipPar = exports.zipLeft = exports.zip = exports.void = exports.succeed = exports.matchEffect = exports.match = exports.mapErrorCause = exports.mapError = exports.mapBoth = exports.map = exports.isSuccess = exports.isInterrupted = exports.isFailure = exports.isExit = exports.interrupt = exports.getOrElse = exports.fromOption = exports.fromEither = exports.forEachEffect = exports.flatten = exports.flatMapEffect = exports.flatMap = exports.failCause = exports.fail = exports.exists = exports.die = exports.causeOption = exports.asVoid = exports.as = exports.all = void 0;
+var core = _interopRequireWildcard(require("./internal/core.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Returns `true` if the specified value is an `Exit`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isExit = exports.isExit = core.exitIsExit;
+/**
+ * Returns `true` if the specified `Exit` is a `Failure`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFailure = exports.isFailure = core.exitIsFailure;
+/**
+ * Returns `true` if the specified `Exit` is a `Success`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSuccess = exports.isSuccess = core.exitIsSuccess;
+/**
+ * Returns `true` if the specified exit is a `Failure` **and** the `Cause` of
+ * the failure was due to interruption, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isInterrupted = exports.isInterrupted = core.exitIsInterrupted;
+/**
+ * Maps the `Success` value of the specified exit to the provided constant
+ * value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = exports.as = core.exitAs;
+/**
+ * Maps the `Success` value of the specified exit to a void.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asVoid = exports.asVoid = core.exitAsVoid;
+/**
+ * Returns a `Some>` if the specified exit is a `Failure`, `None`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const causeOption = exports.causeOption = core.exitCauseOption;
+/**
+ * Collects all of the specified exit values into a `Some, E>>`. If
+ * the provided iterable contains no elements, `None` will be returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = exports.all = core.exitCollectAll;
+/**
+ * Constructs a new `Exit.Failure` from the specified unrecoverable defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = exports.die = core.exitDie;
+/**
+ * Executes the predicate on the value of the specified exit if it is a
+ * `Success`, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const exists = exports.exists = core.exitExists;
+/**
+ * Constructs a new `Exit.Failure` from the specified recoverable error of type
+ * `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = exports.fail = core.exitFail;
+/**
+ * Constructs a new `Exit.Failure` from the specified `Cause` of type `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = exports.failCause = core.exitFailCause;
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = exports.flatMap = core.exitFlatMap;
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMapEffect = exports.flatMapEffect = core.exitFlatMapEffect;
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = exports.flatten = core.exitFlatten;
+/**
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEachEffect = exports.forEachEffect = core.exitForEachEffect;
+/**
+ * Converts an `Either` into an `Exit`.
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const fromEither = exports.fromEither = core.exitFromEither;
+/**
+ * Converts an `Option` into an `Exit`.
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const fromOption = exports.fromOption = core.exitFromOption;
+/**
+ * Returns the `A` if specified exit is a `Success`, otherwise returns the
+ * alternate `A` value computed from the specified function which receives the
+ * `Cause` of the exit `Failure`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const getOrElse = exports.getOrElse = core.exitGetOrElse;
+/**
+ * Constructs a new `Exit.Failure` from the specified `FiberId` indicating that
+ * the `Fiber` running an `Effect` workflow was terminated due to interruption.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupt = exports.interrupt = core.exitInterrupt;
+/**
+ * Maps over the `Success` value of the specified exit using the provided
+ * function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = exports.map = core.exitMap;
+/**
+ * Maps over the `Success` and `Failure` cases of the specified exit using the
+ * provided functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBoth = exports.mapBoth = core.exitMapBoth;
+/**
+ * Maps over the error contained in the `Failure` of the specified exit using
+ * the provided function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = exports.mapError = core.exitMapError;
+/**
+ * Maps over the `Cause` contained in the `Failure` of the specified exit using
+ * the provided function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapErrorCause = exports.mapErrorCause = core.exitMapErrorCause;
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+const match = exports.match = core.exitMatch;
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+const matchEffect = exports.matchEffect = core.exitMatchEffect;
+/**
+ * Constructs a new `Exit.Success` containing the specified value of type `A`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = exports.succeed = core.exitSucceed;
+const void_ = exports.void = core.exitVoid;
+/**
+ * Sequentially zips the this result with the specified result or else returns
+ * the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = exports.zip = core.exitZip;
+/**
+ * Sequentially zips the this result with the specified result discarding the
+ * second element of the tuple or else returns the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = exports.zipLeft = core.exitZipLeft;
+/**
+ * Sequentially zips the this result with the specified result discarding the
+ * first element of the tuple or else returns the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = exports.zipRight = core.exitZipRight;
+/**
+ * Parallelly zips the this result with the specified result or else returns
+ * the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipPar = exports.zipPar = core.exitZipPar;
+/**
+ * Parallelly zips the this result with the specified result discarding the
+ * second element of the tuple or else returns the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipParLeft = exports.zipParLeft = core.exitZipParLeft;
+/**
+ * Parallelly zips the this result with the specified result discarding the
+ * first element of the tuple or else returns the failed `Cause`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipParRight = exports.zipParRight = core.exitZipParRight;
+/**
+ * Zips this exit together with that exit using the specified combination
+ * functions.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = exports.zipWith = core.exitZipWith;
+//# sourceMappingURL=Exit.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Exit.js.map b/backend/node_modules/effect/dist/cjs/Exit.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..8efa6a873d1892a37e4151ecb7595852e11b8ba1
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Exit.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"Exit.js","names":["core","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","isExit","exports","exitIsExit","isFailure","exitIsFailure","isSuccess","exitIsSuccess","isInterrupted","exitIsInterrupted","as","exitAs","asVoid","exitAsVoid","causeOption","exitCauseOption","all","exitCollectAll","die","exitDie","exists","exitExists","fail","exitFail","failCause","exitFailCause","flatMap","exitFlatMap","flatMapEffect","exitFlatMapEffect","flatten","exitFlatten","forEachEffect","exitForEachEffect","fromEither","exitFromEither","fromOption","exitFromOption","getOrElse","exitGetOrElse","interrupt","exitInterrupt","map","exitMap","mapBoth","exitMapBoth","mapError","exitMapError","mapErrorCause","exitMapErrorCause","match","exitMatch","matchEffect","exitMatchEffect","succeed","exitSucceed","void_","void","exitVoid","zip","exitZip","zipLeft","exitZipLeft","zipRight","exitZipRight","zipPar","exitZipPar","zipParLeft","exitZipParLeft","zipParRight","exitZipParRight","zipWith","exitZipWith"],"sources":["../../src/Exit.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FastCheck.js.map b/backend/node_modules/effect/dist/cjs/FastCheck.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..f5670f7446981b39c970d969523614c980952656
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FastCheck.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FastCheck.js","names":["_fastCheck","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get"],"sources":["../../src/FastCheck.ts"],"sourcesContent":[null],"mappings":";;;;;AAQA,IAAAA,UAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,UAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,UAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,UAAA,CAAAK,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Fiber.js b/backend/node_modules/effect/dist/cjs/Fiber.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad00be2c805972e10c521f2c08c4027f9013dde7
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Fiber.js
@@ -0,0 +1,340 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.zipWith = exports.zipRight = exports.zipLeft = exports.zip = exports.void = exports.unsafeRoots = exports.succeed = exports.status = exports.scoped = exports.roots = exports.pretty = exports.poll = exports.orElseEither = exports.orElse = exports.never = exports.match = exports.mapFiber = exports.mapEffect = exports.map = exports.joinAll = exports.join = exports.isRuntimeFiber = exports.isFiber = exports.interrupted = exports.interruptFork = exports.interruptAsFork = exports.interruptAs = exports.interruptAllAs = exports.interruptAll = exports.interrupt = exports.inheritAll = exports.id = exports.getCurrentFiber = exports.fromEffect = exports.failCause = exports.fail = exports.dumpAll = exports.dump = exports.done = exports.children = exports.awaitAll = exports.await = exports.all = exports.RuntimeFiberTypeId = exports.Order = exports.FiberTypeId = void 0;
+var core = _interopRequireWildcard(require("./internal/core.js"));
+var circular = _interopRequireWildcard(require("./internal/effect/circular.js"));
+var internal = _interopRequireWildcard(require("./internal/fiber.js"));
+var fiberRuntime = _interopRequireWildcard(require("./internal/fiberRuntime.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const FiberTypeId = exports.FiberTypeId = internal.FiberTypeId;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RuntimeFiberTypeId = exports.RuntimeFiberTypeId = internal.RuntimeFiberTypeId;
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+const Order = exports.Order = internal.Order;
+/**
+ * Returns `true` if the specified value is a `Fiber`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFiber = exports.isFiber = internal.isFiber;
+/**
+ * Returns `true` if the specified `Fiber` is a `RuntimeFiber`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isRuntimeFiber = exports.isRuntimeFiber = internal.isRuntimeFiber;
+/**
+ * The identity of the fiber.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const id = exports.id = internal.id;
+const _await = exports.await = internal._await;
+/**
+ * Awaits on all fibers to be completed, successfully or not.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const awaitAll = exports.awaitAll = fiberRuntime.fiberAwaitAll;
+/**
+ * Retrieves the immediate children of the fiber.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const children = exports.children = internal.children;
+/**
+ * Collects all fibers into a single fiber producing an in-order list of the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = exports.all = fiberRuntime.fiberAll;
+/**
+ * A fiber that is done with the specified `Exit` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const done = exports.done = internal.done;
+/**
+ * @since 2.0.0
+ * @category destructors
+ */
+const dump = exports.dump = internal.dump;
+/**
+ * @since 2.0.0
+ * @category destructors
+ */
+const dumpAll = exports.dumpAll = internal.dumpAll;
+/**
+ * A fiber that has already failed with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = exports.fail = internal.fail;
+/**
+ * Creates a `Fiber` that has already failed with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = exports.failCause = internal.failCause;
+/**
+ * Lifts an `Effect` into a `Fiber`.
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const fromEffect = exports.fromEffect = internal.fromEffect;
+/**
+ * Gets the current fiber if one is running.
+ *
+ * @since 2.0.0
+ * @category utilities
+ */
+const getCurrentFiber = exports.getCurrentFiber = internal.getCurrentFiber;
+/**
+ * Inherits values from all `FiberRef` instances into current fiber. This
+ * will resume immediately.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const inheritAll = exports.inheritAll = internal.inheritAll;
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interrupt = exports.interrupt = core.interruptFiber;
+/**
+ * Constructrs a `Fiber` that is already interrupted.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupted = exports.interrupted = internal.interrupted;
+/**
+ * Interrupts the fiber as if interrupted from the specified fiber. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptAs = exports.interruptAs = core.interruptAsFiber;
+/**
+ * Interrupts the fiber as if interrupted from the specified fiber. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptAsFork = exports.interruptAsFork = internal.interruptAsFork;
+/**
+ * Interrupts all fibers, awaiting their interruption.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptAll = exports.interruptAll = internal.interruptAll;
+/**
+ * Interrupts all fibers as by the specified fiber, awaiting their
+ * interruption.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptAllAs = exports.interruptAllAs = internal.interruptAllAs;
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. The
+ * interruption will happen in a separate daemon fiber, and the returned
+ * effect will always resume immediately without waiting.
+ *
+ * @since 2.0.0
+ * @category interruption
+ */
+const interruptFork = exports.interruptFork = fiberRuntime.fiberInterruptFork;
+/**
+ * Joins the fiber, which suspends the joining fiber until the result of the
+ * fiber has been determined. Attempting to join a fiber that has erred will
+ * result in a catchable error. Joining an interrupted fiber will result in an
+ * "inner interruption" of this fiber, unlike interruption triggered by
+ * another fiber, "inner interruption" can be caught and recovered.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const join = exports.join = internal.join;
+/**
+ * Joins all fibers, awaiting their _successful_ completion. Attempting to
+ * join a fiber that has erred will result in a catchable error, _if_ that
+ * error does not result from interruption.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const joinAll = exports.joinAll = fiberRuntime.fiberJoinAll;
+/**
+ * Maps over the value the Fiber computes.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = exports.map = internal.map;
+/**
+ * Effectually maps over the value the fiber computes.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = exports.mapEffect = internal.mapEffect;
+/**
+ * Passes the success of this fiber to the specified callback, and continues
+ * with the fiber that it returns.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapFiber = exports.mapFiber = internal.mapFiber;
+/**
+ * Folds over the `Fiber` or `RuntimeFiber`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = exports.match = internal.match;
+/**
+ * A fiber that never fails or succeeds.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = exports.never = internal.never;
+/**
+ * Returns a fiber that prefers `this` fiber, but falls back to the `that` one
+ * when `this` one fails. Interrupting the returned fiber will interrupt both
+ * fibers, sequentially, from left to right.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const orElse = exports.orElse = internal.orElse;
+/**
+ * Returns a fiber that prefers `this` fiber, but falls back to the `that` one
+ * when `this` one fails. Interrupting the returned fiber will interrupt both
+ * fibers, sequentially, from left to right.
+ *
+ * @since 2.0.0
+ * @category alternatives
+ */
+const orElseEither = exports.orElseEither = internal.orElseEither;
+/**
+ * Tentatively observes the fiber, but returns immediately if it is not
+ * already done.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const poll = exports.poll = internal.poll;
+/**
+ * Pretty-prints a `RuntimeFiber`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const pretty = exports.pretty = internal.pretty;
+/**
+ * Returns a chunk containing all root fibers.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const roots = exports.roots = internal.roots;
+/**
+ * Returns a chunk containing all root fibers.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeRoots = exports.unsafeRoots = internal.unsafeRoots;
+/**
+ * Converts this fiber into a scoped effect. The fiber is interrupted when the
+ * scope is closed.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const scoped = exports.scoped = fiberRuntime.fiberScoped;
+/**
+ * Returns the `FiberStatus` of a `RuntimeFiber`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const status = exports.status = internal.status;
+/**
+ * Returns a fiber that has already succeeded with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = exports.succeed = internal.succeed;
+const void_ = exports.void = internal.void;
+/**
+ * Zips this fiber and the specified fiber together, producing a tuple of
+ * their output.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = exports.zip = circular.zipFiber;
+/**
+ * Same as `zip` but discards the output of that `Fiber`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = exports.zipLeft = circular.zipLeftFiber;
+/**
+ * Same as `zip` but discards the output of this `Fiber`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = exports.zipRight = circular.zipRightFiber;
+/**
+ * Zips this fiber with the specified fiber, combining their results using the
+ * specified combiner function. Both joins and interruptions are performed in
+ * sequential order from left to right.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = exports.zipWith = circular.zipWithFiber;
+//# sourceMappingURL=Fiber.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberHandle.js b/backend/node_modules/effect/dist/cjs/FiberHandle.js
new file mode 100644
index 0000000000000000000000000000000000000000..29a8ce337f2269f87439c32a8aa2b8e878ab68e3
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberHandle.js
@@ -0,0 +1,335 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeSet = exports.unsafeGet = exports.set = exports.runtimePromise = exports.runtime = exports.run = exports.makeRuntimePromise = exports.makeRuntime = exports.make = exports.join = exports.isFiberHandle = exports.get = exports.clear = exports.awaitEmpty = exports.TypeId = void 0;
+var Cause = _interopRequireWildcard(require("./Cause.js"));
+var Deferred = _interopRequireWildcard(require("./Deferred.js"));
+var Effect = _interopRequireWildcard(require("./Effect.js"));
+var Exit = _interopRequireWildcard(require("./Exit.js"));
+var Fiber = _interopRequireWildcard(require("./Fiber.js"));
+var FiberId = _interopRequireWildcard(require("./FiberId.js"));
+var _Function = require("./Function.js");
+var HashSet = _interopRequireWildcard(require("./HashSet.js"));
+var Inspectable = _interopRequireWildcard(require("./Inspectable.js"));
+var Option = _interopRequireWildcard(require("./Option.js"));
+var _Pipeable = require("./Pipeable.js");
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+var Runtime = _interopRequireWildcard(require("./Runtime.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @categories type ids
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/FiberHandle");
+/**
+ * @since 2.0.0
+ * @categories refinements
+ */
+const isFiberHandle = u => Predicate.hasProperty(u, TypeId);
+exports.isFiberHandle = isFiberHandle;
+const Proto = {
+ [TypeId]: TypeId,
+ toString() {
+ return Inspectable.format(this.toJSON());
+ },
+ toJSON() {
+ return {
+ _id: "FiberHandle",
+ state: this.state
+ };
+ },
+ [Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+const unsafeMake = deferred => {
+ const self = Object.create(Proto);
+ self.state = {
+ _tag: "Open",
+ fiber: undefined
+ };
+ self.deferred = deferred;
+ return self;
+};
+/**
+ * A FiberHandle can be used to store a single fiber.
+ * When the associated Scope is closed, the contained fiber will be interrupted.
+ *
+ * You can add a fiber to the handle using `FiberHandle.run`, and the fiber will
+ * be automatically removed from the FiberHandle when it completes.
+ *
+ * @example
+ * ```ts
+ * import { Effect, FiberHandle } from "effect"
+ *
+ * Effect.gen(function*() {
+ * const handle = yield* FiberHandle.make()
+ *
+ * // run some effects
+ * yield* FiberHandle.run(handle, Effect.never)
+ * // this will interrupt the previous fiber
+ * yield* FiberHandle.run(handle, Effect.never)
+ *
+ * yield* Effect.sleep(1000)
+ * }).pipe(
+ * Effect.scoped // The fiber will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+const make = () => Effect.acquireRelease(Effect.map(Deferred.make(), deferred => unsafeMake(deferred)), handle => Effect.withFiberRuntime(parent => {
+ const state = handle.state;
+ if (state._tag === "Closed") return Effect.void;
+ handle.state = {
+ _tag: "Closed"
+ };
+ return state.fiber ? Effect.intoDeferred(Effect.asVoid(Fiber.interruptAs(state.fiber, FiberId.combine(parent.id(), internalFiberId))), handle.deferred) : Deferred.done(handle.deferred, Exit.void);
+}));
+/**
+ * Create an Effect run function that is backed by a FiberHandle.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+exports.make = make;
+const makeRuntime = () => Effect.flatMap(make(), self => runtime(self)());
+/**
+ * Create an Effect run function that is backed by a FiberHandle.
+ *
+ * @since 3.13.0
+ * @categories constructors
+ */
+exports.makeRuntime = makeRuntime;
+const makeRuntimePromise = () => Effect.flatMap(make(), self => runtimePromise(self)());
+exports.makeRuntimePromise = makeRuntimePromise;
+const internalFiberIdId = -1;
+const internalFiberId = /*#__PURE__*/FiberId.make(internalFiberIdId, 0);
+const isInternalInterruption = /*#__PURE__*/Cause.reduceWithContext(undefined, {
+ emptyCase: _Function.constFalse,
+ failCase: _Function.constFalse,
+ dieCase: _Function.constFalse,
+ interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+ sequentialCase: (_, left, right) => left || right,
+ parallelCase: (_, left, right) => left || right
+});
+/**
+ * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+ * If a fiber is already running, it will be interrupted unless `options.onlyIfMissing` is set.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeSet = exports.unsafeSet = /*#__PURE__*/(0, _Function.dual)(args => isFiberHandle(args[0]), (self, fiber, options) => {
+ if (self.state._tag === "Closed") {
+ fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ return;
+ } else if (self.state.fiber !== undefined) {
+ if (options?.onlyIfMissing === true) {
+ fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ return;
+ } else if (self.state.fiber === fiber) {
+ return;
+ }
+ self.state.fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ self.state.fiber = undefined;
+ }
+ self.state.fiber = fiber;
+ fiber.addObserver(exit => {
+ if (self.state._tag === "Open" && fiber === self.state.fiber) {
+ self.state.fiber = undefined;
+ }
+ if (Exit.isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !Cause.isInterruptedOnly(exit.cause))) {
+ Deferred.unsafeDone(self.deferred, exit);
+ }
+ });
+});
+/**
+ * Set the fiber in the FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+ * If a fiber already exists in the FiberHandle, it will be interrupted unless `options.onlyIfMissing` is set.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const set = exports.set = /*#__PURE__*/(0, _Function.dual)(args => isFiberHandle(args[0]), (self, fiber, options) => Effect.fiberIdWith(fiberId => Effect.sync(() => unsafeSet(self, fiber, {
+ interruptAs: fiberId,
+ onlyIfMissing: options?.onlyIfMissing,
+ propagateInterruption: options?.propagateInterruption
+}))));
+/**
+ * Retrieve the fiber from the FiberHandle.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeGet = self => self.state._tag === "Closed" ? Option.none() : Option.fromNullable(self.state.fiber);
+/**
+ * Retrieve the fiber from the FiberHandle.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+exports.unsafeGet = unsafeGet;
+const get = self => Effect.suspend(() => unsafeGet(self));
+/**
+ * @since 2.0.0
+ * @categories combinators
+ */
+exports.get = get;
+const clear = self => Effect.uninterruptibleMask(restore => Effect.withFiberRuntime(fiber => {
+ if (self.state._tag === "Closed" || self.state.fiber === undefined) {
+ return Effect.void;
+ }
+ return Effect.zipRight(restore(Fiber.interruptAs(self.state.fiber, FiberId.combine(fiber.id(), internalFiberId))), Effect.sync(() => {
+ if (self.state._tag === "Open") {
+ self.state.fiber = undefined;
+ }
+ }));
+}));
+exports.clear = clear;
+const constInterruptedFiber = /*#__PURE__*/function () {
+ let fiber = undefined;
+ return () => {
+ if (fiber === undefined) {
+ fiber = Effect.runFork(Effect.interrupt);
+ }
+ return fiber;
+ };
+}();
+/**
+ * Run an Effect and add the forked fiber to the FiberHandle.
+ * When the fiber completes, it will be removed from the FiberHandle.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const run = function () {
+ const self = arguments[0];
+ if (Effect.isEffect(arguments[1])) {
+ return runImpl(self, arguments[1], arguments[2]);
+ }
+ const options = arguments[1];
+ return effect => runImpl(self, effect, options);
+};
+exports.run = run;
+const runImpl = (self, effect, options) => Effect.withFiberRuntime(parent => {
+ if (self.state._tag === "Closed") {
+ return Effect.interrupt;
+ } else if (self.state.fiber !== undefined && options?.onlyIfMissing === true) {
+ return Effect.sync(constInterruptedFiber);
+ }
+ const runtime = Runtime.make({
+ context: parent.currentContext,
+ fiberRefs: parent.getFiberRefs(),
+ runtimeFlags: Runtime.defaultRuntime.runtimeFlags
+ });
+ const fiber = Runtime.runFork(runtime)(effect);
+ unsafeSet(self, fiber, {
+ ...options,
+ interruptAs: parent.id()
+ });
+ return Effect.succeed(fiber);
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberHandle.
+ *
+ * @example
+ * ```ts
+ * import { Context, Effect, FiberHandle } from "effect"
+ *
+ * interface Users {
+ * readonly _: unique symbol
+ * }
+ * const Users = Context.GenericTag>
+ * }>("Users")
+ *
+ * Effect.gen(function*() {
+ * const handle = yield* FiberHandle.make()
+ * const run = yield* FiberHandle.runtime(handle)()
+ *
+ * // run an effect and set the fiber in the handle
+ * run(Effect.andThen(Users, _ => _.getAll))
+ *
+ * // this will interrupt the previous fiber
+ * run(Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ * Effect.scoped // The fiber will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const runtime = self => () => Effect.map(Effect.runtime(), runtime => {
+ const runFork = Runtime.runFork(runtime);
+ return (effect, options) => {
+ if (self.state._tag === "Closed") {
+ return constInterruptedFiber();
+ } else if (self.state.fiber !== undefined && options?.onlyIfMissing === true) {
+ return constInterruptedFiber();
+ }
+ const fiber = runFork(effect, options);
+ unsafeSet(self, fiber, options);
+ return fiber;
+ };
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberHandle.
+ *
+ * The returned run function will return Promise's that will resolve when the
+ * fiber completes.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.runtime = runtime;
+const runtimePromise = self => () => Effect.map(runtime(self)(), runFork => (effect, options) => new Promise((resolve, reject) => runFork(effect, options).addObserver(exit => {
+ if (Exit.isSuccess(exit)) {
+ resolve(exit.value);
+ } else {
+ reject(Cause.squash(exit.cause));
+ }
+})));
+/**
+ * If any of the Fiber's in the handle terminate with a failure,
+ * the returned Effect will terminate with the first failure that occurred.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ * @example
+ * ```ts
+ * import { Effect, FiberHandle } from "effect";
+ *
+ * Effect.gen(function* (_) {
+ * const handle = yield* _(FiberHandle.make());
+ * yield* _(FiberHandle.set(handle, Effect.runFork(Effect.fail("error"))));
+ *
+ * // parent fiber will fail with "error"
+ * yield* _(FiberHandle.join(handle));
+ * });
+ * ```
+ */
+exports.runtimePromise = runtimePromise;
+const join = self => Deferred.await(self.deferred);
+/**
+ * Wait for the fiber in the FiberHandle to complete.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.join = join;
+const awaitEmpty = self => Effect.suspend(() => {
+ if (self.state._tag === "Closed" || self.state.fiber === undefined) {
+ return Effect.void;
+ }
+ return Fiber.await(self.state.fiber);
+});
+exports.awaitEmpty = awaitEmpty;
+//# sourceMappingURL=FiberHandle.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberId.js b/backend/node_modules/effect/dist/cjs/FiberId.js
new file mode 100644
index 0000000000000000000000000000000000000000..1150eb15f509018d4d8e97234fb4974488153272
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberId.js
@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeMake = exports.toSet = exports.toOption = exports.threadName = exports.runtime = exports.none = exports.make = exports.isRuntime = exports.isNone = exports.isFiberId = exports.isComposite = exports.ids = exports.getOrElse = exports.composite = exports.combineAll = exports.combine = exports.FiberIdTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/fiberId.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const FiberIdTypeId = exports.FiberIdTypeId = internal.FiberIdTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const none = exports.none = internal.none;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const runtime = exports.runtime = internal.runtime;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const composite = exports.composite = internal.composite;
+/**
+ * Returns `true` if the specified unknown value is a `FiberId`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFiberId = exports.isFiberId = internal.isFiberId;
+/**
+ * Returns `true` if the `FiberId` is a `None`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isNone = exports.isNone = internal.isNone;
+/**
+ * Returns `true` if the `FiberId` is a `Runtime`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isRuntime = exports.isRuntime = internal.isRuntime;
+/**
+ * Returns `true` if the `FiberId` is a `Composite`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isComposite = exports.isComposite = internal.isComposite;
+/**
+ * Combine two `FiberId`s.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const combine = exports.combine = internal.combine;
+/**
+ * Combines a set of `FiberId`s into a single `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const combineAll = exports.combineAll = internal.combineAll;
+/**
+ * Returns this `FiberId` if it is not `None`, otherwise returns that `FiberId`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const getOrElse = exports.getOrElse = internal.getOrElse;
+/**
+ * Get the set of identifiers for this `FiberId`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const ids = exports.ids = internal.ids;
+/**
+ * Creates a new `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = exports.make = internal.make;
+/**
+ * Creates a string representing the name of the current thread of execution
+ * represented by the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const threadName = exports.threadName = internal.threadName;
+/**
+ * Convert a `FiberId` into an `Option`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toOption = exports.toOption = internal.toOption;
+/**
+ * Convert a `FiberId` into a `HashSet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toSet = exports.toSet = internal.toSet;
+/**
+ * Unsafely creates a new `FiberId`.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeMake = exports.unsafeMake = internal.unsafeMake;
+//# sourceMappingURL=FiberId.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberId.js.map b/backend/node_modules/effect/dist/cjs/FiberId.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c93f79edb27d8d99feade8b7215c8df2668334a7
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberId.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FiberId.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","FiberIdTypeId","exports","none","runtime","composite","isFiberId","isNone","isRuntime","isComposite","combine","combineAll","getOrElse","ids","make","threadName","toOption","toSet","unsafeMake"],"sources":["../../src/FiberId.ts"],"sourcesContent":[null],"mappings":";;;;;;AAMA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAiD,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAGjD;;;;AAIO,MAAMkB,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAkBtB,QAAQ,CAACsB,aAAa;AAqDlE;;;;AAIO,MAAME,IAAI,GAAAD,OAAA,CAAAC,IAAA,GAASxB,QAAQ,CAACwB,IAAI;AAEvC;;;;AAIO,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAAqDzB,QAAQ,CAACyB,OAAO;AAEzF;;;;AAIO,MAAMC,SAAS,GAAAH,OAAA,CAAAG,SAAA,GAAiD1B,QAAQ,CAAC0B,SAAS;AAEzF;;;;;;;AAOO,MAAMC,SAAS,GAAAJ,OAAA,CAAAI,SAAA,GAAuC3B,QAAQ,CAAC2B,SAAS;AAE/E;;;;;;AAMO,MAAMC,MAAM,GAAAL,OAAA,CAAAK,MAAA,GAAoC5B,QAAQ,CAAC4B,MAAM;AAEtE;;;;;;AAMO,MAAMC,SAAS,GAAAN,OAAA,CAAAM,SAAA,GAAuC7B,QAAQ,CAAC6B,SAAS;AAE/E;;;;;;AAMO,MAAMC,WAAW,GAAAP,OAAA,CAAAO,WAAA,GAAyC9B,QAAQ,CAAC8B,WAAW;AAErF;;;;;;AAMO,MAAMC,OAAO,GAAAR,OAAA,CAAAQ,OAAA,GAehB/B,QAAQ,CAAC+B,OAAO;AAEpB;;;;;;AAMO,MAAMC,UAAU,GAAAT,OAAA,CAAAS,UAAA,GAAoDhC,QAAQ,CAACgC,UAAU;AAE9F;;;;;;AAMO,MAAMC,SAAS,GAAAV,OAAA,CAAAU,SAAA,GAelBjC,QAAQ,CAACiC,SAAS;AAEtB;;;;;;AAMO,MAAMC,GAAG,GAAAX,OAAA,CAAAW,GAAA,GAA+ClC,QAAQ,CAACkC,GAAG;AAE3E;;;;;;AAMO,MAAMC,IAAI,GAAAZ,OAAA,CAAAY,IAAA,GAAsDnC,QAAQ,CAACmC,IAAI;AAEpF;;;;;;;AAOO,MAAMC,UAAU,GAAAb,OAAA,CAAAa,UAAA,GAA8BpC,QAAQ,CAACoC,UAAU;AAExE;;;;;;AAMO,MAAMC,QAAQ,GAAAd,OAAA,CAAAc,QAAA,GAA8CrC,QAAQ,CAACqC,QAAQ;AAEpF;;;;;;AAMO,MAAMC,KAAK,GAAAf,OAAA,CAAAe,KAAA,GAAgDtC,QAAQ,CAACsC,KAAK;AAEhF;;;;;;AAMO,MAAMC,UAAU,GAAAhB,OAAA,CAAAgB,UAAA,GAAyBvC,QAAQ,CAACuC,UAAU","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberMap.js b/backend/node_modules/effect/dist/cjs/FiberMap.js
new file mode 100644
index 0000000000000000000000000000000000000000..35b6aa9cc0a1c09612c00510eaa345c986a4dc08
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberMap.js
@@ -0,0 +1,374 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeSet = exports.unsafeHas = exports.unsafeGet = exports.size = exports.set = exports.runtimePromise = exports.runtime = exports.run = exports.remove = exports.makeRuntimePromise = exports.makeRuntime = exports.make = exports.join = exports.isFiberMap = exports.has = exports.get = exports.clear = exports.awaitEmpty = exports.TypeId = void 0;
+var Cause = _interopRequireWildcard(require("./Cause.js"));
+var Deferred = _interopRequireWildcard(require("./Deferred.js"));
+var Effect = _interopRequireWildcard(require("./Effect.js"));
+var Exit = _interopRequireWildcard(require("./Exit.js"));
+var Fiber = _interopRequireWildcard(require("./Fiber.js"));
+var FiberId = _interopRequireWildcard(require("./FiberId.js"));
+var _Function = require("./Function.js");
+var HashSet = _interopRequireWildcard(require("./HashSet.js"));
+var Inspectable = _interopRequireWildcard(require("./Inspectable.js"));
+var Iterable = _interopRequireWildcard(require("./Iterable.js"));
+var MutableHashMap = _interopRequireWildcard(require("./MutableHashMap.js"));
+var Option = _interopRequireWildcard(require("./Option.js"));
+var _Pipeable = require("./Pipeable.js");
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+var Runtime = _interopRequireWildcard(require("./Runtime.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @categories type ids
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/FiberMap");
+/**
+ * @since 2.0.0
+ * @categories refinements
+ */
+const isFiberMap = u => Predicate.hasProperty(u, TypeId);
+exports.isFiberMap = isFiberMap;
+const Proto = {
+ [TypeId]: TypeId,
+ [Symbol.iterator]() {
+ if (this.state._tag === "Closed") {
+ return Iterable.empty();
+ }
+ return this.state.backing[Symbol.iterator]();
+ },
+ toString() {
+ return Inspectable.format(this.toJSON());
+ },
+ toJSON() {
+ return {
+ _id: "FiberMap",
+ state: this.state
+ };
+ },
+ [Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+const unsafeMake = (backing, deferred) => {
+ const self = Object.create(Proto);
+ self.state = {
+ _tag: "Open",
+ backing
+ };
+ self.deferred = deferred;
+ return self;
+};
+/**
+ * A FiberMap can be used to store a collection of fibers, indexed by some key.
+ * When the associated Scope is closed, all fibers in the map will be interrupted.
+ *
+ * You can add fibers to the map using `FiberMap.set` or `FiberMap.run`, and the fibers will
+ * be automatically removed from the FiberMap when they complete.
+ *
+ * @example
+ * ```ts
+ * import { Effect, FiberMap } from "effect"
+ *
+ * Effect.gen(function*() {
+ * const map = yield* FiberMap.make()
+ *
+ * // run some effects and add the fibers to the map
+ * yield* FiberMap.run(map, "fiber a", Effect.never)
+ * yield* FiberMap.run(map, "fiber b", Effect.never)
+ *
+ * yield* Effect.sleep(1000)
+ * }).pipe(
+ * Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+const make = () => Effect.acquireRelease(Effect.map(Deferred.make(), deferred => unsafeMake(MutableHashMap.empty(), deferred)), map => Effect.withFiberRuntime(parent => {
+ const state = map.state;
+ if (state._tag === "Closed") return Effect.void;
+ map.state = {
+ _tag: "Closed"
+ };
+ return Fiber.interruptAllAs(Iterable.map(state.backing, ([, fiber]) => fiber), FiberId.combine(parent.id(), internalFiberId)).pipe(Effect.intoDeferred(map.deferred));
+}));
+/**
+ * Create an Effect run function that is backed by a FiberMap.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+exports.make = make;
+const makeRuntime = () => Effect.flatMap(make(), self => runtime(self)());
+/**
+ * Create an Effect run function that is backed by a FiberMap.
+ *
+ * @since 3.13.0
+ * @categories constructors
+ */
+exports.makeRuntime = makeRuntime;
+const makeRuntimePromise = () => Effect.flatMap(make(), self => runtimePromise(self)());
+exports.makeRuntimePromise = makeRuntimePromise;
+const internalFiberIdId = -1;
+const internalFiberId = /*#__PURE__*/FiberId.make(internalFiberIdId, 0);
+const isInternalInterruption = /*#__PURE__*/Cause.reduceWithContext(undefined, {
+ emptyCase: _Function.constFalse,
+ failCase: _Function.constFalse,
+ dieCase: _Function.constFalse,
+ interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+ sequentialCase: (_, left, right) => left || right,
+ parallelCase: (_, left, right) => left || right
+});
+/**
+ * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
+ * If the key already exists in the FiberMap, the previous fiber will be interrupted.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeSet = exports.unsafeSet = /*#__PURE__*/(0, _Function.dual)(args => isFiberMap(args[0]), (self, key, fiber, options) => {
+ if (self.state._tag === "Closed") {
+ fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ return;
+ }
+ const previous = MutableHashMap.get(self.state.backing, key);
+ if (previous._tag === "Some") {
+ if (options?.onlyIfMissing === true) {
+ fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ return;
+ } else if (previous.value === fiber) {
+ return;
+ }
+ previous.value.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ }
+ MutableHashMap.set(self.state.backing, key, fiber);
+ fiber.addObserver(exit => {
+ if (self.state._tag === "Closed") {
+ return;
+ }
+ const current = MutableHashMap.get(self.state.backing, key);
+ if (Option.isSome(current) && fiber === current.value) {
+ MutableHashMap.remove(self.state.backing, key);
+ }
+ if (Exit.isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !Cause.isInterruptedOnly(exit.cause))) {
+ Deferred.unsafeDone(self.deferred, exit);
+ }
+ });
+});
+/**
+ * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
+ * If the key already exists in the FiberMap, the previous fiber will be interrupted.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const set = exports.set = /*#__PURE__*/(0, _Function.dual)(args => isFiberMap(args[0]), (self, key, fiber, options) => Effect.fiberIdWith(fiberId => Effect.sync(() => unsafeSet(self, key, fiber, {
+ ...options,
+ interruptAs: fiberId
+}))));
+/**
+ * Retrieve a fiber from the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeGet = exports.unsafeGet = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key));
+/**
+ * Retrieve a fiber from the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const get = exports.get = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => Effect.suspend(() => unsafeGet(self, key)));
+/**
+ * Check if a key exists in the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeHas = exports.unsafeHas = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => self.state._tag === "Closed" ? false : MutableHashMap.has(self.state.backing, key));
+/**
+ * Check if a key exists in the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const has = exports.has = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => Effect.sync(() => unsafeHas(self, key)));
+/**
+ * Remove a fiber from the FiberMap, interrupting it if it exists.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const remove = exports.remove = /*#__PURE__*/(0, _Function.dual)(2, (self, key) => Effect.withFiberRuntime(removeFiber => {
+ if (self.state._tag === "Closed") {
+ return Effect.void;
+ }
+ const fiber = MutableHashMap.get(self.state.backing, key);
+ if (fiber._tag === "None") {
+ return Effect.void;
+ }
+ // will be removed by the observer
+ return Fiber.interruptAs(fiber.value, FiberId.combine(removeFiber.id(), internalFiberId));
+}));
+/**
+ * @since 2.0.0
+ * @categories combinators
+ */
+const clear = self => Effect.withFiberRuntime(clearFiber => {
+ if (self.state._tag === "Closed") {
+ return Effect.void;
+ }
+ return Effect.forEach(self.state.backing, ([, fiber]) =>
+ // will be removed by the observer
+ Fiber.interruptAs(fiber, FiberId.combine(clearFiber.id(), internalFiberId)));
+});
+exports.clear = clear;
+const constInterruptedFiber = /*#__PURE__*/function () {
+ let fiber = undefined;
+ return () => {
+ if (fiber === undefined) {
+ fiber = Effect.runFork(Effect.interrupt);
+ }
+ return fiber;
+ };
+}();
+/**
+ * Run an Effect and add the forked fiber to the FiberMap.
+ * When the fiber completes, it will be removed from the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const run = function () {
+ const self = arguments[0];
+ if (Effect.isEffect(arguments[2])) {
+ return runImpl(self, arguments[1], arguments[2], arguments[3]);
+ }
+ const key = arguments[1];
+ const options = arguments[2];
+ return effect => runImpl(self, key, effect, options);
+};
+exports.run = run;
+const runImpl = (self, key, effect, options) => Effect.withFiberRuntime(parent => {
+ if (self.state._tag === "Closed") {
+ return Effect.interrupt;
+ } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
+ return Effect.sync(constInterruptedFiber);
+ }
+ const runtime = Runtime.make({
+ context: parent.currentContext,
+ fiberRefs: parent.getFiberRefs(),
+ runtimeFlags: Runtime.defaultRuntime.runtimeFlags
+ });
+ const fiber = Runtime.runFork(runtime)(effect);
+ unsafeSet(self, key, fiber, {
+ ...options,
+ interruptAs: parent.id()
+ });
+ return Effect.succeed(fiber);
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
+ *
+ * @example
+ * ```ts
+ * import { Context, Effect, FiberMap } from "effect"
+ *
+ * interface Users {
+ * readonly _: unique symbol
+ * }
+ * const Users = Context.GenericTag>
+ * }>("Users")
+ *
+ * Effect.gen(function*() {
+ * const map = yield* FiberMap.make()
+ * const run = yield* FiberMap.runtime(map)()
+ *
+ * // run some effects and add the fibers to the map
+ * run("effect-a", Effect.andThen(Users, _ => _.getAll))
+ * run("effect-b", Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ * Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const runtime = self => () => Effect.map(Effect.runtime(), runtime => {
+ const runFork = Runtime.runFork(runtime);
+ return (key, effect, options) => {
+ if (self.state._tag === "Closed") {
+ return constInterruptedFiber();
+ } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
+ return constInterruptedFiber();
+ }
+ const fiber = runFork(effect, options);
+ unsafeSet(self, key, fiber, options);
+ return fiber;
+ };
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.runtime = runtime;
+const runtimePromise = self => () => Effect.map(runtime(self)(), runFork => (key, effect, options) => new Promise((resolve, reject) => runFork(key, effect, options).addObserver(exit => {
+ if (Exit.isSuccess(exit)) {
+ resolve(exit.value);
+ } else {
+ reject(Cause.squash(exit.cause));
+ }
+})));
+/**
+ * @since 2.0.0
+ * @categories combinators
+ */
+exports.runtimePromise = runtimePromise;
+const size = self => Effect.sync(() => self.state._tag === "Closed" ? 0 : MutableHashMap.size(self.state.backing));
+/**
+ * Join all fibers in the FiberMap. If any of the Fiber's in the map terminate with a failure,
+ * the returned Effect will terminate with the first failure that occurred.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ * @example
+ * ```ts
+ * import { Effect, FiberMap } from "effect";
+ *
+ * Effect.gen(function* (_) {
+ * const map = yield* _(FiberMap.make());
+ * yield* _(FiberMap.set(map, "a", Effect.runFork(Effect.fail("error"))));
+ *
+ * // parent fiber will fail with "error"
+ * yield* _(FiberMap.join(map));
+ * });
+ * ```
+ */
+exports.size = size;
+const join = self => Deferred.await(self.deferred);
+/**
+ * Wait for the FiberMap to be empty.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.join = join;
+const awaitEmpty = self => Effect.whileLoop({
+ while: () => self.state._tag === "Open" && MutableHashMap.size(self.state.backing) > 0,
+ body: () => Fiber.await(Iterable.unsafeHead(self)[1]),
+ step: _Function.constVoid
+});
+exports.awaitEmpty = awaitEmpty;
+//# sourceMappingURL=FiberMap.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberRef.js b/backend/node_modules/effect/dist/cjs/FiberRef.js
new file mode 100644
index 0000000000000000000000000000000000000000..af8db7f9f2edd4e19899c62d1d7e38f0376bcb22
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberRef.js
@@ -0,0 +1,243 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.versionMismatchErrorLogLevel = exports.updateSomeAndGet = exports.updateSome = exports.updateAndGet = exports.update = exports.unsafeMakeSupervisor = exports.unsafeMakePatch = exports.unsafeMakeHashSet = exports.unsafeMakeContext = exports.unsafeMake = exports.unhandledErrorLogLevel = exports.set = exports.reset = exports.modifySome = exports.modify = exports.makeWith = exports.makeRuntimeFlags = exports.makeContext = exports.make = exports.interruptedCause = exports.getWith = exports.getAndUpdateSome = exports.getAndUpdate = exports.getAndSet = exports.get = exports.delete = exports.currentTracerTimingEnabled = exports.currentTracerSpanLinks = exports.currentTracerSpanAnnotations = exports.currentTracerEnabled = exports.currentSupervisor = exports.currentSchedulingPriority = exports.currentScheduler = exports.currentRuntimeFlags = exports.currentRequestCacheEnabled = exports.currentRequestCache = exports.currentRequestBatchingEnabled = exports.currentMinimumLogLevel = exports.currentMetricLabels = exports.currentMaxOpsBeforeYield = exports.currentLoggers = exports.currentLogSpan = exports.currentLogLevel = exports.currentLogAnnotations = exports.currentContext = exports.currentConcurrency = exports.FiberRefTypeId = void 0;
+var core = _interopRequireWildcard(require("./internal/core.js"));
+var fiberRuntime = _interopRequireWildcard(require("./internal/fiberRuntime.js"));
+var query = _interopRequireWildcard(require("./internal/query.js"));
+var Scheduler = _interopRequireWildcard(require("./Scheduler.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const FiberRefTypeId = exports.FiberRefTypeId = core.FiberRefTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = exports.make = fiberRuntime.fiberRefMake;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeWith = exports.makeWith = fiberRuntime.fiberRefMakeWith;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeContext = exports.makeContext = fiberRuntime.fiberRefMakeContext;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const makeRuntimeFlags = exports.makeRuntimeFlags = fiberRuntime.fiberRefMakeRuntimeFlags;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeMake = exports.unsafeMake = core.fiberRefUnsafeMake;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeMakeHashSet = exports.unsafeMakeHashSet = core.fiberRefUnsafeMakeHashSet;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeMakeContext = exports.unsafeMakeContext = core.fiberRefUnsafeMakeContext;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeMakeSupervisor = exports.unsafeMakeSupervisor = fiberRuntime.fiberRefUnsafeMakeSupervisor;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unsafeMakePatch = exports.unsafeMakePatch = core.fiberRefUnsafeMakePatch;
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+const get = exports.get = core.fiberRefGet;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const getAndSet = exports.getAndSet = core.fiberRefGetAndSet;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const getAndUpdate = exports.getAndUpdate = core.fiberRefGetAndUpdate;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const getAndUpdateSome = exports.getAndUpdateSome = core.fiberRefGetAndUpdateSome;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const getWith = exports.getWith = core.fiberRefGetWith;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const set = exports.set = core.fiberRefSet;
+const _delete = exports.delete = core.fiberRefDelete;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const reset = exports.reset = core.fiberRefReset;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const modify = exports.modify = core.fiberRefModify;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const modifySome = exports.modifySome = core.fiberRefModifySome;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const update = exports.update = core.fiberRefUpdate;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const updateSome = exports.updateSome = core.fiberRefUpdateSome;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const updateAndGet = exports.updateAndGet = core.fiberRefUpdateAndGet;
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const updateSomeAndGet = exports.updateSomeAndGet = core.fiberRefUpdateSomeAndGet;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentConcurrency = exports.currentConcurrency = core.currentConcurrency;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentRequestBatchingEnabled = exports.currentRequestBatchingEnabled = core.currentRequestBatching;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentRequestCache = exports.currentRequestCache = query.currentCache;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentRequestCacheEnabled = exports.currentRequestCacheEnabled = query.currentCacheEnabled;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentContext = exports.currentContext = core.currentContext;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentSchedulingPriority = exports.currentSchedulingPriority = core.currentSchedulingPriority;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentMaxOpsBeforeYield = exports.currentMaxOpsBeforeYield = core.currentMaxOpsBeforeYield;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const unhandledErrorLogLevel = exports.unhandledErrorLogLevel = core.currentUnhandledErrorLogLevel;
+/**
+ * @since 3.17.0
+ * @category fiberRefs
+ */
+const versionMismatchErrorLogLevel = exports.versionMismatchErrorLogLevel = core.currentVersionMismatchErrorLogLevel;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentLogAnnotations = exports.currentLogAnnotations = core.currentLogAnnotations;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentLoggers = exports.currentLoggers = fiberRuntime.currentLoggers;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentLogLevel = exports.currentLogLevel = core.currentLogLevel;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentMinimumLogLevel = exports.currentMinimumLogLevel = fiberRuntime.currentMinimumLogLevel;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentLogSpan = exports.currentLogSpan = core.currentLogSpan;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentRuntimeFlags = exports.currentRuntimeFlags = fiberRuntime.currentRuntimeFlags;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentScheduler = exports.currentScheduler = Scheduler.currentScheduler;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentSupervisor = exports.currentSupervisor = fiberRuntime.currentSupervisor;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentMetricLabels = exports.currentMetricLabels = core.currentMetricLabels;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentTracerEnabled = exports.currentTracerEnabled = core.currentTracerEnabled;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentTracerTimingEnabled = exports.currentTracerTimingEnabled = core.currentTracerTimingEnabled;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentTracerSpanAnnotations = exports.currentTracerSpanAnnotations = core.currentTracerSpanAnnotations;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const currentTracerSpanLinks = exports.currentTracerSpanLinks = core.currentTracerSpanLinks;
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+const interruptedCause = exports.interruptedCause = core.currentInterruptedCause;
+//# sourceMappingURL=FiberRef.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberRef.js.map b/backend/node_modules/effect/dist/cjs/FiberRef.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..5ff9e7716ddcfc40a1294382d01f6af37fd03957
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberRef.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FiberRef.js","names":["core","_interopRequireWildcard","require","fiberRuntime","query","Scheduler","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","FiberRefTypeId","exports","make","fiberRefMake","makeWith","fiberRefMakeWith","makeContext","fiberRefMakeContext","makeRuntimeFlags","fiberRefMakeRuntimeFlags","unsafeMake","fiberRefUnsafeMake","unsafeMakeHashSet","fiberRefUnsafeMakeHashSet","unsafeMakeContext","fiberRefUnsafeMakeContext","unsafeMakeSupervisor","fiberRefUnsafeMakeSupervisor","unsafeMakePatch","fiberRefUnsafeMakePatch","fiberRefGet","getAndSet","fiberRefGetAndSet","getAndUpdate","fiberRefGetAndUpdate","getAndUpdateSome","fiberRefGetAndUpdateSome","getWith","fiberRefGetWith","fiberRefSet","_delete","delete","fiberRefDelete","reset","fiberRefReset","modify","fiberRefModify","modifySome","fiberRefModifySome","update","fiberRefUpdate","updateSome","fiberRefUpdateSome","updateAndGet","fiberRefUpdateAndGet","updateSomeAndGet","fiberRefUpdateSomeAndGet","currentConcurrency","currentRequestBatchingEnabled","currentRequestBatching","currentRequestCache","currentCache","currentRequestCacheEnabled","currentCacheEnabled","currentContext","currentSchedulingPriority","currentMaxOpsBeforeYield","unhandledErrorLogLevel","currentUnhandledErrorLogLevel","versionMismatchErrorLogLevel","currentVersionMismatchErrorLogLevel","currentLogAnnotations","currentLoggers","currentLogLevel","currentMinimumLogLevel","currentLogSpan","currentRuntimeFlags","currentScheduler","currentSupervisor","currentMetricLabels","currentTracerEnabled","currentTracerTimingEnabled","currentTracerSpanAnnotations","currentTracerSpanLinks","interruptedCause","currentInterruptedCause"],"sources":["../../src/FiberRef.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberRefsPatch.js.map b/backend/node_modules/effect/dist/cjs/FiberRefsPatch.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c3f5e28ba701466273b8db031be938add0885da7
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberRefsPatch.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FiberRefsPatch.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","empty","exports","diff","combine","patch"],"sources":["../../src/FiberRefsPatch.ts"],"sourcesContent":[null],"mappings":";;;;;;AAMA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAyD,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AA4DzD;;;;AAIO,MAAMkB,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAAmBtB,QAAQ,CAACsB,KAAK;AAEnD;;;;;;;AAOO,MAAME,IAAI,GAAAD,OAAA,CAAAC,IAAA,GAAqFxB,QAAQ,CAACwB,IAAI;AAEnH;;;;;;;;AAQO,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAmBhBzB,QAAQ,CAACyB,OAAO;AAEpB;;;;;;;AAOO,MAAMC,KAAK,GAAAH,OAAA,CAAAG,KAAA,GAqBd1B,QAAQ,CAAC0B,KAAK","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberSet.js b/backend/node_modules/effect/dist/cjs/FiberSet.js
new file mode 100644
index 0000000000000000000000000000000000000000..f62e9f9eeda71918201d79b0e3c691662bfcdf6d
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberSet.js
@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.unsafeAdd = exports.size = exports.runtimePromise = exports.runtime = exports.run = exports.makeRuntimePromise = exports.makeRuntime = exports.make = exports.join = exports.isFiberSet = exports.clear = exports.awaitEmpty = exports.add = exports.TypeId = void 0;
+var Cause = _interopRequireWildcard(require("./Cause.js"));
+var Deferred = _interopRequireWildcard(require("./Deferred.js"));
+var Effect = _interopRequireWildcard(require("./Effect.js"));
+var Exit = _interopRequireWildcard(require("./Exit.js"));
+var Fiber = _interopRequireWildcard(require("./Fiber.js"));
+var FiberId = _interopRequireWildcard(require("./FiberId.js"));
+var _Function = require("./Function.js");
+var HashSet = _interopRequireWildcard(require("./HashSet.js"));
+var Inspectable = _interopRequireWildcard(require("./Inspectable.js"));
+var Iterable = _interopRequireWildcard(require("./Iterable.js"));
+var _Pipeable = require("./Pipeable.js");
+var Predicate = _interopRequireWildcard(require("./Predicate.js"));
+var Runtime = _interopRequireWildcard(require("./Runtime.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @categories type ids
+ */
+const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("effect/FiberSet");
+/**
+ * @since 2.0.0
+ * @categories refinements
+ */
+const isFiberSet = u => Predicate.hasProperty(u, TypeId);
+exports.isFiberSet = isFiberSet;
+const Proto = {
+ [TypeId]: TypeId,
+ [Symbol.iterator]() {
+ if (this.state._tag === "Closed") {
+ return Iterable.empty();
+ }
+ return this.state.backing[Symbol.iterator]();
+ },
+ toString() {
+ return Inspectable.format(this.toJSON());
+ },
+ toJSON() {
+ return {
+ _id: "FiberMap",
+ state: this.state
+ };
+ },
+ [Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+const unsafeMake = (backing, deferred) => {
+ const self = Object.create(Proto);
+ self.state = {
+ _tag: "Open",
+ backing
+ };
+ self.deferred = deferred;
+ return self;
+};
+/**
+ * A FiberSet can be used to store a collection of fibers.
+ * When the associated Scope is closed, all fibers in the set will be interrupted.
+ *
+ * You can add fibers to the set using `FiberSet.add` or `FiberSet.run`, and the fibers will
+ * be automatically removed from the FiberSet when they complete.
+ *
+ * @example
+ * ```ts
+ * import { Effect, FiberSet } from "effect"
+ *
+ * Effect.gen(function*() {
+ * const set = yield* FiberSet.make()
+ *
+ * // run some effects and add the fibers to the set
+ * yield* FiberSet.run(set, Effect.never)
+ * yield* FiberSet.run(set, Effect.never)
+ *
+ * yield* Effect.sleep(1000)
+ * }).pipe(
+ * Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+const make = () => Effect.acquireRelease(Effect.map(Deferred.make(), deferred => unsafeMake(new Set(), deferred)), set => Effect.withFiberRuntime(parent => {
+ const state = set.state;
+ if (state._tag === "Closed") return Effect.void;
+ set.state = {
+ _tag: "Closed"
+ };
+ const fibers = state.backing;
+ return Fiber.interruptAllAs(fibers, FiberId.combine(parent.id(), internalFiberId)).pipe(Effect.intoDeferred(set.deferred));
+}));
+/**
+ * Create an Effect run function that is backed by a FiberSet.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+exports.make = make;
+const makeRuntime = () => Effect.flatMap(make(), self => runtime(self)());
+/**
+ * Create an Effect run function that is backed by a FiberSet.
+ *
+ * @since 3.13.0
+ * @categories constructors
+ */
+exports.makeRuntime = makeRuntime;
+const makeRuntimePromise = () => Effect.flatMap(make(), self => runtimePromise(self)());
+exports.makeRuntimePromise = makeRuntimePromise;
+const internalFiberIdId = -1;
+const internalFiberId = /*#__PURE__*/FiberId.make(internalFiberIdId, 0);
+const isInternalInterruption = /*#__PURE__*/Cause.reduceWithContext(undefined, {
+ emptyCase: _Function.constFalse,
+ failCase: _Function.constFalse,
+ dieCase: _Function.constFalse,
+ interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+ sequentialCase: (_, left, right) => left || right,
+ parallelCase: (_, left, right) => left || right
+});
+/**
+ * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const unsafeAdd = exports.unsafeAdd = /*#__PURE__*/(0, _Function.dual)(args => isFiberSet(args[0]), (self, fiber, options) => {
+ if (self.state._tag === "Closed") {
+ fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId));
+ return;
+ } else if (self.state.backing.has(fiber)) {
+ return;
+ }
+ self.state.backing.add(fiber);
+ fiber.addObserver(exit => {
+ if (self.state._tag === "Closed") {
+ return;
+ }
+ self.state.backing.delete(fiber);
+ if (Exit.isFailure(exit) && (options?.propagateInterruption === true ? !isInternalInterruption(exit.cause) : !Cause.isInterruptedOnly(exit.cause))) {
+ Deferred.unsafeDone(self.deferred, exit);
+ }
+ });
+});
+/**
+ * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const add = exports.add = /*#__PURE__*/(0, _Function.dual)(args => isFiberSet(args[0]), (self, fiber, options) => Effect.fiberIdWith(fiberId => Effect.sync(() => unsafeAdd(self, fiber, {
+ ...options,
+ interruptAs: fiberId
+}))));
+/**
+ * @since 2.0.0
+ * @categories combinators
+ */
+const clear = self => Effect.withFiberRuntime(clearFiber => {
+ if (self.state._tag === "Closed") {
+ return Effect.void;
+ }
+ return Effect.forEach(self.state.backing, fiber =>
+ // will be removed by the observer
+ Fiber.interruptAs(fiber, FiberId.combine(clearFiber.id(), internalFiberId)));
+});
+exports.clear = clear;
+const constInterruptedFiber = /*#__PURE__*/function () {
+ let fiber = undefined;
+ return () => {
+ if (fiber === undefined) {
+ fiber = Effect.runFork(Effect.interrupt);
+ }
+ return fiber;
+ };
+}();
+/**
+ * Fork an Effect and add the forked fiber to the FiberSet.
+ * When the fiber completes, it will be removed from the FiberSet.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const run = function () {
+ const self = arguments[0];
+ if (!Effect.isEffect(arguments[1])) {
+ const options = arguments[1];
+ return effect => runImpl(self, effect, options);
+ }
+ return runImpl(self, arguments[1], arguments[2]);
+};
+exports.run = run;
+const runImpl = (self, effect, options) => Effect.fiberIdWith(fiberId => {
+ if (self.state._tag === "Closed") {
+ return Effect.sync(constInterruptedFiber);
+ }
+ return Effect.tap(Effect.forkDaemon(effect), fiber => unsafeAdd(self, fiber, {
+ ...options,
+ interruptAs: fiberId
+ }));
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
+ *
+ * @example
+ * ```ts
+ * import { Context, Effect, FiberSet } from "effect"
+ *
+ * interface Users {
+ * readonly _: unique symbol
+ * }
+ * const Users = Context.GenericTag>
+ * }>("Users")
+ *
+ * Effect.gen(function*() {
+ * const set = yield* FiberSet.make()
+ * const run = yield* FiberSet.runtime(set)()
+ *
+ * // run some effects and add the fibers to the set
+ * run(Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ * Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+const runtime = self => () => Effect.map(Effect.runtime(), runtime => {
+ const runFork = Runtime.runFork(runtime);
+ return (effect, options) => {
+ if (self.state._tag === "Closed") {
+ return constInterruptedFiber();
+ }
+ const fiber = runFork(effect, options);
+ unsafeAdd(self, fiber);
+ return fiber;
+ };
+});
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
+ *
+ * The returned run function will return Promise's.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.runtime = runtime;
+const runtimePromise = self => () => Effect.map(runtime(self)(), runFork => (effect, options) => new Promise((resolve, reject) => runFork(effect, options).addObserver(exit => {
+ if (Exit.isSuccess(exit)) {
+ resolve(exit.value);
+ } else {
+ reject(Cause.squash(exit.cause));
+ }
+})));
+/**
+ * @since 2.0.0
+ * @categories combinators
+ */
+exports.runtimePromise = runtimePromise;
+const size = self => Effect.sync(() => self.state._tag === "Closed" ? 0 : self.state.backing.size);
+/**
+ * Join all fibers in the FiberSet. If any of the Fiber's in the set terminate with a failure,
+ * the returned Effect will terminate with the first failure that occurred.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ * @example
+ * ```ts
+ * import { Effect, FiberSet } from "effect";
+ *
+ * Effect.gen(function* (_) {
+ * const set = yield* _(FiberSet.make());
+ * yield* _(FiberSet.add(set, Effect.runFork(Effect.fail("error"))));
+ *
+ * // parent fiber will fail with "error"
+ * yield* _(FiberSet.join(set));
+ * });
+ * ```
+ */
+exports.size = size;
+const join = self => Deferred.await(self.deferred);
+/**
+ * Wait until the fiber set is empty.
+ *
+ * @since 3.13.0
+ * @categories combinators
+ */
+exports.join = join;
+const awaitEmpty = self => Effect.whileLoop({
+ while: () => self.state._tag === "Open" && self.state.backing.size > 0,
+ body: () => Fiber.await(Iterable.unsafeHead(self)),
+ step: _Function.constVoid
+});
+exports.awaitEmpty = awaitEmpty;
+//# sourceMappingURL=FiberSet.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberSet.js.map b/backend/node_modules/effect/dist/cjs/FiberSet.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..5edc1655f02cbe0e0f831e262867fbb6566f417e
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberSet.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FiberSet.js","names":["Cause","_interopRequireWildcard","require","Deferred","Effect","Exit","Fiber","FiberId","_Function","HashSet","Inspectable","Iterable","_Pipeable","Predicate","Runtime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","Symbol","for","isFiberSet","u","hasProperty","Proto","iterator","state","_tag","empty","backing","toString","format","toJSON","_id","NodeInspectSymbol","pipe","pipeArguments","arguments","unsafeMake","deferred","self","create","make","acquireRelease","map","Set","withFiberRuntime","parent","void","fibers","interruptAllAs","combine","id","internalFiberId","intoDeferred","makeRuntime","flatMap","runtime","makeRuntimePromise","runtimePromise","internalFiberIdId","isInternalInterruption","reduceWithContext","undefined","emptyCase","constFalse","failCase","dieCase","interruptCase","_","fiberId","ids","sequentialCase","left","right","parallelCase","unsafeAdd","dual","args","fiber","options","unsafeInterruptAsFork","interruptAs","none","add","addObserver","exit","delete","isFailure","propagateInterruption","cause","isInterruptedOnly","unsafeDone","fiberIdWith","sync","clear","clearFiber","forEach","constInterruptedFiber","runFork","interrupt","run","isEffect","effect","runImpl","tap","forkDaemon","Promise","resolve","reject","isSuccess","value","squash","size","join","await","awaitEmpty","whileLoop","while","body","unsafeHead","step","constVoid"],"sources":["../../src/FiberSet.ts"],"sourcesContent":[null],"mappings":";;;;;;AAGA,IAAAA,KAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,QAAA,GAAAF,uBAAA,CAAAC,OAAA;AACA,IAAAE,MAAA,GAAAH,uBAAA,CAAAC,OAAA;AACA,IAAAG,IAAA,GAAAJ,uBAAA,CAAAC,OAAA;AACA,IAAAI,KAAA,GAAAL,uBAAA,CAAAC,OAAA;AACA,IAAAK,OAAA,GAAAN,uBAAA,CAAAC,OAAA;AACA,IAAAM,SAAA,GAAAN,OAAA;AACA,IAAAO,OAAA,GAAAR,uBAAA,CAAAC,OAAA;AACA,IAAAQ,WAAA,GAAAT,uBAAA,CAAAC,OAAA;AACA,IAAAS,QAAA,GAAAV,uBAAA,CAAAC,OAAA;AACA,IAAAU,SAAA,GAAAV,OAAA;AACA,IAAAW,SAAA,GAAAZ,uBAAA,CAAAC,OAAA;AACA,IAAAY,OAAA,GAAAb,uBAAA,CAAAC,OAAA;AAAuC,SAAAD,wBAAAc,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAhB,uBAAA,YAAAA,CAAAc,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAfvC;;;;AAkBA;;;;AAIO,MAAMkB,MAAM,GAAAC,OAAA,CAAAD,MAAA,gBAAkBE,MAAM,CAACC,GAAG,CAAC,iBAAiB,CAAC;AA0BlE;;;;AAIO,MAAMC,UAAU,GAAIC,CAAU,IAAsC1B,SAAS,CAAC2B,WAAW,CAACD,CAAC,EAAEL,MAAM,CAAC;AAAAC,OAAA,CAAAG,UAAA,GAAAA,UAAA;AAE3G,MAAMG,KAAK,GAAG;EACZ,CAACP,MAAM,GAAGA,MAAM;EAChB,CAACE,MAAM,CAACM,QAAQ,IAAC;IACf,IAAI,IAAI,CAACC,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;MAChC,OAAOjC,QAAQ,CAACkC,KAAK,EAAE;IACzB;IACA,OAAO,IAAI,CAACF,KAAK,CAACG,OAAO,CAACV,MAAM,CAACM,QAAQ,CAAC,EAAE;EAC9C,CAAC;EACDK,QAAQA,CAAA;IACN,OAAOrC,WAAW,CAACsC,MAAM,CAAC,IAAI,CAACC,MAAM,EAAE,CAAC;EAC1C,CAAC;EACDA,MAAMA,CAAA;IACJ,OAAO;MACLC,GAAG,EAAE,UAAU;MACfP,KAAK,EAAE,IAAI,CAACA;KACb;EACH,CAAC;EACD,CAACjC,WAAW,CAACyC,iBAAiB,IAAC;IAC7B,OAAO,IAAI,CAACF,MAAM,EAAE;EACtB,CAAC;EACDG,IAAIA,CAAA;IACF,OAAO,IAAAC,uBAAa,EAAC,IAAI,EAAEC,SAAS,CAAC;EACvC;CACD;AAED,MAAMC,UAAU,GAAGA,CACjBT,OAAsC,EACtCU,QAA0C,KACxB;EAClB,MAAMC,IAAI,GAAG1B,MAAM,CAAC2B,MAAM,CAACjB,KAAK,CAAC;EACjCgB,IAAI,CAACd,KAAK,GAAG;IAAEC,IAAI,EAAE,MAAM;IAAEE;EAAO,CAAE;EACtCW,IAAI,CAACD,QAAQ,GAAGA,QAAQ;EACxB,OAAOC,IAAI;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BO,MAAME,IAAI,GAAGA,CAAA,KAClBvD,MAAM,CAACwD,cAAc,CACnBxD,MAAM,CAACyD,GAAG,CAAC1D,QAAQ,CAACwD,IAAI,EAAiB,EAAGH,QAAQ,IAAKD,UAAU,CAAC,IAAIO,GAAG,EAAE,EAAEN,QAAQ,CAAC,CAAC,EACxF5B,GAAG,IACFxB,MAAM,CAAC2D,gBAAgB,CAAEC,MAAM,IAAI;EACjC,MAAMrB,KAAK,GAAGf,GAAG,CAACe,KAAK;EACvB,IAAIA,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE,OAAOxC,MAAM,CAAC6D,IAAI;EAC/CrC,GAAG,CAACe,KAAK,GAAG;IAAEC,IAAI,EAAE;EAAQ,CAAE;EAC9B,MAAMsB,MAAM,GAAGvB,KAAK,CAACG,OAAO;EAC5B,OAAOxC,KAAK,CAAC6D,cAAc,CAACD,MAAM,EAAE3D,OAAO,CAAC6D,OAAO,CAACJ,MAAM,CAACK,EAAE,EAAE,EAAEC,eAAe,CAAC,CAAC,CAAClB,IAAI,CACrFhD,MAAM,CAACmE,YAAY,CAAC3C,GAAG,CAAC4B,QAAQ,CAAC,CAClC;AACH,CAAC,CAAC,CACL;AAEH;;;;;;AAAArB,OAAA,CAAAwB,IAAA,GAAAA,IAAA;AAMO,MAAMa,WAAW,GAAGA,CAAA,KAQzBpE,MAAM,CAACqE,OAAO,CACZd,IAAI,EAAQ,EACXF,IAAI,IAAKiB,OAAO,CAACjB,IAAI,CAAC,EAAK,CAC7B;AAEH;;;;;;AAAAtB,OAAA,CAAAqC,WAAA,GAAAA,WAAA;AAMO,MAAMG,kBAAkB,GAAGA,CAAA,KAQhCvE,MAAM,CAACqE,OAAO,CACZd,IAAI,EAAQ,EACXF,IAAI,IAAKmB,cAAc,CAACnB,IAAI,CAAC,EAAK,CACpC;AAAAtB,OAAA,CAAAwC,kBAAA,GAAAA,kBAAA;AAEH,MAAME,iBAAiB,GAAG,CAAC,CAAC;AAC5B,MAAMP,eAAe,gBAAG/D,OAAO,CAACoD,IAAI,CAACkB,iBAAiB,EAAE,CAAC,CAAC;AAC1D,MAAMC,sBAAsB,gBAAG9E,KAAK,CAAC+E,iBAAiB,CAACC,SAAS,EAAE;EAChEC,SAAS,EAAEC,oBAAU;EACrBC,QAAQ,EAAED,oBAAU;EACpBE,OAAO,EAAEF,oBAAU;EACnBG,aAAa,EAAEA,CAACC,CAAC,EAAEC,OAAO,KAAK9E,OAAO,CAACiB,GAAG,CAACnB,OAAO,CAACiF,GAAG,CAACD,OAAO,CAAC,EAAEV,iBAAiB,CAAC;EACnFY,cAAc,EAAEA,CAACH,CAAC,EAAEI,IAAI,EAAEC,KAAK,KAAKD,IAAI,IAAIC,KAAK;EACjDC,YAAY,EAAEA,CAACN,CAAC,EAAEI,IAAI,EAAEC,KAAK,KAAKD,IAAI,IAAIC;CAC3C,CAAC;AAEF;;;;;;AAMO,MAAME,SAAS,GAAA1D,OAAA,CAAA0D,SAAA,gBA4BlB,IAAAC,cAAI,EAAEC,IAAI,IAAKzD,UAAU,CAACyD,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CACtCtC,IAAoB,EACpBuC,KAAiC,EACjCC,OAGa,KACL;EACR,IAAIxC,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;IAChCoD,KAAK,CAACE,qBAAqB,CAAC3F,OAAO,CAAC6D,OAAO,CAAC6B,OAAO,EAAEE,WAAW,IAAI5F,OAAO,CAAC6F,IAAI,EAAE9B,eAAe,CAAC,CAAC;IACnG;EACF,CAAC,MAAM,IAAIb,IAAI,CAACd,KAAK,CAACG,OAAO,CAACpB,GAAG,CAACsE,KAAK,CAAC,EAAE;IACxC;EACF;EACAvC,IAAI,CAACd,KAAK,CAACG,OAAO,CAACuD,GAAG,CAACL,KAAK,CAAC;EAC7BA,KAAK,CAACM,WAAW,CAAEC,IAAI,IAAI;IACzB,IAAI9C,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;MAChC;IACF;IACAa,IAAI,CAACd,KAAK,CAACG,OAAO,CAAC0D,MAAM,CAACR,KAAK,CAAC;IAChC,IACE3F,IAAI,CAACoG,SAAS,CAACF,IAAI,CAAC,KAElBN,OAAO,EAAES,qBAAqB,KAAK,IAAI,GACrC,CAAC5B,sBAAsB,CAACyB,IAAI,CAACI,KAAK,CAAC,GACnC,CAAC3G,KAAK,CAAC4G,iBAAiB,CAACL,IAAI,CAACI,KAAK,CAAC,CACvC,EACD;MACAxG,QAAQ,CAAC0G,UAAU,CAACpD,IAAI,CAACD,QAAQ,EAAE+C,IAAW,CAAC;IACjD;EACF,CAAC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;AAMO,MAAMF,GAAG,GAAAlE,OAAA,CAAAkE,GAAA,gBA0BZ,IAAAP,cAAI,EACLC,IAAI,IAAKzD,UAAU,CAACyD,IAAI,CAAC,CAAC,CAAC,CAAC,EAC7B,CACEtC,IAAoB,EACpBuC,KAAiC,EACjCC,OAEa,KAEb7F,MAAM,CAAC0G,WAAW,CAAEvB,OAAO,IACzBnF,MAAM,CAAC2G,IAAI,CAAC,MACVlB,SAAS,CAACpC,IAAI,EAAEuC,KAAK,EAAE;EACrB,GAAGC,OAAO;EACVE,WAAW,EAAEZ;CACd,CAAC,CACH,CACF,CACJ;AAED;;;;AAIO,MAAMyB,KAAK,GAAUvD,IAAoB,IAC9CrD,MAAM,CAAC2D,gBAAgB,CAAEkD,UAAU,IAAI;EACrC,IAAIxD,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;IAChC,OAAOxC,MAAM,CAAC6D,IAAI;EACpB;EACA,OAAO7D,MAAM,CAAC8G,OAAO,CAACzD,IAAI,CAACd,KAAK,CAACG,OAAO,EAAGkD,KAAK;EAC9C;EACA1F,KAAK,CAAC6F,WAAW,CAACH,KAAK,EAAEzF,OAAO,CAAC6D,OAAO,CAAC6C,UAAU,CAAC5C,EAAE,EAAE,EAAEC,eAAe,CAAC,CAAC,CAAC;AAChF,CAAC,CAAC;AAAAnC,OAAA,CAAA6E,KAAA,GAAAA,KAAA;AAEJ,MAAMG,qBAAqB,gBAAI;EAC7B,IAAInB,KAAK,GAAiDhB,SAAS;EACnE,OAAO,MAAK;IACV,IAAIgB,KAAK,KAAKhB,SAAS,EAAE;MACvBgB,KAAK,GAAG5F,MAAM,CAACgH,OAAO,CAAChH,MAAM,CAACiH,SAAS,CAAC;IAC1C;IACA,OAAOrB,KAAK;EACd,CAAC;AACH,CAAC,CAAC,CAAE;AAEJ;;;;;;;AAOO,MAAMsB,GAAG,GA8BZ,SAAAA,CAAA;EACF,MAAM7D,IAAI,GAAGH,SAAS,CAAC,CAAC,CAAuB;EAC/C,IAAI,CAAClD,MAAM,CAACmH,QAAQ,CAACjE,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;IAClC,MAAM2C,OAAO,GAAG3C,SAAS,CAAC,CAAC,CAAC;IAC5B,OAAQkE,MAAoC,IAAKC,OAAO,CAAChE,IAAI,EAAE+D,MAAM,EAAEvB,OAAO,CAAC;EACjF;EACA,OAAOwB,OAAO,CAAChE,IAAI,EAAEH,SAAS,CAAC,CAAC,CAAC,EAAEA,SAAS,CAAC,CAAC,CAAC,CAAQ;AACzD,CAAC;AAAAnB,OAAA,CAAAmF,GAAA,GAAAA,GAAA;AAED,MAAMG,OAAO,GAAGA,CACdhE,IAAoB,EACpB+D,MAAgC,EAChCvB,OAEC,KAED7F,MAAM,CAAC0G,WAAW,CAAEvB,OAAO,IAAI;EAC7B,IAAI9B,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;IAChC,OAAOxC,MAAM,CAAC2G,IAAI,CAACI,qBAAqB,CAAC;EAC3C;EACA,OAAO/G,MAAM,CAACsH,GAAG,CACftH,MAAM,CAACuH,UAAU,CAACH,MAAM,CAAC,EACxBxB,KAAK,IACJH,SAAS,CAACpC,IAAI,EAAEuC,KAAK,EAAE;IACrB,GAAGC,OAAO;IACVE,WAAW,EAAEZ;GACd,CAAC,CACL;AACH,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BO,MAAMb,OAAO,GAWTjB,IAAoB,IAAK,MAClCrD,MAAM,CAACyD,GAAG,CACRzD,MAAM,CAACsE,OAAO,EAAK,EAClBA,OAAO,IAAI;EACV,MAAM0C,OAAO,GAAGtG,OAAO,CAACsG,OAAO,CAAC1C,OAAO,CAAC;EACxC,OAAO,CACL8C,MAAgC,EAChCvB,OAEa,KACX;IACF,IAAIxC,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,EAAE;MAChC,OAAOuE,qBAAqB,EAAE;IAChC;IACA,MAAMnB,KAAK,GAAGoB,OAAO,CAACI,MAAM,EAAEvB,OAAO,CAAC;IACtCJ,SAAS,CAACpC,IAAI,EAAEuC,KAAK,CAAC;IACtB,OAAOA,KAAK;EACd,CAAC;AACH,CAAC,CACF;AAEH;;;;;;;;AAAA7D,OAAA,CAAAuC,OAAA,GAAAA,OAAA;AAQO,MAAME,cAAc,GAAUnB,IAAoB,IAUzD,MACErD,MAAM,CAACyD,GAAG,CACRa,OAAO,CAACjB,IAAI,CAAC,EAAK,EACjB2D,OAAO,IACR,CACEI,MAAgC,EAChCvB,OAEa,KAEb,IAAI2B,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAC1BV,OAAO,CAACI,MAAM,EAAEvB,OAAO,CAAC,CAACK,WAAW,CAAEC,IAAI,IAAI;EAC5C,IAAIlG,IAAI,CAAC0H,SAAS,CAACxB,IAAI,CAAC,EAAE;IACxBsB,OAAO,CAACtB,IAAI,CAACyB,KAAK,CAAC;EACrB,CAAC,MAAM;IACLF,MAAM,CAAC9H,KAAK,CAACiI,MAAM,CAAC1B,IAAI,CAACI,KAAK,CAAC,CAAC;EAClC;AACF,CAAC,CAAC,CACH,CACJ;AAEH;;;;AAAAxE,OAAA,CAAAyC,cAAA,GAAAA,cAAA;AAIO,MAAMsD,IAAI,GAAUzE,IAAoB,IAC7CrD,MAAM,CAAC2G,IAAI,CAAC,MAAMtD,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,QAAQ,GAAG,CAAC,GAAGa,IAAI,CAACd,KAAK,CAACG,OAAO,CAACoF,IAAI,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;AAAA/F,OAAA,CAAA+F,IAAA,GAAAA,IAAA;AAmBO,MAAMC,IAAI,GAAU1E,IAAoB,IAC7CtD,QAAQ,CAACiI,KAAK,CAAC3E,IAAI,CAACD,QAAsC,CAAC;AAE7D;;;;;;AAAArB,OAAA,CAAAgG,IAAA,GAAAA,IAAA;AAMO,MAAME,UAAU,GAAU5E,IAAoB,IACnDrD,MAAM,CAACkI,SAAS,CAAC;EACfC,KAAK,EAAEA,CAAA,KAAM9E,IAAI,CAACd,KAAK,CAACC,IAAI,KAAK,MAAM,IAAIa,IAAI,CAACd,KAAK,CAACG,OAAO,CAACoF,IAAI,GAAG,CAAC;EACtEM,IAAI,EAAEA,CAAA,KAAMlI,KAAK,CAAC8H,KAAK,CAACzH,QAAQ,CAAC8H,UAAU,CAAChF,IAAI,CAAC,CAAC;EAClDiF,IAAI,EAAEC;CACP,CAAC;AAAAxG,OAAA,CAAAkG,UAAA,GAAAA,UAAA","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberStatus.js b/backend/node_modules/effect/dist/cjs/FiberStatus.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e1304f169ead30bbb0c5ec3a7c8b39d30954fbd
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberStatus.js
@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.suspended = exports.running = exports.isSuspended = exports.isRunning = exports.isFiberStatus = exports.isDone = exports.done = exports.FiberStatusTypeId = void 0;
+var internal = _interopRequireWildcard(require("./internal/fiberStatus.js"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const FiberStatusTypeId = exports.FiberStatusTypeId = internal.FiberStatusTypeId;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const done = exports.done = internal.done;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const running = exports.running = internal.running;
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspended = exports.suspended = internal.suspended;
+/**
+ * Returns `true` if the specified value is a `FiberStatus`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFiberStatus = exports.isFiberStatus = internal.isFiberStatus;
+/**
+ * Returns `true` if the specified `FiberStatus` is `Done`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isDone = exports.isDone = internal.isDone;
+/**
+ * Returns `true` if the specified `FiberStatus` is `Running`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isRunning = exports.isRunning = internal.isRunning;
+/**
+ * Returns `true` if the specified `FiberStatus` is `Suspended`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSuspended = exports.isSuspended = internal.isSuspended;
+//# sourceMappingURL=FiberStatus.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/FiberStatus.js.map b/backend/node_modules/effect/dist/cjs/FiberStatus.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..65ddf73adb70f7b6ca8d3f9a354c186236b2734a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/FiberStatus.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"FiberStatus.js","names":["internal","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","FiberStatusTypeId","exports","done","running","suspended","isFiberStatus","isDone","isRunning","isSuspended"],"sources":["../../src/FiberStatus.ts"],"sourcesContent":[null],"mappings":";;;;;;AAKA,IAAAA,QAAA,GAAAC,uBAAA,CAAAC,OAAA;AAAqD,SAAAD,wBAAAE,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAJ,uBAAA,YAAAA,CAAAE,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAGrD;;;;AAIO,MAAMkB,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAkBtB,QAAQ,CAACsB,iBAAiB;AA4C1E;;;;AAIO,MAAME,IAAI,GAAAD,OAAA,CAAAC,IAAA,GAAgBxB,QAAQ,CAACwB,IAAI;AAE9C;;;;AAIO,MAAMC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAA6DzB,QAAQ,CAACyB,OAAO;AAEjG;;;;AAIO,MAAMC,SAAS,GAAAH,OAAA,CAAAG,SAAA,GACpB1B,QAAQ,CAAC0B,SAAS;AAEpB;;;;;;AAMO,MAAMC,aAAa,GAAAJ,OAAA,CAAAI,aAAA,GAAqC3B,QAAQ,CAAC2B,aAAa;AAErF;;;;;;AAMO,MAAMC,MAAM,GAAAL,OAAA,CAAAK,MAAA,GAAwC5B,QAAQ,CAAC4B,MAAM;AAE1E;;;;;;;AAOO,MAAMC,SAAS,GAAAN,OAAA,CAAAM,SAAA,GAA2C7B,QAAQ,CAAC6B,SAAS;AAEnF;;;;;;;AAOO,MAAMC,WAAW,GAAAP,OAAA,CAAAO,WAAA,GAA6C9B,QAAQ,CAAC8B,WAAW","ignoreList":[]}
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Function.js b/backend/node_modules/effect/dist/cjs/Function.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e07331341b6f04f317b6ddc87a503d7993ee51a
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Function.js
@@ -0,0 +1,488 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.flip = exports.dual = exports.constant = exports.constVoid = exports.constUndefined = exports.constTrue = exports.constNull = exports.constFalse = exports.compose = exports.apply = exports.absurd = exports.SK = void 0;
+exports.flow = flow;
+exports.isFunction = exports.identity = exports.hole = void 0;
+exports.pipe = pipe;
+exports.untupled = exports.unsafeCoerce = exports.tupled = exports.satisfies = void 0;
+/**
+ * Tests if a value is a `function`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { isFunction } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isFunction(isFunction), true)
+ * assert.deepStrictEqual(isFunction("function"), false)
+ * ```
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isFunction = input => typeof input === "function";
+/**
+ * Creates a function that can be used in a data-last (aka `pipe`able) or
+ * data-first style.
+ *
+ * The first parameter to `dual` is either the arity of the uncurried function
+ * or a predicate that determines if the function is being used in a data-first
+ * or data-last style.
+ *
+ * Using the arity is the most common use case, but there are some cases where
+ * you may want to use a predicate. For example, if you have a function that
+ * takes an optional argument, you can use a predicate to determine if the
+ * function is being used in a data-first or data-last style.
+ *
+ * You can pass either the arity of the uncurried function or a predicate
+ * which determines if the function is being used in a data-first or
+ * data-last style.
+ *
+ * **Example** (Using arity to determine data-first or data-last style)
+ *
+ * ```ts
+ * import { dual, pipe } from "effect/Function"
+ *
+ * const sum = dual<
+ * (that: number) => (self: number) => number,
+ * (self: number, that: number) => number
+ * >(2, (self, that) => self + that)
+ *
+ * console.log(sum(2, 3)) // 5
+ * console.log(pipe(2, sum(3))) // 5
+ * ```
+ *
+ * **Example** (Using call signatures to define the overloads)
+ *
+ * ```ts
+ * import { dual, pipe } from "effect/Function"
+ *
+ * const sum: {
+ * (that: number): (self: number) => number
+ * (self: number, that: number): number
+ * } = dual(2, (self: number, that: number): number => self + that)
+ *
+ * console.log(sum(2, 3)) // 5
+ * console.log(pipe(2, sum(3))) // 5
+ * ```
+ *
+ * **Example** (Using a predicate to determine data-first or data-last style)
+ *
+ * ```ts
+ * import { dual, pipe } from "effect/Function"
+ *
+ * const sum = dual<
+ * (that: number) => (self: number) => number,
+ * (self: number, that: number) => number
+ * >(
+ * (args) => args.length === 2,
+ * (self, that) => self + that
+ * )
+ *
+ * console.log(sum(2, 3)) // 5
+ * console.log(pipe(2, sum(3))) // 5
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.isFunction = isFunction;
+const dual = function (arity, body) {
+ if (typeof arity === "function") {
+ return function () {
+ if (arity(arguments)) {
+ // @ts-expect-error
+ return body.apply(this, arguments);
+ }
+ return self => body(self, ...arguments);
+ };
+ }
+ switch (arity) {
+ case 0:
+ case 1:
+ throw new RangeError(`Invalid arity ${arity}`);
+ case 2:
+ return function (a, b) {
+ if (arguments.length >= 2) {
+ return body(a, b);
+ }
+ return function (self) {
+ return body(self, a);
+ };
+ };
+ case 3:
+ return function (a, b, c) {
+ if (arguments.length >= 3) {
+ return body(a, b, c);
+ }
+ return function (self) {
+ return body(self, a, b);
+ };
+ };
+ case 4:
+ return function (a, b, c, d) {
+ if (arguments.length >= 4) {
+ return body(a, b, c, d);
+ }
+ return function (self) {
+ return body(self, a, b, c);
+ };
+ };
+ case 5:
+ return function (a, b, c, d, e) {
+ if (arguments.length >= 5) {
+ return body(a, b, c, d, e);
+ }
+ return function (self) {
+ return body(self, a, b, c, d);
+ };
+ };
+ default:
+ return function () {
+ if (arguments.length >= arity) {
+ // @ts-expect-error
+ return body.apply(this, arguments);
+ }
+ const args = arguments;
+ return function (self) {
+ return body(self, ...args);
+ };
+ };
+ }
+};
+/**
+ * Apply a function to given values.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { pipe, apply } from "effect/Function"
+ * import { length } from "effect/String"
+ *
+ * assert.deepStrictEqual(pipe(length, apply("hello")), 5)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.dual = dual;
+const apply = (...a) => self => self(...a);
+/**
+ * The identity function, i.e. A function that returns its input argument.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { identity } from "effect/Function"
+ *
+ * assert.deepStrictEqual(identity(5), 5)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.apply = apply;
+const identity = a => a;
+/**
+ * A function that ensures that the type of an expression matches some type,
+ * without changing the resulting type of that expression.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { satisfies } from "effect/Function"
+ *
+ * const test1 = satisfies()(5 as const)
+ * //^? const test: 5
+ * // @ts-expect-error
+ * const test2 = satisfies()(5)
+ * //^? Argument of type 'number' is not assignable to parameter of type 'string'
+ *
+ * assert.deepStrictEqual(satisfies()(5), 5)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.identity = identity;
+const satisfies = () => b => b;
+/**
+ * Casts the result to the specified type.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeCoerce, identity } from "effect/Function"
+ *
+ * assert.deepStrictEqual(unsafeCoerce, identity)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.satisfies = satisfies;
+const unsafeCoerce = exports.unsafeCoerce = identity;
+/**
+ * Creates a constant value that never changes.
+ *
+ * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
+ * and want that inner function to always use the same value, no matter how many times it is called.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constant } from "effect/Function"
+ *
+ * const constNull = constant(null)
+ *
+ * assert.deepStrictEqual(constNull(), null)
+ * assert.deepStrictEqual(constNull(), null)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const constant = value => () => value;
+/**
+ * A thunk that returns always `true`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constTrue } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constTrue(), true)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.constant = constant;
+const constTrue = exports.constTrue = /*#__PURE__*/constant(true);
+/**
+ * A thunk that returns always `false`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constFalse } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constFalse(), false)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const constFalse = exports.constFalse = /*#__PURE__*/constant(false);
+/**
+ * A thunk that returns always `null`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constNull } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constNull(), null)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const constNull = exports.constNull = /*#__PURE__*/constant(null);
+/**
+ * A thunk that returns always `undefined`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constUndefined } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constUndefined(), undefined)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const constUndefined = exports.constUndefined = /*#__PURE__*/constant(undefined);
+/**
+ * A thunk that returns always `void`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { constVoid } from "effect/Function"
+ *
+ * assert.deepStrictEqual(constVoid(), undefined)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const constVoid = exports.constVoid = constUndefined;
+/**
+ * Reverses the order of arguments for a curried function.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { flip } from "effect/Function"
+ *
+ * const f = (a: number) => (b: string) => a - b.length
+ *
+ * assert.deepStrictEqual(flip(f)('aaa')(2), -1)
+ * ```
+ *
+ * @since 2.0.0
+ */
+const flip = f => (...b) => (...a) => f(...a)(...b);
+/**
+ * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+ * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { compose } from "effect/Function"
+ *
+ * const increment = (n: number) => n + 1;
+ * const square = (n: number) => n * n;
+ *
+ * assert.strictEqual(compose(increment, square)(2), 9);
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.flip = flip;
+const compose = exports.compose = /*#__PURE__*/dual(2, (ab, bc) => a => bc(ab(a)));
+/**
+ * The `absurd` function is a stub for cases where a value of type `never` is encountered in your code,
+ * meaning that it should be impossible for this code to be executed.
+ *
+ * This function is particularly useful when it's necessary to specify that certain cases are impossible.
+ *
+ * @since 2.0.0
+ */
+const absurd = _ => {
+ throw new Error("Called `absurd` function which should be uncallable");
+};
+/**
+ * Creates a version of this function: instead of `n` arguments, it accepts a single tuple argument.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { tupled } from "effect/Function"
+ *
+ * const sumTupled = tupled((x: number, y: number): number => x + y)
+ *
+ * assert.deepStrictEqual(sumTupled([1, 2]), 3)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.absurd = absurd;
+const tupled = f => a => f(...a);
+/**
+ * Inverse function of `tupled`
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { untupled } from "effect/Function"
+ *
+ * const getFirst = untupled((tuple: [A, B]): A => tuple[0])
+ *
+ * assert.deepStrictEqual(getFirst(1, 2), 1)
+ * ```
+ *
+ * @since 2.0.0
+ */
+exports.tupled = tupled;
+const untupled = f => (...a) => f(a);
+exports.untupled = untupled;
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+ switch (arguments.length) {
+ case 1:
+ return a;
+ case 2:
+ return ab(a);
+ case 3:
+ return bc(ab(a));
+ case 4:
+ return cd(bc(ab(a)));
+ case 5:
+ return de(cd(bc(ab(a))));
+ case 6:
+ return ef(de(cd(bc(ab(a)))));
+ case 7:
+ return fg(ef(de(cd(bc(ab(a))))));
+ case 8:
+ return gh(fg(ef(de(cd(bc(ab(a)))))));
+ case 9:
+ return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+ default:
+ {
+ let ret = arguments[0];
+ for (let i = 1; i < arguments.length; i++) {
+ ret = arguments[i](ret);
+ }
+ return ret;
+ }
+ }
+}
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+ switch (arguments.length) {
+ case 1:
+ return ab;
+ case 2:
+ return function () {
+ return bc(ab.apply(this, arguments));
+ };
+ case 3:
+ return function () {
+ return cd(bc(ab.apply(this, arguments)));
+ };
+ case 4:
+ return function () {
+ return de(cd(bc(ab.apply(this, arguments))));
+ };
+ case 5:
+ return function () {
+ return ef(de(cd(bc(ab.apply(this, arguments)))));
+ };
+ case 6:
+ return function () {
+ return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+ };
+ case 7:
+ return function () {
+ return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+ };
+ case 8:
+ return function () {
+ return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+ };
+ case 9:
+ return function () {
+ return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+ };
+ }
+ return;
+}
+/**
+ * Type hole simulation.
+ *
+ * @since 2.0.0
+ */
+const hole = exports.hole = /*#__PURE__*/unsafeCoerce(absurd);
+/**
+ * The SK combinator, also known as the "S-K combinator" or "S-combinator", is a fundamental combinator in the
+ * lambda calculus and the SKI combinator calculus.
+ *
+ * This function is useful for discarding the first argument passed to it and returning the second argument.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { SK } from "effect/Function";
+ *
+ * assert.deepStrictEqual(SK(0, "hello"), "hello")
+ * ```
+ *
+ * @since 2.0.0
+ */
+const SK = (_, b) => b;
+exports.SK = SK;
+//# sourceMappingURL=Function.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/GlobalValue.js b/backend/node_modules/effect/dist/cjs/GlobalValue.js
new file mode 100644
index 0000000000000000000000000000000000000000..816221c9b593868c6c13b93aeeb195f991180af9
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/GlobalValue.js
@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.globalValue = void 0;
+/**
+ * The `GlobalValue` module ensures that a single instance of a value is created globally,
+ * even when modules are imported multiple times (e.g., due to mixing CommonJS and ESM builds)
+ * or during hot-reloading in development environments like Next.js or Remix.
+ *
+ * It achieves this by using a versioned global store, identified by a unique `Symbol` tied to
+ * the current version of the `effect` library. The store holds values that are keyed by an identifier,
+ * allowing the reuse of previously computed instances across imports or reloads.
+ *
+ * This pattern is particularly useful in scenarios where frequent reloading can cause services or
+ * single-instance objects to be recreated unnecessarily, such as in development environments with hot-reloading.
+ *
+ * @since 2.0.0
+ */
+const globalStoreId = `effect/GlobalValue`;
+let globalStore;
+/**
+ * Retrieves or computes a global value associated with the given `id`. If the value for this `id`
+ * has already been computed, it will be returned from the global store. If it does not exist yet,
+ * the provided `compute` function will be executed to compute the value, store it, and then return it.
+ *
+ * This ensures that even in cases where the module is imported multiple times (e.g., in mixed environments
+ * like CommonJS and ESM, or during hot-reloading in development), the value is computed only once and reused
+ * thereafter.
+ *
+ * @example
+ * ```ts
+ * import { globalValue } from "effect/GlobalValue"
+ *
+ * // This cache will persist as long as the module is running,
+ * // even if reloaded or imported elsewhere
+ * const myCache = globalValue(
+ * Symbol.for("myCache"),
+ * () => new WeakMap()
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ */
+const globalValue = (id, compute) => {
+ if (!globalStore) {
+ // @ts-expect-error
+ globalThis[globalStoreId] ??= new Map();
+ // @ts-expect-error
+ globalStore = globalThis[globalStoreId];
+ }
+ if (!globalStore.has(id)) {
+ globalStore.set(id, compute());
+ }
+ return globalStore.get(id);
+};
+exports.globalValue = globalValue;
+//# sourceMappingURL=GlobalValue.js.map
\ No newline at end of file
diff --git a/backend/node_modules/effect/dist/cjs/Graph.js b/backend/node_modules/effect/dist/cjs/Graph.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f4ec5b7464308c357a54366982050e803237374
--- /dev/null
+++ b/backend/node_modules/effect/dist/cjs/Graph.js
@@ -0,0 +1,3080 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.values = exports.updateNode = exports.updateEdge = exports.undirected = exports.topo = exports.toMermaid = exports.toGraphViz = exports.stronglyConnectedComponents = exports.reverse = exports.removeNode = exports.removeEdge = exports.nodes = exports.nodeCount = exports.neighborsDirected = exports.neighbors = exports.mutate = exports.mapNodes = exports.mapEdges = exports.isGraph = exports.isBipartite = exports.isAcyclic = exports.indices = exports.hasNode = exports.hasEdge = exports.getNode = exports.getEdge = exports.floydWarshall = exports.findNodes = exports.findNode = exports.findEdges = exports.findEdge = exports.filterNodes = exports.filterMapNodes = exports.filterMapEdges = exports.filterEdges = exports.externals = exports.entries = exports.endMutation = exports.edges = exports.edgeCount = exports.directed = exports.dijkstra = exports.dfsPostOrder = exports.dfs = exports.connectedComponents = exports.bfs = exports.bellmanFord = exports.beginMutation = exports.astar = exports.addNode = exports.addEdge = exports.Walker = exports.TypeId = exports.GraphError = exports.Edge = void 0;
+var Data = _interopRequireWildcard(require("./Data.js"));
+var Equal = _interopRequireWildcard(require("./Equal.js"));
+var _Function = require("./Function.js");
+var Hash = _interopRequireWildcard(require("./Hash.js"));
+var _Inspectable = require("./Inspectable.js");
+var Option = _interopRequireWildcard(require("./Option.js"));
+var _Pipeable = require("./Pipeable.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @experimental
+ * @since 3.18.0
+ */
+
+/**
+ * Unique identifier for Graph instances.
+ *
+ * @since 3.18.0
+ * @category symbol
+ */
+const TypeId = exports.TypeId = "~effect/Graph";
+/**
+ * Edge data containing source, target, and user data.
+ *
+ * @since 3.18.0
+ * @category models
+ */
+class Edge extends Data.Class {}
+// =============================================================================
+// Proto Objects
+// =============================================================================
+/** @internal */
+exports.Edge = Edge;
+const ProtoGraph = {
+ [TypeId]: TypeId,
+ [Symbol.iterator]() {
+ return this.nodes[Symbol.iterator]();
+ },
+ [_Inspectable.NodeInspectSymbol]() {
+ return this.toJSON();
+ },
+ [Equal.symbol](that) {
+ if (isGraph(that)) {
+ if (this.nodes.size !== that.nodes.size || this.edges.size !== that.edges.size || this.type !== that.type) {
+ return false;
+ }
+ // Compare nodes
+ for (const [nodeIndex, nodeData] of this.nodes) {
+ if (!that.nodes.has(nodeIndex)) {
+ return false;
+ }
+ const otherNodeData = that.nodes.get(nodeIndex);
+ if (!Equal.equals(nodeData, otherNodeData)) {
+ return false;
+ }
+ }
+ // Compare edges
+ for (const [edgeIndex, edgeData] of this.edges) {
+ if (!that.edges.has(edgeIndex)) {
+ return false;
+ }
+ const otherEdge = that.edges.get(edgeIndex);
+ if (!Equal.equals(edgeData, otherEdge)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ },
+ [Hash.symbol]() {
+ let hash = Hash.string("Graph");
+ hash = hash ^ Hash.string(this.type);
+ hash = hash ^ Hash.number(this.nodes.size);
+ hash = hash ^ Hash.number(this.edges.size);
+ for (const [nodeIndex, nodeData] of this.nodes) {
+ hash = hash ^ Hash.hash(nodeIndex) + Hash.hash(nodeData);
+ }
+ for (const [edgeIndex, edgeData] of this.edges) {
+ hash = hash ^ Hash.hash(edgeIndex) + Hash.hash(edgeData);
+ }
+ return hash;
+ },
+ toJSON() {
+ return {
+ _id: "Graph",
+ nodeCount: this.nodes.size,
+ edgeCount: this.edges.size,
+ type: this.type
+ };
+ },
+ toString() {
+ return (0, _Inspectable.format)(this);
+ },
+ pipe() {
+ return (0, _Pipeable.pipeArguments)(this, arguments);
+ }
+};
+// =============================================================================
+// Errors
+// =============================================================================
+/**
+ * Error thrown when a graph operation fails.
+ *
+ * @since 3.18.0
+ * @category errors
+ */
+class GraphError extends /*#__PURE__*/Data.TaggedError("GraphError") {}
+/** @internal */
+exports.GraphError = GraphError;
+const missingNode = node => new GraphError({
+ message: `Node ${node} does not exist`
+});
+// =============================================================================
+// Constructors
+// =============================================================================
+/** @internal */
+const isGraph = u => typeof u === "object" && u !== null && TypeId in u;
+/**
+ * Creates a directed graph, optionally with initial mutations.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * // Directed graph with initial nodes and edges
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, "A->B")
+ * Graph.addEdge(mutable, b, c, "B->C")
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category constructors
+ */
+exports.isGraph = isGraph;
+const directed = mutate => {
+ const graph = Object.create(ProtoGraph);
+ graph.type = "directed";
+ graph.nodes = new Map();
+ graph.edges = new Map();
+ graph.adjacency = new Map();
+ graph.reverseAdjacency = new Map();
+ graph.nextNodeIndex = 0;
+ graph.nextEdgeIndex = 0;
+ graph.isAcyclic = Option.some(true);
+ graph.mutable = false;
+ if (mutate) {
+ const mutable = beginMutation(graph);
+ mutate(mutable);
+ return endMutation(mutable);
+ }
+ return graph;
+};
+/**
+ * Creates an undirected graph, optionally with initial mutations.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * // Undirected graph with initial nodes and edges
+ * const graph = Graph.undirected((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, "A-B")
+ * Graph.addEdge(mutable, b, c, "B-C")
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category constructors
+ */
+exports.directed = directed;
+const undirected = mutate => {
+ const graph = Object.create(ProtoGraph);
+ graph.type = "undirected";
+ graph.nodes = new Map();
+ graph.edges = new Map();
+ graph.adjacency = new Map();
+ graph.reverseAdjacency = new Map();
+ graph.nextNodeIndex = 0;
+ graph.nextEdgeIndex = 0;
+ graph.isAcyclic = Option.some(true);
+ graph.mutable = false;
+ if (mutate) {
+ const mutable = beginMutation(graph);
+ mutate(mutable);
+ return endMutation(mutable);
+ }
+ return graph;
+};
+// =============================================================================
+// Scoped Mutable API
+// =============================================================================
+/**
+ * Creates a mutable scope for safe graph mutations by copying the data structure.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed()
+ * const mutable = Graph.beginMutation(graph)
+ * // Now mutable can be safely modified without affecting original graph
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.undirected = undirected;
+const beginMutation = graph => {
+ // Copy adjacency maps with deep cloned arrays
+ const adjacency = new Map();
+ const reverseAdjacency = new Map();
+ for (const [nodeIndex, edges] of graph.adjacency) {
+ adjacency.set(nodeIndex, [...edges]);
+ }
+ for (const [nodeIndex, edges] of graph.reverseAdjacency) {
+ reverseAdjacency.set(nodeIndex, [...edges]);
+ }
+ const mutable = Object.create(ProtoGraph);
+ mutable.type = graph.type;
+ mutable.nodes = new Map(graph.nodes);
+ mutable.edges = new Map(graph.edges);
+ mutable.adjacency = adjacency;
+ mutable.reverseAdjacency = reverseAdjacency;
+ mutable.nextNodeIndex = graph.nextNodeIndex;
+ mutable.nextEdgeIndex = graph.nextEdgeIndex;
+ mutable.isAcyclic = graph.isAcyclic;
+ mutable.mutable = true;
+ return mutable;
+};
+/**
+ * Converts a mutable graph back to an immutable graph, ending the mutation scope.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed()
+ * const mutable = Graph.beginMutation(graph)
+ * // ... perform mutations on mutable ...
+ * const newGraph = Graph.endMutation(mutable)
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.beginMutation = beginMutation;
+const endMutation = mutable => {
+ const graph = Object.create(ProtoGraph);
+ graph.type = mutable.type;
+ graph.nodes = new Map(mutable.nodes);
+ graph.edges = new Map(mutable.edges);
+ graph.adjacency = mutable.adjacency;
+ graph.reverseAdjacency = mutable.reverseAdjacency;
+ graph.nextNodeIndex = mutable.nextNodeIndex;
+ graph.nextEdgeIndex = mutable.nextEdgeIndex;
+ graph.isAcyclic = mutable.isAcyclic;
+ graph.mutable = false;
+ return graph;
+};
+/**
+ * Performs scoped mutations on a graph, automatically managing the mutation lifecycle.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed()
+ * const newGraph = Graph.mutate(graph, (mutable) => {
+ * // Safe mutations go here
+ * // mutable gets automatically converted back to immutable
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.endMutation = endMutation;
+const mutate = exports.mutate = /*#__PURE__*/(0, _Function.dual)(2, (graph, f) => {
+ const mutable = beginMutation(graph);
+ f(mutable);
+ return endMutation(mutable);
+});
+// =============================================================================
+// Basic Node Operations
+// =============================================================================
+/**
+ * Adds a new node to a mutable graph and returns its index.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const result = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * console.log(nodeA) // NodeIndex with value 0
+ * console.log(nodeB) // NodeIndex with value 1
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+const addNode = (mutable, data) => {
+ const nodeIndex = mutable.nextNodeIndex;
+ // Add node data
+ mutable.nodes.set(nodeIndex, data);
+ // Initialize empty adjacency lists
+ mutable.adjacency.set(nodeIndex, []);
+ mutable.reverseAdjacency.set(nodeIndex, []);
+ // Update graph allocators
+ mutable.nextNodeIndex = mutable.nextNodeIndex + 1;
+ return nodeIndex;
+};
+/**
+ * Gets the data associated with a node index, if it exists.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * Graph.addNode(mutable, "Node A")
+ * })
+ *
+ * const nodeIndex = 0
+ * const nodeData = Graph.getNode(graph, nodeIndex)
+ *
+ * if (Option.isSome(nodeData)) {
+ * console.log(nodeData.value) // "Node A"
+ * }
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.addNode = addNode;
+const getNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex) ? Option.some(graph.nodes.get(nodeIndex)) : Option.none();
+/**
+ * Checks if a node with the given index exists in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * Graph.addNode(mutable, "Node A")
+ * })
+ *
+ * const nodeIndex = 0
+ * const exists = Graph.hasNode(graph, nodeIndex)
+ * console.log(exists) // true
+ *
+ * const nonExistentIndex = 999
+ * const notExists = Graph.hasNode(graph, nonExistentIndex)
+ * console.log(notExists) // false
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.getNode = getNode;
+const hasNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex);
+/**
+ * Returns the number of nodes in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const emptyGraph = Graph.directed()
+ * console.log(Graph.nodeCount(emptyGraph)) // 0
+ *
+ * const graphWithNodes = Graph.mutate(emptyGraph, (mutable) => {
+ * Graph.addNode(mutable, "Node A")
+ * Graph.addNode(mutable, "Node B")
+ * Graph.addNode(mutable, "Node C")
+ * })
+ *
+ * console.log(Graph.nodeCount(graphWithNodes)) // 3
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.hasNode = hasNode;
+const nodeCount = graph => graph.nodes.size;
+/**
+ * Finds the first node that matches the given predicate.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * Graph.addNode(mutable, "Node A")
+ * Graph.addNode(mutable, "Node B")
+ * Graph.addNode(mutable, "Node C")
+ * })
+ *
+ * const result = Graph.findNode(graph, (data) => data.startsWith("Node B"))
+ * console.log(result) // Option.some(1)
+ *
+ * const notFound = Graph.findNode(graph, (data) => data === "Node D")
+ * console.log(notFound) // Option.none()
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.nodeCount = nodeCount;
+const findNode = (graph, predicate) => {
+ for (const [index, data] of graph.nodes) {
+ if (predicate(data)) {
+ return Option.some(index);
+ }
+ }
+ return Option.none();
+};
+/**
+ * Finds all nodes that match the given predicate.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * Graph.addNode(mutable, "Start A")
+ * Graph.addNode(mutable, "Node B")
+ * Graph.addNode(mutable, "Start C")
+ * })
+ *
+ * const result = Graph.findNodes(graph, (data) => data.startsWith("Start"))
+ * console.log(result) // [0, 2]
+ *
+ * const empty = Graph.findNodes(graph, (data) => data === "Not Found")
+ * console.log(empty) // []
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.findNode = findNode;
+const findNodes = (graph, predicate) => {
+ const results = [];
+ for (const [index, data] of graph.nodes) {
+ if (predicate(data)) {
+ results.push(index);
+ }
+ }
+ return results;
+};
+/**
+ * Finds the first edge that matches the given predicate.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 10)
+ * Graph.addEdge(mutable, nodeB, nodeC, 20)
+ * })
+ *
+ * const result = Graph.findEdge(graph, (data) => data > 15)
+ * console.log(result) // Option.some(1)
+ *
+ * const notFound = Graph.findEdge(graph, (data) => data > 100)
+ * console.log(notFound) // Option.none()
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.findNodes = findNodes;
+const findEdge = (graph, predicate) => {
+ for (const [edgeIndex, edgeData] of graph.edges) {
+ if (predicate(edgeData.data, edgeData.source, edgeData.target)) {
+ return Option.some(edgeIndex);
+ }
+ }
+ return Option.none();
+};
+/**
+ * Finds all edges that match the given predicate.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 10)
+ * Graph.addEdge(mutable, nodeB, nodeC, 20)
+ * Graph.addEdge(mutable, nodeC, nodeA, 30)
+ * })
+ *
+ * const result = Graph.findEdges(graph, (data) => data >= 20)
+ * console.log(result) // [1, 2]
+ *
+ * const empty = Graph.findEdges(graph, (data) => data > 100)
+ * console.log(empty) // []
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.findEdge = findEdge;
+const findEdges = (graph, predicate) => {
+ const results = [];
+ for (const [edgeIndex, edgeData] of graph.edges) {
+ if (predicate(edgeData.data, edgeData.source, edgeData.target)) {
+ results.push(edgeIndex);
+ }
+ }
+ return results;
+};
+/**
+ * Updates a single node's data by applying a transformation function.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * Graph.addNode(mutable, "Node A")
+ * Graph.addNode(mutable, "Node B")
+ * Graph.updateNode(mutable, 0, (data) => data.toUpperCase())
+ * })
+ *
+ * const nodeData = Graph.getNode(graph, 0)
+ * console.log(nodeData) // Option.some("NODE A")
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.findEdges = findEdges;
+const updateNode = (mutable, index, f) => {
+ if (!mutable.nodes.has(index)) {
+ return;
+ }
+ const currentData = mutable.nodes.get(index);
+ const newData = f(currentData);
+ mutable.nodes.set(index, newData);
+};
+/**
+ * Updates a single edge's data by applying a transformation function.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const result = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const edgeIndex = Graph.addEdge(mutable, nodeA, nodeB, 10)
+ * Graph.updateEdge(mutable, edgeIndex, (data) => data * 2)
+ * })
+ *
+ * const edgeData = Graph.getEdge(result, 0)
+ * console.log(edgeData) // Option.some({ source: 0, target: 1, data: 20 })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.updateNode = updateNode;
+const updateEdge = (mutable, edgeIndex, f) => {
+ if (!mutable.edges.has(edgeIndex)) {
+ return;
+ }
+ const currentEdge = mutable.edges.get(edgeIndex);
+ const newData = f(currentEdge.data);
+ mutable.edges.set(edgeIndex, {
+ ...currentEdge,
+ data: newData
+ });
+};
+/**
+ * Creates a new graph with transformed node data using the provided mapping function.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * Graph.addNode(mutable, "node a")
+ * Graph.addNode(mutable, "node b")
+ * Graph.addNode(mutable, "node c")
+ * Graph.mapNodes(mutable, (data) => data.toUpperCase())
+ * })
+ *
+ * const nodeData = Graph.getNode(graph, 0)
+ * console.log(nodeData) // Option.some("NODE A")
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.updateEdge = updateEdge;
+const mapNodes = (mutable, f) => {
+ // Transform existing node data in place
+ for (const [index, data] of mutable.nodes) {
+ const newData = f(data);
+ mutable.nodes.set(index, newData);
+ }
+};
+/**
+ * Transforms all edge data in a mutable graph using the provided mapping function.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, 10)
+ * Graph.addEdge(mutable, b, c, 20)
+ * Graph.mapEdges(mutable, (data) => data * 2)
+ * })
+ *
+ * const edgeData = Graph.getEdge(graph, 0)
+ * console.log(edgeData) // Option.some({ source: 0, target: 1, data: 20 })
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.mapNodes = mapNodes;
+const mapEdges = (mutable, f) => {
+ // Transform existing edge data in place
+ for (const [index, edgeData] of mutable.edges) {
+ const newData = f(edgeData.data);
+ mutable.edges.set(index, {
+ ...edgeData,
+ data: newData
+ });
+ }
+};
+/**
+ * Reverses all edge directions in a mutable graph by swapping source and target nodes.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, 1) // A -> B
+ * Graph.addEdge(mutable, b, c, 2) // B -> C
+ * Graph.reverse(mutable) // Now B -> A, C -> B
+ * })
+ *
+ * const edge0 = Graph.getEdge(graph, 0)
+ * console.log(edge0) // Option.some({ source: 1, target: 0, data: 1 }) - B -> A
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.mapEdges = mapEdges;
+const reverse = mutable => {
+ // Reverse all edges by swapping source and target
+ for (const [index, edgeData] of mutable.edges) {
+ mutable.edges.set(index, {
+ source: edgeData.target,
+ target: edgeData.source,
+ data: edgeData.data
+ });
+ }
+ // Clear and rebuild adjacency lists with reversed directions
+ mutable.adjacency.clear();
+ mutable.reverseAdjacency.clear();
+ // Rebuild adjacency lists with reversed directions
+ for (const [edgeIndex, edgeData] of mutable.edges) {
+ // Add to forward adjacency (source -> target)
+ const sourceEdges = mutable.adjacency.get(edgeData.source) || [];
+ sourceEdges.push(edgeIndex);
+ mutable.adjacency.set(edgeData.source, sourceEdges);
+ // Add to reverse adjacency (target <- source)
+ const targetEdges = mutable.reverseAdjacency.get(edgeData.target) || [];
+ targetEdges.push(edgeIndex);
+ mutable.reverseAdjacency.set(edgeData.target, targetEdges);
+ }
+ // Invalidate cycle flag since edge directions changed
+ mutable.isAcyclic = Option.none();
+};
+/**
+ * Filters and optionally transforms nodes in a mutable graph using a predicate function.
+ * Nodes that return Option.none are removed along with all their connected edges.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "active")
+ * const b = Graph.addNode(mutable, "inactive")
+ * const c = Graph.addNode(mutable, "active")
+ * Graph.addEdge(mutable, a, b, 1)
+ * Graph.addEdge(mutable, b, c, 2)
+ *
+ * // Keep only "active" nodes and transform to uppercase
+ * Graph.filterMapNodes(mutable, (data) =>
+ * data === "active" ? Option.some(data.toUpperCase()) : Option.none()
+ * )
+ * })
+ *
+ * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.reverse = reverse;
+const filterMapNodes = (mutable, f) => {
+ const nodesToRemove = [];
+ // First pass: identify nodes to remove and transform data for nodes to keep
+ for (const [index, data] of mutable.nodes) {
+ const result = f(data);
+ if (Option.isSome(result)) {
+ // Transform node data
+ mutable.nodes.set(index, result.value);
+ } else {
+ // Mark for removal
+ nodesToRemove.push(index);
+ }
+ }
+ // Second pass: remove filtered out nodes and their edges
+ for (const nodeIndex of nodesToRemove) {
+ removeNode(mutable, nodeIndex);
+ }
+};
+/**
+ * Filters and optionally transforms edges in a mutable graph using a predicate function.
+ * Edges that return Option.none are removed from the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, 5)
+ * Graph.addEdge(mutable, b, c, 15)
+ * Graph.addEdge(mutable, c, a, 25)
+ *
+ * // Keep only edges with weight >= 10 and double their weight
+ * Graph.filterMapEdges(mutable, (data) =>
+ * data >= 10 ? Option.some(data * 2) : Option.none()
+ * )
+ * })
+ *
+ * console.log(Graph.edgeCount(graph)) // 2 (edges with weight 5 removed)
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.filterMapNodes = filterMapNodes;
+const filterMapEdges = (mutable, f) => {
+ const edgesToRemove = [];
+ // First pass: identify edges to remove and transform data for edges to keep
+ for (const [index, edgeData] of mutable.edges) {
+ const result = f(edgeData.data);
+ if (Option.isSome(result)) {
+ // Transform edge data
+ mutable.edges.set(index, {
+ ...edgeData,
+ data: result.value
+ });
+ } else {
+ // Mark for removal
+ edgesToRemove.push(index);
+ }
+ }
+ // Second pass: remove filtered out edges
+ for (const edgeIndex of edgesToRemove) {
+ removeEdge(mutable, edgeIndex);
+ }
+};
+/**
+ * Filters nodes by removing those that don't match the predicate.
+ * This function modifies the mutable graph in place.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * Graph.addNode(mutable, "active")
+ * Graph.addNode(mutable, "inactive")
+ * Graph.addNode(mutable, "pending")
+ * Graph.addNode(mutable, "active")
+ *
+ * // Keep only "active" nodes
+ * Graph.filterNodes(mutable, (data) => data === "active")
+ * })
+ *
+ * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain)
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.filterMapEdges = filterMapEdges;
+const filterNodes = (mutable, predicate) => {
+ const nodesToRemove = [];
+ // Identify nodes to remove
+ for (const [index, data] of mutable.nodes) {
+ if (!predicate(data)) {
+ nodesToRemove.push(index);
+ }
+ }
+ // Remove filtered out nodes (this also removes connected edges)
+ for (const nodeIndex of nodesToRemove) {
+ removeNode(mutable, nodeIndex);
+ }
+};
+/**
+ * Filters edges by removing those that don't match the predicate.
+ * This function modifies the mutable graph in place.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ *
+ * Graph.addEdge(mutable, a, b, 5)
+ * Graph.addEdge(mutable, b, c, 15)
+ * Graph.addEdge(mutable, c, a, 25)
+ *
+ * // Keep only edges with weight >= 10
+ * Graph.filterEdges(mutable, (data) => data >= 10)
+ * })
+ *
+ * console.log(Graph.edgeCount(graph)) // 2 (edge with weight 5 removed)
+ * ```
+ *
+ * @since 3.18.0
+ * @category transformations
+ */
+exports.filterNodes = filterNodes;
+const filterEdges = (mutable, predicate) => {
+ const edgesToRemove = [];
+ // Identify edges to remove
+ for (const [index, edgeData] of mutable.edges) {
+ if (!predicate(edgeData.data)) {
+ edgesToRemove.push(index);
+ }
+ }
+ // Remove filtered out edges
+ for (const edgeIndex of edgesToRemove) {
+ removeEdge(mutable, edgeIndex);
+ }
+};
+// =============================================================================
+// Cycle Flag Management (Internal)
+// =============================================================================
+/** @internal */
+exports.filterEdges = filterEdges;
+const invalidateCycleFlagOnRemoval = mutable => {
+ // Only invalidate if the graph had cycles (removing edges/nodes cannot introduce cycles in acyclic graphs)
+ // If already unknown (null) or acyclic (true), no need to change
+ if (Option.isSome(mutable.isAcyclic) && mutable.isAcyclic.value === false) {
+ mutable.isAcyclic = Option.none();
+ }
+};
+/** @internal */
+const invalidateCycleFlagOnAddition = mutable => {
+ // Only invalidate if the graph was acyclic (adding edges cannot remove cycles from cyclic graphs)
+ // If already unknown (null) or cyclic (false), no need to change
+ if (Option.isSome(mutable.isAcyclic) && mutable.isAcyclic.value === true) {
+ mutable.isAcyclic = Option.none();
+ }
+};
+// =============================================================================
+// Edge Operations
+// =============================================================================
+/**
+ * Adds a new edge to a mutable graph and returns its index.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const result = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const edge = Graph.addEdge(mutable, nodeA, nodeB, 42)
+ * console.log(edge) // EdgeIndex with value 0
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+const addEdge = (mutable, source, target, data) => {
+ // Validate that both nodes exist
+ if (!mutable.nodes.has(source)) {
+ throw missingNode(source);
+ }
+ if (!mutable.nodes.has(target)) {
+ throw missingNode(target);
+ }
+ const edgeIndex = mutable.nextEdgeIndex;
+ // Create edge data
+ const edgeData = new Edge({
+ source,
+ target,
+ data
+ });
+ mutable.edges.set(edgeIndex, edgeData);
+ // Update adjacency lists
+ const sourceAdjacency = mutable.adjacency.get(source);
+ if (sourceAdjacency !== undefined) {
+ sourceAdjacency.push(edgeIndex);
+ }
+ const targetReverseAdjacency = mutable.reverseAdjacency.get(target);
+ if (targetReverseAdjacency !== undefined) {
+ targetReverseAdjacency.push(edgeIndex);
+ }
+ // For undirected graphs, add reverse connections
+ if (mutable.type === "undirected") {
+ const targetAdjacency = mutable.adjacency.get(target);
+ if (targetAdjacency !== undefined) {
+ targetAdjacency.push(edgeIndex);
+ }
+ const sourceReverseAdjacency = mutable.reverseAdjacency.get(source);
+ if (sourceReverseAdjacency !== undefined) {
+ sourceReverseAdjacency.push(edgeIndex);
+ }
+ }
+ // Update allocators
+ mutable.nextEdgeIndex = mutable.nextEdgeIndex + 1;
+ // Only invalidate cycle flag if the graph was acyclic
+ // Adding edges cannot remove cycles from cyclic graphs
+ invalidateCycleFlagOnAddition(mutable);
+ return edgeIndex;
+};
+/**
+ * Removes a node and all its incident edges from a mutable graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const result = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * Graph.addEdge(mutable, nodeA, nodeB, 42)
+ *
+ * // Remove nodeA and all edges connected to it
+ * Graph.removeNode(mutable, nodeA)
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.addEdge = addEdge;
+const removeNode = (mutable, nodeIndex) => {
+ // Check if node exists
+ if (!mutable.nodes.has(nodeIndex)) {
+ return; // Node doesn't exist, nothing to remove
+ }
+ // Collect all incident edges for removal
+ const edgesToRemove = [];
+ // Get outgoing edges
+ const outgoingEdges = mutable.adjacency.get(nodeIndex);
+ if (outgoingEdges !== undefined) {
+ for (const edge of outgoingEdges) {
+ edgesToRemove.push(edge);
+ }
+ }
+ // Get incoming edges
+ const incomingEdges = mutable.reverseAdjacency.get(nodeIndex);
+ if (incomingEdges !== undefined) {
+ for (const edge of incomingEdges) {
+ edgesToRemove.push(edge);
+ }
+ }
+ // Remove all incident edges
+ for (const edgeIndex of edgesToRemove) {
+ removeEdgeInternal(mutable, edgeIndex);
+ }
+ // Remove the node itself
+ mutable.nodes.delete(nodeIndex);
+ mutable.adjacency.delete(nodeIndex);
+ mutable.reverseAdjacency.delete(nodeIndex);
+ // Only invalidate cycle flag if the graph wasn't already known to be acyclic
+ // Removing nodes cannot introduce cycles in an acyclic graph
+ invalidateCycleFlagOnRemoval(mutable);
+};
+/**
+ * Removes an edge from a mutable graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const result = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const edge = Graph.addEdge(mutable, nodeA, nodeB, 42)
+ *
+ * // Remove the edge
+ * Graph.removeEdge(mutable, edge)
+ * })
+ * ```
+ *
+ * @since 3.18.0
+ * @category mutations
+ */
+exports.removeNode = removeNode;
+const removeEdge = (mutable, edgeIndex) => {
+ const wasRemoved = removeEdgeInternal(mutable, edgeIndex);
+ // Only invalidate cycle flag if an edge was actually removed
+ // and only if the graph wasn't already known to be acyclic
+ if (wasRemoved) {
+ invalidateCycleFlagOnRemoval(mutable);
+ }
+};
+/** @internal */
+exports.removeEdge = removeEdge;
+const removeEdgeInternal = (mutable, edgeIndex) => {
+ // Get edge data
+ const edge = mutable.edges.get(edgeIndex);
+ if (edge === undefined) {
+ return false; // Edge doesn't exist, no mutation occurred
+ }
+ const {
+ source,
+ target
+ } = edge;
+ // Remove from adjacency lists
+ const sourceAdjacency = mutable.adjacency.get(source);
+ if (sourceAdjacency !== undefined) {
+ const index = sourceAdjacency.indexOf(edgeIndex);
+ if (index !== -1) {
+ sourceAdjacency.splice(index, 1);
+ }
+ }
+ const targetReverseAdjacency = mutable.reverseAdjacency.get(target);
+ if (targetReverseAdjacency !== undefined) {
+ const index = targetReverseAdjacency.indexOf(edgeIndex);
+ if (index !== -1) {
+ targetReverseAdjacency.splice(index, 1);
+ }
+ }
+ // For undirected graphs, remove reverse connections
+ if (mutable.type === "undirected") {
+ const targetAdjacency = mutable.adjacency.get(target);
+ if (targetAdjacency !== undefined) {
+ const index = targetAdjacency.indexOf(edgeIndex);
+ if (index !== -1) {
+ targetAdjacency.splice(index, 1);
+ }
+ }
+ const sourceReverseAdjacency = mutable.reverseAdjacency.get(source);
+ if (sourceReverseAdjacency !== undefined) {
+ const index = sourceReverseAdjacency.indexOf(edgeIndex);
+ if (index !== -1) {
+ sourceReverseAdjacency.splice(index, 1);
+ }
+ }
+ }
+ // Remove edge data
+ mutable.edges.delete(edgeIndex);
+ return true; // Edge was successfully removed
+};
+// =============================================================================
+// Edge Query Operations
+// =============================================================================
+/**
+ * Gets the edge data associated with an edge index, if it exists.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * Graph.addEdge(mutable, nodeA, nodeB, 42)
+ * })
+ *
+ * const edgeIndex = 0
+ * const edgeData = Graph.getEdge(graph, edgeIndex)
+ *
+ * if (Option.isSome(edgeData)) {
+ * console.log(edgeData.value.data) // 42
+ * console.log(edgeData.value.source) // NodeIndex(0)
+ * console.log(edgeData.value.target) // NodeIndex(1)
+ * }
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+const getEdge = (graph, edgeIndex) => graph.edges.has(edgeIndex) ? Option.some(graph.edges.get(edgeIndex)) : Option.none();
+/**
+ * Checks if an edge exists between two nodes in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 42)
+ * })
+ *
+ * const nodeA = 0
+ * const nodeB = 1
+ * const nodeC = 2
+ *
+ * const hasAB = Graph.hasEdge(graph, nodeA, nodeB)
+ * console.log(hasAB) // true
+ *
+ * const hasAC = Graph.hasEdge(graph, nodeA, nodeC)
+ * console.log(hasAC) // false
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.getEdge = getEdge;
+const hasEdge = (graph, source, target) => {
+ const adjacencyList = graph.adjacency.get(source);
+ if (adjacencyList === undefined) {
+ return false;
+ }
+ // Check if any edge in the adjacency list connects to the target
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined && edge.target === target) {
+ return true;
+ }
+ }
+ return false;
+};
+/**
+ * Returns the number of edges in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const emptyGraph = Graph.directed()
+ * console.log(Graph.edgeCount(emptyGraph)) // 0
+ *
+ * const graphWithEdges = Graph.mutate(emptyGraph, (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 1)
+ * Graph.addEdge(mutable, nodeB, nodeC, 2)
+ * Graph.addEdge(mutable, nodeC, nodeA, 3)
+ * })
+ *
+ * console.log(Graph.edgeCount(graphWithEdges)) // 3
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.hasEdge = hasEdge;
+const edgeCount = graph => graph.edges.size;
+/**
+ * Returns the neighboring nodes (targets of outgoing edges) for a given node.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 1)
+ * Graph.addEdge(mutable, nodeA, nodeC, 2)
+ * })
+ *
+ * const nodeA = 0
+ * const nodeB = 1
+ * const nodeC = 2
+ *
+ * const neighborsA = Graph.neighbors(graph, nodeA)
+ * console.log(neighborsA) // [NodeIndex(1), NodeIndex(2)]
+ *
+ * const neighborsB = Graph.neighbors(graph, nodeB)
+ * console.log(neighborsB) // []
+ * ```
+ *
+ * @since 3.18.0
+ * @category getters
+ */
+exports.edgeCount = edgeCount;
+const neighbors = (graph, nodeIndex) => {
+ // For undirected graphs, use the specialized helper that returns the other endpoint
+ if (graph.type === "undirected") {
+ return getUndirectedNeighbors(graph, nodeIndex);
+ }
+ const adjacencyList = graph.adjacency.get(nodeIndex);
+ if (adjacencyList === undefined) {
+ return [];
+ }
+ const result = [];
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ result.push(edge.target);
+ }
+ }
+ return result;
+};
+/**
+ * Get neighbors of a node in a specific direction for bidirectional traversal.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * Graph.addEdge(mutable, a, b, "A->B")
+ * })
+ *
+ * const nodeA = 0
+ * const nodeB = 1
+ *
+ * // Get outgoing neighbors (nodes that nodeA points to)
+ * const outgoing = Graph.neighborsDirected(graph, nodeA, "outgoing")
+ *
+ * // Get incoming neighbors (nodes that point to nodeB)
+ * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming")
+ * ```
+ *
+ * @since 3.18.0
+ * @category queries
+ */
+exports.neighbors = neighbors;
+const neighborsDirected = (graph, nodeIndex, direction) => {
+ const adjacencyMap = direction === "incoming" ? graph.reverseAdjacency : graph.adjacency;
+ const adjacencyList = adjacencyMap.get(nodeIndex);
+ if (adjacencyList === undefined) {
+ return [];
+ }
+ const result = [];
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ // For incoming direction, we want the source node instead of target
+ const neighborNode = direction === "incoming" ? edge.source : edge.target;
+ result.push(neighborNode);
+ }
+ }
+ return result;
+};
+/**
+ * Exports a graph to GraphViz DOT format for visualization.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const nodeA = Graph.addNode(mutable, "Node A")
+ * const nodeB = Graph.addNode(mutable, "Node B")
+ * const nodeC = Graph.addNode(mutable, "Node C")
+ * Graph.addEdge(mutable, nodeA, nodeB, 1)
+ * Graph.addEdge(mutable, nodeB, nodeC, 2)
+ * Graph.addEdge(mutable, nodeC, nodeA, 3)
+ * })
+ *
+ * const dot = Graph.toGraphViz(graph)
+ * console.log(dot)
+ * // digraph G {
+ * // "0" [label="Node A"];
+ * // "1" [label="Node B"];
+ * // "2" [label="Node C"];
+ * // "0" -> "1" [label="1"];
+ * // "1" -> "2" [label="2"];
+ * // "2" -> "0" [label="3"];
+ * // }
+ * ```
+ *
+ * @since 3.18.0
+ * @category utils
+ */
+exports.neighborsDirected = neighborsDirected;
+const toGraphViz = (graph, options) => {
+ const {
+ edgeLabel = data => String(data),
+ graphName = "G",
+ nodeLabel = data => String(data)
+ } = options ?? {};
+ const isDirected = graph.type === "directed";
+ const graphType = isDirected ? "digraph" : "graph";
+ const edgeOperator = isDirected ? "->" : "--";
+ const lines = [];
+ lines.push(`${graphType} ${graphName} {`);
+ // Add nodes
+ for (const [nodeIndex, nodeData] of graph.nodes) {
+ const label = nodeLabel(nodeData).replace(/"/g, "\\\"");
+ lines.push(` "${nodeIndex}" [label="${label}"];`);
+ }
+ // Add edges
+ for (const [, edgeData] of graph.edges) {
+ const label = edgeLabel(edgeData.data).replace(/"/g, "\\\"");
+ lines.push(` "${edgeData.source}" ${edgeOperator} "${edgeData.target}" [label="${label}"];`);
+ }
+ lines.push("}");
+ return lines.join("\n");
+};
+/** @internal */
+exports.toGraphViz = toGraphViz;
+const escapeMermaidLabel = label => {
+ // Escape special characters for Mermaid using HTML entity codes
+ // According to: https://mermaid.js.org/syntax/flowchart.html#special-characters-that-break-syntax
+ return label.replace(/#/g, "#35;").replace(/"/g, "#quot;").replace(//g, "#gt;").replace(/&/g, "#amp;").replace(/\[/g, "#91;").replace(/\]/g, "#93;").replace(/\{/g, "#123;").replace(/\}/g, "#125;").replace(/\(/g, "#40;").replace(/\)/g, "#41;").replace(/\|/g, "#124;").replace(/\\/g, "#92;").replace(/\n/g, "
");
+};
+/** @internal */
+const formatMermaidNode = (nodeId, label, shape) => {
+ switch (shape) {
+ case "rectangle":
+ return `${nodeId}["${label}"]`;
+ case "rounded":
+ return `${nodeId}("${label}")`;
+ case "circle":
+ return `${nodeId}(("${label}"))`;
+ case "diamond":
+ return `${nodeId}{"${label}"}`;
+ case "hexagon":
+ return `${nodeId}{{"${label}"}}`;
+ case "stadium":
+ return `${nodeId}(["${label}"])`;
+ case "subroutine":
+ return `${nodeId}[["${label}"]]`;
+ case "cylindrical":
+ return `${nodeId}[("${label}")]`;
+ }
+};
+/**
+ * Exports a graph to Mermaid diagram format for visualization.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.mutate(Graph.directed(), (mutable) => {
+ * const app = Graph.addNode(mutable, "App")
+ * const db = Graph.addNode(mutable, "Database")
+ * const cache = Graph.addNode(mutable, "Cache")
+ * Graph.addEdge(mutable, app, db, 1)
+ * Graph.addEdge(mutable, app, cache, 2)
+ * })
+ *
+ * const mermaid = Graph.toMermaid(graph)
+ * console.log(mermaid)
+ * // flowchart TD
+ * // 0["App"]
+ * // 1["Database"]
+ * // 2["Cache"]
+ * // 0 -->|"1"| 1
+ * // 0 -->|"2"| 2
+ * ```
+ *
+ * @since 3.18.0
+ * @category utils
+ */
+const toMermaid = (graph, options) => {
+ // Extract and validate options with defaults
+ const {
+ diagramType,
+ direction = "TD",
+ edgeLabel = data => String(data),
+ nodeLabel = data => String(data),
+ nodeShape = () => "rectangle"
+ } = options ?? {};
+ // Auto-detect diagram type if not specified
+ const finalDiagramType = diagramType ?? (graph.type === "directed" ? "flowchart" : "graph");
+ // Generate diagram header
+ const lines = [];
+ lines.push(`${finalDiagramType} ${direction}`);
+ // Add nodes
+ for (const [nodeIndex, nodeData] of graph.nodes) {
+ const nodeId = String(nodeIndex);
+ const label = escapeMermaidLabel(nodeLabel(nodeData));
+ const shape = nodeShape(nodeData);
+ const formattedNode = formatMermaidNode(nodeId, label, shape);
+ lines.push(` ${formattedNode}`);
+ }
+ // Add edges
+ const edgeOperator = finalDiagramType === "flowchart" ? "-->" : "---";
+ for (const [, edgeData] of graph.edges) {
+ const sourceId = String(edgeData.source);
+ const targetId = String(edgeData.target);
+ const label = escapeMermaidLabel(edgeLabel(edgeData.data));
+ if (label) {
+ lines.push(` ${sourceId} ${edgeOperator}|"${label}"| ${targetId}`);
+ } else {
+ lines.push(` ${sourceId} ${edgeOperator} ${targetId}`);
+ }
+ }
+ return lines.join("\n");
+};
+// =============================================================================
+// =============================================================================
+// Graph Structure Analysis Algorithms (Phase 5A)
+// =============================================================================
+/**
+ * Checks if the graph is acyclic (contains no cycles).
+ *
+ * Uses depth-first search to detect back edges, which indicate cycles.
+ * For directed graphs, any back edge creates a cycle. For undirected graphs,
+ * a back edge that doesn't go to the immediate parent creates a cycle.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * // Acyclic directed graph (DAG)
+ * const dag = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, "A->B")
+ * Graph.addEdge(mutable, b, c, "B->C")
+ * })
+ * console.log(Graph.isAcyclic(dag)) // true
+ *
+ * // Cyclic directed graph
+ * const cyclic = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * Graph.addEdge(mutable, a, b, "A->B")
+ * Graph.addEdge(mutable, b, a, "B->A") // Creates cycle
+ * })
+ * console.log(Graph.isAcyclic(cyclic)) // false
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.toMermaid = toMermaid;
+const isAcyclic = graph => {
+ // Use existing cycle flag if available
+ if (Option.isSome(graph.isAcyclic)) {
+ return graph.isAcyclic.value;
+ }
+ // Stack-safe DFS cycle detection using iterative approach
+ const visited = new Set();
+ const recursionStack = new Set();
+ // Get all nodes to handle disconnected components
+ for (const startNode of graph.nodes.keys()) {
+ if (visited.has(startNode)) {
+ continue; // Already processed this component
+ }
+ // Iterative DFS with explicit stack
+ const stack = [[startNode, [], 0, true]];
+ while (stack.length > 0) {
+ const [node, neighbors, neighborIndex, isFirstVisit] = stack[stack.length - 1];
+ // First visit to this node
+ if (isFirstVisit) {
+ if (recursionStack.has(node)) {
+ // Back edge found - cycle detected
+ graph.isAcyclic = Option.some(false);
+ return false;
+ }
+ if (visited.has(node)) {
+ stack.pop();
+ continue;
+ }
+ visited.add(node);
+ recursionStack.add(node);
+ // Get neighbors for this node
+ const nodeNeighbors = Array.from(neighborsDirected(graph, node, "outgoing"));
+ stack[stack.length - 1] = [node, nodeNeighbors, 0, false];
+ continue;
+ }
+ // Process next neighbor
+ if (neighborIndex < neighbors.length) {
+ const neighbor = neighbors[neighborIndex];
+ stack[stack.length - 1] = [node, neighbors, neighborIndex + 1, false];
+ if (recursionStack.has(neighbor)) {
+ // Back edge found - cycle detected
+ graph.isAcyclic = Option.some(false);
+ return false;
+ }
+ if (!visited.has(neighbor)) {
+ stack.push([neighbor, [], 0, true]);
+ }
+ } else {
+ // Done with this node - backtrack
+ recursionStack.delete(node);
+ stack.pop();
+ }
+ }
+ }
+ // Cache the result
+ graph.isAcyclic = Option.some(true);
+ return true;
+};
+/**
+ * Checks if an undirected graph is bipartite.
+ *
+ * A bipartite graph is one whose vertices can be divided into two disjoint sets
+ * such that no two vertices within the same set are adjacent. Uses BFS coloring
+ * to determine bipartiteness.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * // Bipartite graph (alternating coloring possible)
+ * const bipartite = Graph.undirected((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * const d = Graph.addNode(mutable, "D")
+ * Graph.addEdge(mutable, a, b, "edge") // Set 1: {A, C}, Set 2: {B, D}
+ * Graph.addEdge(mutable, b, c, "edge")
+ * Graph.addEdge(mutable, c, d, "edge")
+ * })
+ * console.log(Graph.isBipartite(bipartite)) // true
+ *
+ * // Non-bipartite graph (odd cycle)
+ * const triangle = Graph.undirected((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, "edge")
+ * Graph.addEdge(mutable, b, c, "edge")
+ * Graph.addEdge(mutable, c, a, "edge") // Triangle (3-cycle)
+ * })
+ * console.log(Graph.isBipartite(triangle)) // false
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.isAcyclic = isAcyclic;
+const isBipartite = graph => {
+ const coloring = new Map();
+ const discovered = new Set();
+ let isBipartiteGraph = true;
+ // Get all nodes to handle disconnected components
+ for (const startNode of graph.nodes.keys()) {
+ if (!discovered.has(startNode)) {
+ // Start BFS coloring from this component
+ const queue = [startNode];
+ coloring.set(startNode, 0); // Color start node with 0
+ discovered.add(startNode);
+ while (queue.length > 0 && isBipartiteGraph) {
+ const current = queue.shift();
+ const currentColor = coloring.get(current);
+ const neighborColor = currentColor === 0 ? 1 : 0;
+ // Get all neighbors for undirected graph
+ const nodeNeighbors = getUndirectedNeighbors(graph, current);
+ for (const neighbor of nodeNeighbors) {
+ if (!discovered.has(neighbor)) {
+ // Color unvisited neighbor with opposite color
+ coloring.set(neighbor, neighborColor);
+ discovered.add(neighbor);
+ queue.push(neighbor);
+ } else {
+ // Check if neighbor has the same color (conflict)
+ if (coloring.get(neighbor) === currentColor) {
+ isBipartiteGraph = false;
+ break;
+ }
+ }
+ }
+ }
+ // Early exit if not bipartite
+ if (!isBipartiteGraph) {
+ break;
+ }
+ }
+ }
+ return isBipartiteGraph;
+};
+/**
+ * Get neighbors for undirected graphs by checking both adjacency and reverse adjacency.
+ * For undirected graphs, we need to find the other endpoint of each edge incident to the node.
+ */
+exports.isBipartite = isBipartite;
+const getUndirectedNeighbors = (graph, nodeIndex) => {
+ const neighbors = new Set();
+ // Check edges where this node is the source
+ const adjacencyList = graph.adjacency.get(nodeIndex);
+ if (adjacencyList !== undefined) {
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ // For undirected graphs, the neighbor is the other endpoint
+ const otherNode = edge.source === nodeIndex ? edge.target : edge.source;
+ neighbors.add(otherNode);
+ }
+ }
+ }
+ return Array.from(neighbors);
+};
+/**
+ * Find connected components in an undirected graph.
+ * Each component is represented as an array of node indices.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.undirected((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * const d = Graph.addNode(mutable, "D")
+ * Graph.addEdge(mutable, a, b, "edge") // Component 1: A-B
+ * Graph.addEdge(mutable, c, d, "edge") // Component 2: C-D
+ * })
+ *
+ * const components = Graph.connectedComponents(graph)
+ * console.log(components) // [[0, 1], [2, 3]]
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+const connectedComponents = graph => {
+ const visited = new Set();
+ const components = [];
+ for (const startNode of graph.nodes.keys()) {
+ if (!visited.has(startNode)) {
+ // DFS to find all nodes in this component
+ const component = [];
+ const stack = [startNode];
+ while (stack.length > 0) {
+ const current = stack.pop();
+ if (!visited.has(current)) {
+ visited.add(current);
+ component.push(current);
+ // Add all unvisited neighbors to stack
+ const nodeNeighbors = getUndirectedNeighbors(graph, current);
+ for (const neighbor of nodeNeighbors) {
+ if (!visited.has(neighbor)) {
+ stack.push(neighbor);
+ }
+ }
+ }
+ }
+ components.push(component);
+ }
+ }
+ return components;
+};
+/**
+ * Find strongly connected components in a directed graph using Kosaraju's algorithm.
+ * Each SCC is represented as an array of node indices.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, "A->B")
+ * Graph.addEdge(mutable, b, c, "B->C")
+ * Graph.addEdge(mutable, c, a, "C->A") // Creates SCC: A-B-C
+ * })
+ *
+ * const sccs = Graph.stronglyConnectedComponents(graph)
+ * console.log(sccs) // [[0, 1, 2]]
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.connectedComponents = connectedComponents;
+const stronglyConnectedComponents = graph => {
+ const visited = new Set();
+ const finishOrder = [];
+ for (const startNode of graph.nodes.keys()) {
+ if (visited.has(startNode)) {
+ continue;
+ }
+ const stack = [[startNode, [], 0, true]];
+ while (stack.length > 0) {
+ const [node, nodeNeighbors, neighborIndex, isFirstVisit] = stack[stack.length - 1];
+ if (isFirstVisit) {
+ if (visited.has(node)) {
+ stack.pop();
+ continue;
+ }
+ visited.add(node);
+ const nodeNeighborsList = neighbors(graph, node);
+ stack[stack.length - 1] = [node, nodeNeighborsList, 0, false];
+ continue;
+ }
+ // Process next neighbor
+ if (neighborIndex < nodeNeighbors.length) {
+ const neighbor = nodeNeighbors[neighborIndex];
+ stack[stack.length - 1] = [node, nodeNeighbors, neighborIndex + 1, false];
+ if (!visited.has(neighbor)) {
+ stack.push([neighbor, [], 0, true]);
+ }
+ } else {
+ // Done with this node - add to finish order (post-order)
+ finishOrder.push(node);
+ stack.pop();
+ }
+ }
+ }
+ // Step 2: Stack-safe DFS on transpose graph in reverse finish order
+ visited.clear();
+ const sccs = [];
+ for (let i = finishOrder.length - 1; i >= 0; i--) {
+ const startNode = finishOrder[i];
+ if (visited.has(startNode)) {
+ continue;
+ }
+ const scc = [];
+ const stack = [startNode];
+ while (stack.length > 0) {
+ const node = stack.pop();
+ if (visited.has(node)) {
+ continue;
+ }
+ visited.add(node);
+ scc.push(node);
+ // Use reverse adjacency (transpose graph)
+ const reverseAdjacency = graph.reverseAdjacency.get(node);
+ if (reverseAdjacency !== undefined) {
+ for (const edgeIndex of reverseAdjacency) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ const predecessor = edge.source;
+ if (!visited.has(predecessor)) {
+ stack.push(predecessor);
+ }
+ }
+ }
+ }
+ }
+ sccs.push(scc);
+ }
+ return sccs;
+};
+/**
+ * Find the shortest path between two nodes using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm works with non-negative edge weights and finds the shortest
+ * path from a source node to a target node in O((V + E) log V) time complexity.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, 5)
+ * Graph.addEdge(mutable, a, c, 10)
+ * Graph.addEdge(mutable, b, c, 2)
+ * })
+ *
+ * const result = Graph.dijkstra(graph, { source: 0, target: 2, cost: (edgeData) => edgeData })
+ * if (Option.isSome(result)) {
+ * console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
+ * console.log(result.value.distance) // 7 - total distance
+ * }
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.stronglyConnectedComponents = stronglyConnectedComponents;
+const dijkstra = (graph, config) => {
+ const {
+ cost,
+ source,
+ target
+ } = config;
+ // Validate that source and target nodes exist
+ if (!graph.nodes.has(source)) {
+ throw missingNode(source);
+ }
+ if (!graph.nodes.has(target)) {
+ throw missingNode(target);
+ }
+ // Early return if source equals target
+ if (source === target) {
+ return Option.some({
+ path: [source],
+ distance: 0,
+ costs: []
+ });
+ }
+ // Distance tracking and priority queue simulation
+ const distances = new Map();
+ const previous = new Map();
+ const visited = new Set();
+ // Initialize distances
+ // Iterate directly over node keys
+ for (const node of graph.nodes.keys()) {
+ distances.set(node, node === source ? 0 : Infinity);
+ previous.set(node, null);
+ }
+ // Simple priority queue using array (can be optimized with proper heap)
+ const priorityQueue = [{
+ node: source,
+ distance: 0
+ }];
+ while (priorityQueue.length > 0) {
+ // Find minimum distance node (priority queue extract-min)
+ let minIndex = 0;
+ for (let i = 1; i < priorityQueue.length; i++) {
+ if (priorityQueue[i].distance < priorityQueue[minIndex].distance) {
+ minIndex = i;
+ }
+ }
+ const current = priorityQueue.splice(minIndex, 1)[0];
+ const currentNode = current.node;
+ // Skip if already visited (can happen with duplicate entries)
+ if (visited.has(currentNode)) {
+ continue;
+ }
+ visited.add(currentNode);
+ // Early termination if we reached the target
+ if (currentNode === target) {
+ break;
+ }
+ // Get current distance
+ const currentDistance = distances.get(currentNode);
+ // Examine all outgoing edges
+ const adjacencyList = graph.adjacency.get(currentNode);
+ if (adjacencyList !== undefined) {
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ const neighbor = edge.target;
+ const weight = cost(edge.data);
+ // Validate non-negative weights
+ if (weight < 0) {
+ throw new Error(`Dijkstra's algorithm requires non-negative edge weights, found ${weight}`);
+ }
+ const newDistance = currentDistance + weight;
+ const neighborDistance = distances.get(neighbor);
+ // Relaxation step
+ if (newDistance < neighborDistance) {
+ distances.set(neighbor, newDistance);
+ previous.set(neighbor, {
+ node: currentNode,
+ edgeData: edge.data
+ });
+ // Add to priority queue if not visited
+ if (!visited.has(neighbor)) {
+ priorityQueue.push({
+ node: neighbor,
+ distance: newDistance
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ // Check if target is reachable
+ const targetDistance = distances.get(target);
+ if (targetDistance === Infinity) {
+ return Option.none(); // No path exists
+ }
+ // Reconstruct path
+ const path = [];
+ const costs = [];
+ let currentNode = target;
+ while (currentNode !== null) {
+ path.unshift(currentNode);
+ const prev = previous.get(currentNode);
+ if (prev !== null) {
+ costs.unshift(prev.edgeData);
+ currentNode = prev.node;
+ } else {
+ currentNode = null;
+ }
+ }
+ return Option.some({
+ path,
+ distance: targetDistance,
+ costs
+ });
+};
+/**
+ * Find shortest paths between all pairs of nodes using Floyd-Warshall algorithm.
+ *
+ * Floyd-Warshall algorithm computes shortest paths between all pairs of nodes in O(V³) time.
+ * It can handle negative edge weights and detect negative cycles.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, 3)
+ * Graph.addEdge(mutable, b, c, 2)
+ * Graph.addEdge(mutable, a, c, 7)
+ * })
+ *
+ * const result = Graph.floydWarshall(graph, (edgeData) => edgeData)
+ * const distanceAToC = result.distances.get(0)?.get(2) // 5 (A->B->C)
+ * const pathAToC = result.paths.get(0)?.get(2) // [0, 1, 2]
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.dijkstra = dijkstra;
+const floydWarshall = (graph, cost) => {
+ // Get all nodes for Floyd-Warshall algorithm (needs array for nested iteration)
+ const allNodes = Array.from(graph.nodes.keys());
+ // Initialize distance matrix
+ const dist = new Map();
+ const next = new Map();
+ const edgeMatrix = new Map();
+ // Initialize with infinity for all pairs
+ for (const i of allNodes) {
+ dist.set(i, new Map());
+ next.set(i, new Map());
+ edgeMatrix.set(i, new Map());
+ for (const j of allNodes) {
+ dist.get(i).set(j, i === j ? 0 : Infinity);
+ next.get(i).set(j, null);
+ edgeMatrix.get(i).set(j, null);
+ }
+ }
+ // Set edge weights
+ for (const [, edgeData] of graph.edges) {
+ const weight = cost(edgeData.data);
+ const i = edgeData.source;
+ const j = edgeData.target;
+ // Use minimum weight if multiple edges exist
+ const currentWeight = dist.get(i).get(j);
+ if (weight < currentWeight) {
+ dist.get(i).set(j, weight);
+ next.get(i).set(j, j);
+ edgeMatrix.get(i).set(j, edgeData.data);
+ }
+ }
+ // Floyd-Warshall main loop
+ for (const k of allNodes) {
+ for (const i of allNodes) {
+ for (const j of allNodes) {
+ const distIK = dist.get(i).get(k);
+ const distKJ = dist.get(k).get(j);
+ const distIJ = dist.get(i).get(j);
+ if (distIK !== Infinity && distKJ !== Infinity && distIK + distKJ < distIJ) {
+ dist.get(i).set(j, distIK + distKJ);
+ next.get(i).set(j, next.get(i).get(k));
+ }
+ }
+ }
+ }
+ // Check for negative cycles
+ for (const i of allNodes) {
+ if (dist.get(i).get(i) < 0) {
+ throw new Error(`Negative cycle detected involving node ${i}`);
+ }
+ }
+ // Build result paths and edge weights
+ const paths = new Map();
+ const resultCosts = new Map();
+ for (const i of allNodes) {
+ paths.set(i, new Map());
+ resultCosts.set(i, new Map());
+ for (const j of allNodes) {
+ if (i === j) {
+ paths.get(i).set(j, [i]);
+ resultCosts.get(i).set(j, []);
+ } else if (dist.get(i).get(j) === Infinity) {
+ paths.get(i).set(j, null);
+ resultCosts.get(i).set(j, []);
+ } else {
+ // Reconstruct path iteratively
+ const path = [];
+ const weights = [];
+ let current = i;
+ path.push(current);
+ while (current !== j) {
+ const nextNode = next.get(current).get(j);
+ if (nextNode === null) break;
+ const edgeData = edgeMatrix.get(current).get(nextNode);
+ if (edgeData !== null) {
+ weights.push(edgeData);
+ }
+ current = nextNode;
+ path.push(current);
+ }
+ paths.get(i).set(j, path);
+ resultCosts.get(i).set(j, weights);
+ }
+ }
+ }
+ return {
+ distances: dist,
+ paths,
+ costs: resultCosts
+ };
+};
+/**
+ * Find the shortest path between two nodes using A* pathfinding algorithm.
+ *
+ * A* is an extension of Dijkstra's algorithm that uses a heuristic function to guide
+ * the search towards the target, potentially finding paths faster than Dijkstra's.
+ * The heuristic must be admissible (never overestimate the actual cost).
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.directed<{x: number, y: number}, number>((mutable) => {
+ * const a = Graph.addNode(mutable, {x: 0, y: 0})
+ * const b = Graph.addNode(mutable, {x: 1, y: 0})
+ * const c = Graph.addNode(mutable, {x: 2, y: 0})
+ * Graph.addEdge(mutable, a, b, 1)
+ * Graph.addEdge(mutable, b, c, 1)
+ * })
+ *
+ * // Manhattan distance heuristic
+ * const heuristic = (nodeData: {x: number, y: number}, targetData: {x: number, y: number}) =>
+ * Math.abs(nodeData.x - targetData.x) + Math.abs(nodeData.y - targetData.y)
+ *
+ * const result = Graph.astar(graph, { source: 0, target: 2, cost: (edgeData) => edgeData, heuristic })
+ * if (Option.isSome(result)) {
+ * console.log(result.value.path) // [0, 1, 2] - shortest path
+ * console.log(result.value.distance) // 2 - total distance
+ * }
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.floydWarshall = floydWarshall;
+const astar = (graph, config) => {
+ const {
+ cost,
+ heuristic,
+ source,
+ target
+ } = config;
+ // Validate that source and target nodes exist
+ if (!graph.nodes.has(source)) {
+ throw missingNode(source);
+ }
+ if (!graph.nodes.has(target)) {
+ throw missingNode(target);
+ }
+ // Early return if source equals target
+ if (source === target) {
+ return Option.some({
+ path: [source],
+ distance: 0,
+ costs: []
+ });
+ }
+ // Get target node data for heuristic calculations
+ const targetNodeData = graph.nodes.get(target);
+ if (targetNodeData === undefined) {
+ throw new Error(`Target node ${target} data not found`);
+ }
+ // Distance tracking (g-score) and f-score (g + h)
+ const gScore = new Map();
+ const fScore = new Map();
+ const previous = new Map();
+ const visited = new Set();
+ // Initialize scores
+ // Iterate directly over node keys
+ for (const node of graph.nodes.keys()) {
+ gScore.set(node, node === source ? 0 : Infinity);
+ fScore.set(node, Infinity);
+ previous.set(node, null);
+ }
+ // Calculate initial f-score for source
+ const sourceNodeData = graph.nodes.get(source);
+ if (sourceNodeData !== undefined) {
+ const h = heuristic(sourceNodeData, targetNodeData);
+ fScore.set(source, h);
+ }
+ // Priority queue using f-score (total estimated cost)
+ const openSet = [{
+ node: source,
+ fScore: fScore.get(source)
+ }];
+ while (openSet.length > 0) {
+ // Find node with lowest f-score
+ let minIndex = 0;
+ for (let i = 1; i < openSet.length; i++) {
+ if (openSet[i].fScore < openSet[minIndex].fScore) {
+ minIndex = i;
+ }
+ }
+ const current = openSet.splice(minIndex, 1)[0];
+ const currentNode = current.node;
+ // Skip if already visited
+ if (visited.has(currentNode)) {
+ continue;
+ }
+ visited.add(currentNode);
+ // Early termination if we reached the target
+ if (currentNode === target) {
+ break;
+ }
+ // Get current g-score
+ const currentGScore = gScore.get(currentNode);
+ // Examine all outgoing edges
+ const adjacencyList = graph.adjacency.get(currentNode);
+ if (adjacencyList !== undefined) {
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ const neighbor = edge.target;
+ const weight = cost(edge.data);
+ // Validate non-negative weights
+ if (weight < 0) {
+ throw new Error(`A* algorithm requires non-negative edge weights, found ${weight}`);
+ }
+ const tentativeGScore = currentGScore + weight;
+ const neighborGScore = gScore.get(neighbor);
+ // If this path to neighbor is better than any previous one
+ if (tentativeGScore < neighborGScore) {
+ // Update g-score and previous
+ gScore.set(neighbor, tentativeGScore);
+ previous.set(neighbor, {
+ node: currentNode,
+ edgeData: edge.data
+ });
+ // Calculate f-score using heuristic
+ const neighborNodeData = graph.nodes.get(neighbor);
+ if (neighborNodeData !== undefined) {
+ const h = heuristic(neighborNodeData, targetNodeData);
+ const f = tentativeGScore + h;
+ fScore.set(neighbor, f);
+ // Add to open set if not visited
+ if (!visited.has(neighbor)) {
+ openSet.push({
+ node: neighbor,
+ fScore: f
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ // Check if target is reachable
+ const targetGScore = gScore.get(target);
+ if (targetGScore === Infinity) {
+ return Option.none(); // No path exists
+ }
+ // Reconstruct path
+ const path = [];
+ const costs = [];
+ let currentNode = target;
+ while (currentNode !== null) {
+ path.unshift(currentNode);
+ const prev = previous.get(currentNode);
+ if (prev !== null) {
+ costs.unshift(prev.edgeData);
+ currentNode = prev.node;
+ } else {
+ currentNode = null;
+ }
+ }
+ return Option.some({
+ path,
+ distance: targetGScore,
+ costs
+ });
+};
+/**
+ * Find the shortest path between two nodes using Bellman-Ford algorithm.
+ *
+ * Bellman-Ford algorithm can handle negative edge weights and detects negative cycles.
+ * It has O(VE) time complexity, slower than Dijkstra's but more versatile.
+ * Returns Option.none() if a negative cycle is detected that affects the path.
+ *
+ * @example
+ * ```ts
+ * import { Graph, Option } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * const c = Graph.addNode(mutable, "C")
+ * Graph.addEdge(mutable, a, b, -1) // Negative weight allowed
+ * Graph.addEdge(mutable, b, c, 3)
+ * Graph.addEdge(mutable, a, c, 5)
+ * })
+ *
+ * const result = Graph.bellmanFord(graph, { source: 0, target: 2, cost: (edgeData) => edgeData })
+ * if (Option.isSome(result)) {
+ * console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
+ * console.log(result.value.distance) // 2 - total distance
+ * }
+ * ```
+ *
+ * @since 3.18.0
+ * @category algorithms
+ */
+exports.astar = astar;
+const bellmanFord = (graph, config) => {
+ const {
+ cost,
+ source,
+ target
+ } = config;
+ // Validate that source and target nodes exist
+ if (!graph.nodes.has(source)) {
+ throw missingNode(source);
+ }
+ if (!graph.nodes.has(target)) {
+ throw missingNode(target);
+ }
+ // Early return if source equals target
+ if (source === target) {
+ return Option.some({
+ path: [source],
+ distance: 0,
+ costs: []
+ });
+ }
+ // Initialize distances and predecessors
+ const distances = new Map();
+ const previous = new Map();
+ // Iterate directly over node keys
+ for (const node of graph.nodes.keys()) {
+ distances.set(node, node === source ? 0 : Infinity);
+ previous.set(node, null);
+ }
+ // Collect all edges for relaxation
+ const edges = [];
+ for (const [, edgeData] of graph.edges) {
+ const weight = cost(edgeData.data);
+ edges.push({
+ source: edgeData.source,
+ target: edgeData.target,
+ weight,
+ edgeData: edgeData.data
+ });
+ }
+ // Relax edges up to V-1 times
+ const nodeCount = graph.nodes.size;
+ for (let i = 0; i < nodeCount - 1; i++) {
+ let hasUpdate = false;
+ for (const edge of edges) {
+ const sourceDistance = distances.get(edge.source);
+ const targetDistance = distances.get(edge.target);
+ // Relaxation step
+ if (sourceDistance !== Infinity && sourceDistance + edge.weight < targetDistance) {
+ distances.set(edge.target, sourceDistance + edge.weight);
+ previous.set(edge.target, {
+ node: edge.source,
+ edgeData: edge.edgeData
+ });
+ hasUpdate = true;
+ }
+ }
+ // Early termination if no updates
+ if (!hasUpdate) {
+ break;
+ }
+ }
+ // Check for negative cycles
+ for (const edge of edges) {
+ const sourceDistance = distances.get(edge.source);
+ const targetDistance = distances.get(edge.target);
+ if (sourceDistance !== Infinity && sourceDistance + edge.weight < targetDistance) {
+ // Negative cycle detected - check if it affects the path to target
+ const affectedNodes = new Set();
+ const queue = [edge.target];
+ while (queue.length > 0) {
+ const node = queue.shift();
+ if (affectedNodes.has(node)) continue;
+ affectedNodes.add(node);
+ // Add all nodes reachable from this node
+ const adjacencyList = graph.adjacency.get(node);
+ if (adjacencyList !== undefined) {
+ for (const edgeIndex of adjacencyList) {
+ const edge = graph.edges.get(edgeIndex);
+ if (edge !== undefined) {
+ queue.push(edge.target);
+ }
+ }
+ }
+ }
+ // If target is affected by negative cycle, return null
+ if (affectedNodes.has(target)) {
+ return Option.none();
+ }
+ }
+ }
+ // Check if target is reachable
+ const targetDistance = distances.get(target);
+ if (targetDistance === Infinity) {
+ return Option.none(); // No path exists
+ }
+ // Reconstruct path
+ const path = [];
+ const costs = [];
+ let currentNode = target;
+ while (currentNode !== null) {
+ path.unshift(currentNode);
+ const prev = previous.get(currentNode);
+ if (prev !== null) {
+ costs.unshift(prev.edgeData);
+ currentNode = prev.node;
+ } else {
+ currentNode = null;
+ }
+ }
+ return Option.some({
+ path,
+ distance: targetDistance,
+ costs
+ });
+};
+/**
+ * Concrete class for iterables that produce [NodeIndex, NodeData] tuples.
+ *
+ * This class provides a common abstraction for all iterables that return node data,
+ * including traversal iterators (DFS, BFS, etc.) and element iterators (nodes, externals).
+ * It uses a mapEntry function pattern for flexible iteration and transformation.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * Graph.addEdge(mutable, a, b, 1)
+ * })
+ *
+ * // Both traversal and element iterators return NodeWalker
+ * const dfsNodes: Graph.NodeWalker = Graph.dfs(graph, { start: [0] })
+ * const allNodes: Graph.NodeWalker = Graph.nodes(graph)
+ *
+ * // Common interface for working with node iterables
+ * function processNodes(nodeIterable: Graph.NodeWalker): Array {
+ * return Array.from(Graph.indices(nodeIterable))
+ * }
+ *
+ * // Access node data using values() or entries()
+ * const nodeData = Array.from(Graph.values(dfsNodes)) // ["A", "B"]
+ * const nodeEntries = Array.from(Graph.entries(allNodes)) // [[0, "A"], [1, "B"]]
+ * ```
+ *
+ * @since 3.18.0
+ * @category models
+ */
+exports.bellmanFord = bellmanFord;
+class Walker {
+ /**
+ * @since 3.18.0
+ */
+ // @ts-ignore
+ [Symbol.iterator];
+ /**
+ * Visits each element and maps it to a value using the provided function.
+ *
+ * Takes a function that receives the index and data,
+ * and returns an iterable of the mapped values. Skips elements that
+ * no longer exist in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * Graph.addEdge(mutable, a, b, 1)
+ * })
+ *
+ * const dfs = Graph.dfs(graph, { start: [0] })
+ *
+ * // Map to just the node data
+ * const values = Array.from(dfs.visit((index, data) => data))
+ * console.log(values) // ["A", "B"]
+ *
+ * // Map to custom objects
+ * const custom = Array.from(dfs.visit((index, data) => ({ id: index, name: data })))
+ * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }]
+ * ```
+ *
+ * @since 3.18.0
+ * @category iterators
+ */
+ visit;
+ constructor(
+ /**
+ * Visits each element and maps it to a value using the provided function.
+ *
+ * Takes a function that receives the index and data,
+ * and returns an iterable of the mapped values. Skips elements that
+ * no longer exist in the graph.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed((mutable) => {
+ * const a = Graph.addNode(mutable, "A")
+ * const b = Graph.addNode(mutable, "B")
+ * Graph.addEdge(mutable, a, b, 1)
+ * })
+ *
+ * const dfs = Graph.dfs(graph, { start: [0] })
+ *
+ * // Map to just the node data
+ * const values = Array.from(dfs.visit((index, data) => data))
+ * console.log(values) // ["A", "B"]
+ *
+ * // Map to custom objects
+ * const custom = Array.from(dfs.visit((index, data) => ({ id: index, name: data })))
+ * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }]
+ * ```
+ *
+ * @since 3.18.0
+ * @category iterators
+ */
+ visit) {
+ this.visit = visit;
+ this[Symbol.iterator] = visit((index, data) => [index, data])[Symbol.iterator];
+ }
+}
+/**
+ * Returns an iterator over the indices in the walker.
+ *
+ * @example
+ * ```ts
+ * import { Graph } from "effect"
+ *
+ * const graph = Graph.directed