From 8577d4837d8b1e7e90b6ee6c64dcde1f30a49dc7 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 09:13:37 +0200
Subject: [PATCH 1/6] prep

---
 packages/vue/src/experimental/commander2.ts | 1688 +++++++++++++++++++
 1 file changed, 1688 insertions(+)
 create mode 100644 packages/vue/src/experimental/commander2.ts

diff --git a/packages/vue/src/experimental/commander2.ts b/packages/vue/src/experimental/commander2.ts
new file mode 100644
index 0000000000..21e6464673
--- /dev/null
+++ b/packages/vue/src/experimental/commander2.ts
@@ -0,0 +1,1688 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { asResult, type MissingDependencies, reportRuntimeError } from "@effect-app/vue"
+import { reportMessage } from "@effect-app/vue/errorReporter"
+import { type Result } from "@effect-atom/atom/Result"
+import { Cause, Context, Effect, type Exit, flow, Match, Option, Runtime, S } from "effect-app"
+import { SupportedErrors } from "effect-app/client"
+import { OperationFailure, OperationSuccess } from "effect-app/Operations"
+import { wrapEffect } from "effect-app/utils"
+import { id, type RuntimeFiber } from "effect/Fiber"
+import { type NoInfer } from "effect/Types"
+import { isGeneratorFunction, type YieldWrap } from "effect/Utils"
+import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat"
+import { computed, type ComputedRef, reactive, ref } from "vue"
+import { CommandContext } from "./commander.js"
+import { Confirm } from "./confirm.js"
+import { I18n } from "./intl.js"
+import { WithToast } from "./withToast.js"
+
+type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>
+type FnOptions<I18nCustomKey extends string, State extends IntlRecord | undefined> = {
+  i18nCustomKey?: I18nCustomKey
+  /**
+   * passed to the i18n formatMessage calls so you can use it in translation messagee
+   * including the Command `action` string.
+   * Automatically wrapped with Computed if just a thunk.
+   * provided as Command.state tag, so you can access it in the function.
+   */
+  state?: ComputedRef<State> | (() => State)
+  disableSharedWaiting?: boolean
+}
+
+type FnOptionsInternal<I18nCustomKey extends string> = {
+  i18nCustomKey?: I18nCustomKey | undefined
+  state?: IntlRecord | undefined
+}
+
+export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void
+
+export declare namespace Commander {
+  export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
+    & Commander.Gen<RT, Id, I18nKey, State>
+    & Commander.NonGen<RT, Id, I18nKey, State>
+    & Commander.CommandContextLocal<Id, I18nKey>
+    & {
+      state: Context.Tag<`Commander.Command.${Id}.state`, State>
+    }
+
+  export type CommanderFn<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
+    CommanderBase<RT, Id, I18nKey, State>
+
+  export type CommanderWrap<
+    RT,
+    Id extends string,
+    I18nCustomKey extends string,
+    State extends IntlRecord | undefined,
+    I extends any[],
+    A,
+    E,
+    R
+  > =
+    & CommandContextLocal<Id, I18nCustomKey>
+    & GenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
+    & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
+    & {
+      state: Context.Tag<`Commander.Command.${Id}.state`, State>
+    }
+
+  export interface CommandContextLocal<Id extends string, I18nKey extends string> {
+    id: Id
+    i18nKey: I18nKey
+    namespace: `action.${I18nKey}`
+    namespaced: <K extends string>(k: K) => `action.${I18nKey}.${K}`
+  }
+
+  export interface CommandProps<
+    A,
+    E,
+    Id extends string,
+    I18nKey extends string,
+    State extends IntlRecord | undefined
+  > extends CommandContextLocal<Id, I18nKey> {
+    /** reactive */
+    action: string
+    /** reactive */
+    label: string
+    /** reactive */
+    result: Result<A, E>
+    /** reactive */
+    waiting: boolean
+    /** reactive */
+    state: ComputedRef<State>
+  }
+
+  export interface CommandOut<
+    Args extends Array<unknown>,
+    A,
+    E,
+    R,
+    Id extends string,
+    I18nKey extends string,
+    State extends IntlRecord | undefined
+  > extends CommandProps<A, E, Id, I18nKey, State> {
+    new(): {}
+
+    /** click handlers */
+    handle: ((...args: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
+      /** @deprecated don't exist */
+      effect: (...args: Args) => Effect.Effect<A, E, R>
+    }
+
+    // // TODO: if we keep them, it would probably be nicer as an option api, deciding the return value like in Atom?
+    // /** @experimental */
+    // compose: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, R>
+    // /** @experimental */
+    // compose2: (...args: Args) => Effect.Effect<A, E, R>
+    // /**
+    //  * @experimental
+    //  * captures the current span and returns an Effect that when run will execute the command
+    //  */
+    // handleEffect: (...args: Args) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
+    // /**
+    //  * @experimental
+    //  */
+    // exec: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
+  }
+
+  type CommandOutHelper<
+    Args extends Array<unknown>,
+    Eff extends Effect.Effect<any, any, any>,
+    Id extends string,
+    I18nKey extends string,
+    State extends IntlRecord | undefined
+  > = CommandOut<
+    Args,
+    Effect.Effect.Success<Eff>,
+    Effect.Effect.Error<Eff>,
+    Effect.Effect.Context<Eff>,
+    Id,
+    I18nKey,
+    State
+  >
+
+  export type Gen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
+      AEff,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>
+    ): CommandOut<
+      Args,
+      AEff,
+      [Eff] extends [never] ? never
+        : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+        : never,
+      [Eff] extends [never] ? never
+        : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+        : never,
+      Id,
+      I18nKey,
+      State
+    >
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A
+    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B
+    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C
+    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D
+    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D,
+      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E
+    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F
+    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G
+    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H
+    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<unknown>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H,
+      i: (_: H, ...args: NoInfer<Args>) => I
+    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+  }
+
+  export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => H,
+      h: (_: H, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      I,
+      Args extends Array<unknown>
+    >(
+      body: (...args: Args) => A,
+      a: (_: A, ...args: NoInfer<Args>) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => H,
+      h: (_: H, ...args: NoInfer<Args>) => I,
+      i: (_: H, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+  }
+
+  export type GenWrap<
+    RT,
+    Id extends string,
+    I18nKey extends string,
+    Args extends Array<unknown>,
+    AEff,
+    EEff,
+    REff,
+    State extends IntlRecord | undefined
+  > = {
+    (): Exclude<REff, RT> extends never ? CommandOut<
+        Args,
+        AEff,
+        EEff,
+        REff,
+        Id,
+        I18nKey,
+        State
+      >
+      : MissingDependencies<RT, REff> & {}
+    <
+      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A
+    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    <
+      A,
+      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B
+    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+    <
+      A,
+      B,
+      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C
+    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+    <
+      A,
+      B,
+      C,
+      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D
+    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+    <
+      A,
+      B,
+      C,
+      D,
+      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E
+    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+    <
+      A,
+      B,
+      C,
+      D,
+      E,
+      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F
+    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+    <
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G
+    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+    <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H
+    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+    <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H,
+      i: (_: H, ...args: NoInfer<Args>) => I
+    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+  }
+
+  export type NonGenWrap<
+    RT,
+    Id extends string,
+    I18nKey extends string,
+    Args extends Array<unknown>,
+    AEff,
+    EEff,
+    REff,
+    State extends IntlRecord | undefined
+  > = {
+    (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
+      : MissingDependencies<RT, REff> & {}
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      E,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      E,
+      F,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => H,
+      h: (_: H, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    <
+      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      I,
+      Args extends Array<unknown>
+    >(
+      a: (
+        _: Effect.Effect<
+          AEff,
+          EEff,
+          REff
+        >,
+        ...args: NoInfer<Args>
+      ) => B,
+      b: (_: B, ...args: NoInfer<Args>) => C,
+      c: (_: C, ...args: NoInfer<Args>) => D,
+      d: (_: D, ...args: NoInfer<Args>) => E,
+      e: (_: E, ...args: NoInfer<Args>) => F,
+      f: (_: F, ...args: NoInfer<Args>) => G,
+      g: (_: G, ...args: NoInfer<Args>) => H,
+      h: (_: H, ...args: NoInfer<Args>) => I,
+      i: (_: H, ...args: NoInfer<Args>) => Eff
+    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+  }
+}
+
+type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined
+
+const renderErrorMaker = I18n.use(
+  ({ intl }) =>
+  <E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) =>
+  (e: E, ...args: Args): string => {
+    if (errorRenderer) {
+      const m = errorRenderer(e, action, ...args)
+      if (m !== undefined) {
+        return m
+      }
+    }
+    if (!S.is(SupportedErrors)(e) && !S.ParseResult.isParseError(e)) {
+      if (typeof e === "object" && e !== null) {
+        if ("message" in e) {
+          return `${e.message}`
+        }
+        if ("_tag" in e) {
+          return `${e._tag}`
+        }
+      }
+      return ""
+    }
+    const e2: SupportedErrors | S.ParseResult.ParseError = e
+    return Match.value(e2).pipe(
+      Match.tags({
+        NotFoundError: (e) => {
+          return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id })
+        },
+        ParseError: (e) => {
+          console.warn(e.toString())
+          return intl.formatMessage({ id: "validation.failed" })
+        }
+      }),
+      Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
+    )
+  }
+)
+
+const defaultFailureMessageHandler = <E, Args extends Array<unknown>, AME, AMR>(
+  actionMaker:
+    | string
+    | ((o: Option.Option<E>, ...args: Args) => string)
+    | ((o: Option.Option<E>, ...args: Args) => Effect.Effect<string, AME, AMR>),
+  errorRenderer?: ErrorRenderer<E, Args>
+) =>
+  Effect.fnUntraced(function*(o: Option.Option<E>, ...args: Args) {
+    const action = yield* wrapEffect(actionMaker)(o, ...args)
+    const { intl } = yield* I18n
+    const renderError = yield* renderErrorMaker
+
+    return Option.match(o, {
+      onNone: () =>
+        intl.formatMessage(
+          { id: "handle.unexpected_error2" },
+          {
+            action,
+            error: "" // TODO consider again Cause.pretty(cause), // will be reported to Sentry/Otel anyway.. and we shouldn't bother users with error dumps?
+          }
+        ),
+      onSome: (e) =>
+        S.is(OperationFailure)(e)
+          ? {
+            level: "warn" as const,
+            message: intl.formatMessage(
+                { id: "handle.with_warnings" },
+                { action }
+              ) + e.message
+              ? "\n" + e.message
+              : ""
+          }
+          : `${
+            intl.formatMessage(
+              { id: "handle.with_errors" },
+              { action }
+            )
+          }:\n` + renderError(action, errorRenderer)(e, ...args)
+    })
+  })
+
+export const CommanderStatic = {
+  /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
+  confirmOrInterrupt: Effect.fnUntraced(function*(
+    message: string | undefined = undefined
+  ) {
+    const context = yield* CommandContext
+    const { intl } = yield* I18n
+
+    yield* Confirm.confirmOrInterrupt(
+      message
+        ?? intl.formatMessage(
+          { id: "handle.confirmation" },
+          { action: context.action }
+        )
+    )
+  }),
+  /** Version of @see confirm that automatically includes the action name in the default messages */
+  confirm: Effect.fnUntraced(function*(
+    message: string | undefined = undefined
+  ) {
+    const context = yield* CommandContext
+    const { intl } = yield* I18n
+    return yield* Confirm.confirm(
+      message
+        ?? intl.formatMessage(
+          { id: "handle.confirmation" },
+          { action: context.action }
+        )
+    )
+  }),
+  updateAction:
+    <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) =>
+    <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) =>
+      Effect.updateService(
+        _,
+        CommandContext,
+        (c) => ({ ...c, action: update(c.action, ...input) })
+      ),
+  defaultFailureMessageHandler,
+  renderError: renderErrorMaker,
+  /**
+   * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
+   * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
+   * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
+   *
+   * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
+   *
+   * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
+   * If you provide a string or function, it will be used instead of the i18n message.
+   * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
+   */
+  withDefaultToast: <A, E, R, Args extends Array<unknown>>(
+    options?: {
+      /**
+       * if true, previous toasts with this key will be replaced
+       */
+      stableToastId?: undefined | true | string | ((id: string, ...args: Args) => true | string | undefined)
+      errorRenderer?: ErrorRenderer<E, Args>
+      onWaiting?: null | undefined | string | ((id: string, ...args: Args) => string | null | undefined)
+      onSuccess?: null | undefined | string | ((a: A, action: string, ...args: Args) => string | null | undefined)
+    }
+  ) =>
+  (
+    self: Effect.Effect<A, E, R>,
+    ...args: Args
+  ) =>
+    Effect.gen(function*() {
+      const cc = yield* CommandContext
+      const { intl } = yield* I18n
+      const withToast = yield* WithToast
+      const customWaiting = cc.namespaced("waiting")
+      const hasCustomWaiting = !!intl.messages[customWaiting]
+      const customSuccess = cc.namespaced("success")
+      const hasCustomSuccess = !!intl.messages[customSuccess]
+      const customFailure = cc.namespaced("failure")
+      const hasCustomFailure = !!intl.messages[customFailure]
+      const stableToastId = options?.stableToastId
+        ? typeof options.stableToastId === "string"
+          ? options.stableToastId
+          : typeof options.stableToastId === "boolean"
+          ? cc.id
+          : typeof options.stableToastId === "function"
+          ? (...args: Args) => {
+            const r = (options.stableToastId as any)(id, ...args)
+            if (typeof r === "string") return r
+            if (r === true) return cc.id
+            return undefined
+          }
+          : undefined
+        : undefined
+      return yield* self.pipe(
+        (_) =>
+          withToast<A, E, Args, R, never, never, I18n>({
+            onWaiting: options?.onWaiting === null ? null : hasCustomWaiting
+              ? intl.formatMessage({
+                id: customWaiting
+              }, cc.state)
+              : intl.formatMessage(
+                { id: "handle.waiting" },
+                { action: cc.action }
+              ),
+            onSuccess: options?.onSuccess === null
+              ? null
+              : (a, ..._args) =>
+                hasCustomSuccess
+                  ? intl.formatMessage(
+                    { id: customSuccess },
+                    cc.state
+                  )
+                  : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
+                    + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
+            onFailure: defaultFailureMessageHandler(
+              hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action,
+              options?.errorRenderer
+            ),
+            stableToastId
+          })(_, ...args)
+      )
+    })
+}
+
+const makeBaseInfo = <const Id extends string, const I18nKey extends string = Id>(
+  id: Id,
+  options?: Pick<FnOptionsInternal<I18nKey>, "i18nCustomKey">
+) => {
+  if (!id) throw new Error("must specify an id")
+  const i18nKey: I18nKey = options?.i18nCustomKey ?? id as unknown as I18nKey
+
+  const namespace = `action.${i18nKey}` as const
+
+  const context = {
+    id,
+    i18nKey,
+    namespace,
+    namespaced: <const K extends string>(k: K) => `${namespace}.${k}` as const
+  }
+
+  return context
+}
+
+const waitState = ref<Record<string, number>>({})
+const registerWait = (id: string) => {
+  // console.debug("register wait", id)
+  waitState.value[id] = waitState.value[id] ? waitState.value[id] + 1 : 1
+}
+const unregisterWait = (id: string) => {
+  // console.debug("unregister wait", id)
+  if (waitState.value[id]) {
+    waitState.value[id] = waitState.value[id] - 1
+    if (waitState.value[id] <= 0) {
+      delete waitState.value[id]
+    }
+  }
+}
+
+const getStateValues = <const I18nKey extends string, State extends IntlRecord | undefined>(
+  options?: FnOptions<I18nKey, State>
+): ComputedRef<State> => {
+  const state_ = options?.state
+  const state = !state_ ? computed(() => undefined as State) : typeof state_ === "function"
+    ? computed(state_)
+    : state_
+  return state
+}
+
+// class preserves JSDoc throughout..
+export class CommanderImpl<RT> {
+  private runFork: <A, E>(
+    effect: Effect.Effect<A, E, RT>,
+    options?: Runtime.RunForkOptions
+  ) => RuntimeFiber<A, E>
+
+  constructor(private readonly rt: Runtime.Runtime<RT>, private readonly intl: I18n) {
+    this.runFork = Runtime.runFork(this.rt)
+  }
+
+  readonly makeContext = <const Id extends string, const I18nKey extends string = Id>(
+    id: Id,
+    options?: FnOptionsInternal<I18nKey>
+  ) => {
+    if (!id) throw new Error("must specify an id")
+    const i18nKey: I18nKey = options?.i18nCustomKey ?? id as unknown as I18nKey
+
+    const namespace = `action.${i18nKey}` as const
+
+    // must remain stable through out single call
+    const action = this.intl.formatMessage({
+      id: namespace,
+      defaultMessage: id
+    }, { ...options?.state, _isLabel: false })
+
+    const label = this.intl.formatMessage({
+      id: namespace,
+      defaultMessage: id
+    }, { ...options?.state, _isLabel: true })
+
+    const context = CommandContext.of({
+      ...makeBaseInfo(id, options),
+      action,
+      label,
+      state: options?.state
+    })
+
+    return context
+  }
+
+  readonly makeCommand = <
+    const Id extends string,
+    const State extends IntlRecord | undefined,
+    const I18nKey extends string = Id
+  >(
+    id_: Id | { id: Id },
+    options?: FnOptions<I18nKey, State>,
+    errorDef?: Error
+  ) => {
+    const id = typeof id_ === "string" ? id_ : id_.id
+    const state = getStateValues(options)
+
+    return Object.assign(
+      <Args extends ReadonlyArray<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+        handler: (...args: Args) => Effect.Effect<A, E, R>
+      ) => {
+        // we capture the definition stack here, so we can append it to later stack traces
+        const limit = Error.stackTraceLimit
+        Error.stackTraceLimit = 2
+        const localErrorDef = new Error()
+        Error.stackTraceLimit = limit
+        if (!errorDef) {
+          errorDef = localErrorDef
+        }
+
+        const key = `Commander.Command.${id}.state` as const
+        const stateTag = Context.GenericTag<typeof key, State>(key)
+
+        const makeContext_ = () => this.makeContext(id, { ...options, state: state?.value })
+        const initialContext = makeContext_()
+        const context = computed(() => makeContext_())
+        const action = computed(() => context.value.action)
+        const label = computed(() => context.value.label)
+
+        const errorReporter = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+          self.pipe(
+            Effect.tapErrorCause(
+              Effect.fnUntraced(function*(cause) {
+                if (Cause.isInterruptedOnly(cause)) {
+                  console.info(`Interrupted while trying to ${id}`)
+                  return
+                }
+
+                const fail = Cause.failureOption(cause)
+                if (Option.isSome(fail)) {
+                  // if (fail.value._tag === "SuppressErrors") {
+                  //   console.info(
+                  //     `Suppressed error trying to ${action}`,
+                  //     fail.value,
+                  //   )
+                  //   return
+                  // }
+                  const message = `Failure trying to ${id}`
+                  yield* reportMessage(message, {
+                    action: id,
+                    error: fail.value
+                  })
+                  return
+                }
+
+                const context = yield* CommandContext
+                const extra = {
+                  action: context.action,
+                  message: `Unexpected Error trying to ${id}`
+                }
+                yield* reportRuntimeError(cause, extra)
+              }, Effect.uninterruptible)
+            )
+          )
+
+        const currentState = Effect.sync(() => state.value)
+
+        const theHandler = flow(
+          handler,
+          errorReporter,
+          // all must be within the Effect.fn to fit within the Span
+          Effect.provideServiceEffect(
+            stateTag,
+            currentState
+          ),
+          Effect.provideServiceEffect(
+            CommandContext,
+            Effect.sync(() => makeContext_())
+          )
+        )
+
+        const [result, exec_] = asResult(theHandler)
+        // probably could be nice to use a namespaced, computable wait key instead not unlike query invalidation?
+        // ["Something.Update", { id }] for instance
+        const exec = options?.disableSharedWaiting
+          ? exec_
+          : Effect
+            .fnUntraced(function*(...args: Args) {
+              registerWait(id)
+              return yield* exec_(...args)
+            }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
+
+        const waiting = options?.disableSharedWaiting
+          ? computed(() => result.value.waiting)
+          : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
+
+        const handle = Object.assign((...args: Args) => {
+          // we capture the call site stack here
+          const limit = Error.stackTraceLimit
+          Error.stackTraceLimit = 2
+          const errorCall = new Error()
+          Error.stackTraceLimit = limit
+
+          let cache: false | string = false
+          const captureStackTrace = () => {
+            // in case of an error, we want to append the definition stack to the call site stack,
+            // so we can see where the handler was defined too
+
+            if (cache !== false) {
+              return cache
+            }
+            if (errorCall.stack) {
+              const stackDef = errorDef!.stack!.trim().split("\n")
+              const stackCall = errorCall.stack.trim().split("\n")
+              let endStackDef = stackDef.slice(2).join("\n").trim()
+              if (!endStackDef.includes(`(`)) {
+                endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
+              }
+              let endStackCall = stackCall.slice(2).join("\n").trim()
+              if (!endStackCall.includes(`(`)) {
+                endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+              }
+              cache = `${endStackDef}\n${endStackCall}`
+              return cache
+            }
+          }
+
+          const command = currentState.pipe(Effect.flatMap((state) =>
+            Effect.withSpan(
+              exec(...args),
+              id,
+              {
+                captureStackTrace,
+                attributes: {
+                  input: args,
+                  state,
+                  action: initialContext.action,
+                  label: initialContext.label,
+                  id: initialContext.id,
+                  i18nKey: initialContext.i18nKey
+                }
+              }
+            )
+          ))
+
+          return this.runFork(command)
+        }, { action, label })
+
+        return reactive({
+          /** static */
+          id,
+
+          /** the base i18n key, based on id by default. static */
+          i18nKey: initialContext.i18nKey,
+          /** the `action.` namespace based on i18nKey.. static */
+          namespace: initialContext.namespace,
+
+          /** easy generate namespaced 18n keys, based on namespace. static */
+          namespaced: initialContext.namespaced,
+
+          /** reactive */
+          result,
+          /** reactive */
+          waiting,
+          /** reactive */
+          action,
+          /** reactive */
+          label,
+          /** reactive */
+          state,
+
+          handle
+        })
+      },
+      { id }
+    )
+  }
+
+  // /** @experimental */
+  // takeOver:
+  //   <Args extends any[], A, E, R, const Id extends string>(command: Commander.CommandOut<Args, A, E, R, Id,I18nKey>) =>
+  //   (...args: Args) => {
+  //     // we capture the call site stack here
+  //     const limit = Error.stackTraceLimit
+  //     Error.stackTraceLimit = 2
+  //     const errorCall = new Error()
+  //     const localErrorDef = new Error()
+  //     Error.stackTraceLimit = limit
+
+  //     // TODO
+  //     const errorDef = localErrorDef
+
+  //     let cache: false | string = false
+  //     const captureStackTrace = () => {
+  //       // in case of an error, we want to append the definition stack to the call site stack,
+  //       // so we can see where the handler was defined too
+
+  //       if (cache !== false) {
+  //         return cache
+  //       }
+  //       if (errorCall.stack) {
+  //         const stackDef = errorDef.stack!.trim().split("\n")
+  //         const stackCall = errorCall.stack.trim().split("\n")
+  //         let endStackDef = stackDef.slice(2).join("\n").trim()
+  //         if (!endStackDef.includes(`(`)) {
+  //           endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
+  //         }
+  //         let endStackCall = stackCall.slice(2).join("\n").trim()
+  //         if (!endStackCall.includes(`(`)) {
+  //           endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+  //         }
+  //         cache = `${endStackDef}\n${endStackCall}`
+  //         return cache
+  //       }
+  //     }
+
+  //     return Effect.gen(function*() {
+  //       const ctx = yield* CommandContext
+  //       ctx.action = command.action
+  //       return yield* command.exec(...args).pipe(
+  //         Effect.flatten,
+  //         Effect.withSpan(
+  //           command.action,
+  //           { captureStackTrace }
+  //         )
+  //       )
+  //     })
+  //   },
+
+  /**
+   * Define a Command for handling user actions with built-in error reporting and state management.
+   *
+   * @param id The internal identifier for the action. Used as a tracing span and to lookup
+   *                   the user-facing name via internationalization (`action.${id}`).
+   * @param options Optional configuration for internationalization and state.
+   * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+   * @param options.state Optional reactive state object (or function returning one) that is
+   *                     made available to the command effects and can be used for i18n interpolation.
+   *                     The state is captured at the start of each command execution and remains stable throughout.
+   * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+   *          Built-in error reporting handles failures automatically.
+   *
+   * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+   * the user-facing action name.
+   *
+   * **Returned Properties**:
+   * - `action`: User-facing action name from intl messages (useful for button labels)
+   * - `result`: The command result state
+   * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+   * - `handle`: Function to execute the command
+   * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+   * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+   *
+   * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+   * the `result` inline for custom UI feedback.
+   */
+  fn = <
+    const Id extends string,
+    const State extends IntlRecord = IntlRecord,
+    const I18nKey extends string = Id
+  >(
+    id: Id | { id: Id },
+    options?: FnOptions<I18nKey, State>
+  ): Commander.Gen<RT, Id, I18nKey, State> & Commander.NonGen<RT, Id, I18nKey, State> & {
+    state: Context.Tag<`Commander.Command.${Id}.state`, State>
+  } =>
+    Object.assign(
+      (
+        fn: any,
+        ...combinators: any[]
+      ): any => {
+        // we capture the definition stack here, so we can append it to later stack traces
+        const limit = Error.stackTraceLimit
+        Error.stackTraceLimit = 2
+        const errorDef = new Error()
+        Error.stackTraceLimit = limit
+
+        return this.makeCommand(id, options, errorDef)(
+          Effect.fnUntraced(
+            // fnUntraced only supports generators as first arg, so we convert to generator if needed
+            isGeneratorFunction(fn) ? fn : function*(...args) {
+              return yield* fn(...args)
+            },
+            ...combinators as [any]
+          ) as any
+        )
+      },
+      makeBaseInfo(typeof id === "string" ? id : id.id, options),
+      {
+        state: Context.GenericTag<`Commander.Command.${Id}.state`, State>(
+          `Commander.Command.${typeof id === "string" ? id : id.id}.state`
+        )
+      }
+    )
+
+  /** @experimental */
+  alt2: <
+    const Id extends string,
+    MutArgs extends Array<unknown>,
+    MutA,
+    MutE,
+    MutR,
+    const I18nKey extends string = Id,
+    State extends IntlRecord | undefined = undefined
+  >(
+    id:
+      | Id
+      | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
+      | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
+    options?: FnOptions<I18nKey, State>
+  ) =>
+    & Commander.CommandContextLocal<Id, I18nKey>
+    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+      handler: (
+        ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander.CommandContextLocal<Id, I18nKey> & {
+          // todo: only if we passed in one
+          mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
+        }
+      ) => (...args: Args) => Effect.Effect<A, E, R>
+    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
+      _id,
+      options?
+    ) => {
+      const isObject = typeof _id === "object" || typeof _id === "function"
+      const id = isObject ? _id.id : _id
+      const baseInfo = makeBaseInfo(id, options)
+      const idCmd = this.makeCommand(id, options)
+      // TODO: implement proper tracing stack
+      return Object.assign((cb: any) =>
+        idCmd(cb(
+          Object.assign(
+            (fn: any, ...combinators: any[]) =>
+              Effect.fnUntraced(
+                // fnUntraced only supports generators as first arg, so we convert to generator if needed
+                isGeneratorFunction(fn) ? fn : function*(...args) {
+                  return yield* fn(...args)
+                },
+                ...combinators as [any]
+              ),
+            baseInfo,
+            isObject
+              ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
+              : {}
+          )
+        )), baseInfo) as any
+    }
+
+  /** @experimental */
+  alt = this.makeCommand as unknown as <
+    const Id extends string,
+    const I18nKey extends string = Id,
+    State extends IntlRecord | undefined = undefined
+  >(
+    id: Id,
+    customI18nKey?: I18nKey
+  ) =>
+    & Commander.CommandContextLocal<Id, I18nKey>
+    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+      handler: (...args: Args) => Effect.Effect<A, E, R>
+    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>)
+
+  /**
+   * Define a Command for handling user actions with built-in error reporting and state management.
+   *
+   * @param mutation The mutation function to take the identifier and initial handler from. Used as a tracing span and to lookup
+   *                   the user-facing name via internationalization (`action.${id}`).
+   * @param options Optional configuration for internationalization and state.
+   * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+   * @param options.state Optional reactive state object (or function returning one) that is
+   *                     made available to the command effects and can be used for i18n interpolation.
+   *                     The state is captured at the start of each command execution and remains stable throughout.
+   * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+   *          Built-in error reporting handles failures automatically.
+   *
+   * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+   * the user-facing action name.
+   *
+   * **Returned Properties**:
+   * - `action`: User-facing action name from intl messages (useful for button labels)
+   * - `result`: The command result state
+   * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+   * - `handle`: Function to execute the command
+   * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+   * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+   *
+   * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+   * the `result` inline for custom UI feedback.
+   */
+  wrap = <
+    const Id extends string,
+    Args extends Array<unknown>,
+    A,
+    E,
+    R,
+    const State extends IntlRecord = IntlRecord,
+    I18nKey extends string = Id
+  >(
+    mutation:
+      | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
+      | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id },
+    options?: FnOptions<I18nKey, State>
+  ): Commander.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
+    Object.assign(
+      (
+        ...combinators: any[]
+      ): any => {
+        // we capture the definition stack here, so we can append it to later stack traces
+        const limit = Error.stackTraceLimit
+        Error.stackTraceLimit = 2
+        const errorDef = new Error()
+        Error.stackTraceLimit = limit
+
+        const mutate = "mutate" in mutation ? mutation.mutate : mutation
+
+        return this.makeCommand(mutation.id, options, errorDef)(
+          Effect.fnUntraced(
+            // fnUntraced only supports generators as first arg, so we convert to generator if needed
+            isGeneratorFunction(mutate) ? mutate : function*(...args: Args) {
+              return yield* mutate(...args)
+            },
+            ...combinators as [any]
+          ) as any
+        )
+      },
+      makeBaseInfo(mutation.id, options),
+      {
+        state: Context.GenericTag<`Commander.Command.${Id}.state`, State>(
+          `Commander.Command.${mutation.id}.state`
+        )
+      }
+    )
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class Commander extends Effect.Service<Commander>()("Commander", {
+  dependencies: [WithToast.Default, Confirm.Default],
+  effect: Effect.gen(function*() {
+    const i18n = yield* I18n
+    return <RT>(rt: Runtime.Runtime<RT>) => new CommanderImpl(rt, i18n)
+  })
+}) {}

From 016876b93ffc60767dd3e4c59ae225d995db5775 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 09:25:42 +0200
Subject: [PATCH 2/6] prep

---
 packages/vue/src/experimental/commander2.ts | 617 ++++++++++----------
 1 file changed, 324 insertions(+), 293 deletions(-)

diff --git a/packages/vue/src/experimental/commander2.ts b/packages/vue/src/experimental/commander2.ts
index 21e6464673..c85b741fb4 100644
--- a/packages/vue/src/experimental/commander2.ts
+++ b/packages/vue/src/experimental/commander2.ts
@@ -34,13 +34,11 @@ type FnOptionsInternal<I18nCustomKey extends string> = {
   state?: IntlRecord | undefined
 }
 
-export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void
-
-export declare namespace Commander {
+export declare namespace Commander2 {
   export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
-    & Commander.Gen<RT, Id, I18nKey, State>
-    & Commander.NonGen<RT, Id, I18nKey, State>
-    & Commander.CommandContextLocal<Id, I18nKey>
+    & Gen<RT, Id, I18nKey, State>
+    & NonGen<RT, Id, I18nKey, State>
+    & CommandContextLocal<Id, I18nKey>
     & {
       state: Context.Tag<`Commander.Command.${Id}.state`, State>
     }
@@ -92,7 +90,7 @@ export declare namespace Commander {
   }
 
   export interface CommandOut<
-    Args extends Array<unknown>,
+    Arg,
     A,
     E,
     R,
@@ -103,35 +101,41 @@ export declare namespace Commander {
     new(): {}
 
     /** click handlers */
-    handle: ((...args: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
+    handle: ((arg: Arg) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
       /** @deprecated don't exist */
-      effect: (...args: Args) => Effect.Effect<A, E, R>
+      effect: (arg: Arg) => Effect.Effect<A, E, R>
     }
 
     // // TODO: if we keep them, it would probably be nicer as an option api, deciding the return value like in Atom?
     // /** @experimental */
-    // compose: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, R>
+    // compose: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, R>
     // /** @experimental */
-    // compose2: (...args: Args) => Effect.Effect<A, E, R>
+    // compose2: (arg: Arg) => Effect.Effect<A, E, R>
     // /**
     //  * @experimental
     //  * captures the current span and returns an Effect that when run will execute the command
     //  */
-    // handleEffect: (...args: Args) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
+    // handleEffect: (arg: Arg) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
     // /**
     //  * @experimental
     //  */
-    // exec: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
+    // exec: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
+  }
+
+  export interface CommandContextLocal2<Id extends string, I18nKey extends string, State extends IntlRecord | undefined>
+    extends CommandContextLocal<Id, I18nKey>
+  {
+    state: State
   }
 
   type CommandOutHelper<
-    Args extends Array<unknown>,
+    Arg,
     Eff extends Effect.Effect<any, any, any>,
     Id extends string,
     I18nKey extends string,
     State extends IntlRecord | undefined
   > = CommandOut<
-    Args,
+    Arg,
     Effect.Effect.Success<Eff>,
     Effect.Effect.Error<Eff>,
     Effect.Effect.Context<Eff>,
@@ -144,11 +148,11 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
       AEff,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>
+      body: (arg: Arg) => Generator<Eff, AEff, never>
     ): CommandOut<
-      Args,
+      Arg,
       AEff,
       [Eff] extends [never] ? never
         : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
@@ -163,10 +167,10 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -177,17 +181,18 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
-    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -198,19 +203,20 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B
-    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -221,21 +227,22 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C
-    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
+    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
       D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -246,23 +253,24 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D
-    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
+    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
       D,
       E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -273,17 +281,18 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E
-    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
+    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
@@ -291,7 +300,7 @@ export declare namespace Commander {
       E,
       F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -302,18 +311,19 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F
-    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
+    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
@@ -322,7 +332,7 @@ export declare namespace Commander {
       F,
       G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -333,19 +343,20 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G
-    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
+    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
@@ -355,7 +366,7 @@ export declare namespace Commander {
       G,
       H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -366,20 +377,21 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H
-    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
+    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
+      Arg,
       A,
       B,
       C,
@@ -390,7 +402,7 @@ export declare namespace Commander {
       H,
       I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -401,70 +413,71 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H,
-      i: (_: H, ...args: NoInfer<Args>) => I
-    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
+    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
   export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
       C,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
       C,
       D,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -472,15 +485,15 @@ export declare namespace Commander {
       C,
       D,
       E,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -489,16 +502,16 @@ export declare namespace Commander {
       D,
       E,
       F,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -508,17 +521,17 @@ export declare namespace Commander {
       E,
       F,
       G,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -529,18 +542,18 @@ export declare namespace Commander {
       F,
       G,
       H,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -552,33 +565,33 @@ export declare namespace Commander {
       G,
       H,
       I,
-      Args extends Array<unknown>
+      Arg
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => I,
-      i: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
   }
 
   export type GenWrap<
     RT,
     Id extends string,
     I18nKey extends string,
-    Args extends Array<unknown>,
+    Arg,
     AEff,
     EEff,
     REff,
     State extends IntlRecord | undefined
   > = {
     (): Exclude<REff, RT> extends never ? CommandOut<
-        Args,
+        Arg,
         AEff,
         EEff,
         REff,
@@ -596,9 +609,10 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
-    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
     <
       A,
       B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
@@ -609,10 +623,11 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B
-    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       A,
       B,
@@ -624,11 +639,12 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C
-    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
+    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       A,
       B,
@@ -641,12 +657,13 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D
-    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
+    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       A,
       B,
@@ -660,13 +677,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E
-    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
+    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       A,
       B,
@@ -681,14 +699,15 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F
-    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
+    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       A,
       B,
@@ -704,15 +723,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G
-    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
+    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
     <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
       a: (
         _: Effect.Effect<
@@ -720,16 +740,17 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H
-    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
+    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
     <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
       a: (
         _: Effect.Effect<
@@ -737,34 +758,35 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H,
-      i: (_: H, ...args: NoInfer<Args>) => I
-    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
+    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
   export type NonGenWrap<
     RT,
     Id extends string,
     I18nKey extends string,
-    Args extends Array<unknown>,
+    Arg,
     AEff,
     EEff,
     REff,
     State extends IntlRecord | undefined
   > = {
-    (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
+    (): Exclude<REff, RT> extends never ? CommandOutHelper<Arg, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
       : MissingDependencies<RT, REff> & {}
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -772,13 +794,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -786,15 +809,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -802,17 +826,18 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
       D,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -820,19 +845,20 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
       D,
       E,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -840,13 +866,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -854,7 +881,7 @@ export declare namespace Commander {
       D,
       E,
       F,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -862,14 +889,15 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -878,7 +906,7 @@ export declare namespace Commander {
       E,
       F,
       G,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -886,15 +914,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -904,7 +933,7 @@ export declare namespace Commander {
       F,
       G,
       H,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -912,16 +941,17 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -932,7 +962,7 @@ export declare namespace Commander {
       G,
       H,
       I,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -940,17 +970,18 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => I,
-      i: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
   }
 }
 
@@ -1508,7 +1539,7 @@ export class CommanderImpl<RT> {
   >(
     id: Id | { id: Id },
     options?: FnOptions<I18nKey, State>
-  ): Commander.Gen<RT, Id, I18nKey, State> & Commander.NonGen<RT, Id, I18nKey, State> & {
+  ): Commander2.Gen<RT, Id, I18nKey, State> & Commander2.NonGen<RT, Id, I18nKey, State> & {
     state: Context.Tag<`Commander.Command.${Id}.state`, State>
   } =>
     Object.assign(
@@ -1556,15 +1587,15 @@ export class CommanderImpl<RT> {
       | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
     options?: FnOptions<I18nKey, State>
   ) =>
-    & Commander.CommandContextLocal<Id, I18nKey>
+    & Commander2.CommandContextLocal<Id, I18nKey>
     & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
       handler: (
-        ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander.CommandContextLocal<Id, I18nKey> & {
+        ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander2.CommandContextLocal<Id, I18nKey> & {
           // todo: only if we passed in one
           mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
         }
       ) => (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
+    ) => Commander2.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
       _id,
       options?
     ) => {
@@ -1601,10 +1632,10 @@ export class CommanderImpl<RT> {
     id: Id,
     customI18nKey?: I18nKey
   ) =>
-    & Commander.CommandContextLocal<Id, I18nKey>
+    & Commander2.CommandContextLocal<Id, I18nKey>
     & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
       handler: (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>)
+    ) => Commander2.CommandOut<Args, A, E, R, Id, I18nKey, State>)
 
   /**
    * Define a Command for handling user actions with built-in error reporting and state management.
@@ -1646,7 +1677,7 @@ export class CommanderImpl<RT> {
       | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
       | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id },
     options?: FnOptions<I18nKey, State>
-  ): Commander.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
+  ): Commander2.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
     Object.assign(
       (
         ...combinators: any[]

From 18223c3277d28a8b167176246459aa9693ed768b Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 09:36:24 +0200
Subject: [PATCH 3/6] progress

---
 packages/vue/src/experimental/commander2.ts | 46 ++++++++++-----------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/packages/vue/src/experimental/commander2.ts b/packages/vue/src/experimental/commander2.ts
index c85b741fb4..b3bd7cb844 100644
--- a/packages/vue/src/experimental/commander2.ts
+++ b/packages/vue/src/experimental/commander2.ts
@@ -51,7 +51,7 @@ export declare namespace Commander2 {
     Id extends string,
     I18nCustomKey extends string,
     State extends IntlRecord | undefined,
-    I extends any[],
+    I,
     A,
     E,
     R
@@ -1284,8 +1284,8 @@ export class CommanderImpl<RT> {
     const state = getStateValues(options)
 
     return Object.assign(
-      <Args extends ReadonlyArray<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
-        handler: (...args: Args) => Effect.Effect<A, E, R>
+      <Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+        handler: (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
       ) => {
         // we capture the definition stack here, so we can append it to later stack traces
         const limit = Error.stackTraceLimit
@@ -1363,7 +1363,7 @@ export class CommanderImpl<RT> {
         const exec = options?.disableSharedWaiting
           ? exec_
           : Effect
-            .fnUntraced(function*(...args: Args) {
+            .fnUntraced(function*(...args: [any, any]) {
               registerWait(id)
               return yield* exec_(...args)
             }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
@@ -1372,7 +1372,7 @@ export class CommanderImpl<RT> {
           ? computed(() => result.value.waiting)
           : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
 
-        const handle = Object.assign((...args: Args) => {
+        const handle = Object.assign((arg: Arg) => {
           // we capture the call site stack here
           const limit = Error.stackTraceLimit
           Error.stackTraceLimit = 2
@@ -1405,12 +1405,12 @@ export class CommanderImpl<RT> {
 
           const command = currentState.pipe(Effect.flatMap((state) =>
             Effect.withSpan(
-              exec(...args),
+              exec(arg, { ...context.value, state } as any),
               id,
               {
                 captureStackTrace,
                 attributes: {
-                  input: args,
+                  input: arg,
                   state,
                   action: initialContext.action,
                   label: initialContext.label,
@@ -1574,7 +1574,7 @@ export class CommanderImpl<RT> {
   /** @experimental */
   alt2: <
     const Id extends string,
-    MutArgs extends Array<unknown>,
+    MutArg,
     MutA,
     MutE,
     MutR,
@@ -1583,19 +1583,19 @@ export class CommanderImpl<RT> {
   >(
     id:
       | Id
-      | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
-      | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
+      | { id: Id; mutate: (arg: MutArg) => Effect.Effect<MutA, MutE, MutR> }
+      | ((arg: MutArg) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
     options?: FnOptions<I18nKey, State>
   ) =>
     & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+    & (<Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
       handler: (
         ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander2.CommandContextLocal<Id, I18nKey> & {
           // todo: only if we passed in one
-          mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
+          mutate: (arg: Arg) => Effect.Effect<MutA, MutE, MutR>
         }
-      ) => (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander2.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
+      ) => (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
+    ) => Commander2.CommandOut<Arg, A, E, R, Id, I18nKey, State>) = (
       _id,
       options?
     ) => {
@@ -1633,9 +1633,9 @@ export class CommanderImpl<RT> {
     customI18nKey?: I18nKey
   ) =>
     & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
-      handler: (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander2.CommandOut<Args, A, E, R, Id, I18nKey, State>)
+    & (<Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+      handler: (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
+    ) => Commander2.CommandOut<Arg, A, E, R, Id, I18nKey, State>)
 
   /**
    * Define a Command for handling user actions with built-in error reporting and state management.
@@ -1666,7 +1666,7 @@ export class CommanderImpl<RT> {
    */
   wrap = <
     const Id extends string,
-    Args extends Array<unknown>,
+    Arg,
     A,
     E,
     R,
@@ -1674,10 +1674,10 @@ export class CommanderImpl<RT> {
     I18nKey extends string = Id
   >(
     mutation:
-      | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
-      | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id },
+      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
+      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
     options?: FnOptions<I18nKey, State>
-  ): Commander2.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
+  ): Commander2.CommanderWrap<RT, Id, I18nKey, State, Arg, A, E, R> =>
     Object.assign(
       (
         ...combinators: any[]
@@ -1693,8 +1693,8 @@ export class CommanderImpl<RT> {
         return this.makeCommand(mutation.id, options, errorDef)(
           Effect.fnUntraced(
             // fnUntraced only supports generators as first arg, so we convert to generator if needed
-            isGeneratorFunction(mutate) ? mutate : function*(...args: Args) {
-              return yield* mutate(...args)
+            isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
+              return yield* mutate(arg)
             },
             ...combinators as [any]
           ) as any

From 46e3280c8f77f2c9599d08d02a479b3badc030e3 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 09:56:49 +0200
Subject: [PATCH 4/6] update test setup

---
 package.json        | 1 +
 pnpm-lock.yaml      | 3 +++
 vite.config.base.ts | 4 +++-
 vitest.setup.ts     | 3 +++
 4 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 vitest.setup.ts

diff --git a/package.json b/package.json
index 48a94db980..8233016f46 100644
--- a/package.json
+++ b/package.json
@@ -64,6 +64,7 @@
     "@effect/language-service": "0.41.1",
     "@effect/platform": "^0.92.0",
     "@effect/platform-node": "^0.98.0",
+    "@effect/vitest": "^0.26.0",
     "@tsconfig/strictest": "^2.0.6",
     "@types/lodash": "^4.17.20",
     "@types/node": "~24.6.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c0a9d9ac49..c82f17bf9e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -67,6 +67,9 @@ importers:
       '@effect/platform-node':
         specifier: ^0.98.0
         version: 0.98.0(@effect/cluster@0.46.4(75de7a998cf2258bdcd42684c0598ed2))(@effect/platform@0.92.0(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(@effect/rpc@0.71.0(@effect/platform@0.92.0(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(@effect/sql@0.46.0(@effect/experimental@0.56.0(@effect/platform@0.92.0(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(@effect/platform@0.92.0(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a)))(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a))
+      '@effect/vitest':
+        specifier: ^0.26.0
+        version: 0.26.0(effect@3.18.0(patch_hash=43c3b64130695b34e77e33c4bce41699657064974a32b770f14bbeefe69bf30a))(vitest@3.2.4(@types/node@24.6.0)(jsdom@27.0.0(postcss@8.5.6))(sass@1.93.2)(terser@5.44.0)(tsx@4.20.6)(yaml@2.8.1))
       '@tsconfig/strictest':
         specifier: ^2.0.6
         version: 2.0.6
diff --git a/vite.config.base.ts b/vite.config.base.ts
index 223b137861..7586a0d532 100644
--- a/vite.config.base.ts
+++ b/vite.config.base.ts
@@ -12,6 +12,7 @@ import fs from "fs"
 //   ]
 // })
 
+
 export default function makeConfig(dirName?: string) {
   const prefix = path.resolve(__dirname, "packages")
   const packages = fs.readdirSync(prefix).map(f => prefix + "/" + f).filter(f => fs.lstatSync(f).isDirectory() )
@@ -21,7 +22,8 @@ export default function makeConfig(dirName?: string) {
     test: {
       include:  ["./test/**/*.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
       reporters: "verbose",
-      globals: true
+      globals: true,
+      setupFiles: [path.join(__dirname, "vitest.setup.ts")],
     },
     resolve: {
       alias: packages.map(pkg => ({ pkg, json: pkg + "/package.json"})).filter(_ => fs.existsSync(_.json)).reduce((acc, { pkg, json}) => { 
diff --git a/vitest.setup.ts b/vitest.setup.ts
new file mode 100644
index 0000000000..7c3c6dccbc
--- /dev/null
+++ b/vitest.setup.ts
@@ -0,0 +1,3 @@
+import { addEqualityTesters } from "@effect/vitest"
+
+addEqualityTesters()
\ No newline at end of file

From 21f74682689abf70f3562896e984d03e046d832f Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 10:03:05 +0200
Subject: [PATCH 5/6] commander2

---
 .changeset/huge-bobcats-greet.md              |  5 ++
 packages/vue/package.json                     |  4 ++
 packages/vue/src/experimental/commander2.ts   | 66 +++++++++----------
 .../vue/src/experimental/makeUseCommand.ts    |  4 +-
 packages/vue/src/makeClient.ts                |  3 +-
 packages/vue/test/Mutation.test.ts            | 39 ++++++-----
 packages/vue/test/stubs.ts                    |  6 +-
 7 files changed, 73 insertions(+), 54 deletions(-)
 create mode 100644 .changeset/huge-bobcats-greet.md

diff --git a/.changeset/huge-bobcats-greet.md b/.changeset/huge-bobcats-greet.md
new file mode 100644
index 0000000000..a19d21933c
--- /dev/null
+++ b/.changeset/huge-bobcats-greet.md
@@ -0,0 +1,5 @@
+---
+"@effect-app/vue": minor
+---
+
+introduce Commander2, which is unary and passes context as second arg.
diff --git a/packages/vue/package.json b/packages/vue/package.json
index f02e1beab3..2684f85f20 100644
--- a/packages/vue/package.json
+++ b/packages/vue/package.json
@@ -54,6 +54,10 @@
       "types": "./dist/experimental/commander.d.ts",
       "default": "./dist/experimental/commander.js"
     },
+    "./experimental/commander2": {
+      "types": "./dist/experimental/commander2.d.ts",
+      "default": "./dist/experimental/commander2.js"
+    },
     "./experimental/confirm": {
       "types": "./dist/experimental/confirm.d.ts",
       "default": "./dist/experimental/confirm.js"
diff --git a/packages/vue/src/experimental/commander2.ts b/packages/vue/src/experimental/commander2.ts
index b3bd7cb844..ef57b98a2a 100644
--- a/packages/vue/src/experimental/commander2.ts
+++ b/packages/vue/src/experimental/commander2.ts
@@ -148,7 +148,7 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
       AEff,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg) => Generator<Eff, AEff, never>
     ): CommandOut<
@@ -167,8 +167,8 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
-      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -188,9 +188,9 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
-      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -211,10 +211,10 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
-      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -236,11 +236,11 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
-      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -263,12 +263,12 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
       D,
-      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -292,13 +292,13 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
       D,
       E,
-      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -323,14 +323,14 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
       D,
       E,
       F,
-      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -356,7 +356,6 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
@@ -364,7 +363,8 @@ export declare namespace Commander2 {
       E,
       F,
       G,
-      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -391,7 +391,6 @@ export declare namespace Commander2 {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Arg,
       A,
       B,
       C,
@@ -400,7 +399,8 @@ export declare namespace Commander2 {
       F,
       G,
       H,
-      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
@@ -430,14 +430,14 @@ export declare namespace Commander2 {
   export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff
     ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
@@ -446,7 +446,7 @@ export declare namespace Commander2 {
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -457,7 +457,7 @@ export declare namespace Commander2 {
       A,
       B,
       C,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -470,7 +470,7 @@ export declare namespace Commander2 {
       B,
       C,
       D,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -485,7 +485,7 @@ export declare namespace Commander2 {
       C,
       D,
       E,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -502,7 +502,7 @@ export declare namespace Commander2 {
       D,
       E,
       F,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -521,7 +521,7 @@ export declare namespace Commander2 {
       E,
       F,
       G,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -542,7 +542,7 @@ export declare namespace Commander2 {
       F,
       G,
       H,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -565,7 +565,7 @@ export declare namespace Commander2 {
       G,
       H,
       I,
-      Arg
+      Arg = void
     >(
       body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
       a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
@@ -1571,7 +1571,7 @@ export class CommanderImpl<RT> {
       }
     )
 
-  /** @experimental */
+  /** @experimental @deprecated */
   alt2: <
     const Id extends string,
     MutArg,
@@ -1588,7 +1588,7 @@ export class CommanderImpl<RT> {
     options?: FnOptions<I18nKey, State>
   ) =>
     & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
       handler: (
         ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander2.CommandContextLocal<Id, I18nKey> & {
           // todo: only if we passed in one
@@ -1633,7 +1633,7 @@ export class CommanderImpl<RT> {
     customI18nKey?: I18nKey
   ) =>
     & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
       handler: (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
     ) => Commander2.CommandOut<Arg, A, E, R, Id, I18nKey, State>)
 
@@ -1710,7 +1710,7 @@ export class CommanderImpl<RT> {
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class Commander extends Effect.Service<Commander>()("Commander", {
+export class Commander2 extends Effect.Service<Commander2>()("Commander2", {
   dependencies: [WithToast.Default, Confirm.Default],
   effect: Effect.gen(function*() {
     const i18n = yield* I18n
diff --git a/packages/vue/src/experimental/makeUseCommand.ts b/packages/vue/src/experimental/makeUseCommand.ts
index afbb2cd026..7a955ee092 100644
--- a/packages/vue/src/experimental/makeUseCommand.ts
+++ b/packages/vue/src/experimental/makeUseCommand.ts
@@ -1,5 +1,5 @@
 import { Effect } from "effect-app"
-import { Commander, type CommanderImpl, CommanderStatic } from "./commander.js"
+import { Commander2, type CommanderImpl, CommanderStatic } from "./commander2.js"
 
 type X<X> = X
 
@@ -10,7 +10,7 @@ export interface CommanderResolved<RT>
 }
 
 export const makeUseCommand = Effect.fnUntraced(function*<R = never>() {
-  const cmndr = yield* Commander
+  const cmndr = yield* Commander2
   const runtime = yield* Effect.runtime<R>()
 
   const comm = cmndr(runtime)
diff --git a/packages/vue/src/makeClient.ts b/packages/vue/src/makeClient.ts
index 0a74e374cd..3b6efadfb2 100644
--- a/packages/vue/src/makeClient.ts
+++ b/packages/vue/src/makeClient.ts
@@ -14,6 +14,7 @@ import { type RuntimeFiber } from "effect/Fiber"
 import { computed, type ComputedRef, onBeforeUnmount, type Ref, ref, watch, type WatchSource } from "vue"
 import { reportMessage } from "./errorReporter.js"
 import { type Commander, CommanderStatic } from "./experimental/commander.js"
+import { type Commander2 } from "./experimental/commander2.js"
 import { I18n } from "./experimental/intl.js"
 import { type CommanderResolved, makeUseCommand } from "./experimental/makeUseCommand.js"
 import { Toast } from "./experimental/toast.js"
@@ -1247,7 +1248,7 @@ export class QueryImpl<R> {
 const managedRuntimeRt = <A, E>(mrt: ManagedRuntime.ManagedRuntime<A, E>) => mrt.runSync(Effect.runtime<A>())
 
 type Base = I18n | Toast
-type Mix = ApiClientFactory | Commander | LegacyMutation | Base
+type Mix = ApiClientFactory | Commander2 | LegacyMutation | Base
 export const makeClient = <RT_>(
   // global, but only accessible after startup has completed
   getBaseMrt: () => ManagedRuntime.ManagedRuntime<RT_ | Mix, never>,
diff --git a/packages/vue/test/Mutation.test.ts b/packages/vue/test/Mutation.test.ts
index 153ddcd937..bf352e35ec 100644
--- a/packages/vue/test/Mutation.test.ts
+++ b/packages/vue/test/Mutation.test.ts
@@ -24,10 +24,10 @@ describe("alt2", () => {
 
         const someMutation = {
           id: "Test Action",
-          mutate: (() => {}) as unknown as (a: number, b: string) => Effect.Effect<string, number, CommandContext>
+          mutate: (() => {}) as unknown as (a: number) => Effect.Effect<string, number, CommandContext>
         } as const
         const someMutation2 = Object.assign(
-          (() => {}) as unknown as (a: number, b: string) => Effect.Effect<string, number, CommandContext>,
+          (() => {}) as unknown as (a: number) => Effect.Effect<string, number, CommandContext>,
           {
             id: "Test Action"
           } as const
@@ -252,16 +252,19 @@ it.live("can receive and use input", () =>
       let executed = false
 
       const command = Command.fn("Test Action")(
-        function*(input1: number, input2: string) {
+        function*(input1: number, input2) {
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
           return { input1, input2 }
         },
         Effect.tap(() => executed = true)
       )
-      const r = yield* unwrap(command.handle(1, "2"))
+      const r = yield* unwrap(command.handle(1))
 
-      expect(r).toEqual({ input1: 1, input2: "2" }) // to confirm that the initial function has ran and received input.
+      expect(r.input1).toBe(1) // to confirm that the initial function has ran and received input.
+      const { handle, result, waiting, ...rest } = command
+      const ctx = { ...rest, state: undefined }
+      expect(JSON.stringify(r.input2)).equal(JSON.stringify(ctx))
       expect(executed).toBe(true) // to confirm that the combinators have ran.
     }))
 
@@ -547,19 +550,25 @@ it.live("can receive and use input with alt", () =>
 
       let executed = false
 
-      const command = Command.alt("Test Action")(
-        Effect.fnUntraced(
-          function*(input1: number, input2: string) {
-            expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+      const command = Command.alt("Test Action")((input1: number, input2) =>
+        Effect
+          .gen(
+            function*() {
+              expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
-            return { input1, input2 }
-          },
-          Effect.tap(() => executed = true)
-        )
+              return { input1, input2 }
+            }
+          )
+          .pipe(
+            Effect.tap(() => executed = true)
+          )
       )
-      const r = yield* unwrap(command.handle(1, "2"))
+      const r = yield* unwrap(command.handle(1))
 
-      expect(r).toEqual({ input1: 1, input2: "2" }) // to confirm that the initial function has ran and received input.
+      const { handle, result, waiting, ...rest } = command
+      const ctx = { ...rest, state: undefined }
+      expect(r.input1).toBe(1)
+      expect(JSON.stringify(r.input2)).equal(JSON.stringify(ctx)) // to confirm that the initial function has ran and received input.
       expect(executed).toBe(true) // to confirm that the combinators have ran.
     }))
 
diff --git a/packages/vue/test/stubs.ts b/packages/vue/test/stubs.ts
index 988dde8712..b354c4ab0a 100644
--- a/packages/vue/test/stubs.ts
+++ b/packages/vue/test/stubs.ts
@@ -6,7 +6,7 @@ import { Effect, Layer, ManagedRuntime, Option, S } from "effect-app"
 import { ApiClientFactory, makeRpcClient } from "effect-app/client"
 import { RpcContextMap } from "effect-app/rpc"
 import { ref } from "vue"
-import { Commander } from "../src/experimental/commander.js"
+import { Commander2 } from "../src/experimental/commander2.js"
 import { I18n } from "../src/experimental/intl.js"
 import { makeUseCommand } from "../src/experimental/makeUseCommand.js"
 import * as Toast from "../src/experimental/toast.js"
@@ -83,7 +83,7 @@ export const useExperimental = (
 ) => {
   const FakeIntlLayer = fakeIntlLayer(options?.messages)
   const FakeToastLayer = fakeToastLayer(options?.toasts)
-  const CommanderLayer = Commander.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
+  const CommanderLayer = Commander2.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
   const WithToastLayer = WithToast.Default.pipe(Layer.provide(FakeToastLayer))
   const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer)
 
@@ -110,7 +110,7 @@ export const useClient = (
 ) => {
   const FakeIntlLayer = fakeIntlLayer(options?.messages)
   const FakeToastLayer = fakeToastLayer(options?.toasts)
-  const CommanderLayer = Commander.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
+  const CommanderLayer = Commander2.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
   const WithToastLayer = WithToast.Default.pipe(Layer.provide(FakeToastLayer))
   const api = ApiClientFactory.layer({ url: "bogus", headers: Option.none() }).pipe(
     Layer.provide(FetchHttpClient.layer)

From 8fc7fa54bdc6d2a985e0a0f83dde6354f3397f16 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 14 Oct 2025 10:06:04 +0200
Subject: [PATCH 6/6] just replace the original Commander.

---
 .changeset/huge-bobcats-greet.md              |    2 +-
 packages/vue/src/experimental/commander.ts    |  665 ++++---
 packages/vue/src/experimental/commander2.ts   | 1719 -----------------
 .../vue/src/experimental/makeUseCommand.ts    |    4 +-
 packages/vue/src/makeClient.ts                |    3 +-
 packages/vue/test/stubs.ts                    |    6 +-
 6 files changed, 356 insertions(+), 2043 deletions(-)
 delete mode 100644 packages/vue/src/experimental/commander2.ts

diff --git a/.changeset/huge-bobcats-greet.md b/.changeset/huge-bobcats-greet.md
index a19d21933c..1d06304ea3 100644
--- a/.changeset/huge-bobcats-greet.md
+++ b/.changeset/huge-bobcats-greet.md
@@ -2,4 +2,4 @@
 "@effect-app/vue": minor
 ---
 
-introduce Commander2, which is unary and passes context as second arg.
+Change Commander to be unary and pass Context as second arg.
\ No newline at end of file
diff --git a/packages/vue/src/experimental/commander.ts b/packages/vue/src/experimental/commander.ts
index 10718fa818..382967f33b 100644
--- a/packages/vue/src/experimental/commander.ts
+++ b/packages/vue/src/experimental/commander.ts
@@ -93,9 +93,9 @@ export const wrapEmit = <A, Event extends string>(
 
 export declare namespace Commander {
   export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
-    & Commander.Gen<RT, Id, I18nKey, State>
-    & Commander.NonGen<RT, Id, I18nKey, State>
-    & Commander.CommandContextLocal<Id, I18nKey>
+    & Gen<RT, Id, I18nKey, State>
+    & NonGen<RT, Id, I18nKey, State>
+    & CommandContextLocal<Id, I18nKey>
     & {
       state: Context.Tag<`Commander.Command.${Id}.state`, State>
     }
@@ -108,7 +108,7 @@ export declare namespace Commander {
     Id extends string,
     I18nCustomKey extends string,
     State extends IntlRecord | undefined,
-    I extends any[],
+    I,
     A,
     E,
     R
@@ -147,7 +147,7 @@ export declare namespace Commander {
   }
 
   export interface CommandOut<
-    Args extends Array<unknown>,
+    Arg,
     A,
     E,
     R,
@@ -158,35 +158,41 @@ export declare namespace Commander {
     new(): {}
 
     /** click handlers */
-    handle: ((...args: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
+    handle: ((arg: Arg) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
       /** @deprecated don't exist */
-      effect: (...args: Args) => Effect.Effect<A, E, R>
+      effect: (arg: Arg) => Effect.Effect<A, E, R>
     }
 
     // // TODO: if we keep them, it would probably be nicer as an option api, deciding the return value like in Atom?
     // /** @experimental */
-    // compose: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, R>
+    // compose: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, R>
     // /** @experimental */
-    // compose2: (...args: Args) => Effect.Effect<A, E, R>
+    // compose2: (arg: Arg) => Effect.Effect<A, E, R>
     // /**
     //  * @experimental
     //  * captures the current span and returns an Effect that when run will execute the command
     //  */
-    // handleEffect: (...args: Args) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
+    // handleEffect: (arg: Arg) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
     // /**
     //  * @experimental
     //  */
-    // exec: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
+    // exec: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
+  }
+
+  export interface CommandContextLocal2<Id extends string, I18nKey extends string, State extends IntlRecord | undefined>
+    extends CommandContextLocal<Id, I18nKey>
+  {
+    state: State
   }
 
   type CommandOutHelper<
-    Args extends Array<unknown>,
+    Arg,
     Eff extends Effect.Effect<any, any, any>,
     Id extends string,
     I18nKey extends string,
     State extends IntlRecord | undefined
   > = CommandOut<
-    Args,
+    Arg,
     Effect.Effect.Success<Eff>,
     Effect.Effect.Error<Eff>,
     Effect.Effect.Context<Eff>,
@@ -199,11 +205,11 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
       AEff,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>
+      body: (arg: Arg) => Generator<Eff, AEff, never>
     ): CommandOut<
-      Args,
+      Arg,
       AEff,
       [Eff] extends [never] ? never
         : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
@@ -218,10 +224,10 @@ export declare namespace Commander {
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
-      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -232,17 +238,18 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
-    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
-      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -253,19 +260,20 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B
-    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
-      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -276,21 +284,22 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C
-    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
+    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
-      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -301,23 +310,24 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D
-    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
+    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
       D,
-      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -328,25 +338,26 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E
-    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
+    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
       D,
       E,
-      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -357,27 +368,28 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F
-    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
+    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
       D,
       E,
       F,
-      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -388,19 +400,19 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G
-    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
+    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -408,9 +420,10 @@ export declare namespace Commander {
       E,
       F,
       G,
-      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -421,20 +434,20 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H
-    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
+    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
     <
       Eff extends YieldWrap<Effect.Effect<any, any, any>>,
       AEff,
-      Args extends Array<unknown>,
       A,
       B,
       C,
@@ -443,9 +456,10 @@ export declare namespace Commander {
       F,
       G,
       H,
-      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
+      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
+      Arg = void
     >(
-      body: (...args: Args) => Generator<Eff, AEff, never>,
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
       a: (
         _: Effect.Effect<
           AEff,
@@ -456,70 +470,71 @@ export declare namespace Commander {
             : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
             : never
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H,
-      i: (_: H, ...args: NoInfer<Args>) => I
-    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
+    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
   export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
       C,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
       B,
       C,
       D,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -527,15 +542,15 @@ export declare namespace Commander {
       C,
       D,
       E,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -544,16 +559,16 @@ export declare namespace Commander {
       D,
       E,
       F,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -563,17 +578,17 @@ export declare namespace Commander {
       E,
       F,
       G,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -584,18 +599,18 @@ export declare namespace Commander {
       F,
       G,
       H,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       A,
@@ -607,33 +622,33 @@ export declare namespace Commander {
       G,
       H,
       I,
-      Args extends Array<unknown>
+      Arg = void
     >(
-      body: (...args: Args) => A,
-      a: (_: A, ...args: NoInfer<Args>) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => I,
-      i: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
+      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
   }
 
   export type GenWrap<
     RT,
     Id extends string,
     I18nKey extends string,
-    Args extends Array<unknown>,
+    Arg,
     AEff,
     EEff,
     REff,
     State extends IntlRecord | undefined
   > = {
     (): Exclude<REff, RT> extends never ? CommandOut<
-        Args,
+        Arg,
         AEff,
         EEff,
         REff,
@@ -651,9 +666,10 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
-    ): CommandOutHelper<Args, A, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
     <
       A,
       B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
@@ -664,10 +680,11 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B
-    ): CommandOutHelper<Args, B, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       A,
       B,
@@ -679,11 +696,12 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C
-    ): CommandOutHelper<Args, C, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
+    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       A,
       B,
@@ -696,12 +714,13 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D
-    ): CommandOutHelper<Args, D, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
+    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       A,
       B,
@@ -715,13 +734,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E
-    ): CommandOutHelper<Args, E, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
+    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       A,
       B,
@@ -736,14 +756,15 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F
-    ): CommandOutHelper<Args, F, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
+    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       A,
       B,
@@ -759,15 +780,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G
-    ): CommandOutHelper<Args, G, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
+    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
     <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
       a: (
         _: Effect.Effect<
@@ -775,16 +797,17 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H
-    ): CommandOutHelper<Args, H, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
+    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
     <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
       a: (
         _: Effect.Effect<
@@ -792,34 +815,35 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, ...args: NoInfer<Args>) => B,
-      c: (_: B, ...args: NoInfer<Args>) => C,
-      d: (_: C, ...args: NoInfer<Args>) => D,
-      e: (_: D, ...args: NoInfer<Args>) => E,
-      f: (_: E, ...args: NoInfer<Args>) => F,
-      g: (_: F, ...args: NoInfer<Args>) => G,
-      h: (_: G, ...args: NoInfer<Args>) => H,
-      i: (_: H, ...args: NoInfer<Args>) => I
-    ): CommandOutHelper<Args, I, Id, I18nKey, State>
+      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
+      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
+    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
   export type NonGenWrap<
     RT,
     Id extends string,
     I18nKey extends string,
-    Args extends Array<unknown>,
+    Arg,
     AEff,
     EEff,
     REff,
     State extends IntlRecord | undefined
   > = {
-    (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
+    (): Exclude<REff, RT> extends never ? CommandOutHelper<Arg, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
       : MissingDependencies<RT, REff> & {}
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -827,13 +851,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -841,15 +866,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -857,17 +883,18 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
       D,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -875,19 +902,20 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
       C,
       D,
       E,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -895,13 +923,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -909,7 +938,7 @@ export declare namespace Commander {
       D,
       E,
       F,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -917,14 +946,15 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -933,7 +963,7 @@ export declare namespace Commander {
       E,
       F,
       G,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -941,15 +971,16 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -959,7 +990,7 @@ export declare namespace Commander {
       F,
       G,
       H,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -967,16 +998,17 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
     <
       Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
       B,
@@ -987,7 +1019,7 @@ export declare namespace Commander {
       G,
       H,
       I,
-      Args extends Array<unknown>
+      Arg
     >(
       a: (
         _: Effect.Effect<
@@ -995,17 +1027,18 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        ...args: NoInfer<Args>
+        arg: NoInfer<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, ...args: NoInfer<Args>) => C,
-      c: (_: C, ...args: NoInfer<Args>) => D,
-      d: (_: D, ...args: NoInfer<Args>) => E,
-      e: (_: E, ...args: NoInfer<Args>) => F,
-      f: (_: F, ...args: NoInfer<Args>) => G,
-      g: (_: G, ...args: NoInfer<Args>) => H,
-      h: (_: H, ...args: NoInfer<Args>) => I,
-      i: (_: H, ...args: NoInfer<Args>) => Eff
-    ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
+      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
+      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
+      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
+      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
+      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
+      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
+      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
+      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
   }
 }
 
@@ -1308,8 +1341,8 @@ export class CommanderImpl<RT> {
     const state = getStateValues(options)
 
     return Object.assign(
-      <Args extends ReadonlyArray<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
-        handler: (...args: Args) => Effect.Effect<A, E, R>
+      <Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+        handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
       ) => {
         // we capture the definition stack here, so we can append it to later stack traces
         const limit = Error.stackTraceLimit
@@ -1387,7 +1420,7 @@ export class CommanderImpl<RT> {
         const exec = options?.disableSharedWaiting
           ? exec_
           : Effect
-            .fnUntraced(function*(...args: Args) {
+            .fnUntraced(function*(...args: [any, any]) {
               registerWait(id)
               return yield* exec_(...args)
             }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
@@ -1396,7 +1429,7 @@ export class CommanderImpl<RT> {
           ? computed(() => result.value.waiting)
           : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
 
-        const handle = Object.assign((...args: Args) => {
+        const handle = Object.assign((arg: Arg) => {
           // we capture the call site stack here
           const limit = Error.stackTraceLimit
           Error.stackTraceLimit = 2
@@ -1429,12 +1462,12 @@ export class CommanderImpl<RT> {
 
           const command = currentState.pipe(Effect.flatMap((state) =>
             Effect.withSpan(
-              exec(...args),
+              exec(arg, { ...context.value, state } as any),
               id,
               {
                 captureStackTrace,
                 attributes: {
-                  input: args,
+                  input: arg,
                   state,
                   action: initialContext.action,
                   label: initialContext.label,
@@ -1595,10 +1628,10 @@ export class CommanderImpl<RT> {
       }
     )
 
-  /** @experimental */
+  /** @experimental @deprecated */
   alt2: <
     const Id extends string,
-    MutArgs extends Array<unknown>,
+    MutArg,
     MutA,
     MutE,
     MutR,
@@ -1607,19 +1640,19 @@ export class CommanderImpl<RT> {
   >(
     id:
       | Id
-      | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
-      | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
+      | { id: Id; mutate: (arg: MutArg) => Effect.Effect<MutA, MutE, MutR> }
+      | ((arg: MutArg) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
     options?: FnOptions<I18nKey, State>
   ) =>
     & Commander.CommandContextLocal<Id, I18nKey>
-    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
+    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
       handler: (
         ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander.CommandContextLocal<Id, I18nKey> & {
           // todo: only if we passed in one
-          mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
+          mutate: (arg: Arg) => Effect.Effect<MutA, MutE, MutR>
         }
-      ) => (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
+      ) => (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
+    ) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>) = (
       _id,
       options?
     ) => {
@@ -1657,9 +1690,9 @@ export class CommanderImpl<RT> {
     customI18nKey?: I18nKey
   ) =>
     & Commander.CommandContextLocal<Id, I18nKey>
-    & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
-      handler: (...args: Args) => Effect.Effect<A, E, R>
-    ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>)
+    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
+      handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
+    ) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>)
 
   /**
    * Define a Command for handling user actions with built-in error reporting and state management.
@@ -1690,7 +1723,7 @@ export class CommanderImpl<RT> {
    */
   wrap = <
     const Id extends string,
-    Args extends Array<unknown>,
+    Arg,
     A,
     E,
     R,
@@ -1698,10 +1731,10 @@ export class CommanderImpl<RT> {
     I18nKey extends string = Id
   >(
     mutation:
-      | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
-      | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id },
+      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
+      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
     options?: FnOptions<I18nKey, State>
-  ): Commander.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
+  ): Commander.CommanderWrap<RT, Id, I18nKey, State, Arg, A, E, R> =>
     Object.assign(
       (
         ...combinators: any[]
@@ -1717,8 +1750,8 @@ export class CommanderImpl<RT> {
         return this.makeCommand(mutation.id, options, errorDef)(
           Effect.fnUntraced(
             // fnUntraced only supports generators as first arg, so we convert to generator if needed
-            isGeneratorFunction(mutate) ? mutate : function*(...args: Args) {
-              return yield* mutate(...args)
+            isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
+              return yield* mutate(arg)
             },
             ...combinators as [any]
           ) as any
diff --git a/packages/vue/src/experimental/commander2.ts b/packages/vue/src/experimental/commander2.ts
deleted file mode 100644
index ef57b98a2a..0000000000
--- a/packages/vue/src/experimental/commander2.ts
+++ /dev/null
@@ -1,1719 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { asResult, type MissingDependencies, reportRuntimeError } from "@effect-app/vue"
-import { reportMessage } from "@effect-app/vue/errorReporter"
-import { type Result } from "@effect-atom/atom/Result"
-import { Cause, Context, Effect, type Exit, flow, Match, Option, Runtime, S } from "effect-app"
-import { SupportedErrors } from "effect-app/client"
-import { OperationFailure, OperationSuccess } from "effect-app/Operations"
-import { wrapEffect } from "effect-app/utils"
-import { id, type RuntimeFiber } from "effect/Fiber"
-import { type NoInfer } from "effect/Types"
-import { isGeneratorFunction, type YieldWrap } from "effect/Utils"
-import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat"
-import { computed, type ComputedRef, reactive, ref } from "vue"
-import { CommandContext } from "./commander.js"
-import { Confirm } from "./confirm.js"
-import { I18n } from "./intl.js"
-import { WithToast } from "./withToast.js"
-
-type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>
-type FnOptions<I18nCustomKey extends string, State extends IntlRecord | undefined> = {
-  i18nCustomKey?: I18nCustomKey
-  /**
-   * passed to the i18n formatMessage calls so you can use it in translation messagee
-   * including the Command `action` string.
-   * Automatically wrapped with Computed if just a thunk.
-   * provided as Command.state tag, so you can access it in the function.
-   */
-  state?: ComputedRef<State> | (() => State)
-  disableSharedWaiting?: boolean
-}
-
-type FnOptionsInternal<I18nCustomKey extends string> = {
-  i18nCustomKey?: I18nCustomKey | undefined
-  state?: IntlRecord | undefined
-}
-
-export declare namespace Commander2 {
-  export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
-    & Gen<RT, Id, I18nKey, State>
-    & NonGen<RT, Id, I18nKey, State>
-    & CommandContextLocal<Id, I18nKey>
-    & {
-      state: Context.Tag<`Commander.Command.${Id}.state`, State>
-    }
-
-  export type CommanderFn<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
-    CommanderBase<RT, Id, I18nKey, State>
-
-  export type CommanderWrap<
-    RT,
-    Id extends string,
-    I18nCustomKey extends string,
-    State extends IntlRecord | undefined,
-    I,
-    A,
-    E,
-    R
-  > =
-    & CommandContextLocal<Id, I18nCustomKey>
-    & GenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
-    & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
-    & {
-      state: Context.Tag<`Commander.Command.${Id}.state`, State>
-    }
-
-  export interface CommandContextLocal<Id extends string, I18nKey extends string> {
-    id: Id
-    i18nKey: I18nKey
-    namespace: `action.${I18nKey}`
-    namespaced: <K extends string>(k: K) => `action.${I18nKey}.${K}`
-  }
-
-  export interface CommandProps<
-    A,
-    E,
-    Id extends string,
-    I18nKey extends string,
-    State extends IntlRecord | undefined
-  > extends CommandContextLocal<Id, I18nKey> {
-    /** reactive */
-    action: string
-    /** reactive */
-    label: string
-    /** reactive */
-    result: Result<A, E>
-    /** reactive */
-    waiting: boolean
-    /** reactive */
-    state: ComputedRef<State>
-  }
-
-  export interface CommandOut<
-    Arg,
-    A,
-    E,
-    R,
-    Id extends string,
-    I18nKey extends string,
-    State extends IntlRecord | undefined
-  > extends CommandProps<A, E, Id, I18nKey, State> {
-    new(): {}
-
-    /** click handlers */
-    handle: ((arg: Arg) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
-      /** @deprecated don't exist */
-      effect: (arg: Arg) => Effect.Effect<A, E, R>
-    }
-
-    // // TODO: if we keep them, it would probably be nicer as an option api, deciding the return value like in Atom?
-    // /** @experimental */
-    // compose: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, R>
-    // /** @experimental */
-    // compose2: (arg: Arg) => Effect.Effect<A, E, R>
-    // /**
-    //  * @experimental
-    //  * captures the current span and returns an Effect that when run will execute the command
-    //  */
-    // handleEffect: (arg: Arg) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
-    // /**
-    //  * @experimental
-    //  */
-    // exec: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
-  }
-
-  export interface CommandContextLocal2<Id extends string, I18nKey extends string, State extends IntlRecord | undefined>
-    extends CommandContextLocal<Id, I18nKey>
-  {
-    state: State
-  }
-
-  type CommandOutHelper<
-    Arg,
-    Eff extends Effect.Effect<any, any, any>,
-    Id extends string,
-    I18nKey extends string,
-    State extends IntlRecord | undefined
-  > = CommandOut<
-    Arg,
-    Effect.Effect.Success<Eff>,
-    Effect.Effect.Error<Eff>,
-    Effect.Effect.Context<Eff>,
-    Id,
-    I18nKey,
-    State
-  >
-
-  export type Gen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
-      AEff,
-      Arg = void
-    >(
-      body: (arg: Arg) => Generator<Eff, AEff, never>
-    ): CommandOut<
-      Arg,
-      AEff,
-      [Eff] extends [never] ? never
-        : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-        : never,
-      [Eff] extends [never] ? never
-        : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-        : never,
-      Id,
-      I18nKey,
-      State
-    >
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A
-    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
-    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
-    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
-    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D,
-      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
-    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
-    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
-    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
-    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
-    <
-      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-      AEff,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H,
-      I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
-      a: (
-        _: Effect.Effect<
-          AEff,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-            : never,
-          [Eff] extends [never] ? never
-            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-            : never
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
-    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
-  }
-
-  export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      E,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H,
-      I,
-      Arg = void
-    >(
-      body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
-      a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
-      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-  }
-
-  export type GenWrap<
-    RT,
-    Id extends string,
-    I18nKey extends string,
-    Arg,
-    AEff,
-    EEff,
-    REff,
-    State extends IntlRecord | undefined
-  > = {
-    (): Exclude<REff, RT> extends never ? CommandOut<
-        Arg,
-        AEff,
-        EEff,
-        REff,
-        Id,
-        I18nKey,
-        State
-      >
-      : MissingDependencies<RT, REff> & {}
-    <
-      A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A
-    ): CommandOutHelper<Arg, A, Id, I18nKey, State>
-    <
-      A,
-      B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
-    ): CommandOutHelper<Arg, B, Id, I18nKey, State>
-    <
-      A,
-      B,
-      C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
-    ): CommandOutHelper<Arg, C, Id, I18nKey, State>
-    <
-      A,
-      B,
-      C,
-      D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
-    ): CommandOutHelper<Arg, D, Id, I18nKey, State>
-    <
-      A,
-      B,
-      C,
-      D,
-      E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
-    ): CommandOutHelper<Arg, E, Id, I18nKey, State>
-    <
-      A,
-      B,
-      C,
-      D,
-      E,
-      F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
-    ): CommandOutHelper<Arg, F, Id, I18nKey, State>
-    <
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
-    ): CommandOutHelper<Arg, G, Id, I18nKey, State>
-    <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
-    ): CommandOutHelper<Arg, H, Id, I18nKey, State>
-    <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
-      c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
-    ): CommandOutHelper<Arg, I, Id, I18nKey, State>
-  }
-
-  export type NonGenWrap<
-    RT,
-    Id extends string,
-    I18nKey extends string,
-    Arg,
-    AEff,
-    EEff,
-    REff,
-    State extends IntlRecord | undefined
-  > = {
-    (): Exclude<REff, RT> extends never ? CommandOutHelper<Arg, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
-      : MissingDependencies<RT, REff> & {}
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      E,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      E,
-      F,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-    <
-      Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H,
-      I,
-      Arg
-    >(
-      a: (
-        _: Effect.Effect<
-          AEff,
-          EEff,
-          REff
-        >,
-        arg: NoInfer<Arg>,
-        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
-      ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
-      c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
-      d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
-      e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
-      f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
-      g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
-      h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
-      i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
-    ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
-  }
-}
-
-type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined
-
-const renderErrorMaker = I18n.use(
-  ({ intl }) =>
-  <E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) =>
-  (e: E, ...args: Args): string => {
-    if (errorRenderer) {
-      const m = errorRenderer(e, action, ...args)
-      if (m !== undefined) {
-        return m
-      }
-    }
-    if (!S.is(SupportedErrors)(e) && !S.ParseResult.isParseError(e)) {
-      if (typeof e === "object" && e !== null) {
-        if ("message" in e) {
-          return `${e.message}`
-        }
-        if ("_tag" in e) {
-          return `${e._tag}`
-        }
-      }
-      return ""
-    }
-    const e2: SupportedErrors | S.ParseResult.ParseError = e
-    return Match.value(e2).pipe(
-      Match.tags({
-        NotFoundError: (e) => {
-          return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id })
-        },
-        ParseError: (e) => {
-          console.warn(e.toString())
-          return intl.formatMessage({ id: "validation.failed" })
-        }
-      }),
-      Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
-    )
-  }
-)
-
-const defaultFailureMessageHandler = <E, Args extends Array<unknown>, AME, AMR>(
-  actionMaker:
-    | string
-    | ((o: Option.Option<E>, ...args: Args) => string)
-    | ((o: Option.Option<E>, ...args: Args) => Effect.Effect<string, AME, AMR>),
-  errorRenderer?: ErrorRenderer<E, Args>
-) =>
-  Effect.fnUntraced(function*(o: Option.Option<E>, ...args: Args) {
-    const action = yield* wrapEffect(actionMaker)(o, ...args)
-    const { intl } = yield* I18n
-    const renderError = yield* renderErrorMaker
-
-    return Option.match(o, {
-      onNone: () =>
-        intl.formatMessage(
-          { id: "handle.unexpected_error2" },
-          {
-            action,
-            error: "" // TODO consider again Cause.pretty(cause), // will be reported to Sentry/Otel anyway.. and we shouldn't bother users with error dumps?
-          }
-        ),
-      onSome: (e) =>
-        S.is(OperationFailure)(e)
-          ? {
-            level: "warn" as const,
-            message: intl.formatMessage(
-                { id: "handle.with_warnings" },
-                { action }
-              ) + e.message
-              ? "\n" + e.message
-              : ""
-          }
-          : `${
-            intl.formatMessage(
-              { id: "handle.with_errors" },
-              { action }
-            )
-          }:\n` + renderError(action, errorRenderer)(e, ...args)
-    })
-  })
-
-export const CommanderStatic = {
-  /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
-  confirmOrInterrupt: Effect.fnUntraced(function*(
-    message: string | undefined = undefined
-  ) {
-    const context = yield* CommandContext
-    const { intl } = yield* I18n
-
-    yield* Confirm.confirmOrInterrupt(
-      message
-        ?? intl.formatMessage(
-          { id: "handle.confirmation" },
-          { action: context.action }
-        )
-    )
-  }),
-  /** Version of @see confirm that automatically includes the action name in the default messages */
-  confirm: Effect.fnUntraced(function*(
-    message: string | undefined = undefined
-  ) {
-    const context = yield* CommandContext
-    const { intl } = yield* I18n
-    return yield* Confirm.confirm(
-      message
-        ?? intl.formatMessage(
-          { id: "handle.confirmation" },
-          { action: context.action }
-        )
-    )
-  }),
-  updateAction:
-    <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) =>
-    <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) =>
-      Effect.updateService(
-        _,
-        CommandContext,
-        (c) => ({ ...c, action: update(c.action, ...input) })
-      ),
-  defaultFailureMessageHandler,
-  renderError: renderErrorMaker,
-  /**
-   * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
-   * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
-   * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
-   *
-   * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
-   *
-   * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
-   * If you provide a string or function, it will be used instead of the i18n message.
-   * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
-   */
-  withDefaultToast: <A, E, R, Args extends Array<unknown>>(
-    options?: {
-      /**
-       * if true, previous toasts with this key will be replaced
-       */
-      stableToastId?: undefined | true | string | ((id: string, ...args: Args) => true | string | undefined)
-      errorRenderer?: ErrorRenderer<E, Args>
-      onWaiting?: null | undefined | string | ((id: string, ...args: Args) => string | null | undefined)
-      onSuccess?: null | undefined | string | ((a: A, action: string, ...args: Args) => string | null | undefined)
-    }
-  ) =>
-  (
-    self: Effect.Effect<A, E, R>,
-    ...args: Args
-  ) =>
-    Effect.gen(function*() {
-      const cc = yield* CommandContext
-      const { intl } = yield* I18n
-      const withToast = yield* WithToast
-      const customWaiting = cc.namespaced("waiting")
-      const hasCustomWaiting = !!intl.messages[customWaiting]
-      const customSuccess = cc.namespaced("success")
-      const hasCustomSuccess = !!intl.messages[customSuccess]
-      const customFailure = cc.namespaced("failure")
-      const hasCustomFailure = !!intl.messages[customFailure]
-      const stableToastId = options?.stableToastId
-        ? typeof options.stableToastId === "string"
-          ? options.stableToastId
-          : typeof options.stableToastId === "boolean"
-          ? cc.id
-          : typeof options.stableToastId === "function"
-          ? (...args: Args) => {
-            const r = (options.stableToastId as any)(id, ...args)
-            if (typeof r === "string") return r
-            if (r === true) return cc.id
-            return undefined
-          }
-          : undefined
-        : undefined
-      return yield* self.pipe(
-        (_) =>
-          withToast<A, E, Args, R, never, never, I18n>({
-            onWaiting: options?.onWaiting === null ? null : hasCustomWaiting
-              ? intl.formatMessage({
-                id: customWaiting
-              }, cc.state)
-              : intl.formatMessage(
-                { id: "handle.waiting" },
-                { action: cc.action }
-              ),
-            onSuccess: options?.onSuccess === null
-              ? null
-              : (a, ..._args) =>
-                hasCustomSuccess
-                  ? intl.formatMessage(
-                    { id: customSuccess },
-                    cc.state
-                  )
-                  : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
-                    + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
-            onFailure: defaultFailureMessageHandler(
-              hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action,
-              options?.errorRenderer
-            ),
-            stableToastId
-          })(_, ...args)
-      )
-    })
-}
-
-const makeBaseInfo = <const Id extends string, const I18nKey extends string = Id>(
-  id: Id,
-  options?: Pick<FnOptionsInternal<I18nKey>, "i18nCustomKey">
-) => {
-  if (!id) throw new Error("must specify an id")
-  const i18nKey: I18nKey = options?.i18nCustomKey ?? id as unknown as I18nKey
-
-  const namespace = `action.${i18nKey}` as const
-
-  const context = {
-    id,
-    i18nKey,
-    namespace,
-    namespaced: <const K extends string>(k: K) => `${namespace}.${k}` as const
-  }
-
-  return context
-}
-
-const waitState = ref<Record<string, number>>({})
-const registerWait = (id: string) => {
-  // console.debug("register wait", id)
-  waitState.value[id] = waitState.value[id] ? waitState.value[id] + 1 : 1
-}
-const unregisterWait = (id: string) => {
-  // console.debug("unregister wait", id)
-  if (waitState.value[id]) {
-    waitState.value[id] = waitState.value[id] - 1
-    if (waitState.value[id] <= 0) {
-      delete waitState.value[id]
-    }
-  }
-}
-
-const getStateValues = <const I18nKey extends string, State extends IntlRecord | undefined>(
-  options?: FnOptions<I18nKey, State>
-): ComputedRef<State> => {
-  const state_ = options?.state
-  const state = !state_ ? computed(() => undefined as State) : typeof state_ === "function"
-    ? computed(state_)
-    : state_
-  return state
-}
-
-// class preserves JSDoc throughout..
-export class CommanderImpl<RT> {
-  private runFork: <A, E>(
-    effect: Effect.Effect<A, E, RT>,
-    options?: Runtime.RunForkOptions
-  ) => RuntimeFiber<A, E>
-
-  constructor(private readonly rt: Runtime.Runtime<RT>, private readonly intl: I18n) {
-    this.runFork = Runtime.runFork(this.rt)
-  }
-
-  readonly makeContext = <const Id extends string, const I18nKey extends string = Id>(
-    id: Id,
-    options?: FnOptionsInternal<I18nKey>
-  ) => {
-    if (!id) throw new Error("must specify an id")
-    const i18nKey: I18nKey = options?.i18nCustomKey ?? id as unknown as I18nKey
-
-    const namespace = `action.${i18nKey}` as const
-
-    // must remain stable through out single call
-    const action = this.intl.formatMessage({
-      id: namespace,
-      defaultMessage: id
-    }, { ...options?.state, _isLabel: false })
-
-    const label = this.intl.formatMessage({
-      id: namespace,
-      defaultMessage: id
-    }, { ...options?.state, _isLabel: true })
-
-    const context = CommandContext.of({
-      ...makeBaseInfo(id, options),
-      action,
-      label,
-      state: options?.state
-    })
-
-    return context
-  }
-
-  readonly makeCommand = <
-    const Id extends string,
-    const State extends IntlRecord | undefined,
-    const I18nKey extends string = Id
-  >(
-    id_: Id | { id: Id },
-    options?: FnOptions<I18nKey, State>,
-    errorDef?: Error
-  ) => {
-    const id = typeof id_ === "string" ? id_ : id_.id
-    const state = getStateValues(options)
-
-    return Object.assign(
-      <Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
-        handler: (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
-      ) => {
-        // we capture the definition stack here, so we can append it to later stack traces
-        const limit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const localErrorDef = new Error()
-        Error.stackTraceLimit = limit
-        if (!errorDef) {
-          errorDef = localErrorDef
-        }
-
-        const key = `Commander.Command.${id}.state` as const
-        const stateTag = Context.GenericTag<typeof key, State>(key)
-
-        const makeContext_ = () => this.makeContext(id, { ...options, state: state?.value })
-        const initialContext = makeContext_()
-        const context = computed(() => makeContext_())
-        const action = computed(() => context.value.action)
-        const label = computed(() => context.value.label)
-
-        const errorReporter = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-          self.pipe(
-            Effect.tapErrorCause(
-              Effect.fnUntraced(function*(cause) {
-                if (Cause.isInterruptedOnly(cause)) {
-                  console.info(`Interrupted while trying to ${id}`)
-                  return
-                }
-
-                const fail = Cause.failureOption(cause)
-                if (Option.isSome(fail)) {
-                  // if (fail.value._tag === "SuppressErrors") {
-                  //   console.info(
-                  //     `Suppressed error trying to ${action}`,
-                  //     fail.value,
-                  //   )
-                  //   return
-                  // }
-                  const message = `Failure trying to ${id}`
-                  yield* reportMessage(message, {
-                    action: id,
-                    error: fail.value
-                  })
-                  return
-                }
-
-                const context = yield* CommandContext
-                const extra = {
-                  action: context.action,
-                  message: `Unexpected Error trying to ${id}`
-                }
-                yield* reportRuntimeError(cause, extra)
-              }, Effect.uninterruptible)
-            )
-          )
-
-        const currentState = Effect.sync(() => state.value)
-
-        const theHandler = flow(
-          handler,
-          errorReporter,
-          // all must be within the Effect.fn to fit within the Span
-          Effect.provideServiceEffect(
-            stateTag,
-            currentState
-          ),
-          Effect.provideServiceEffect(
-            CommandContext,
-            Effect.sync(() => makeContext_())
-          )
-        )
-
-        const [result, exec_] = asResult(theHandler)
-        // probably could be nice to use a namespaced, computable wait key instead not unlike query invalidation?
-        // ["Something.Update", { id }] for instance
-        const exec = options?.disableSharedWaiting
-          ? exec_
-          : Effect
-            .fnUntraced(function*(...args: [any, any]) {
-              registerWait(id)
-              return yield* exec_(...args)
-            }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
-
-        const waiting = options?.disableSharedWaiting
-          ? computed(() => result.value.waiting)
-          : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
-
-        const handle = Object.assign((arg: Arg) => {
-          // we capture the call site stack here
-          const limit = Error.stackTraceLimit
-          Error.stackTraceLimit = 2
-          const errorCall = new Error()
-          Error.stackTraceLimit = limit
-
-          let cache: false | string = false
-          const captureStackTrace = () => {
-            // in case of an error, we want to append the definition stack to the call site stack,
-            // so we can see where the handler was defined too
-
-            if (cache !== false) {
-              return cache
-            }
-            if (errorCall.stack) {
-              const stackDef = errorDef!.stack!.trim().split("\n")
-              const stackCall = errorCall.stack.trim().split("\n")
-              let endStackDef = stackDef.slice(2).join("\n").trim()
-              if (!endStackDef.includes(`(`)) {
-                endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
-              }
-              let endStackCall = stackCall.slice(2).join("\n").trim()
-              if (!endStackCall.includes(`(`)) {
-                endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
-              }
-              cache = `${endStackDef}\n${endStackCall}`
-              return cache
-            }
-          }
-
-          const command = currentState.pipe(Effect.flatMap((state) =>
-            Effect.withSpan(
-              exec(arg, { ...context.value, state } as any),
-              id,
-              {
-                captureStackTrace,
-                attributes: {
-                  input: arg,
-                  state,
-                  action: initialContext.action,
-                  label: initialContext.label,
-                  id: initialContext.id,
-                  i18nKey: initialContext.i18nKey
-                }
-              }
-            )
-          ))
-
-          return this.runFork(command)
-        }, { action, label })
-
-        return reactive({
-          /** static */
-          id,
-
-          /** the base i18n key, based on id by default. static */
-          i18nKey: initialContext.i18nKey,
-          /** the `action.` namespace based on i18nKey.. static */
-          namespace: initialContext.namespace,
-
-          /** easy generate namespaced 18n keys, based on namespace. static */
-          namespaced: initialContext.namespaced,
-
-          /** reactive */
-          result,
-          /** reactive */
-          waiting,
-          /** reactive */
-          action,
-          /** reactive */
-          label,
-          /** reactive */
-          state,
-
-          handle
-        })
-      },
-      { id }
-    )
-  }
-
-  // /** @experimental */
-  // takeOver:
-  //   <Args extends any[], A, E, R, const Id extends string>(command: Commander.CommandOut<Args, A, E, R, Id,I18nKey>) =>
-  //   (...args: Args) => {
-  //     // we capture the call site stack here
-  //     const limit = Error.stackTraceLimit
-  //     Error.stackTraceLimit = 2
-  //     const errorCall = new Error()
-  //     const localErrorDef = new Error()
-  //     Error.stackTraceLimit = limit
-
-  //     // TODO
-  //     const errorDef = localErrorDef
-
-  //     let cache: false | string = false
-  //     const captureStackTrace = () => {
-  //       // in case of an error, we want to append the definition stack to the call site stack,
-  //       // so we can see where the handler was defined too
-
-  //       if (cache !== false) {
-  //         return cache
-  //       }
-  //       if (errorCall.stack) {
-  //         const stackDef = errorDef.stack!.trim().split("\n")
-  //         const stackCall = errorCall.stack.trim().split("\n")
-  //         let endStackDef = stackDef.slice(2).join("\n").trim()
-  //         if (!endStackDef.includes(`(`)) {
-  //           endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
-  //         }
-  //         let endStackCall = stackCall.slice(2).join("\n").trim()
-  //         if (!endStackCall.includes(`(`)) {
-  //           endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
-  //         }
-  //         cache = `${endStackDef}\n${endStackCall}`
-  //         return cache
-  //       }
-  //     }
-
-  //     return Effect.gen(function*() {
-  //       const ctx = yield* CommandContext
-  //       ctx.action = command.action
-  //       return yield* command.exec(...args).pipe(
-  //         Effect.flatten,
-  //         Effect.withSpan(
-  //           command.action,
-  //           { captureStackTrace }
-  //         )
-  //       )
-  //     })
-  //   },
-
-  /**
-   * Define a Command for handling user actions with built-in error reporting and state management.
-   *
-   * @param id The internal identifier for the action. Used as a tracing span and to lookup
-   *                   the user-facing name via internationalization (`action.${id}`).
-   * @param options Optional configuration for internationalization and state.
-   * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
-   * @param options.state Optional reactive state object (or function returning one) that is
-   *                     made available to the command effects and can be used for i18n interpolation.
-   *                     The state is captured at the start of each command execution and remains stable throughout.
-   * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
-   *          Built-in error reporting handles failures automatically.
-   *
-   * **Effect Context**: Effects have access to the `CommandContext` service, which provides
-   * the user-facing action name.
-   *
-   * **Returned Properties**:
-   * - `action`: User-facing action name from intl messages (useful for button labels)
-   * - `result`: The command result state
-   * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
-   * - `handle`: Function to execute the command
-   * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
-   * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
-   *
-   * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
-   * the `result` inline for custom UI feedback.
-   */
-  fn = <
-    const Id extends string,
-    const State extends IntlRecord = IntlRecord,
-    const I18nKey extends string = Id
-  >(
-    id: Id | { id: Id },
-    options?: FnOptions<I18nKey, State>
-  ): Commander2.Gen<RT, Id, I18nKey, State> & Commander2.NonGen<RT, Id, I18nKey, State> & {
-    state: Context.Tag<`Commander.Command.${Id}.state`, State>
-  } =>
-    Object.assign(
-      (
-        fn: any,
-        ...combinators: any[]
-      ): any => {
-        // we capture the definition stack here, so we can append it to later stack traces
-        const limit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const errorDef = new Error()
-        Error.stackTraceLimit = limit
-
-        return this.makeCommand(id, options, errorDef)(
-          Effect.fnUntraced(
-            // fnUntraced only supports generators as first arg, so we convert to generator if needed
-            isGeneratorFunction(fn) ? fn : function*(...args) {
-              return yield* fn(...args)
-            },
-            ...combinators as [any]
-          ) as any
-        )
-      },
-      makeBaseInfo(typeof id === "string" ? id : id.id, options),
-      {
-        state: Context.GenericTag<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${typeof id === "string" ? id : id.id}.state`
-        )
-      }
-    )
-
-  /** @experimental @deprecated */
-  alt2: <
-    const Id extends string,
-    MutArg,
-    MutA,
-    MutE,
-    MutR,
-    const I18nKey extends string = Id,
-    State extends IntlRecord | undefined = undefined
-  >(
-    id:
-      | Id
-      | { id: Id; mutate: (arg: MutArg) => Effect.Effect<MutA, MutE, MutR> }
-      | ((arg: MutArg) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
-    options?: FnOptions<I18nKey, State>
-  ) =>
-    & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
-      handler: (
-        ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander2.CommandContextLocal<Id, I18nKey> & {
-          // todo: only if we passed in one
-          mutate: (arg: Arg) => Effect.Effect<MutA, MutE, MutR>
-        }
-      ) => (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
-    ) => Commander2.CommandOut<Arg, A, E, R, Id, I18nKey, State>) = (
-      _id,
-      options?
-    ) => {
-      const isObject = typeof _id === "object" || typeof _id === "function"
-      const id = isObject ? _id.id : _id
-      const baseInfo = makeBaseInfo(id, options)
-      const idCmd = this.makeCommand(id, options)
-      // TODO: implement proper tracing stack
-      return Object.assign((cb: any) =>
-        idCmd(cb(
-          Object.assign(
-            (fn: any, ...combinators: any[]) =>
-              Effect.fnUntraced(
-                // fnUntraced only supports generators as first arg, so we convert to generator if needed
-                isGeneratorFunction(fn) ? fn : function*(...args) {
-                  return yield* fn(...args)
-                },
-                ...combinators as [any]
-              ),
-            baseInfo,
-            isObject
-              ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
-              : {}
-          )
-        )), baseInfo) as any
-    }
-
-  /** @experimental */
-  alt = this.makeCommand as unknown as <
-    const Id extends string,
-    const I18nKey extends string = Id,
-    State extends IntlRecord | undefined = undefined
-  >(
-    id: Id,
-    customI18nKey?: I18nKey
-  ) =>
-    & Commander2.CommandContextLocal<Id, I18nKey>
-    & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
-      handler: (arg: Arg, ctx: Commander2.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
-    ) => Commander2.CommandOut<Arg, A, E, R, Id, I18nKey, State>)
-
-  /**
-   * Define a Command for handling user actions with built-in error reporting and state management.
-   *
-   * @param mutation The mutation function to take the identifier and initial handler from. Used as a tracing span and to lookup
-   *                   the user-facing name via internationalization (`action.${id}`).
-   * @param options Optional configuration for internationalization and state.
-   * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
-   * @param options.state Optional reactive state object (or function returning one) that is
-   *                     made available to the command effects and can be used for i18n interpolation.
-   *                     The state is captured at the start of each command execution and remains stable throughout.
-   * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
-   *          Built-in error reporting handles failures automatically.
-   *
-   * **Effect Context**: Effects have access to the `CommandContext` service, which provides
-   * the user-facing action name.
-   *
-   * **Returned Properties**:
-   * - `action`: User-facing action name from intl messages (useful for button labels)
-   * - `result`: The command result state
-   * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
-   * - `handle`: Function to execute the command
-   * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
-   * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
-   *
-   * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
-   * the `result` inline for custom UI feedback.
-   */
-  wrap = <
-    const Id extends string,
-    Arg,
-    A,
-    E,
-    R,
-    const State extends IntlRecord = IntlRecord,
-    I18nKey extends string = Id
-  >(
-    mutation:
-      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
-      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
-    options?: FnOptions<I18nKey, State>
-  ): Commander2.CommanderWrap<RT, Id, I18nKey, State, Arg, A, E, R> =>
-    Object.assign(
-      (
-        ...combinators: any[]
-      ): any => {
-        // we capture the definition stack here, so we can append it to later stack traces
-        const limit = Error.stackTraceLimit
-        Error.stackTraceLimit = 2
-        const errorDef = new Error()
-        Error.stackTraceLimit = limit
-
-        const mutate = "mutate" in mutation ? mutation.mutate : mutation
-
-        return this.makeCommand(mutation.id, options, errorDef)(
-          Effect.fnUntraced(
-            // fnUntraced only supports generators as first arg, so we convert to generator if needed
-            isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
-              return yield* mutate(arg)
-            },
-            ...combinators as [any]
-          ) as any
-        )
-      },
-      makeBaseInfo(mutation.id, options),
-      {
-        state: Context.GenericTag<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${mutation.id}.state`
-        )
-      }
-    )
-}
-
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class Commander2 extends Effect.Service<Commander2>()("Commander2", {
-  dependencies: [WithToast.Default, Confirm.Default],
-  effect: Effect.gen(function*() {
-    const i18n = yield* I18n
-    return <RT>(rt: Runtime.Runtime<RT>) => new CommanderImpl(rt, i18n)
-  })
-}) {}
diff --git a/packages/vue/src/experimental/makeUseCommand.ts b/packages/vue/src/experimental/makeUseCommand.ts
index 7a955ee092..afbb2cd026 100644
--- a/packages/vue/src/experimental/makeUseCommand.ts
+++ b/packages/vue/src/experimental/makeUseCommand.ts
@@ -1,5 +1,5 @@
 import { Effect } from "effect-app"
-import { Commander2, type CommanderImpl, CommanderStatic } from "./commander2.js"
+import { Commander, type CommanderImpl, CommanderStatic } from "./commander.js"
 
 type X<X> = X
 
@@ -10,7 +10,7 @@ export interface CommanderResolved<RT>
 }
 
 export const makeUseCommand = Effect.fnUntraced(function*<R = never>() {
-  const cmndr = yield* Commander2
+  const cmndr = yield* Commander
   const runtime = yield* Effect.runtime<R>()
 
   const comm = cmndr(runtime)
diff --git a/packages/vue/src/makeClient.ts b/packages/vue/src/makeClient.ts
index 3b6efadfb2..0a74e374cd 100644
--- a/packages/vue/src/makeClient.ts
+++ b/packages/vue/src/makeClient.ts
@@ -14,7 +14,6 @@ import { type RuntimeFiber } from "effect/Fiber"
 import { computed, type ComputedRef, onBeforeUnmount, type Ref, ref, watch, type WatchSource } from "vue"
 import { reportMessage } from "./errorReporter.js"
 import { type Commander, CommanderStatic } from "./experimental/commander.js"
-import { type Commander2 } from "./experimental/commander2.js"
 import { I18n } from "./experimental/intl.js"
 import { type CommanderResolved, makeUseCommand } from "./experimental/makeUseCommand.js"
 import { Toast } from "./experimental/toast.js"
@@ -1248,7 +1247,7 @@ export class QueryImpl<R> {
 const managedRuntimeRt = <A, E>(mrt: ManagedRuntime.ManagedRuntime<A, E>) => mrt.runSync(Effect.runtime<A>())
 
 type Base = I18n | Toast
-type Mix = ApiClientFactory | Commander2 | LegacyMutation | Base
+type Mix = ApiClientFactory | Commander | LegacyMutation | Base
 export const makeClient = <RT_>(
   // global, but only accessible after startup has completed
   getBaseMrt: () => ManagedRuntime.ManagedRuntime<RT_ | Mix, never>,
diff --git a/packages/vue/test/stubs.ts b/packages/vue/test/stubs.ts
index b354c4ab0a..988dde8712 100644
--- a/packages/vue/test/stubs.ts
+++ b/packages/vue/test/stubs.ts
@@ -6,7 +6,7 @@ import { Effect, Layer, ManagedRuntime, Option, S } from "effect-app"
 import { ApiClientFactory, makeRpcClient } from "effect-app/client"
 import { RpcContextMap } from "effect-app/rpc"
 import { ref } from "vue"
-import { Commander2 } from "../src/experimental/commander2.js"
+import { Commander } from "../src/experimental/commander.js"
 import { I18n } from "../src/experimental/intl.js"
 import { makeUseCommand } from "../src/experimental/makeUseCommand.js"
 import * as Toast from "../src/experimental/toast.js"
@@ -83,7 +83,7 @@ export const useExperimental = (
 ) => {
   const FakeIntlLayer = fakeIntlLayer(options?.messages)
   const FakeToastLayer = fakeToastLayer(options?.toasts)
-  const CommanderLayer = Commander2.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
+  const CommanderLayer = Commander.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
   const WithToastLayer = WithToast.Default.pipe(Layer.provide(FakeToastLayer))
   const layers = Layer.mergeAll(CommanderLayer, WithToastLayer, FakeToastLayer, FakeIntlLayer)
 
@@ -110,7 +110,7 @@ export const useClient = (
 ) => {
   const FakeIntlLayer = fakeIntlLayer(options?.messages)
   const FakeToastLayer = fakeToastLayer(options?.toasts)
-  const CommanderLayer = Commander2.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
+  const CommanderLayer = Commander.Default.pipe(Layer.provide([FakeIntlLayer, FakeToastLayer]))
   const WithToastLayer = WithToast.Default.pipe(Layer.provide(FakeToastLayer))
   const api = ApiClientFactory.layer({ url: "bogus", headers: Option.none() }).pipe(
     Layer.provide(FetchHttpClient.layer)