@barnum/barnum 0.0.0-main-54c41bbb → 0.0.0-main-a589e69d

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";
@@ -82,12 +83,16 @@ export type BuiltinKind = {
 } | {
     kind: "Sleep";
     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;
 }
@@ -95,22 +100,65 @@ 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> = Action & {
     __in?: (input: In) => void;
     __in_co?: In;
     __out?: () => Out;
-    __out_contra?: (output: Out) => void;
+    /** 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>;
     /** Apply an action to each element of an array output. `a.forEach(b)` ≡ `a.then(forEach(b))`. */
@@ -119,10 +167,13 @@ export type TypedAction<In = unknown, Out = unknown> = Action & {
     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]>>;
-    /** Flatten a nested array output. `a.flatten()` ≡ `pipe(a, flatten())`. */
-    flatten(): TypedAction<In, Out extends (infer TElement)[][] ? TElement[] : Out>;
+    /** 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>;
+    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>>;
     /** Extract a field from the output object. `a.getField("name")` ≡ `pipe(a, getField("name"))`. */
@@ -140,44 +191,77 @@ export type TypedAction<In = unknown, Out = unknown> = Action & {
     /** Init/last decomposition. Only callable when Out is TElement[]. */
     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>(this: TypedAction<TIn, Option<T>>, action: Pipeable<T, U>): TypedAction<TIn, Option<U>>;
+    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>>, 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.
+     *
+     * Option: If Some, pass through value. If None, apply default.
+     * Result: If Ok, pass through value. If Err, apply default.
      *
-     * Uses CaseHandler for defaultAction (covariant output only) so that
-     * `TypedAction<TError, never>` is assignable to `CaseHandler<TError, TValue>`.
+     * Covariant output makes throw tokens (Out=never) work:
+     *   `handler.unwrapOr(throwError)`
      */
-    unwrapOr<TIn, TValue, TError>(this: TypedAction<TIn, Result<TValue, TError>>, defaultAction: CaseHandler<TError, TValue>): TypedAction<TIn, TValue>;
+    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.
@@ -186,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.
@@ -333,7 +411,7 @@ export type LoopResult<TContinue, TBreak> = TaggedUnion<LoopResultDef<TContinue,
  *
  * 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.
@@ -346,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 })))`
@@ -366,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;

package/dist/ast.js

@@ -1,5 +1,23 @@
 import { chain } from "./chain.js";
-import { drop, flatten as flattenBuiltin, getField, getIndex, identity, merge, Option, pick, Result, splitFirst, splitLast, tag, wrapInField, } from "./builtins.js";
+import { drop, flatten as flattenBuiltin, getField, getIndex, identity, merge, pick, splitFirst, splitLast, tag, wrapInField, } from "./builtins.js";
+import { Option } from "./option.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";
+/**
+ * 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 function withUnion(action, name, methods) {
+    Object.defineProperty(action, "__union", {
+        value: { name, methods },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+    return action;
+}
 // ---------------------------------------------------------------------------
 // typedAction — attach .then() and .forEach() as non-enumerable methods
 // ---------------------------------------------------------------------------
@@ -14,6 +32,11 @@ function branchMethod(cases) {
     return chain(this, branch(cases));
 }
 function flattenMethod() {
+    const dispatch = this.__union;
+    if (dispatch?.methods.flatten) {
+        return chain(this, dispatch.methods.flatten());
+    }
+    // Fall back to array flatten
     return chain(this, flattenBuiltin());
 }
 function dropMethod() {
@@ -43,14 +66,89 @@ function splitFirstMethod() {
 function splitLastMethod() {
     return chain(this, splitLast());
 }
-function mapOptionMethod(action) {
-    return chain(this, Option.map(action));
+/**
+ * Require a dispatch method, throwing a descriptive error if missing.
+ * Uses the union's type name for context.
+ */
+function requireDispatch(dispatch, methodName, accessor) {
+    if (!dispatch) {
+        throw new Error(`.${methodName}() requires a union type (Option or Result)`);
+    }
+    const method = accessor(dispatch.methods);
+    if (!method) {
+        throw new Error(`.${methodName}() is not available on ${dispatch.name}`);
+    }
+    return method;
+}
+function mapMethod(action) {
+    const map = requireDispatch(this.__union, "map", (m) => m.map);
+    return chain(this, map(action));
 }
 function mapErrMethod(action) {
-    return chain(this, Result.mapErr(action));
+    const mapErr = requireDispatch(this.__union, "mapErr", (m) => m.mapErr);
+    return chain(this, mapErr(action));
+}
+function unwrapMethod() {
+    const unwrap = requireDispatch(this.__union, "unwrap", (m) => m.unwrap);
+    return chain(this, unwrap());
 }
 function unwrapOrMethod(defaultAction) {
-    return chain(this, Result.unwrapOr(defaultAction));
+    const unwrapOr = requireDispatch(this.__union, "unwrapOr", (m) => m.unwrapOr);
+    return chain(this, unwrapOr(defaultAction));
+}
+// --- Dispatched postfix methods (via __union) ---
+function andThenMethod(action) {
+    const andThen = requireDispatch(this.__union, "andThen", (m) => m.andThen);
+    return chain(this, andThen(action));
+}
+function filterMethod(predicate) {
+    const filter = requireDispatch(this.__union, "filter", (m) => m.filter);
+    return chain(this, filter(predicate));
+}
+function isSomeMethod() {
+    const isSome = requireDispatch(this.__union, "isSome", (m) => m.isSome);
+    return chain(this, isSome());
+}
+function isNoneMethod() {
+    const isNone = requireDispatch(this.__union, "isNone", (m) => m.isNone);
+    return chain(this, isNone());
+}
+function collectMethod() {
+    return chain(this, Option.collect());
+}
+function orMethod(fallback) {
+    const or = requireDispatch(this.__union, "or", (m) => m.or);
+    return chain(this, or(fallback));
+}
+function andPostfixMethod(other) {
+    const and = requireDispatch(this.__union, "and", (m) => m.and);
+    return chain(this, and(other));
+}
+function toOptionMethod() {
+    const toOption = requireDispatch(this.__union, "toOption", (m) => m.toOption);
+    return chain(this, toOption());
+}
+function toOptionErrMethod() {
+    const toOptionErr = requireDispatch(this.__union, "toOptionErr", (m) => m.toOptionErr);
+    return chain(this, toOptionErr());
+}
+function isOkMethod() {
+    const isOk = requireDispatch(this.__union, "isOk", (m) => m.isOk);
+    return chain(this, isOk());
+}
+function isErrMethod() {
+    const isErr = requireDispatch(this.__union, "isErr", (m) => m.isErr);
+    return chain(this, isErr());
+}
+function transposeMethod() {
+    const transpose = requireDispatch(this.__union, "transpose", (m) => m.transpose);
+    return chain(this, transpose());
+}
+function bindMethod(bindings, body) {
+    return chain(this, bindStandalone(bindings, body));
+}
+function bindInputMethod(body) {
+    return chain(this, bindInputStandalone(body));
 }
 /**
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
@@ -59,6 +157,7 @@ function unwrapOrMethod(defaultAction) {
 export function typedAction(action) {
     if (!("then" in action)) {
         Object.defineProperties(action, {
+            __union: { value: null, configurable: true, enumerable: false, writable: true },
             then: { value: thenMethod, configurable: true },
             forEach: { value: forEachMethod, configurable: true },
             branch: { value: branchMethod, configurable: true },
@@ -72,9 +171,24 @@ export function typedAction(action) {
             pick: { value: pickMethod, configurable: true },
             splitFirst: { value: splitFirstMethod, configurable: true },
             splitLast: { value: splitLastMethod, configurable: true },
-            mapOption: { value: mapOptionMethod, 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 },
+            collect: { value: collectMethod, configurable: true },
+            or: { value: orMethod, configurable: true },
+            and: { value: andPostfixMethod, configurable: true },
+            toOption: { value: toOptionMethod, configurable: true },
+            toOptionErr: { value: toOptionErrMethod, 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;

package/dist/bind.d.ts

@@ -6,17 +6,14 @@ import { type Action, type ExtractInput, type ExtractOutput, type TypedAction }
  * 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]>>;
@@ -40,12 +37,11 @@ export type InferVarRefs<TBindings extends Action[]> = {
  */
 /**
  * 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>;
 /**

package/dist/builtins.d.ts

@@ -1,4 +1,4 @@
-import { type Action, type MergeTuple, type Option as OptionT, type Pipeable, type Result as ResultT, type TaggedUnion, type TypedAction } from "./ast.js";
+import { type MergeTuple, type Option as OptionT, type Pipeable, type TaggedUnion, type TypedAction } from "./ast.js";
 import { z } from "zod";
 /**
  * Typed combinators for structural data transformations.
@@ -33,7 +33,14 @@ export declare function taggedUnionSchema<TDef extends Record<string, z.ZodTypeA
 }>>>;
 export declare function constant<TValue>(value: TValue): TypedAction<any, TValue>;
 export declare function identity<TValue = any>(): TypedAction<TValue, TValue>;
-export declare const drop: TypedAction<any, never>;
+export declare const drop: TypedAction<any, void>;
+/**
+ * Halt execution with a fatal error. Not caught by tryCatch.
+ * Analogous to Rust's `panic!`.
+ *
+ * Output type is `never` — a panic never produces a value.
+ */
+export declare function panic(message: string): TypedAction<any, never>;
 /**
  * Wrap input as a tagged union member. Requires the full variant map TDef
  * so the output type carries __def for branch decomposition.
@@ -68,18 +75,6 @@ export declare function withResource<TIn extends Record<string, unknown>, TResou
     action: Pipeable<TResource & TIn, TOut>;
     dispose: Pipeable<TResource, TDisposeOut>;
 }): TypedAction<TIn, TOut>;
-/**
- * Run `action` on the input for its side effects, then discard the action's
- * output and return the original input unchanged. The action must accept
- * exactly `TInput`. Use `pick` inside the action's pipe if the inner
- * handler needs a subset.
- *
- * Constraint: input must be an object (uses all + merge internally).
- *
- * Example:
- *   pipe(tap(pipe(pick("worktreePath", "description"), implement)), createPR)
- */
-export declare function tap<TInput extends Record<string, unknown>>(action: Pipeable<TInput, any>): TypedAction<TInput, TInput>;
 export declare function wrapInField<TField extends string, TValue>(field: TField): TypedAction<TValue, Record<TField, TValue>>;
 export declare function range(start: number, end: number): TypedAction<any, number[]>;
 /**
@@ -105,125 +100,4 @@ export declare function splitFirst<TElement>(): TypedAction<TElement[], OptionT<
  * that can't be composed from existing AST nodes.
  */
 export declare function splitLast<TElement>(): TypedAction<TElement[], OptionT<[TElement[], TElement]>>;
-/**
- * Extract the first element of an array.
- * `readonly TElement[] → Option<TElement>`
- *
- * Composes `splitFirst` (which returns `Option<[TElement, TElement[]]>`)
- * with `Option.map(getIndex(0))` to extract just the element.
- */
-export declare function first<TElement>(): TypedAction<readonly TElement[], OptionT<TElement>>;
-/**
- * Extract the last element of an array.
- * `readonly TElement[] → Option<TElement>`
- *
- * Composes `splitLast` (which returns `Option<[TElement[], TElement]>`)
- * with `Option.map(getIndex(1))` to extract just the element.
- */
-export declare function last<TElement>(): TypedAction<readonly TElement[], OptionT<TElement>>;
-/**
- * Option namespace. All combinators produce TypedAction AST nodes that
- * desugar to branch + existing builtins, except collect which uses the
- * CollectSome builtin.
- */
-export declare const Option: {
-    /** Wrap a value as Some. `T → Option<T>` */
-    readonly some: <T>() => TypedAction<T, OptionT<T>>;
-    /** Produce a None. `never → Option<T>` */
-    readonly none: <T>() => TypedAction<never, OptionT<T>>;
-    /** Transform the Some value. `Option<T> → Option<U>` */
-    readonly map: <T, U>(action: Pipeable<T, U>) => TypedAction<OptionT<T>, OptionT<U>>;
-    /**
-     * Monadic bind (flatMap). If Some, pass the value to action which
-     * returns Option<U>. If None, stay None. `Option<T> → Option<U>`
-     */
-    readonly andThen: <T, U>(action: Pipeable<T, OptionT<U>>) => TypedAction<OptionT<T>, OptionT<U>>;
-    /**
-     * Extract the Some value or produce a default from an action.
-     * `Option<T> → T`
-     *
-     * The None branch drops its void payload before calling defaultAction,
-     * matching Rust's `unwrap_or_else(|| default)`.
-     */
-    readonly unwrapOr: <T>(defaultAction: Pipeable<never, T>) => TypedAction<OptionT<T>, T>;
-    /** Unwrap a nested Option. `Option<Option<T>> → Option<T>` */
-    readonly flatten: <T>() => TypedAction<OptionT<OptionT<T>>, OptionT<T>>;
-    /**
-     * Conditional keep. If Some, pass value to predicate which returns
-     * Option<T>. If None, stay None. `Option<T> → Option<T>`
-     */
-    readonly filter: <T>(predicate: Pipeable<T, OptionT<T>>) => TypedAction<OptionT<T>, OptionT<T>>;
-    /**
-     * Collect Some values from an array, discarding Nones.
-     * `Option<T>[] → T[]`
-     */
-    readonly collect: <T = any>() => TypedAction<OptionT<T>[], T[]>;
-    /** Test if the value is Some. `Option<T> → boolean` */
-    readonly isSome: <T>() => TypedAction<OptionT<T>, boolean>;
-    /** Test if the value is None. `Option<T> → boolean` */
-    readonly isNone: <T>() => TypedAction<OptionT<T>, boolean>;
-    /**
-     * Build a Zod schema for `Option<T>`.
-     *
-     * ```ts
-     * const schema = Option.schema(z.string());
-     * // validates: { kind: "Some", value: "hello" } or { kind: "None", value: null }
-     * ```
-     */
-    readonly schema: <TValue>(valueSchema: z.ZodType<TValue>) => z.ZodType<OptionT<TValue>>;
-};
-export declare const Result: {
-    /** Wrap a value as Ok. `TValue → Result<TValue, TError>` */
-    readonly ok: <TValue, TError>() => TypedAction<TValue, ResultT<TValue, TError>>;
-    /** Wrap a value as Err. `TError → Result<TValue, TError>` */
-    readonly err: <TValue, TError>() => TypedAction<TError, ResultT<TValue, TError>>;
-    /** Transform the Ok value. `Result<TValue, TError> → Result<TOut, TError>` */
-    readonly map: <TValue, TOut, TError>(action: Pipeable<TValue, TOut>) => TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
-    /** Transform the Err value. `Result<TValue, TError> → Result<TValue, TErrorOut>` */
-    readonly mapErr: <TValue, TError, TErrorOut>(action: Pipeable<TError, TErrorOut>) => TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>>;
-    /**
-     * Monadic bind (flatMap) for Ok. If Ok, pass value to action which
-     * returns Result<TOut, TError>. If Err, propagate.
-     */
-    readonly andThen: <TValue, TOut, TError>(action: Pipeable<TValue, ResultT<TOut, TError>>) => TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
-    /** Fallback on Err. If Ok, keep it. If Err, pass error to fallback. */
-    readonly or: <TValue, TError, TErrorOut>(fallback: Pipeable<TError, ResultT<TValue, TErrorOut>>) => TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>>;
-    /** Replace Ok value with another Result. If Ok, discard value and return other. */
-    readonly and: <TValue, TOut, TError>(other: Pipeable<never, ResultT<TOut, TError>>) => TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
-    /**
-     * Extract Ok or compute default from Err. `Result<TValue, TError> → TValue`
-     *
-     * Uses covariant output checking so throw tokens (Out=never) are assignable.
-     * For inference-free usage with throw tokens, prefer the postfix method:
-     * `handler.unwrapOr(throwError)`.
-     */
-    readonly unwrapOr: <TValue, TError>(defaultAction: Action & {
-        __in?: (input: TError) => void;
-        __out?: () => TValue;
-    }) => TypedAction<ResultT<TValue, TError>, TValue>;
-    /** Unwrap nested Result. `Result<Result<TValue, TError>, TError> → Result<TValue, TError>` */
-    readonly flatten: <TValue, TError>() => TypedAction<ResultT<ResultT<TValue, TError>, TError>, ResultT<TValue, TError>>;
-    /** Convert Ok to Some, Err to None. `Result<TValue, TError> → Option<TValue>` */
-    readonly toOption: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, OptionT<TValue>>;
-    /** Convert Err to Some, Ok to None. `Result<TValue, TError> → Option<TError>` */
-    readonly toOptionErr: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, OptionT<TError>>;
-    /**
-     * Swap Result/Option nesting.
-     * `Result<Option<TValue>, TError> → Option<Result<TValue, TError>>`
-     */
-    readonly transpose: <TValue, TError>() => TypedAction<ResultT<OptionT<TValue>, TError>, OptionT<ResultT<TValue, TError>>>;
-    /** Test if the value is Ok. `Result<TValue, TError> → boolean` */
-    readonly isOk: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, boolean>;
-    /** Test if the value is Err. `Result<TValue, TError> → boolean` */
-    readonly isErr: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, boolean>;
-    /**
-     * Build a Zod schema for `Result<TValue, TError>`.
-     *
-     * ```ts
-     * const schema = Result.schema(z.string(), z.number());
-     * // validates: { kind: "Ok", value: "hello" } or { kind: "Err", value: 42 }
-     * ```
-     */
-    readonly schema: <TValue, TError>(okSchema: z.ZodType<TValue>, errSchema: z.ZodType<TError>) => z.ZodType<ResultT<TValue, TError>>;
-};
 export {};