@barnum/barnum 0.0.0-main-18fb14ce → 0.0.0-main-a589e69d

package/dist/all.d.ts

@@ -1,12 +1,42 @@
 import { type Pipeable, type TypedAction } from "./ast.js";
 export declare function all(): TypedAction<any, []>;
-export declare function all<In, O1>(a1: Pipeable<In, O1>): TypedAction<In, [O1]>;
-export declare function all<In, O1, O2>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>): TypedAction<In, [O1, O2]>;
-export declare function all<In, O1, O2, O3>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>): TypedAction<In, [O1, O2, O3]>;
-export declare function all<In, O1, O2, O3, O4>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>): TypedAction<In, [O1, O2, O3, O4]>;
-export declare function all<In, O1, O2, O3, O4, O5>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>): TypedAction<In, [O1, O2, O3, O4, O5]>;
-export declare function all<In, O1, O2, O3, O4, O5, O6>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>, a6: Pipeable<In, O6>): TypedAction<In, [O1, O2, O3, O4, O5, O6]>;
-export declare function all<In, O1, O2, O3, O4, O5, O6, O7>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>, a6: Pipeable<In, O6>, a7: Pipeable<In, O7>): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7]>;
-export declare function all<In, O1, O2, O3, O4, O5, O6, O7, O8>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>, a6: Pipeable<In, O6>, a7: Pipeable<In, O7>, a8: Pipeable<In, O8>): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8]>;
-export declare function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>, a6: Pipeable<In, O6>, a7: Pipeable<In, O7>, a8: Pipeable<In, O8>, a9: Pipeable<In, O9>): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9]>;
-export declare function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10>(a1: Pipeable<In, O1>, a2: Pipeable<In, O2>, a3: Pipeable<In, O3>, a4: Pipeable<In, O4>, a5: Pipeable<In, O5>, a6: Pipeable<In, O6>, a7: Pipeable<In, O7>, a8: Pipeable<In, O8>, a9: Pipeable<In, O9>, a10: Pipeable<In, O10>): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9, O10]>;
+export declare function all<TInput, TOut1>(a1: Pipeable<TInput, TOut1>): TypedAction<TInput, [TOut1]>;
+export declare function all<TInput, TOut1, TOut2>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>): TypedAction<TInput, [TOut1, TOut2]>;
+export declare function all<TInput, TOut1, TOut2, TOut3>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>): TypedAction<TInput, [TOut1, TOut2, TOut3]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>): TypedAction<TInput, [TOut1, TOut2, TOut3, TOut4]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>): TypedAction<TInput, [TOut1, TOut2, TOut3, TOut4, TOut5]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>, a6: Pipeable<TInput, TOut6>): TypedAction<TInput, [TOut1, TOut2, TOut3, TOut4, TOut5, TOut6]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6, TOut7>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>, a6: Pipeable<TInput, TOut6>, a7: Pipeable<TInput, TOut7>): TypedAction<TInput, [TOut1, TOut2, TOut3, TOut4, TOut5, TOut6, TOut7]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6, TOut7, TOut8>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>, a6: Pipeable<TInput, TOut6>, a7: Pipeable<TInput, TOut7>, a8: Pipeable<TInput, TOut8>): TypedAction<TInput, [
+    TOut1,
+    TOut2,
+    TOut3,
+    TOut4,
+    TOut5,
+    TOut6,
+    TOut7,
+    TOut8
+]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6, TOut7, TOut8, TOut9>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>, a6: Pipeable<TInput, TOut6>, a7: Pipeable<TInput, TOut7>, a8: Pipeable<TInput, TOut8>, a9: Pipeable<TInput, TOut9>): TypedAction<TInput, [
+    TOut1,
+    TOut2,
+    TOut3,
+    TOut4,
+    TOut5,
+    TOut6,
+    TOut7,
+    TOut8,
+    TOut9
+]>;
+export declare function all<TInput, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6, TOut7, TOut8, TOut9, TOut10>(a1: Pipeable<TInput, TOut1>, a2: Pipeable<TInput, TOut2>, a3: Pipeable<TInput, TOut3>, a4: Pipeable<TInput, TOut4>, a5: Pipeable<TInput, TOut5>, a6: Pipeable<TInput, TOut6>, a7: Pipeable<TInput, TOut7>, a8: Pipeable<TInput, TOut8>, a9: Pipeable<TInput, TOut9>, a10: Pipeable<TInput, TOut10>): TypedAction<TInput, [
+    TOut1,
+    TOut2,
+    TOut3,
+    TOut4,
+    TOut5,
+    TOut6,
+    TOut7,
+    TOut8,
+    TOut9,
+    TOut10
+]>;

package/dist/ast.d.ts

@@ -1,4 +1,5 @@
 import type { JSONSchema7 } from "json-schema";
+import { type VarRef, type InferVarRefs } from "./bind.js";
 export type Action = InvokeAction | ChainAction | ForEachAction | AllAction | BranchAction | ResumeHandleAction | ResumePerformAction | RestartHandleAction | RestartPerformAction;
 export interface InvokeAction {
     kind: "Invoke";
@@ -60,22 +61,16 @@ export type BuiltinKind = {
     kind: "Identity";
 } | {
     kind: "Drop";
-} | {
-    kind: "Tag";
-    value: string;
 } | {
     kind: "Merge";
 } | {
     kind: "Flatten";
 } | {
     kind: "GetField";
-    value: string;
+    field: string;
 } | {
     kind: "GetIndex";
-    value: number;
-} | {
-    kind: "Pick";
-    value: string[];
+    index: number;
 } | {
     kind: "CollectSome";
 } | {
@@ -84,16 +79,20 @@ export type BuiltinKind = {
     kind: "SplitLast";
 } | {
     kind: "WrapInField";
-    value: string;
+    field: string;
 } | {
     kind: "Sleep";
-    value: number;
+    ms: number;
+} | {
+    kind: "Panic";
+    message: string;
 };
 /**
- * When TIn is `never` (handler ignores input), produce `any` so the
- * combinator/pipe can sit in any pipeline position.
+ * When T is `never` or `void` (handler ignores input / recur doesn't
+ * thread state), produce `any` so the combinator can sit in any
+ * pipeline position.
  */
-export type PipeIn<T> = [T] extends [never] ? any : T;
+export type PipeIn<T> = [T] extends [never] ? any : [T] extends [void] ? any : T;
 export interface Config {
     workflow: Action;
 }
@@ -101,96 +100,168 @@ type UnionToIntersection<TUnion> = (TUnion extends any ? (x: TUnion) => void : n
 /** Merge a tuple of objects into a single intersection type. */
 export type MergeTuple<TTuple> = TTuple extends unknown[] ? UnionToIntersection<TTuple[number]> : never;
 /**
- * An action with tracked input/output types. Phantom fields enforce invariance
+ * Runtime dispatch table for union postfix methods. Each method is optional —
+ * Option and Result provide different subsets. TypedAction type signatures
+ * gate availability at compile time; this table handles runtime dispatch.
+ */
+export interface UnionMethods {
+    map?: (action: Action) => Action;
+    andThen?: (action: Action) => Action;
+    unwrap?: () => Action;
+    unwrapOr?: (action: Action) => Action;
+    flatten?: () => Action;
+    filter?: (predicate: Action) => Action;
+    collect?: () => Action;
+    isSome?: () => Action;
+    isNone?: () => Action;
+    mapErr?: (action: Action) => Action;
+    and?: (other: Action) => Action;
+    or?: (fallback: Action) => Action;
+    toOption?: () => Action;
+    toOptionErr?: () => Action;
+    transpose?: () => Action;
+    isOk?: () => Action;
+    isErr?: () => Action;
+}
+/**
+ * Runtime dispatch info attached to every TypedAction. Non-null when the
+ * output is a union type (Option, Result). `name` identifies the type for
+ * error messages; `methods` is the dispatch table.
+ */
+export interface UnionDispatch {
+    name: string;
+    methods: UnionMethods;
+}
+/**
+ * Attach a union dispatch table to a TypedAction. Used by constructors
+ * and family-preserving combinators so postfix methods can dispatch
+ * to the correct implementation.
+ */
+export declare function withUnion<In, Out>(action: TypedAction<In, Out>, name: string, methods: UnionMethods): TypedAction<In, Out>;
+/**
+ * An action with tracked input/output types. Phantom fields enforce variance
  * and are never set at runtime — they exist only for the TypeScript compiler.
  *
- * Each type variable gets a contravariant + covariant field pair:
  *   In:  __in (contravariant) + __in_co (covariant) → invariant
- *   Out: __out (covariant) + __out_contra (contravariant) → invariant
+ *   Out: __out (covariant only)
  *
- * This ensures exact type matching at every pipeline connection point.
+ * Input invariance ensures exact type matching at pipeline connection points.
  * Data crosses serialization boundaries to handlers in arbitrary languages
  * (Rust, Python, etc.), so extra/missing fields are runtime errors.
+ *
+ * Output covariance is safe — a step producing Dog where Animal is expected
+ * downstream works. `never` (throwError, recur, done) is assignable to any
+ * output slot via standard subtyping.
  */
-export type TypedAction<In = unknown, Out = unknown, Refs extends string = never> = Action & {
+export type TypedAction<In = unknown, Out = unknown> = Action & {
     __in?: (input: In) => void;
     __in_co?: In;
     __out?: () => Out;
-    __out_contra?: (output: Out) => void;
-    __refs?: {
-        _brand: Refs;
-    };
+    /** Runtime dispatch info for union postfix methods (Option/Result). Null for non-union outputs. */
+    __union: UnionDispatch | null;
     /** Chain this action with another. `a.then(b)` ≡ `chain(a, b)`. */
-    then<TNext>(next: Pipeable<Out, TNext>): TypedAction<In, TNext, Refs>;
+    then<TNext>(next: Pipeable<Out, TNext>): TypedAction<In, TNext>;
     /** Apply an action to each element of an array output. `a.forEach(b)` ≡ `a.then(forEach(b))`. */
-    forEach<TIn, TElement, TNext, TRefs extends string>(this: TypedAction<TIn, TElement[], TRefs>, action: Pipeable<TElement, TNext>): TypedAction<TIn, TNext[], TRefs>;
+    forEach<TIn, TElement, TNext>(this: TypedAction<TIn, TElement[]>, action: Pipeable<TElement, TNext>): TypedAction<TIn, TNext[]>;
     /** Dispatch on a tagged union output. Auto-unwraps `value` before each case handler. */
     branch<TCases extends {
         [K in BranchKeys<Out>]: CaseHandler<BranchPayload<Out, K>, unknown>;
-    }>(cases: [BranchKeys<Out>] extends [never] ? never : TCases): TypedAction<In, ExtractOutput<TCases[keyof TCases & string]>, Refs>;
-    /** Flatten a nested array output. `a.flatten()` ≡ `pipe(a, flatten())`. */
-    flatten(): TypedAction<In, Out extends (infer TElement)[][] ? TElement[] : Out, Refs>;
+    }>(cases: [BranchKeys<Out>] extends [never] ? never : TCases): TypedAction<In, ExtractOutput<TCases[keyof TCases & string]>>;
+    /** Flatten one level of nesting. Dispatches: Array, Option, Result. */
+    flatten<TIn, TElement>(this: TypedAction<TIn, TElement[][]>): TypedAction<TIn, TElement[]>;
+    flatten<TIn, TValue>(this: TypedAction<TIn, Option<Option<TValue>>>): TypedAction<TIn, Option<TValue>>;
+    flatten<TIn, TValue, TError>(this: TypedAction<TIn, Result<Result<TValue, TError>, TError>>): TypedAction<TIn, Result<TValue, TError>>;
+    flatten(): TypedAction<In, unknown>;
     /** Discard output. `a.drop()` ≡ `pipe(a, drop)`. */
-    drop(): TypedAction<In, never, Refs>;
+    drop(): TypedAction<In, void>;
     /** Wrap output as a tagged union member. Requires full variant map TDef so __def is carried. */
-    tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind): TypedAction<In, TaggedUnion<TDef>, Refs>;
+    tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind): TypedAction<In, TaggedUnion<TDef>>;
     /** Extract a field from the output object. `a.getField("name")` ≡ `pipe(a, getField("name"))`. */
-    getField<TField extends keyof Out & string>(field: TField): TypedAction<In, Out[TField], Refs>;
+    getField<TField extends keyof Out & string>(field: TField): TypedAction<In, Out[TField]>;
     /** Extract an element from the output tuple by index. `a.getIndex(0)` ≡ `pipe(a, getIndex(0))`. */
-    getIndex<TIn, TTuple extends unknown[], TIndex extends number, TRefs extends string>(this: TypedAction<TIn, TTuple, TRefs>, index: TIndex): TypedAction<TIn, TTuple[TIndex], TRefs>;
+    getIndex<TIn, TTuple extends unknown[], TIndex extends number>(this: TypedAction<TIn, TTuple>, index: TIndex): TypedAction<TIn, TTuple[TIndex]>;
     /** Wrap output in an object under a field name. `a.wrapInField("foo")` ≡ `pipe(a, wrapInField("foo"))`. */
-    wrapInField<TField extends string>(field: TField): TypedAction<In, Record<TField, Out>, Refs>;
+    wrapInField<TField extends string>(field: TField): TypedAction<In, Record<TField, Out>>;
     /** Merge a tuple of objects into a single object. `a.merge()` ≡ `pipe(a, merge())`. */
-    merge(): TypedAction<In, MergeTuple<Out>, Refs>;
+    merge(): TypedAction<In, MergeTuple<Out>>;
     /** Select fields from the output. `a.pick("x", "y")` ≡ `pipe(a, pick("x", "y"))`. */
-    pick<TKeys extends (keyof Out & string)[]>(...keys: TKeys): TypedAction<In, Pick<Out, TKeys[number]>, Refs>;
+    pick<TKeys extends (keyof Out & string)[]>(...keys: TKeys): TypedAction<In, Pick<Out, TKeys[number]>>;
     /** Head/tail decomposition. Only callable when Out is TElement[]. */
-    splitFirst<TIn, TElement, TRefs extends string>(this: TypedAction<TIn, TElement[], TRefs>): TypedAction<TIn, Option<[TElement, TElement[]]>, TRefs>;
+    splitFirst<TIn, TElement>(this: TypedAction<TIn, TElement[]>): TypedAction<TIn, Option<[TElement, TElement[]]>>;
     /** Init/last decomposition. Only callable when Out is TElement[]. */
-    splitLast<TIn, TElement, TRefs extends string>(this: TypedAction<TIn, TElement[], TRefs>): TypedAction<TIn, Option<[TElement[], TElement]>, TRefs>;
+    splitLast<TIn, TElement>(this: TypedAction<TIn, TElement[]>): TypedAction<TIn, Option<[TElement[], TElement]>>;
     /**
-     * Transform the Some value inside an Option output. Only callable when
-     * Out is Option<T>. Uses `this` parameter constraint to gate availability.
+     * Transform the inner value. Dispatches: Option.map, Result.map.
      */
-    mapOption<TIn, T, U, TRefs extends string>(this: TypedAction<TIn, Option<T>, TRefs>, action: Pipeable<T, U>): TypedAction<TIn, Option<U>, TRefs>;
+    map<TIn, T, U>(this: TypedAction<TIn, Option<T>>, action: Pipeable<T, U>): TypedAction<TIn, Option<U>>;
+    map<TIn, TValue, TOut, TError>(this: TypedAction<TIn, Result<TValue, TError>>, action: Pipeable<TValue, TOut>): TypedAction<TIn, Result<TOut, TError>>;
     /**
      * Transform the Err value of a Result output.
      * `Result<TValue, TError> → Result<TValue, TErrorOut>`
-     *
-     * Only callable when Out is Result<TValue, TError>.
      */
-    mapErr<TIn, TValue, TError, TErrorOut>(this: TypedAction<TIn, Result<TValue, TError>, any>, action: Pipeable<TError, TErrorOut>): TypedAction<TIn, Result<TValue, TErrorOut>, Refs>;
+    mapErr<TIn, TValue, TError, TErrorOut>(this: TypedAction<TIn, Result<TValue, TError>>, action: Pipeable<TError, TErrorOut>): TypedAction<TIn, Result<TValue, TErrorOut>>;
     /**
-     * Unwrap a Result output. If Ok, pass through the value. If Err, apply
-     * the default action. Only callable when Out is Result<TValue, TError>.
+     * Unwrap or panic. Dispatches: Option.unwrap, Result.unwrap.
      *
-     * The `this` constraint provides TValue from context, so throw tokens
-     * (Out=never) work without explicit type parameters:
-     *   `handler.unwrapOr(throwError)`
+     * Option: If Some, pass through value. If None, panic.
+     * Result: If Ok, pass through value. If Err, panic.
+     */
+    unwrap<TIn, TValue>(this: TypedAction<TIn, Option<TValue>>): TypedAction<TIn, TValue>;
+    unwrap<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>): TypedAction<TIn, TValue>;
+    /**
+     * Unwrap a union output. Dispatches: Option.unwrapOr, Result.unwrapOr.
      *
-     * Uses CaseHandler for defaultAction (covariant output only) so that
-     * `TypedAction<TError, never>` is assignable to `CaseHandler<TError, TValue>`.
+     * Option: If Some, pass through value. If None, apply default.
+     * Result: If Ok, pass through value. If Err, apply default.
      *
-     * Refs position uses `any` in the `this` constraint to avoid TS
-     * falling back to the constraint bound `string` when Refs = never.
-     * The return type uses the enclosing TypedAction's `Refs` directly.
+     * Covariant output makes throw tokens (Out=never) work:
+     *   `handler.unwrapOr(throwError)`
      */
-    unwrapOr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>, any>, defaultAction: CaseHandler<TError, TValue>): TypedAction<TIn, TValue, Refs>;
+    unwrapOr<TIn, TValue>(this: TypedAction<TIn, Option<TValue>>, defaultAction: Pipeable<void, TValue>): TypedAction<TIn, TValue>;
+    unwrapOr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>, defaultAction: Pipeable<TError, TValue>): TypedAction<TIn, TValue>;
+    /** Monadic bind. Option: `Option<T> → Option<U>`. Result: `Result<T,E> → Result<U,E>`. */
+    andThen<TIn, TValue, TOut>(this: TypedAction<TIn, Option<TValue>>, action: Pipeable<TValue, Option<TOut>>): TypedAction<TIn, Option<TOut>>;
+    andThen<TIn, TValue, TOut, TError>(this: TypedAction<TIn, Result<TValue, TError>>, action: Pipeable<TValue, Result<TOut, TError>>): TypedAction<TIn, Result<TOut, TError>>;
+    /** Conditional keep. If Some, apply predicate. If None, stay None. */
+    filter<TIn, TValue>(this: TypedAction<TIn, Option<TValue>>, predicate: Pipeable<TValue, Option<TValue>>): TypedAction<TIn, Option<TValue>>;
+    /** Test if the value is Some. `Option<T> → boolean` */
+    isSome<TIn, TValue>(this: TypedAction<TIn, Option<TValue>>): TypedAction<TIn, boolean>;
+    /** Test if the value is None. `Option<T> → boolean` */
+    isNone<TIn, TValue>(this: TypedAction<TIn, Option<TValue>>): TypedAction<TIn, boolean>;
+    /** Collect Some values from an array, discarding Nones. `Option<T>[] → T[]` */
+    collect<TIn, TValue>(this: TypedAction<TIn, Option<TValue>[]>): TypedAction<TIn, TValue[]>;
+    /** Fallback on Err. `Result<T,E> → Result<T,F>` */
+    or<TIn, TValue, TError, TErrorOut>(this: TypedAction<TIn, Result<TValue, TError>>, fallback: Pipeable<TError, Result<TValue, TErrorOut>>): TypedAction<TIn, Result<TValue, TErrorOut>>;
+    /** Replace Ok value with another Result. `Result<T,E> → Result<U,E>` */
+    and<TIn, TValue, TOut, TError>(this: TypedAction<TIn, Result<TValue, TError>>, other: Pipeable<void, Result<TOut, TError>>): TypedAction<TIn, Result<TOut, TError>>;
+    /** Convert Ok to Some, Err to None. `Result<T,E> → Option<T>` */
+    toOption<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>): TypedAction<TIn, Option<TValue>>;
+    /** Convert Err to Some, Ok to None. `Result<T,E> → Option<E>` */
+    toOptionErr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>): TypedAction<TIn, Option<TError>>;
+    /** Test if the value is Ok. `Result<T,E> → boolean` */
+    isOk<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>): TypedAction<TIn, boolean>;
+    /** Test if the value is Err. `Result<T,E> → boolean` */
+    isErr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>): TypedAction<TIn, boolean>;
+    /** Swap nesting. `Option<Result<T,E>> → Result<Option<T>,E>` or `Result<Option<T>,E> → Option<Result<T,E>>`. */
+    transpose<TIn, TValue, TError>(this: TypedAction<TIn, Option<Result<TValue, TError>>>): TypedAction<TIn, Result<Option<TValue>, TError>>;
+    transpose<TIn, TValue, TError>(this: TypedAction<TIn, Result<Option<TValue>, TError>>): TypedAction<TIn, Option<Result<TValue, TError>>>;
+    /** Bind concurrent values as VarRefs available throughout the body. */
+    bind<TBindings extends Action[], TOut>(bindings: [...TBindings], body: (vars: InferVarRefs<TBindings>) => Action & {
+        __out?: () => TOut;
+    }): TypedAction<In, TOut>;
+    /** Capture the pipeline input as a VarRef. */
+    bindInput<TOut>(body: (input: VarRef<Out>) => Action & {
+        __out?: () => TOut;
+    }): TypedAction<In, TOut>;
 };
 /**
- * Parameter type for pipe and combinators. Contains the same phantom fields
- * as TypedAction but without methods.
- *
- * Invariance: Both In and Out are invariant, matching TypedAction:
- *   In:  __in (contravariant) + __in_co (covariant) → invariant
- *   Out: __out (covariant) + __out_contra (contravariant) → invariant
+ * Parameter type for pipe and combinators. Same phantom fields as TypedAction
+ * but without methods.
  *
  * Why no methods: TypedAction's methods (then, branch, etc.) participate in
  * TS assignability checks in complex, recursive ways that interfere with
  * generic inference in pipe overloads. Pipeable strips methods so that only
- * phantom fields drive inference — predictable covariant/contravariant
- * resolution, with invariance enforced when TS checks candidates from
- * both sides of a connection.
+ * phantom fields drive inference.
  *
  * TypedAction (with methods) is assignable to Pipeable because Pipeable
  * only requires a subset of properties.
@@ -199,24 +270,18 @@ export type Pipeable<In = unknown, Out = unknown> = Action & {
     __in?: (input: In) => void;
     __in_co?: In;
     __out?: () => Out;
-    __out_contra?: (output: Out) => void;
 };
 /**
- * Contravariant-only input checking for branch case handler positions.
+ * Contravariant input + covariant output for branch case handler positions.
  *
- * Omits __in_co (covariant input) and __out_contra (contravariant output)
- * compared to TypedAction/Pipeable. This gives:
+ * Omits __in_co (covariant input) compared to Pipeable. This gives:
  *   In:  contravariant only (via __in)
  *   Out: covariant only (via __out)
  *
  * Why contravariant input: a handler that accepts `unknown` (like drop)
  * can handle any variant. (input: unknown) => void is assignable to
  * (input: HasErrors) => void because HasErrors extends unknown.
- *
- * Why covariant output: the constraint doesn't restrict output types —
- * they're inferred from the actual case handlers via ExtractOutput.
- * TypedAction's invariant __out_contra with Out=unknown would
- * reject any handler with a specific output type, so we omit it.
+ * Pipeable's invariant input (__in_co) would reject this.
  *
  * TypedAction is assignable to CaseHandler because CaseHandler only
  * requires a subset of TypedAction's phantom fields.
@@ -231,6 +296,11 @@ type CaseHandler<TIn = unknown, TOut = unknown> = Action & {
  * field enables `.branch()` to decompose the union via simple indexing
  * (`keyof ExtractDef<Out>` and `ExtractDef<Out>[K]`) instead of
  * conditional types (`KindOf<Out>` and `Extract<Out, { kind: K }>`).
+ *
+ * **Void → null mapping:** Variants with `void` payload (e.g. `{ None: void }`)
+ * become `{ kind: "None"; value: null }` at runtime. This is handled by
+ * `VoidToNull` below — `void` has no runtime representation in JSON, so it
+ * serializes as `null`. Use `z.null()` in Zod schemas for void variants.
  */
 type VoidToNull<T> = 0 extends 1 & T ? T : [T] extends [never] ? never : [T] extends [void] ? null : T;
 export type TaggedUnion<TDef extends Record<string, unknown>> = {
@@ -279,12 +349,12 @@ type BranchPayload<Out, K extends string> = [ExtractDef<Out>] extends [never] ?
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
  * Methods are non-enumerable: invisible to JSON.stringify and toEqual.
  */
-export declare function typedAction<In = unknown, Out = unknown, Refs extends string = never>(action: Action): TypedAction<In, Out, Refs>;
+export declare function typedAction<In = unknown, Out = unknown>(action: Action): TypedAction<In, Out>;
 /**
  * Extract the input type from a TypedAction.
  *
  * Uses direct phantom field extraction (not full TypedAction matching) to
- * avoid the `TypedAction<any, any, any>` constraint which fails for In=never
+ * avoid a full `TypedAction<any, any>` constraint which fails for In=never
  * due to __in contravariance.
  */
 export type ExtractInput<T> = T extends {
@@ -332,8 +402,6 @@ type LoopResultDef<TContinue, TBreak> = {
     Break: TBreak;
 };
 export type LoopResult<TContinue, TBreak> = TaggedUnion<LoopResultDef<TContinue, TBreak>>;
-export declare const TAG_BREAK: Action;
-export declare const IDENTITY: Action;
 /**
  * Restartable scope. The body callback receives `restart`, a TypedAction that
  * re-executes the body from the beginning with a new input value.
@@ -343,7 +411,7 @@ export declare const IDENTITY: Action;
  *
  * Compiled form: `RestartHandle(id, GetIndex(0), body)`
  */
-export declare function recur<TIn = never, TOut = any>(bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut>): TypedAction<PipeIn<TIn>, TOut>;
+export declare function recur<TIn = void, TOut = any>(bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut>): TypedAction<PipeIn<TIn>, TOut>;
 /**
  * Early return scope. The body callback receives `earlyReturn`, a TypedAction
  * that exits the scope immediately with the returned value.
@@ -356,7 +424,7 @@ export declare function recur<TIn = never, TOut = any>(bodyFn: (restart: TypedAc
  * a Branch. earlyReturn tags with Break and performs — the handler restarts
  * the body, Branch takes the Break path, and the value exits.
  */
-export declare function earlyReturn<TEarlyReturn = never, TIn = any, TOut = any>(bodyFn: (earlyReturn: TypedAction<TEarlyReturn, never>) => Pipeable<TIn, TOut>): TypedAction<TIn, TEarlyReturn | TOut>;
+export declare function earlyReturn<TEarlyReturn = void, TIn = any, TOut = any>(bodyFn: (earlyReturn: TypedAction<TEarlyReturn, never>) => Pipeable<TIn, TOut>): TypedAction<TIn, TEarlyReturn | TOut>;
 /**
  * Build the restart+branch compiled form:
  * `Chain(Tag("Continue"), RestartHandle(id, GetIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
@@ -376,6 +444,6 @@ export declare function buildRestartBranchAction(restartHandlerId: RestartHandle
  *
  * Compiles to `RestartHandle`/`RestartPerform`/Branch — same effect substrate as tryCatch and earlyReturn.
  */
-export declare function loop<TBreak = never, TIn = never>(bodyFn: (recur: TypedAction<TIn, never>, done: TypedAction<VoidToNull<TBreak>, never>) => Pipeable<TIn, never>): TypedAction<PipeIn<TIn>, VoidToNull<TBreak>>;
+export declare function loop<TBreak = void, TRecur = void>(bodyFn: (recur: TypedAction<TRecur, never>, done: TypedAction<VoidToNull<TBreak>, never>) => Pipeable<TRecur, never>): TypedAction<PipeIn<TRecur>, VoidToNull<TBreak>>;
 /** Simple config factory. */
 export declare function config(workflow: Action): Config;