@nlozgachev/pipelined 0.28.0 → 0.30.0

package/dist/index.js

@@ -351,18 +351,18 @@ var Logged;
 var Result;
 ((Result2) => {
   Result2.ok = (value) => ({ kind: "Ok", value });
-  Result2.err = (error) => ({ kind: "Error", error });
+  Result2.error = (e) => ({ kind: "Error", error: e });
   Result2.isOk = (data) => data.kind === "Ok";
-  Result2.isErr = (data) => data.kind === "Error";
+  Result2.isError = (data) => data.kind === "Error";
   Result2.tryCatch = (f, onError) => {
     try {
       return (0, Result2.ok)(f());
     } catch (e) {
-      return (0, Result2.err)(onError(e));
+      return (0, Result2.error)(onError(e));
     }
   };
   Result2.map = (f) => (data) => (0, Result2.isOk)(data) ? (0, Result2.ok)(f(data.value)) : data;
-  Result2.mapError = (f) => (data) => (0, Result2.isErr)(data) ? (0, Result2.err)(f(data.error)) : data;
+  Result2.mapError = (f) => (data) => (0, Result2.isError)(data) ? (0, Result2.error)(f(data.error)) : data;
   Result2.chain = (f) => (data) => (0, Result2.isOk)(data) ? f(data.value) : data;
   Result2.fold = (onErr, onOk) => (data) => (0, Result2.isOk)(data) ? onOk(data.value) : onErr(data.error);
   Result2.match = (cases) => (data) => (0, Result2.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
@@ -372,14 +372,14 @@ var Result;
     return data;
   };
   Result2.tapError = (f) => (data) => {
-    if ((0, Result2.isErr)(data)) f(data.error);
+    if ((0, Result2.isError)(data)) f(data.error);
     return data;
   };
-  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
+  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isError)(data) ? data : arg;
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -394,7 +394,7 @@ var Maybe;
   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.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.error(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;
@@ -411,14 +411,14 @@ var Maybe;
 })(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 _abortedNil = { kind: "OpNil", reason: "aborted" };
+var _droppedNil = { kind: "OpNil", reason: "dropped" };
+var _replacedNil = { kind: "OpNil", reason: "replaced" };
+var _evictedNil = { kind: "OpNil", reason: "evicted" };
 var _idle = { kind: "Idle" };
 var _pending = { kind: "Pending" };
-var ok = (value) => ({ kind: "Ok", value });
-var err = (error) => ({ kind: "Err", error });
+var ok = (value) => ({ kind: "OpOk", value });
+var err = (error) => ({ kind: "OpError", error });
 var cancellableWait = (ms, signal) => {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve) => {
@@ -541,6 +541,12 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -605,6 +611,12 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -704,6 +716,12 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -774,6 +792,12 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -896,6 +920,12 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -988,6 +1018,12 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -1069,6 +1105,12 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -1145,6 +1187,15 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
       subscribers.add(cb);
       if (stateMap.size > 0) cb(new Map(stateMap));
       return () => subscribers.delete(cb);
+    },
+    reset: () => {
+      stateMap.clear();
+      emitSnapshot();
+    },
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -1199,6 +1250,12 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -1206,44 +1263,59 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
 // src/Core/Op.ts
 var Op;
 ((Op2) => {
-  Op2.nil = (reason) => ({ kind: "Nil", reason });
+  Op2.nil = (reason) => ({ kind: "OpNil", reason });
   Op2.create = (factory, onError) => ({
     _factory: (input, signal) => Deferred.fromPromise(
-      factory(signal)(input).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.err(onError(e)))
+      factory(signal)(input).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.error(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.lift = (f) => (0, Op2.create)(
+    (signal) => (input) => f(input, signal),
+    (e) => e
+  );
+  Op2.ok = (value) => ({ kind: "OpOk", value });
+  Op2.error = (error2) => ({ kind: "OpError", error: error2 });
+  Op2.isIdle = (state) => state.kind === "Idle";
+  Op2.isPending = (state) => state.kind === "Pending";
+  Op2.isQueued = (state) => state.kind === "Queued";
+  Op2.isRetrying = (state) => state.kind === "Retrying";
+  Op2.isOk = (state) => state.kind === "OpOk";
+  Op2.isError = (state) => state.kind === "OpError";
+  Op2.isNil = (state) => state.kind === "OpNil";
   Op2.match = (cases) => (outcome) => {
-    if (outcome.kind === "Ok") return cases.ok(outcome.value);
-    if (outcome.kind === "Err") return cases.err(outcome.error);
+    if (outcome.kind === "OpOk") return cases.ok(outcome.value);
+    if (outcome.kind === "OpError") return cases.error(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);
+  Op2.fold = (onError, onOk, onNil) => (outcome) => {
+    if (outcome.kind === "OpOk") return onOk(outcome.value);
+    if (outcome.kind === "OpError") return onError(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.getOrElse = (defaultValue) => (outcome) => outcome.kind === "OpOk" ? outcome.value : defaultValue();
+  Op2.map = (f) => (outcome) => outcome.kind === "OpOk" ? (0, Op2.ok)(f(outcome.value)) : outcome;
+  Op2.mapError = (f) => (outcome) => outcome.kind === "OpError" ? (0, Op2.error)(f(outcome.error)) : outcome;
+  Op2.chain = (f) => (outcome) => outcome.kind === "OpOk" ? f(outcome.value) : outcome;
   Op2.tap = (f) => (outcome) => {
-    if (outcome.kind === "Ok") f(outcome.value);
+    if (outcome.kind === "OpOk") f(outcome.value);
     return outcome;
   };
-  Op2.recover = (f) => (outcome) => outcome.kind === "Err" ? f(outcome.error) : outcome;
+  Op2.recover = (f) => (outcome) => outcome.kind === "OpError" ? 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());
+    if (outcome.kind === "OpOk") return Result.ok(outcome.value);
+    if (outcome.kind === "OpError") return Result.error(outcome.error);
+    return Result.error(onNil());
   };
-  Op2.toMaybe = (outcome) => outcome.kind === "Ok" ? Maybe.some(outcome.value) : Maybe.none();
+  Op2.toMaybe = (outcome) => outcome.kind === "OpOk" ? 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)));
+  Op2.wire = (source, f) => source.subscribe((state) => {
+    if ((0, Op2.isOk)(state)) f(state.value);
+  });
+  Op2.wireAll = (...pairs) => {
+    const cleanups = pairs.map(([source, f]) => (0, Op2.wire)(source, f));
+    return () => cleanups.forEach((c) => c());
+  };
   function interpret(op, options) {
     const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
     switch (strategy) {
@@ -1382,7 +1454,7 @@ var Refinement;
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
   Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
-  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
+  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.error(onFail(a));
 })(Refinement || (Refinement = {}));
 
 // src/Core/RemoteData.ts
@@ -1451,9 +1523,10 @@ var RemoteData;
   };
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
-  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+  RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.error((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
   RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
   RemoteData2.fromMaybe = (onNone) => (data) => Maybe.isSome(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(onNone());
+  RemoteData2.filter = (pred, onFalse) => (data) => (0, RemoteData2.isSuccess)(data) ? pred(data.value) ? data : (0, RemoteData2.failure)(onFalse(data.value)) : data;
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
@@ -1493,22 +1566,22 @@ var Task;
     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, signal).then((a) => {
+    const run2 = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
-      return wait().then(() => run(left - 1));
+      return wait().then(() => run2(left - 1));
     });
-    return run(times);
+    return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = (attempt) => toPromise(task, signal).then((a) => {
+    const run2 = (attempt) => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run(attempt + 1));
+      return wait().then(() => run2(attempt + 1));
     });
-    return run(1);
+    return run2(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
@@ -1533,7 +1606,7 @@ var Task;
         timerId = setTimeout(() => {
           controller.abort();
           outerSignal?.removeEventListener("abort", onOuterAbort);
-          resolve2(Result.err(onTimeout()));
+          resolve2(Result.error(onTimeout()));
         }, ms);
       })
     ]);
@@ -1556,6 +1629,7 @@ var Task;
     };
     return { task, abort };
   };
+  Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -1568,7 +1642,7 @@ var Resource;
   });
   Resource2.use = (f) => (resource) => Task.from(
     () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
-      if (Result.isErr(acquired)) return acquired;
+      if (Result.isError(acquired)) return acquired;
       const a = acquired.value;
       const usageResult = await Deferred.toPromise(f(a)());
       await Deferred.toPromise(resource.release(a)());
@@ -1578,10 +1652,10 @@ var Resource;
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
       () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
-        if (Result.isErr(acquiredA)) return acquiredA;
+        if (Result.isError(acquiredA)) return acquiredA;
         const a = acquiredA.value;
         const acquiredB = await Deferred.toPromise(resourceB.acquire());
-        if (Result.isErr(acquiredB)) {
+        if (Result.isError(acquiredB)) {
           await Deferred.toPromise(resourceA.release(a)());
           return acquiredB;
         }
@@ -1653,23 +1727,26 @@ var TaskMaybe;
 var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.err = (error) => Task.resolve(Result.error(error));
   TaskResult2.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Result.ok).catch((e) => Result.err(onError(e)))
+    (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
   );
   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)))(
+  TaskResult2.chain = (f) => (data) => Task.chain(
+    (result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.error(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(
-    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
+    (result) => Result.isError(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.run = (signal) => (task) => Deferred.toPromise(task(signal));
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts
@@ -1712,7 +1789,9 @@ var Validation;
   };
   Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
   Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some(isBlocked) ? fallback() : data;
-  Validation2.toResult = (data) => (0, Validation2.isValid)(data) ? Result.ok(data.value) : Result.err(data.errors);
+  Validation2.toResult = (data) => (0, Validation2.isValid)(data) ? Result.ok(data.value) : Result.error(data.errors);
+  Validation2.toMaybe = (data) => (0, Validation2.isValid)(data) ? Maybe.some(data.value) : Maybe.none();
+  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.valid)(data.value) : (0, Validation2.invalid)(data.error);
   Validation2.product = (first, second) => {
     if ((0, Validation2.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
     const errors = [
@@ -2017,7 +2096,7 @@ var Arr;
     const result = [];
     for (const a of data) {
       const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) return r;
+      if (Result.isError(r)) return r;
       result.push(r.value);
     }
     return Result.ok(result);
@@ -2158,6 +2237,14 @@ var Dict;
     }
     return result;
   };
+  Dict2.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") result.set(key, mapped.value);
+    }
+    return result;
+  };
   Dict2.union = (other) => (m) => {
     const result = new globalThis.Map(m);
     for (const [k, v] of other) {

package/dist/index.mjs

@@ -44,7 +44,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-QJS6D6MW.mjs";
+} from "./chunk-PV7JOUKL.mjs";
 import {
   Arr,
   Dict,
@@ -52,13 +52,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-CA3VE4YD.mjs";
+} from "./chunk-FWYOEWJ2.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-7JF44HJH.mjs";
+} from "./chunk-SDGDJ7CU.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-BZT0wedE.mjs';
+import { M as Maybe, R as Result, T as Task } from './Task-BDcKwFAj.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /**
@@ -269,7 +269,7 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.error("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -684,6 +684,21 @@ declare namespace Dict {
      * ```
      */
     const compact: <K, A>(m: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
+    /**
+     * Applies `f` to each value. Entries where `f` returns `None` are removed; entries where
+     * `f` returns `Some` are kept with the unwrapped value. Combines map and filter in one pass.
+     *
+     * @example
+     * ```ts
+     * const parse = (s: string): Maybe<number> => {
+     *     const n = Number(s);
+     *     return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     * };
+     * Dict.filterMap(parse)(Dict.fromRecord({ a: "1", b: "two", c: "3" }));
+     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * ```
+     */
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
     /**
      * Merges two dictionaries. When both contain the same key, the value from `other` takes
      * precedence.

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-BW66NsGR.js';
+import { M as Maybe, R as Result, T as Task } from './Task-CnF22Q2o.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /**
@@ -269,7 +269,7 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.error("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -684,6 +684,21 @@ declare namespace Dict {
      * ```
      */
     const compact: <K, A>(m: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
+    /**
+     * Applies `f` to each value. Entries where `f` returns `None` are removed; entries where
+     * `f` returns `Some` are kept with the unwrapped value. Combines map and filter in one pass.
+     *
+     * @example
+     * ```ts
+     * const parse = (s: string): Maybe<number> => {
+     *     const n = Number(s);
+     *     return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     * };
+     * Dict.filterMap(parse)(Dict.fromRecord({ a: "1", b: "two", c: "3" }));
+     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * ```
+     */
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
     /**
      * Merges two dictionaries. When both contain the same key, the value from `other` takes
      * precedence.

package/dist/utils.js

@@ -43,18 +43,18 @@ var Deferred;
 var Result;
 ((Result2) => {
   Result2.ok = (value) => ({ kind: "Ok", value });
-  Result2.err = (error) => ({ kind: "Error", error });
+  Result2.error = (e) => ({ kind: "Error", error: e });
   Result2.isOk = (data) => data.kind === "Ok";
-  Result2.isErr = (data) => data.kind === "Error";
+  Result2.isError = (data) => data.kind === "Error";
   Result2.tryCatch = (f, onError) => {
     try {
       return (0, Result2.ok)(f());
     } catch (e) {
-      return (0, Result2.err)(onError(e));
+      return (0, Result2.error)(onError(e));
     }
   };
   Result2.map = (f) => (data) => (0, Result2.isOk)(data) ? (0, Result2.ok)(f(data.value)) : data;
-  Result2.mapError = (f) => (data) => (0, Result2.isErr)(data) ? (0, Result2.err)(f(data.error)) : data;
+  Result2.mapError = (f) => (data) => (0, Result2.isError)(data) ? (0, Result2.error)(f(data.error)) : data;
   Result2.chain = (f) => (data) => (0, Result2.isOk)(data) ? f(data.value) : data;
   Result2.fold = (onErr, onOk) => (data) => (0, Result2.isOk)(data) ? onOk(data.value) : onErr(data.error);
   Result2.match = (cases) => (data) => (0, Result2.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
@@ -64,14 +64,14 @@ var Result;
     return data;
   };
   Result2.tapError = (f) => (data) => {
-    if ((0, Result2.isErr)(data)) f(data.error);
+    if ((0, Result2.isError)(data)) f(data.error);
     return data;
   };
-  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
+  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isError)(data) ? data : arg;
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -86,7 +86,7 @@ var Maybe;
   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.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.error(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;
@@ -139,22 +139,22 @@ var Task;
     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, signal).then((a) => {
+    const run2 = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
-      return wait().then(() => run(left - 1));
+      return wait().then(() => run2(left - 1));
     });
-    return run(times);
+    return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = (attempt) => toPromise(task, signal).then((a) => {
+    const run2 = (attempt) => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run(attempt + 1));
+      return wait().then(() => run2(attempt + 1));
     });
-    return run(1);
+    return run2(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
@@ -179,7 +179,7 @@ var Task;
         timerId = setTimeout(() => {
           controller.abort();
           outerSignal?.removeEventListener("abort", onOuterAbort);
-          resolve2(Result.err(onTimeout()));
+          resolve2(Result.error(onTimeout()));
         }, ms);
       })
     ]);
@@ -202,6 +202,7 @@ var Task;
     };
     return { task, abort };
   };
+  Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
 })(Task || (Task = {}));
 
 // src/Types/NonEmptyList.ts
@@ -365,7 +366,7 @@ var Arr;
     const result = [];
     for (const a of data) {
       const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) return r;
+      if (Result.isError(r)) return r;
       result.push(r.value);
     }
     return Result.ok(result);
@@ -506,6 +507,14 @@ var Dict;
     }
     return result;
   };
+  Dict2.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") result.set(key, mapped.value);
+    }
+    return result;
+  };
   Dict2.union = (other) => (m) => {
     const result = new globalThis.Map(m);
     for (const [k, v] of other) {

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-CA3VE4YD.mjs";
-import "./chunk-7JF44HJH.mjs";
+} from "./chunk-FWYOEWJ2.mjs";
+import "./chunk-SDGDJ7CU.mjs";
 import "./chunk-DBIC62UV.mjs";
 export {
   Arr,