@nlozgachev/pipelined 0.19.0 → 0.21.0

package/dist/core.js

@@ -24,6 +24,7 @@ __export(Core_exports, {
   Lens: () => Lens,
   Logged: () => Logged,
   Maybe: () => Maybe,
+  Op: () => Op,
   Optional: () => Optional,
   Predicate: () => Predicate,
   Reader: () => Reader,
@@ -43,15 +44,13 @@ __export(Core_exports, {
 module.exports = __toCommonJS(Core_exports);
 
 // src/Core/Deferred.ts
-var _store = /* @__PURE__ */ new WeakMap();
 var Deferred;
 ((Deferred2) => {
-  Deferred2.fromPromise = (p) => {
-    const d = { then: ((f) => p.then(f)) };
-    _store.set(d, p);
-    return d;
-  };
-  Deferred2.toPromise = (d) => _store.get(d) ?? new Promise((resolve) => d.then(resolve));
+  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/Lens.ts
@@ -161,6 +160,880 @@ var Maybe;
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
 })(Maybe || (Maybe = {}));
 
+// src/internal/Op.util.ts
+var _abortedNil = { kind: "Nil", reason: "aborted" };
+var _droppedNil = { kind: "Nil", reason: "dropped" };
+var _replacedNil = { kind: "Nil", reason: "replaced" };
+var _evictedNil = { kind: "Nil", reason: "evicted" };
+var _idle = { kind: "Idle" };
+var _pending = { kind: "Pending" };
+var ok = (value) => ({ kind: "Ok", value });
+var err = (error) => ({ kind: "Err", error });
+var cancellableWait = (ms, signal) => {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const id = setTimeout(resolve, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(id);
+      resolve();
+    }, { once: true });
+  });
+};
+var runWithRetry = (op, input, signal, options, onRetrying) => {
+  const { attempts, backoff, when: shouldRetry } = options;
+  const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
+  const attempt = async (left) => {
+    const result = await Deferred.toPromise(op._factory(input, signal));
+    if (result === null || signal.aborted) return null;
+    if (result.kind === "Ok") return result;
+    if (left <= 1) return result;
+    if (shouldRetry !== void 0 && !shouldRetry(result.error)) return result;
+    const attemptNumber = attempts - left + 1;
+    const ms = getDelay(attemptNumber);
+    onRetrying({
+      kind: "Retrying",
+      attempt: attemptNumber,
+      lastError: result.error,
+      ...ms > 0 ? { nextRetryIn: ms } : {}
+    });
+    await cancellableWait(ms, signal);
+    if (signal.aborted) return null;
+    return attempt(left - 1);
+  };
+  return attempt(attempts);
+};
+var execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying) => {
+  const { signal } = controller;
+  const toOutcome = (r) => r === null ? _abortedNil : r.kind === "Ok" ? ok(r.value) : err(r.error);
+  const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, input, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.toPromise(op._factory(input, signal)).then(toOutcome);
+  if (timeoutOptions === void 0) return Deferred.fromPromise(runPromise);
+  let timerId;
+  return Deferred.fromPromise(Promise.race([
+    runPromise.then((outcome) => {
+      clearTimeout(timerId);
+      return outcome;
+    }),
+    new Promise((resolve) => {
+      timerId = setTimeout(() => {
+        controller.abort();
+        resolve(err(timeoutOptions.onTimeout()));
+      }, timeoutOptions.ms);
+    })
+  ]));
+};
+var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let waitController;
+  let lastStartTime = 0;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => Deferred.fromPromise(
+    new Promise((resolve) => {
+      waitController?.abort();
+      waitController = void 0;
+      currentController?.abort();
+      const prev = currentResolve;
+      currentResolve = resolve;
+      currentController = new AbortController();
+      const controller = currentController;
+      prev?.(_replacedNil);
+      const startExecution = () => {
+        if (currentController !== controller) return;
+        lastStartTime = Date.now();
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) emit(r);
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) return;
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+        });
+      };
+      const gap = minInterval !== void 0 ? Math.max(0, minInterval - (Date.now() - lastStartTime)) : 0;
+      if (gap > 0) {
+        waitController = new AbortController();
+        const wc = waitController;
+        cancellableWait(gap, wc.signal).then(() => {
+          if (waitController === wc) waitController = void 0;
+          startExecution();
+        });
+      } else {
+        startExecution();
+      }
+    })
+  );
+  const abort = () => {
+    waitController?.abort();
+    waitController = void 0;
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let cooldownTimer;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => {
+    if (currentController !== void 0 || cooldownTimer !== void 0) {
+      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.fromPromise(
+      new Promise((resolve) => {
+        currentResolve = resolve;
+        currentController = new AbortController();
+        const controller = currentController;
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) emit(r);
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) return;
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+          if (cooldown !== void 0 && cooldown > 0) {
+            cooldownTimer = setTimeout(() => {
+              cooldownTimer = void 0;
+            }, cooldown);
+          }
+        });
+      })
+    );
+  };
+  const abort = () => {
+    if (cooldownTimer !== void 0) {
+      clearTimeout(cooldownTimer);
+      cooldownTimer = void 0;
+    }
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeoutOptions) => {
+  const maxConcurrency = concurrency ?? 1;
+  let currentState = _idle;
+  let generation = 0;
+  let inFlight = 0;
+  const queue = [];
+  const inflightControllers = /* @__PURE__ */ new Set();
+  const inflightResolvers = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startOne = (input, resolve, myGeneration) => {
+    inFlight++;
+    const controller = new AbortController();
+    inflightControllers.add(controller);
+    inflightResolvers.push(resolve);
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (generation === myGeneration && inflightControllers.has(controller)) emit(r);
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      inflightControllers.delete(controller);
+      const idx = inflightResolvers.indexOf(resolve);
+      if (idx !== -1) inflightResolvers.splice(idx, 1);
+      if (generation !== myGeneration) {
+        resolve(_abortedNil);
+        return;
+      }
+      inFlight--;
+      emit(outcome);
+      resolve(outcome);
+      if (queue.length > 0) {
+        const next = queue.shift();
+        startOne(next.input, next.resolve, generation);
+      }
+    });
+  };
+  const run = (input) => {
+    const myGeneration = generation;
+    if (dedupe !== void 0) {
+      const idx = queue.findIndex((item) => dedupe(input, item.input));
+      if (idx !== -1) {
+        const dup = queue.splice(idx, 1)[0];
+        dup.resolve(_droppedNil);
+      }
+    }
+    if (inFlight < maxConcurrency) {
+      return Deferred.fromPromise(
+        new Promise((resolve) => {
+          startOne(input, resolve, myGeneration);
+        })
+      );
+    }
+    if (maxSize === void 0 || queue.length < maxSize) {
+      return Deferred.fromPromise(
+        new Promise((resolve) => {
+          queue.push({ input, resolve });
+          emit({ kind: "Queued", position: queue.length - 1 });
+        })
+      );
+    }
+    if (overflow === "replace-last") {
+      return Deferred.fromPromise(
+        new Promise((resolve) => {
+          const tail = queue.pop();
+          tail.resolve(_evictedNil);
+          queue.push({ input, resolve });
+          emit({ kind: "Queued", position: queue.length - 1 });
+        })
+      );
+    }
+    return Deferred.fromPromise(Promise.resolve(_droppedNil));
+  };
+  const abort = () => {
+    generation++;
+    inflightControllers.forEach((c) => c.abort());
+    inflightControllers.clear();
+    const toResolve = inflightResolvers.splice(0);
+    const queuedResolvers = queue.splice(0).map((item) => item.resolve);
+    inFlight = 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    toResolve.forEach((r) => r(_abortedNil));
+    queuedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
+  const bufferSize = size ?? 1;
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  const buffer = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startRun = (input, resolve) => {
+    currentResolve = resolve;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) emit(r);
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) return;
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+      if (buffer.length > 0) {
+        const next = buffer.shift();
+        startRun(next.input, next.resolve);
+      }
+    });
+  };
+  const run = (input) => Deferred.fromPromise(
+    new Promise((resolve) => {
+      if (currentController === void 0) {
+        startRun(input, resolve);
+      } else if (buffer.length < bufferSize) {
+        buffer.push({ input, resolve });
+        emit({ kind: "Queued", position: buffer.length - 1 });
+      } else {
+        const evicted = buffer.shift();
+        evicted.resolve(_evictedNil);
+        buffer.push({ input, resolve });
+        emit({ kind: "Queued", position: buffer.length - 1 });
+      }
+    })
+  );
+  const abort = () => {
+    currentController?.abort();
+    currentController = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    const bufferedResolvers = buffer.splice(0).map((item) => item.resolve);
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    cr?.(_abortedNil);
+    bufferedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let leadingController;
+  let leadingResolve;
+  let pendingResolve;
+  let timerId;
+  let pendingInput;
+  let firstCallAt = 0;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const fireLeading = (input, resolve) => {
+    leadingController = new AbortController();
+    const controller = leadingController;
+    leadingResolve = resolve;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (leadingController === controller) emit(r);
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (leadingController !== controller) return;
+      const r = leadingResolve;
+      leadingResolve = void 0;
+      leadingController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const fireTrailing = () => {
+    timerId = void 0;
+    firstCallAt = 0;
+    const capturedResolve = pendingResolve;
+    pendingResolve = void 0;
+    if (capturedResolve === void 0) return;
+    currentResolve = capturedResolve;
+    const toRun = pendingInput;
+    pendingInput = void 0;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) emit(r);
+    } : void 0;
+    execute(op, toRun, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) return;
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const scheduleTrailing = () => {
+    if (timerId !== void 0) clearTimeout(timerId);
+    let delay = ms;
+    if (maxWait !== void 0 && firstCallAt > 0) {
+      const maxDelay = firstCallAt + maxWait - Date.now();
+      delay = Math.min(ms, Math.max(0, maxDelay));
+    }
+    timerId = setTimeout(fireTrailing, delay);
+  };
+  const inDebounceWindow = () => timerId !== void 0 || leadingController !== void 0 || currentController !== void 0;
+  const run = (input) => Deferred.fromPromise(
+    new Promise((resolve) => {
+      if (!inDebounceWindow()) {
+        firstCallAt = Date.now();
+        if (leading) {
+          fireLeading(input, resolve);
+          scheduleTrailing();
+        } else {
+          pendingInput = input;
+          pendingResolve = resolve;
+          scheduleTrailing();
+        }
+      } else {
+        const prev = pendingResolve;
+        pendingInput = input;
+        pendingResolve = resolve;
+        prev?.(_evictedNil);
+        scheduleTrailing();
+      }
+    })
+  );
+  const abort = () => {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+      timerId = void 0;
+      pendingInput = void 0;
+      firstCallAt = 0;
+    }
+    const pr = pendingResolve;
+    pendingResolve = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    currentController?.abort();
+    currentController = void 0;
+    const lr = leadingResolve;
+    leadingResolve = void 0;
+    leadingController?.abort();
+    leadingController = void 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    pr?.(_abortedNil);
+    cr?.(_abortedNil);
+    lr?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  let cooldownTimer;
+  let pendingInput;
+  let pendingResolve;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const fireOp = (input, resolve) => {
+    currentResolve = resolve;
+    currentController = new AbortController();
+    const controller = currentController;
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (currentController === controller) emit(r);
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      if (currentController !== controller) return;
+      const r = currentResolve;
+      currentResolve = void 0;
+      currentController = void 0;
+      emit(outcome);
+      r?.(outcome);
+    });
+  };
+  const startCooldown = () => {
+    cooldownTimer = setTimeout(() => {
+      cooldownTimer = void 0;
+      if (trailing && pendingInput !== void 0) {
+        const input = pendingInput;
+        const resolve = pendingResolve;
+        pendingInput = void 0;
+        pendingResolve = void 0;
+        fireOp(input, resolve);
+        startCooldown();
+      }
+    }, ms);
+  };
+  const run = (input) => {
+    if (cooldownTimer !== void 0) {
+      if (!trailing) {
+        return Deferred.fromPromise(Promise.resolve(_droppedNil));
+      }
+      return Deferred.fromPromise(
+        new Promise((resolve) => {
+          const prev = pendingResolve;
+          pendingInput = input;
+          pendingResolve = resolve;
+          prev?.(_evictedNil);
+        })
+      );
+    }
+    return Deferred.fromPromise(
+      new Promise((resolve) => {
+        fireOp(input, resolve);
+        startCooldown();
+      })
+    );
+  };
+  const abort = () => {
+    if (cooldownTimer !== void 0) {
+      clearTimeout(cooldownTimer);
+      cooldownTimer = void 0;
+    }
+    currentController?.abort();
+    currentController = void 0;
+    const cr = currentResolve;
+    currentResolve = void 0;
+    const pr = pendingResolve;
+    pendingResolve = void 0;
+    pendingInput = void 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    cr?.(_abortedNil);
+    pr?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let inflight = 0;
+  let generation = 0;
+  const controllers = /* @__PURE__ */ new Set();
+  const inflightResolvers = [];
+  const overflowQueue = [];
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const startOne = (input, resolve, myGeneration) => {
+    inflight++;
+    const controller = new AbortController();
+    controllers.add(controller);
+    inflightResolvers.push(resolve);
+    emit(_pending);
+    const onRetrying = retryOptions ? (r) => {
+      if (generation === myGeneration && controllers.has(controller)) emit(r);
+    } : void 0;
+    execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+      controllers.delete(controller);
+      const idx = inflightResolvers.indexOf(resolve);
+      if (idx !== -1) inflightResolvers.splice(idx, 1);
+      if (generation !== myGeneration) {
+        resolve(_abortedNil);
+        return;
+      }
+      inflight--;
+      emit(outcome);
+      resolve(outcome);
+      if (overflowQueue.length > 0) {
+        const next = overflowQueue.shift();
+        startOne(next.input, next.resolve, generation);
+      }
+    });
+  };
+  const run = (input) => {
+    const myGeneration = generation;
+    if (inflight < n) {
+      return Deferred.fromPromise(
+        new Promise((resolve) => {
+          startOne(input, resolve, myGeneration);
+        })
+      );
+    }
+    if (overflow === "drop") {
+      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.fromPromise(
+      new Promise((resolve) => {
+        overflowQueue.push({ input, resolve });
+        emit({ kind: "Queued", position: overflowQueue.length - 1 });
+      })
+    );
+  };
+  const abort = () => {
+    generation++;
+    controllers.forEach((c) => c.abort());
+    controllers.clear();
+    const toResolve = inflightResolvers.splice(0);
+    const queuedResolvers = overflowQueue.splice(0).map((item) => item.resolve);
+    inflight = 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    toResolve.forEach((r) => r(_abortedNil));
+    queuedResolvers.forEach((r) => r(_abortedNil));
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
+  const stateMap = /* @__PURE__ */ new Map();
+  const slots = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  const emitSnapshot = () => {
+    const snapshot = new Map(stateMap);
+    subscribers.forEach((cb) => cb(snapshot));
+  };
+  const run = (input) => {
+    const k = keyFn(input);
+    if (slots.has(k)) {
+      if (perKey === "exclusive") {
+        return Deferred.fromPromise(Promise.resolve(_droppedNil));
+      }
+      const existing = slots.get(k);
+      existing.controller.abort();
+      const prev = existing.resolve;
+      slots.delete(k);
+      prev(_replacedNil);
+    }
+    return Deferred.fromPromise(
+      new Promise((resolve) => {
+        const controller = new AbortController();
+        slots.set(k, { controller, resolve });
+        stateMap.set(k, _pending);
+        emitSnapshot();
+        execute(op, input, controller, void 0, timeoutOptions, void 0).then((outcome) => {
+          const slot = slots.get(k);
+          if (!slot || slot.controller !== controller) {
+            resolve(_abortedNil);
+            return;
+          }
+          slots.delete(k);
+          stateMap.set(k, outcome);
+          emitSnapshot();
+          resolve(outcome);
+        });
+      })
+    );
+  };
+  const abort = (key) => {
+    if (key !== void 0) {
+      const slot = slots.get(key);
+      if (slot) {
+        slot.controller.abort();
+        const r = slot.resolve;
+        slots.delete(key);
+        stateMap.set(key, _abortedNil);
+        emitSnapshot();
+        r(_abortedNil);
+      }
+    } else {
+      const toResolve = [];
+      for (const [k, slot] of slots) {
+        slot.controller.abort();
+        toResolve.push(slot.resolve);
+        stateMap.set(k, _abortedNil);
+      }
+      slots.clear();
+      if (toResolve.length > 0) emitSnapshot();
+      toResolve.forEach((r) => r(_abortedNil));
+    }
+  };
+  return {
+    get state() {
+      return new Map(stateMap);
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (stateMap.size > 0) cb(new Map(stateMap));
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+var makeOnce = (op, retryOptions, timeoutOptions) => {
+  let currentState = _idle;
+  let currentController;
+  let currentResolve;
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (state) => {
+    currentState = state;
+    subscribers.forEach((cb) => cb(state));
+  };
+  const run = (input) => {
+    if (currentState.kind !== "Idle") {
+      return Deferred.fromPromise(Promise.resolve(_droppedNil));
+    }
+    return Deferred.fromPromise(
+      new Promise((resolve) => {
+        currentResolve = resolve;
+        currentController = new AbortController();
+        const controller = currentController;
+        emit(_pending);
+        const onRetrying = retryOptions ? (r) => {
+          if (currentController === controller) emit(r);
+        } : void 0;
+        execute(op, input, controller, retryOptions, timeoutOptions, onRetrying).then((outcome) => {
+          if (currentController !== controller) return;
+          const r = currentResolve;
+          currentResolve = void 0;
+          currentController = void 0;
+          emit(outcome);
+          r?.(outcome);
+        });
+      })
+    );
+  };
+  const abort = () => {
+    currentController?.abort();
+    currentController = void 0;
+    const r = currentResolve;
+    currentResolve = void 0;
+    if (currentState.kind !== "Idle") emit(_abortedNil);
+    r?.(_abortedNil);
+  };
+  return {
+    get state() {
+      return currentState;
+    },
+    run,
+    abort,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      if (currentState.kind !== "Idle") cb(currentState);
+      return () => subscribers.delete(cb);
+    }
+  };
+};
+
+// src/Core/Op.ts
+var Op;
+((Op2) => {
+  Op2.nil = (reason) => ({ kind: "Nil", reason });
+  Op2.create = (factory, onError) => ({
+    _factory: (input, signal) => Deferred.fromPromise(
+      factory(input, signal).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.err(onError(e)))
+    )
+  });
+  Op2.ok = (value) => ({ kind: "Ok", value });
+  Op2.err = (error) => ({ kind: "Err", error });
+  Op2.isOk = (outcome) => outcome.kind === "Ok";
+  Op2.isErr = (outcome) => outcome.kind === "Err";
+  Op2.isNil = (outcome) => outcome.kind === "Nil";
+  Op2.match = (cases) => (outcome) => {
+    if (outcome.kind === "Ok") return cases.ok(outcome.value);
+    if (outcome.kind === "Err") return cases.err(outcome.error);
+    return cases.nil();
+  };
+  Op2.fold = (onErr, onOk, onNil) => (outcome) => {
+    if (outcome.kind === "Ok") return onOk(outcome.value);
+    if (outcome.kind === "Err") return onErr(outcome.error);
+    return onNil();
+  };
+  Op2.getOrElse = (defaultValue) => (outcome) => outcome.kind === "Ok" ? outcome.value : defaultValue();
+  Op2.map = (f) => (outcome) => outcome.kind === "Ok" ? (0, Op2.ok)(f(outcome.value)) : outcome;
+  Op2.mapError = (f) => (outcome) => outcome.kind === "Err" ? (0, Op2.err)(f(outcome.error)) : outcome;
+  Op2.chain = (f) => (outcome) => outcome.kind === "Ok" ? f(outcome.value) : outcome;
+  Op2.tap = (f) => (outcome) => {
+    if (outcome.kind === "Ok") f(outcome.value);
+    return outcome;
+  };
+  Op2.recover = (f) => (outcome) => outcome.kind === "Err" ? f(outcome.error) : outcome;
+  Op2.toResult = (onNil) => (outcome) => {
+    if (outcome.kind === "Ok") return Result.ok(outcome.value);
+    if (outcome.kind === "Err") return Result.err(outcome.error);
+    return Result.err(onNil());
+  };
+  Op2.toMaybe = (outcome) => outcome.kind === "Ok" ? Maybe.some(outcome.value) : Maybe.none();
+  Op2.all = (invocations) => Deferred.fromPromise(Promise.all(invocations.map(Deferred.toPromise)));
+  Op2.race = (invocations) => Deferred.fromPromise(Promise.race(invocations.map(Deferred.toPromise)));
+  function interpret(op, options) {
+    const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
+    switch (strategy) {
+      case "once":
+        return makeOnce(op, retryOptions, timeoutOptions);
+      case "restartable":
+        return makeRestartable(op, options.minInterval, retryOptions, timeoutOptions);
+      case "exclusive":
+        return makeExclusive(op, options.cooldown, retryOptions, timeoutOptions);
+      case "queue":
+        return makeQueue(
+          op,
+          options.maxSize,
+          options.overflow,
+          options.concurrency,
+          options.dedupe,
+          retryOptions,
+          timeoutOptions
+        );
+      case "buffered":
+        return makeBuffered(op, options.size, retryOptions, timeoutOptions);
+      case "debounced":
+        return makeDebounced(op, options.ms ?? 0, options.leading ?? false, options.maxWait, retryOptions, timeoutOptions);
+      case "throttled":
+        return makeThrottled(op, options.ms ?? 0, options.trailing ?? false, retryOptions, timeoutOptions);
+      case "concurrent":
+        return makeConcurrent(
+          op,
+          options.n ?? 1,
+          options.overflow ?? "drop",
+          retryOptions,
+          timeoutOptions
+        );
+      case "keyed":
+        return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+    }
+  }
+  Op2.interpret = interpret;
+})(Op || (Op = {}));
+
 // src/Core/Optional.ts
 var Optional;
 ((Optional2) => {
@@ -328,77 +1201,99 @@ var RemoteData;
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
-var toPromise = (task) => Deferred.toPromise(task());
+var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-  Task2.from = (f) => () => Deferred.fromPromise(f());
-  Task2.map = (f) => (data) => (0, Task2.from)(() => toPromise(data).then(f));
-  Task2.chain = (f) => (data) => (0, Task2.from)(() => toPromise(data).then((a) => toPromise(f(a))));
+  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  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)(
-    () => Promise.all([
-      toPromise(data),
-      toPromise(arg)
+    (signal) => Promise.all([
+      toPromise(data, signal),
+      toPromise(arg, signal)
     ]).then(([f, a]) => f(a))
   );
   Task2.tap = (f) => (data) => (0, Task2.from)(
-    () => toPromise(data).then((a) => {
+    (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
   Task2.all = (tasks) => (0, Task2.from)(
-    () => Promise.all(tasks.map((t) => toPromise(t)))
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    () => new Promise(
+    (signal) => new Promise(
       (resolve2) => setTimeout(
-        () => toPromise(data).then(resolve2),
+        () => toPromise(data, signal).then(resolve2),
         ms
       )
     )
   );
-  Task2.repeat = (options) => (task) => (0, Task2.from)(() => {
+  Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
     const { times, delay: ms } = options;
     if (times <= 0) return Promise.resolve([]);
     const results = [];
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = (left) => toPromise(task).then((a) => {
+    const run = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
       return wait().then(() => run(left - 1));
     });
     return run(times);
   });
-  Task2.repeatUntil = (options) => (task) => (0, Task2.from)(() => {
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task).then((a) => {
+    const run = () => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       return wait().then(run);
     });
     return run();
   });
-  Task2.race = (tasks) => (0, Task2.from)(() => Promise.race(tasks.map(toPromise)));
-  Task2.sequential = (tasks) => (0, Task2.from)(async () => {
+  Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
+  Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
-      results.push(await toPromise(task));
+      results.push(await toPromise(task, signal));
     }
     return results;
   });
-  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)(() => {
+  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
+    const controller = new AbortController();
+    const onOuterAbort = () => controller.abort();
+    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
     return Promise.race([
-      toPromise(task).then((a) => {
+      toPromise(task, controller.signal).then((a) => {
         clearTimeout(timerId);
+        outerSignal?.removeEventListener("abort", onOuterAbort);
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
-        timerId = setTimeout(() => resolve2(Result.err(onTimeout())), ms);
+        timerId = setTimeout(() => {
+          controller.abort();
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          resolve2(Result.err(onTimeout()));
+        }, ms);
       })
     ]);
   });
+  Task2.abortable = (factory) => {
+    const controller = new AbortController();
+    const task = (outerSignal) => {
+      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: () => controller.abort() };
+  };
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -498,7 +1393,7 @@ var TaskResult;
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
   TaskResult2.err = (error) => Task.resolve(Result.err(error));
   TaskResult2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Result.ok).catch((e) => Result.err(onError(e)))
+    (signal) => f(signal).then(Result.ok).catch((e) => Result.err(onError(e)))
   );
   TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
@@ -512,43 +1407,6 @@ var TaskResult;
   )(data);
   TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
   TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult2.retry = (options) => (data) => Task.from(() => {
-    const { attempts, backoff, when: shouldRetry } = options;
-    const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
-    const run = (left) => Deferred.toPromise(data()).then((result) => {
-      if (Result.isOk(result)) return result;
-      if (left <= 1) return result;
-      if (shouldRetry !== void 0 && !shouldRetry(result.error)) {
-        return result;
-      }
-      const ms = getDelay(attempts - left + 1);
-      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(left - 1));
-    });
-    return run(attempts);
-  });
-  TaskResult2.pollUntil = (options) => (task) => Task.from(() => {
-    const { when: predicate, delay } = options;
-    const getDelay = (attempt) => delay === void 0 ? 0 : typeof delay === "function" ? delay(attempt) : delay;
-    const run = (attempt) => Deferred.toPromise(task()).then((result) => {
-      if (Result.isErr(result)) return result;
-      if (predicate(result.value)) return result;
-      const ms = getDelay(attempt);
-      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(attempt + 1));
-    });
-    return run(1);
-  });
-  TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from(() => {
-    let timerId;
-    return Promise.race([
-      Deferred.toPromise(data()).then((result) => {
-        clearTimeout(timerId);
-        return result;
-      }),
-      new Promise((resolve) => {
-        timerId = setTimeout(() => resolve(Result.err(onTimeout())), ms);
-      })
-    ]);
-  });
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts
@@ -585,7 +1443,7 @@ var Validation;
     return data;
   };
   Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err) => blockedErrors.includes(err)) ? fallback() : data;
+  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err2) => blockedErrors.includes(err2)) ? fallback() : data;
   Validation2.product = (first, second) => {
     if ((0, Validation2.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
     const errors = [
@@ -727,6 +1585,7 @@ var Tuple;
   Lens,
   Logged,
   Maybe,
+  Op,
   Optional,
   Predicate,
   Reader,