@effect-app/vue 4.0.0-beta.18 → 4.0.0-beta.181

package/src/{experimental/commander.ts → commander.ts}

@@ -1,19 +1,55 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { asResult, type MissingDependencies, reportRuntimeError } from "@effect-app/vue"
+import { asResult, deepToRaw, type MissingDependencies, reportRuntimeError } from "@effect-app/vue"
 import { reportMessage } from "@effect-app/vue/errorReporter"
-import { Cause, Effect, type Exit, type Fiber, flow, Layer, Match, MutableHashMap, Option, Predicate, S, ServiceMap } from "effect-app"
+import { Cause, Context, Effect, type Exit, type Fiber, flow, Layer, Match, MutableHashMap, Option, Predicate, S } from "effect-app"
 import { SupportedErrors } from "effect-app/client"
 import { OperationFailure, OperationSuccess } from "effect-app/Operations"
 import { isGeneratorFunction, wrapEffect } from "effect-app/utils"
-import { type AsyncResult } from "effect/unstable/reactivity/AsyncResult"
+import { type Refinement } from "effect/Predicate"
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat"
-import { computed, type ComputedRef, reactive, ref } from "vue"
+import { computed, type ComputedRef, reactive, ref, toRaw } from "vue"
 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<Id extends string, I18nCustomKey extends string, State extends IntlRecord | undefined> = {
+
+/**
+ * Progress information surfaced by a stream command. Either a plain text label
+ * or a `{ text, percentage }` pair when concrete progress is known.
+ */
+export type Progress = string | { readonly text: string; readonly percentage: number }
+
+/**
+ * Options accepted when calling a stream mutation factory.
+ * Supplying `progress` causes the resulting command to expose `running`
+ * (the live AsyncResult ref) and `progress` (formatted loading info).
+ * When omitted, neither is exposed on the command.
+ */
+export type StreamMutationCallOptions<A, E> = {
+  progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined
+}
+
+type StreamMutationTuple<Id extends string, Arg, A, E, R> =
+  & readonly [
+    ComputedRef<AsyncResult.AsyncResult<A, E>>,
+    ((arg: Arg) => Effect.Effect<any, never, R>) | Effect.Effect<any, never, R>
+  ]
+  & {
+    readonly id: Id
+    readonly running?: ComputedRef<AsyncResult.AsyncResult<A, E>>
+    readonly progress?: ComputedRef<Progress | undefined>
+  }
+
+type StreamMutationFactory<Id extends string, Arg, A, E, R> =
+  & ((options?: StreamMutationCallOptions<A, E>) => StreamMutationTuple<Id, Arg, A, E, R>)
+  & { readonly id: Id }
+type FnOptions<
+  Id extends string,
+  I18nCustomKey extends string,
+  State extends IntlRecord | undefined
+> = {
   i18nCustomKey?: I18nCustomKey
   /**
    * passed to the i18n formatMessage calls so you can use it in translation messagee
@@ -66,7 +102,7 @@ export const DefaultIntl = {
   }
 }
 
-export class CommandContext extends ServiceMap.Service<CommandContext, {
+export class CommandContext extends Context.Service<CommandContext, {
   id: string
   i18nKey: string
   action: string
@@ -96,7 +132,7 @@ export declare namespace Commander {
     & NonGen<RT, Id, I18nKey, State>
     & CommandContextLocal<Id, I18nKey>
     & {
-      state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>
+      state: Context.Service<`Commander.Command.${Id}.state`, State>
     }
 
   export type CommanderFn<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
@@ -116,7 +152,7 @@ export declare namespace Commander {
     & GenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
     & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
     & {
-      state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>
+      state: Context.Service<`Commander.Command.${Id}.state`, State>
     }
 
   export interface CommandContextLocal<Id extends string, I18nKey extends string> {
@@ -138,7 +174,19 @@ export declare namespace Commander {
     /** reactive */
     label: string
     /** reactive */
-    result: AsyncResult<A, E>
+    result: AsyncResult.AsyncResult<A, E>
+    /**
+     * reactive – set when the command wraps a stream (`wrapStream` / `wrap` with `mutateStream`)
+     * or when the `progress` option is provided to `fn`.
+     * Reflects the live AsyncResult of the underlying stream.
+     */
+    running: AsyncResult.AsyncResult<any, any> | undefined
+    /**
+     * reactive – formatted progress info computed from `running` via the
+     * `progress` option. Useful as the loading state on a `CommandButton`.
+     * Undefined when no `progress` formatter was supplied.
+     */
+    progress: Progress | undefined
     /** reactive */
     waiting: boolean
     /** reactive */
@@ -188,6 +236,8 @@ export declare namespace Commander {
     state: State
   }
 
+  type ArgForCombinator<Arg> = [Arg] extends [void] ? undefined : NoInfer<Arg>
+
   type CommandOutHelper<
     Arg,
     Eff extends Effect.Effect<any, any, any>,
@@ -241,7 +291,7 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
     ): CommandOutHelper<Arg, A, Id, I18nKey, State>
@@ -263,10 +313,14 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B
     ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -287,11 +341,19 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C
     ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -313,12 +375,24 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D
     ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -341,13 +415,29 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E
     ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -371,14 +461,34 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F
     ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -403,15 +513,39 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G
     ): CommandOutHelper<Arg, G, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -437,16 +571,44 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      h: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H
     ): CommandOutHelper<Arg, H, Id, I18nKey, State>
     <
       Eff extends Effect.Yieldable<any, any, any, any>,
@@ -473,17 +635,49 @@ export declare namespace Commander {
             : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R
             : never
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      h: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      i: (
+        _: H,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => I
     ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
@@ -500,7 +694,11 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<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`>,
@@ -509,8 +707,16 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<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`>,
@@ -520,9 +726,21 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<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`>,
@@ -533,10 +751,26 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<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`>,
@@ -548,11 +782,31 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<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`>,
@@ -565,12 +819,36 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<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`>,
@@ -584,13 +862,41 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<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`>,
@@ -605,14 +911,46 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      h: (
+        _: H,
+        arg: ArgForCombinator<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`>,
@@ -628,15 +966,51 @@ export declare namespace Commander {
       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
+      a: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      h: (
+        _: H,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => I,
+      i: (
+        _: H,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => Eff
     ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
   }
 
@@ -669,7 +1043,7 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A
     ): CommandOutHelper<Arg, A, Id, I18nKey, State>
@@ -683,10 +1057,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => A,
-      b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B
     ): CommandOutHelper<Arg, B, Id, I18nKey, State>
     <
       A,
@@ -699,11 +1077,19 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C
     ): CommandOutHelper<Arg, C, Id, I18nKey, State>
     <
       A,
@@ -717,12 +1103,24 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D
     ): CommandOutHelper<Arg, D, Id, I18nKey, State>
     <
       A,
@@ -737,13 +1135,29 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E
     ): CommandOutHelper<Arg, E, Id, I18nKey, State>
     <
       A,
@@ -759,14 +1173,34 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F
     ): CommandOutHelper<Arg, F, Id, I18nKey, State>
     <
       A,
@@ -783,15 +1217,39 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<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: (
@@ -800,16 +1258,44 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      h: (
+        _: G,
+        arg: ArgForCombinator<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: (
@@ -818,17 +1304,49 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: A,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => B,
+      c: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      d: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      e: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      f: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      g: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      h: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      i: (
+        _: H,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => I
     ): CommandOutHelper<Arg, I, Id, I18nKey, State>
   }
 
@@ -854,7 +1372,7 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => Eff
     ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
@@ -869,10 +1387,14 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<Arg>,
         ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
       ) => B,
-      b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
+      b: (
+        _: B,
+        arg: ArgForCombinator<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`>,
@@ -886,11 +1408,19 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<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`>,
@@ -905,12 +1435,24 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<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`>,
@@ -926,13 +1468,29 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<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`>,
@@ -949,14 +1507,34 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<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`>,
@@ -974,15 +1552,39 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<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`>,
@@ -1001,16 +1603,44 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      h: (
+        _: H,
+        arg: ArgForCombinator<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`>,
@@ -1030,59 +1660,120 @@ export declare namespace Commander {
           EEff,
           REff
         >,
-        arg: NoInfer<Arg>,
+        arg: ArgForCombinator<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
+      b: (
+        _: B,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => C,
+      c: (
+        _: C,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => D,
+      d: (
+        _: D,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => E,
+      e: (
+        _: E,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => F,
+      f: (
+        _: F,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => G,
+      g: (
+        _: G,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => H,
+      h: (
+        _: H,
+        arg: ArgForCombinator<Arg>,
+        ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
+      ) => I,
+      i: (
+        _: H,
+        arg: ArgForCombinator<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.useSync(
-  ({ 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
+type RegisteredErrorRenderer<A> = {
+  guard: Refinement<unknown, A>
+  render: (guarded: A) => string | undefined
+}
+
+export class CommanderErrorRenderers extends Context.Reference("Commander.ErrorRenderers", {
+  defaultValue: () => [] as RegisteredErrorRenderer<any>[]
+}) {}
+
+export const makeRegisteredErrorRenderer = <A>(
+  guard: Predicate.Refinement<unknown, A>,
+  render: (guarded: A) => string | undefined
+): RegisteredErrorRenderer<A> => ({
+  guard,
+  render
+})
+
+const renderErrorMaker = Effect.gen(function*() {
+  const { intl } = yield* I18n
+  const registeredRenderers = yield* CommanderErrorRenderers
+  return (
+    <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.isSchemaError(e)) {
-      if (typeof e === "object" && e !== null) {
-        if ("message" in e) {
-          return `${e.message}`
+      for (const entry of registeredRenderers) {
+        if (!entry.guard(e)) {
+          continue
         }
-        if ("_tag" in e) {
-          return `${e._tag}`
+        const m = entry.render(e)
+        if (m !== undefined) {
+          return m
         }
       }
-      return ""
-    }
-    const e2: SupportedErrors | S.SchemaError = e
-    return Match.value(e2).pipe(
-      Match.tags({
-        NotFoundError: (e) => {
-          return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id })
-        },
-        SchemaError: (e) => {
-          console.warn(e.toString())
-          return intl.formatMessage({ id: "validation.failed" })
+      if (!S.is(SupportedErrors)(e) && !S.isSchemaError(e)) {
+        if (typeof e === "object" && e !== null) {
+          if ("message" in e) {
+            return `${e.message}`
+          }
+          if ("_tag" in e) {
+            return `${e._tag}`
+          }
         }
-      }),
-      Match.orElse((e) => `${e.message ?? e._tag ?? e}`)
-    )
-  }
-)
+        return ""
+      }
+      const e2: SupportedErrors | S.SchemaError = e
+      return Match.value(e2).pipe(
+        Match.tags({
+          NotFoundError: (e) => {
+            return intl.formatMessage({ id: "handle.not_found" }, { type: e.type, id: e.id })
+          },
+          SchemaError: (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:
@@ -1105,23 +1796,28 @@ const defaultFailureMessageHandler = <E, Args extends Array<unknown>, AME, AMR>(
             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)
+      onSome: (e) => {
+        const rendered = renderError(action, errorRenderer)(e, ...args)
+        return S.is(OperationFailure)(e)
           ? {
             level: "warn" as const,
-            message: intl.formatMessage(
+            message: `${
+              intl.formatMessage(
                 { id: "handle.with_warnings" },
                 { action }
-              ) + e.message
-              ? "\n" + e.message
-              : ""
+              )
+            }${rendered ? "\n" + rendered : ""}`
           }
-          : `${
-            intl.formatMessage(
-              { id: "handle.with_errors" },
-              { action }
-            )
-          }:\n` + renderError(action, errorRenderer)(e, ...args)
+          : {
+            level: "warn" as const,
+            message: `${
+              intl.formatMessage(
+                { id: "handle.with_errors" },
+                { action }
+              )
+            }:\n` + rendered
+          }
+      }
     })
   })
 
@@ -1168,6 +1864,17 @@ export const CommanderStatic = {
         CommandContext,
         (c) => ({ ...c, action: update(c.action, ...input) })
       ),
+  registerErrorRenderer: <A>(
+    guard: Predicate.Refinement<unknown, A>,
+    render: (guarded: A) => string | undefined
+  ) =>
+    Layer.effect(
+      CommanderErrorRenderers,
+      Effect.gen(function*() {
+        const current = yield* CommanderErrorRenderers
+        return [...current, makeRegisteredErrorRenderer(guard, render)]
+      })
+    ),
   defaultFailureMessageHandler,
   renderError: renderErrorMaker,
   /**
@@ -1186,17 +1893,29 @@ export const CommanderStatic = {
       /**
        * 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)
+      stableToastId?:
+        | undefined
+        | true
+        | string
+        | ((id: string, arg: NoInfer<Args>[0], ctx: NoInfer<Args>[1]) => true | string | undefined)
+      errorRenderer?: (e: E, action: string, arg: NoInfer<Args>[0], ctx: NoInfer<Args>[1]) => string | undefined
+      showSpanInfo?: false
+      onWaiting?:
+        | null
+        | undefined
+        | string
+        | ((id: string, arg: NoInfer<Args>[0], ctx: NoInfer<Args>[1]) => string | null | undefined)
+      onSuccess?:
+        | null
+        | undefined
+        | string
+        | ((a: A, action: string, arg: NoInfer<Args>[0], ctx: NoInfer<Args>[1]) => string | null | undefined)
     }
   ) =>
-  (
-    self: Effect.Effect<A, E, R>,
-    ...args: Args
-  ) =>
-    Effect.gen(function*() {
+    Effect.fnUntraced(function*(
+      self: Effect.Effect<A, E, R>,
+      ...args: Args
+    ) {
       const cc = yield* CommandContext
       const { intl } = yield* I18n
       const withToast = yield* WithToast
@@ -1243,9 +1962,10 @@ export const CommanderStatic = {
                     + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
             onFailure: defaultFailureMessageHandler(
               hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action,
-              options?.errorRenderer
+              options?.errorRenderer as ErrorRenderer<E, Args> | undefined
             ),
-            stableToastId
+            stableToastId,
+            ...options?.showSpanInfo === false ? { showSpanInfo: options.showSpanInfo } : {}
           })(_, ...args)
       )
     }),
@@ -1310,7 +2030,11 @@ const unregisterWait = (id: string) => {
   }
 }
 
-const getStateValues = <const Id extends string, const I18nKey extends string, State extends IntlRecord | undefined>(
+const getStateValues = <
+  const Id extends string,
+  const I18nKey extends string,
+  State extends IntlRecord | undefined
+>(
   options?: FnOptions<Id, I18nKey, State>
 ): ComputedRef<State> => {
   const state_ = options?.state
@@ -1323,7 +2047,7 @@ const getStateValues = <const Id extends string, const I18nKey extends string, S
 // class preserves JSDoc throughout..
 export class CommanderImpl<RT, RTHooks> {
   constructor(
-    private readonly rt: ServiceMap.ServiceMap<RT>,
+    private readonly rt: Context.Context<RT>,
     private readonly intl: I18n,
     private readonly hooks: Layer.Layer<RTHooks, never, RT>
   ) {
@@ -1362,11 +2086,17 @@ export class CommanderImpl<RT, RTHooks> {
   readonly makeCommand = <
     const Id extends string,
     const State extends IntlRecord | undefined,
-    const I18nKey extends string = Id
+    const I18nKey extends string = Id,
+    RunningA = unknown,
+    RunningE = unknown
   >(
     id_: Id | { id: Id },
     options?: FnOptions<Id, I18nKey, State>,
-    errorDef?: Error
+    errorDef?: Error,
+    streamMeta?: {
+      running?: ComputedRef<AsyncResult.AsyncResult<RunningA, RunningE>> | undefined
+      progress?: ComputedRef<Progress | undefined> | undefined
+    }
   ) => {
     const id = typeof id_ === "string" ? id_ : id_.id
     const state = getStateValues(options)
@@ -1385,7 +2115,7 @@ export class CommanderImpl<RT, RTHooks> {
         }
 
         const key = `Commander.Command.${id}.state` as const
-        const stateTag = ServiceMap.Service<typeof key, State>(key)
+        const stateTag = Context.Service<typeof key, State>(key)
 
         const makeContext_ = () => this.makeContext(id, { ...options, state: state?.value })
         const initialContext = makeContext_()
@@ -1479,10 +2209,11 @@ export class CommanderImpl<RT, RTHooks> {
         const computeAllowed = options?.allowed
         const allowed = computeAllowed ? computed(() => computeAllowed(id, state)) : true
 
-        const rt = Effect.services<RT | RTHooks>().pipe(Effect.provide(this.hooks)).pipe(Effect.runSyncWith(this.rt))
+        const rt = Effect.context<RT | RTHooks>().pipe(Effect.provide(this.hooks)).pipe(Effect.runSyncWith(this.rt))
         const runFork = Effect.runForkWith(rt)
 
         const handle = Object.assign((arg: Arg) => {
+          arg = toRaw(arg) // remove outside vue proxy bs
           // we capture the call site stack here
           const limit = Error.stackTraceLimit
           Error.stackTraceLimit = 2
@@ -1513,15 +2244,17 @@ export class CommanderImpl<RT, RTHooks> {
             }
           }
 
-          const command = currentState.pipe(Effect.flatMap((state) =>
-            Effect.withSpan(
+          const command = currentState.pipe(Effect.flatMap((state) => {
+            const rawArg = deepToRaw(arg)
+            const rawState = deepToRaw(state)
+            return Effect.withSpan(
               exec(arg, { ...context.value, state } as any),
               id,
               {
                 captureStackTrace,
                 attributes: {
-                  input: arg,
-                  state,
+                  input: rawArg,
+                  state: rawState,
                   action: initialContext.action,
                   label: initialContext.label,
                   id: initialContext.id,
@@ -1529,7 +2262,7 @@ export class CommanderImpl<RT, RTHooks> {
                 }
               }
             )
-          ))
+          }))
 
           return runFork(command)
         }, { action, label })
@@ -1548,6 +2281,12 @@ export class CommanderImpl<RT, RTHooks> {
 
           /** reactive */
           result,
+          /** reactive – live AsyncResult of the underlying stream, exposed only when
+           * the stream factory was called with a `progress` formatter */
+          running: streamMeta?.running,
+          /** reactive – formatted progress info for current `running` state, when `progress`
+           * formatter was supplied to the stream factory */
+          progress: streamMeta?.progress,
           /** reactive */
           waiting,
           /** reactive */
@@ -1649,14 +2388,41 @@ export class CommanderImpl<RT, RTHooks> {
   fn = <
     const Id extends string,
     const State extends IntlRecord = IntlRecord,
-    const I18nKey extends string = Id
+    const I18nKey extends string = Id,
+    RunningA = unknown,
+    RunningE = unknown
   >(
-    id: Id | { id: Id },
+    id:
+      | Id
+      | { id: Id }
+      | StreamMutationTuple<Id, any, RunningA, RunningE, any>
+      | StreamMutationFactory<Id, any, RunningA, RunningE, any>,
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.Gen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGen<RT | RTHooks, Id, I18nKey, State> & {
-    state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>
-  } =>
-    Object.assign(
+    state: Context.Service<`Commander.Command.${Id}.state`, State>
+  } => {
+    // Resolve id and (optionally) per-build stream metadata.
+    const resolvedId: Id = typeof id === "string" ? id : (id as { id: Id }).id
+    const isStreamFactory = typeof id === "function" && "id" in id && (id as any).length <= 1
+    const isStreamTuple = Array.isArray(id) && "id" in id
+    const resolveStreamMeta = ():
+      | {
+        running?: ComputedRef<AsyncResult.AsyncResult<RunningA, RunningE>> | undefined
+        progress?: ComputedRef<Progress | undefined> | undefined
+      }
+      | undefined =>
+    {
+      if (isStreamTuple) {
+        const t = id as StreamMutationTuple<Id, any, RunningA, RunningE, any>
+        return { running: t.running, progress: t.progress }
+      }
+      if (isStreamFactory) {
+        const t = id()
+        return { running: t.running, progress: t.progress }
+      }
+      return undefined
+    }
+    return Object.assign(
       (
         fn: any,
         ...combinators: any[]
@@ -1667,7 +2433,9 @@ export class CommanderImpl<RT, RTHooks> {
         const errorDef = new Error()
         Error.stackTraceLimit = limit
 
-        return this.makeCommand(id, options, errorDef)(
+        const streamMeta = resolveStreamMeta()
+
+        return this.makeCommand(resolvedId, options, errorDef, streamMeta)(
           Effect.fnUntraced(
             // fnUntraced only supports generators as first arg, so we convert to generator if needed
             isGeneratorFunction(fn) ? fn : function*(...args) {
@@ -1677,15 +2445,16 @@ export class CommanderImpl<RT, RTHooks> {
           ) as any
         )
       },
-      makeBaseInfo(typeof id === "string" ? id : id.id, options),
+      makeBaseInfo(resolvedId, options),
       {
-        state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${typeof id === "string" ? id : id.id}.state`
+        state: Context.Service<`Commander.Command.${Id}.state`, State>(
+          `Commander.Command.${resolvedId}.state`
         )
       }
     )
+  }
 
-  /** @experimental @deprecated */
+  /** @deprecated */
   alt2: <
     const Id extends string,
     MutArg,
@@ -1737,7 +2506,6 @@ export class CommanderImpl<RT, RTHooks> {
         )), baseInfo) as any
     }
 
-  /** @experimental */
   alt = this.makeCommand as unknown as <
     const Id extends string,
     const I18nKey extends string = Id,
@@ -1789,10 +2557,31 @@ export class CommanderImpl<RT, RTHooks> {
   >(
     mutation:
       | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
-      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
+      | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id }
+      | StreamMutationFactory<Id, Arg, A, E, R>
+      | {
+        id: Id
+        mutateStream:
+          | StreamMutationFactory<Id, Arg, A, E, R>
+          | StreamMutationTuple<Id, Arg, A, E, R>
+      }
+      | StreamMutationTuple<Id, Arg, A, E, R>,
     options?: FnOptions<Id, I18nKey, State>
-  ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> =>
-    Object.assign(
+  ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
+    if (mutation !== null && typeof mutation === "object" && "mutateStream" in mutation) {
+      return this.wrapStream(mutation as any, options) as any
+    }
+    if (Array.isArray(mutation) && "id" in mutation) {
+      return this.wrapStream(mutation as any, options) as any
+    }
+    if (typeof mutation === "function" && "id" in mutation && (mutation as any).length <= 1) {
+      return this.wrapStream(mutation as any, options) as any
+    }
+    // At this point mutation is either { mutate, id } or (fn & { id })
+    const callMutation = mutation as
+      | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
+      | (((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id })
+    return Object.assign(
       (
         ...combinators: any[]
       ): any => {
@@ -1801,9 +2590,11 @@ export class CommanderImpl<RT, RTHooks> {
         Error.stackTraceLimit = 2
         const errorDef = new Error()
         Error.stackTraceLimit = limit
-        const mutate = "mutate" in mutation ? mutation.mutate : mutation
+        const mutate = "mutate" in callMutation
+          ? callMutation.mutate
+          : callMutation
 
-        return this.makeCommand(mutation.id, options, errorDef)(
+        return this.makeCommand(callMutation.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) {
@@ -1813,20 +2604,112 @@ export class CommanderImpl<RT, RTHooks> {
           ) as any
         )
       },
-      makeBaseInfo(mutation.id, options),
+      makeBaseInfo(callMutation.id, options),
       {
-        state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>(
-          `Commander.Command.${mutation.id}.state`
+        state: Context.Service<`Commander.Command.${Id}.state`, State>(
+          `Commander.Command.${callMutation.id}.state`
         )
       }
     )
+  }
+
+  /**
+   * Define a Command from a stream-type mutation (`mutateStream` factory).
+   * The stream's reactive `AsyncResult` ref is exposed as `running` for independent progress tracking.
+   * The command's own `result` reflects the execution outcome of the `execute` function.
+   * Supports the same combinator pipeline as `wrap` (e.g. `withDefaultToast`).
+   *
+   * Each invocation of the resulting wrap call produces a fresh `[ref, execute]` pair
+   * (the `mutateStream` factory is called once per build), so independent commands
+   * don't share progress state.
+   *
+   * Accepts either:
+   * - An object with `id` and `mutateStream` factory (e.g. a client entry)
+   * - The `mutateStream` factory directly (callable, with `id`)
+   * - An already-called factory result (`[resultRef, execute] & { id }`) — shared ref across builds
+   *
+   * @example
+   * ```ts
+   * // Via client entry (recommended):
+   * const exportCmd = Command.wrapStream(client.myExport)()
+   *
+   * // Via factory directly:
+   * const exportCmd = Command.wrapStream(client.myExport.mutateStream)()
+   *
+   * // Via already-called factory (shared ref):
+   * const stream = client.myExport.mutateStream()
+   * const exportCmd = Command.wrapStream(stream)()
+   * ```
+   */
+  wrapStream = <
+    const Id extends string,
+    Arg,
+    A,
+    E,
+    R,
+    const State extends IntlRecord = IntlRecord,
+    const I18nKey extends string = Id
+  >(
+    mutation:
+      | {
+        id: Id
+        mutateStream:
+          | StreamMutationFactory<Id, Arg, A, E, R>
+          | StreamMutationTuple<Id, Arg, A, E, R>
+      }
+      | StreamMutationFactory<Id, Arg, A, E, R>
+      | StreamMutationTuple<Id, Arg, A, E, R>,
+    options?: FnOptions<Id, I18nKey, State>
+  ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
+    const id = mutation.id
+    // Resolve `source` to the factory or already-called tuple.
+    const source: StreamMutationFactory<Id, Arg, A, E, R> | StreamMutationTuple<Id, Arg, A, E, R> =
+      mutation !== null && typeof mutation === "object" && "mutateStream" in mutation
+        ? (mutation.mutateStream as any)
+        : (mutation as any)
+    const resolveTuple = (): StreamMutationTuple<Id, Arg, A, E, R> => (typeof source === "function" ? source() : source)
+    return 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
+
+        // Fresh per build: call the factory once per command instance so each
+        // wrap call gets its own ComputedRef + execute pair. `running`/`progress`
+        // are only surfaced when the factory was called with a `progress` formatter.
+        const tuple = resolveTuple()
+        const [, executeRaw] = tuple
+        const mutate: (_arg: Arg) => Effect.Effect<any, never, R> = Effect.isEffect(executeRaw)
+          ? (_arg: Arg) => executeRaw
+          : executeRaw
+        const streamMeta = { running: tuple.running, progress: tuple.progress }
+
+        return this.makeCommand(id, options, errorDef, streamMeta)(
+          Effect.fnUntraced(
+            isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
+              return yield* mutate(arg)
+            },
+            ...combinators as [any]
+          ) as any
+        )
+      },
+      makeBaseInfo(id, options),
+      {
+        state: Context.Service<`Commander.Command.${Id}.state`, State>(
+          `Commander.Command.${id}.state`
+        )
+      }
+    )
+  }
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class Commander extends ServiceMap.Service<Commander>()("Commander", {
+export class Commander extends Context.Service<Commander>()("Commander", {
   make: Effect.gen(function*() {
     const i18n = yield* I18n
-    return <RT, RTHooks>(rt: ServiceMap.ServiceMap<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) =>
+    return <RT, RTHooks>(rt: Context.Context<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) =>
       new CommanderImpl(rt, i18n, rtHooks)
   })
 }) {