@effect-app/vue 4.0.0-beta.19 → 4.0.0-beta.191

package/dist/commander.js

@@ -0,0 +1,1056 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { asResult, asStreamResult, deepToRaw, reportRuntimeError } from "@effect-app/vue";
+import { reportMessage } from "@effect-app/vue/errorReporter";
+import { Cause, Context, Effect, Fiber, flow, Layer, Match, MutableHashMap, Option, Predicate, S } from "effect-app";
+import { SupportedErrors } from "effect-app/client";
+import { isGeneratorFunction, wrapEffect } from "effect-app/utils";
+import * as Stream from "effect/Stream";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+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: {
+        "handle.confirmation": "{action} bestätigen?",
+        "handle.waiting": "{action} wird ausgeführt...",
+        "handle.success": "{action} erfolgreich",
+        "handle.with_errors": "{action} fehlgeschlagen",
+        "handle.with_warnings": "{action} erfolgreich, mit Warnungen",
+        "handle.error_response": "Die Anfrage war nicht erfolgreich:\n{error}\nWir wurden benachrichtigt und werden das Problem in Kürze beheben.",
+        "handle.response_error": "Die Antwort konnte nicht verarbeitet werden:\n{error}",
+        "handle.request_error": "Die Anfrage konnte nicht gesendet werden:\n{error}",
+        "handle.unexpected_error2": "{action} unerwarteter Fehler, probieren sie es in kurze nochmals.",
+        "handle.unexpected_error": "Unerwarteter Fehler:\n{error}",
+        "handle.not_found": "Das gesuchte war nicht gefunden"
+    },
+    en: {
+        "handle.confirmation": "Confirm {action}?",
+        "handle.waiting": "{action} executing...",
+        "handle.success": "{action} Success",
+        "handle.with_errors": "{action} Failed",
+        "handle.with_warnings": "{action}, with warnings",
+        "handle.error_response": "There was an error in processing the response:\n{error}\nWe have been notified and will fix the problem shortly.",
+        "handle.request_error": "There was an error in the request:\n{error}",
+        "handle.response_error": "The request was not successful:\n{error}",
+        "handle.unexpected_error2": "{action} unexpected error, please try again shortly.",
+        "handle.unexpected_error": "Unexpected Error:\n{error}",
+        "handle.not_found": "The requested item was not found."
+    }
+};
+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));
+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;
+            }
+        }
+        for (const entry of registeredRenderers) {
+            if (!entry.guard(e)) {
+                continue;
+            }
+            const m = entry.render(e);
+            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}`;
+                }
+                if ("_tag" in e) {
+                    return `${e._tag}`;
+                }
+            }
+            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());
+                return intl.formatMessage({ id: "validation.failed" });
+            }
+        }), Match.orElse((e) => e.message ?? e._tag ?? e));
+    });
+});
+const defaultFailureMessageHandler = (actionMaker, errorRenderer) => Effect.fnUntraced(function* (o, ...args) {
+    const action = yield* wrapEffect(actionMaker)(o, ...args);
+    const { intl } = yield* I18n;
+    const renderError = yield* renderErrorMaker;
+    return Option.match(o, {
+        onNone: () => intl.formatMessage({ id: "handle.unexpected_error2" }, {
+            action,
+            error: "" // TODO consider again Cause.pretty(cause), // will be reported to Sentry/Otel anyway.. and we shouldn't bother users with error dumps?
+        }),
+        onSome: (e) => {
+            const rendered = renderError(action, errorRenderer)(e, ...args);
+            return {
+                level: "warn",
+                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) {
+        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) {
+        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,
+    /**
+     * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
+     * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
+     * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
+     *
+     * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
+     *
+     * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
+     * If you provide a string or function, it will be used instead of the i18n message.
+     * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
+     */
+    withDefaultToast: (options) => Effect.fnUntraced(function* (self, ...args) {
+        const cc = yield* CommandContext;
+        const { intl } = yield* I18n;
+        const withToast = yield* WithToast;
+        const customWaiting = cc.namespaced("waiting");
+        const hasCustomWaiting = !!intl.messages[customWaiting];
+        const customSuccess = cc.namespaced("success");
+        const hasCustomSuccess = !!intl.messages[customSuccess];
+        const customFailure = cc.namespaced("failure");
+        const hasCustomFailure = !!intl.messages[customFailure];
+        const stableToastId = options?.stableToastId
+            ? typeof options.stableToastId === "string"
+                ? options.stableToastId
+                : typeof options.stableToastId === "boolean"
+                    ? cc.id
+                    : typeof options.stableToastId === "function"
+                        ? (...args) => {
+                            const r = options.stableToastId(cc.id, ...args);
+                            if (typeof r === "string")
+                                return r;
+                            if (r === true)
+                                return cc.id;
+                            return undefined;
+                        }
+                        : undefined
+            : undefined;
+        return yield* self.pipe((_) => withToast({
+            onWaiting: options?.onWaiting === null ? null : hasCustomWaiting
+                ? intl.formatMessage({
+                    id: customWaiting
+                }, cc.state)
+                : intl.formatMessage({ id: "handle.waiting" }, { action: cc.action }),
+            onSuccess: options?.onSuccess === null
+                ? null
+                : (_a, ..._args) => hasCustomSuccess
+                    ? intl.formatMessage({ id: customSuccess }, cc.state)
+                    : intl.formatMessage({ id: "handle.success" }, { action: cc.action }),
+            onFailure: defaultFailureMessageHandler(hasCustomFailure ? intl.formatMessage({ id: customFailure }, cc.state) : cc.action, options?.errorRenderer),
+            stableToastId,
+            ...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 waitingFiber = waitingMsg === null ? undefined : yield* Effect.forkDetach(Effect.sleep("1 seconds").pipe(Effect.andThen(toast.info(waitingMsg, { id: toastId, timeout: Infinity }))));
+            const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void;
+            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) {
+                            yield* interruptWaiting;
+                            const progressText = typeof p === "string" ? p : p.text;
+                            const msg = waitingMsg ? `${waitingMsg}\n${progressText}` : progressText;
+                            yield* toast.info(msg, { id: toastId, timeout: Infinity });
+                        }
+                    }
+                }
+            })), Stream.tapCause(Effect.fnUntraced(function* (cause) {
+                didFail = true;
+                yield* interruptWaiting;
+                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 };
+                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 interruptWaiting;
+                if (options?.onSuccess === null)
+                    return interruptWaiting;
+                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 interruptWaiting;
+                return interruptWaiting.pipe(Effect.andThen(toast.success(successMsg, toastId !== undefined ? { id: toastId, timeout: baseTimeout } : { timeout: baseTimeout })));
+            })));
+            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();
+        const registry = new FinalizationRegistry((arg) => {
+            MutableHashMap.remove(commands, arg);
+        });
+        return (_k) => {
+            const k = keyMaker ? keyMaker(_k) : _k;
+            // we want to compare structurally, unless custom equal/hash has been implemented
+            const item = MutableHashMap.get(commands, k).pipe(Option.flatMap((r) => Option.fromNullishOr(r.deref())));
+            if (item.value) {
+                return item.value;
+            }
+            const v = maker(k);
+            MutableHashMap.set(commands, k, new WeakRef(v));
+            registry.register(v, k);
+            return v;
+        };
+    }
+};
+const makeBaseInfo = (id, options) => {
+    if (!id)
+        throw new Error("must specify an id");
+    const i18nKey = options?.i18nCustomKey ?? id;
+    const namespace = `action.${i18nKey}`;
+    const context = {
+        id,
+        i18nKey,
+        namespace,
+        namespaced: (k) => `${namespace}.${k}`
+    };
+    return context;
+};
+const waitState = ref({});
+const registerWait = (id) => {
+    // console.debug("register wait", id)
+    waitState.value[id] = waitState.value[id] ? waitState.value[id] + 1 : 1;
+};
+const unregisterWait = (id) => {
+    // console.debug("unregister wait", id)
+    if (waitState.value[id]) {
+        waitState.value[id] = waitState.value[id] - 1;
+        if (waitState.value[id] <= 0) {
+            delete waitState.value[id];
+        }
+    }
+};
+const getStateValues = (options) => {
+    const state_ = options?.state;
+    const state = !state_ ? computed(() => undefined) : typeof state_ === "function"
+        ? computed(state_)
+        : state_;
+    return state;
+};
+// class preserves JSDoc throughout..
+export class CommanderImpl {
+    rt;
+    intl;
+    hooks;
+    constructor(rt, intl, hooks) {
+        this.rt = rt;
+        this.intl = intl;
+        this.hooks = hooks;
+    }
+    makeContext = (id, options) => {
+        if (!id)
+            throw new Error("must specify an id");
+        const i18nKey = options?.i18nCustomKey ?? id;
+        const namespace = `action.${i18nKey}`;
+        // must remain stable through out single call
+        const action = this.intl.formatMessage({
+            id: namespace,
+            defaultMessage: id
+        }, { ...options?.state, _isLabel: false });
+        const label = this.intl.formatMessage({
+            id: namespace,
+            defaultMessage: id
+        }, { ...options?.state, _isLabel: true });
+        const context = CommandContext.of({
+            ...makeBaseInfo(id, options),
+            action,
+            label,
+            state: options?.state
+        });
+        return context;
+    };
+    makeCommand = (id_, options, errorDef) => {
+        const id = typeof id_ === "string" ? id_ : id_.id;
+        const state = getStateValues(options);
+        return Object.assign((handler) => {
+            // we capture the definition stack here, so we can append it to later stack traces
+            const limit = Error.stackTraceLimit;
+            Error.stackTraceLimit = 2;
+            const localErrorDef = new Error();
+            Error.stackTraceLimit = limit;
+            if (!errorDef) {
+                errorDef = localErrorDef;
+            }
+            const key = `Commander.Command.${id}.state`;
+            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 errorReporter = (self) => self.pipe(Effect.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)) {
+                    // if (fail.value._tag === "SuppressErrors") {
+                    //   console.info(
+                    //     `Suppressed error trying to ${action}`,
+                    //     fail.value,
+                    //   )
+                    //   return
+                    // }
+                    const message = `Failure trying to ${id}`;
+                    yield* reportMessage(message, {
+                        action: id,
+                        error: fail.value
+                    });
+                    return;
+                }
+                const context = yield* CommandContext;
+                const extra = {
+                    action: context.action,
+                    message: `Unexpected Error trying to ${id}`
+                };
+                yield* reportRuntimeError(cause, extra);
+            }, Effect.uninterruptible)));
+            const currentState = Effect.sync(() => state.value);
+            const theHandler = flow(handler, errorReporter, 
+            // all must be within the Effect.fn to fit within the Span
+            Effect.provideServiceEffect(stateTag, currentState), Effect.provideServiceEffect(CommandContext, Effect.sync(() => makeContext_())));
+            const waitId = options?.waitKey ? options.waitKey(id) : undefined;
+            const blockId = options?.blockKey ? options.blockKey(id) : undefined;
+            const [result, exec_] = asResult(theHandler);
+            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 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;
+                const errorCall = new Error();
+                Error.stackTraceLimit = limit;
+                let cache = false;
+                const captureStackTrace = () => {
+                    // in case of an error, we want to append the definition stack to the call site stack,
+                    // so we can see where the handler was defined too
+                    if (cache !== false) {
+                        return cache;
+                    }
+                    if (errorCall.stack) {
+                        const stackDef = errorDef.stack.trim().split("\n");
+                        const stackCall = errorCall.stack.trim().split("\n");
+                        let endStackDef = stackDef.slice(2).join("\n").trim();
+                        if (!endStackDef.includes(`(`)) {
+                            endStackDef = endStackDef.replace(/at (.*)/, "at ($1)");
+                        }
+                        let endStackCall = stackCall.slice(2).join("\n").trim();
+                        if (!endStackCall.includes(`(`)) {
+                            endStackCall = endStackCall.replace(/at (.*)/, "at ($1)");
+                        }
+                        cache = `${endStackDef}\n${endStackCall}`;
+                        return cache;
+                    }
+                };
+                const command = currentState.pipe(Effect.flatMap((state) => {
+                    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({
+                /** static */
+                id,
+                /** the base i18n key, based on id by default. static */
+                i18nKey: initialContext.i18nKey,
+                /** the `action.` namespace based on i18nKey.. static */
+                namespace: initialContext.namespace,
+                /** easy generate namespaced 18n keys, based on namespace. static */
+                namespaced: initialContext.namespaced,
+                /** reactive */
+                result,
+                /** always undefined for non-stream commands */
+                progress: undefined,
+                /** reactive */
+                waiting,
+                /** reactive */
+                blocked,
+                /** reactive */
+                allowed,
+                /** reactive */
+                action,
+                /** reactive */
+                label,
+                /** reactive */
+                state,
+                handle
+            });
+        }, { id });
+    };
+    // /** @experimental */
+    // takeOver:
+    //   <Args extends any[], A, E, R, const Id extends string>(command: Commander.CommandOut<Args, A, E, R, Id,I18nKey>) =>
+    //   (...args: Args) => {
+    //     // we capture the call site stack here
+    //     const limit = Error.stackTraceLimit
+    //     Error.stackTraceLimit = 2
+    //     const errorCall = new Error()
+    //     const localErrorDef = new Error()
+    //     Error.stackTraceLimit = limit
+    //     // TODO
+    //     const errorDef = localErrorDef
+    //     let cache: false | string = false
+    //     const captureStackTrace = () => {
+    //       // in case of an error, we want to append the definition stack to the call site stack,
+    //       // so we can see where the handler was defined too
+    //       if (cache !== false) {
+    //         return cache
+    //       }
+    //       if (errorCall.stack) {
+    //         const stackDef = errorDef.stack!.trim().split("\n")
+    //         const stackCall = errorCall.stack.trim().split("\n")
+    //         let endStackDef = stackDef.slice(2).join("\n").trim()
+    //         if (!endStackDef.includes(`(`)) {
+    //           endStackDef = endStackDef.replace(/at (.*)/, "at ($1)")
+    //         }
+    //         let endStackCall = stackCall.slice(2).join("\n").trim()
+    //         if (!endStackCall.includes(`(`)) {
+    //           endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+    //         }
+    //         cache = `${endStackDef}\n${endStackCall}`
+    //         return cache
+    //       }
+    //     }
+    //     return Effect.gen(function*() {
+    //       const ctx = yield* CommandContext
+    //       ctx.action = command.action
+    //       return yield* command.exec(...args).pipe(
+    //         Effect.flatten,
+    //         Effect.withSpan(
+    //           command.action,
+    //           { captureStackTrace }
+    //         )
+    //       )
+    //     })
+    //   },
+    /**
+     * Define a Command for handling user actions with built-in error reporting and state management.
+     *
+     * @param id The internal identifier for the action. Used as a tracing span and to lookup
+     *                   the user-facing name via internationalization (`action.${id}`).
+     * @param options Optional configuration for internationalization and state.
+     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+     * @param options.state Optional reactive state object (or function returning one) that is
+     *                     made available to the command effects and can be used for i18n interpolation.
+     *                     The state is captured at the start of each command execution and remains stable throughout.
+     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+     *          Built-in error reporting handles failures automatically.
+     *
+     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+     * the user-facing action name.
+     *
+     * **Returned Properties**:
+     * - `action`: User-facing action name from intl messages (useful for button labels)
+     * - `result`: The command result state
+     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+     * - `handle`: Function to execute the command
+     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+     *
+     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+     * the `result` inline for custom UI feedback.
+     */
+    fn = (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);
+        const id = isObject ? _id.id : _id;
+        const baseInfo = makeBaseInfo(id, options);
+        const idCmd = this.makeCommand(id, options);
+        // TODO: implement proper tracing stack
+        return Object.assign((cb) => idCmd(cb(Object.assign((fn, ...combinators) => 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), baseInfo, isObject
+            ? { mutate: "mutate" in _id ? _id.mutate : typeof _id === "function" ? _id : undefined }
+            : {}))), baseInfo);
+    };
+    alt = this.makeCommand;
+    /**
+     * Define a Command for handling user actions with built-in error reporting and state management.
+     *
+     * @param mutation The mutation function to take the identifier and initial handler from. Used as a tracing span and to lookup
+     *                   the user-facing name via internationalization (`action.${id}`).
+     * @param options Optional configuration for internationalization and state.
+     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
+     * @param options.state Optional reactive state object (or function returning one) that is
+     *                     made available to the command effects and can be used for i18n interpolation.
+     *                     The state is captured at the start of each command execution and remains stable throughout.
+     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
+     *          Built-in error reporting handles failures automatically.
+     *
+     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
+     * the user-facing action name.
+     *
+     * **Returned Properties**:
+     * - `action`: User-facing action name from intl messages (useful for button labels)
+     * - `result`: The command result state
+     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
+     * - `handle`: Function to execute the command
+     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
+     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
+     *
+     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
+     * the `result` inline for custom UI feedback.
+     */
+    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", {
+    make: Effect.gen(function* () {
+        const i18n = yield* I18n;
+        return (rt, rtHooks) => new CommanderImpl(rt, i18n, rtHooks);
+    })
+}) {
+    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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"}