@nlozgachev/pipelined 0.36.0 → 0.37.1

package/dist/{chunk-4QMYKCWE.mjs → chunk-M2X7TFKN.mjs}

@@ -1,12 +1,6 @@
-import {
-  Deferred,
-  Maybe,
-  Result,
-  Task
-} from "./chunk-DLBHVYII.mjs";
 import {
   Duration
-} from "./chunk-VWVPHDZO.mjs";
+} from "./chunk-5AFEEFE4.mjs";
 
 // src/Core/Combinable.ts
 var Combinable;
@@ -24,6 +18,16 @@ var Combinable;
   Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
 })(Combinable || (Combinable = {}));
 
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (p) => (
+    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+    { then: ((f) => p.then(f)) }
+  );
+  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
 // src/Core/Equality.ts
 var Equality;
 ((Equality2) => {
@@ -64,18 +68,18 @@ var Lazy;
 
 // src/Core/Lens.ts
 var Lens;
-((Lens2) => {
-  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Lens2.prop = () => (key) => (0, Lens2.make)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
-  Lens2.get = (lens) => (s) => lens.get(s);
-  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
-  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
-  Lens2.andThenOptional = (inner) => (outer) => ({
+((Lens3) => {
+  Lens3.make = (get2, set2) => ({ get: get2, set: set2 });
+  Lens3.prop = () => (key) => (0, Lens3.make)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
+  Lens3.get = (lens) => (s) => lens.get(s);
+  Lens3.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens3.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens3.andThen = (inner) => (outer) => (0, Lens3.make)((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
+  Lens3.andThenOptional = (inner) => (outer) => ({
     get: (s) => inner.get(outer.get(s)),
     set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
   });
-  Lens2.toOptional = (lens) => ({
+  Lens3.toOptional = (lens) => ({
     get: (s) => ({ kind: "Some", value: lens.get(s) }),
     set: lens.set
   });
@@ -103,8 +107,59 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
+// src/Core/Maybe.ts
+var _none = { kind: "None" };
+var Maybe;
+((Maybe2) => {
+  Maybe2.some = (value) => ({ kind: "Some", value });
+  Maybe2.isSome = (data) => data.kind === "Some";
+  Maybe2.none = () => _none;
+  Maybe2.isNone = (data) => data.kind === "None";
+  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
+  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
+  Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
+  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
+  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
+  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if ((0, Maybe2.isSome)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
+  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Maybe2.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if ((0, Maybe2.isNone)(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return (0, Maybe2.some)(result);
+  };
+})(Maybe || (Maybe = {}));
+
 // src/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -1277,6 +1332,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -1420,6 +1479,71 @@ var Resource;
   });
 })(Resource || (Resource = {}));
 
+// src/Core/Result.ts
+var Result;
+((Result4) => {
+  Result4.ok = (value) => ({ kind: "Ok", value });
+  Result4.err = (e) => ({ kind: "Err", error: e });
+  Result4.isOk = (data) => data.kind === "Ok";
+  Result4.isErr = (data) => data.kind === "Err";
+  Result4.tryCatch = (f, onError) => {
+    try {
+      return (0, Result4.ok)(f());
+    } catch (error) {
+      return (0, Result4.err)(onError(error));
+    }
+  };
+  Result4.map = (f) => (data) => (0, Result4.isOk)(data) ? (0, Result4.ok)(f(data.value)) : data;
+  Result4.mapError = (f) => (data) => (0, Result4.isErr)(data) ? (0, Result4.err)(f(data.error)) : data;
+  Result4.chain = (f) => (data) => (0, Result4.isOk)(data) ? f(data.value) : data;
+  Result4.fold = (onErr, onOk) => (data) => (0, Result4.isOk)(data) ? onOk(data.value) : onErr(data.error);
+  Result4.match = (cases) => (data) => (0, Result4.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result4.getOrElse = (defaultValue) => (data) => (0, Result4.isOk)(data) ? data.value : defaultValue();
+  Result4.tap = (f) => (data) => {
+    if ((0, Result4.isOk)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Result4.tapError = (f) => (data) => {
+    if ((0, Result4.isErr)(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  Result4.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result4.ok)(a) : (0, Result4.err)(onFalse(a));
+  Result4.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result4.err)(onNull()) : (0, Result4.ok)(value);
+  Result4.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result4.err)(onNone()) : (0, Result4.ok)(maybe.value);
+  Result4.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result4.ok)(f(...args));
+    } catch (error) {
+      return (0, Result4.err)(onError(error));
+    }
+  };
+  Result4.recover = (fallback) => (data) => (0, Result4.isOk)(data) ? data : fallback(data.error);
+  Result4.recoverUnless = (isBlocked, fallback) => (data) => (0, Result4.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
+  Result4.toMaybe = (data) => (0, Result4.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
+  Result4.ap = (arg) => (data) => (0, Result4.isOk)(data) && (0, Result4.isOk)(arg) ? (0, Result4.ok)(data.value(arg.value)) : (0, Result4.isErr)(data) ? data : arg;
+  Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
+  Result4.bind = (key, f) => (data) => (0, Result4.chain)(
+    (a) => (0, Result4.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Result4.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if ((0, Result4.isErr)(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return (0, Result4.ok)(result);
+  };
+})(Result || (Result = {}));
+
 // src/Core/State.ts
 var State;
 ((State2) => {
@@ -1449,8 +1573,240 @@ var State;
   State2.run = (initialState) => (st) => st(initialState);
   State2.evaluate = (initialState) => (st) => st(initialState)[0];
   State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(State || (State = {}));
 
+// src/Core/Task.ts
+var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs2 = (duration) => Duration.toMilliseconds(duration);
+var Task;
+((Task2) => {
+  Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
+  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
+  Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
+  Task2.ap = (arg) => (data) => (0, Task2.from)((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
+  Task2.tap = (f) => (data) => (0, Task2.from)(
+    (signal) => toPromise(data, signal).then((a) => {
+      f(a);
+      return a;
+    })
+  );
+  Task2.all = (tasks) => (0, Task2.from)(
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
+  );
+  Task2.delay = (duration) => (data) => (0, Task2.from)(
+    (signal) => new Promise((res) => {
+      let timerId;
+      const onAbort = () => {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        res(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return res(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res(toPromise(data, signal));
+      }, getMs2(duration));
+    })
+  );
+  Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
+    const { times, delay: delayDuration } = options;
+    if (times <= 0) {
+      return Promise.resolve([]);
+    }
+    const results = [];
+    const wait = () => {
+      if (signal?.aborted) {
+        return Promise.resolve();
+      }
+      return new Promise((r) => {
+        let timerId;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, delayDuration ? getMs2(delayDuration) : 0);
+      });
+    };
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) {
+          return results;
+        }
+        return wait().then(() => run2(left - 1));
+      });
+    };
+    return run2(times);
+  });
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
+    const { when: predicate, delay: delayDuration, maxAttempts } = options;
+    const wait = () => {
+      if (signal?.aborted) {
+        return Promise.resolve();
+      }
+      return new Promise((r) => {
+        let timerId;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, delayDuration ? getMs2(delayDuration) : 0);
+      });
+    };
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise(task, signal).then((a) => {
+        if (predicate(a)) {
+          return a;
+        }
+        if (maxAttempts !== void 0 && attempt >= maxAttempts) {
+          return a;
+        }
+        if (signal?.aborted) {
+          return a;
+        }
+        return wait().then(() => run2(attempt + 1, a));
+      });
+    };
+    return run2(1);
+  });
+  Task2.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.fromPromise(new Promise(() => {
+      }));
+    }
+    return (0, Task2.from)((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) {
+          ctrl.abort();
+        }
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
+  };
+  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
+  Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
+    const results = [];
+    for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
+      results.push(await toPromise(task, signal));
+    }
+    return results;
+  });
+  Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
+    const controller = new AbortController();
+    let timerId;
+    function cleanUp() {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    }
+    function onOuterAbort() {
+      cleanUp();
+      controller.abort();
+    }
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
+    return Promise.race([
+      toPromise(task, controller.signal).then((a) => {
+        cleanUp();
+        return Result.ok(a);
+      }),
+      new Promise((res) => {
+        timerId = setTimeout(() => {
+          controller.abort();
+          cleanUp();
+          res(Result.err(onTimeout()));
+        }, getMs2(duration));
+      })
+    ]);
+  });
+  Task2.abortable = (factory) => {
+    let currentController = null;
+    const abort = () => currentController?.abort();
+    const task = (outerSignal) => {
+      currentController?.abort();
+      currentController = new AbortController();
+      const controller = currentController;
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.fromPromise(factory(controller.signal));
+    };
+    return { task, abort };
+  };
+  Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+})(Task || (Task = {}));
+
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
@@ -1474,99 +1830,63 @@ var TaskMaybe;
   TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
   TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
   TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
-var TaskResult;
-((TaskResult2) => {
-  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.err(error));
-  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
-  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
-  TaskResult2.fromResult = (result) => Task.resolve(result);
-  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult2.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
-  TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-  TaskResult2.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
+var TaskResult3;
+((TaskResult4) => {
+  TaskResult4.ok = (value) => Task.resolve(Result.ok(value));
+  TaskResult4.err = (error) => Task.resolve(Result.err(error));
+  TaskResult4.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
+  TaskResult4.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
+  TaskResult4.fromResult = (result) => Task.resolve(result);
+  TaskResult4.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult4.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult4.map = (f) => (data) => Task.map(Result.map(f))(data);
+  TaskResult4.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
+  TaskResult4.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
     data
   );
-  TaskResult2.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
-  TaskResult2.match = (cases) => (data) => Task.map(Result.match(cases))(data);
-  TaskResult2.recover = (fallback) => (data) => Task.chain(
+  TaskResult4.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
+  TaskResult4.match = (cases) => (data) => Task.map(Result.match(cases))(data);
+  TaskResult4.recover = (fallback) => (data) => Task.chain(
     (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
   )(data);
-  TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-  TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult2.ap = (arg) => (data) => Task.from(
+  TaskResult4.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
+  TaskResult4.tap = (f) => (data) => Task.map(Result.tap(f))(data);
+  TaskResult4.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
+  TaskResult4.ap = (arg) => (data) => Task.from(
     (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
       ([of_, oa]) => Result.ap(oa)(of_)
     )
   );
-  TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
-})(TaskResult || (TaskResult = {}));
-
-// src/Core/Validation.ts
-var Validation;
-((Validation2) => {
-  Validation2.passed = (value) => ({ kind: "Passed", value });
-  Validation2.failed = (error) => ({ kind: "Failed", errors: [error] });
-  Validation2.failedAll = (errors) => ({ kind: "Failed", errors });
-  Validation2.isPassed = (data) => data.kind === "Passed";
-  Validation2.isFailed = (data) => data.kind === "Failed";
-  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.passed)(a) : (0, Validation2.failed)(onFalse(a));
-  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.failed)(onNull()) : (0, Validation2.passed)(value);
-  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.failed)(onNone()) : (0, Validation2.passed)(maybe.value);
-  Validation2.map = (f) => (data) => (0, Validation2.isPassed)(data) ? (0, Validation2.passed)(f(data.value)) : data;
-  Validation2.mapError = (f) => (data) => (0, Validation2.isFailed)(data) ? (0, Validation2.failedAll)(data.errors.map(f)) : data;
-  Validation2.ap = (arg) => (data) => {
-    if ((0, Validation2.isPassed)(data) && (0, Validation2.isPassed)(arg)) {
-      return (0, Validation2.passed)(data.value(arg.value));
-    }
-    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
-    return (0, Validation2.failedAll)(errors);
-  };
-  Validation2.fold = (onFailed, onPassed) => (data) => (0, Validation2.isPassed)(data) ? onPassed(data.value) : onFailed(data.errors);
-  Validation2.match = (cases) => (data) => (0, Validation2.isPassed)(data) ? cases.passed(data.value) : cases.failed(data.errors);
-  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isPassed)(data) ? data.value : defaultValue();
-  Validation2.tap = (f) => (data) => {
-    if ((0, Validation2.isPassed)(data)) {
-      f(data.value);
-    }
-    return data;
-  };
-  Validation2.tapError = (f) => (data) => {
-    if ((0, Validation2.isFailed)(data)) {
-      f(data.errors);
-    }
-    return data;
-  };
-  Validation2.recover = (fallback) => (data) => (0, Validation2.isPassed)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isFailed)(data) && !data.errors.some(isBlocked) ? fallback() : data;
-  Validation2.toResult = (data) => (0, Validation2.isPassed)(data) ? Result.ok(data.value) : Result.err(data.errors);
-  Validation2.toMaybe = (data) => (0, Validation2.isPassed)(data) ? Maybe.some(data.value) : Maybe.none();
-  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.passed)(data.value) : (0, Validation2.failed)(data.error);
-  Validation2.product = (first, second) => {
-    if ((0, Validation2.isPassed)(first) && (0, Validation2.isPassed)(second)) {
-      return (0, Validation2.passed)([first.value, second.value]);
-    }
-    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
-    return (0, Validation2.failedAll)(errors);
-  };
-  Validation2.productAll = (data) => {
-    const values = [];
-    const errors = [];
-    for (const v of data) {
-      if ((0, Validation2.isPassed)(v)) {
-        values.push(v.value);
-      } else {
-        errors.push(...v.errors);
+  TaskResult4.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult4.bindTo = (key) => (data) => (0, TaskResult4.map)((a) => ({ [key]: a }))(data);
+  TaskResult4.bind = (key, f) => (data) => (0, TaskResult4.chain)(
+    (a) => (0, TaskResult4.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskResult4.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)).then((res) => ({ key, res })));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (const key of keys) {
+        const found = results.find((r) => r.key === key);
+        if (found) {
+          if (Result.isErr(found.res)) {
+            return found.res;
+          }
+          record[key] = found.res.value;
+        }
       }
-    }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
-  };
-})(Validation || (Validation = {}));
+      return Result.ok(record);
+    });
+  });
+})(TaskResult3 || (TaskResult3 = {}));
 
 // src/Core/TaskValidation.ts
 var TaskValidation;
@@ -1712,12 +2032,90 @@ var Tuple;
   };
 })(Tuple || (Tuple = {}));
 
+// src/Core/Validation.ts
+var Validation;
+((Validation2) => {
+  Validation2.passed = (value) => ({ kind: "Passed", value });
+  Validation2.failed = (error) => ({ kind: "Failed", errors: [error] });
+  Validation2.failedAll = (errors) => ({ kind: "Failed", errors });
+  Validation2.isPassed = (data) => data.kind === "Passed";
+  Validation2.isFailed = (data) => data.kind === "Failed";
+  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.passed)(a) : (0, Validation2.failed)(onFalse(a));
+  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.failed)(onNull()) : (0, Validation2.passed)(value);
+  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.failed)(onNone()) : (0, Validation2.passed)(maybe.value);
+  Validation2.map = (f) => (data) => (0, Validation2.isPassed)(data) ? (0, Validation2.passed)(f(data.value)) : data;
+  Validation2.mapError = (f) => (data) => (0, Validation2.isFailed)(data) ? (0, Validation2.failedAll)(data.errors.map(f)) : data;
+  Validation2.ap = (arg) => (data) => {
+    if ((0, Validation2.isPassed)(data) && (0, Validation2.isPassed)(arg)) {
+      return (0, Validation2.passed)(data.value(arg.value));
+    }
+    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
+    return (0, Validation2.failedAll)(errors);
+  };
+  Validation2.fold = (onFailed, onPassed) => (data) => (0, Validation2.isPassed)(data) ? onPassed(data.value) : onFailed(data.errors);
+  Validation2.match = (cases) => (data) => (0, Validation2.isPassed)(data) ? cases.passed(data.value) : cases.failed(data.errors);
+  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isPassed)(data) ? data.value : defaultValue();
+  Validation2.tap = (f) => (data) => {
+    if ((0, Validation2.isPassed)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Validation2.tapError = (f) => (data) => {
+    if ((0, Validation2.isFailed)(data)) {
+      f(data.errors);
+    }
+    return data;
+  };
+  Validation2.recover = (fallback) => (data) => (0, Validation2.isPassed)(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isFailed)(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  Validation2.toResult = (data) => (0, Validation2.isPassed)(data) ? Result.ok(data.value) : Result.err(data.errors);
+  Validation2.toMaybe = (data) => (0, Validation2.isPassed)(data) ? Maybe.some(data.value) : Maybe.none();
+  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.passed)(data.value) : (0, Validation2.failed)(data.error);
+  Validation2.product = (first, second) => {
+    if ((0, Validation2.isPassed)(first) && (0, Validation2.isPassed)(second)) {
+      return (0, Validation2.passed)([first.value, second.value]);
+    }
+    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
+    return (0, Validation2.failedAll)(errors);
+  };
+  Validation2.productAll = (data) => {
+    const values = [];
+    const errors = [];
+    for (const v of data) {
+      if ((0, Validation2.isPassed)(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
+  };
+  Validation2.struct = (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if ((0, Validation2.isPassed)(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+  };
+})(Validation || (Validation = {}));
+
 export {
   Combinable,
+  Deferred,
   Equality,
   Lazy,
   Lens,
   Logged,
+  Maybe,
   Op,
   Optional,
   Ordering,
@@ -1726,11 +2124,13 @@ export {
   Refinement,
   RemoteData,
   Resource,
+  Result,
   State,
+  Task,
   TaskMaybe,
-  TaskResult,
-  Validation,
+  TaskResult3 as TaskResult,
   TaskValidation,
   These,
-  Tuple
+  Tuple,
+  Validation
 };