@effect-app/vue 2.52.5 → 2.52.7

package/src/experimental/commander.ts

@@ -8,7 +8,7 @@ import { OperationFailure, OperationSuccess } from "effect-app/Operations"
 import { type RuntimeFiber } from "effect/Fiber"
 import { type NoInfer } from "effect/Types"
 import { type YieldWrap } from "effect/Utils"
-import { computed, type ComputedRef } from "vue"
+import { computed, reactive } from "vue"
 import { ConfirmSvc } from "./confirm.js"
 import { IntlSvc } from "./intl.js"
 import { WithToastSvc } from "./withToast.js"
@@ -40,16 +40,334 @@ export const DefaultIntl = {
   }
 }
 
+/**
+ * Use on form submit @handler callbacks, to handle form submitting state.
+ */
+const handleSubmit = <Arg>(
+  command: (arg: Arg) => RuntimeFiber<any, any>
+) =>
+(arg: Arg, resolve: () => void) => {
+  return command(arg).addObserver(resolve)
+}
+
 export class CommandContext extends Context.Tag("CommandContext")<
   CommandContext,
   { action: string }
 >() {}
 
-export interface CommandProps<A, E> {
-  action: string
-  result: Result<A, E>
-  waiting: boolean
+export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void
+
+/**
+ * Use to wrap emit calls with a callback to signal completion.
+ * Useful when the publisher wants to wait for the subscriber to finish processing.
+ */
+export const wrapEmit = <A, Event extends string>(
+  emit: EmitWithCallback<A, NoInfer<Event>>,
+  event: Event
+) =>
+(value: A) => new Promise<void>((resolve) => emit(event, value, resolve))
+
+/**
+ * Shorthand of @see wrapEmit to wrap emit calls for OmegaForm form submission callback
+ */
+export const wrapEmitSubmit = <A>(
+  emit: EmitWithCallback<A, "submit">
+) => {
+  const submit = wrapEmit(emit, "submit")
+  return ({ value }: { value: A }) => submit(value)
 }
+
+export declare namespace Commander {
+  export interface CommandProps<A, E> {
+    action: string
+    result: Result<A, E>
+    waiting: boolean
+  }
+
+  export interface UnaryCommandOut<Arg, A, E> extends CommandProps<A, E> {
+    handle: (a: Arg) => RuntimeFiber<Exit.Exit<A, E>, never>
+    /* for forms, only use with unary functions */
+    handleSubmit: (a: Arg, resolve: () => Exit.Exit<A, E>) => void
+  }
+
+  export interface OtherCommandOut<Args extends Array<any>, A, E> extends CommandProps<A, E> {
+    handle: (...args: Args) => RuntimeFiber<Exit.Exit<A, E>, never>
+  }
+
+  export type CommandOut<Args extends Array<any>, A, E> = Args extends [infer _A] ? UnaryCommandOut<_A, A, E>
+    : OtherCommandOut<Args, A, E>
+
+  type CommandOutHelper<Args extends Array<any>, Eff extends Effect.Effect<any, any, any>> = CommandOut<
+    Args,
+    Effect.Effect.Success<Eff>,
+    Effect.Effect.Error<Eff>
+  >
+
+  export type Gen<RT> = {
+    <Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext>>, AEff, Args extends Array<any>>(
+      body: (...args: Args) => Generator<Eff, AEff, never>
+    ): CommandOut<
+      Args,
+      AEff,
+      [Eff] extends [never] ? never
+        : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+        : never
+    >
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A
+    ): CommandOutHelper<Args, A>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B
+    ): CommandOutHelper<Args, B>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C
+    ): CommandOutHelper<Args, C>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D
+    ): CommandOutHelper<Args, D>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D,
+      E extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E
+    ): CommandOutHelper<Args, E>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F
+    ): CommandOutHelper<Args, F>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G
+    ): CommandOutHelper<Args, G>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H
+    ): CommandOutHelper<Args, H>
+    <
+      Eff extends YieldWrap<Effect.Effect<any, any, any>>,
+      AEff,
+      Args extends Array<any>,
+      A,
+      B,
+      C,
+      D,
+      E,
+      F,
+      G,
+      H,
+      I extends Effect.Effect<any, any, RT | CommandContext>
+    >(
+      body: (...args: Args) => Generator<Eff, AEff, never>,
+      a: (
+        _: Effect.Effect<
+          AEff,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
+            : never,
+          [Eff] extends [never] ? never
+            : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
+            : never
+        >,
+        ...args: NoInfer<Args>
+      ) => A,
+      b: (_: A, ...args: NoInfer<Args>) => B,
+      c: (_: B, ...args: NoInfer<Args>) => C,
+      d: (_: C, ...args: NoInfer<Args>) => D,
+      e: (_: D, ...args: NoInfer<Args>) => E,
+      f: (_: E, ...args: NoInfer<Args>) => F,
+      g: (_: F, ...args: NoInfer<Args>) => G,
+      h: (_: G, ...args: NoInfer<Args>) => H,
+      i: (_: H, ...args: NoInfer<Args>) => I
+    ): CommandOutHelper<Args, I>
+  }
+}
+
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class Commander extends Effect.Service<Commander>()("Commander", {
   dependencies: [WithToastSvc.Default, ConfirmSvc.Default],
@@ -58,284 +376,6 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
     const withToast = yield* WithToastSvc
     const { confirmOrInterrupt } = yield* ConfirmSvc
 
-    type CommandOut<Args extends Array<any>, A, E> = ComputedRef<
-      ((...a: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
-        action: string
-        result: Result<A, E>
-        waiting: boolean
-      }
-    >
-
-    type CommandOutHelper<Args extends Array<any>, Eff extends Effect.Effect<any, any, any>> = CommandOut<
-      Args,
-      Effect.Effect.Success<Eff>,
-      Effect.Effect.Error<Eff>
-    >
-
-    type Gen<RT> = {
-      <Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext>>, AEff, Args extends Array<any>>(
-        body: (...args: Args) => Generator<Eff, AEff, never>
-      ): CommandOut<
-        Args,
-        AEff,
-        [Eff] extends [never] ? never
-          : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-          : never
-      >
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A
-      ): CommandOutHelper<Args, A>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B
-      ): CommandOutHelper<Args, B>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C
-      ): CommandOutHelper<Args, C>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D
-      ): CommandOutHelper<Args, D>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D,
-        E extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D,
-        e: (_: D, ...args: NoInfer<Args>) => E
-      ): CommandOutHelper<Args, E>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D,
-        E,
-        F extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D,
-        e: (_: D, ...args: NoInfer<Args>) => E,
-        f: (_: E, ...args: NoInfer<Args>) => F
-      ): CommandOutHelper<Args, F>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D,
-        E,
-        F,
-        G extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D,
-        e: (_: D, ...args: NoInfer<Args>) => E,
-        f: (_: E, ...args: NoInfer<Args>) => F,
-        g: (_: F, ...args: NoInfer<Args>) => G
-      ): CommandOutHelper<Args, G>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D,
-        E,
-        F,
-        G,
-        H extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D,
-        e: (_: D, ...args: NoInfer<Args>) => E,
-        f: (_: E, ...args: NoInfer<Args>) => F,
-        g: (_: F, ...args: NoInfer<Args>) => G,
-        h: (_: G, ...args: NoInfer<Args>) => H
-      ): CommandOutHelper<Args, H>
-      <
-        Eff extends YieldWrap<Effect.Effect<any, any, any>>,
-        AEff,
-        Args extends Array<any>,
-        A,
-        B,
-        C,
-        D,
-        E,
-        F,
-        G,
-        H,
-        I extends Effect.Effect<any, any, RT | CommandContext>
-      >(
-        body: (...args: Args) => Generator<Eff, AEff, never>,
-        a: (
-          _: Effect.Effect<
-            AEff,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-              : never,
-            [Eff] extends [never] ? never
-              : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-              : never
-          >,
-          ...args: NoInfer<Args>
-        ) => A,
-        b: (_: A, ...args: NoInfer<Args>) => B,
-        c: (_: B, ...args: NoInfer<Args>) => C,
-        d: (_: C, ...args: NoInfer<Args>) => D,
-        e: (_: D, ...args: NoInfer<Args>) => E,
-        f: (_: E, ...args: NoInfer<Args>) => F,
-        g: (_: F, ...args: NoInfer<Args>) => G,
-        h: (_: G, ...args: NoInfer<Args>) => H,
-        i: (_: H, ...args: NoInfer<Args>) => I
-      ): CommandOutHelper<Args, I>
-    }
-
     const makeCommand =
       <RT>(runtime: Runtime.Runtime<RT>) =>
       (actionName: string, errorDef?: Error) =>
@@ -400,43 +440,55 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
 
         const [result, mut] = asResult(theHandler)
 
-        return computed(() =>
-          Object.assign(
-            (...args: Args) => {
-              const limit = Error.stackTraceLimit
-              Error.stackTraceLimit = 2
-              const errorCall = new Error()
-              Error.stackTraceLimit = limit
+        const waiting = computed(() => result.value.waiting)
 
-              let cache: false | string = 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 = Object.assign((...args: Args) => {
+          const limit = Error.stackTraceLimit
+          Error.stackTraceLimit = 2
+          const errorCall = new Error()
+          Error.stackTraceLimit = limit
+
+          let cache: false | string = 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)")
               }
-              return Runtime.runFork(runtime)(Effect.withSpan(mut(...args), actionName, { captureStackTrace }))
-            }, /* make sure always create a new one, or the state won't properly propagate */
-            {
-              action,
-              result: result.value,
-              waiting: result.value.waiting
-            } as CommandProps<A, E>
-          )
-        )
+              let endStackCall = stackCall.slice(2).join("\n").trim()
+              if (!endStackCall.includes(`(`)) {
+                endStackCall = endStackCall.replace(/at (.*)/, "at ($1)")
+              }
+              cache = `${endStackDef}\n${endStackCall}`
+              return cache
+            }
+          }
+          return Runtime.runFork(runtime)(Effect.withSpan(mut(...args), actionName, { captureStackTrace }))
+        }, /* make sure always create a new one, or the state won't properly propagate */ { action })
+
+        Object.defineProperty(command, "result", {
+          get() {
+            return result.value
+          }
+        })
+        Object.defineProperty(command, "waiting", {
+          get() {
+            return waiting.value
+          }
+        })
+
+        return reactive({
+          result,
+          waiting,
+          action,
+          handle: command,
+          handleSubmit: handleSubmit(command as any)
+        })
       }
 
     return {
@@ -541,7 +593,7 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
        */
       fn: <RT>(runtime: Runtime.Runtime<RT>) => {
         const make = makeCommand(runtime)
-        return (actionName: string): Gen<RT> =>
+        return (actionName: string): Commander.Gen<RT> =>
         // TODO constrain/type combinators
         (
           fn: any,
@@ -559,9 +611,9 @@ export class Commander extends Effect.Service<Commander>()("Commander", {
 
       alt: makeCommand as <RT>(runtime: Runtime.Runtime<RT>) => (
         actionName: string
-      ) => <Args extends ReadonlyArray<any>, A, E, R extends RT | CommandContext>(
+      ) => <Args extends Array<any>, A, E, R extends RT | CommandContext>(
         handler: (...args: Args) => Effect.Effect<A, E, R>
-      ) => ComputedRef<((...a: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & CommandProps<A, E>>
+      ) => Commander.CommandOut<Args, A, E>
     }
   })
 }) {}