@barnum/barnum 0.0.0-main-3c07d795 → 0.0.0-main-54c41bbb

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

@@ -60,22 +60,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,10 +78,10 @@ export type BuiltinKind = {
     kind: "SplitLast";
 } | {
     kind: "WrapInField";
-    value: string;
+    field: string;
 } | {
     kind: "Sleep";
-    value: number;
+    ms: number;
 };
 /**
  * When TIn is `never` (handler ignores input), produce `any` so the
@@ -112,54 +106,51 @@ export type MergeTuple<TTuple> = TTuple extends unknown[] ? UnionToIntersection<
  * Data crosses serialization boundaries to handlers in arbitrary languages
  * (Rust, Python, etc.), so extra/missing fields are runtime errors.
  */
-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;
-    };
     /** 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>;
+    }>(cases: [BranchKeys<Out>] extends [never] ? never : TCases): TypedAction<In, ExtractOutput<TCases[keyof TCases & string]>>;
     /** Flatten a nested array output. `a.flatten()` ≡ `pipe(a, flatten())`. */
-    flatten(): TypedAction<In, Out extends (infer TElement)[][] ? TElement[] : Out, Refs>;
+    flatten(): TypedAction<In, Out extends (infer TElement)[][] ? TElement[] : Out>;
     /** Discard output. `a.drop()` ≡ `pipe(a, drop)`. */
-    drop(): TypedAction<In, never, Refs>;
+    drop(): TypedAction<In, never>;
     /** 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.
      */
-    mapOption<TIn, T, U, TRefs extends string>(this: TypedAction<TIn, Option<T>, TRefs>, action: Pipeable<T, U>): TypedAction<TIn, Option<U>, TRefs>;
+    mapOption<TIn, T, U>(this: TypedAction<TIn, Option<T>>, action: Pipeable<T, U>): TypedAction<TIn, Option<U>>;
     /**
      * 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>.
@@ -170,12 +161,8 @@ export type TypedAction<In = unknown, Out = unknown, Refs extends string = never
      *
      * Uses CaseHandler for defaultAction (covariant output only) so that
      * `TypedAction<TError, never>` is assignable to `CaseHandler<TError, TValue>`.
-     *
-     * 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.
      */
-    unwrapOr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>, any>, defaultAction: CaseHandler<TError, TValue>): TypedAction<TIn, TValue, Refs>;
+    unwrapOr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>, defaultAction: CaseHandler<TError, TValue>): TypedAction<TIn, TValue>;
 };
 /**
  * Parameter type for pipe and combinators. Contains the same phantom fields
@@ -231,6 +218,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 +271,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 +324,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.

package/dist/ast.js

@@ -1,206 +1,56 @@
+import { chain } from "./chain.js";
+import { drop, flatten as flattenBuiltin, getField, getIndex, identity, merge, Option, pick, Result, splitFirst, splitLast, tag, wrapInField, } from "./builtins.js";
 // ---------------------------------------------------------------------------
 // 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 });
+    return chain(this, next);
 }
 function forEachMethod(action) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: { kind: "ForEach", action },
-    });
+    return chain(this, forEach(action));
 }
 function branchMethod(cases) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: { kind: "Branch", cases: unwrapBranchCases(cases) },
-    });
+    return chain(this, branch(cases));
 }
 function flattenMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Flatten" } },
-        },
-    });
+    return chain(this, flattenBuiltin());
 }
 function dropMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Drop" } },
-        },
-    });
+    return chain(this, drop);
 }
 function tagMethod(kind) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Tag", value: kind } },
-        },
-    });
+    return chain(this, tag(kind));
 }
 function getFieldMethod(field) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "GetField", value: field },
-            },
-        },
-    });
+    return chain(this, getField(field));
 }
 function getIndexMethod(index) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "GetIndex", value: index },
-            },
-        },
-    });
+    return chain(this, getIndex(index));
 }
 function wrapInFieldMethod(field) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "WrapInField", value: field },
-            },
-        },
-    });
+    return chain(this, wrapInField(field));
 }
 function mergeMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Merge" } },
-        },
-    });
+    return chain(this, merge());
 }
 function pickMethod(...keys) {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Pick", value: keys } },
-        },
-    });
+    return chain(this, pick(...keys));
 }
 function splitFirstMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "SplitFirst" } },
-        },
-    });
+    return chain(this, splitFirst());
 }
 function splitLastMethod() {
-    return typedAction({
-        kind: "Chain",
-        first: this,
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "SplitLast" } },
-        },
-    });
+    return chain(this, splitLast());
 }
 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" } },
-                },
-            }),
-        },
-    });
+    return chain(this, Option.map(action));
 }
 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" },
-                        },
-                    },
-                },
-            }),
-        },
-    });
+    return chain(this, Result.mapErr(action));
 }
 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(this, Result.unwrapOr(defaultAction));
 }
 /**
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
@@ -253,17 +103,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: "GetField", value: "value" },
-                },
-            },
-            rest: cases[key],
-        };
+        unwrapped[key] = chain(getField("value"), cases[key]);
     }
     return unwrapped;
 }
@@ -272,25 +112,6 @@ 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: "GetIndex", 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" } },
-};
-// ---------------------------------------------------------------------------
 // recur — restart body primitive
 // ---------------------------------------------------------------------------
 /**
@@ -313,7 +134,7 @@ export function recur(bodyFn) {
         kind: "RestartHandle",
         restart_handler_id: restartHandlerId,
         body,
-        handler: EXTRACT_PAYLOAD,
+        handler: getIndex(0),
     });
 }
 // ---------------------------------------------------------------------------
@@ -333,13 +154,12 @@ 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 earlyReturnAction = typedAction(chain(tag("Break"), {
+        kind: "RestartPerform",
+        restart_handler_id: restartHandlerId,
+    }));
     const body = bodyFn(earlyReturnAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, IDENTITY));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, identity()));
 }
 // ---------------------------------------------------------------------------
 // loop — iterative restart with break
@@ -354,22 +174,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 chain(tag("Continue"), {
+        kind: "RestartHandle",
+        restart_handler_id: restartHandlerId,
+        body: branch({ Continue: continueArm, Break: breakArm }),
+        handler: getIndex(0),
+    });
 }
 /**
  * Iterative loop. The body callback receives `recur` and `done`:
@@ -386,18 +196,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 recurAction = typedAction(chain(tag("Continue"), perform));
+    const doneAction = typedAction(chain(tag("Break"), perform));
     const body = bodyFn(recurAction, doneAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, IDENTITY));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, identity()));
 }
 // ---------------------------------------------------------------------------
 // Config builders

package/dist/bind.js

@@ -1,5 +1,7 @@
 import { typedAction, } from "./ast.js";
-import { identity, drop } from "./builtins.js";
+import { chain } from "./chain.js";
+import { all } from "./all.js";
+import { identity, drop, getIndex } from "./builtins.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 import { pipe } from "./pipe.js";
 function createVarRef(resumeHandlerId) {
@@ -21,35 +23,7 @@ function createVarRef(resumeHandlerId) {
  * Expanded AST: All(Chain(GetIndex(1), GetIndex(n)), GetIndex(1))
  */
 function readVar(n) {
-    return {
-        kind: "All",
-        actions: [
-            {
-                kind: "Chain",
-                first: {
-                    kind: "Invoke",
-                    handler: {
-                        kind: "Builtin",
-                        builtin: { kind: "GetIndex", value: 1 },
-                    },
-                },
-                rest: {
-                    kind: "Invoke",
-                    handler: {
-                        kind: "Builtin",
-                        builtin: { kind: "GetIndex", value: n },
-                    },
-                },
-            },
-            {
-                kind: "Invoke",
-                handler: {
-                    kind: "Builtin",
-                    builtin: { kind: "GetIndex", value: 1 },
-                },
-            },
-        ],
-    };
+    return all(chain(getIndex(1), getIndex(n)), getIndex(1));
 }
 export function bind(bindings, body) {
     // 1. Gensym one resumeHandlerId per binding.
@@ -61,17 +35,7 @@ export function bind(bindings, body) {
     // 4. Build nested Handles from inside out.
     //    Innermost: extract pipeline_input (last All element) → user body
     const pipelineInputIndex = bindings.length;
-    let inner = {
-        kind: "Chain",
-        first: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "GetIndex", value: pipelineInputIndex },
-            },
-        },
-        rest: bodyAction,
-    };
+    let inner = chain(getIndex(pipelineInputIndex), bodyAction);
     for (let i = resumeHandlerIds.length - 1; i >= 0; i--) {
         inner = {
             kind: "ResumeHandle",
@@ -81,15 +45,11 @@ export function bind(bindings, body) {
         };
     }
     // 5. All(...bindings, identity()) → nested Handles
-    const allActions = [
-        ...bindings.map((b) => b),
-        identity(),
-    ];
-    return typedAction({
-        kind: "Chain",
-        first: { kind: "All", actions: allActions },
-        rest: inner,
-    });
+    const allAction = {
+        kind: "All",
+        actions: [...bindings.map((b) => b), identity()],
+    };
+    return typedAction(chain(allAction, inner));
 }
 // ---------------------------------------------------------------------------
 // bindInput — bind the pipeline input