@nlozgachev/pipelined 0.11.0 → 0.13.0

package/types/src/Core/Result.d.ts

@@ -1,182 +0,0 @@
-import { WithError, WithKind, WithValue } from "./InternalTypes.js";
-import { Option } from "./Option.js";
-/**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
- * Use Result when an operation can fail with a meaningful error value.
- *
- * @example
- * ```ts
- * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
- *
- * pipe(
- *   divide(10, 2),
- *   Result.map(n => n * 2),
- *   Result.getOrElse(() => 0)
- * ); // 10
- * ```
- */
-export type Result<E, A> = Ok<A> | Err<E>;
-export type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-export type Err<E> = WithKind<"Error"> & WithError<E>;
-export declare namespace Result {
-    /**
-     * Creates a successful Result with the given value.
-     */
-    const ok: <A>(value: A) => Ok<A>;
-    /**
-     * Creates a failed Result with the given error.
-     */
-    const err: <E>(error: E) => Err<E>;
-    /**
-     * Type guard that checks if an Result is Ok.
-     */
-    const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
-    /**
-     * Type guard that checks if an Result is Err.
-     */
-    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
-    /**
-     * Creates an Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     *
-     * @example
-     * ```ts
-     * const parseJson = (s: string): Result<string, unknown> =>
-     *   Result.tryCatch(
-     *     () => JSON.parse(s),
-     *     (e) => `Parse error: ${e}`
-     *   );
-     * ```
-     */
-    const tryCatch: <E, A>(f: () => A, onError: (e: unknown) => E) => Result<E, A>;
-    /**
-     * Transforms the success value inside an Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
-     * ```
-     */
-    const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
-    /**
-     * Transforms the error value inside an Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
-     * ```
-     */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
-    /**
-     * Chains Result computations. If the first is Ok, passes the value to f.
-     * If the first is Err, propagates the error.
-     *
-     * @example
-     * ```ts
-     * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
-     *
-     * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
-     * ```
-     */
-    const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
-    /**
-     * Extracts the value from an Result by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.ok(5),
-     *   Result.fold(
-     *     e => `Error: ${e}`,
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Result<E, A>) => B;
-    /**
-     * Pattern matches on a Result, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   result,
-     *   Result.match({
-     *     ok: value => `Got ${value}`,
-     *     err: error => `Failed: ${error}`
-     *   })
-     * );
-     * ```
-     */
-    const match: <E, A, B>(cases: {
-        ok: (a: A) => B;
-        err: (e: E) => B;
-    }) => (data: Result<E, A>) => B;
-    /**
-     * Returns the success value or a default value if the Result is an error.
-     * The default is a thunk `() => B` — evaluated only when the Result is Err.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
-    /**
-     * Executes a side effect on the success value without changing the Result.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.ok(5),
-     *   Result.tap(n => console.log("Value:", n)),
-     *   Result.map(n => n * 2)
-     * );
-     * ```
-     */
-    const tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
-    /**
-     * Recovers from an error by providing a fallback Result.
-     * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
-     */
-    const recover: <E, A, B>(fallback: (e: E) => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
-    /**
-     * Recovers from an error unless it matches the blocked error.
-     * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
-     */
-    const recoverUnless: <E, A, B>(blockedErr: E, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
-    /**
-     * Converts a Result to an Option.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Result.toOption(Result.ok(42)); // Some(42)
-     * Result.toOption(Result.err("oops")); // None
-     * ```
-     */
-    const toOption: <E, A>(data: Result<E, A>) => Option<A>;
-    /**
-     * Applies a function wrapped in an Result to a value wrapped in an Result.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Result.ok(add),
-     *   Result.ap(Result.ok(5)),
-     *   Result.ap(Result.ok(3))
-     * ); // Ok(8)
-     * ```
-     */
-    const ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
-}
-//# sourceMappingURL=Result.d.ts.map

package/types/src/Core/Result.d.ts.map

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

package/types/src/Core/State.d.ts

@@ -1,192 +0,0 @@
-/**
- * A synchronous computation that threads a piece of mutable state `S` through
- * a pipeline without exposing mutation at call sites.
- *
- * At runtime a `State<S, A>` is just a function from an initial state to a pair
- * `[value, nextState]`. Nothing runs until you supply the initial state with
- * `State.run`, `State.evaluate`, or `State.execute`.
- *
- * @example
- * ```ts
- * type Counter = number;
- *
- * const increment: State<Counter, undefined> = State.modify(n => n + 1);
- * const getCount:  State<Counter, Counter>   = State.get();
- *
- * const program = pipe(
- *   increment,
- *   State.chain(() => increment),
- *   State.chain(() => getCount),
- * );
- *
- * State.run(0)(program); // [2, 2]  — value is 2, final state is 2
- * ```
- */
-export type State<S, A> = (s: S) => readonly [A, S];
-export declare namespace State {
-    /**
-     * Lifts a pure value into a State computation. The state passes through unchanged.
-     *
-     * @example
-     * ```ts
-     * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
-     * ```
-     */
-    const resolve: <S, A>(value: A) => State<S, A>;
-    /**
-     * Produces the current state as the value, without modifying it.
-     *
-     * @example
-     * ```ts
-     * const readStack: State<string[], string[]> = State.get();
-     * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
-     * ```
-     */
-    const get: <S>() => State<S, S>;
-    /**
-     * Reads a projection of the state without modifying it.
-     * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
-     *
-     * @example
-     * ```ts
-     * type AppState = { count: number; label: string };
-     * const readCount: State<AppState, number> = State.gets(s => s.count);
-     * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
-     * ```
-     */
-    const gets: <S, A>(f: (s: S) => A) => State<S, A>;
-    /**
-     * Replaces the current state with a new value. Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const reset: State<number, undefined> = State.put(0);
-     * State.run(99)(reset); // [undefined, 0]
-     * ```
-     */
-    const put: <S>(newState: S) => State<S, undefined>;
-    /**
-     * Applies a function to the current state to produce the next state.
-     * Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
-     * ```
-     */
-    const modify: <S>(f: (s: S) => S) => State<S, undefined>;
-    /**
-     * Transforms the value produced by a State computation.
-     * The state transformation is unchanged.
-     *
-     * @example
-     * ```ts
-     * const readLength: State<string[], number> = pipe(
-     *   State.get<string[]>(),
-     *   State.map(stack => stack.length),
-     * );
-     *
-     * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
-     * ```
-     */
-    const map: <S, A, B>(f: (a: A) => B) => (st: State<S, A>) => State<S, B>;
-    /**
-     * Sequences two State computations. The state output of the first is passed
-     * as the state input to the second.
-     *
-     * Data-last — the first computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * const program = pipe(
-     *   push("a"),
-     *   State.chain(() => push("b")),
-     *   State.chain(() => State.get<string[]>()),
-     * );
-     *
-     * State.evaluate([])(program); // ["a", "b"]
-     * ```
-     */
-    const chain: <S, A, B>(f: (a: A) => State<S, B>) => (st: State<S, A>) => State<S, B>;
-    /**
-     * Applies a function wrapped in a State to a value wrapped in a State.
-     * The function computation runs first; its output state is the input to the
-     * argument computation.
-     *
-     * @example
-     * ```ts
-     * const addCounted = (n: number) => (m: number) => n + m;
-     * const program = pipe(
-     *   State.resolve<number, typeof addCounted>(addCounted),
-     *   State.ap(State.gets((s: number) => s * 2)),
-     *   State.ap(State.gets((s: number) => s)),
-     * );
-     *
-     * State.evaluate(3)(program); // 6 + 3 = 9
-     * ```
-     */
-    const ap: <S, A>(arg: State<S, A>) => <B>(fn: State<S, (a: A) => B>) => State<S, B>;
-    /**
-     * Runs a side effect on the produced value without changing the State computation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   State.get<number>(),
-     *   State.tap(n => console.log("current:", n)),
-     *   State.chain(() => State.modify(n => n + 1)),
-     * );
-     * ```
-     */
-    const tap: <S, A>(f: (a: A) => void) => (st: State<S, A>) => State<S, A>;
-    /**
-     * Runs a State computation with an initial state, returning both the
-     * produced value and the final state as a pair.
-     *
-     * Data-last — the computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const program = pipe(
-     *   State.modify<number>(n => n + 1),
-     *   State.chain(() => State.get<number>()),
-     * );
-     *
-     * State.run(0)(program); // [1, 1]
-     * ```
-     */
-    const run: <S>(initialState: S) => <A>(st: State<S, A>) => readonly [A, S];
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * produced value (discarding the final state).
-     *
-     * @example
-     * ```ts
-     * State.evaluate([])(pipe(
-     *   State.modify<string[]>(s => [...s, "x"]),
-     *   State.chain(() => State.get<string[]>()),
-     * )); // ["x"]
-     * ```
-     */
-    const evaluate: <S>(initialState: S) => <A>(st: State<S, A>) => A;
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * final state (discarding the produced value).
-     *
-     * @example
-     * ```ts
-     * State.execute(0)(pipe(
-     *   State.modify<number>(n => n + 10),
-     *   State.chain(() => State.modify<number>(n => n * 2)),
-     * )); // 20
-     * ```
-     */
-    const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
-}
-//# sourceMappingURL=State.d.ts.map

package/types/src/Core/State.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../src/src/Core/State.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpD,yBAAiB,KAAK,CAAC;IACtB;;;;;;;OAOG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAsB,CAAC;IAE1E;;;;;;;;OAQG;IACI,MAAM,GAAG,GAAI,CAAC,OAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAkB,CAAC;IAEvD;;;;;;;;;;OAUG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAqB,CAAC;IAE5E;;;;;;;;OAQG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,UAAU,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,SAAS,CAAkC,CAAC;IAE1F;;;;;;;;;;;OAWG;IACI,MAAM,MAAM,GAAI,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,SAAS,CAA6B,CAAC;IAE3F;;;;;;;;;;;;;OAaG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAG5E,CAAC;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAGxF,CAAC;IAEF;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAIvF,CAAC;IAEF;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAI5E,CAAC;IAEF;;;;;;;;;;;;;;;OAeG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAqB,CAAC;IAErG;;;;;;;;;;;OAWG;IACI,MAAM,QAAQ,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAwB,CAAC;IAE/F;;;;;;;;;;;OAWG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAwB,CAAC;CAC9F"}

package/types/src/Core/Task.d.ts

@@ -1,219 +0,0 @@
-import { Deferred } from "./Deferred.js";
-import { Result } from "./Result.js";
-/**
- * A lazy async computation that always resolves.
- *
- * Two guarantees:
- * - **Lazy** — nothing starts until you call it.
- * - **Infallible** — it never rejects. If failure is possible, encode it in the
- *   return type using `TaskResult<E, A>` instead.
- *
- * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
- * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
- *
- * **Consuming a Task:**
- *
- * Use `await task()` to run it and get the value directly:
- * ```ts
- * const value: number = await task();
- * ```
- *
- * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
- * the `Deferred` with `Deferred.toPromise`:
- * ```ts
- * const p: Promise<number> = Deferred.toPromise(task());
- * ```
- *
- * @example
- * ```ts
- * const getTimestamp: Task<number> = Task.resolve(Date.now());
- *
- * // Nothing runs yet — getTimestamp is just a description
- * const formatted = pipe(
- *   getTimestamp,
- *   Task.map(ts => new Date(ts).toISOString())
- * );
- *
- * // Execute when ready
- * const result = await formatted();
- * ```
- */
-export type Task<A> = () => Deferred<A>;
-export declare namespace Task {
-    /**
-     * Creates a Task that immediately resolves to the given value.
-     *
-     * @example
-     * ```ts
-     * const task = Task.resolve(42);
-     * const value = await task(); // 42
-     * ```
-     */
-    const resolve: <A>(value: A) => Task<A>;
-    /**
-     * Creates a Task from a function that returns a Promise.
-     *
-     * @example
-     * ```ts
-     * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
-     * ```
-     */
-    const from: <A>(f: () => Promise<A>) => Task<A>;
-    /**
-     * Transforms the value inside a Task.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(5),
-     *   Task.map(n => n * 2)
-     * )(); // Deferred<10>
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
-    /**
-     * Chains Task computations. Passes the resolved value of the first Task to f.
-     *
-     * @example
-     * ```ts
-     * const readUserId: Task<string> = Task.resolve(session.userId);
-     * const loadPrefs = (id: string): Task<Preferences> =>
-     *   Task.resolve(prefsCache.get(id));
-     *
-     * pipe(
-     *   readUserId,
-     *   Task.chain(loadPrefs)
-     * )(); // Deferred<Preferences>
-     * ```
-     */
-    const chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
-    /**
-     * Applies a function wrapped in a Task to a value wrapped in a Task.
-     * Both Tasks run in parallel.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Task.resolve(add),
-     *   Task.ap(Task.resolve(5)),
-     *   Task.ap(Task.resolve(3))
-     * )(); // Deferred<8>
-     * ```
-     */
-    const ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
-    /**
-     * Executes a side effect on the value without changing the Task.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   loadConfig,
-     *   Task.tap(cfg => console.log("Config:", cfg)),
-     *   Task.map(buildReport)
-     * );
-     * ```
-     */
-    const tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
-    /**
-     * Runs multiple Tasks in parallel and collects their results.
-     *
-     * @example
-     * ```ts
-     * Task.all([loadConfig, detectLocale, loadTheme])();
-     * // Deferred<[Config, string, Theme]>
-     * ```
-     */
-    const all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
-    /**
-     * Delays the execution of a Task by the specified milliseconds.
-     * Useful for debouncing or rate limiting.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(42),
-     *   Task.delay(1000)
-     * )(); // Resolves after 1 second
-     * ```
-     */
-    const delay: (ms: number) => <A>(data: Task<A>) => Task<A>;
-    /**
-     * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay (ms) can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   pollSensor,
-     *   Task.repeat({ times: 5, delay: 1000 })
-     * )(); // Task<Reading[]> — 5 readings, one per second
-     * ```
-     */
-    const repeat: (options: {
-        times: number;
-        delay?: number;
-    }) => <A>(task: Task<A>) => Task<A[]>;
-    /**
-     * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay (ms) can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: 500 })
-     * )(); // polls every 500ms until status is "ready"
-     * ```
-     */
-    const repeatUntil: <A>(options: {
-        when: (a: A) => boolean;
-        delay?: number;
-    }) => (task: Task<A>) => Task<A>;
-    /**
-     * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately; the rest are abandoned once one resolves.
-     *
-     * @example
-     * ```ts
-     * const fast = Task.from(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
-     *
-     * await Task.race([fast, slow])(); // "fast"
-     * ```
-     */
-    const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
-    /**
-     * Runs an array of Tasks one at a time in order, collecting all results.
-     * Each Task starts only after the previous one resolves.
-     *
-     * @example
-     * ```ts
-     * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from(() => {
-     *   log.push(n);
-     *   return Promise.resolve(n);
-     * });
-     *
-     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
-     * // log = [1, 2, 3] — tasks ran in order
-     * ```
-     */
-    const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
-    /**
-     * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given time.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   heavyComputation,
-     *   Task.timeout(5000, () => "timed out"),
-     *   TaskResult.chain(processResult)
-     * );
-     * ```
-     */
-    const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
-}
-//# sourceMappingURL=Task.d.ts.map

package/types/src/Core/Task.d.ts.map

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