@effect-app/vue 4.0.0-beta.98 → 4.0.0

package/dist/commander.d.ts

@@ -1,12 +1,29 @@
-import { type MissingDependencies } from "@effect-app/vue";
-import { Context, Effect, type Exit, type Fiber, Layer, Option } from "effect-app";
-import { type AsyncResult } from "effect/unstable/reactivity/AsyncResult";
+import { type MissingDependencies } from "@effect-app/vue/makeClient";
+import * as Context from "effect-app/Context";
+import * as Effect from "effect-app/Effect";
+import * as Layer from "effect-app/Layer";
+import * as Option from "effect-app/Option";
+import type * as Exit from "effect/Exit";
+import type * as Fiber from "effect/Fiber";
+import * as Predicate from "effect/Predicate";
+import { type Refinement } from "effect/Predicate";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Stream from "effect/Stream";
 import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat";
 import { type ComputedRef } from "vue";
 import { Confirm } from "./confirm.js";
 import { I18n } from "./intl.js";
+import { Toast } from "./toast.js";
 import { WithToast } from "./withToast.js";
 type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>;
+/**
+ * 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;
+};
 type FnOptions<Id extends string, I18nCustomKey extends string, State extends IntlRecord | undefined> = {
     i18nCustomKey?: I18nCustomKey;
     /**
@@ -63,6 +80,34 @@ declare const CommandContext_base: Context.ServiceClass<CommandContext, "Command
 }>;
 export declare class CommandContext extends CommandContext_base {
 }
+declare const CommandProgress_base: Context.Reference<{
+    readonly update: (progress: Progress | undefined) => Effect.Effect<void>;
+}>;
+/**
+ * Service available inside `streamFn` stream handlers that lets you imperatively push
+ * progress updates to the command's reactive `progress` ref.
+ *
+ * Use `Command.mapProgress(fn)` or `Command.updateProgress(progress)` to interact with this service.
+ *
+ * @example
+ * ```ts
+ * // Using mapProgress (recommended) — applied as a stream pipe operator:
+ * const exportCmd = Command.streamFn("exportData")(
+ *   function*(arg, ctx) {
+ *     return makeExportStream(arg.id).pipe(
+ *       Command.mapProgress((r) =>
+ *         AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress"
+ *           ? { text: `${r.value.completed}/${r.value.total}`, percentage: r.value.completed / r.value.total * 100 }
+ *           : undefined
+ *       )
+ *     )
+ *   }
+ * )
+ * // exportCmd.progress is updated for every OperationProgress event
+ * ```
+ */
+export declare class CommandProgress extends CommandProgress_base {
+}
 export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void;
 /**
  * Use to wrap emit calls with a callback to signal completion.
@@ -70,6 +115,14 @@ export type EmitWithCallback<A, Event extends string> = (event: Event, value: A,
  */
 export declare const wrapEmit: <A, Event extends string>(emit: EmitWithCallback<A, NoInfer<Event>>, event: Event) => (value: A) => Promise<void>;
 export declare namespace Commander {
+    type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>;
+    type FnOptions<Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
+        i18nCustomKey?: I18nKey;
+        state?: ComputedRef<State> | (() => State);
+        blockKey?: (id: Id) => string | undefined;
+        waitKey?: (id: Id) => string | undefined;
+        allowed?: (id: Id, state: ComputedRef<State>) => boolean;
+    };
     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.Service<`Commander.Command.${Id}.state`, State>;
     };
@@ -89,7 +142,12 @@ export declare namespace Commander {
         /** reactive */
         label: string;
         /** reactive */
-        result: AsyncResult<A, E>;
+        result: AsyncResult.AsyncResult<A, E>;
+        /**
+         * reactive – formatted progress info driven by `Command.mapProgress` or `Command.updateProgress`
+         * inside a `streamFn` handler. Undefined for non-stream commands.
+         */
+        progress: Progress | undefined;
         /** reactive */
         waiting: boolean;
         /** reactive */
@@ -102,7 +160,7 @@ export declare namespace Commander {
     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) => Fiber.Fiber<Exit.Exit<A, E>, never>) & {
+        handle: ((arg: Arg) => Fiber.Fiber<Exit.Exit<A, E>>) & {
             /** @deprecated don't exist */
             effect: (arg: Arg) => Effect.Effect<A, E, R>;
         };
@@ -113,56 +171,56 @@ export declare namespace Commander {
     type ArgForCombinator<Arg> = [Arg] extends [void] ? undefined : NoInfer<Arg>;
     type CommandOutHelper<Arg, Eff extends Effect.Effect<any, any, any>, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = CommandOut<Arg, Effect.Success<Eff>, Effect.Error<Eff>, Effect.Services<Eff>, Id, I18nKey, State>;
     type Gen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
-        <Eff extends Effect.Yieldable<any, any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, AEff, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>): CommandOut<Arg, AEff, [
+        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, AEff, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>): CommandOut<Arg, AEff, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never, Id, I18nKey, State>;
+        <Eff extends 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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOutHelper<Arg, A, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOutHelper<Arg, A, Id, I18nKey, State>;
+        <Eff extends 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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B): CommandOutHelper<Arg, B, Id, I18nKey, State>;
+        <Eff extends 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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>, 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, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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.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 [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
             Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>;
+        ] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, 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>;
     };
     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>;
@@ -200,20 +258,109 @@ export declare namespace Commander {
         <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: 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`>, B, C, D, E, F, G, H, I, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, 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>;
     };
+    /**
+     * Type for `streamFn` — generator overload where the body yields Effects and returns a `Stream`.
+     * `waiting` stays `true` while the stream is running, and updates the `result` ref per emitted value.
+     */
+    type StreamGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
+        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, SA, SE, SR, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, Stream.Stream<SA, SE, SR>, never>): CommandOut<Arg, SA, SE | ([Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never), SR | ([Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never), Id, I18nKey, State>;
+        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, SA, SE, SR, B, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, Stream.Stream<SA, SE, SR>, never>, a: (_: Effect.Effect<Stream.Stream<SA, SE, SR>, ([Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never), ([Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never)>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B): B extends Stream.Stream<infer SA2, infer SE2, infer SR2> ? CommandOut<Arg, SA2, SE2, SR2, Id, I18nKey, State> : B extends Effect.Effect<Stream.Stream<infer SA2, infer SE2, infer SR2>, infer EE2, infer ER2> ? CommandOut<Arg, SA2, SE2 | EE2, SR2 | ER2, Id, I18nKey, State> : never;
+    };
+    /**
+     * Type for `streamFn` — non-generator overload accepting a function that returns a `Stream` directly,
+     * or an `Effect` that resolves to a `Stream`.
+     */
+    type NonGenStream<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
+        <SA, SE, SR extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Stream.Stream<SA, SE, SR>): CommandOut<Arg, SA, SE, SR, Id, I18nKey, State>;
+        <SA, SE, SR, A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Stream.Stream<SA, SE, SR>, a: (_: Stream.Stream<SA, SE, SR>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>;
+        <SA, SE, SR, EE, ER extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<Stream.Stream<SA, SE, SR>, EE, ER>): CommandOut<Arg, SA, SE | EE, SR | ER, Id, I18nKey, State>;
+        <SA, SE, SR, EE, ER, B, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<Stream.Stream<SA, SE, SR>, EE, ER>, a: (_: Effect.Effect<Stream.Stream<SA, SE, SR>, EE, ER>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B): B extends Stream.Stream<infer SA2, infer SE2, infer SR2> ? CommandOut<Arg, SA2, SE2, SR2, Id, I18nKey, State> : B extends Effect.Effect<Stream.Stream<infer SA2, infer SE2, infer SR2>, infer EE2, infer ER2> ? CommandOut<Arg, SA2, SE2 | EE2, SR2 | ER2, Id, I18nKey, State> : never;
+    };
+    /**
+     * Type returned by `mutate.wrap` on a stream handler — analogous to `CommanderWrap` but for streams.
+     * The handler is pre-baked (from the stream mutation), so this is called with only optional combinators.
+     */
+    type StreamerWrap<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined, Arg, SA, SE, SR> = CommandContextLocal<Id, I18nKey> & {
+        readonly state: Context.Service<`Commander.Command.${Id}.state`, State>;
+    } & {
+        (): Exclude<SR, RT> extends never ? CommandOut<Arg, SA, SE, SR, Id, I18nKey, State> : MissingDependencies<RT, SR> & {};
+        <A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Stream.Stream<SA, SE, SR>, arg: ArgForCombinator<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>;
+        <B, A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Stream.Stream<SA, SE, SR>, 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>>) => A): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>;
+        <B, C, A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Stream.Stream<SA, SE, SR>, 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>>) => A): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>;
+        <B, C, D, A extends Stream.Stream<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Stream.Stream<SA, SE, SR>, 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>>) => A): CommandOut<Arg, Stream.Success<A>, Stream.Error<A>, Stream.Services<A>, Id, I18nKey, State>;
+    };
 }
 type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined;
+type RegisteredErrorRenderer<A> = {
+    guard: Refinement<unknown, A>;
+    render: (guarded: A) => string | undefined;
+};
+declare const CommanderErrorRenderers_base: Context.Reference<RegisteredErrorRenderer<any>[]>;
+export declare class CommanderErrorRenderers extends CommanderErrorRenderers_base {
+}
+export declare const makeRegisteredErrorRenderer: <A>(guard: Predicate.Refinement<unknown, A>, render: (guarded: A) => string | undefined) => RegisteredErrorRenderer<A>;
 export declare const CommanderStatic: {
     accessArgs: <In, Out, Arg2, Arg = void>(cb: (a: NoInfer<Arg>, b: NoInfer<Arg2>) => (self: NoInfer<In>) => Out) => (self: In, arg: Arg, arg2: Arg2) => Out;
+    /**
+     * Stream pipe operator that maps each emitted value to a `Progress` entry and updates the
+     * command's reactive `progress` ref via the `CommandProgress` service.
+     *
+     * The mapper receives an `AsyncResult<A, E>` (each emitted value wrapped as
+     * `AsyncResult.success(value, { waiting: true })`), matching the same shape used by
+     * `CommandButton`'s `:progress-map` prop.
+     *
+     * Designed to be used inside a `streamFn` handler (either directly with `.pipe()`, or as
+     * a combinator argument):
+     *
+     * @example
+     * ```ts
+     * // Inside the handler body:
+     * Command.streamFn("exportData")(function*(arg, ctx) {
+     *   return makeExportStream(arg.id).pipe(
+     *     Command.mapProgress((r) =>
+     *       AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress"
+     *         ? { text: `${r.value.completed}/${r.value.total}`, percentage: r.value.completed / r.value.total * 100 }
+     *         : undefined
+     *     )
+     *   )
+     * })
+     *
+     * // Or as a stream combinator argument:
+     * Command.streamFn("exportData")(
+     *   function*(arg, ctx) { return makeExportStream(arg.id) },
+     *   (s) => s.pipe(Command.mapProgress((r) => AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress" ? { text: `${r.value.completed}/${r.value.total}` } : undefined))
+     * )
+     * ```
+     */
+    mapProgress: <A, E>(fn: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined) => <R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+    /**
+     * Imperatively push a progress update from inside a `streamFn` handler.
+     * Requires `CommandProgress` to be in context — provided automatically for all `streamFn` streams.
+     *
+     * @example
+     * ```ts
+     * // In a streamFn handler:
+     * stream.pipe(
+     *   Stream.tap((event) =>
+     *     event._tag === "OperationProgress"
+     *       ? Command.updateProgress({ text: `${event.completed}/${event.total}`, percentage: event.completed / event.total * 100 })
+     *       : Effect.void
+     *   )
+     * )
+     * ```
+     */
+    updateProgress: (progress: Progress | undefined) => Effect.Effect<void>;
     /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
-    confirmOrInterrupt: (message?: string | undefined) => Effect.Effect<void, never, I18n | CommandContext | Confirm>;
+    confirmOrInterrupt: (message?: string | undefined) => Effect.Effect<void, never, CommandContext | Confirm | I18n>;
     /** Version of @see confirm that automatically includes the action name in the default messages */
-    confirm: (message?: string | undefined) => Effect.Effect<boolean, never, I18n | CommandContext | Confirm>;
-    updateAction: <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) => <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) => Effect.Effect<A, E, CommandContext | R>;
+    confirm: (message?: string | undefined) => Effect.Effect<boolean, never, CommandContext | Confirm | I18n>;
+    updateAction: <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) => <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) => Effect.Effect<A, E, R | CommandContext>;
+    registerErrorRenderer: <A>(guard: Predicate.Refinement<unknown, A>, render: (guarded: A) => string | undefined) => Layer.Layer<never, never, never>;
     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>) => (o: Option.Option<E>, ...args: Args) => Effect.Effect<string | {
         level: "warn";
         message: string;
-    }, AME, I18n | AMR>;
-    renderError: Effect.Effect<(<E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) => (e: E, ...args: Args) => string), never, I18n>;
+    }, AME, AMR | I18n>;
+    renderError: Effect.Effect<<E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) => (e: E, ...args: Args) => string, never, I18n>;
     /**
      * 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,
@@ -231,9 +378,45 @@ export declare const CommanderStatic: {
          */
         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.Effect<A, E, R | CommandContext | I18n | WithToast>;
+    /**
+     * Stream-aware version of `withDefaultToast`. Use this as a combinator inside `streamFn`
+     * (or anywhere a `Stream` needs toast lifecycle handling) instead of `withDefaultToast`.
+     *
+     * Unlike `withDefaultToast` (which only wraps the initial `Effect`), this combinator:
+     * - Shows the "waiting" toast **before** the stream starts
+     * - Updates the waiting toast with progress text when `progress` is set and a new element arrives
+     * - Shows the "success" toast only **after** the stream drains fully without error
+     * - Shows the "failure" toast if the stream errors or fails
+     *
+     * Accepts either a `Stream<A, E, R>` or an `Effect<Stream<A, E, R>, EE, ER>` as input,
+     * so it works in both the `NonGenStream` and `StreamGen` overloads of `streamFn`.
+     *
+     * @example
+     * ```ts
+     * Command.streamFn("exportData")(
+     *   function*(arg, ctx) { return makeExportStream(arg.id) },
+     *   Command.withDefaultToastStream({
+     *     progress: (r) =>
+     *       AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress"
+     *         ? { text: `${r.value.completed}/${r.value.total}`, percentage: r.value.completed / r.value.total * 100 }
+     *         : undefined
+     *   })
+     * )
+     * ```
+     */
+    withDefaultToastStream: <A, E, R, Args extends Array<unknown>>(options?: {
+        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.Effect<A, E, I18n | CommandContext | R | WithToast>;
+        /** Map each stream element to a progress label. When non-`undefined`, updates both the active waiting toast and the `CommandProgress` service (for CommandButton progress display). */
+        progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined;
+    }) => (self: Stream.Stream<A, E, R> | Effect.Effect<Stream.Stream<A, E, R>, any, any>, ...args: Args) => Stream.Stream<A, E, R | I18n | Toast | CommandContext>;
     /** borrowing the idea from Families in Effect Atom */
     family: <T extends object, Arg, ArgIn = Arg>(maker: (arg: Arg) => T, keyMaker?: (arg: ArgIn) => Arg) => (arg: ArgIn) => T;
 };
@@ -258,7 +441,8 @@ export declare class CommanderImpl<RT, RTHooks> {
         i18nKey: string;
         namespace: string;
         namespaced: (key: string) => string;
-        result: AsyncResult<A, E>;
+        result: AsyncResult.AsyncResult<A, E>;
+        progress: undefined;
         waiting: boolean;
         blocked: boolean;
         allowed: boolean;
@@ -304,6 +488,96 @@ export declare class CommanderImpl<RT, RTHooks> {
     }, options?: FnOptions<Id, I18nKey, State>) => Commander.Gen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGen<RT | RTHooks, Id, I18nKey, State> & {
         state: Context.Service<`Commander.Command.${Id}.state`, State>;
     };
+    /**
+     * Internal factory for stream-backed commands. Accepts a handler that returns a `Stream` directly.
+     * Services (`CommandContext`, `stateTag`) are provided to the stream via `Stream.provideServiceEffect`.
+     */
+    readonly makeStreamCommand: <const Id extends string, const State extends IntlRecord | undefined, const I18nKey extends string = Id>(id_: Id | {
+        id: Id;
+    }, options?: FnOptions<Id, I18nKey, State>, errorDef?: Error) => (<Arg, SA, SE, SR>(handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Stream.Stream<SA, SE, SR>) => {
+        id: import("vue").UnwrapRef<Id>;
+        i18nKey: string;
+        namespace: string;
+        namespaced: (key: string) => string;
+        result: AsyncResult.AsyncResult<SA, SE>;
+        progress: string | {
+            readonly text: string;
+            readonly percentage: number;
+        } | undefined;
+        waiting: boolean;
+        blocked: boolean;
+        allowed: boolean;
+        action: string;
+        label: string;
+        state: State;
+        handle: ((arg: Arg) => Fiber.Fiber<unknown, unknown>) & {
+            action: ComputedRef<string>;
+            label: ComputedRef<string>;
+        };
+    }) & {
+        id: Id;
+    };
+    /**
+     * Define a stream-backed Command for handling user actions.
+     *
+     * Like `fn`, but the body generator (or function) must **return** a `Stream` rather than
+     * an `Effect`. The command's `waiting` state stays `true` while the stream is running and
+     * is set to `false` once it terminates. The reactive `result` ref is updated for every
+     * value emitted by the stream.
+     *
+     * Three handler shapes are accepted:
+     * 1. **Generator returning a Stream** (primary) — may yield Effects freely before returning the stream:
+     *    ```ts
+     *    Command.streamFn("exportData")(
+     *      function*(arg, ctx) {
+     *        const token = yield* getAuthToken
+     *        return Stream.fromEffect(startExport(token, arg.id)).pipe(
+     *          Stream.flatMap((job) => pollProgress(job.id))
+     *        )
+     *      }
+     *    )
+     *    ```
+     * 2. **Function returning a Stream directly**: `(arg, ctx) => Stream.make(1, 2, 3)`
+     * 3. **Function returning `Effect<Stream>`**: `(arg, ctx) => Effect.map(setup, (s) => s.stream)`
+     *
+     * @param id The internal identifier for the action (used for tracing and i18n lookup).
+     * @param options Same options as `fn` (`state`, `blockKey`, `waitKey`, `allowed`, `i18nCustomKey`).
+     *
+     * **Progress** — use `Command.mapProgress(fn)` as a stream pipe operator; the mapper receives
+     * `AsyncResult<A, E>` (each value wrapped as `AsyncResult.success(v, { waiting: true })`),
+     * matching the same shape as CommandButton’s `:progress-map` prop. Or call
+     * `Command.updateProgress(p)` for imperative control:
+     *
+     * ```ts
+     * // mapProgress as a combinator arg (outside the handler):
+     * Command.streamFn("exportData")(
+     *   function*(arg, ctx) { return makeExportStream(arg.id) },
+     *   (s) => s.pipe(Command.mapProgress((r) => AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress" ? { text: `${r.value.completed}/${r.value.total}` } : undefined))
+     * )
+     *
+     * // Or inline inside the handler body:
+     * Command.streamFn("exportData")(function*(arg, ctx) {
+     *   return makeExportStream(arg.id).pipe(Command.mapProgress((r) => AsyncResult.isSuccess(r) ? ... : undefined))
+     * })
+     * ```
+     *
+     * **Pipeable combinators** — the 2nd–Nth args follow the same pattern as `fn`: each combinator
+     * receives `(stream, arg, ctx)` and returns a transformed stream:
+     * ```ts
+     * Command.streamFn("exportData")(
+     *   handler,
+     *   (s, arg, ctx) => s.pipe(Command.mapProgress(fn), Stream.take(100))
+     * )
+     * ```
+     *
+     * **Returned Properties**: `action`, `label`, `result`, `progress`, `waiting`, `blocked`,
+     * `allowed`, `handle`, `i18nKey`, `namespace`, `namespaced`.
+     */
+    streamFn: <const Id extends string, const State extends IntlRecord = IntlRecord, const I18nKey extends string = Id>(id: Id | {
+        id: Id;
+    }, options?: FnOptions<Id, I18nKey, State>) => Commander.StreamGen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGenStream<RT | RTHooks, Id, I18nKey, State> & {
+        state: Context.Service<`Commander.Command.${Id}.state`, State>;
+    };
     /** @deprecated */
     alt2: <const Id extends string, MutArg, MutA, MutE, MutR, const I18nKey extends string = Id, State extends IntlRecord | undefined = undefined>(id: Id | {
         id: Id;
@@ -341,6 +615,7 @@ export declare class CommanderImpl<RT, RTHooks> {
      * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
      * the `result` inline for custom UI feedback.
      */
+    streamWrap: <const Id extends string, Arg, SA, SE, SR, const State extends IntlRecord = IntlRecord, I18nKey extends string = Id>(handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Stream.Stream<SA, SE, SR>, id: Id, options?: FnOptions<Id, I18nKey, State>) => Commander.StreamerWrap<RT | RTHooks, Id, I18nKey, State, Arg, SA, SE, SR>;
     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;
@@ -349,7 +624,7 @@ export declare class CommanderImpl<RT, RTHooks> {
     }), options?: FnOptions<Id, I18nKey, State>) => Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R>;
 }
 declare const Commander_base: Context.ServiceClass<Commander, "Commander", <RT, RTHooks>(rt: Context.Context<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) => CommanderImpl<RT, RTHooks>> & {
-    readonly make: Effect.Effect<(<RT, RTHooks>(rt: Context.Context<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) => CommanderImpl<RT, RTHooks>), never, I18n>;
+    readonly make: Effect.Effect<<RT, RTHooks>(rt: Context.Context<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) => CommanderImpl<RT, RTHooks>, never, I18n>;
 };
 export declare class Commander extends Commander_base {
     static readonly DefaultWithoutDependencies: Layer.Layer<Commander, never, I18n>;