@praha/byethrow 0.6.3 → 0.7.1

package/dist/cjs/exports.d.ts

@@ -1,23 +1,23 @@
-export * from './result';
-export * from './functions/and-then';
-export * from './functions/and-through';
-export * from './functions/assert-failure';
-export * from './functions/assert-success';
-export * from './functions/bind';
-export * from './functions/combine';
-export * from './functions/do';
-export * from './functions/fail';
-export * from './functions/inspect';
-export * from './functions/inspect-error';
-export * from './functions/is-failure';
-export * from './functions/is-result';
-export * from './functions/is-success';
-export * from './functions/map';
-export * from './functions/map-error';
-export * from './functions/or-else';
-export * from './functions/parse';
-export * from './functions/pipe';
-export * from './functions/succeed';
-export * from './functions/try';
-export * from './functions/unwrap';
-export * from './functions/unwrap-error';
+export * from './result.js';
+export * from './functions/and-then.js';
+export * from './functions/and-through.js';
+export * from './functions/assert-failure.js';
+export * from './functions/assert-success.js';
+export * from './functions/bind.js';
+export * from './functions/combine.js';
+export * from './functions/do.js';
+export * from './functions/fail.js';
+export * from './functions/inspect.js';
+export * from './functions/inspect-error.js';
+export * from './functions/is-failure.js';
+export * from './functions/is-result.js';
+export * from './functions/is-success.js';
+export * from './functions/map.js';
+export * from './functions/map-error.js';
+export * from './functions/or-else.js';
+export * from './functions/parse.js';
+export * from './functions/pipe.js';
+export * from './functions/succeed.js';
+export * from './functions/try.js';
+export * from './functions/unwrap.js';
+export * from './functions/unwrap-error.js';

package/dist/cjs/functions/and-then.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains the next computation using the success value of a {@link Result} or {@link ResultAsync}.
  * If the original result is a {@link Failure}, it is returned unchanged.
@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (input is a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('error'),
  *   Result.andThen((x) => Result.succeed(x * 2)),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.succeed(3),
  *   Result.andThen((x) => Result.fail('error: ' + x)),

package/dist/cjs/functions/and-through.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Runs an additional computation using the success value of a {@link Result} or {@link ResultAsync},
  * but **returns the original result** if the additional computation is successful.
@@ -28,7 +28,7 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.pipe(
- *   Result.fail('error),
+ *   Result.fail('error'),
  *   Result.andThrough((x) => {
  *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
  *   }),

package/dist/cjs/functions/assert-failure.d.ts

@@ -1,4 +1,4 @@
-import type { Failure, InferFailure, Result, ResultAsync } from '../result';
+import type { Failure, InferFailure, Result, ResultAsync } from '../result.js';
 /**
  * Asserts that a {@link Result} or {@link ResultAsync} is a {@link Failure} and returns it.
  * If the result is a {@link Success}, throws an error.
@@ -13,16 +13,17 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * const failure = Result.assertFailure(result);
  * // failure: { type: 'Failure', error: 'error' }
  * ```
  *
  * @example Throws on Success
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * Result.assertFailure(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.fail('error');
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.andThen(() => Result.fail('die')),
  *   Result.assertFailure,
  *   Result.unwrapError(), // Safe unwrap after assertion

package/dist/cjs/functions/assert-success.d.ts

@@ -1,4 +1,4 @@
-import type { InferSuccess, Result, ResultAsync, Success } from '../result';
+import type { InferSuccess, Result, ResultAsync, Success } from '../result.js';
 /**
  * Asserts that a {@link Result} or {@link ResultAsync} is a {@link Success} and returns it.
  * If the result is a {@link Failure}, throws an error.
@@ -13,16 +13,17 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * const success = Result.assertSuccess(result);
  * // success: { type: 'Success', value: 42 }
  * ```
  *
  * @example Throws on Failure
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * Result.assertSuccess(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<string, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.succeed(42);
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.orElse(() => Result.succeed('fallback')),
  *   Result.assertSuccess,
  *   Result.unwrap(), // Safe unwrap after assertion

package/dist/cjs/functions/bind.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains another {@link Result}-producing computation and **merges its success value**
  * into the existing object under the specified key.

package/dist/cjs/functions/combine.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Combines multiple {@link Result} or {@link ResultAsync} values into a single result.
  * If all inputs are {@link Success}, returns a {@link Success} with combined values.

package/dist/cjs/functions/do.d.ts

@@ -13,5 +13,5 @@
  *
  * @category Creators
  */
-declare const do_: () => import("../result").Result<{}, never>;
+declare const do_: () => import("../result.js").Result<{}, never>;
 export { do_ as do };

package/dist/cjs/functions/fail.d.ts

@@ -1,4 +1,4 @@
-import type { ResultFor } from '../result';
+import type { ResultFor } from '../result.js';
 /**
  * Creates a {@link Failure} result from a given error.
  * Automatically wraps the error in a `Promise` if it is asynchronous.

package/dist/cjs/functions/inspect-error.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, ResultMaybeAsync } from '../result';
+import type { InferFailure, ResultMaybeAsync } from '../result.js';
 /**
  * Executes a side effect function on the error value of a {@link Result} or {@link ResultAsync},
  * without modifying the original result. This is useful for debugging, logging, or performing

package/dist/cjs/functions/inspect.d.ts

@@ -1,4 +1,4 @@
-import type { InferSuccess, ResultMaybeAsync } from '../result';
+import type { InferSuccess, ResultMaybeAsync } from '../result.js';
 /**
  * Executes a side effect function on the success value of a {@link Result} or {@link ResultAsync},
  * without modifying the original result. This is useful for debugging, logging, or performing

package/dist/cjs/functions/is-failure.d.ts

@@ -1,4 +1,4 @@
-import type { Failure, Result } from '../result';
+import type { Failure, Result } from '../result.js';
 /**
  * Type guard to check if a {@link Result} is a {@link Failure}.
  *

package/dist/cjs/functions/is-result.d.ts

@@ -1,4 +1,4 @@
-import type { Result } from '../result';
+import type { Result } from '../result.js';
 /**
  * Type guard to check if a value is a {@link Result}.
  *

package/dist/cjs/functions/is-success.d.ts

@@ -1,4 +1,4 @@
-import type { Result, Success } from '../result';
+import type { Result, Success } from '../result.js';
 /**
  * Type guard to check if a {@link Result} is a {@link Success}.
  *

package/dist/cjs/functions/map-error.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Applies a transformation function to the error value of a {@link Result} or {@link ResultAsync}.
  * If the input is a {@link Success}, it will be returned unchanged.

package/dist/cjs/functions/map.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Applies a transformation function to the success value of a {@link Result} or {@link ResultAsync}.
  * If the input is a {@link Failure}, it will be returned unchanged.

package/dist/cjs/functions/or-else.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains the next computation using the error value of a {@link Result} or {@link ResultAsync}.
  * If the original result is a {@link Success}, it is returned unchanged.
@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Success)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.succeed('default value')),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.fail('new error: ' + error)),

package/dist/cjs/functions/parse.d.ts

@@ -1,4 +1,4 @@
-import type { Result } from '../result';
+import type { Result } from '../result.js';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 /**
  * Parses a value using a {@link https://github.com/standard-schema/standard-schema Standard Schema} compatible schema.

package/dist/cjs/functions/succeed.d.ts

@@ -1,4 +1,4 @@
-import type { ResultFor } from '../result';
+import type { ResultFor } from '../result.js';
 /**
  * Creates a {@link Success} result from a given value.
  * Automatically wraps the value in a `Promise` if it is asynchronous.

package/dist/cjs/functions/try.cjs

@@ -30,11 +30,7 @@ const external_fail_cjs_namespaceObject = require("./fail.cjs");
 const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
 const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
 const try_ = (options)=>{
-    if ((0, is_promise_cjs_namespaceObject.isPromise)(options.try)) {
-        if ('safe' in options && options.safe) return (0, external_succeed_cjs_namespaceObject.succeed)(options.try);
-        return options.try.then((value)=>(0, external_succeed_cjs_namespaceObject.succeed)(value), (error)=>(0, external_fail_cjs_namespaceObject.fail)(options.catch(error)));
-    }
-    return (...args)=>{
+    const fn = (...args)=>{
         try {
             const output = options.try(...args);
             if ((0, is_promise_cjs_namespaceObject.isPromise)(output)) {
@@ -48,6 +44,8 @@ const try_ = (options)=>{
             return (0, external_fail_cjs_namespaceObject.fail)(options.catch(error));
         }
     };
+    if ('immediate' in options && options.immediate) return fn();
+    return fn;
 };
 exports["try"] = __webpack_exports__["try"];
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [

package/dist/cjs/functions/try.d.ts

@@ -1,4 +1,4 @@
-import type { Result, ResultAsync } from '../result';
+import type { Result, ResultAsync } from '../result.js';
 /**
  * Wraps a function execution (sync or async) or a Promise in a {@link Result} or {@link ResultAsync} type,
  * capturing errors and returning them in a structured way.
@@ -10,58 +10,64 @@ import type { Result, ResultAsync } from '../result';
  * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
- * @example Promise Try-Catch
+ * @example Sync try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result = Result.try({
- *   try: fetch('/api/data'),
- *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * const fn = Result.try({
+ *   try: (x: number) => {
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<Response, Error>
+ * const result = fn(5); // Result.Result<number, Error>
  * ```
  *
- * @example Promise Safe
+ * @example Sync try-catch with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.try({
- *   safe: true,
- *   try: Promise.resolve('ok'),
+ *   immediate: true,
+ *   try: () => {
+ *     const x = Math.random() * 10 - 5;
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<string, never>
+ * // result is Result<number, Error>
  * ```
  *
- * @example Sync Try-Catch
+ * @example Sync safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const fn = Result.try({
- *   try: (x: number) => {
- *     if (x < 0) throw new Error('Negative!');
- *     return x * 2;
- *   },
- *   catch: (error) => new Error('Oops!', { cause: error }),
+ *   safe: true,
+ *   try: (x: number) => x + 1,
  * });
  *
- * const result = fn(5); // Result.Result<number, Error>
+ * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Sync Safe
+ * @example Sync safe with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const fn = Result.try({
+ * const result = Result.try({
  *   safe: true,
- *   try: (x: number) => x + 1,
+ *   immediate: true,
+ *   try: () => Math.random() + 1,
  * });
  *
- * const result = fn(1); // Result.Result<number, never>
+ * // result is Result<number, never>
  * ```
  *
- * @example Async Function Try-Catch
+ * @example Async try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -73,7 +79,20 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Function Safe
+ * @example Async try-catch with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   immediate: true,
+ *   try: () => fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Async safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -85,32 +104,57 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn(); // Result.ResultAsync<string, never>
  * ```
  *
+ * @example Async safe with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   immediate: true,
+ *   try: () => Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @category Creators
  */
 declare const try_: {
-    <T extends Promise<any>, E>(options: {
-        try: T;
-        catch: (error: unknown) => E;
-    }): ResultAsync<Awaited<T>, E>;
-    <T extends Promise<any>>(options: {
-        try: T;
-        safe: true;
-    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, E>;
-    <T extends (...args: readonly any[]) => Promise<any>>(options: {
+    <T extends () => Promise<any>, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<ReturnType<T>>, E>;
+    <T extends (...args: readonly any[]) => Promise<any>>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, never>;
+    <T extends () => Promise<any>>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): ResultAsync<Awaited<ReturnType<T>>, never>;
     <T extends (...args: readonly any[]) => any, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, E>;
-    <T extends (...args: readonly any[]) => any>(options: {
+    <T extends () => any, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): Result<ReturnType<T>, E>;
+    <T extends (...args: readonly any[]) => any>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, never>;
+    <T extends () => any>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): Result<ReturnType<T>, never>;
 };
 export { try_ as try };

package/dist/cjs/functions/unwrap-error.d.ts

@@ -1,5 +1,5 @@
-import type { HasPromise } from '../internals/types/has-promise';
-import type { InferFailure, ResultMaybeAsync } from '../result';
+import type { HasPromise } from '../internals/types/has-promise.js';
+import type { InferFailure, ResultMaybeAsync } from '../result.js';
 /**
  * Extracts the error value from a {@link Result} or {@link ResultAsync}.
  *

package/dist/cjs/functions/unwrap.d.ts

@@ -1,5 +1,5 @@
-import type { HasPromise } from '../internals/types/has-promise';
-import type { InferSuccess, ResultMaybeAsync } from '../result';
+import type { HasPromise } from '../internals/types/has-promise.js';
+import type { InferSuccess, ResultMaybeAsync } from '../result.js';
 /**
  * Extracts the success value from a {@link Result} or {@link ResultAsync}.
  *

package/dist/cjs/index.d.ts

@@ -62,8 +62,8 @@
  * }
  * ```
  */
-export * as Result from './exports';
+export * as Result from './exports.js';
 /**
  * Shorthand alias for {@link Result}.
  */
-export * as R from './exports';
+export * as R from './exports.js';

package/dist/cjs/result.d.ts

@@ -1,4 +1,4 @@
-import type { HasPromise } from './internals/types/has-promise';
+import type { HasPromise } from './internals/types/has-promise.js';
 /**
  * Represents a successful result.
  *

package/dist/esm/exports.d.ts

@@ -1,23 +1,23 @@
-export * from './result';
-export * from './functions/and-then';
-export * from './functions/and-through';
-export * from './functions/assert-failure';
-export * from './functions/assert-success';
-export * from './functions/bind';
-export * from './functions/combine';
-export * from './functions/do';
-export * from './functions/fail';
-export * from './functions/inspect';
-export * from './functions/inspect-error';
-export * from './functions/is-failure';
-export * from './functions/is-result';
-export * from './functions/is-success';
-export * from './functions/map';
-export * from './functions/map-error';
-export * from './functions/or-else';
-export * from './functions/parse';
-export * from './functions/pipe';
-export * from './functions/succeed';
-export * from './functions/try';
-export * from './functions/unwrap';
-export * from './functions/unwrap-error';
+export * from './result.js';
+export * from './functions/and-then.js';
+export * from './functions/and-through.js';
+export * from './functions/assert-failure.js';
+export * from './functions/assert-success.js';
+export * from './functions/bind.js';
+export * from './functions/combine.js';
+export * from './functions/do.js';
+export * from './functions/fail.js';
+export * from './functions/inspect.js';
+export * from './functions/inspect-error.js';
+export * from './functions/is-failure.js';
+export * from './functions/is-result.js';
+export * from './functions/is-success.js';
+export * from './functions/map.js';
+export * from './functions/map-error.js';
+export * from './functions/or-else.js';
+export * from './functions/parse.js';
+export * from './functions/pipe.js';
+export * from './functions/succeed.js';
+export * from './functions/try.js';
+export * from './functions/unwrap.js';
+export * from './functions/unwrap-error.js';

package/dist/esm/functions/and-then.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains the next computation using the success value of a {@link Result} or {@link ResultAsync}.
  * If the original result is a {@link Failure}, it is returned unchanged.
@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (input is a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('error'),
  *   Result.andThen((x) => Result.succeed(x * 2)),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.succeed(3),
  *   Result.andThen((x) => Result.fail('error: ' + x)),

package/dist/esm/functions/and-through.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Runs an additional computation using the success value of a {@link Result} or {@link ResultAsync},
  * but **returns the original result** if the additional computation is successful.
@@ -28,7 +28,7 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.pipe(
- *   Result.fail('error),
+ *   Result.fail('error'),
  *   Result.andThrough((x) => {
  *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
  *   }),

package/dist/esm/functions/assert-failure.d.ts

@@ -1,4 +1,4 @@
-import type { Failure, InferFailure, Result, ResultAsync } from '../result';
+import type { Failure, InferFailure, Result, ResultAsync } from '../result.js';
 /**
  * Asserts that a {@link Result} or {@link ResultAsync} is a {@link Failure} and returns it.
  * If the result is a {@link Success}, throws an error.
@@ -13,16 +13,17 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * const failure = Result.assertFailure(result);
  * // failure: { type: 'Failure', error: 'error' }
  * ```
  *
  * @example Throws on Success
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * Result.assertFailure(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.fail('error');
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.andThen(() => Result.fail('die')),
  *   Result.assertFailure,
  *   Result.unwrapError(), // Safe unwrap after assertion

package/dist/esm/functions/assert-success.d.ts

@@ -1,4 +1,4 @@
-import type { InferSuccess, Result, ResultAsync, Success } from '../result';
+import type { InferSuccess, Result, ResultAsync, Success } from '../result.js';
 /**
  * Asserts that a {@link Result} or {@link ResultAsync} is a {@link Success} and returns it.
  * If the result is a {@link Failure}, throws an error.
@@ -13,16 +13,17 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * const success = Result.assertSuccess(result);
  * // success: { type: 'Success', value: 42 }
  * ```
  *
  * @example Throws on Failure
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * Result.assertSuccess(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<string, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.succeed(42);
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.orElse(() => Result.succeed('fallback')),
  *   Result.assertSuccess,
  *   Result.unwrap(), // Safe unwrap after assertion

package/dist/esm/functions/bind.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains another {@link Result}-producing computation and **merges its success value**
  * into the existing object under the specified key.

package/dist/esm/functions/combine.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Combines multiple {@link Result} or {@link ResultAsync} values into a single result.
  * If all inputs are {@link Success}, returns a {@link Success} with combined values.

package/dist/esm/functions/do.d.ts

@@ -13,5 +13,5 @@
  *
  * @category Creators
  */
-declare const do_: () => import("../result").Result<{}, never>;
+declare const do_: () => import("../result.js").Result<{}, never>;
 export { do_ as do };

package/dist/esm/functions/fail.d.ts

@@ -1,4 +1,4 @@
-import type { ResultFor } from '../result';
+import type { ResultFor } from '../result.js';
 /**
  * Creates a {@link Failure} result from a given error.
  * Automatically wraps the error in a `Promise` if it is asynchronous.

package/dist/esm/functions/inspect-error.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, ResultMaybeAsync } from '../result';
+import type { InferFailure, ResultMaybeAsync } from '../result.js';
 /**
  * Executes a side effect function on the error value of a {@link Result} or {@link ResultAsync},
  * without modifying the original result. This is useful for debugging, logging, or performing

package/dist/esm/functions/inspect.d.ts

@@ -1,4 +1,4 @@
-import type { InferSuccess, ResultMaybeAsync } from '../result';
+import type { InferSuccess, ResultMaybeAsync } from '../result.js';
 /**
  * Executes a side effect function on the success value of a {@link Result} or {@link ResultAsync},
  * without modifying the original result. This is useful for debugging, logging, or performing

package/dist/esm/functions/is-failure.d.ts

@@ -1,4 +1,4 @@
-import type { Failure, Result } from '../result';
+import type { Failure, Result } from '../result.js';
 /**
  * Type guard to check if a {@link Result} is a {@link Failure}.
  *

package/dist/esm/functions/is-result.d.ts

@@ -1,4 +1,4 @@
-import type { Result } from '../result';
+import type { Result } from '../result.js';
 /**
  * Type guard to check if a value is a {@link Result}.
  *

package/dist/esm/functions/is-success.d.ts

@@ -1,4 +1,4 @@
-import type { Result, Success } from '../result';
+import type { Result, Success } from '../result.js';
 /**
  * Type guard to check if a {@link Result} is a {@link Success}.
  *

package/dist/esm/functions/map-error.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Applies a transformation function to the error value of a {@link Result} or {@link ResultAsync}.
  * If the input is a {@link Success}, it will be returned unchanged.

package/dist/esm/functions/map.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Applies a transformation function to the success value of a {@link Result} or {@link ResultAsync}.
  * If the input is a {@link Failure}, it will be returned unchanged.

package/dist/esm/functions/or-else.d.ts

@@ -1,4 +1,4 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
 /**
  * Chains the next computation using the error value of a {@link Result} or {@link ResultAsync}.
  * If the original result is a {@link Success}, it is returned unchanged.
@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Success)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.succeed('default value')),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.fail('new error: ' + error)),

package/dist/esm/functions/parse.d.ts

@@ -1,4 +1,4 @@
-import type { Result } from '../result';
+import type { Result } from '../result.js';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 /**
  * Parses a value using a {@link https://github.com/standard-schema/standard-schema Standard Schema} compatible schema.

package/dist/esm/functions/succeed.d.ts

@@ -1,4 +1,4 @@
-import type { ResultFor } from '../result';
+import type { ResultFor } from '../result.js';
 /**
  * Creates a {@link Success} result from a given value.
  * Automatically wraps the value in a `Promise` if it is asynchronous.

package/dist/esm/functions/try.d.ts

@@ -1,4 +1,4 @@
-import type { Result, ResultAsync } from '../result';
+import type { Result, ResultAsync } from '../result.js';
 /**
  * Wraps a function execution (sync or async) or a Promise in a {@link Result} or {@link ResultAsync} type,
  * capturing errors and returning them in a structured way.
@@ -10,58 +10,64 @@ import type { Result, ResultAsync } from '../result';
  * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
- * @example Promise Try-Catch
+ * @example Sync try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result = Result.try({
- *   try: fetch('/api/data'),
- *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * const fn = Result.try({
+ *   try: (x: number) => {
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<Response, Error>
+ * const result = fn(5); // Result.Result<number, Error>
  * ```
  *
- * @example Promise Safe
+ * @example Sync try-catch with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.try({
- *   safe: true,
- *   try: Promise.resolve('ok'),
+ *   immediate: true,
+ *   try: () => {
+ *     const x = Math.random() * 10 - 5;
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<string, never>
+ * // result is Result<number, Error>
  * ```
  *
- * @example Sync Try-Catch
+ * @example Sync safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const fn = Result.try({
- *   try: (x: number) => {
- *     if (x < 0) throw new Error('Negative!');
- *     return x * 2;
- *   },
- *   catch: (error) => new Error('Oops!', { cause: error }),
+ *   safe: true,
+ *   try: (x: number) => x + 1,
  * });
  *
- * const result = fn(5); // Result.Result<number, Error>
+ * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Sync Safe
+ * @example Sync safe with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const fn = Result.try({
+ * const result = Result.try({
  *   safe: true,
- *   try: (x: number) => x + 1,
+ *   immediate: true,
+ *   try: () => Math.random() + 1,
  * });
  *
- * const result = fn(1); // Result.Result<number, never>
+ * // result is Result<number, never>
  * ```
  *
- * @example Async Function Try-Catch
+ * @example Async try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -73,7 +79,20 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Function Safe
+ * @example Async try-catch with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   immediate: true,
+ *   try: () => fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Async safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -85,32 +104,57 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn(); // Result.ResultAsync<string, never>
  * ```
  *
+ * @example Async safe with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   immediate: true,
+ *   try: () => Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @category Creators
  */
 declare const try_: {
-    <T extends Promise<any>, E>(options: {
-        try: T;
-        catch: (error: unknown) => E;
-    }): ResultAsync<Awaited<T>, E>;
-    <T extends Promise<any>>(options: {
-        try: T;
-        safe: true;
-    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, E>;
-    <T extends (...args: readonly any[]) => Promise<any>>(options: {
+    <T extends () => Promise<any>, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<ReturnType<T>>, E>;
+    <T extends (...args: readonly any[]) => Promise<any>>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, never>;
+    <T extends () => Promise<any>>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): ResultAsync<Awaited<ReturnType<T>>, never>;
     <T extends (...args: readonly any[]) => any, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, E>;
-    <T extends (...args: readonly any[]) => any>(options: {
+    <T extends () => any, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): Result<ReturnType<T>, E>;
+    <T extends (...args: readonly any[]) => any>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, never>;
+    <T extends () => any>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): Result<ReturnType<T>, never>;
 };
 export { try_ as try };

package/dist/esm/functions/try.js

@@ -2,11 +2,7 @@ import { fail } from "./fail.js";
 import { succeed } from "./succeed.js";
 import { isPromise } from "../internals/helpers/is-promise.js";
 const try_ = (options)=>{
-    if (isPromise(options.try)) {
-        if ('safe' in options && options.safe) return succeed(options.try);
-        return options.try.then((value)=>succeed(value), (error)=>fail(options.catch(error)));
-    }
-    return (...args)=>{
+    const fn = (...args)=>{
         try {
             const output = options.try(...args);
             if (isPromise(output)) {
@@ -20,5 +16,7 @@ const try_ = (options)=>{
             return fail(options.catch(error));
         }
     };
+    if ('immediate' in options && options.immediate) return fn();
+    return fn;
 };
 export { try_ as try };

package/dist/esm/functions/unwrap-error.d.ts

@@ -1,5 +1,5 @@
-import type { HasPromise } from '../internals/types/has-promise';
-import type { InferFailure, ResultMaybeAsync } from '../result';
+import type { HasPromise } from '../internals/types/has-promise.js';
+import type { InferFailure, ResultMaybeAsync } from '../result.js';
 /**
  * Extracts the error value from a {@link Result} or {@link ResultAsync}.
  *

package/dist/esm/functions/unwrap.d.ts

@@ -1,5 +1,5 @@
-import type { HasPromise } from '../internals/types/has-promise';
-import type { InferSuccess, ResultMaybeAsync } from '../result';
+import type { HasPromise } from '../internals/types/has-promise.js';
+import type { InferSuccess, ResultMaybeAsync } from '../result.js';
 /**
  * Extracts the success value from a {@link Result} or {@link ResultAsync}.
  *

package/dist/esm/index.d.ts

@@ -62,8 +62,8 @@
  * }
  * ```
  */
-export * as Result from './exports';
+export * as Result from './exports.js';
 /**
  * Shorthand alias for {@link Result}.
  */
-export * as R from './exports';
+export * as R from './exports.js';

package/dist/esm/result.d.ts

@@ -1,4 +1,4 @@
-import type { HasPromise } from './internals/types/has-promise';
+import type { HasPromise } from './internals/types/has-promise.js';
 /**
  * Represents a successful result.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praha/byethrow",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "description": "A lightweight, tree-shakable Result type package with a simple, consistent API designed",
   "keywords": [
     "javascript",
@@ -44,11 +44,11 @@
     "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.11.2",
-    "eslint": "9.32.0",
-    "typedoc": "0.28.10",
-    "typedoc-plugin-markdown": "4.8.0",
-    "typescript": "5.8.3",
+    "@rslib/core": "0.13.3",
+    "eslint": "9.36.0",
+    "typedoc": "0.28.13",
+    "typedoc-plugin-markdown": "4.9.0",
+    "typescript": "5.9.2",
     "vitest": "3.2.4"
   },
   "publishConfig": {