effect 4.0.0-rc.112 → 4.0.0-rc.113

package/dist/Effect.d.ts

@@ -32,7 +32,7 @@ import type * as Predicate from "./Predicate.ts";
 import type * as Request from "./Request.ts";
 import type { RequestResolver } from "./RequestResolver.ts";
 import type * as Result from "./Result.ts";
-import type { Schedule } from "./Schedule.ts";
+import type { Metadata as ScheduleMetadata, Schedule } from "./Schedule.ts";
 import type { Scheduler } from "./Scheduler.ts";
 import type { Scope } from "./Scope.ts";
 import type { AnySpan, ParentSpan, Span, SpanLink, SpanOptions, SpanOptionsNoTrace, TraceOptions, Tracer } from "./Tracer.ts";
@@ -238,7 +238,7 @@ export declare namespace All {
         -readonly [K in keyof T]: [T[K]] extends [
             Effect<infer _A, infer _E, infer _R>
         ] ? Mode extends true ? Result.Result<_A, _E> : _A : never;
-    }, Mode extends true ? never : keyof T extends never ? never : T[keyof T] extends Effect<infer _A, infer _E, infer _R> ? _E : never, keyof T extends never ? never : T[keyof T] extends Effect<infer _A, infer _E, infer _R> ? _R : never> : never;
+    }, Mode extends true ? never : Error<ObjectValues<T>>, Services<ObjectValues<T>>> : never;
     /**
      * Detects whether `Effect.all` should discard collected values.
      *
@@ -270,6 +270,7 @@ export declare namespace All {
         readonly discard?: boolean | undefined;
         readonly mode?: "default" | "result" | undefined;
     }> = [Arg] extends [ReadonlyArray<EffectAny>] ? ReturnTuple<Arg, IsDiscard<O>, IsResult<O>> : [Arg] extends [Iterable<EffectAny>] ? ReturnIterable<Arg, IsDiscard<O>, IsResult<O>> : [Arg] extends [Record<string, EffectAny>] ? ReturnObject<Arg, IsDiscard<O>, IsResult<O>> : never;
+    type ObjectValues<T> = T extends unknown ? T[keyof T] : never;
 }
 /**
  * Combines an iterable or record of effects into one effect whose success shape
@@ -1237,10 +1238,153 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * @category constructors
  * @since 2.0.0
  */
-export declare const tryPromise: <A, E = Cause.UnknownError>(options: {
-    readonly try: (signal: AbortSignal) => PromiseLike<A>;
-    readonly catch: (error: unknown) => E;
-} | ((signal: AbortSignal) => PromiseLike<A>)) => Effect<A, E>;
+export declare const tryPromise: {
+    /**
+     * Creates an `Effect` from an asynchronous computation that may throw or
+     * reject, mapping failures into the error channel.
+     *
+     * **When to use**
+     *
+     * Use when you need to perform asynchronous operations that might fail, such
+     * as fetching data from an API, and want thrown exceptions or rejected promises
+     * captured as Effect errors.
+     *
+     * **Details**
+     *
+     * The promise thunk is evaluated when the effect runs. If it returns a promise
+     * that resolves, the resolved value becomes the success value. If the thunk
+     * throws before returning a promise, or if the returned promise rejects, the
+     * thrown or rejected value is mapped into the error channel.
+     *
+     * Passing the thunk directly maps failures to {@link Cause.UnknownError}.
+     * Passing `{ try, catch }` uses `catch` to map failures to an error of type
+     * `E`.
+     *
+     * The thunk receives an `AbortSignal` that is aborted if the effect is
+     * interrupted. The underlying asynchronous operation only stops if it observes
+     * that signal.
+     *
+     * **Gotchas**
+     *
+     * If `catch` throws while mapping the error, that thrown value is treated as a
+     * defect. Return the error value you want in the error channel instead of
+     * throwing it.
+     *
+     * **Example** (Wrapping a fetch request that may fail)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect } from "effect"
+     *
+     * const getTodo = (id: number) =>
+     *   Effect.tryPromise(() => Promise.resolve({ id, completed: false }))
+     *
+     * //      ┌─── Effect<{ id: number; completed: boolean }, UnknownError, never>
+     * //      ▼
+     * const program = getTodo(1)
+     * await Effect.runPromise(program) // => { id: 1, completed: false }
+     * ```
+     *
+     * **Example** (Mapping Promise rejections to a tagged error)
+     *
+     * ```ts import.meta.vitest
+     * import { Data, Effect } from "effect"
+     *
+     * class TodoFetchError extends Data.TaggedError("TodoFetchError")<{ readonly cause: unknown }> {}
+     *
+     * const getTodo = (id: number) =>
+     *   Effect.tryPromise({
+     *     try: () => Promise.reject(`Todo ${id} is unavailable`),
+     *     // remap the error
+     *     catch: (cause) => new TodoFetchError({ cause })
+     *   })
+     *
+     * //      ┌─── Effect<never, TodoFetchError, never>
+     * //      ▼
+     * const program = Effect.flip(getTodo(1))
+     * const error = await Effect.runPromise(program)
+     * error._tag // => "TodoFetchError"
+     * ```
+     *
+     * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
+     * @category constructors
+     * @since 2.0.0
+     */
+    <A>(options: (signal: AbortSignal) => PromiseLike<A>): Effect<A, Cause.UnknownError>;
+    /**
+     * Creates an `Effect` from an asynchronous computation that may throw or
+     * reject, mapping failures into the error channel.
+     *
+     * **When to use**
+     *
+     * Use when you need to perform asynchronous operations that might fail, such
+     * as fetching data from an API, and want thrown exceptions or rejected promises
+     * captured as Effect errors.
+     *
+     * **Details**
+     *
+     * The promise thunk is evaluated when the effect runs. If it returns a promise
+     * that resolves, the resolved value becomes the success value. If the thunk
+     * throws before returning a promise, or if the returned promise rejects, the
+     * thrown or rejected value is mapped into the error channel.
+     *
+     * Passing the thunk directly maps failures to {@link Cause.UnknownError}.
+     * Passing `{ try, catch }` uses `catch` to map failures to an error of type
+     * `E`.
+     *
+     * The thunk receives an `AbortSignal` that is aborted if the effect is
+     * interrupted. The underlying asynchronous operation only stops if it observes
+     * that signal.
+     *
+     * **Gotchas**
+     *
+     * If `catch` throws while mapping the error, that thrown value is treated as a
+     * defect. Return the error value you want in the error channel instead of
+     * throwing it.
+     *
+     * **Example** (Wrapping a fetch request that may fail)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect } from "effect"
+     *
+     * const getTodo = (id: number) =>
+     *   Effect.tryPromise(() => Promise.resolve({ id, completed: false }))
+     *
+     * //      ┌─── Effect<{ id: number; completed: boolean }, UnknownError, never>
+     * //      ▼
+     * const program = getTodo(1)
+     * await Effect.runPromise(program) // => { id: 1, completed: false }
+     * ```
+     *
+     * **Example** (Mapping Promise rejections to a tagged error)
+     *
+     * ```ts import.meta.vitest
+     * import { Data, Effect } from "effect"
+     *
+     * class TodoFetchError extends Data.TaggedError("TodoFetchError")<{ readonly cause: unknown }> {}
+     *
+     * const getTodo = (id: number) =>
+     *   Effect.tryPromise({
+     *     try: () => Promise.reject(`Todo ${id} is unavailable`),
+     *     // remap the error
+     *     catch: (cause) => new TodoFetchError({ cause })
+     *   })
+     *
+     * //      ┌─── Effect<never, TodoFetchError, never>
+     * //      ▼
+     * const program = Effect.flip(getTodo(1))
+     * const error = await Effect.runPromise(program)
+     * error._tag // => "TodoFetchError"
+     * ```
+     *
+     * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
+     * @category constructors
+     * @since 2.0.0
+     */
+    <A, E>(options: {
+        readonly try: (signal: AbortSignal) => PromiseLike<A>;
+        readonly catch: (error: unknown) => E;
+    }): Effect<A, E>;
+};
 /**
  * Creates an `Effect` that always succeeds with a given value.
  *
@@ -2031,10 +2175,13 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ef
  * @since 2.0.0
  */
 export declare const die: (defect: unknown) => Effect<never>;
-declare const try_: <A, E = Cause.UnknownError>(options: {
-    readonly try: LazyArg<A>;
-    readonly catch: (error: unknown) => E;
-} | LazyArg<A>) => Effect<A, E>;
+declare const try_: {
+    <A>(options: LazyArg<A>): Effect<A, Cause.UnknownError>;
+    <A, E>(options: {
+        readonly try: LazyArg<A>;
+        readonly catch: (error: unknown) => E;
+    }): Effect<A, E>;
+};
 export { 
 /**
  * Creates an `Effect` from a synchronous computation that may throw, mapping
@@ -2163,6 +2310,23 @@ export declare const yieldNowWith: (priority?: number) => Effect<void>;
  * @since 4.0.0
  */
 export declare const withFiber: <A, E = never, R = never>(evaluate: (fiber: Fiber<unknown, unknown>) => Effect<A, E, R>) => Effect<A, E, R>;
+/**
+ * Accesses the current fiber to compute a successful value.
+ *
+ * **Example** (Computing a value from the current fiber)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.withFiberSucceed((fiber) => typeof fiber.id)
+ *
+ * Effect.runSync(program) // => "number"
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const withFiberSucceed: <A, R = never>(evaluate: (fiber: Fiber<unknown, unknown>) => A) => Effect<A, never, R>;
 /**
  * Converts a `Result` to an `Effect`.
  *
@@ -6407,7 +6571,7 @@ export declare const tapDefect: {
      * @category sequencing
      * @since 2.0.0
      */
-    <E, B, E2, R2>(f: (defect: unknown) => Effect<B, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>;
+    <B, E2, R2>(f: (defect: unknown) => Effect<B, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>;
     /**
      * Runs an effectful operation when the source effect dies with a defect.
      *
@@ -7430,7 +7594,7 @@ export declare const withErrorReporting: <Arg extends Effect<any, any, any> | {
     readonly defectsOnly?: boolean | undefined;
 }>(effectOrOptions: Arg, options?: {
     readonly defectsOnly?: boolean | undefined;
-} | undefined) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Arg : <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+} | undefined) => [Arg] extends [Effect<infer A, infer E, infer R>] ? Effect<A, E, R> : <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
  * Recovers from a typed failure by producing a fallback success value.
  *
@@ -7791,21 +7955,8 @@ export declare const timeoutOption: {
     <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>;
 };
 /**
- * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
- *
- * **When to use**
- *
- * Use when a timeout of an `Effect` should switch to a fallback effect.
- *
- * **Details**
- *
- * The fallback effect is created lazily by `orElse` and may introduce its own
- * success, failure, and requirement types.
- *
- * **Gotchas**
- *
- * If the timeout wins, the source effect is interrupted before the fallback is
- * run.
+ * Applies a timeout to an effect, lazily evaluating `orElse` after interrupting
+ * the source if the timeout is reached.
  *
  * **Example** (Falling back on timeout)
  *
@@ -7832,21 +7983,8 @@ export declare const timeoutOption: {
  */
 export declare const timeoutOrElse: {
     /**
-     * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
-     *
-     * **When to use**
-     *
-     * Use when a timeout of an `Effect` should switch to a fallback effect.
-     *
-     * **Details**
-     *
-     * The fallback effect is created lazily by `orElse` and may introduce its own
-     * success, failure, and requirement types.
-     *
-     * **Gotchas**
-     *
-     * If the timeout wins, the source effect is interrupted before the fallback is
-     * run.
+     * Applies a timeout to an effect, lazily evaluating `orElse` after interrupting
+     * the source if the timeout is reached.
      *
      * **Example** (Falling back on timeout)
      *
@@ -7876,21 +8014,8 @@ export declare const timeoutOrElse: {
         readonly orElse: LazyArg<Effect<A2, E2, R2>>;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2, R | R2>;
     /**
-     * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
-     *
-     * **When to use**
-     *
-     * Use when a timeout of an `Effect` should switch to a fallback effect.
-     *
-     * **Details**
-     *
-     * The fallback effect is created lazily by `orElse` and may introduce its own
-     * success, failure, and requirement types.
-     *
-     * **Gotchas**
-     *
-     * If the timeout wins, the source effect is interrupted before the fallback is
-     * run.
+     * Applies a timeout to an effect, lazily evaluating `orElse` after interrupting
+     * the source if the timeout is reached.
      *
      * **Example** (Falling back on timeout)
      *
@@ -12533,6 +12658,8 @@ export declare const onExitPrimitive: <A, E, R, XE = never, XR = never>(self: Ef
  * Ensures that a cleanup function runs whether this effect succeeds, fails, or
  * is interrupted.
  *
+ * **Details**
+ *
  * If both the effect and the cleanup function fail, the two causes are merged.
  *
  * **Example** (Observing every exit)
@@ -12562,6 +12689,8 @@ export declare const onExit: {
      * Ensures that a cleanup function runs whether this effect succeeds, fails, or
      * is interrupted.
      *
+     * **Details**
+     *
      * If both the effect and the cleanup function fail, the two causes are merged.
      *
      * **Example** (Observing every exit)
@@ -12591,6 +12720,8 @@ export declare const onExit: {
      * Ensures that a cleanup function runs whether this effect succeeds, fails, or
      * is interrupted.
      *
+     * **Details**
+     *
      * If both the effect and the cleanup function fail, the two causes are merged.
      *
      * **Example** (Observing every exit)
@@ -14050,10 +14181,10 @@ export declare const repeat: {
  * const program = Effect.repeatOrElse(
  *   task,
  *   Schedule.recurs(3),
- *   (error, attempts) =>
+ *   (error, previous) =>
  *     Effect.sync(() => { output.push(
  *       `Final failure: ${error}, after ${
- *         Option.getOrElse(attempts, () => 0)
+ *         Option.isSome(previous) ? previous.value.attempt : 0
  *       } attempts`
  *     ) }).pipe(Effect.map(() => 0))
  * )
@@ -14102,10 +14233,10 @@ export declare const repeatOrElse: {
      * const program = Effect.repeatOrElse(
      *   task,
      *   Schedule.recurs(3),
-     *   (error, attempts) =>
+     *   (error, previous) =>
      *     Effect.sync(() => { output.push(
      *       `Final failure: ${error}, after ${
-     *         Option.getOrElse(attempts, () => 0)
+     *         Option.isSome(previous) ? previous.value.attempt : 0
      *       } attempts`
      *     ) }).pipe(Effect.map(() => 0))
      * )
@@ -14117,7 +14248,7 @@ export declare const repeatOrElse: {
      * @category repetition
      * @since 2.0.0
      */
-    <R2, A, B, E, E2, E3, R3>(schedule: Schedule<B, A, E2, R2>, orElse: (error: E | E2, option: Option<B>) => Effect<B, E3, R3>): <R>(self: Effect<A, E, R>) => Effect<B, E3, R | R2 | R3>;
+    <R2, A, B, E, E2, E3, R3>(schedule: Schedule<B, A, E2, R2>, orElse: (error: E | E2, option: Option<ScheduleMetadata<B, A>>) => Effect<B, E3, R3>): <R>(self: Effect<A, E, R>) => Effect<B, E3, R | R2 | R3>;
     /**
      * Repeats an effect according to a schedule and runs a fallback effect if
      * repetition fails before the schedule completes.
@@ -14154,10 +14285,10 @@ export declare const repeatOrElse: {
      * const program = Effect.repeatOrElse(
      *   task,
      *   Schedule.recurs(3),
-     *   (error, attempts) =>
+     *   (error, previous) =>
      *     Effect.sync(() => { output.push(
      *       `Final failure: ${error}, after ${
-     *         Option.getOrElse(attempts, () => 0)
+     *         Option.isSome(previous) ? previous.value.attempt : 0
      *       } attempts`
      *     ) }).pipe(Effect.map(() => 0))
      * )
@@ -14169,7 +14300,7 @@ export declare const repeatOrElse: {
      * @category repetition
      * @since 2.0.0
      */
-    <A, E, R, R2, B, E2, E3, R3>(self: Effect<A, E, R>, schedule: Schedule<B, A, E2, R2>, orElse: (error: E | E2, option: Option<B>) => Effect<B, E3, R3>): Effect<B, E3, R | R2 | R3>;
+    <A, E, R, R2, B, E2, E3, R3>(self: Effect<A, E, R>, schedule: Schedule<B, A, E2, R2>, orElse: (error: E | E2, option: Option<ScheduleMetadata<B, A>>) => Effect<B, E3, R3>): Effect<B, E3, R | R2 | R3>;
 };
 /**
  * Returns an array of `n` identical effects.
@@ -17919,14 +18050,10 @@ export declare const annotateLogsScoped: {
  */
 export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>) & (<A, E, R>(effect: Effect<A, E, R>, label: string) => Effect<A, E, R>);
 /**
- * Updates the `Metric` every time the `Effect` is executed.
- *
- * **Details**
- *
- * Also accepts an optional function which can be used to map the `Exit` value
- * of the `Effect` into a valid `Input` for the `Metric`.
+ * Updates a metric after each effect execution, optionally mapping its `Exit` to
+ * the metric's input.
  *
- * **Example** (Incrementing a metric for each execution)
+ * **Example** (Counting executions)
  *
  * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
@@ -17943,12 +18070,11 @@ export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A
  * Effect.runSync(Metric.value(counter)).count // => 1
  * ```
  *
- * **Example** (Mapping exits before updating a metric)
+ * **Example** (Mapping exits)
  *
  * ```ts import.meta.vitest
  * import { Effect, Exit, Metric } from "effect"
  *
- * // Track different exit types with custom mapping
  * const exitTracker = Metric.frequency("exit_types", {
  *   description: "Tracks success/failure/defect counts"
  * })
@@ -17971,14 +18097,10 @@ export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A
  */
 export declare const track: {
     /**
-     * Updates the `Metric` every time the `Effect` is executed.
-     *
-     * **Details**
-     *
-     * Also accepts an optional function which can be used to map the `Exit` value
-     * of the `Effect` into a valid `Input` for the `Metric`.
+     * Updates a metric after each effect execution, optionally mapping its `Exit` to
+     * the metric's input.
      *
-     * **Example** (Incrementing a metric for each execution)
+     * **Example** (Counting executions)
      *
      * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
@@ -17995,12 +18117,11 @@ export declare const track: {
      * Effect.runSync(Metric.value(counter)).count // => 1
      * ```
      *
-     * **Example** (Mapping exits before updating a metric)
+     * **Example** (Mapping exits)
      *
      * ```ts import.meta.vitest
      * import { Effect, Exit, Metric } from "effect"
      *
-     * // Track different exit types with custom mapping
      * const exitTracker = Metric.frequency("exit_types", {
      *   description: "Tracks success/failure/defect counts"
      * })
@@ -18021,16 +18142,12 @@ export declare const track: {
      * @category metrics
      * @since 4.0.0
      */
-    <Input, State, E, A>(metric: Metric.Metric<Input, State>, f: (exit: Exit.Exit<A, E>) => Input): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
+    <Input, State, E, A>(metric: Metric.Metric<Input, State>, f: (exit: Exit.Exit<A, E>) => Input): <E2 extends E, R>(self: Effect<A, E2, R>) => Effect<A, E2, R>;
     /**
-     * Updates the `Metric` every time the `Effect` is executed.
-     *
-     * **Details**
-     *
-     * Also accepts an optional function which can be used to map the `Exit` value
-     * of the `Effect` into a valid `Input` for the `Metric`.
+     * Updates a metric after each effect execution, optionally mapping its `Exit` to
+     * the metric's input.
      *
-     * **Example** (Incrementing a metric for each execution)
+     * **Example** (Counting executions)
      *
      * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
@@ -18047,12 +18164,11 @@ export declare const track: {
      * Effect.runSync(Metric.value(counter)).count // => 1
      * ```
      *
-     * **Example** (Mapping exits before updating a metric)
+     * **Example** (Mapping exits)
      *
      * ```ts import.meta.vitest
      * import { Effect, Exit, Metric } from "effect"
      *
-     * // Track different exit types with custom mapping
      * const exitTracker = Metric.frequency("exit_types", {
      *   description: "Tracks success/failure/defect counts"
      * })
@@ -18075,14 +18191,10 @@ export declare const track: {
      */
     <State, E, A>(metric: Metric.Metric<Exit.Exit<NoInfer<A>, NoInfer<E>>, State>): <R>(self: Effect<A, E, R>) => Effect<A, E, R>;
     /**
-     * Updates the `Metric` every time the `Effect` is executed.
+     * Updates a metric after each effect execution, optionally mapping its `Exit` to
+     * the metric's input.
      *
-     * **Details**
-     *
-     * Also accepts an optional function which can be used to map the `Exit` value
-     * of the `Effect` into a valid `Input` for the `Metric`.
-     *
-     * **Example** (Incrementing a metric for each execution)
+     * **Example** (Counting executions)
      *
      * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
@@ -18099,12 +18211,11 @@ export declare const track: {
      * Effect.runSync(Metric.value(counter)).count // => 1
      * ```
      *
-     * **Example** (Mapping exits before updating a metric)
+     * **Example** (Mapping exits)
      *
      * ```ts import.meta.vitest
      * import { Effect, Exit, Metric } from "effect"
      *
-     * // Track different exit types with custom mapping
      * const exitTracker = Metric.frequency("exit_types", {
      *   description: "Tracks success/failure/defect counts"
      * })
@@ -18127,14 +18238,10 @@ export declare const track: {
      */
     <A, E, R, Input, State>(self: Effect<A, E, R>, metric: Metric.Metric<Input, State>, f: (exit: Exit.Exit<A, E>) => Input): Effect<A, E, R>;
     /**
-     * Updates the `Metric` every time the `Effect` is executed.
-     *
-     * **Details**
-     *
-     * Also accepts an optional function which can be used to map the `Exit` value
-     * of the `Effect` into a valid `Input` for the `Metric`.
+     * Updates a metric after each effect execution, optionally mapping its `Exit` to
+     * the metric's input.
      *
-     * **Example** (Incrementing a metric for each execution)
+     * **Example** (Counting executions)
      *
      * ```ts import.meta.vitest
      * import { Effect, Metric } from "effect"
@@ -18151,12 +18258,11 @@ export declare const track: {
      * Effect.runSync(Metric.value(counter)).count // => 1
      * ```
      *
-     * **Example** (Mapping exits before updating a metric)
+     * **Example** (Mapping exits)
      *
      * ```ts import.meta.vitest
      * import { Effect, Exit, Metric } from "effect"
      *
-     * // Track different exit types with custom mapping
      * const exitTracker = Metric.frequency("exit_types", {
      *   description: "Tracks success/failure/defect counts"
      * })
@@ -19467,6 +19573,7 @@ export declare namespace Effectify {
         (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
     } ? NonNullable<E1> : never;
 }
+type EffectifyArgs<F extends (...args: Array<any>) => any> = Parameters<F> extends [...infer Args, any] ? Args : Parameters<F>;
 /**
  * Converts an error-first callback API into a function that returns an
  * `Effect`.
@@ -19625,7 +19732,7 @@ export declare const effectify: {
      * @category converting
      * @since 4.0.0
      */
-    <F extends (...args: Array<any>) => any, E>(fn: F, onError: (error: Effectify.EffectifyError<F>, args: Parameters<F>) => E): Effectify.Effectify<F, E>;
+    <F extends (...args: Array<any>) => any, E>(fn: F, onError: (error: Effectify.EffectifyError<F>, args: EffectifyArgs<F>) => E): Effectify.Effectify<F, E>;
     /**
      * Converts an error-first callback API into a function that returns an
      * `Effect`.
@@ -19678,7 +19785,7 @@ export declare const effectify: {
      * @category converting
      * @since 4.0.0
      */
-    <F extends (...args: Array<any>) => any, E, E2>(fn: F, onError: (error: Effectify.EffectifyError<F>, args: Parameters<F>) => E, onSyncError: (error: unknown, args: Parameters<F>) => E2): Effectify.Effectify<F, E | E2>;
+    <F extends (...args: Array<any>) => any, E, E2>(fn: F, onError: (error: Effectify.EffectifyError<F>, args: EffectifyArgs<F>) => E, onSyncError: (error: unknown, args: EffectifyArgs<F>) => E2): Effectify.Effectify<F, E | E2>;
 };
 /**
  * Ensures that an effect's success type extends a given type `A`.