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

package/dist/commander.js

@@ -1,13 +1,24 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { asResult, reportRuntimeError } from "@effect-app/vue";
 import { reportMessage } from "@effect-app/vue/errorReporter";
-import { Cause, Context, Effect, flow, Layer, Match, MutableHashMap, Option, Predicate, S } from "effect-app";
+import { deepToRaw, reportRuntimeError } from "@effect-app/vue/lib";
+import { asResult, asStreamResult } from "@effect-app/vue/mutate";
 import { SupportedErrors } from "effect-app/client";
-import { OperationFailure, OperationSuccess } from "effect-app/Operations";
+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 * as S from "effect-app/Schema";
 import { isGeneratorFunction, wrapEffect } from "effect-app/utils";
-import { computed, reactive, ref } from "vue";
+import * as Cause from "effect/Cause";
+import { flow } from "effect/Function";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Predicate from "effect/Predicate";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+import * as Stream from "effect/Stream";
+import { computed, reactive, ref, toRaw } from "vue";
 import { Confirm } from "./confirm.js";
 import { I18n } from "./intl.js";
+import { CurrentToastId, Toast } from "./toast.js";
 import { WithToast } from "./withToast.js";
 export const DefaultIntl = {
     de: {
@@ -39,39 +50,86 @@ export const DefaultIntl = {
 };
 export class CommandContext extends Context.Service()("CommandContext") {
 }
+/**
+ * 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 class CommandProgress extends Context.Reference("Commander.CommandProgress", {
+    defaultValue: () => ({ update: (_progress) => Effect.void })
+}) {
+}
 /**
  * Use to wrap emit calls with a callback to signal completion.
  * Useful when the publisher wants to wait for the subscriber to finish processing.
  */
 export const wrapEmit = (emit, event) => (value) => new Promise((resolve) => emit(event, value, resolve));
-const renderErrorMaker = I18n.useSync(({ intl }) => (action, errorRenderer) => (e, ...args) => {
-    if (errorRenderer) {
-        const m = errorRenderer(e, action, ...args);
-        if (m !== undefined) {
-            return m;
+export class CommanderErrorRenderers extends Context.Reference("Commander.ErrorRenderers", {
+    defaultValue: () => []
+}) {
+}
+export const makeRegisteredErrorRenderer = (guard, render) => ({
+    guard,
+    render
+});
+const renderErrorMaker = Effect.gen(function* () {
+    const { intl } = yield* I18n;
+    const registeredRenderers = yield* CommanderErrorRenderers;
+    return ((action, errorRenderer) => (e, ...args) => {
+        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 = 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());
+        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}`;
+                }
+            }
+            return "";
+        }
+        const e2 = e;
+        if (e2._tag === "NotFoundError") {
+            return intl.formatMessage({ id: "handle.not_found" }, { type: e2.type, id: String(e2.id) });
+        }
+        if (e2._tag === "SchemaError") {
+            console.warn(e2.toString());
             return intl.formatMessage({ id: "validation.failed" });
         }
-    }), Match.orElse((e) => `${e.message ?? e._tag ?? e}`));
+        return e2.message ?? e2._tag ?? e2;
+    });
 });
 const defaultFailureMessageHandler = (actionMaker, errorRenderer) => Effect.fnUntraced(function* (o, ...args) {
     const action = yield* wrapEffect(actionMaker)(o, ...args);
@@ -82,33 +140,88 @@ const defaultFailureMessageHandler = (actionMaker, errorRenderer) => Effect.fnUn
             action,
             error: "" // TODO consider again Cause.pretty(cause), // will be reported to Sentry/Otel anyway.. and we shouldn't bother users with error dumps?
         }),
-        onSome: (e) => S.is(OperationFailure)(e)
-            ? {
+        onSome: (e) => {
+            const rendered = renderError(action, errorRenderer)(e, ...args);
+            return {
                 level: "warn",
-                message: intl.formatMessage({ id: "handle.with_warnings" }, { action }) + e.message
-                    ? "\n" + e.message
-                    : ""
-            }
-            : `${intl.formatMessage({ id: "handle.with_errors" }, { action })}:\n` + renderError(action, errorRenderer)(e, ...args)
+                message: `${intl.formatMessage({ id: "handle.with_errors" }, { action })}:\n` + rendered
+            };
+        }
     });
 });
 export const CommanderStatic = {
     accessArgs: (cb) => (self, arg, arg2) => cb(arg, arg2)(self),
+    /**
+     * 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: (fn) => (stream) => stream.pipe(Stream.tap((v) => {
+        const p = fn(AsyncResult.success(v, { waiting: true }));
+        return p !== undefined ? CommandProgress.use((s) => s.update(p)) : Effect.void;
+    })),
+    /**
+     * 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) => CommandProgress.use((s) => s.update(progress)),
     /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
-    confirmOrInterrupt: Effect.fnUntraced(function* (message = undefined) {
+    confirmOrInterrupt: Effect.fnUntraced(function* (message) {
         const context = yield* CommandContext;
         const { intl } = yield* I18n;
         yield* Confirm.confirmOrInterrupt(message
             ?? intl.formatMessage({ id: "handle.confirmation" }, { action: context.action }));
     }),
     /** Version of @see confirm that automatically includes the action name in the default messages */
-    confirm: Effect.fnUntraced(function* (message = undefined) {
+    confirm: Effect.fnUntraced(function* (message) {
         const context = yield* CommandContext;
         const { intl } = yield* I18n;
         return yield* Confirm.confirm(message
             ?? intl.formatMessage({ id: "handle.confirmation" }, { action: context.action }));
     }),
     updateAction: (update) => (_, ...input) => Effect.updateService(_, CommandContext, (c) => ({ ...c, action: update(c.action, ...input) })),
+    registerErrorRenderer: (guard, render) => Layer.effect(CommanderErrorRenderers, Effect.gen(function* () {
+        const current = yield* CommanderErrorRenderers;
+        return [...current, makeRegisteredErrorRenderer(guard, render)];
+    })),
     defaultFailureMessageHandler,
     renderError: renderErrorMaker,
     /**
@@ -122,7 +235,7 @@ export const CommanderStatic = {
      * If you provide a string or function, it will be used instead of the i18n message.
      * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
      */
-    withDefaultToast: (options) => (self, ...args) => Effect.gen(function* () {
+    withDefaultToast: (options) => Effect.fnUntraced(function* (self, ...args) {
         const cc = yield* CommandContext;
         const { intl } = yield* I18n;
         const withToast = yield* WithToast;
@@ -156,14 +269,150 @@ export const CommanderStatic = {
                 : intl.formatMessage({ id: "handle.waiting" }, { action: cc.action }),
             onSuccess: options?.onSuccess === null
                 ? null
-                : (a, ..._args) => hasCustomSuccess
+                : (_a, ..._args) => hasCustomSuccess
                     ? intl.formatMessage({ id: customSuccess }, cc.state)
-                    : (intl.formatMessage({ id: "handle.success" }, { action: cc.action })
-                        + (S.is(OperationSuccess)(a) && a.message ? "\n" + a.message : "")),
+                    : intl.formatMessage({ id: "handle.success" }, { action: cc.action }),
             onFailure: defaultFailureMessageHandler(hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action, options?.errorRenderer),
-            stableToastId
+            stableToastId,
+            groupId: cc.id,
+            ...options?.showSpanInfo === false ? { showSpanInfo: options.showSpanInfo } : {}
         })(_, ...args));
     }),
+    /**
+     * 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: (options) => (self, ...args) => {
+        const rawStream = Stream.isStream(self)
+            ? self
+            : Stream.unwrap(self);
+        return Stream.unwrap(Effect.gen(function* () {
+            const cc = yield* CommandContext;
+            const { intl } = yield* I18n;
+            const toast = yield* Toast;
+            const customWaiting = cc.namespaced("waiting");
+            const hasCustomWaiting = !!intl.messages[customWaiting];
+            const customSuccess = cc.namespaced("success");
+            const hasCustomSuccess = !!intl.messages[customSuccess];
+            const customFailure = cc.namespaced("failure");
+            const hasCustomFailure = !!intl.messages[customFailure];
+            const stableToastId = options?.stableToastId
+                ? typeof options.stableToastId === "string"
+                    ? options.stableToastId
+                    : typeof options.stableToastId === "boolean"
+                        ? cc.id
+                        : typeof options.stableToastId === "function"
+                            ? (() => {
+                                const r = options.stableToastId(cc.id, ...args);
+                                if (typeof r === "string")
+                                    return r;
+                                if (r === true)
+                                    return cc.id;
+                                return undefined;
+                            })()
+                            : undefined
+                : undefined;
+            const baseTimeout = 3_000;
+            const waitingMsg = options?.onWaiting === null
+                ? null
+                : typeof options?.onWaiting === "string"
+                    ? options.onWaiting
+                    : typeof options?.onWaiting === "function"
+                        ? options.onWaiting(cc.id, ...args) ?? null
+                        : hasCustomWaiting
+                            ? intl.formatMessage({ id: customWaiting }, cc.state)
+                            : intl.formatMessage({ id: "handle.waiting" }, { action: cc.action });
+            const toastId = waitingMsg === null
+                ? stableToastId
+                : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`;
+            const requestId = yield* Effect.currentSpan.pipe(Effect.map((span) => span.traceId), Effect.orElseSucceed(() => S.StringId.make()));
+            const meta = { groupId: cc.id, requestId };
+            if (waitingMsg !== null) {
+                yield* toast.info(waitingMsg, { id: toastId, timeout: Infinity, ...meta });
+            }
+            const failureHandler = defaultFailureMessageHandler(hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action, options?.errorRenderer);
+            let lastValue = undefined;
+            let didFail = false;
+            const composed = rawStream.pipe(Stream.tap((v) => Effect.gen(function* () {
+                lastValue = v;
+                if (options?.progress !== undefined) {
+                    const p = options.progress(AsyncResult.success(v, { waiting: true }));
+                    if (p !== undefined) {
+                        // Update CommandProgress so CommandButton progress indicator is also driven
+                        yield* CommandProgress.use((s) => s.update(p));
+                        if (toastId !== undefined) {
+                            const progressText = typeof p === "string" ? p : p.text;
+                            const msg = waitingMsg ? `${waitingMsg}\n${progressText}` : progressText;
+                            yield* toast.info(msg, { id: toastId, timeout: Infinity, ...meta });
+                        }
+                    }
+                }
+            })), Stream.tapCause(Effect.fnUntraced(function* (cause) {
+                didFail = true;
+                if (Cause.hasInterruptsOnly(cause)) {
+                    if (toastId !== undefined)
+                        yield* toast.dismiss(toastId);
+                    return;
+                }
+                const spanInfo = options?.showSpanInfo !== false
+                    ? yield* Effect.currentSpan.pipe(Effect.map((span) => `\nTrace: ${span.traceId}\nSpan: ${span.spanId}`), Effect.orElseSucceed(() => ""))
+                    : "";
+                const t = yield* failureHandler(Cause.findErrorOption(cause));
+                const opts = { timeout: baseTimeout * 2, ...meta };
+                if (typeof t === "object") {
+                    const message = t.message + spanInfo;
+                    yield* t.level === "warn"
+                        ? toast.warning(message, toastId !== undefined ? { ...opts, id: toastId } : opts)
+                        : toast.error(message, toastId !== undefined ? { ...opts, id: toastId } : opts);
+                }
+                else {
+                    yield* toast.error(t + spanInfo, toastId !== undefined ? { ...opts, id: toastId } : opts);
+                }
+            }, Effect.uninterruptible)), Stream.ensuring(Effect.suspend(() => {
+                if (didFail)
+                    return Effect.void;
+                if (options?.onSuccess === null)
+                    return Effect.void;
+                const successMsg = typeof options?.onSuccess === "string"
+                    ? options.onSuccess
+                    : typeof options?.onSuccess === "function"
+                        ? options.onSuccess(lastValue, cc.action, ...args) ?? null
+                        : hasCustomSuccess
+                            ? intl.formatMessage({ id: customSuccess }, cc.state)
+                            : intl.formatMessage({ id: "handle.success" }, { action: cc.action });
+                if (successMsg === null)
+                    return Effect.void;
+                return toast.success(successMsg, toastId !== undefined
+                    ? { id: toastId, timeout: baseTimeout, ...meta }
+                    : { timeout: baseTimeout, ...meta });
+            })));
+            return (toastId !== undefined
+                ? composed.pipe(Stream.provideService(CurrentToastId, CurrentToastId.of({ toastId })))
+                : composed);
+        }));
+    },
     /** borrowing the idea from Families in Effect Atom */
     family: (maker, keyMaker) => {
         const commands = MutableHashMap.empty();
@@ -330,6 +579,7 @@ export class CommanderImpl {
             const rt = Effect.context().pipe(Effect.provide(this.hooks)).pipe(Effect.runSyncWith(this.rt));
             const runFork = Effect.runForkWith(rt);
             const handle = Object.assign((arg) => {
+                arg = toRaw(arg); // remove outside vue proxy bs
                 // we capture the call site stack here
                 const limit = Error.stackTraceLimit;
                 Error.stackTraceLimit = 2;
@@ -357,17 +607,21 @@ export class CommanderImpl {
                         return cache;
                     }
                 };
-                const command = currentState.pipe(Effect.flatMap((state) => Effect.withSpan(exec(arg, { ...context.value, state }), id, {
-                    captureStackTrace,
-                    attributes: {
-                        input: arg,
-                        state,
-                        action: initialContext.action,
-                        label: initialContext.label,
-                        id: initialContext.id,
-                        i18nKey: initialContext.i18nKey
-                    }
-                })));
+                const command = currentState.pipe(Effect.flatMap((state) => {
+                    const rawArg = deepToRaw(arg);
+                    const rawState = deepToRaw(state);
+                    return Effect.withSpan(exec(arg, { ...context.value, state }), id, {
+                        captureStackTrace,
+                        attributes: {
+                            input: rawArg,
+                            state: rawState,
+                            action: initialContext.action,
+                            label: initialContext.label,
+                            id: initialContext.id,
+                            i18nKey: initialContext.i18nKey
+                        }
+                    });
+                }));
                 return runFork(command);
             }, { action, label });
             return reactive({
@@ -381,6 +635,8 @@ export class CommanderImpl {
                 namespaced: initialContext.namespaced,
                 /** reactive */
                 result,
+                /** always undefined for non-stream commands */
+                progress: undefined,
                 /** reactive */
                 waiting,
                 /** reactive */
@@ -470,20 +726,252 @@ export class CommanderImpl {
      * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
      * the `result` inline for custom UI feedback.
      */
-    fn = (id, options) => Object.assign((fn, ...combinators) => {
-        // we capture the definition stack here, so we can append it to later stack traces
-        const limit = Error.stackTraceLimit;
-        Error.stackTraceLimit = 2;
-        const errorDef = new Error();
-        Error.stackTraceLimit = limit;
-        return this.makeCommand(id, options, errorDef)(Effect.fnUntraced(
-        // fnUntraced only supports generators as first arg, so we convert to generator if needed
-        isGeneratorFunction(fn) ? fn : function* (...args) {
-            return yield* fn(...args);
-        }, ...combinators));
-    }, makeBaseInfo(typeof id === "string" ? id : id.id, options), {
-        state: Context.Service(`Commander.Command.${typeof id === "string" ? id : id.id}.state`)
-    });
+    fn = (id, options) => {
+        const resolvedId = typeof id === "string" ? id : id.id;
+        return Object.assign((fn, ...combinators) => {
+            // we capture the definition stack here, so we can append it to later stack traces
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const errorDef = new Error();
+            Error.stackTraceLimit = limit;
+            return this.makeCommand(resolvedId, options, errorDef)(Effect.fnUntraced(
+            // fnUntraced only supports generators as first arg, so we convert to generator if needed
+            isGeneratorFunction(fn) ? fn : function* (...args) {
+                return yield* fn(...args);
+            }, ...combinators));
+        }, makeBaseInfo(resolvedId, options), {
+            state: Context.Service(`Commander.Command.${resolvedId}.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`.
+     */
+    makeStreamCommand = (id_, options, errorDef) => {
+        const id = typeof id_ === "string" ? id_ : id_.id;
+        const state = getStateValues(options);
+        return Object.assign((handler) => {
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const localErrorDef = new Error();
+            Error.stackTraceLimit = limit;
+            if (!errorDef) {
+                errorDef = localErrorDef;
+            }
+            const key = `Commander.Command.${id}.state`;
+            const stateTag = Context.Service(key);
+            const makeContext_ = () => this.makeContext(id, { ...options, state: state?.value });
+            const initialContext = makeContext_();
+            const context = computed(() => makeContext_());
+            const action = computed(() => context.value.action);
+            const label = computed(() => context.value.label);
+            const currentState = Effect.sync(() => state.value);
+            // Reactive ref driven by the CommandProgress service — updated imperatively
+            // from inside the stream via `Command.mapProgress(fn)` or `Command.updateProgress(p)`.
+            const progressRef = ref(undefined);
+            const commandProgressService = {
+                update: (p) => Effect.sync(() => {
+                    progressRef.value = p;
+                })
+            };
+            const streamErrorReporter = (self) => self.pipe(Stream.tapCause(Effect.fnUntraced(function* (cause) {
+                if (Cause.hasInterruptsOnly(cause)) {
+                    console.info(`Interrupted while trying to ${id}`);
+                    return;
+                }
+                const fail = Cause.findErrorOption(cause);
+                if (Option.isSome(fail)) {
+                    const message = `Failure trying to ${id}`;
+                    yield* reportMessage(message, {
+                        action: id,
+                        error: fail.value
+                    });
+                    return;
+                }
+                const ctx = yield* CommandContext;
+                const extra = {
+                    action: ctx.action,
+                    message: `Unexpected Error trying to ${id}`
+                };
+                yield* reportRuntimeError(cause, extra);
+            }, Effect.uninterruptible)));
+            const theStreamHandler = (arg, ctx) => handler(arg, ctx).pipe(streamErrorReporter, Stream.provideService(CommandProgress, commandProgressService), Stream.provideServiceEffect(stateTag, currentState), Stream.provideServiceEffect(CommandContext, Effect.sync(() => makeContext_())));
+            const waitId = options?.waitKey ? options.waitKey(id) : undefined;
+            const blockId = options?.blockKey ? options.blockKey(id) : undefined;
+            const [result, exec_] = asStreamResult(theStreamHandler);
+            const exec = Effect
+                .fnUntraced(function* (...args) {
+                if (waitId !== undefined)
+                    registerWait(waitId);
+                if (blockId !== undefined && blockId !== waitId) {
+                    registerWait(blockId);
+                }
+                return yield* exec_(...args);
+            }, Effect.onExit(() => Effect.sync(() => {
+                if (waitId !== undefined)
+                    unregisterWait(waitId);
+                if (blockId !== undefined && blockId !== waitId) {
+                    unregisterWait(blockId);
+                }
+            })));
+            const waiting = waitId !== undefined
+                ? computed(() => result.value.waiting || (waitState.value[waitId] ?? 0) > 0)
+                : computed(() => result.value.waiting);
+            const blocked = blockId !== undefined
+                ? computed(() => waiting.value || (waitState.value[blockId] ?? 0) > 0)
+                : computed(() => waiting.value);
+            const computeAllowed = options?.allowed;
+            const allowed = computeAllowed ? computed(() => computeAllowed(id, state)) : true;
+            const rt = Effect.context().pipe(Effect.provide(this.hooks)).pipe(Effect.runSyncWith(this.rt));
+            const runFork = Effect.runForkWith(rt);
+            const progress = progressRef;
+            const handle = Object.assign((arg) => {
+                arg = toRaw(arg);
+                progressRef.value = undefined; // reset progress on new invocation
+                const limit = Error.stackTraceLimit;
+                Error.stackTraceLimit = 2;
+                const errorCall = new Error();
+                Error.stackTraceLimit = limit;
+                let cache = false;
+                const captureStackTrace = () => {
+                    if (cache !== false) {
+                        return cache;
+                    }
+                    if (errorCall.stack) {
+                        const stackDef = errorDef.stack.trim().split("\n");
+                        const stackCall = errorCall.stack.trim().split("\n");
+                        let endStackDef = stackDef.slice(2).join("\n").trim();
+                        if (!endStackDef.includes(`(`)) {
+                            endStackDef = endStackDef.replace(/at (.*)/, "at ($1)");
+                        }
+                        let endStackCall = stackCall.slice(2).join("\n").trim();
+                        if (!endStackCall.includes(`(`)) {
+                            endStackCall = endStackCall.replace(/at (.*)/, "at ($1)");
+                        }
+                        cache = `${endStackDef}\n${endStackCall}`;
+                        return cache;
+                    }
+                };
+                const command = currentState.pipe(Effect.flatMap((state) => {
+                    const rawArg = deepToRaw(arg);
+                    const rawState = deepToRaw(state);
+                    return Effect.withSpan(exec(arg, { ...context.value, state }), id, {
+                        captureStackTrace,
+                        attributes: {
+                            input: rawArg,
+                            state: rawState,
+                            action: initialContext.action,
+                            label: initialContext.label,
+                            id: initialContext.id,
+                            i18nKey: initialContext.i18nKey
+                        }
+                    });
+                }));
+                return runFork(command);
+            }, { action, label });
+            return reactive({
+                id,
+                i18nKey: initialContext.i18nKey,
+                namespace: initialContext.namespace,
+                namespaced: initialContext.namespaced,
+                result,
+                /** reactive – progress driven by `Command.mapProgress` or `Command.updateProgress` inside the stream */
+                progress,
+                waiting,
+                blocked,
+                allowed,
+                action,
+                label,
+                state,
+                handle
+            });
+        }, { 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 = (id, options) => {
+        const resolvedId = typeof id === "string" ? id : id.id;
+        const toRawHandler = (fn) => {
+            if (isGeneratorFunction(fn)) {
+                return Effect.fnUntraced(function* (arg, ctx) {
+                    return yield* fn(arg, ctx);
+                });
+            }
+            return fn;
+        };
+        const toFinalStream = (value) => Stream.isStream(value) ? value : Stream.unwrap(value);
+        return Object.assign((fn, ...combinators) => {
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const errorDef = new Error();
+            Error.stackTraceLimit = limit;
+            const rawHandler = toRawHandler(fn);
+            const handler = (arg, ctx) => {
+                let current = rawHandler(arg, ctx);
+                for (const combinator of combinators) {
+                    current = combinator(current, arg, ctx);
+                }
+                return toFinalStream(current);
+            };
+            return this.makeStreamCommand(id, options, errorDef)(handler);
+        }, makeBaseInfo(resolvedId, options), {
+            state: Context.Service(`Commander.Command.${resolvedId}.state`)
+        });
+    };
     /** @deprecated */
     alt2 = (_id, options) => {
         const isObject = Predicate.isObjectKeyword(_id);
@@ -527,21 +1015,45 @@ export class CommanderImpl {
      * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
      * the `result` inline for custom UI feedback.
      */
-    wrap = (mutation, options) => Object.assign((...combinators) => {
-        // we capture the definition stack here, so we can append it to later stack traces
-        const limit = Error.stackTraceLimit;
-        Error.stackTraceLimit = 2;
-        const errorDef = new Error();
-        Error.stackTraceLimit = limit;
-        const mutate = "mutate" in mutation ? mutation.mutate : mutation;
-        return this.makeCommand(mutation.id, options, errorDef)(Effect.fnUntraced(
-        // fnUntraced only supports generators as first arg, so we convert to generator if needed
-        isGeneratorFunction(mutate) ? mutate : function* (arg) {
-            return yield* mutate(arg);
-        }, ...combinators));
-    }, makeBaseInfo(mutation.id, options), {
-        state: Context.Service(`Commander.Command.${mutation.id}.state`)
-    });
+    streamWrap = (handler, id, options) => {
+        return Object.assign((...combinators) => {
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const errorDef = new Error();
+            Error.stackTraceLimit = limit;
+            return this.makeStreamCommand(id, options, errorDef)(combinators.length === 0
+                ? handler
+                : (arg, ctx) => {
+                    let current = handler(arg, ctx);
+                    for (const combinator of combinators) {
+                        current = combinator(current, arg, ctx);
+                    }
+                    return current;
+                });
+        }, makeBaseInfo(id, options), {
+            state: Context.Service(`Commander.Command.${id}.state`)
+        });
+    };
+    wrap = (mutation, options) => {
+        const callMutation = mutation;
+        return Object.assign((...combinators) => {
+            // we capture the definition stack here, so we can append it to later stack traces
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const errorDef = new Error();
+            Error.stackTraceLimit = limit;
+            const mutate = "mutate" in callMutation
+                ? callMutation.mutate
+                : callMutation;
+            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) {
+                return yield* mutate(arg);
+            }, ...combinators));
+        }, makeBaseInfo(callMutation.id, options), {
+            state: Context.Service(`Commander.Command.${callMutation.id}.state`)
+        });
+    };
 }
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class Commander extends Context.Service()("Commander", {
@@ -553,4 +1065,4 @@ export class Commander extends Context.Service()("Commander", {
     static DefaultWithoutDependencies = Layer.effect(this, this.make);
     static Default = this.DefaultWithoutDependencies;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commander.js","sourceRoot":"","sources":["../src/commander.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commander.js","sourceRoot":"","sources":["../src/commander.ts"],"names":[],"mappings":"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"}