@nlozgachev/pipelined 0.6.4

package/script/src/Core/TaskResult.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResult = void 0;
+const Deferred_js_1 = require("./Deferred.js");
+const Result_js_1 = require("./Result.js");
+const Task_js_1 = require("./Task.js");
+var TaskResult;
+(function (TaskResult) {
+    /**
+     * Wraps a value in a successful TaskResult.
+     */
+    TaskResult.ok = (value) => Task_js_1.Task.resolve(Result_js_1.Result.ok(value));
+    /**
+     * Creates a failed TaskResult with the given error.
+     */
+    TaskResult.err = (error) => Task_js_1.Task.resolve(Result_js_1.Result.err(error));
+    /**
+     * Creates a TaskResult from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const parseJson = (s: string): TaskResult<string, unknown> =>
+     *   TaskResult.tryCatch(
+     *     async () => JSON.parse(s),
+     *     (e) => `Parse error: ${e}`
+     *   );
+     * ```
+     */
+    TaskResult.tryCatch = (f, onError) => Task_js_1.Task.from(() => f()
+        .then(Result_js_1.Result.ok)
+        .catch((e) => Result_js_1.Result.err(onError(e))));
+    /**
+     * Transforms the success value inside a TaskResult.
+     */
+    TaskResult.map = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.map(f))(data);
+    /**
+     * Transforms the error value inside a TaskResult.
+     */
+    TaskResult.mapError = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.mapError(f))(data);
+    /**
+     * Chains TaskResult computations. If the first succeeds, passes the value to f.
+     * If the first fails, propagates the error.
+     */
+    TaskResult.chain = (f) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isOk(result) ? f(result.value) : Task_js_1.Task.resolve(Result_js_1.Result.err(result.error)))(data);
+    /**
+     * Extracts the value from a TaskResult by providing handlers for both cases.
+     */
+    TaskResult.fold = (onErr, onOk) => (data) => Task_js_1.Task.map(Result_js_1.Result.fold(onErr, onOk))(data);
+    /**
+     * Pattern matches on a TaskResult, returning a Task of the result.
+     */
+    TaskResult.match = (cases) => (data) => Task_js_1.Task.map(Result_js_1.Result.match(cases))(data);
+    /**
+     * Recovers from an error by providing a fallback TaskResult.
+     */
+    TaskResult.recover = (fallback) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isErr(result) ? fallback(result.error) : Task_js_1.Task.resolve(result))(data);
+    /**
+     * Returns the success value or a default value if the TaskResult is an error.
+     */
+    TaskResult.getOrElse = (defaultValue) => (data) => Task_js_1.Task.map(Result_js_1.Result.getOrElse(defaultValue))(data);
+    /**
+     * Executes a side effect on the success value without changing the TaskResult.
+     * Useful for logging or debugging.
+     */
+    TaskResult.tap = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.tap(f))(data);
+    /**
+     * Re-runs a TaskResult on `Err` with configurable attempts, backoff, and retry condition.
+     *
+     * @param options.attempts - Total number of attempts (1 = no retry, 3 = up to 3 tries)
+     * @param options.backoff - Fixed delay in ms, or a function `(attempt) => ms` for computed delay
+     * @param options.when - Only retry when this returns true; defaults to always retry on Err
+     *
+     * @example
+     * ```ts
+     * // Retry up to 3 times with exponential backoff
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.retry({ attempts: 3, backoff: n => n * 1000 })
+     * );
+     *
+     * // Only retry on network errors, not auth errors
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.retry({ attempts: 3, when: e => e instanceof NetworkError })
+     * );
+     * ```
+     */
+    TaskResult.retry = (options) => (data) => Task_js_1.Task.from(() => {
+        const { attempts, backoff, when: shouldRetry } = options;
+        const getDelay = (n) => backoff === undefined ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
+        const run = (left) => Deferred_js_1.Deferred.toPromise(data()).then((result) => {
+            if (Result_js_1.Result.isOk(result))
+                return result;
+            if (left <= 1)
+                return result;
+            if (shouldRetry !== undefined && !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);
+    });
+    /**
+     * Fails a TaskResult with a typed error if it does not resolve within the given time.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.timeout(5000, () => new TimeoutError("fetch user timed out"))
+     * );
+     * ```
+     */
+    TaskResult.timeout = (ms, onTimeout) => (data) => Task_js_1.Task.from(() => {
+        let timerId;
+        return Promise.race([
+            Deferred_js_1.Deferred.toPromise(data()).then((result) => {
+                clearTimeout(timerId);
+                return result;
+            }),
+            new Promise((resolve) => {
+                timerId = setTimeout(() => resolve(Result_js_1.Result.err(onTimeout())), ms);
+            }),
+        ]);
+    });
+})(TaskResult || (exports.TaskResult = TaskResult = {}));

package/script/src/Core/TaskValidation.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskValidation = void 0;
+const Deferred_js_1 = require("./Deferred.js");
+const Task_js_1 = require("./Task.js");
+const Validation_js_1 = require("./Validation.js");
+var TaskValidation;
+(function (TaskValidation) {
+    /**
+     * Wraps a value in a valid TaskValidation.
+     */
+    TaskValidation.valid = (value) => Task_js_1.Task.resolve(Validation_js_1.Validation.valid(value));
+    /**
+     * Creates a failed TaskValidation with a single error.
+     */
+    TaskValidation.invalid = (error) => Task_js_1.Task.resolve(Validation_js_1.Validation.invalid(error));
+    /**
+     * Creates an invalid TaskValidation from multiple errors.
+     */
+    TaskValidation.invalidAll = (errors) => Task_js_1.Task.resolve(Validation_js_1.Validation.invalidAll(errors));
+    /**
+     * Lifts a Validation into a TaskValidation.
+     */
+    TaskValidation.fromValidation = (validation) => Task_js_1.Task.resolve(validation);
+    /**
+     * Creates a TaskValidation from a Promise-returning function.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = (id: string): TaskValidation<string, User> =>
+     *   TaskValidation.tryCatch(
+     *     () => fetch(`/users/${id}`).then(r => r.json()),
+     *     e => `Failed to fetch user: ${e}`
+     *   );
+     * ```
+     */
+    TaskValidation.tryCatch = (f, onError) => Task_js_1.Task.from(() => f()
+        .then((Validation_js_1.Validation.valid))
+        .catch((e) => Validation_js_1.Validation.invalid(onError(e))));
+    /**
+     * Transforms the success value inside a TaskValidation.
+     */
+    TaskValidation.map = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.map(f))(data);
+    /**
+     * Chains TaskValidation computations. If the first is Valid, passes the value
+     * to f. If the first is Invalid, propagates the errors.
+     *
+     * Note: chain short-circuits on first error. Use ap to accumulate errors.
+     */
+    TaskValidation.chain = (f) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation)
+        ? f(validation.value)
+        : Task_js_1.Task.resolve(Validation_js_1.Validation.invalidAll(validation.errors)))(data);
+    /**
+     * Applies a function wrapped in a TaskValidation to a value wrapped in a
+     * TaskValidation. Both Tasks run in parallel and errors from both sides
+     * are accumulated.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
+     *   TaskValidation.ap(validateName(name)),
+     *   TaskValidation.ap(validateAge(age))
+     * )();
+     * ```
+     */
+    TaskValidation.ap = (arg) => (data) => Task_js_1.Task.from(() => Promise.all([
+        Deferred_js_1.Deferred.toPromise(data()),
+        Deferred_js_1.Deferred.toPromise(arg()),
+    ]).then(([vf, va]) => Validation_js_1.Validation.ap(va)(vf)));
+    /**
+     * Extracts a value from a TaskValidation by providing handlers for both cases.
+     */
+    TaskValidation.fold = (onInvalid, onValid) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.fold(onInvalid, onValid))(data);
+    /**
+     * Pattern matches on a TaskValidation, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validateForm(input),
+     *   TaskValidation.match({
+     *     valid: data => save(data),
+     *     invalid: errors => showErrors(errors)
+     *   })
+     * )();
+     * ```
+     */
+    TaskValidation.match = (cases) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.match(cases))(data);
+    /**
+     * Returns the success value or a default value if the TaskValidation is invalid.
+     */
+    TaskValidation.getOrElse = (defaultValue) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.getOrElse(defaultValue))(data);
+    /**
+     * Executes a side effect on the success value without changing the TaskValidation.
+     * Useful for logging or debugging.
+     */
+    TaskValidation.tap = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.tap(f))(data);
+    /**
+     * Recovers from an Invalid state by providing a fallback TaskValidation.
+     */
+    TaskValidation.recover = (fallback) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation) ? Task_js_1.Task.resolve(validation) : fallback())(data);
+})(TaskValidation || (exports.TaskValidation = TaskValidation = {}));

package/script/src/Core/These.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.These = void 0;
+var These;
+(function (These) {
+    /**
+     * Creates a These holding only a first value.
+     *
+     * @example
+     * ```ts
+     * These.first(42); // { kind: "First", first: 42 }
+     * ```
+     */
+    These.first = (value) => ({ kind: "First", first: value });
+    /**
+     * Creates a These holding only a second value.
+     *
+     * @example
+     * ```ts
+     * These.second("warning"); // { kind: "Second", second: "warning" }
+     * ```
+     */
+    These.second = (value) => ({ kind: "Second", second: value });
+    /**
+     * Creates a These holding both a first and a second value simultaneously.
+     *
+     * @example
+     * ```ts
+     * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
+     * ```
+     */
+    These.both = (first, second) => ({
+        kind: "Both",
+        first,
+        second,
+    });
+    /**
+     * Type guard — checks if a These holds only a first value.
+     */
+    These.isFirst = (data) => data.kind === "First";
+    /**
+     * Type guard — checks if a These holds only a second value.
+     */
+    These.isSecond = (data) => data.kind === "Second";
+    /**
+     * Type guard — checks if a These holds both values simultaneously.
+     */
+    These.isBoth = (data) => data.kind === "Both";
+    /**
+     * Returns true if the These contains a first value (First or Both).
+     */
+    These.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
+    /**
+     * Returns true if the These contains a second value (Second or Both).
+     */
+    These.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.mapFirst(n => n * 2));           // First(10)
+     * pipe(These.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+     * pipe(These.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
+     * ```
+     */
+    These.mapFirst = (f) => (data) => {
+        if (These.isSecond(data))
+            return data;
+        if (These.isFirst(data))
+            return These.first(f(data.first));
+        return These.both(f(data.first), data.second);
+    };
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
+     * pipe(These.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
+     * ```
+     */
+    These.mapSecond = (f) => (data) => {
+        if (These.isFirst(data))
+            return data;
+        if (These.isSecond(data))
+            return These.second(f(data.second));
+        return These.both(data.first, f(data.second));
+    };
+    /**
+     * Transforms both the first and second values independently.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   These.both(5, "warn"),
+     *   These.mapBoth(n => n * 2, e => e.toUpperCase())
+     * ); // Both(10, "WARN")
+     * ```
+     */
+    These.mapBoth = (onFirst, onSecond) => (data) => {
+        if (These.isSecond(data))
+            return These.second(onSecond(data.second));
+        if (These.isFirst(data))
+            return These.first(onFirst(data.first));
+        return These.both(onFirst(data.first), onSecond(data.second));
+    };
+    /**
+     * Chains These computations by passing the first value to f.
+     * Second propagates unchanged; First and Both apply f to the first value.
+     *
+     * @example
+     * ```ts
+     * const double = (n: number): These<number, string> => These.first(n * 2);
+     *
+     * pipe(These.first(5), These.chainFirst(double));            // First(10)
+     * pipe(These.both(5, "warn"), These.chainFirst(double));     // First(10)
+     * pipe(These.second("warn"), These.chainFirst(double));      // Second("warn")
+     * ```
+     */
+    These.chainFirst = (f) => (data) => {
+        if (These.isSecond(data))
+            return data;
+        return f(data.first);
+    };
+    /**
+     * Chains These computations by passing the second value to f.
+     * First propagates unchanged; Second and Both apply f to the second value.
+     *
+     * @example
+     * ```ts
+     * const shout = (s: string): These<number, string> => These.second(s.toUpperCase());
+     *
+     * pipe(These.second("warn"), These.chainSecond(shout));      // Second("WARN")
+     * pipe(These.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+     * pipe(These.first(5), These.chainSecond(shout));            // First(5)
+     * ```
+     */
+    These.chainSecond = (f) => (data) => {
+        if (These.isFirst(data))
+            return data;
+        return f(data.second);
+    };
+    /**
+     * Extracts a value from a These by providing handlers for all three cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.fold(
+     *     a => `First: ${a}`,
+     *     b => `Second: ${b}`,
+     *     (a, b) => `Both: ${a} / ${b}`
+     *   )
+     * );
+     * ```
+     */
+    These.fold = (onFirst, onSecond, onBoth) => (data) => {
+        if (These.isSecond(data))
+            return onSecond(data.second);
+        if (These.isFirst(data))
+            return onFirst(data.first);
+        return onBoth(data.first, data.second);
+    };
+    /**
+     * Pattern matches on a These, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.match({
+     *     first: a => `First: ${a}`,
+     *     second: b => `Second: ${b}`,
+     *     both: (a, b) => `Both: ${a} / ${b}`
+     *   })
+     * );
+     * ```
+     */
+    These.match = (cases) => (data) => {
+        if (These.isSecond(data))
+            return cases.second(data.second);
+        if (These.isFirst(data))
+            return cases.first(data.first);
+        return cases.both(data.first, data.second);
+    };
+    /**
+     * Returns the first value, or a default if the These has no first value.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.getFirstOrElse(0));            // 5
+     * pipe(These.both(5, "warn"), These.getFirstOrElse(0));     // 5
+     * pipe(These.second("warn"), These.getFirstOrElse(0));      // 0
+     * ```
+     */
+    These.getFirstOrElse = (defaultValue) => (data) => These.hasFirst(data) ? data.first : defaultValue;
+    /**
+     * Returns the second value, or a default if the These has no second value.
+     *
+     * @example
+     * ```ts
+     * pipe(These.second("warn"), These.getSecondOrElse("none")); // "warn"
+     * pipe(These.both(5, "warn"), These.getSecondOrElse("none")); // "warn"
+     * pipe(These.first(5), These.getSecondOrElse("none"));       // "none"
+     * ```
+     */
+    These.getSecondOrElse = (defaultValue) => (data) => These.hasSecond(data) ? data.second : defaultValue;
+    /**
+     * Executes a side effect on the first value without changing the These.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.tap(console.log)); // logs 5, returns First(5)
+     * ```
+     */
+    These.tap = (f) => (data) => {
+        if (These.hasFirst(data))
+            f(data.first);
+        return data;
+    };
+    /**
+     * Swaps the roles of first and second values.
+     * - First(a)    → Second(a)
+     * - Second(b)   → First(b)
+     * - Both(a, b)  → Both(b, a)
+     *
+     * @example
+     * ```ts
+     * These.swap(These.first(5));            // Second(5)
+     * These.swap(These.second("warn"));      // First("warn")
+     * These.swap(These.both(5, "warn"));     // Both("warn", 5)
+     * ```
+     */
+    These.swap = (data) => {
+        if (These.isSecond(data))
+            return These.first(data.second);
+        if (These.isFirst(data))
+            return These.second(data.first);
+        return These.both(data.second, data.first);
+    };
+})(These || (exports.These = These = {}));

package/script/src/Core/Validation.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validation = void 0;
+const NonEmptyList_js_1 = require("../Types/NonEmptyList.js");
+var Validation;
+(function (Validation) {
+    /**
+     * Wraps a value in a valid Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.valid(42); // Valid(42)
+     * ```
+     */
+    Validation.valid = (value) => ({
+        kind: "Valid",
+        value,
+    });
+    /**
+     * Creates an invalid Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.invalid("Invalid input");
+     * ```
+     */
+    Validation.invalid = (error) => ({
+        kind: "Invalid",
+        errors: [error],
+    });
+    /**
+     * Creates an invalid Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * Validation.invalidAll(["Invalid input"]);
+     * ```
+     */
+    Validation.invalidAll = (errors) => ({
+        kind: "Invalid",
+        errors,
+    });
+    /**
+     * Type guard that checks if a Validation is valid.
+     */
+    Validation.isValid = (data) => data.kind === "Valid";
+    /**
+     * Type guard that checks if a Validation is invalid.
+     */
+    Validation.isInvalid = (data) => data.kind === "Invalid";
+    /**
+     * Transforms the success value inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.valid(5), Validation.map(n => n * 2)); // Valid(10)
+     * pipe(Validation.invalid("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
+     * ```
+     */
+    Validation.map = (f) => (data) => Validation.isValid(data) ? Validation.valid(f(data.value)) : data;
+    /**
+     * Chains Validation computations. If the first is Valid, passes the value to f.
+     * If the first is Invalid, propagates the errors.
+     *
+     * Note: chain short-circuits on first error. Use `ap` to accumulate errors.
+     *
+     * @example
+     * ```ts
+     * const validatePositive = (n: number): Validation<string, number> =>
+     *   n > 0 ? Validation.valid(n) : Validation.invalid("Must be positive");
+     *
+     * pipe(Validation.valid(5), Validation.chain(validatePositive)); // Valid(5)
+     * pipe(Validation.valid(-1), Validation.chain(validatePositive)); // Invalid(["Must be positive"])
+     * ```
+     */
+    Validation.chain = (f) => (data) => Validation.isValid(data) ? f(data.value) : data;
+    /**
+     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+     * Accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.valid(5)),
+     *   Validation.ap(Validation.valid(3))
+     * ); // Valid(8)
+     *
+     * pipe(
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.invalid<string, number>("bad a")),
+     *   Validation.ap(Validation.invalid<string, number>("bad b"))
+     * ); // Invalid(["bad a", "bad b"])
+     * ```
+     */
+    Validation.ap = (arg) => (data) => {
+        if (Validation.isValid(data) && Validation.isValid(arg))
+            return Validation.valid(data.value(arg.value));
+        const errors = [
+            ...(Validation.isInvalid(data) ? data.errors : []),
+            ...(Validation.isInvalid(arg) ? arg.errors : []),
+        ];
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.invalidAll(errors) : Validation.valid(data);
+    };
+    /**
+     * Extracts the value from a Validation by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.valid(42),
+     *   Validation.fold(
+     *     errors => `Errors: ${errors.join(", ")}`,
+     *     value => `Value: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    Validation.fold = (onInvalid, onValid) => (data) => Validation.isValid(data) ? onValid(data.value) : onInvalid(data.errors);
+    /**
+     * Pattern matches on a Validation, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validation,
+     *   Validation.match({
+     *     valid: value => `Got ${value}`,
+     *     invalid: errors => `Failed: ${errors.join(", ")}`
+     *   })
+     * );
+     * ```
+     */
+    Validation.match = (cases) => (data) => Validation.isValid(data) ? cases.valid(data.value) : cases.invalid(data.errors);
+    /**
+     * Returns the success value or a default value if the Validation is invalid.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.valid(5), Validation.getOrElse(0)); // 5
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(0)); // 0
+     * ```
+     */
+    Validation.getOrElse = (defaultValue) => (data) => Validation.isValid(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.valid(5),
+     *   Validation.tap(n => console.log("Value:", n)),
+     *   Validation.map(n => n * 2)
+     * );
+     * ```
+     */
+    Validation.tap = (f) => (data) => {
+        if (Validation.isValid(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Recovers from an Invalid state by providing a fallback Validation.
+     */
+    Validation.recover = (fallback) => (data) => Validation.isValid(data) ? data : fallback();
+    /**
+     * Recovers from an Invalid state unless the errors contain any of the blocked errors.
+     */
+    Validation.recoverUnless = (blockedErrors, fallback) => (data) => Validation.isInvalid(data) &&
+        !data.errors.some((err) => blockedErrors.includes(err))
+        ? fallback()
+        : data;
+    /**
+     * Combines two Validation instances, accumulating errors from both.
+     * If both are Valid, returns the second valid value.
+     * If either is Invalid, combines their errors into a single Invalid.
+     *
+     * @example
+     * ```ts
+     * Validation.combine(
+     *   Validation.invalid("Error 1"),
+     *   Validation.invalid("Error 2")
+     * ); // Invalid(["Error 1", "Error 2"])
+     *
+     * Validation.combine(
+     *   Validation.valid("a"),
+     *   Validation.valid("b")
+     * ); // Valid("b")
+     * ```
+     */
+    Validation.combine = (first, second) => {
+        if (Validation.isValid(first) && Validation.isValid(second)) {
+            return second;
+        }
+        const errors = [
+            ...(Validation.isInvalid(first) ? first.errors : []),
+            ...(Validation.isInvalid(second) ? second.errors : []),
+        ];
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.invalidAll(errors) : second;
+    };
+    /**
+     * Combines multiple Validation instances, accumulating all errors.
+     * If all are Valid, returns the last valid value.
+     * Returns undefined for an empty array.
+     *
+     * @example
+     * ```ts
+     * Validation.combineAll([
+     *   validateName(name),
+     *   validateEmail(email),
+     *   validateAge(age)
+     * ]);
+     * ```
+     */
+    Validation.combineAll = (data) => data.length === 0 ? undefined : data.reduce((acc, v) => Validation.combine(acc, v));
+})(Validation || (exports.Validation = Validation = {}));