@mkvlrn/result 5.0.6 → 5.0.8

package/README.md

@@ -1,47 +1,45 @@
 # @mkvlrn/result
 
-Type-safe Result pattern for TypeScript representing success or error. Anything to avoid try/catch hell.
+Dead simple Result pattern for TypeScript.
+
+No `.map()`, no `.flatMap()`, no `.andThen()`, no `.orElse()`, no `.unwrap()`, no monadic gymnastics. Just a type, two functions, and TypeScript doing what TypeScript already does well.
 
 [![npm](https://img.shields.io/npm/v/@mkvlrn/result)](https://www.npmjs.com/package/@mkvlrn/result)
 
-## Installation
+## Why this one?
 
-```bash
-pnpm add @mkvlrn/result
-```
+There are dozens of Result libraries for TypeScript. Nearly all of them bolt on method chaining, transformation pipelines, and functional programming utilities that turn a simple concept into an entire paradigm.
 
-## Usage
+This package does **one thing**: gives you a type-safe `Result<T, E>` discriminated union with `ok()` and `err()` constructors. You use `if/else` to handle it. TypeScript narrows the type for you. That's the whole API.
 
-```typescript
-import { Result, AsyncResult, ok, err } from "@mkvlrn/result";
+**The entire implementation is ~35 lines. Zero runtime dependencies. Four exports.**
 
-// Success
-const success = ok(42);
+If you need `.map().flatMap().andThen().orElse().unwrapOr()` chains, use [neverthrow](https://github.com/supermacro/neverthrow) or [ts-results](https://github.com/vultix/ts-results). They're good libraries. This isn't that.
 
-// Error
-const failure = err(new Error("Something went wrong"));
+## Installation
 
-// Check result
-const result = ok(42);
-if (result.isError) {
-  console.log("Error:", result.error.message);
-} else {
-  console.log("Value:", result.value);
-}
+```bash
+pnpm add @mkvlrn/result
 ```
 
 ## API
 
-| Export              | Description                                  |
+| Export              | What it does                                 |
 | ------------------- | -------------------------------------------- |
 | `Result<T, E>`      | Union type representing success or failure   |
 | `AsyncResult<T, E>` | `Promise<Result<T, E>>` for async operations |
 | `ok(value)`         | Creates a success result                     |
 | `err(error)`        | Creates an error result                      |
 
-## Examples
+That's it. That's the whole thing.
+
+## Usage
+
+```typescript
+import { type Result, type AsyncResult, ok, err } from "@mkvlrn/result";
+```
 
-### Basic Function
+### Create results, check results
 
 ```typescript
 function divide(a: number, b: number): Result<number, Error> {
@@ -53,10 +51,16 @@ function divide(a: number, b: number): Result<number, Error> {
 
 const result = divide(10, 2);
 if (result.isOk) {
-  console.log(result.value); // 5
+  console.log(result.value); // number - TypeScript knows
+}
+
+if (result.isError) {
+  console.log(result.error.message); // Error - TypeScript knows
 }
 ```
 
+No `.unwrap()`. No `.expect()`. Just an `if` statement and the compiler handles the rest.
+
 ### Async Operations
 
 ```typescript
@@ -74,29 +78,32 @@ async function fetchUser(id: number): AsyncResult<User, Error> {
 }
 ```
 
+`AsyncResult<T, E>` is just `Promise<Result<T, E>>`. It's a type alias, not a class, not a wrapper, not a monad.
+
 ### Custom Error Types
 
 ```typescript
 class ValidationError extends Error {
-  readonly customField: number;
+  readonly code: number;
 
-  constructor(customField: number, message: string) {
+  constructor(code: number, message: string) {
     super(message);
     this.name = "ValidationError";
-    this.customField = customField;
+    this.code = code;
   }
 }
 
 function validateEmail(email: string): Result<string, ValidationError> {
   if (!email.includes("@")) {
-    return err(new ValidationError(400, "custom"));
+    return err(new ValidationError(400, "bad-email"));
   }
   return ok(email);
 }
 
 const result = validateEmail("invalid-email");
 if (result.isError) {
-  console.log(`${result.error.customField}: ${result.error.message}`);
+  // TypeScript knows this is a ValidationError, not just Error
+  console.log(`${result.error.code}: ${result.error.message}`); // 400: bad-email
 }
 ```
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mkvlrn/result",
   "description": "Simple Result type/pattern for TypeScript",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "license": "MIT",
   "type": "module",
   "author": "Mike Valeriano <mkvlrn@gmail.com>",
@@ -14,25 +14,22 @@
     "typescript",
     "result"
   ],
-  "engines": {
-    "node": "24"
-  },
   "files": [
     "build"
   ],
   "imports": {
-    "#*": "./src/*.ts"
+    "#/*": "./src/*.ts"
   },
   "exports": {
     "types": "./build/index.d.ts",
     "default": "./build/index.js"
   },
   "devDependencies": {
-    "@types/node": "^25.2.0",
-    "lint-staged": "^16.2.7",
+    "@types/node": "^25.3.3",
+    "lint-staged": "^16.3.2",
     "tsc-files": "^1.1.4",
-    "tsdown": "0.20.1",
-    "typescript": "^5.9.3",
+    "tsdown": "0.20.3",
+    "typescript": "6.0.0-beta",
     "vitest": "^4.0.18"
   },
   "scripts": {