yield-result 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yield-result contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to nobility conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# yield-result
+
+> Rust-style `?` operator for TypeScript using generators (`yield*`). Zero dependencies, lightweight, type-safe error handling without runtime exceptions.
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.5+-blue.svg)](https://www.typescriptlang.org/)
+[![Vitest](https://img.shields.io/badge/tested%20with-vitest-blueviolet.svg)](https://vitest.dev/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+---
+
+## ⚡ Why `yield-result`?
+
+In languages like Rust, the `?` operator unbinds a `Result` value with automatic early-return short-circuiting on errors—avoiding deep callback nesting (`.then()`, `.flatMap()`) and `try/catch` exception overhead.
+
+JavaScript/TypeScript does not support custom operator overloading, but ECMAScript **`yield*`** (generator delegation) provides the **exact same semantics natively**!
+
+### Syntax Comparison
+
+```typescript
+// ❌ BEFORE: Try/catch nesting or monadic chain hell
+async function processOrder(id: string) {
+  try {
+    const order = await fetchOrder(id);
+    if (!order) return { error: "Order not found" };
+    
+    const stock = await reserveStock(order);
+    if (!stock.ok) return { error: stock.error };
+
+    return { ok: true, data: stock.value };
+  } catch (e) {
+    return { error: String(e) };
+  }
+}
+
+// ✅ WITH YIELD-RESULT: Linear, type-safe, synchronous or async, zero try/catch
+import { safe, Result } from "yield-result";
+
+const processOrder = (id: string) => safe.async(async function* () {
+  const order = yield* await fetchOrder(id);   // If Err, short-circuits and early-returns Err!
+  const stock = yield* await reserveStock(order);
+  
+  return { status: "Success", stock };
+});
+```
+
+---
+
+## 🚀 Installation
+
+```bash
+npm install yield-result
+```
+
+---
+
+## 🏎️ Performance Benchmarks
+
+Benchmarked using `vitest bench` (powered by `tinybench`) on Node.js:
+
+### 🔴 Unhappy Path (Error Triggered)
+
+When errors actually occur during domain execution:
+
+| Implementation | Operations / sec | Benchmark Summary |
+| :--- | :---: | :--- |
+| **`yield-result` (`safe.sync`)** | **`207,485 ops/sec`** | ⚡ **3.55x FASTER than native try/catch** |
+| **Native `try/catch` with `throw`** | **`58,515 ops/sec`** | 🐢 3.55x slower |
+
+> 🏆 **Why is `yield-result` 3.55x faster on errors?**  
+> Native `throw new Error()` forces JavaScript V8 engines to pause execution, capture call stack frames, allocate Error objects, and deoptimize JIT loops. In `yield-result`, returning an `Err` is just returning a plain object without unwinding stack frames.
+
+### 🟢 Happy Path (Success Flow)
+
+| Implementation | Operations / sec | Average Latency |
+| :--- | :---: | :---: |
+| **Native `try/catch` (no throw)** | `11,372,962 ops/sec` | `0.0001 ms` |
+| **`yield-result` (`safe.sync`)** | `231,068 ops/sec` | `0.0043 ms` |
+
+*Over 230,000 complete domain pipelines evaluated per second on a single thread—zero impact on network or database latencies.*
+
+---
+
+## 📖 Usage Guide
+
+### 1. Creating Results
+
+```typescript
+import { ok, err, Result } from "yield-result";
+
+function divide(a: number, b: number): Result<number, string> {
+  if (b === 0) return err("Division by zero");
+  return ok(a / b);
+}
+```
+
+### 2. Composing Pipelines (`safe.sync` and `safe.async`)
+
+Use `safe.sync` for synchronous workflows and `safe.async` for asynchronous workflows:
+
+```typescript
+import { safe, ok, err } from "yield-result";
+
+const result = safe.sync(function* () {
+  const a = yield* divide(100, 2); // a = 50
+  const b = yield* divide(a, 5);   // b = 10
+  return a + b;                    // Returns ok(60)
+});
+
+console.log(result); // { ok: true, value: 60 }
+```
+
+### 3. Integrating with Throwable & Async Code
+
+Convert legacy functions that throw exceptions or return Promises:
+
+```typescript
+import { fromThrowable, fromPromise, fromAsyncFn } from "yield-result";
+
+// Sync throwable functions (e.g. JSON.parse)
+const jsonRes = fromThrowable(() => JSON.parse('{"status": "ok"}'));
+
+// Promises
+const fetchRes = await fromPromise(
+  fetch("https://api.example.com/data").then(r => r.json()),
+  (err) => `API Error: ${err}`
+);
+
+// Async Functions (handles both sync throws and promise rejections)
+const asyncRes = await fromAsyncFn(() => loadData());
+```
+
+---
+
+## 🛡️ Built-in Safety Features
+
+### Runtime Protection against Missing Asterisk (`*`)
+
+Forgetting the asterisk (`yield` instead of `yield*`) is automatically intercepted at runtime and in TypeScript:
+
+```typescript
+safe.sync(function* () {
+  // ❌ Dev forgets the asterisk:
+  const data = yield divide(10, 2); 
+});
+
+// 💥 Throws an immediate explanatory Error:
+// Error: Incorrect 'yield' usage: missing asterisk '*'. Use 'yield* result' instead of 'yield result'.
+```
+
+---
+
+## 🛠️ Complete API Reference
+
+### Constructors & Guards
+* **`ok(value)`** / **`Result.ok(value)`** — Creates an `Ok<T>` result.
+* **`err(error)`** / **`Result.err(error)`** — Creates an `Err<E>` result.
+* **`isOk(result)`** / **`isErr(result)`** — TypeScript type guards.
+
+### Flow Runners (`safe`)
+* **`safe.sync(function* () { ... })`** — Executes a synchronous generator function with early-return short-circuiting on `Err`.
+* **`safe.async(async function* () { ... })`** — Executes an async generator function with early-return short-circuiting on `Err`.
+
+### Exception Wrappers
+* **`fromThrowable(fn, errorMapper?)`** — Wraps a throwing function into a `Result<T, E>`.
+* **`fromPromise(promise, errorMapper?)`** — Wraps a Promise into `Promise<Result<T, E>>`.
+* **`fromAsyncFn(fn, errorMapper?)`** — Wraps an async function into `Promise<Result<T, E>>`.
+
+### Combinators & Utilities
+* **`map(result, fn)`** — Transforms the `Ok` value.
+* **`mapErr(result, fn)`** — Transforms the `Err` value.
+* **`andThen(result, fn)`** — Chains a new Result-returning function if `Ok`.
+* **`unwrapOr(result, fallback)`** — Returns contained `Ok` value or fallback.
+* **`unwrap(result)`** — Extracts `Ok` value or throws `Err`.
+* **`expectResult(result, msg)`** — Extracts `Ok` value or throws custom error message.
+* **`tap(result, fn)`** — Runs side-effect function if `Ok`.
+* **`tapErr(result, fn)`** — Runs side-effect function if `Err`.
+* **`match(result, { ok, err })`** — Pattern matches on Ok or Err.
+* **`all([r1, r2, r3])`** — Combines `Result<T, E>[]` into `Result<T[], E>`.
+* **`partition(results)`** — Partitions array of Results into `{ values, errors }`.
+
+---
+
+## 🧪 Testing & Benchmarks
+
+```bash
+npm run test        # Runs all Vitest unit tests (39 tests)
+npm run test:types  # Runs strict TypeScript type-checking (tsc --noEmit)
+npm run bench       # Runs performance benchmarks (vitest bench)
+npm run build       # Compiles output to dist/
+```
+
+---
+
+## ⚖️ License
+
+MIT © yield-result contributors
+
+

package/dist/flow.d.ts

@@ -0,0 +1,16 @@
+import { Result, Err } from "./types.js";
+/**
+ * Control flow runners for evaluating generator functions with short-circuiting on Err.
+ */
+export declare const safe: {
+    /**
+     * Evaluates a synchronous generator function, returning Ok(value) on completion,
+     * or short-circuiting on the first yielded Err(error).
+     */
+    sync: <T, E = unknown>(fn: () => Generator<Err<E>, T, unknown>) => Result<T, E>;
+    /**
+     * Evaluates an async generator function, returning Ok(value) on completion,
+     * or short-circuiting on the first yielded Err(error).
+     */
+    async: <T, E = unknown>(fn: () => AsyncGenerator<Err<E>, T, unknown>) => Promise<Result<T, E>>;
+};

package/dist/flow.js

@@ -0,0 +1,104 @@
+import { ok, err, isOk, isErr } from "./types.js";
+/**
+ * Control flow runners for evaluating generator functions with short-circuiting on Err.
+ */
+export const safe = {
+    /**
+     * Evaluates a synchronous generator function, returning Ok(value) on completion,
+     * or short-circuiting on the first yielded Err(error).
+     */
+    sync: (fn) => {
+        let gen;
+        try {
+            gen = fn();
+        }
+        catch (e) {
+            return err(e);
+        }
+        try {
+            const next = gen.next();
+            if (!next.done) {
+                // Safety guard: detects if developer forgot the '*' when yielding an Ok or non-Err value
+                if (isOk(next.value)) {
+                    try {
+                        gen.return(undefined);
+                    }
+                    catch (_) { }
+                    throw new Error("Incorrect 'yield' usage: missing asterisk '*'. Use 'yield* result' instead of 'yield result'.");
+                }
+                if (!isErr(next.value)) {
+                    try {
+                        gen.return(undefined);
+                    }
+                    catch (_) { }
+                    throw new Error("Incorrect 'yield' usage: generator yielded a value that is not a Result Err. Make sure to use 'yield* result'.");
+                }
+                // Trigger resource cleanup for try...finally blocks in suspended generator
+                try {
+                    gen.return(undefined);
+                }
+                catch (_) { }
+                return next.value;
+            }
+            return ok(next.value);
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes("Incorrect 'yield' usage")) {
+                throw e;
+            }
+            try {
+                gen.return(undefined);
+            }
+            catch (_) { }
+            return err(e);
+        }
+    },
+    /**
+     * Evaluates an async generator function, returning Ok(value) on completion,
+     * or short-circuiting on the first yielded Err(error).
+     */
+    async: async (fn) => {
+        let gen;
+        try {
+            gen = fn();
+        }
+        catch (e) {
+            return err(e);
+        }
+        try {
+            const next = await gen.next();
+            if (!next.done) {
+                if (isOk(next.value)) {
+                    try {
+                        await gen.return(undefined);
+                    }
+                    catch (_) { }
+                    throw new Error("Incorrect 'yield' usage: missing asterisk '*'. Use 'yield* result' instead of 'yield result'.");
+                }
+                if (!isErr(next.value)) {
+                    try {
+                        await gen.return(undefined);
+                    }
+                    catch (_) { }
+                    throw new Error("Incorrect 'yield' usage: generator yielded a value that is not a Result Err. Make sure to use 'yield* result'.");
+                }
+                try {
+                    await gen.return(undefined);
+                }
+                catch (_) { }
+                return next.value;
+            }
+            return ok(next.value);
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes("Incorrect 'yield' usage")) {
+                throw e;
+            }
+            try {
+                await gen.return(undefined);
+            }
+            catch (_) { }
+            return err(e);
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./wrappers.js";
+export * from "./flow.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./wrappers.js";
+export * from "./flow.js";

package/dist/types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Core Result type: simple discriminated unions without classes.
+ *
+ * For `yield* result` to work inside a generator function, `result`
+ * must implement the Iterable protocol (`Symbol.iterator`).
+ *
+ *  - Ok: the iterator returns `value` immediately without yielding.
+ *    This allows `yield* ok(x)` to evaluate synchronously to `x`.
+ *  - Err: the iterator yields `this` (the Err object) once.
+ *    This propagates the Err object to the runner in `flow.ts` to abort execution.
+ */
+export type Ok<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly [Symbol.iterator]: () => Generator<never, T, unknown>;
+};
+export type Err<E> = {
+    readonly ok: false;
+    readonly error: E;
+    readonly [Symbol.iterator]: () => Generator<Err<E>, never, unknown>;
+};
+export type Result<T, E = string> = Ok<T> | Err<E>;
+/**
+ * Creates a successful Result containing a value.
+ */
+export declare const ok: <T>(value: T) => Ok<T>;
+/**
+ * Creates an error Result containing an error value.
+ */
+export declare const err: <E>(error: E) => Err<E>;
+/**
+ * Type guard for Ok results.
+ */
+export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+/**
+ * Type guard for Err results.
+ */
+export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
+/**
+ * Maps a Result<T, E> to Result<U, E> by applying a function to a successful value.
+ */
+export declare const map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U) => Result<U, E>;
+/**
+ * Maps a Result<T, E> to Result<T, F> by applying a function to an error value.
+ */
+export declare const mapErr: <T, E, F>(result: Result<T, E>, fn: (error: E) => F) => Result<T, F>;
+/**
+ * Chains another Result-returning function if the result is Ok.
+ */
+export declare const andThen: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>) => Result<U, E>;
+/**
+ * Returns the contained Ok value or a fallback value if Err.
+ */
+export declare const unwrapOr: <T, E>(result: Result<T, E>, fallback: T) => T;
+/**
+ * Extracts the contained Ok value, or throws the contained Error.
+ */
+export declare const unwrap: <T, E>(result: Result<T, E>) => T;
+/**
+ * Extracts the contained Ok value, or throws a custom error message.
+ */
+export declare const expectResult: <T, E>(result: Result<T, E>, msg: string) => T;
+/**
+ * Executes a side-effect function if the result is Ok.
+ */
+export declare const tap: <T, E>(result: Result<T, E>, fn: (value: T) => void) => Result<T, E>;
+/**
+ * Executes a side-effect function if the result is Err.
+ */
+export declare const tapErr: <T, E>(result: Result<T, E>, fn: (error: E) => void) => Result<T, E>;
+/**
+ * Pattern matches on a Result, executing the ok or err handler.
+ */
+export declare const match: <T, E, R>(result: Result<T, E>, handlers: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+}) => R;
+/**
+ * Combines an array of Results into a single Result containing an array of values.
+ * Short-circuits on the first Err.
+ */
+export declare const all: <T, E>(results: Result<T, E>[]) => Result<T[], E>;
+/**
+ * Partitions an array of Results into separate values and errors arrays.
+ */
+export declare const partition: <T, E>(results: Result<T, E>[]) => {
+    values: T[];
+    errors: E[];
+};
+/**
+ * Namespace object grouping all Result constructors, guards, and combinators.
+ */
+export declare const Result: {
+    readonly ok: <T>(value: T) => Ok<T>;
+    readonly err: <E>(error: E) => Err<E>;
+    readonly isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+    readonly isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
+    readonly map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U) => Result<U, E>;
+    readonly mapErr: <T, E, F>(result: Result<T, E>, fn: (error: E) => F) => Result<T, F>;
+    readonly andThen: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>) => Result<U, E>;
+    readonly unwrapOr: <T, E>(result: Result<T, E>, fallback: T) => T;
+    readonly unwrap: <T, E>(result: Result<T, E>) => T;
+    readonly expect: <T, E>(result: Result<T, E>, msg: string) => T;
+    readonly tap: <T, E>(result: Result<T, E>, fn: (value: T) => void) => Result<T, E>;
+    readonly tapErr: <T, E>(result: Result<T, E>, fn: (error: E) => void) => Result<T, E>;
+    readonly match: <T, E, R>(result: Result<T, E>, handlers: {
+        ok: (value: T) => R;
+        err: (error: E) => R;
+    }) => R;
+    readonly all: <T, E>(results: Result<T, E>[]) => Result<T[], E>;
+    readonly partition: <T, E>(results: Result<T, E>[]) => {
+        values: T[];
+        errors: E[];
+    };
+};

package/dist/types.js

@@ -0,0 +1,155 @@
+/**
+ * Core Result type: simple discriminated unions without classes.
+ *
+ * For `yield* result` to work inside a generator function, `result`
+ * must implement the Iterable protocol (`Symbol.iterator`).
+ *
+ *  - Ok: the iterator returns `value` immediately without yielding.
+ *    This allows `yield* ok(x)` to evaluate synchronously to `x`.
+ *  - Err: the iterator yields `this` (the Err object) once.
+ *    This propagates the Err object to the runner in `flow.ts` to abort execution.
+ */
+// Shared prototypes for memory optimization and structuredClone support
+const OkPrototype = {
+    ok: true,
+    *[Symbol.iterator]() {
+        return this.value;
+    },
+};
+const ErrPrototype = {
+    ok: false,
+    *[Symbol.iterator]() {
+        yield this;
+        throw new Error("Err iterator resumed after yield — indicates an invalid generator runner execution.");
+    },
+};
+/**
+ * Creates a successful Result containing a value.
+ */
+export const ok = (value) => {
+    const instance = Object.create(OkPrototype);
+    instance.ok = true;
+    instance.value = value;
+    return Object.freeze(instance);
+};
+/**
+ * Creates an error Result containing an error value.
+ */
+export const err = (error) => {
+    const instance = Object.create(ErrPrototype);
+    instance.ok = false;
+    instance.error = error;
+    return Object.freeze(instance);
+};
+/**
+ * Type guard for Ok results.
+ */
+export const isOk = (result) => result.ok;
+/**
+ * Type guard for Err results.
+ */
+export const isErr = (result) => !result.ok;
+// --- Combinators ---
+/**
+ * Maps a Result<T, E> to Result<U, E> by applying a function to a successful value.
+ */
+export const map = (result, fn) => result.ok ? ok(fn(result.value)) : result;
+/**
+ * Maps a Result<T, E> to Result<T, F> by applying a function to an error value.
+ */
+export const mapErr = (result, fn) => result.ok ? result : err(fn(result.error));
+/**
+ * Chains another Result-returning function if the result is Ok.
+ */
+export const andThen = (result, fn) => (result.ok ? fn(result.value) : result);
+/**
+ * Returns the contained Ok value or a fallback value if Err.
+ */
+export const unwrapOr = (result, fallback) => result.ok ? result.value : fallback;
+/**
+ * Extracts the contained Ok value, or throws the contained Error.
+ */
+export const unwrap = (result) => {
+    if (result.ok)
+        return result.value;
+    if (result.error instanceof Error)
+        throw result.error;
+    throw new Error(String(result.error));
+};
+/**
+ * Extracts the contained Ok value, or throws a custom error message.
+ */
+export const expectResult = (result, msg) => {
+    if (result.ok)
+        return result.value;
+    throw new Error(`${msg}: ${String(result.error)}`);
+};
+/**
+ * Executes a side-effect function if the result is Ok.
+ */
+export const tap = (result, fn) => {
+    if (result.ok)
+        fn(result.value);
+    return result;
+};
+/**
+ * Executes a side-effect function if the result is Err.
+ */
+export const tapErr = (result, fn) => {
+    if (!result.ok)
+        fn(result.error);
+    return result;
+};
+/**
+ * Pattern matches on a Result, executing the ok or err handler.
+ */
+export const match = (result, handlers) => (result.ok ? handlers.ok(result.value) : handlers.err(result.error));
+/**
+ * Combines an array of Results into a single Result containing an array of values.
+ * Short-circuits on the first Err.
+ */
+export const all = (results) => {
+    const values = [];
+    for (const r of results) {
+        if (!r.ok)
+            return err(r.error);
+        values.push(r.value);
+    }
+    return ok(values);
+};
+/**
+ * Partitions an array of Results into separate values and errors arrays.
+ */
+export const partition = (results) => {
+    const values = [];
+    const errors = [];
+    for (const r of results) {
+        if (r.ok) {
+            values.push(r.value);
+        }
+        else {
+            errors.push(r.error);
+        }
+    }
+    return { values, errors };
+};
+/**
+ * Namespace object grouping all Result constructors, guards, and combinators.
+ */
+export const Result = {
+    ok,
+    err,
+    isOk,
+    isErr,
+    map,
+    mapErr,
+    andThen,
+    unwrapOr,
+    unwrap,
+    expect: expectResult,
+    tap,
+    tapErr,
+    match,
+    all,
+    partition,
+};

package/dist/wrappers.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "./types.js";
+/**
+ * Wraps a synchronous function that may throw an exception into a Result<T, E>.
+ * Catches any thrown value and maps it using errorMapper if provided.
+ */
+export declare const fromThrowable: <T, E = unknown>(fn: () => T, errorMapper?: (e: unknown) => E) => Result<T, E>;
+/**
+ * Wraps a Promise into a Promise<Result<T, E>>.
+ * Catches any rejection and maps it using errorMapper if provided.
+ */
+export declare const fromPromise: <T, E = unknown>(promise: Promise<T>, errorMapper?: (e: unknown) => E) => Promise<Result<T, E>>;
+/**
+ * Wraps an async function that returns a Promise into a Promise<Result<T, E>>.
+ * Catches both synchronous exceptions thrown during execution and async rejections.
+ */
+export declare const fromAsyncFn: <T, E = unknown>(fn: () => Promise<T>, errorMapper?: (e: unknown) => E) => Promise<Result<T, E>>;

package/dist/wrappers.js

@@ -0,0 +1,39 @@
+import { ok, err } from "./types.js";
+/**
+ * Wraps a synchronous function that may throw an exception into a Result<T, E>.
+ * Catches any thrown value and maps it using errorMapper if provided.
+ */
+export const fromThrowable = (fn, errorMapper) => {
+    try {
+        return ok(fn());
+    }
+    catch (e) {
+        return err(errorMapper ? errorMapper(e) : e);
+    }
+};
+/**
+ * Wraps a Promise into a Promise<Result<T, E>>.
+ * Catches any rejection and maps it using errorMapper if provided.
+ */
+export const fromPromise = async (promise, errorMapper) => {
+    try {
+        const data = await promise;
+        return ok(data);
+    }
+    catch (e) {
+        return err(errorMapper ? errorMapper(e) : e);
+    }
+};
+/**
+ * Wraps an async function that returns a Promise into a Promise<Result<T, E>>.
+ * Catches both synchronous exceptions thrown during execution and async rejections.
+ */
+export const fromAsyncFn = async (fn, errorMapper) => {
+    try {
+        const promise = fn();
+        return await fromPromise(promise, errorMapper);
+    }
+    catch (e) {
+        return err(errorMapper ? errorMapper(e) : e);
+    }
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "yield-result",
+  "version": "0.1.0",
+  "description": "Rust-style ? operator for TypeScript using generators (yield*). Zero dependencies, type-safe error handling.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npx vitest run",
+    "test:types": "tsc -p tsconfig.json --noEmit",
+    "bench": "npx vitest bench",
+    "prepublishOnly": "npm run test && npm run test:types && npm run build"
+  },
+  "keywords": [
+    "result",
+    "error-handling",
+    "rust",
+    "generator",
+    "yield",
+    "monad",
+    "typescript",
+    "either",
+    "safe"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
+  }
+}
+