@wentools/result 0.1.2-beta.94ae1942

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wentools
+
+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 the following 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,146 @@
+# @wentools/result
+
+A TypeScript-first wrapper around [neverthrow](https://github.com/supermacro/neverthrow) that adds literal type inference and error composition patterns.
+
+## Why This Exists
+
+neverthrow is excellent for Result-based error handling, but creating typed errors requires boilerplate:
+
+```typescript
+// With plain neverthrow
+import { err } from 'neverthrow'
+
+// You need `as const` or explicit types to preserve the literal
+const result = err({ type: 'not_found' as const, message: 'User not found' })
+```
+
+This library fixes that with TypeScript 5.0+ const type parameters:
+
+```typescript
+// With @wentools/result
+import { err } from '@wentools/result'
+
+// Literal type is inferred automatically
+const result = err('not_found', 'User not found')
+// Type: Err<never, { type: 'not_found'; message: string }>
+```
+
+It also provides utilities for:
+- Defining error types concisely
+- Extracting and composing error types from functions
+- Runtime Result detection without importing neverthrow types
+
+## Install
+
+```bash
+# JSR (recommended)
+npx jsr add @wentools/result
+
+# Deno
+deno add jsr:@wentools/result
+```
+
+## Usage
+
+### Basic Error Creation
+
+```typescript
+import { err, ok, type Result, type ErrorType } from '@wentools/result'
+
+// Define error types concisely
+type UserNotFoundError = ErrorType<'user_not_found'>
+type InvalidEmailError = ErrorType<'invalid_email', { email: string }>
+
+// Create Results with inferred literal types
+const getUser = (id: string): Result<User, UserNotFoundError> => {
+  const user = users.get(id)
+  if (!user) {
+    return err('user_not_found', `User ${id} not found`)
+  }
+  return ok(user)
+}
+
+// Add context to errors
+const validateEmail = (email: string): Result<string, InvalidEmailError> => {
+  if (!email.includes('@')) {
+    return err('invalid_email', 'Email must contain @', { email })
+  }
+  return ok(email)
+}
+```
+
+### Async Chains
+
+```typescript
+import { errAsync, okAsync, type ResultAsync } from '@wentools/result'
+
+const createUser = (data: UserData): ResultAsync<User, CreateError> => {
+  return validateEmail(data.email)
+    .asyncAndThen((email) =>
+      checkEmailUnique(email)
+        .andThen(() => insertUser({ ...data, email }))
+    )
+}
+```
+
+### Error Type Composition
+
+```typescript
+import { type ExtractFnError } from '@wentools/result'
+
+// Extract and combine error types from multiple functions
+type ServiceError =
+  | ExtractFnError<typeof getUser>
+  | ExtractFnError<typeof validateEmail>
+  | ExtractFnError<typeof createUser>
+```
+
+### Runtime Type Check
+
+```typescript
+import { isResult } from '@wentools/result'
+
+const handle = (value: unknown) => {
+  if (isResult(value)) {
+    if (value.isErr()) {
+      console.error(value.error)
+    }
+  }
+}
+```
+
+## API
+
+### Functions
+
+| Function | Description |
+|----------|-------------|
+| `err(type, message, additional?)` | Create an Err with literal type inference |
+| `errAsync(type, message, additional?)` | Async version of `err` |
+| `ok(value)` | Create an Ok (re-export from neverthrow) |
+| `okAsync(value)` | Create an async Ok (re-export from neverthrow) |
+| `makeErr(type, message, additional?)` | Create error object without wrapping in Err |
+| `rawErr(error)` | Direct neverthrow `err()` for lifting unstructured errors |
+| `isResult(value)` | Runtime check if value is a Result |
+| `propagateErr(result)` | Propagate error to different Result type |
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `Result<T, E>` | Sync Result (from neverthrow) |
+| `ResultAsync<T, E>` | Async Result (from neverthrow) |
+| `ErrorType<Type, Additional?>` | Utility for defining `{ type, message, ...additional }` |
+| `ExtractError<T>` | Extract error type from Result or Promise<Result> |
+| `ExtractFnError<F>` | Extract error type from function return type |
+| `ExtractErrors<T[]>` | Union of errors from multiple Results |
+| `ExtractFnsError<F[]>` | Union of errors from multiple functions |
+
+## Requirements
+
+- TypeScript 5.0+ (for const type parameters)
+- neverthrow 8.x (peer dependency)
+
+## License
+
+MIT

package/esm/err/err.d.ts

@@ -0,0 +1,38 @@
+import { type Err } from 'neverthrow';
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const err: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => Err<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+export { err };
+//# sourceMappingURL=err.d.ts.map

package/esm/err/err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"err.d.ts","sourceRoot":"","sources":["../../src/err/err.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,GAAG,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAM,GAAG,GACR,KAAK,CAAC,KAAK,SAAS,MAAM,EAC1B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEnE,MAAM,KAAK,EACX,SAAS,MAAM,EACf,aAAa,WAAW,KACtB,GAAG,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,WAAW,CAKP,CAAA;AAErD,OAAO,EAAE,GAAG,EAAE,CAAA"}

package/esm/err/err.js

@@ -0,0 +1,38 @@
+import { err as _Err } from 'neverthrow';
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const err = (type, message, additional) => _Err({
+    ...additional,
+    type,
+    message,
+});
+export { err };

package/esm/err/mod.d.ts

@@ -0,0 +1,2 @@
+export { err } from './err.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/err/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/err/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA"}

package/esm/err/mod.js

@@ -0,0 +1 @@
+export { err } from './err.js';

package/esm/is_result/is_result.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+declare const isResult: (value: unknown) => value is {
+    isOk: () => boolean;
+    isErr: () => boolean;
+};
+export { isResult };
+//# sourceMappingURL=is_result.d.ts.map

package/esm/is_result/is_result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_result.d.ts","sourceRoot":"","sources":["../../src/is_result/is_result.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAA;CAStF,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/esm/is_result/is_result.js

@@ -0,0 +1,14 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+const isResult = (value) => {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'isOk' in value &&
+        'isErr' in value &&
+        typeof value.isOk === 'function' &&
+        typeof value.isErr === 'function');
+};
+export { isResult };

package/esm/is_result/mod.d.ts

@@ -0,0 +1,2 @@
+export { isResult } from './is_result.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/is_result/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/is_result/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/esm/is_result/mod.js

@@ -0,0 +1 @@
+export { isResult } from './is_result.js';

package/esm/mod.d.ts

@@ -0,0 +1,156 @@
+import { err as _Err, ok, type Result, type Err, ResultAsync, okAsync as neverthrowOkAsync } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+declare const makeErr: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const errAsync: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => ResultAsync<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+declare const okAsync: typeof neverthrowOkAsync;
+/**
+ * Utility type for defining error types concisely
+ *
+ * @example
+ * // Instead of:
+ * type UserNotFoundError = {
+ *   type: 'user_not_found'
+ *   message: string
+ *   userId: UserId
+ * }
+ *
+ * // Write:
+ * type UserNotFoundError = ErrorType<'user_not_found', { userId: UserId }>
+ *
+ * @example
+ * // Error without additional properties:
+ * type InvalidOperationError = ErrorType<'invalid_operation'>
+ */
+type ErrorType<TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>> = {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Extract the error type from a Result or Promise<Result>
+ *
+ * @example
+ * // From async function
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractError<ReturnType<typeof getUser>>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // From Result type directly
+ * type MyResult = Result<User, InvalidError>
+ * type MyError = ExtractError<MyResult>
+ * // Type: InvalidError
+ *
+ * @example
+ * // Works with composed errors
+ * const replaceVersion = async (): Promise<Result<Version, VersionNotFoundError | VersionExistsError>> => { ... }
+ * type ReplaceError = ExtractError<ReturnType<typeof replaceVersion>>
+ * // Type: VersionNotFoundError | VersionExistsError
+ */
+type ExtractError<TResultOrPromise> = TResultOrPromise extends Promise<Result<unknown, infer TError>> ? TError : TResultOrPromise extends Result<unknown, infer TError> ? TError : never;
+/**
+ * Extract the error type from a function that returns Result or Promise<Result>
+ *
+ * @example
+ * // Simple extraction
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractFnError<typeof getUser>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // Compose errors from multiple functions
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * type CombinedError = ExtractFnError<typeof getUser> | ExtractFnError<typeof getImage>
+ * // Type: UserNotFoundError | ImageNotFoundError
+ */
+type ExtractFnError<TFunction extends (...args: unknown[]) => unknown> = ExtractError<ReturnType<TFunction>>;
+/**
+ * Extract and combine error types from multiple Result or Promise<Result> types
+ *
+ * @example
+ * type UserResult = Result<User, UserNotFoundError>
+ * type ImageResult = Promise<Result<Image, ImageNotFoundError>>
+ * type ProductResult = Result<Product, ProductNotFoundError>
+ *
+ * type CombinedError = ExtractErrors<[UserResult, ImageResult, ProductResult]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractErrors<TResults extends readonly unknown[]> = TResults extends readonly [
+    infer TFirst,
+    ...infer TRest
+] ? ExtractError<TFirst> | ExtractErrors<TRest> : never;
+/**
+ * Extract and combine error types from multiple functions that return Result or Promise<Result>
+ *
+ * @example
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * const deleteProduct = async (id: string): Promise<Result<void, ProductNotFoundError>> => { ... }
+ *
+ * type CombinedError = ExtractFnsError<[typeof getUser, typeof getImage, typeof deleteProduct]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractFnsError<TFunctions extends readonly ((...args: unknown[]) => unknown)[]> = TFunctions extends readonly [
+    infer TFirst,
+    ...infer TRest extends readonly ((...args: unknown[]) => unknown)[]
+] ? ExtractFnError<TFirst & ((...args: unknown[]) => unknown)> | ExtractFnsError<TRest> : never;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+declare const rawErr: typeof _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export type { Result, Err, ErrorType, ExtractError, ExtractFnError, ExtractErrors, ExtractFnsError };
+export { err } from './err/mod.js';
+export { isResult } from './is_result/mod.js';
+export { propagateErr } from './propagate_err/mod.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"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"}

package/esm/mod.js

@@ -0,0 +1,65 @@
+import { err as _Err, ok, ResultAsync, errAsync as neverthrowErrAsync, okAsync as neverthrowOkAsync, } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+const makeErr = (type, message, additional) => ({
+    ...additional,
+    type,
+    message,
+});
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const errAsync = (type, message, additional) => neverthrowErrAsync({
+    ...additional,
+    type,
+    message,
+});
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+const okAsync = neverthrowOkAsync;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+const rawErr = _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export { err } from './err/mod.js';
+export { isResult } from './is_result/mod.js';
+export { propagateErr } from './propagate_err/mod.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/propagate_err/mod.d.ts

@@ -0,0 +1,2 @@
+export { propagateErr } from './propagate_err.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/propagate_err/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/propagate_err/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/esm/propagate_err/mod.js

@@ -0,0 +1 @@
+export { propagateErr } from './propagate_err.js';

package/esm/propagate_err/propagate_err.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from 'neverthrow';
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+declare const propagateErr: <TNew, E>(errorResult: Result<unknown, E>) => Result<TNew, E>;
+export { propagateErr };
+//# sourceMappingURL=propagate_err.d.ts.map

package/esm/propagate_err/propagate_err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate_err.d.ts","sourceRoot":"","sources":["../../src/propagate_err/propagate_err.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,YAAY,GAAI,IAAI,EAAE,CAAC,EAAE,aAAa,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAI9E,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/esm/propagate_err/propagate_err.js

@@ -0,0 +1,30 @@
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+const propagateErr = (errorResult) => {
+    // Type assertion is safe: we're only propagating errors, and error Results
+    // don't contain the success value. The error type E is preserved exactly.
+    return errorResult;
+};
+export { propagateErr };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@wentools/result",
+  "version": "0.1.2-beta.94ae1942",
+  "description": "TypeScript-first Result type with literal error inference",
+  "keywords": [
+    "result",
+    "neverthrow",
+    "typescript",
+    "error-handling",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/wentools/result"
+  },
+  "license": "MIT",
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "neverthrow": "^8.2.0"
+  },
+  "peerDependencies": {
+    "neverthrow": "^8.2.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/err/err.d.ts

@@ -0,0 +1,38 @@
+import { type Err } from 'neverthrow';
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const err: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => Err<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+export { err };
+//# sourceMappingURL=err.d.ts.map

package/script/err/err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"err.d.ts","sourceRoot":"","sources":["../../src/err/err.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,GAAG,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAM,GAAG,GACR,KAAK,CAAC,KAAK,SAAS,MAAM,EAC1B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEnE,MAAM,KAAK,EACX,SAAS,MAAM,EACf,aAAa,WAAW,KACtB,GAAG,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,WAAW,CAKP,CAAA;AAErD,OAAO,EAAE,GAAG,EAAE,CAAA"}

package/script/err/err.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = void 0;
+const neverthrow_1 = require("neverthrow");
+/**
+ * Create an Err Result with automatic literal type preservation
+ *
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ * No need for 'as const' - the type parameter is inferred as a literal!
+ *
+ * Returns Err<never, E> (not Result<never, E>) so .error is directly accessible.
+ *
+ * @example
+ * // ✅ Simple error
+ * return err('not_found', 'User not found')
+ * // Type: Err<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return err('not_found', 'User not found', { userId: '123' })
+ * // Type: Err<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Direct .error access (no narrowing needed)
+ * const error = err('not_found', 'User not found').error
+ * // error.type is 'not_found'
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return err('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: Err<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const err = (type, message, additional) => (0, neverthrow_1.err)({
+    ...additional,
+    type,
+    message,
+});
+exports.err = err;

package/script/err/mod.d.ts

@@ -0,0 +1,2 @@
+export { err } from './err.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/err/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/err/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA"}

package/script/err/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = void 0;
+var err_js_1 = require("./err.js");
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return err_js_1.err; } });

package/script/is_result/is_result.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+declare const isResult: (value: unknown) => value is {
+    isOk: () => boolean;
+    isErr: () => boolean;
+};
+export { isResult };
+//# sourceMappingURL=is_result.d.ts.map

package/script/is_result/is_result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_result.d.ts","sourceRoot":"","sources":["../../src/is_result/is_result.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAA;CAStF,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/script/is_result/is_result.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResult = void 0;
+const isResult = (value) => {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'isOk' in value &&
+        'isErr' in value &&
+        typeof value.isOk === 'function' &&
+        typeof value.isErr === 'function');
+};
+exports.isResult = isResult;

package/script/is_result/mod.d.ts

@@ -0,0 +1,2 @@
+export { isResult } from './is_result.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/is_result/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/is_result/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/script/is_result/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResult = void 0;
+var is_result_js_1 = require("./is_result.js");
+Object.defineProperty(exports, "isResult", { enumerable: true, get: function () { return is_result_js_1.isResult; } });

package/script/mod.d.ts

@@ -0,0 +1,156 @@
+import { err as _Err, ok, type Result, type Err, ResultAsync, okAsync as neverthrowOkAsync } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+declare const makeErr: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const errAsync: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => ResultAsync<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+declare const okAsync: typeof neverthrowOkAsync;
+/**
+ * Utility type for defining error types concisely
+ *
+ * @example
+ * // Instead of:
+ * type UserNotFoundError = {
+ *   type: 'user_not_found'
+ *   message: string
+ *   userId: UserId
+ * }
+ *
+ * // Write:
+ * type UserNotFoundError = ErrorType<'user_not_found', { userId: UserId }>
+ *
+ * @example
+ * // Error without additional properties:
+ * type InvalidOperationError = ErrorType<'invalid_operation'>
+ */
+type ErrorType<TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>> = {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Extract the error type from a Result or Promise<Result>
+ *
+ * @example
+ * // From async function
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractError<ReturnType<typeof getUser>>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // From Result type directly
+ * type MyResult = Result<User, InvalidError>
+ * type MyError = ExtractError<MyResult>
+ * // Type: InvalidError
+ *
+ * @example
+ * // Works with composed errors
+ * const replaceVersion = async (): Promise<Result<Version, VersionNotFoundError | VersionExistsError>> => { ... }
+ * type ReplaceError = ExtractError<ReturnType<typeof replaceVersion>>
+ * // Type: VersionNotFoundError | VersionExistsError
+ */
+type ExtractError<TResultOrPromise> = TResultOrPromise extends Promise<Result<unknown, infer TError>> ? TError : TResultOrPromise extends Result<unknown, infer TError> ? TError : never;
+/**
+ * Extract the error type from a function that returns Result or Promise<Result>
+ *
+ * @example
+ * // Simple extraction
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractFnError<typeof getUser>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // Compose errors from multiple functions
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * type CombinedError = ExtractFnError<typeof getUser> | ExtractFnError<typeof getImage>
+ * // Type: UserNotFoundError | ImageNotFoundError
+ */
+type ExtractFnError<TFunction extends (...args: unknown[]) => unknown> = ExtractError<ReturnType<TFunction>>;
+/**
+ * Extract and combine error types from multiple Result or Promise<Result> types
+ *
+ * @example
+ * type UserResult = Result<User, UserNotFoundError>
+ * type ImageResult = Promise<Result<Image, ImageNotFoundError>>
+ * type ProductResult = Result<Product, ProductNotFoundError>
+ *
+ * type CombinedError = ExtractErrors<[UserResult, ImageResult, ProductResult]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractErrors<TResults extends readonly unknown[]> = TResults extends readonly [
+    infer TFirst,
+    ...infer TRest
+] ? ExtractError<TFirst> | ExtractErrors<TRest> : never;
+/**
+ * Extract and combine error types from multiple functions that return Result or Promise<Result>
+ *
+ * @example
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * const deleteProduct = async (id: string): Promise<Result<void, ProductNotFoundError>> => { ... }
+ *
+ * type CombinedError = ExtractFnsError<[typeof getUser, typeof getImage, typeof deleteProduct]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractFnsError<TFunctions extends readonly ((...args: unknown[]) => unknown)[]> = TFunctions extends readonly [
+    infer TFirst,
+    ...infer TRest extends readonly ((...args: unknown[]) => unknown)[]
+] ? ExtractFnError<TFirst & ((...args: unknown[]) => unknown)> | ExtractFnsError<TRest> : never;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+declare const rawErr: typeof _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export type { Result, Err, ErrorType, ExtractError, ExtractFnError, ExtractErrors, ExtractFnsError };
+export { err } from './err/mod.js';
+export { isResult } from './is_result/mod.js';
+export { propagateErr } from './propagate_err/mod.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"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"}

package/script/mod.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = exports.isResult = exports.err = exports.ResultAsync = exports._Err = exports.rawErr = exports.okAsync = exports.ok = exports.errAsync = exports.makeErr = void 0;
+const neverthrow_1 = require("neverthrow");
+Object.defineProperty(exports, "_Err", { enumerable: true, get: function () { return neverthrow_1.err; } });
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return neverthrow_1.ok; } });
+Object.defineProperty(exports, "ResultAsync", { enumerable: true, get: function () { return neverthrow_1.ResultAsync; } });
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+const makeErr = (type, message, additional) => ({
+    ...additional,
+    type,
+    message,
+});
+exports.makeErr = makeErr;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const errAsync = (type, message, additional) => (0, neverthrow_1.errAsync)({
+    ...additional,
+    type,
+    message,
+});
+exports.errAsync = errAsync;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+const okAsync = neverthrow_1.okAsync;
+exports.okAsync = okAsync;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+const rawErr = neverthrow_1.err;
+exports.rawErr = rawErr;
+var mod_js_1 = require("./err/mod.js");
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return mod_js_1.err; } });
+var mod_js_2 = require("./is_result/mod.js");
+Object.defineProperty(exports, "isResult", { enumerable: true, get: function () { return mod_js_2.isResult; } });
+var mod_js_3 = require("./propagate_err/mod.js");
+Object.defineProperty(exports, "propagateErr", { enumerable: true, get: function () { return mod_js_3.propagateErr; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/propagate_err/mod.d.ts

@@ -0,0 +1,2 @@
+export { propagateErr } from './propagate_err.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/propagate_err/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/propagate_err/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/script/propagate_err/mod.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = void 0;
+var propagate_err_js_1 = require("./propagate_err.js");
+Object.defineProperty(exports, "propagateErr", { enumerable: true, get: function () { return propagate_err_js_1.propagateErr; } });

package/script/propagate_err/propagate_err.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from 'neverthrow';
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+declare const propagateErr: <TNew, E>(errorResult: Result<unknown, E>) => Result<TNew, E>;
+export { propagateErr };
+//# sourceMappingURL=propagate_err.d.ts.map

package/script/propagate_err/propagate_err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate_err.d.ts","sourceRoot":"","sources":["../../src/propagate_err/propagate_err.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,YAAY,GAAI,IAAI,EAAE,CAAC,EAAE,aAAa,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAI9E,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/script/propagate_err/propagate_err.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateErr = void 0;
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+const propagateErr = (errorResult) => {
+    // Type assertion is safe: we're only propagating errors, and error Results
+    // don't contain the success value. The error type E is preserved exactly.
+    return errorResult;
+};
+exports.propagateErr = propagateErr;