@barnum/barnum 0.3.0 → 0.4.0

package/dist/ast.js

@@ -1,182 +1,227 @@
+import { chain } from "./chain.js";
+import { constant, drop, extractPrefix, flatten as flattenBuiltin, getField, getIndex, identity, panic, pick, splitFirst, splitLast, tag, wrapInField, asOption as asOptionStandalone, } from "./builtins/index.js";
+import { Option } from "./option.js";
+import { Result } from "./result.js";
+// Lazy import — iterator.ts imports from ast.ts, but these are only called inside
+// methods (after all modules load), so the circular reference is safe at runtime.
+import { Iterator as IteratorNs } from "./iterator.js";
+// Lazy import — bind.ts imports from ast.ts, but these are only called inside
+// methods (after all modules load), so the circular reference is safe at runtime.
+import { bind as bindStandalone, bindInput as bindInputStandalone, } from "./bind.js";
+/**
+ * Strip phantom types from a Pipeable, returning a plain Action.
+ *
+ * Replaces `x as Action` casts throughout the codebase. The constraint
+ * ensures the argument is structurally a Pipeable — unlike a bare cast,
+ * `toAction(123)` is a type error.
+ */
+export function toAction(pipeable) {
+    return pipeable;
+}
 // ---------------------------------------------------------------------------
 // typedAction — attach .then() and .forEach() as non-enumerable methods
 // ---------------------------------------------------------------------------
 // Shared implementations (one closure, not per-instance)
 function thenMethod(next) {
-    return typedAction({ kind: "Chain", first: this, rest: next });
-}
-function forEachMethod(action) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: { kind: "ForEach", action },
-    });
+    return chain(this, next);
 }
 function branchMethod(cases) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: { kind: "Branch", cases: unwrapBranchCases(cases) },
-    });
+    return chain(toAction(this), toAction(branch(cases)));
 }
 function flattenMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Flatten" } },
-        },
-    });
+    return chain(toAction(this), toAction(flattenBuiltin()));
 }
 function dropMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Drop" } },
-        },
-    });
+    return chain(toAction(this), toAction(drop));
 }
-function tagMethod(kind) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Tag", value: kind } },
-        },
-    });
+function tagMethod(kind, enumName) {
+    return chain(toAction(this), toAction(tag(kind, enumName)));
 }
-function getMethod(field) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "ExtractField", value: field },
-            },
-        },
-    });
+function someMethod() {
+    return chain(toAction(this), toAction(Option.some()));
 }
-function augmentMethod() {
-    // Construct: All(this, identity) → Merge
-    // "this" is the sub-pipeline. augment() wraps it so the original input
-    // flows through identity alongside the sub-pipeline, then merges the results.
-    return typedAction({
-        kind: "Chain",
-        first: {
-            kind: "All",
-            actions: [
-                this,
-                {
-                    kind: "Invoke",
-                    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-                },
-            ],
-        },
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Merge" } },
-        },
-    });
+function okMethod() {
+    return chain(toAction(this), toAction(Result.ok()));
 }
-function mergeMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Merge" } },
-        },
-    });
+function errMethod() {
+    return chain(toAction(this), toAction(Result.err()));
+}
+function getFieldMethod(field) {
+    return chain(toAction(this), toAction(getField(field)));
+}
+function getIndexMethod(index) {
+    return chain(toAction(this), toAction(getIndex(index)));
+}
+function wrapInFieldMethod(field) {
+    return chain(toAction(this), toAction(wrapInField(field)));
 }
 function pickMethod(...keys) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Pick", value: keys } },
-        },
-    });
+    return chain(toAction(this), toAction(pick(...keys)));
 }
-function mapOptionMethod(action) {
-    // Desugars to: self.then(branch({ Some: pipe(action, tag("Some")), None: tag("None") }))
-    // But branch auto-unwraps value, so:
-    //   Some case: receives T, runs action, wraps as Some
-    //   None case: receives void, wraps as None
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Branch",
-            cases: unwrapBranchCases({
-                Some: {
-                    kind: "Chain",
-                    first: action,
-                    rest: {
-                        kind: "Invoke",
-                        handler: {
-                            kind: "Builtin",
-                            builtin: { kind: "Tag", value: "Some" },
-                        },
-                    },
-                },
-                None: {
-                    kind: "Invoke",
-                    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "None" } },
-                },
-            }),
-        },
-    });
+function splitFirstMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Iterator: IteratorNs.splitFirst(),
+        Array: splitFirst(),
+    })));
 }
-function mapErrMethod(action) {
-    // Desugars to: self.then(branch({ Ok: tag("Ok"), Err: pipe(action, tag("Err")) }))
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Branch",
-            cases: unwrapBranchCases({
-                Ok: {
-                    kind: "Invoke",
-                    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Ok" } },
-                },
-                Err: {
-                    kind: "Chain",
-                    first: action,
-                    rest: {
-                        kind: "Invoke",
-                        handler: {
-                            kind: "Builtin",
-                            builtin: { kind: "Tag", value: "Err" },
-                        },
-                    },
-                },
-            }),
-        },
-    });
+function splitLastMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Iterator: IteratorNs.splitLast(),
+        Array: splitLast(),
+    })));
+}
+// --- Shared postfix methods (Option + Result) — dispatch via branchFamily ---
+function mapMethod(action) {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({
+            Ok: chain(toAction(action), toAction(Result.ok())),
+            Err: Result.err(),
+        }),
+        Option: branch({
+            Some: chain(toAction(action), toAction(Option.some())),
+            None: Option.none(),
+        }),
+        Iterator: IteratorNs.map(action),
+    })));
+}
+function unwrapMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: identity(), Err: panic("called unwrap on Err") }),
+        Option: branch({
+            Some: identity(),
+            None: panic("called unwrap on None"),
+        }),
+    })));
 }
 function unwrapOrMethod(defaultAction) {
-    // Desugars to: self.then(branch({ Ok: identity(), Err: defaultAction }))
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Branch",
-            cases: unwrapBranchCases({
-                Ok: {
-                    kind: "Invoke",
-                    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-                },
-                Err: defaultAction,
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: identity(), Err: defaultAction }),
+        Option: branch({ Some: identity(), None: defaultAction }),
+    })));
+}
+function andThenMethod(action) {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: action, Err: Result.err() }),
+        Option: branch({ Some: action, None: Option.none() }),
+    })));
+}
+function transposeMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: branch({
+            Some: branch({
+                Ok: chain(toAction(Option.some()), toAction(Result.ok())),
+                Err: Result.err(),
             }),
-        },
-    });
+            None: chain(toAction(chain(toAction(drop), toAction(Option.none()))), toAction(Result.ok())),
+        }),
+        Result: branch({
+            Ok: branch({
+                Some: chain(toAction(Result.ok()), toAction(Option.some())),
+                None: chain(toAction(drop), toAction(Option.none())),
+            }),
+            Err: chain(toAction(Result.err()), toAction(Option.some())),
+        }),
+    })));
+}
+// --- Result-only postfix methods ---
+function mapErrMethod(action) {
+    return chain(toAction(this), toAction(branch({
+        Ok: Result.ok(),
+        Err: chain(toAction(action), toAction(Result.err())),
+    })));
+}
+function orMethod(fallback) {
+    return chain(toAction(this), toAction(branch({
+        Ok: Result.ok(),
+        Err: fallback,
+    })));
+}
+function asOkOptionMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: Option.some(),
+        Err: chain(toAction(drop), toAction(Option.none())),
+    })));
+}
+function asErrOptionMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: chain(toAction(drop), toAction(Option.none())),
+        Err: Option.some(),
+    })));
+}
+function isOkMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: constant(true),
+        Err: constant(false),
+    })));
+}
+function isErrMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: constant(false),
+        Err: constant(true),
+    })));
+}
+// --- Option-only postfix methods ---
+function filterMethod(predicate) {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: branch({
+            Some: predicate,
+            None: Option.none(),
+        }),
+        Iterator: IteratorNs.filter(predicate),
+    })));
+}
+function isSomeMethod() {
+    return chain(toAction(this), toAction(branch({
+        Some: constant(true),
+        None: constant(false),
+    })));
+}
+function isNoneMethod() {
+    return chain(toAction(this), toAction(branch({
+        Some: constant(false),
+        None: constant(true),
+    })));
+}
+function asOptionMethod() {
+    return chain(toAction(this), toAction(asOptionStandalone()));
+}
+// --- Iterator postfix methods ---
+function iterateMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: IteratorNs.fromOption(),
+        Result: IteratorNs.fromResult(),
+        Array: IteratorNs.fromArray(),
+    })));
+}
+function flatMapMethod(action) {
+    return chain(toAction(this), toAction(IteratorNs.flatMap(action)));
+}
+function collectMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Array: Option.collect(),
+        Iterator: IteratorNs.collect(),
+    })));
+}
+function foldMethod(init, body) {
+    return chain(toAction(this), toAction(IteratorNs.fold(init, body)));
+}
+function isEmptyMethod() {
+    return chain(toAction(this), toAction(IteratorNs.isEmpty()));
+}
+function sliceMethod(start, end) {
+    return chain(toAction(this), toAction(IteratorNs.slice(start, end)));
+}
+function takeMethod(n) {
+    return chain(toAction(this), toAction(IteratorNs.take(n)));
+}
+function skipMethod(n) {
+    return chain(toAction(this), toAction(IteratorNs.skip(n)));
+}
+function bindMethod(bindings, body) {
+    return chain(toAction(this), toAction(bindStandalone(bindings, body)));
+}
+function bindInputMethod(body) {
+    return chain(toAction(this), toAction(bindInputStandalone(body)));
 }
 /**
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
@@ -186,18 +231,44 @@ export function typedAction(action) {
     if (!("then" in action)) {
         Object.defineProperties(action, {
             then: { value: thenMethod, configurable: true },
-            forEach: { value: forEachMethod, configurable: true },
             branch: { value: branchMethod, configurable: true },
             flatten: { value: flattenMethod, configurable: true },
             drop: { value: dropMethod, configurable: true },
             tag: { value: tagMethod, configurable: true },
-            get: { value: getMethod, configurable: true },
-            augment: { value: augmentMethod, configurable: true },
-            merge: { value: mergeMethod, configurable: true },
+            some: { value: someMethod, configurable: true },
+            ok: { value: okMethod, configurable: true },
+            err: { value: errMethod, configurable: true },
+            getField: { value: getFieldMethod, configurable: true },
+            getIndex: { value: getIndexMethod, configurable: true },
+            wrapInField: { value: wrapInFieldMethod, configurable: true },
             pick: { value: pickMethod, configurable: true },
-            mapOption: { value: mapOptionMethod, configurable: true },
+            splitFirst: { value: splitFirstMethod, configurable: true },
+            splitLast: { value: splitLastMethod, configurable: true },
+            map: { value: mapMethod, configurable: true },
             mapErr: { value: mapErrMethod, configurable: true },
+            unwrap: { value: unwrapMethod, configurable: true },
             unwrapOr: { value: unwrapOrMethod, configurable: true },
+            andThen: { value: andThenMethod, configurable: true },
+            filter: { value: filterMethod, configurable: true },
+            isSome: { value: isSomeMethod, configurable: true },
+            isNone: { value: isNoneMethod, configurable: true },
+            asOption: { value: asOptionMethod, configurable: true },
+            collect: { value: collectMethod, configurable: true },
+            fold: { value: foldMethod, configurable: true },
+            isEmpty: { value: isEmptyMethod, configurable: true },
+            slice: { value: sliceMethod, configurable: true },
+            take: { value: takeMethod, configurable: true },
+            skip: { value: skipMethod, configurable: true },
+            or: { value: orMethod, configurable: true },
+            iterate: { value: iterateMethod, configurable: true },
+            flatMap: { value: flatMapMethod, configurable: true },
+            asOkOption: { value: asOkOptionMethod, configurable: true },
+            asErrOption: { value: asErrOptionMethod, configurable: true },
+            isOk: { value: isOkMethod, configurable: true },
+            isErr: { value: isErrMethod, configurable: true },
+            transpose: { value: transposeMethod, configurable: true },
+            bind: { value: bindMethod, configurable: true },
+            bindInput: { value: bindInputMethod, configurable: true },
         });
     }
     return action;
@@ -215,10 +286,10 @@ import { allocateRestartHandlerId, } from "./effect-id.js";
 export { tryCatch } from "./try-catch.js";
 export { race, sleep, withTimeout } from "./race.js";
 export function forEach(action) {
-    return typedAction({ kind: "ForEach", action: action });
+    return typedAction({ kind: "ForEach", action: toAction(action) });
 }
 /**
- * Insert ExtractField("value") before each case handler in a branch.
+ * Insert GetField("value") before each case handler in a branch.
  * This implements auto-unwrapping: the engine dispatches on `kind`, then
  * extracts `value` before passing to the handler. Case handlers receive
  * the payload directly, not the full `{ kind, value }` variant.
@@ -226,17 +297,7 @@ export function forEach(action) {
 function unwrapBranchCases(cases) {
     const unwrapped = {};
     for (const key of Object.keys(cases)) {
-        unwrapped[key] = {
-            kind: "Chain",
-            first: {
-                kind: "Invoke",
-                handler: {
-                    kind: "Builtin",
-                    builtin: { kind: "ExtractField", value: "value" },
-                },
-            },
-            rest: cases[key],
-        };
+        unwrapped[key] = toAction(chain(toAction(getField("value")), toAction(cases[key])));
     }
     return unwrapped;
 }
@@ -244,25 +305,21 @@ function unwrapBranchCases(cases) {
 export function branch(cases) {
     return typedAction({ kind: "Branch", cases: unwrapBranchCases(cases) });
 }
-// ---------------------------------------------------------------------------
-// Shared AST constants for control flow compilation
-// ---------------------------------------------------------------------------
-const EXTRACT_PAYLOAD = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "ExtractIndex", value: 0 } },
-};
-const TAG_CONTINUE = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Continue" } },
-};
-export const TAG_BREAK = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Break" } },
-};
-export const IDENTITY = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-};
+/**
+ * Two-level dispatch: extract the enum prefix from a tagged value's `kind`,
+ * then branch on that prefix. Used by postfix methods (`.map()`, `.unwrapOr()`,
+ * etc.) to dispatch across union families (Option, Result) without runtime
+ * metadata.
+ *
+ * `branchFamily({ Result: ..., Option: ... })` ≡ `chain(extractPrefix(), branch(cases))`
+ */
+export function branchFamily(cases) {
+    return typedAction({
+        kind: "Chain",
+        first: toAction(extractPrefix()),
+        rest: toAction(branch(cases)),
+    });
+}
 // ---------------------------------------------------------------------------
 // recur — restart body primitive
 // ---------------------------------------------------------------------------
@@ -273,7 +330,7 @@ export const IDENTITY = {
  * If the body completes normally → output is TOut.
  * If restart fires → body re-executes with the restarted value.
  *
- * Compiled form: `RestartHandle(id, ExtractIndex(0), body)`
+ * Compiled form: `RestartHandle(id, GetIndex(0), body)`
  */
 export function recur(bodyFn) {
     const restartHandlerId = allocateRestartHandlerId();
@@ -281,12 +338,12 @@ export function recur(bodyFn) {
         kind: "RestartPerform",
         restart_handler_id: restartHandlerId,
     });
-    const body = bodyFn(restartAction);
+    const body = toAction(bodyFn(restartAction));
     return typedAction({
         kind: "RestartHandle",
         restart_handler_id: restartHandlerId,
         body,
-        handler: EXTRACT_PAYLOAD,
+        handler: toAction(getIndex(0).unwrap()),
     });
 }
 // ---------------------------------------------------------------------------
@@ -306,20 +363,19 @@ export function recur(bodyFn) {
  */
 export function earlyReturn(bodyFn) {
     const restartHandlerId = allocateRestartHandlerId();
-    const earlyReturnAction = typedAction({
-        kind: "Chain",
-        first: TAG_BREAK,
-        rest: { kind: "RestartPerform", restart_handler_id: restartHandlerId },
-    });
-    const body = bodyFn(earlyReturnAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, IDENTITY));
+    const earlyReturnAction = typedAction(toAction(chain(toAction(tag("Break", "LoopResult")), {
+        kind: "RestartPerform",
+        restart_handler_id: restartHandlerId,
+    })));
+    const body = toAction(bodyFn(earlyReturnAction));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, toAction(identity())));
 }
 // ---------------------------------------------------------------------------
 // loop — iterative restart with break
 // ---------------------------------------------------------------------------
 /**
  * Build the restart+branch compiled form:
- * `Chain(Tag("Continue"), RestartHandle(id, ExtractIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
+ * `Chain(Tag("Continue"), RestartHandle(id, GetIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
  *
  * Input is tagged Continue so the Branch enters the continueArm on first execution.
  * Continue tag → restart → re-enters continueArm. Break tag → restart → runs breakArm, exits `RestartHandle`.
@@ -327,22 +383,12 @@ export function earlyReturn(bodyFn) {
  * Used by earlyReturn, loop, tryCatch, and race.
  */
 export function buildRestartBranchAction(restartHandlerId, continueArm, breakArm) {
-    return {
-        kind: "Chain",
-        first: TAG_CONTINUE,
-        rest: {
-            kind: "RestartHandle",
-            restart_handler_id: restartHandlerId,
-            body: {
-                kind: "Branch",
-                cases: unwrapBranchCases({
-                    Continue: continueArm,
-                    Break: breakArm,
-                }),
-            },
-            handler: EXTRACT_PAYLOAD,
-        },
-    };
+    return toAction(chain(toAction(tag("Continue", "LoopResult")), {
+        kind: "RestartHandle",
+        restart_handler_id: restartHandlerId,
+        body: toAction(branch({ Continue: continueArm, Break: breakArm })),
+        handler: toAction(getIndex(0).unwrap()),
+    }));
 }
 /**
  * Iterative loop. The body callback receives `recur` and `done`:
@@ -359,18 +405,10 @@ export function loop(bodyFn) {
         kind: "RestartPerform",
         restart_handler_id: restartHandlerId,
     };
-    const recurAction = typedAction({
-        kind: "Chain",
-        first: TAG_CONTINUE,
-        rest: perform,
-    });
-    const doneAction = typedAction({
-        kind: "Chain",
-        first: TAG_BREAK,
-        rest: perform,
-    });
-    const body = bodyFn(recurAction, doneAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, IDENTITY));
+    const recurAction = typedAction(toAction(chain(toAction(tag("Continue", "LoopResult")), toAction(perform))));
+    const doneAction = typedAction(toAction(chain(toAction(tag("Break", "LoopResult")), toAction(perform))));
+    const body = toAction(bodyFn(recurAction, doneAction));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, toAction(identity())));
 }
 // ---------------------------------------------------------------------------
 // Config builders

package/dist/bind.d.ts

@@ -3,20 +3,17 @@ import { type Action, type ExtractInput, type ExtractOutput, type TypedAction }
  * A typed reference to a bound value. Output is `TValue`.
  *
  * Use `.then()` (not `pipe()`) when chaining a VarRef into a generic
- * action like `pick` or `extractField` — pipe overloads can't infer
+ * action like `pick` or `getField` — pipe overloads can't infer
  * the generic's type parameter from the VarRef's output.
  */
-export type VarRef<TValue> = TypedAction<never, TValue>;
+export type VarRef<TValue> = TypedAction<any, TValue>;
 /**
  * Maps each binding's output type to a VarRef. TypeScript resolves
  * ExtractOutput from each binding expression.
  *
- * Constraint is `Action[]` (not `Pipeable<any, any>[]`) because
- * `TypedAction<never, X>` (e.g. from `constant()`) fails the invariant
- * `__in` check against `Pipeable<any, any>` on the 9-variant
- * Action union. Using raw `Action[]` avoids the phantom field
- * assignability issue while `ExtractOutput` still extracts the correct
- * output type from the phantom fields on the concrete types.
+ * Constraint is `Action[]` (not `Pipeable<any, any>[]`) so that
+ * `ExtractOutput` extracts the correct output type from the phantom
+ * fields on the concrete types without fighting invariant `__in` checks.
  */
 export type InferVarRefs<TBindings extends Action[]> = {
     [K in keyof TBindings]: VarRef<ExtractOutput<TBindings[K]>>;
@@ -33,19 +30,18 @@ export type InferVarRefs<TBindings extends Action[]> = {
  *     All(...bindings, Identity),
  *     ResumeHandle(r0, readVar(0),
  *       ResumeHandle(r1, readVar(1),
- *         Chain(ExtractIndex(N), body)
+ *         Chain(GetIndex(N), body)
  *       )
  *     )
  *   )
  */
 /**
  * Constraint for the body callback return type. Only requires the output
- * phantom fields — omits `__in` and `__in_co` so that body actions with
- * `In = never` (e.g. pipelines starting from a VarRef) are assignable.
+ * phantom field — omits `__in` and `__in_co` so that body actions with
+ * any input type (e.g. pipelines starting from a VarRef) are assignable.
  */
 type BodyResult<TOut> = Action & {
     __out?: () => TOut;
-    __out_contra?: (output: TOut) => void;
 };
 export declare function bind<TBindings extends Action[], TOut>(bindings: [...TBindings], body: (vars: InferVarRefs<TBindings>) => BodyResult<TOut>): TypedAction<ExtractInput<TBindings[number]>, TOut>;
 /**
@@ -60,3 +56,4 @@ export declare function bind<TBindings extends Action[], TOut>(bindings: [...TBi
  */
 export declare function bindInput<TIn, TOut = any>(body: (input: VarRef<TIn>) => BodyResult<TOut>): TypedAction<TIn, TOut>;
 export {};
+//# sourceMappingURL=bind.d.ts.map

package/dist/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../src/bind.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAGjB,MAAM,UAAU,CAAC;AAWlB;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,IAAI,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAetD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI;KACpD,CAAC,IAAI,MAAM,SAAS,GAAG,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5D,CAAC;AA4BF;;;;;;;;;;;;;;;;GAgBG;AACH;;;;GAIG;AACH,KAAK,UAAU,CAAC,IAAI,IAAI,MAAM,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,wBAAgB,IAAI,CAAC,SAAS,SAAS,MAAM,EAAE,EAAE,IAAI,EACnD,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,EACxB,IAAI,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,GACxD,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAkCpD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EACvC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,GAC7C,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAExB"}