@onrails/result 0.4.0 → 0.4.2

package/dist/{types-BQ9vv0nD.d.ts → types.d.ts}

@@ -15,7 +15,7 @@
  * }
  * ```
  */
-type Result<T, E> = {
+export type Result<T, E> = {
     readonly _tag: "Ok";
     readonly value: T;
 } | {
@@ -26,13 +26,13 @@ type Result<T, E> = {
  * The success branch of a {@link Result} — `{ _tag: "Ok"; value: T }`.
  * The `E` parameter keeps the type assignable to `Result<T, E>`.
  */
-type Ok<T, E = never> = Extract<Result<T, E>, {
+export type Ok<T, E = never> = Extract<Result<T, E>, {
     _tag: "Ok";
 }>;
 /**
  * The failure branch of a {@link Result} — `{ _tag: "Err"; error: E }`.
  */
-type Err<T, E> = Extract<Result<T, E>, {
+export type Err<T, E> = Extract<Result<T, E>, {
     _tag: "Err";
 }>;
 /**
@@ -47,9 +47,7 @@ type Err<T, E> = Extract<Result<T, E>, {
  * defect.cause; // the original thrown value
  * ```
  */
-declare class UnexpectedError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
+export declare class UnexpectedError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
 }
-
-export { type Err as E, type Ok as O, type Result as R, UnexpectedError as U };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/result",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Tagged Result / ResultAsync for railway-oriented TypeScript — pure tagged unions, neverthrow-shaped compat shim, FL-friendly",
   "license": "MIT",
   "author": "Alan R. Soares",
@@ -50,51 +50,96 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./fluent": {
-      "types": "./dist/fluent.d.ts",
-      "import": "./dist/fluent.js",
-      "require": "./dist/fluent.cjs"
+      "import": {
+        "types": "./dist/fluent.d.ts",
+        "default": "./dist/fluent.js"
+      },
+      "require": {
+        "types": "./dist/fluent.d.cts",
+        "default": "./dist/fluent.cjs"
+      }
+    },
+    "./async": {
+      "import": {
+        "types": "./dist/async-fns.d.ts",
+        "default": "./dist/async-fns.js"
+      },
+      "require": {
+        "types": "./dist/async-fns.d.cts",
+        "default": "./dist/async-fns.cjs"
+      }
     },
     "./extra": {
-      "types": "./dist/extra.d.ts",
-      "import": "./dist/extra.js",
-      "require": "./dist/extra.cjs"
+      "import": {
+        "types": "./dist/extra.d.ts",
+        "default": "./dist/extra.js"
+      },
+      "require": {
+        "types": "./dist/extra.d.cts",
+        "default": "./dist/extra.cjs"
+      }
     },
     "./pipe": {
-      "types": "./dist/pipe.d.ts",
-      "import": "./dist/pipe.js",
-      "require": "./dist/pipe.cjs"
+      "import": {
+        "types": "./dist/pipe.d.ts",
+        "default": "./dist/pipe.js"
+      },
+      "require": {
+        "types": "./dist/pipe.d.cts",
+        "default": "./dist/pipe.cjs"
+      }
     },
     "./railway": {
-      "types": "./dist/railway.d.ts",
-      "import": "./dist/railway.js",
-      "require": "./dist/railway.cjs"
+      "import": {
+        "types": "./dist/railway.d.ts",
+        "default": "./dist/railway.js"
+      },
+      "require": {
+        "types": "./dist/railway.d.cts",
+        "default": "./dist/railway.cjs"
+      }
     },
     "./try-gen": {
-      "types": "./dist/try-gen.d.ts",
-      "import": "./dist/try-gen.js",
-      "require": "./dist/try-gen.cjs"
+      "import": {
+        "types": "./dist/try-gen.d.ts",
+        "default": "./dist/try-gen.js"
+      },
+      "require": {
+        "types": "./dist/try-gen.d.cts",
+        "default": "./dist/try-gen.cjs"
+      }
     },
     "./compat/neverthrow": {
-      "types": "./dist/compat/neverthrow.d.ts",
-      "import": "./dist/compat/neverthrow.js",
-      "require": "./dist/compat/neverthrow.cjs"
+      "import": {
+        "types": "./dist/compat/neverthrow.d.ts",
+        "default": "./dist/compat/neverthrow.js"
+      },
+      "require": {
+        "types": "./dist/compat/neverthrow.d.cts",
+        "default": "./dist/compat/neverthrow.cjs"
+      }
     }
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "check": "bun typecheck && bun test",
-    "build": "tsup",
+    "build": "tsup && tsc -p tsconfig.build.json && bun run ../../scripts/dts-to-cts.ts",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "fast-check": "^3.23.2",
+    "fast-check": "^4.9.0",
     "ts-expect": "^1.3.0",
     "tsup": "^8.5.1"
   }

package/skills/railway-do-notation/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: railway-do-notation
-description: "Ergonomic railway composition for `@onrails/result`: when to use low-level Result/ResultAsync helpers, fluent `Railway.*` workflows, or sync `tryGen`. Use when writing or refactoring Result-heavy TypeScript, Drizzle/Zod ETL workflows, nested `flatMapResult` chains, mixed sync/async railway code, or when a user asks about 'Railway', 'railway', 'do-notation', 'safe workflow', or 'expressive Result code'. Do NOT use workflow builders for tiny repository methods where `asyncAfter` or `.flatMap` is clearer."
+description: "Ergonomic railway composition for `@onrails/result`: when to use low-level Result/ResultAsync helpers, fluent `Railway.*` workflows, or sync `tryGen`. Use when writing or refactoring Result-heavy TypeScript, Drizzle/Zod ETL workflows, nested `flatMap` chains, mixed sync/async railway code, or when a user asks about 'Railway', 'railway', 'do-notation', 'safe workflow', or 'expressive Result code'. Do NOT use workflow builders for tiny repository methods where `asyncAfter` or `.flatMap` is clearer."
 ---
 
 # Railway ergonomics in `@onrails/result`
@@ -16,7 +16,7 @@ The goal is expressive safe code without exposing plumbing at every composition
 Use the smallest layer that makes the code clear:
 
 1. **Low-level helpers** for small functions and library internals.
-   - Use `trySync`, `tryAsync`, `fromResult`, `asyncAfter`, `flatMapResult`, `.flatMap`, `.andThen`.
+   - Use `trySync`, `fromThrowable`, `tryAsync`, `fromResult`, `asyncAfter`, `flatMap`, `.flatMap`, `.andThen`.
    - Best for one or two steps, repository helpers, and package internals.
 
 2. **Fluent `Railway.*`** for service workflows.
@@ -25,7 +25,7 @@ Use the smallest layer that makes the code clear:
    - For steps shared across workflows, extract plain context functions and plug them in via `.fromResult` / `.fromAsync`.
 
 3. **Sync `tryGen`** for dense synchronous `Result` chains only.
-   - Use sparingly when no workflow builder is warranted and nested sync `flatMapResult` is hard to read.
+   - Use sparingly when no workflow builder is warranted and nested sync `flatMap` is hard to read.
    - Never use for `ResultAsync` or anything with `await`.
 
 ## Layer 1 — Low-Level Helpers
@@ -35,7 +35,7 @@ Use low-level helpers when the operation is small and direct.
 ```ts
 return asyncAfter(
   // Sync validation boundary. If Zod throws, map the thrown value to Error.
-  trySync(() => ArtifactSchema.parse(artifact), toError)(),
+  trySync(() => ArtifactSchema.parse(artifact), toError),
 
   // Async IO boundary. Promise rejection becomes Err(Error).
   (validated) =>
@@ -169,7 +169,7 @@ function loadProfileSummary(id: string): ResultAsync<ProfileSummary, Error> {
 Use fluent `Railway.*` when it removes manual bridges like:
 
 - `fromResult(...)`
-- nested `flatMapResult(...)`
+- nested `flatMap(...)`
 - positional tuple destructuring for parallel work
 - manual context-carrying objects after every step
 
@@ -212,7 +212,7 @@ Each step function is independently testable — call it with a hand-built conte
 Use it only when:
 
 - every step is sync
-- the function body has nested `flatMapResult` / `mapResult`
+- the function body has nested `flatMap` / `map`
 - a full `Railway.*` workflow would be overkill
 
 ```ts
@@ -342,7 +342,7 @@ Better:
 
 ```ts
 return asyncAfter(
-  trySync(() => ArtifactSchema.parse(artifact), toError)(),
+  trySync(() => ArtifactSchema.parse(artifact), toError),
   (validated) =>
     tryAsync(
       getDb()
@@ -375,14 +375,14 @@ Consider extracting reusable step functions when:
 Consider `tryGen` when:
 
 - all steps are sync
-- the current code is a nested `flatMapResult` tree
+- the current code is a nested `flatMap` tree
 - a workflow builder would introduce unnecessary named context
 
 Stay low-level when:
 
 - the function has one or two steps
 - the code is library internals
-- the operation is already readable with `asyncAfter`, `.flatMap`, or `mapResult`
+- the operation is already readable with `asyncAfter`, `.flatMap`, or `map`
 
 ## Maintainer Workflow For Case Studies