@shirudo/result 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -1,5 +1,5 @@
 
-//#region src/pipeable.ts
+//#region src/core/pipeable.ts
 var Pipeable = class {
 	pipe(...ops) {
 		let ret = this;
@@ -14,19 +14,13 @@ var Pipeable = class {
 };
 
 //#endregion
-//#region src/utils/isResult.ts
-function isResult(value) {
-	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "function" && "isErr" in value && typeof value.isErr === "function";
-}
-
-//#endregion
-//#region src/matcher.ts
+//#region src/core/matcher.ts
 /**
-* Matcher for Err values (returns any return type, e.g. string messages).
+* Matcher für Err-Values (liefert einen beliebigen Return-Type, z.B. string messages).
 *
 * - `.when(Ctor, handler)` matched via `instanceof`
-* - `.whenGuard(guard, handler)` matched via type guard
-* - `.run()` is only allowed once all error cases are handled (`E` is reduced to `never`)
+* - `.whenGuard(guard, handler)` matched via Type-Guard
+* - `.run()` ist nur erlaubt, wenn alle Error-Cases behandelt wurden (`E` wurde zu `never` reduziert)
 */
 var ErrorMatchBuilder = class ErrorMatchBuilder {
 	#error;
@@ -58,12 +52,15 @@ var ErrorMatchBuilder = class ErrorMatchBuilder {
 		throw this.#error;
 	}
 };
+function isResult$1(value) {
+	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "function" && "isErr" in value && typeof value.isErr === "function";
+}
 /**
-* Matcher for `Result` errors that always returns a `Result`.
+* Matcher für `Result`-Errors, der immer wieder ein `Result` zurückgibt.
 *
-* Handlers may:
-* - return a `Result` (returned directly)
-* - return an error value (automatically wrapped to `Err(error)`)
+* Handler dürfen:
+* - ein `Result` zurückgeben (wird direkt returned)
+* - einen Error-Wert zurückgeben (wird automatisch zu `Err(error)` gewrappt)
 */
 var ErrMatchBuilder = class ErrMatchBuilder {
 	#makeErr;
@@ -84,7 +81,7 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 		if (this.#resolved) return this;
 		if (this.#error instanceof ctor) {
 			const out = handler(this.#error);
-			const resolved = isResult(out) ? out : this.#makeErr(out);
+			const resolved = isResult$1(out) ? out : this.#makeErr(out);
 			return new ErrMatchBuilder(this.#makeErr, this.#error, resolved);
 		}
 		return this;
@@ -94,7 +91,7 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 		const error = this.#error;
 		if (guard(error)) {
 			const out = handler(error);
-			const resolved = isResult(out) ? out : this.#makeErr(out);
+			const resolved = isResult$1(out) ? out : this.#makeErr(out);
 			return new ErrMatchBuilder(this.#makeErr, this.#error, resolved);
 		}
 		return this;
@@ -102,688 +99,19 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 	otherwise(handler) {
 		if (this.#resolved) return this.#resolved;
 		const out = handler(this.#error);
-		return isResult(out) ? out : this.#makeErr(out);
+		return isResult$1(out) ? out : this.#makeErr(out);
 	}
 	run() {
 		if (this.#resolved) return this.#resolved;
 		throw this.#error;
 	}
 };
-/**
-* Universal matcher for `Result` (Ok + Err in a single chain).
-*
-* - `.err(Ctor, handler)` matched via `instanceof`
-* - `.errVal(value, handler)` matched via `Object.is`
-* - `.ok(handler)` defines the success branch
-* - `.run()` is only allowed after `.ok()` is set
-*
-* Lazy: if the Result is `Ok`, Err cases are not evaluated in `.run()`.
-*/
-var ResultMatchBuilder = class ResultMatchBuilder {
-	#result;
-	#errCases;
-	#okHandler;
-	constructor(result, errCases = [], okHandler) {
-		this.#result = result;
-		this.#errCases = Object.freeze([...errCases]);
-		this.#okHandler = okHandler;
-		Object.freeze(this);
-	}
-	static fromResult(result) {
-		return new ResultMatchBuilder(result);
-	}
-	err(ctor, handler) {
-		return new ResultMatchBuilder(this.#result, [...this.#errCases, {
-			kind: "ctor",
-			ctor,
-			handler
-		}], this.#okHandler);
-	}
-	errVal(value, handler) {
-		return new ResultMatchBuilder(this.#result, [...this.#errCases, {
-			kind: "val",
-			value,
-			handler
-		}], this.#okHandler);
-	}
-	ok(handler) {
-		return new ResultMatchBuilder(this.#result, this.#errCases, handler);
-	}
-	run() {
-		const result = this.#result;
-		if (result.isOk()) {
-			const okHandler = this.#okHandler;
-			if (!okHandler) throw new Error("ResultMatchBuilder.run() requires an ok() handler.");
-			return okHandler(result.value);
-		}
-		if (result.isErr()) {
-			const error = result.error;
-			for (const c of this.#errCases) {
-				if (c.kind === "ctor") {
-					if (error instanceof c.ctor) return c.handler(error);
-					continue;
-				}
-				if (Object.is(error, c.value)) return c.handler(error);
-			}
-			throw error;
-		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
-	}
-};
-
-//#endregion
-//#region src/conversions/fromNullable.ts
-/**
-* Converts `null | undefined` to `Err`, everything else to `Ok`.
-* 
-* **Type Safety**: The type assertion `as NonNullable<T>` is safe,
-* as the runtime check guarantees that the value is not null/undefined.
-* 
-* @param value The value to check
-* @param error The error to use if value is null/undefined
-* @returns An Ok Result with the NonNullable value, or an Err Result with the error
-* 
-* @example
-* ```ts
-* fromNullable(user, 'User not found')
-* // Ok(user) or Err('User not found')
-* ```
-*/
-function fromNullable(value, error) {
-	if (value === null || value === void 0) return Result.err(error);
-	return Result.ok(value);
-}
-
-//#endregion
-//#region src/conversions/fromPromise.ts
-async function fromPromise(promise, errorMapper) {
-	try {
-		const value = await promise;
-		return Result.ok(value);
-	} catch (error) {
-		try {
-			return Result.err(errorMapper ? errorMapper(error) : error);
-		} catch (mapperError) {
-			return Result.err(mapperError);
-		}
-	}
-}
-
-//#endregion
-//#region src/conversions/try.ts
-/**
-* Executes a function and catches exceptions.
-* 
-* @param fn The function to execute
-* @returns An Ok Result with the return value, or an Err Result with the caught exception
-* 
-* @example
-* ```ts
-* const result = tryFn(() => JSON.parse(input));
-* // Ok(parsed) or Err(SyntaxError)
-* ```
-*/
-function tryFn(fn) {
-	try {
-		return Result.ok(fn());
-	} catch (error) {
-		return Result.err(error);
-	}
-}
-
-//#endregion
-//#region src/conversions/toPromise.ts
-/**
-* Converts a Result to a Promise.
-* Ok → resolves with the value, Err → rejects with the error
-* 
-* @param result The Result to convert
-* @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
-* 
-* @example
-* ```ts
-* const result = ok(42);
-* const promise = toPromise(result);
-* const value = await promise; // 42
-* ```
-*/
-function toPromise(result) {
-	if (result.isOk()) return Promise.resolve(result.value);
-	return Promise.reject(result.error);
-}
-
-//#endregion
-//#region src/conversions/toNullable.ts
-/**
-* Converts a Result to `T | null`.
-* Ok → returns the value, Err → returns null
-* 
-* @param result The Result to convert
-* @returns The value if Ok, or null if Err
-* 
-* @example
-* ```ts
-* const result = ok(42);
-* const value = toNullable(result); // 42
-* 
-* const errResult = err('error');
-* const nullValue = toNullable(errResult); // null
-* ```
-*/
-function toNullable(result) {
-	if (result.isOk()) return result.value;
-	return null;
-}
-
-//#endregion
-//#region src/result.ts
-var Result = class Result extends Pipeable {
-	#state;
-	constructor(state) {
-		super();
-		Object.freeze(state);
-		this.#state = state;
-		Object.freeze(this);
-	}
-	/**
-	* Creates an Ok Result with the given value.
-	* 
-	* **Note**: `null` and `undefined` are allowed as values.
-	* If you want to convert `null`/`undefined` to an Err, use `fromNullable()`.
-	* 
-	* @param value The value for the Ok Result
-	* @returns An Ok Result with the given value
-	* 
-	* @example
-	* ```ts
-	* const result = Result.ok(42);
-	* const nullResult = Result.ok(null); // Allowed!
-	* ```
-	*/
-	static ok(value) {
-		return new Result({
-			_tag: "Ok",
-			value
-		});
-	}
-	/**
-	* Creates an Err Result with the given error.
-	* 
-	* **Note**: `null` and `undefined` are allowed as errors.
-	* 
-	* @param error The error for the Err Result
-	* @returns An Err Result with the given error
-	* 
-	* @example
-	* ```ts
-	* const result = Result.err('error message');
-	* const nullError = Result.err(null); // Allowed!
-	* ```
-	*/
-	static err(error) {
-		return new Result({
-			_tag: "Err",
-			error
-		});
-	}
-	/**
-	* Converts `null | undefined` to `Err`, everything else to `Ok`.
-	* 
-	* **Type Safety**: The type assertion `as NonNullable<T>` is safe,
-	* as the runtime check guarantees that the value is not null/undefined.
-	* 
-	* @param value The value to check
-	* @param error The error to use if value is null/undefined
-	* @returns An Ok Result with the NonNullable value, or an Err Result with the error
-	* 
-	* @example
-	* ```ts
-	* Result.fromNullable(user, 'User not found')
-	* // Ok(user) or Err('User not found')
-	* ```
-	*/
-	static fromNullable(value, error) {
-		return fromNullable(value, error);
-	}
-	static fromPromise(promise, errorMapper) {
-		return fromPromise(promise, errorMapper);
-	}
-	/**
-	* Executes a function and catches exceptions.
-	* 
-	* @example
-	* ```ts
-	* const result = Result.try(() => JSON.parse(input));
-	* // Ok(parsed) or Err(SyntaxError)
-	* ```
-	*/
-	static try(fn) {
-		return tryFn(fn);
-	}
-	/**
-	* Checks if the Result is Ok.
-	* 
-	* @returns `true` if the Result is Ok (and narrows the type)
-	* 
-	* @example
-	* ```ts
-	* if (result.isOk()) {
-	*   const value: T = result.value; // TypeScript knows that value is defined
-	* }
-	* ```
-	*/
-	isOk() {
-		return this.#state._tag === "Ok";
-	}
-	/**
-	* Checks if the Result is Err.
-	* 
-	* @returns `true` if the Result is Err (and narrows the type)
-	* 
-	* @example
-	* ```ts
-	* if (result.isErr()) {
-	*   const error: E = result.error; // TypeScript knows that error is defined
-	* }
-	* ```
-	*/
-	isErr() {
-		return this.#state._tag === "Err";
-	}
-	get value() {
-		return this.#state._tag === "Ok" ? this.#state.value : void 0;
-	}
-	get error() {
-		return this.#state._tag === "Err" ? this.#state.error : void 0;
-	}
-	/**
-	* Returns the value, guaranteed to be defined after `isOk()` check.
-	* This method provides better type narrowing than the `value` getter.
-	* 
-	* ⚠️ **Warning**: This method throws an Error if called on an Err result.
-	* Use this method only after a type guard (`if (result.isOk())`).
-	* For a safer alternative with a custom message, use `expect()`.
-	* 
-	* @throws {Error} If called on an Err result
-	* 
-	* @example
-	* ```ts
-	* if (result.isOk()) {
-	*   const value = result.unwrap(); // Type is T, not T | undefined
-	* }
-	* ```
-	*/
-	unwrap() {
-		if (this.#state._tag === "Ok") return this.#state.value;
-		const errorStr = (() => {
-			try {
-				const error = this.#state.error;
-				if (error === null) return "null";
-				if (error === void 0) return "undefined";
-				if (typeof error === "string") return error;
-				if (error instanceof Error) return error.message;
-				if (typeof error === "object" && "toString" in error) try {
-					return String(error);
-				} catch {
-					return "[unstringifiable error]";
-				}
-				return String(error);
-			} catch {
-				return "[unstringifiable error]";
-			}
-		})();
-		throw new Error(`Called unwrap() on Err: ${errorStr}`);
-	}
-	/**
-	* Returns the error, guaranteed to be defined after `isErr()` check.
-	* This method provides better type narrowing than the `error` getter.
-	* 
-	* ⚠️ **Warning**: This method throws an Error if called on an Ok result.
-	* Use this method only after a type guard (`if (result.isErr())`).
-	* For a safer alternative with a custom message, use `expectErr()`.
-	* 
-	* @throws {Error} If called on an Ok result
-	* 
-	* @example
-	* ```ts
-	* if (result.isErr()) {
-	*   const error = result.unwrapErr(); // Type is E, not E | undefined
-	* }
-	* ```
-	*/
-	unwrapErr() {
-		if (this.#state._tag === "Err") return this.#state.error;
-		const valueStr = (() => {
-			try {
-				const value = this.#state.value;
-				if (value === null) return "null";
-				if (value === void 0) return "undefined";
-				if (typeof value === "string") return value;
-				if (value instanceof Error) return value.message;
-				if (typeof value === "object" && "toString" in value) try {
-					return String(value);
-				} catch {
-					return "[unstringifiable value]";
-				}
-				return String(value);
-			} catch {
-				return "[unstringifiable value]";
-			}
-		})();
-		throw new Error(`Called unwrapErr() on Ok: ${valueStr}`);
-	}
-	/**
-	* Returns the value with a custom error message if the result is Err.
-	* Similar to `unwrap()`, but allows you to provide a custom error message.
-	* 
-	* ⚠️ **Warning**: This method throws an Error if called on an Err result.
-	* Use this method only if you are sure the Result is Ok,
-	* or if you need a meaningful error message.
-	* 
-	* @param message Custom error message to throw if result is Err
-	* @returns The value if result is Ok
-	* @throws {Error} If called on an Err result with the provided message
-	* 
-	* @example
-	* ```ts
-	* const result = fetchUser(id);
-	* const user = result.expect('User should exist'); // Throws with custom message if Err
-	* ```
-	*/
-	expect(message) {
-		if (this.#state._tag === "Ok") return this.#state.value;
-		throw new Error(message);
-	}
-	/**
-	* Returns the error with a custom error message if the result is Ok.
-	* Similar to `unwrapErr()`, but allows you to provide a custom error message.
-	* 
-	* ⚠️ **Warning**: This method throws an Error if called on an Ok result.
-	* Use this method only if you are sure the Result is Err,
-	* or if you need a meaningful error message.
-	* 
-	* @param message Custom error message to throw if result is Ok
-	* @returns The error if result is Err
-	* @throws {Error} If called on an Ok result with the provided message
-	* 
-	* @example
-	* ```ts
-	* const result = validateInput(input);
-	* if (result.isErr()) {
-	*   const error = result.expectErr('Validation should have failed'); // Throws if Ok
-	* }
-	* ```
-	*/
-	expectErr(message) {
-		if (this.#state._tag === "Err") return this.#state.error;
-		throw new Error(message);
-	}
-	unwrapOr(defaultValue) {
-		return this.#state._tag === "Ok" ? this.#state.value : defaultValue;
-	}
-	/**
-	* Converts the Result to a Promise.
-	* Ok → resolves with the value, Err → rejects with the error
-	* 
-	* This instance method delegates to the standalone `toPromise()` function.
-	* 
-	* @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
-	* 
-	* @example
-	* ```ts
-	* const result = ok(42);
-	* const promise = result.toPromise();
-	* const value = await promise; // 42
-	* 
-	* const errResult = err('error');
-	* try {
-	*   await errResult.toPromise();
-	* } catch (error) {
-	*   console.log(error); // 'error'
-	* }
-	* ```
-	*/
-	toPromise() {
-		return toPromise(this);
-	}
-	/**
-	* Converts the Result to `T | null`.
-	* Ok → returns the value, Err → returns null
-	* 
-	* This instance method delegates to the standalone `toNullable()` function.
-	* 
-	* @returns The value if Ok, or null if Err
-	* 
-	* @example
-	* ```ts
-	* const result = ok(42);
-	* const value = result.toNullable(); // 42
-	* 
-	* const errResult = err('error');
-	* const nullValue = errResult.toNullable(); // null
-	* ```
-	*/
-	toNullable() {
-		return toNullable(this);
-	}
-	/**
-	* Enables `yield* result` in generators (Do-notation).
-	*
-	* The iterator yields the `Result` itself; the runner (see `task`) decides:
-	* - Ok  → sends back the Ok value (`next(value)`), `yield*` yields `T`
-	* - Err → aborts and returns the Err Result
-	*/
-	*[Symbol.iterator]() {
-		return yield this;
-	}
-	/**
-	* Universal pattern matcher for Ok + Err cases.
-	* 
-	* Use this to exhaustively match on both success and error cases with type-based
-	* and value-based pattern matching.
-	* 
-	* @example
-	* ```ts
-	* const message = result
-	*   .match()
-	*   .err(NetworkError, e => `Network: ${e.message}`)
-	*   .err(ValidationError, e => `Validation: ${e.message}`)
-	*   .ok(val => `Success: ${val}`)
-	*   .run();
-	* ```
-	*/
-	match() {
-		return ResultMatchBuilder.fromResult(this);
-	}
-	matchErr() {
-		if (this.isErr()) return new ErrorMatchBuilder(this.error);
-		throw new Error("matchErr() can only be called on Err results. Use `if (result.isErr()) { ... }` first.");
-	}
-	/**
-	* Matches on the Err value, but normalizes every branch to a `Result`:
-	* - Handlers may return a `Result` (returned directly)
-	* - or an error value (wrapped to `Err(error)`)
-	*/
-	matchErrResult() {
-		const makeErr = (error) => Result.err(error);
-		return ErrMatchBuilder.fromResult(this, makeErr);
-	}
-	/**
-	* @deprecated Use `.match()` instead. Will be removed in next major version.
-	*/
-	pattern() {
-		return this.match();
-	}
-	/**
-	* @deprecated Use `.match()` instead. Will be removed in next major version.
-	*/
-	switch() {
-		return this.match();
-	}
-	/**
-	* Folds the Result into a single value by applying one of two functions.
-	* 
-	* This is a direct method equivalent to the `match` pipe operator.
-	* Use this when you want to handle both Ok and Err cases and return a single value.
-	* 
-	* @param onOk Function to apply if the Result is Ok
-	* @param onErr Function to apply if the Result is Err
-	* @returns The result of applying the appropriate function
-	* 
-	* @example
-	* ```ts
-	* const result = ok(42);
-	* const message = result.fold(
-	*     val => `Success: ${val}`,
-	*     err => `Error: ${err}`
-	* );
-	* // message = "Success: 42"
-	* ```
-	* 
-	* @example
-	* ```ts
-	* // Works with discriminated unions
-	* const result: Result<string, number> = err(404);
-	* const response = result.fold(
-	*     data => ({ success: true as const, data }),
-	*     code => ({ success: false as const, code })
-	* );
-	* // response: { success: true; data: string } | { success: false; code: number }
-	* ```
-	*/
-	fold(onOk, onErr) {
-		if (this.isOk()) return onOk(this.value);
-		if (this.isErr()) return onErr(this.error);
-		throw new Error("Unreachable: Result is neither Ok nor Err");
-	}
-	/**
-	* Returns the Result as a discriminated union (`{ _tag: 'Ok', value } | { _tag: 'Err', error }`).
-	* Useful for libraries like `ts-pattern` that match on plain object unions.
-	*/
-	toUnion() {
-		return this.#state;
-	}
-	/**
-	* Serializes the Result into a simple object format.
-	* Preserves the original types.
-	*/
-	serialize() {
-		if (this.#state._tag === "Ok") return {
-			isSuccess: true,
-			data: this.#state.value
-		};
-		return {
-			isSuccess: false,
-			error: this.#state.error
-		};
-	}
-	/**
-	* Serializes the Result into a user-friendly format.
-	* Converts errors to readable strings.
-	*/
-	toUserFriendly() {
-		if (this.#state._tag === "Ok") return {
-			isSuccess: true,
-			data: this.#state.value
-		};
-		const error = this.#state.error;
-		const toSafeString = (value) => {
-			try {
-				return String(value);
-			} catch {
-				return "[Unstringifiable error]";
-			}
-		};
-		return {
-			isSuccess: false,
-			error: (() => {
-				if (error && typeof error === "object" && "message" in error) {
-					const message = error.message;
-					return typeof message === "string" ? message : toSafeString(error);
-				}
-				return toSafeString(error);
-			})()
-		};
-	}
-};
-const ok = Result.ok;
-const err = Result.err;
-/**
-* Helper for conditional Result creation.
-* Avoids type inference issues with ternary operators.
-* 
-* @example
-* ```ts
-* const result = okIf(value > 5, value, 'too small');
-* // instead of: value > 5 ? ok(value) : err('too small')
-* ```
-*/
-function okIf(condition, okValue, errValue) {
-	return condition ? ok(okValue) : err(errValue);
-}
-/**
-* Helper for conditional Result creation with lazy evaluation.
-* Evaluates values only when they are needed.
-* 
-* @example
-* ```ts
-* const result = okIfLazy(
-*     value > 5,
-*     () => expensiveComputation(value),
-*     () => 'too small'
-* );
-* ```
-*/
-function okIfLazy(condition, okFn, errFn) {
-	return condition ? ok(okFn()) : err(errFn());
-}
-
-//#endregion
-//#region src/gen.ts
-async function task(makeGenerator, onThrow) {
-	const iterator = makeGenerator();
-	let input = void 0;
-	while (true) {
-		let step;
-		try {
-			step = await iterator.next(input);
-		} catch (caught) {
-			if (!onThrow) throw caught;
-			return err(onThrow(caught));
-		}
-		if (step.done) try {
-			const awaited = await step.value;
-			if (isResult(awaited)) return awaited;
-			return ok(awaited);
-		} catch (caught) {
-			if (!onThrow) throw caught;
-			return err(onThrow(caught));
-		}
-		const yielded = step.value;
-		if (!isResult(yielded)) throw new TypeError("task() expected yielded values to be Result. Use `yield*` on a Result.");
-		if (yielded.isOk()) {
-			input = yielded.value;
-			continue;
-		}
-		if (yielded.isErr()) {
-			try {
-				if (typeof iterator.return === "function") await iterator.return(void 0);
-			} catch (caught) {
-				if (!onThrow) throw caught;
-				return err(onThrow(caught));
-			}
-			return yielded;
-		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
-	}
-}
-const gen = task;
 
 //#endregion
-//#region src/operators/map.ts
+//#region src/core/map.ts
 /**
-* Transforms the value (Ok case).
-* Equivalent to Rust `map`.
+* Transformiert den Wert (Ok-Fall).
+* Entspricht Rust `map`.
 */
 function map(project) {
 	return (source) => {
@@ -793,10 +121,10 @@ function map(project) {
 }
 
 //#endregion
-//#region src/operators/mapErr.ts
+//#region src/core/mapErr.ts
 /**
-* Transforms the error (Err case).
-* Equivalent to Rust `map_err`.
+* Transformiert den Fehler (Err-Fall).
+* Entspricht Rust `map_err`.
 */
 function mapErr(project) {
 	return (source) => {
@@ -806,10 +134,10 @@ function mapErr(project) {
 }
 
 //#endregion
-//#region src/operators/mapBoth.ts
+//#region src/core/mapBoth.ts
 /**
-* Transforms both the Ok value and the Err error.
-* Equivalent to FP `bimap` / `mapBoth`.
+* Transformiert sowohl den Ok-Wert als auch den Err-Fehler.
+* Entspricht FP `bimap` / `mapBoth`.
 */
 function mapBoth(mapOk, mapErr$1) {
 	return (source) => {
@@ -819,15 +147,15 @@ function mapBoth(mapOk, mapErr$1) {
 	};
 }
 /**
-* Alias for `mapBoth`.
+* Alias für `mapBoth`.
 */
 const bimap = mapBoth;
 
 //#endregion
-//#region src/operators/flatMap.ts
+//#region src/core/flatMap.ts
 /**
-* Chains another operation that returns a Result.
-* Equivalent to Rust `and_then` or JS `flatMap`.
+* Verkettet eine weitere Operation, die ein Result zurückgibt.
+* Entspricht Rust `and_then` oder JS `flatMap`.
 */
 function flatMap(project) {
 	return (source) => {
@@ -837,10 +165,42 @@ function flatMap(project) {
 }
 
 //#endregion
-//#region src/operators/tap.ts
+//#region src/core/zip.ts
+function zipImpl(left, right) {
+	if (left.isErr()) return left;
+	if (right.isErr()) return right;
+	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
+	throw new Error("Unreachable: Result is neither Ok nor Err");
+}
+function zip(...args) {
+	if (args.length === 1) {
+		const right$1 = args[0];
+		return (left$1) => zipImpl(left$1, right$1);
+	}
+	const [left, right] = args;
+	return zipImpl(left, right);
+}
+function combineImpl(left, right) {
+	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
+	const errors = [];
+	if (left.isErr()) errors.push(left.error);
+	if (right.isErr()) errors.push(right.error);
+	return err(errors);
+}
+function combine(...args) {
+	if (args.length === 1) {
+		const right$1 = args[0];
+		return (left$1) => combineImpl(left$1, right$1);
+	}
+	const [left, right] = args;
+	return combineImpl(left, right);
+}
+
+//#endregion
+//#region src/core/tap.ts
 /**
-* Executes a side effect (logging, debugging) without changing the Result.
-* Equivalent to Rust `inspect` / `inspect_err`.
+* Führt einen Seiteneffekt aus (Logging, Debugging), ohne das Result zu ändern.
+* Entspricht Rust `inspect` / `inspect_err`.
 */
 function tap(observer) {
 	return (source) => {
@@ -851,10 +211,10 @@ function tap(observer) {
 }
 
 //#endregion
-//#region src/operators/filter.ts
+//#region src/core/filter.ts
 /**
-* Checks a predicate. If false, the Result becomes Err.
-* Partially equivalent to Rust `filter`.
+* Prüft eine Bedingung. Wenn falsch, wird das Result zu Err.
+* Entspricht Rust `filter` (teilweise).
 */
 function filter(predicate, errorFn) {
 	return (source) => {
@@ -867,31 +227,61 @@ function filter(predicate, errorFn) {
 }
 
 //#endregion
-//#region src/operators/fold.ts
+//#region src/core/match.ts
 /**
-* Folds the Result into a single value by applying one of two functions.
-* The end of the pipe.
-* 
-* This is the pipe operator equivalent of the `.fold()` instance method.
+* Löst das Result auf. Das Ende der Pipe.
+* Entspricht Rust `match`.
 */
-function fold(handlers) {
+function match(handlers) {
 	return (source) => {
 		if (source.isOk()) return handlers.ok(source.value);
 		if (source.isErr()) return handlers.err(source.error);
 		throw new Error("Unreachable: Result is neither Ok nor Err");
 	};
 }
+
+//#endregion
+//#region src/core/recover.ts
+/**
+* Recover: wandelt Err in Ok(defaultValue) um.
+* Ergebnis ist garantiert Ok → Error-Typ wird `never`.
+*/
+function recover(defaultValue) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(defaultValue);
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
 /**
-* @deprecated Use `fold` instead. Will be removed in next major version.
+* Wie `recover`, aber berechnet den Default-Wert anhand des Errors.
 */
-const match = fold;
+function recoverWith(fn) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(fn(source.error));
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
 
 //#endregion
-//#region src/operators/tryCatch.ts
+//#region src/core/swap.ts
 /**
-* Executes a function and catches exceptions.
-* Converts exceptions into Result<E>.
-* Equivalent to Rust `Result::from` for fallible operations.
+* Tauscht Ok und Err.
+* Result<T, E> → Result<E, T>
+*/
+function swap(result) {
+	if (result.isOk()) return err(result.value);
+	if (result.isErr()) return ok(result.error);
+	throw new Error("Unreachable: Result is neither Ok nor Err");
+}
+
+//#endregion
+//#region src/core/tryCatch.ts
+/**
+* Führt eine Funktion aus und fängt Exceptions ab.
+* Wandelt Exceptions in Result<E> um.
+* Entspricht Rust `Result::from` für fallible Operationen.
 */
 function tryCatch(fn, errorMapper) {
 	return (source) => {
@@ -905,9 +295,9 @@ function tryCatch(fn, errorMapper) {
 }
 
 //#endregion
-//#region src/operators/tryMap.ts
+//#region src/core/tryMap.ts
 /**
-* Like `map`, but catches exceptions and turns them into Err.
+* Wie `map`, aber fängt Exceptions ab und wandelt sie in Err um.
 */
 function tryMap(project, errorMapper) {
 	return (source) => {
@@ -922,33 +312,29 @@ function tryMap(project, errorMapper) {
 }
 
 //#endregion
-//#region src/operators/recover.ts
-/**
-* Recover: turns Err into Ok(defaultValue).
-* Result is guaranteed Ok → error type becomes `never`.
-*/
-function recover(defaultValue) {
-	return (source) => {
-		if (source.isOk()) return source;
-		if (source.isErr()) return ok(defaultValue);
-		throw new Error("Unreachable: Result is neither Ok nor Err");
-	};
-}
+//#region src/core/collectFirstOk.ts
 /**
-* Like `recover`, but computes the default value from the error.
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
 */
-function recoverWith(fn) {
-	return (source) => {
-		if (source.isOk()) return source;
-		if (source.isErr()) return ok(fn(source.error));
+function collectFirstOk(results) {
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) return ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
 		throw new Error("Unreachable: Result is neither Ok nor Err");
-	};
+	}
+	return err(errors);
 }
 
 //#endregion
-//#region src/operators-async/mapAsync.ts
+//#region src/core/mapAsync.ts
 /**
-* Async version of map.
+* Async-Version von map.
 */
 function mapAsync(project) {
 	return async (source) => {
@@ -958,9 +344,9 @@ function mapAsync(project) {
 }
 
 //#endregion
-//#region src/operators-async/mapErrAsync.ts
+//#region src/core/mapErrAsync.ts
 /**
-* Async version of mapErr.
+* Async-Version von mapErr.
 */
 function mapErrAsync(project) {
 	return async (source) => {
@@ -970,10 +356,9 @@ function mapErrAsync(project) {
 }
 
 //#endregion
-//#region src/operators-async/flatMapAsync.ts
+//#region src/core/flatMapAsync.ts
 /**
-* Async version of flatMap.
-* Allows different error types in the projected Result.
+* Async-Version von flatMap.
 */
 function flatMapAsync(project) {
 	return async (source) => {
@@ -983,9 +368,9 @@ function flatMapAsync(project) {
 }
 
 //#endregion
-//#region src/operators-async/tapAsync.ts
+//#region src/core/tapAsync.ts
 /**
-* Async version of tap.
+* Async-Version von tap.
 */
 function tapAsync(observer) {
 	return async (source) => {
@@ -996,9 +381,9 @@ function tapAsync(observer) {
 }
 
 //#endregion
-//#region src/operators-async/filterAsync.ts
+//#region src/core/filterAsync.ts
 /**
-* Async version of filter.
+* Async-Version von filter.
 */
 function filterAsync(predicate, errorFn) {
 	return async (source) => {
@@ -1011,29 +396,22 @@ function filterAsync(predicate, errorFn) {
 }
 
 //#endregion
-//#region src/operators-async/foldAsync.ts
+//#region src/core/matchAsync.ts
 /**
-* Async version of `fold`. Folds the Result into a single value asynchronously.
-* The end of the pipe.
-* 
-* This is the async pipe operator equivalent of the `.fold()` instance method.
+* Async-Version von match.
 */
-function foldAsync(handlers) {
+function matchAsync(handlers) {
 	return async (source) => {
 		if (source.isOk()) return await handlers.ok(source.value);
 		if (source.isErr()) return await handlers.err(source.error);
 		throw new Error("Unreachable: Result is neither Ok nor Err");
 	};
 }
-/**
-* @deprecated Use `foldAsync` instead. Will be removed in next major version.
-*/
-const matchAsync = foldAsync;
 
 //#endregion
-//#region src/operators-async/tryCatchAsync.ts
+//#region src/core/tryCatchAsync.ts
 /**
-* Async version of tryCatch.
+* Async-Version von tryCatch.
 */
 function tryCatchAsync(fn, errorMapper) {
 	return async (source) => {
@@ -1047,9 +425,9 @@ function tryCatchAsync(fn, errorMapper) {
 }
 
 //#endregion
-//#region src/operators-async/tryMapAsync.ts
+//#region src/core/tryMapAsync.ts
 /**
-* Async version of tryMap.
+* Async-Version von tryMap.
 */
 function tryMapAsync(project, errorMapper) {
 	return async (source) => {
@@ -1064,10 +442,234 @@ function tryMapAsync(project, errorMapper) {
 }
 
 //#endregion
-//#region src/unwrap/unwrap.ts
+//#region src/core/result.ts
+var ResultBase = class extends Pipeable {
+	isOk() {
+		return this._tag === "Ok";
+	}
+	isErr() {
+		return this._tag === "Err";
+	}
+	unwrapOr(defaultValue) {
+		return this._tag === "Ok" ? this.value : defaultValue;
+	}
+	/**
+	* Folds the Result into a single value by applying one of two functions.
+	*/
+	fold(onOk, onErr) {
+		if (this._tag === "Ok") return onOk(this.value);
+		if (this._tag === "Err") return onErr(this.error);
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+	/**
+	* Enables `yield* result` in generators (Do-notation).
+	*
+	* The iterator yields the `Result` itself; the runner (see `task`) decides:
+	* - Ok  → sends back the Ok value (`next(value)`), `yield*` yields `T`
+	* - Err → aborts and returns the Err Result
+	*/
+	*[Symbol.iterator]() {
+		return yield this;
+	}
+	/**
+	* Matcht auf den Err-Wert via `.when(...)` Kette.
+	*
+	* Hinweis: aus Type-Safety-Gründen ist `.match()` nur auf einem bereits zu `Err` verengten Result aufrufbar,
+	* z.B. innerhalb von `if (result.isErr()) { ... }`.
+	*/
+	match() {
+		if (this._tag === "Err") return new ErrorMatchBuilder(this.error);
+		throw new Error("match() can only be called on Err results. Use `if (result.isErr()) { ... }` first.");
+	}
+	/**
+	* Matcht auf den Err-Wert, aber normalisiert jeden Branch zu einem `Result`:
+	* - Handler dürfen ein `Result` zurückgeben (wird direkt returned)
+	* - oder einen Error-Wert (wird zu `Err(error)` gewrappt)
+	*/
+	matchErr() {
+		const makeErr = (error) => err(error);
+		return ErrMatchBuilder.fromResult(this, makeErr);
+	}
+	/**
+	* Serialisiert das Result in ein einfaches Objekt-Format.
+	* Behält die ursprünglichen Typen bei.
+	*/
+	serialize() {
+		if (this._tag === "Ok") return {
+			isSuccess: true,
+			data: this.value
+		};
+		return {
+			isSuccess: false,
+			error: this.error
+		};
+	}
+	/**
+	* Serialisiert das Result in ein user-friendly Format.
+	* Konvertiert Errors zu lesbaren Strings.
+	*/
+	toUserFriendly() {
+		if (this._tag === "Ok") return {
+			isSuccess: true,
+			data: this.value
+		};
+		const error = this.error;
+		return {
+			isSuccess: false,
+			error: error && typeof error === "object" && "message" in error ? error.message : String(error)
+		};
+	}
+};
+var Ok = class extends ResultBase {
+	_tag = "Ok";
+	value;
+	error = void 0;
+	constructor(value) {
+		super();
+		this.value = value;
+		Object.freeze(this);
+	}
+};
+var Err = class extends ResultBase {
+	_tag = "Err";
+	value = void 0;
+	error;
+	constructor(error) {
+		super();
+		this.error = error;
+		Object.freeze(this);
+	}
+};
+function ok(value) {
+	return new Ok(value);
+}
+function err(error) {
+	return new Err(error);
+}
+function okIf(condition, okValue, errValue) {
+	return condition ? ok(okValue) : err(errValue);
+}
+function okIfLazy(condition, okFn, errFn) {
+	return condition ? ok(okFn()) : err(errFn());
+}
+function fromNullable(value, error) {
+	if (value === null || value === void 0) return err(error);
+	return ok(value);
+}
+async function fromPromise(promise, errorMapper) {
+	try {
+		return ok(await promise);
+	} catch (error) {
+		try {
+			return err(errorMapper ? errorMapper(error) : error);
+		} catch (mapperError) {
+			return err(mapperError);
+		}
+	}
+}
+function tryFn(fn) {
+	try {
+		return ok(fn());
+	} catch (error) {
+		return err(error);
+	}
+}
+const Result = {
+	ok,
+	err,
+	fromNullable,
+	fromPromise,
+	try: tryFn
+};
+
+//#endregion
+//#region src/core/isResult.ts
+/**
+* Checks whether a value is a Result.
+* Pure function alternative for runtime checks.
+*/
+function isResult(value) {
+	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "function" && "isErr" in value && typeof value.isErr === "function";
+}
+
+//#endregion
+//#region src/gen.ts
+async function task(makeGenerator, onThrow) {
+	const iterator = makeGenerator();
+	let input = void 0;
+	while (true) {
+		let step;
+		try {
+			step = await iterator.next(input);
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			return err(onThrow(caught));
+		}
+		if (step.done) try {
+			const awaited = await step.value;
+			if (isResult(awaited)) return awaited;
+			return ok(awaited);
+		} catch (caught) {
+			if (!onThrow) throw caught;
+			return err(onThrow(caught));
+		}
+		const yielded = step.value;
+		if (!isResult(yielded)) throw new TypeError("task() expected yielded values to be Result. Use `yield*` on a Result.");
+		if (yielded.isOk()) {
+			input = yielded.value;
+			continue;
+		}
+		if (yielded.isErr()) {
+			try {
+				if (typeof iterator.return === "function") await iterator.return(void 0);
+			} catch (caught) {
+				if (!onThrow) throw caught;
+				return err(onThrow(caught));
+			}
+			return yielded;
+		}
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	}
+}
+const gen = task;
+
+//#endregion
+//#region src/core/fold.ts
+/**
+* Folds the Result into a single value by applying one of two functions.
+* The end of the pipe.
+*
+* This is the pipe operator equivalent of the `.fold()` instance method.
+*/
+function fold(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
+
+//#endregion
+//#region src/core/foldAsync.ts
+/**
+* Async version of `fold`. Folds the Result into a single value asynchronously.
+* The end of the pipe.
+*
+* This is the async pipe operator equivalent of the `.fold()` instance method.
+*/
+function foldAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new Error("Unreachable: Result is neither Ok nor Err");
+	};
+}
+
+//#endregion
+//#region src/core/unwrap.ts
 /**
-* Returns the value or throws an Error.
-* Equivalent to Rust `unwrap`.
+* Gibt den Wert zurück oder wirft einen Error.
+* Entspricht Rust `unwrap`.
 */
 function unwrap(result) {
 	if (result.isOk()) return result.value;
@@ -1076,10 +678,10 @@ function unwrap(result) {
 }
 
 //#endregion
-//#region src/unwrap/unwrapOr.ts
+//#region src/core/unwrapOr.ts
 /**
-* Returns the value or a default value.
-* Pure function alternative to the instance method.
+* Gibt den Wert zurück oder einen Default-Wert.
+* Pure function Alternative zur Instanz-Methode.
 */
 function unwrapOr(result, defaultValue) {
 	if (result.isOk()) return result.value;
@@ -1087,10 +689,10 @@ function unwrapOr(result, defaultValue) {
 }
 
 //#endregion
-//#region src/unwrap/unwrapOrElse.ts
+//#region src/core/unwrapOrElse.ts
 /**
-* Returns the value or computes a default value with a function.
-* Equivalent to Rust `unwrap_or_else`.
+* Gibt den Wert zurück oder berechnet einen Default-Wert mit einer Funktion.
+* Entspricht Rust `unwrap_or_else`.
 */
 function unwrapOrElse(result, fn) {
 	if (result.isOk()) return result.value;
@@ -1099,20 +701,20 @@ function unwrapOrElse(result, fn) {
 }
 
 //#endregion
-//#region src/unwrap/unwrapOrDefault.ts
+//#region src/core/unwrapOrDefault.ts
 /**
-* Alias for `unwrapOr`.
-* Equivalent to Rust `unwrap_or_default` (with an explicit default value).
+* Alias für `unwrapOr`.
+* Entspricht Rust `unwrap_or_default` (mit explizitem Default-Wert).
 */
 function unwrapOrDefault(result, defaultValue) {
 	return unwrapOr(result, defaultValue);
 }
 
 //#endregion
-//#region src/unwrap/unwrapOrThrow.ts
+//#region src/core/unwrapOrThrow.ts
 /**
-* Returns the value or throws the original Err value (not wrapped).
-* Useful to keep `Error` instances with stack traces.
+* Gibt den Wert zurück oder wirft den originalen Err-Wert (nicht gewrappt).
+* Nützlich um `Error`-Instanzen inkl. Stacktrace zu erhalten.
 */
 function unwrapOrThrow(result) {
 	if (result.isOk()) return result.value;
@@ -1121,10 +723,10 @@ function unwrapOrThrow(result) {
 }
 
 //#endregion
-//#region src/unwrap/unwrapErr.ts
+//#region src/core/unwrapErr.ts
 /**
-* Returns the error or throws an Error.
-* Equivalent to Rust `unwrap_err`.
+* Gibt den Fehler zurück oder wirft einen Error.
+* Entspricht Rust `unwrap_err`.
 */
 function unwrapErr(result) {
 	if (result.isErr()) return result.error;
@@ -1133,10 +735,10 @@ function unwrapErr(result) {
 }
 
 //#endregion
-//#region src/unwrap/expectResult.ts
+//#region src/core/expectResult.ts
 /**
-* Returns the value or throws an Error with a custom message.
-* Equivalent to Rust `expect`.
+* Gibt den Wert zurück oder wirft einen Error mit custom Nachricht.
+* Entspricht Rust `expect`.
 */
 function expectResult(result, message) {
 	if (result.isOk()) return result.value;
@@ -1144,10 +746,10 @@ function expectResult(result, message) {
 }
 
 //#endregion
-//#region src/unwrap/expectErr.ts
+//#region src/core/expectErr.ts
 /**
-* Returns the error or throws an Error with a custom message.
-* Equivalent to Rust `expect_err`.
+* Gibt den Fehler zurück oder wirft einen Error mit custom Nachricht.
+* Entspricht Rust `expect_err`.
 */
 function expectErr(result, message) {
 	if (result.isErr()) return result.error;
@@ -1155,30 +757,30 @@ function expectErr(result, message) {
 }
 
 //#endregion
-//#region src/combinators/and.ts
+//#region src/core/and.ts
 /**
-* Combines two Results. Returns the second only if the first is Ok.
-* Equivalent to Rust `and`.
+* Kombiniert zwei Results. Gibt den zweiten zurück nur wenn erster Ok ist.
+* Entspricht Rust `and`.
 */
 function and(result, other) {
 	return result.isOk() ? other : result;
 }
 
 //#endregion
-//#region src/combinators/or.ts
+//#region src/core/or.ts
 /**
-* Fallback to another Result when the first is Err.
-* Equivalent to Rust `or`.
+* Fallback zu einem anderen Result wenn erster Err ist.
+* Entspricht Rust `or`.
 */
 function or(result, other) {
 	return result.isOk() ? result : other;
 }
 
 //#endregion
-//#region src/combinators/orElse.ts
+//#region src/core/orElse.ts
 /**
-* Fallback using a function that returns a Result.
-* Equivalent to Rust `or_else`.
+* Fallback mit einer Funktion die ein Result zurückgibt.
+* Entspricht Rust `or_else`.
 */
 function orElse(result, fn) {
 	if (result.isOk()) return result;
@@ -1187,10 +789,10 @@ function orElse(result, fn) {
 }
 
 //#endregion
-//#region src/combinators/mapOr.ts
+//#region src/core/mapOr.ts
 /**
-* Transforms the value or returns a default value.
-* Equivalent to Rust `map_or`.
+* Transformiert den Wert oder gibt einen Default-Wert zurück.
+* Entspricht Rust `map_or`.
 */
 function mapOr(result, defaultValue, fn) {
 	if (result.isOk()) return fn(result.value);
@@ -1198,10 +800,10 @@ function mapOr(result, defaultValue, fn) {
 }
 
 //#endregion
-//#region src/combinators/mapOrElse.ts
+//#region src/core/mapOrElse.ts
 /**
-* Transforms the value or computes a default value with a function.
-* Equivalent to Rust `map_or_else`.
+* Transformiert den Wert oder berechnet einen Default-Wert mit einer Funktion.
+* Entspricht Rust `map_or_else`.
 */
 function mapOrElse(result, defaultFn, fn) {
 	if (result.isOk()) return fn(result.value);
@@ -1210,55 +812,11 @@ function mapOrElse(result, defaultFn, fn) {
 }
 
 //#endregion
-//#region src/combinators/zip.ts
-function zipImpl(left, right) {
-	if (left.isErr()) return left;
-	if (right.isErr()) return right;
-	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
-}
-function zip(...args) {
-	if (args.length === 1) {
-		const right$1 = args[0];
-		return (left$1) => zipImpl(left$1, right$1);
-	}
-	const [left, right] = args;
-	return zipImpl(left, right);
-}
-function combineImpl(left, right) {
-	if (left.isOk() && right.isOk()) return ok([left.value, right.value]);
-	const errors = [];
-	if (left.isErr()) errors.push(left.error);
-	if (right.isErr()) errors.push(right.error);
-	return err(errors);
-}
-function combine(...args) {
-	if (args.length === 1) {
-		const right$1 = args[0];
-		return (left$1) => combineImpl(left$1, right$1);
-	}
-	const [left, right] = args;
-	return combineImpl(left, right);
-}
-
-//#endregion
-//#region src/combinators/swap.ts
-/**
-* Swaps Ok and Err.
-* Result<T, E> → Result<E, T>
-*/
-function swap(result) {
-	if (result.isOk()) return err(result.value);
-	if (result.isErr()) return ok(result.error);
-	throw new Error("Unreachable: Result is neither Ok nor Err");
-}
-
-//#endregion
-//#region src/collections/sequence.ts
+//#region src/core/sequence.ts
 /**
-* Combines a list of Results into a Result of a list.
-* Short-circuits on the first Err.
-* Analogous to Rust `collect::<Result<Vec<_>, _>>()`.
+* Kombiniert eine Liste von Results zu einem Result einer Liste.
+* Short-circuits beim ersten Err.
+* Analog zu Rust `collect::<Result<Vec<_>, _>>()`.
 */
 function sequence(results) {
 	const values = [];
@@ -1273,23 +831,23 @@ function sequence(results) {
 	return ok(values);
 }
 /**
-* Alias for `sequence`.
+* Alias für `sequence`.
 */
 function all(results) {
 	return sequence(results);
 }
 
 //#endregion
-//#region src/collections/sequenceRecord.ts
+//#region src/core/sequenceRecord.ts
 /**
-* Like `sequence`, but for records/objects.
-* Short-circuits on the first Err.
+* Wie `sequence`, aber für Records/Objekte.
+* Short-circuits beim ersten Err.
 */
 function sequenceRecord(record) {
 	const out = {};
 	for (const key of Object.keys(record)) {
 		const result = record[key];
-		if (!result) throw new Error(`Missing Result for key "${String(key)}"`);
+		if (!result) continue;
 		if (result.isOk()) {
 			out[key] = result.value;
 			continue;
@@ -1301,33 +859,13 @@ function sequenceRecord(record) {
 }
 
 //#endregion
-//#region src/collections/collectFirstOk.ts
-/**
-* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
-* If no `Ok` is found, returns an `Err` containing the collected error values.
-* Useful for "try multiple approaches until one works" patterns.
-*/
-function collectFirstOk(results) {
-	const errors = [];
-	for (const result of results) {
-		if (result.isOk()) return ok(result.value);
-		if (result.isErr()) {
-			errors.push(result.error);
-			continue;
-		}
-		throw new Error("Unreachable: Result is neither Ok nor Err");
-	}
-	return err(errors);
-}
-
-//#endregion
-//#region src/collections/collectFirstOkAsync.ts
+//#region src/core/collectFirstOkAsync.ts
 /**
-* Async version of collectFirstOk.
+* Async-Version von collectFirstOk.
 *
-* - Accepts already-started promises or "thunks" (`() => Awaitable<Result<...>>`).
-* - Processes inputs strictly sequentially (like `for ... of` + `await`).
-* - Returns the first `Ok` and collects all errors when no `Ok` is found.
+* - Nimmt entweder bereits gestartete Promises oder "Thunks" (`() => Awaitable<Result<...>>`).
+* - Verarbeitet die Inputs strikt sequentiell (wie `for ... of` + `await`).
+* - Gibt das erste `Ok` zurück und sammelt alle Errors wenn kein `Ok` gefunden wird.
 */
 async function collectFirstOkAsync(inputs) {
 	const errors = [];
@@ -1346,61 +884,43 @@ async function collectFirstOkAsync(inputs) {
 }
 
 //#endregion
-//#region src/collections/collectFirstOkRaceAsync.ts
+//#region src/core/collectFirstOkParallelAsync.ts
 /**
-* Parallel/race variant of `collectFirstOkAsync`.
+* Parallel-Variante von `collectFirstOkAsync`.
 *
-* - Starts all inputs immediately (promises or thunks).
-* - Returns the first `Ok` as soon as it is available.
-* - If no `Ok` is found, returns an `Err` with all error values (in input order).
-* - **Note**: There is no cancellation logic. All inputs keep running even after the first `Ok` is found.
+* - Startet alle Inputs sofort (Promises oder Thunks).
+* - Gibt das erste `Ok` zurück, sobald es verfügbar ist.
+* - Wenn kein `Ok` gefunden wird, gibt ein `Err` mit allen Error-Werten (in Input-Reihenfolge) zurück.
+* - Rejections werden als `ErrValue` behandelt (`caught as ErrValue`).
+* - Wenn mehrere Inputs ein `Ok` liefern, gewinnt das zuerst abgeschlossene Ergebnis.
+*   Bei gleichzeitiger Completion gewinnt das zuerst beobachtete Ergebnis.
+* - Wenn kein `Ok` kommt und mindestens ein Input nie settled, bleibt das Promise offen.
 */
-async function collectFirstOkRaceAsync(inputs) {
+async function collectFirstOkParallelAsync(inputs) {
 	if (inputs.length === 0) return err([]);
-	const UNSET = Symbol("unset");
-	const errorsByIndex = Array(inputs.length).fill(UNSET);
-	return new Promise((resolve) => {
-		let done = false;
-		let remaining = inputs.length;
-		const finishAllErr = () => {
-			const errors = [];
-			for (const entry of errorsByIndex) if (entry !== UNSET) errors.push(entry);
-			resolve(err(errors));
-		};
-		const settleError = (index, errorValue) => {
-			if (done) return;
-			errorsByIndex[index] = errorValue;
-			remaining -= 1;
-			if (remaining === 0) {
-				done = true;
-				finishAllErr();
-			}
-		};
-		inputs.forEach((input, index) => {
-			Promise.resolve().then(() => typeof input === "function" ? input() : input).then((result) => {
-				if (done) return;
-				if (result.isOk()) {
-					done = true;
-					resolve(ok(result.value));
-					return;
-				}
-				if (result.isErr()) {
-					settleError(index, result.error);
-					return;
-				}
-				settleError(index, /* @__PURE__ */ new Error("Unreachable: Result is neither Ok nor Err"));
-			}).catch((caught) => {
-				settleError(index, caught);
-			});
-		});
+	const started = inputs.map((input) => typeof input === "function" ? Promise.resolve().then(input) : input);
+	const firstOk = new Promise((resolve) => {
+		for (const promise of started) promise.then((result) => {
+			if (result.isOk()) resolve(ok(result.value));
+		}).catch(() => {});
+	});
+	const allErrors = Promise.allSettled(started).then((settled) => {
+		const errors = [];
+		for (const entry of settled) if (entry.status === "fulfilled") {
+			const result = entry.value;
+			if (result.isErr()) errors.push(result.error);
+			else if (!result.isOk()) errors.push(/* @__PURE__ */ new Error("Unreachable: Result is neither Ok nor Err"));
+		} else errors.push(entry.reason);
+		return err(errors);
 	});
+	return Promise.race([firstOk, allErrors]);
 }
 
 //#endregion
-//#region src/collections/collectAllErrors.ts
+//#region src/core/collectAllErrors.ts
 /**
-* Combines a list of Results.
-* Returns Ok(values) only if all are Ok, otherwise Err([errors]).
+* Kombiniert eine Liste von Results.
+* Gibt Ok(values) nur zurück wenn alle Ok sind, sonst Err([errors]).
 */
 function collectAllErrors(results) {
 	const values = [];
@@ -1420,9 +940,9 @@ function collectAllErrors(results) {
 }
 
 //#endregion
-//#region src/collections/partition.ts
+//#region src/core/partition.ts
 /**
-* Partitions Results into Ok values and Err errors.
+* Partitioniert Results in Ok-Werte und Err-Fehler.
 */
 function partition(results) {
 	const oks = [];
@@ -1442,7 +962,7 @@ function partition(results) {
 }
 
 //#endregion
-//#region src/collections/flatten.ts
+//#region src/core/flatten.ts
 /**
 * Flacht ein nested Result ab.
 * Result<Result<T, E>, E> → Result<T, E>
@@ -1454,30 +974,53 @@ function flatten(result) {
 }
 
 //#endregion
-//#region src/utils/isOk.ts
+//#region src/core/toPromise.ts
+/**
+* Konvertiert ein Result zu einem Promise.
+* Ok → resolve(value), Err → reject(error)
+*/
+function toPromise(result) {
+	if (result.isOk()) return Promise.resolve(result.value);
+	if (result.isErr()) return Promise.reject(result.error);
+	throw new Error("Unreachable: Result is neither Ok nor Err");
+}
+
+//#endregion
+//#region src/core/toNullable.ts
+/**
+* Konvertiert ein Result zu `T | null`.
+* Ok → value, Err → null
+*/
+function toNullable(result) {
+	if (result.isOk()) return result.value;
+	return null;
+}
+
+//#endregion
+//#region src/core/isOk.ts
 /**
-* Checks whether a Result is Ok.
-* Pure function alternative to the instance method.
+* Prüft ob ein Result Ok ist.
+* Pure function Alternative zur Instanz-Methode.
 */
 function isOk(result) {
 	return result.isOk();
 }
 
 //#endregion
-//#region src/utils/isErr.ts
+//#region src/core/isErr.ts
 /**
-* Checks whether a Result is Err.
-* Pure function alternative to the instance method.
+* Prüft ob ein Result Err ist.
+* Pure function Alternative zur Instanz-Methode.
 */
 function isErr(result) {
 	return result.isErr();
 }
 
 //#endregion
-//#region src/utils/contains.ts
+//#region src/core/contains.ts
 /**
-* Checks whether the Result contains a specific value.
-* Equivalent to Rust `contains`.
+* Prüft ob das Result einen bestimmten Wert enthält.
+* Entspricht Rust `contains`.
 */
 function contains(result, value) {
 	if (!result.isOk()) return false;
@@ -1485,10 +1028,10 @@ function contains(result, value) {
 }
 
 //#endregion
-//#region src/utils/containsErr.ts
+//#region src/core/containsErr.ts
 /**
-* Checks whether the Result contains a specific error.
-* Analogous to `contains` for the Err case.
+* Prüft ob das Result einen bestimmten Fehler enthält.
+* Analog zu `contains` für den Err-Fall.
 */
 function containsErr(result, error) {
 	if (!result.isErr()) return false;
@@ -1496,6 +1039,8 @@ function containsErr(result, error) {
 }
 
 //#endregion
+exports.Err = Err;
+exports.Ok = Ok;
 exports.Result = Result;
 exports.all = all;
 exports.and = and;
@@ -1503,7 +1048,7 @@ exports.bimap = bimap;
 exports.collectAllErrors = collectAllErrors;
 exports.collectFirstOk = collectFirstOk;
 exports.collectFirstOkAsync = collectFirstOkAsync;
-exports.collectFirstOkRaceAsync = collectFirstOkRaceAsync;
+exports.collectFirstOkParallelAsync = collectFirstOkParallelAsync;
 exports.combine = combine;
 exports.contains = contains;
 exports.containsErr = containsErr;