@barnum/barnum 0.3.0 → 0.4.0

package/dist/race.js

@@ -1,27 +1,18 @@
-import { typedAction, buildRestartBranchAction, TAG_BREAK, IDENTITY, } from "./ast.js";
+import { toAction, typedAction, buildRestartBranchAction, } from "./ast.js";
+import { chain } from "./chain.js";
+import { identity, tag } from "./builtins/index.js";
+import { Result } from "./result.js";
 import { allocateRestartHandlerId, } from "./effect-id.js";
-// ---------------------------------------------------------------------------
-// Shared AST fragments
-// ---------------------------------------------------------------------------
-const TAG_OK = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Ok" } },
-};
-const TAG_ERR = {
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Err" } },
-};
 /**
  * `Chain(Tag("Break"), RestartPerform(id))` — shared by race branches.
  * The winning branch tags its result as Break, then performs. The handler
  * restarts the body; Branch takes the Break arm (identity), `RestartHandle` exits.
  */
 function breakPerform(restartHandlerId) {
-    return {
-        kind: "Chain",
-        first: TAG_BREAK,
-        rest: { kind: "RestartPerform", restart_handler_id: restartHandlerId },
-    };
+    return toAction(chain(toAction(tag("Break", "LoopResult")), {
+        kind: "RestartPerform",
+        restart_handler_id: restartHandlerId,
+    }));
 }
 // ---------------------------------------------------------------------------
 // race — first branch to complete wins, losers cancelled
@@ -35,7 +26,7 @@ function breakPerform(restartHandlerId) {
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({`
  *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
  *         `Break: identity,`
@@ -47,13 +38,9 @@ function breakPerform(restartHandlerId) {
 export function race(...actions) {
     const restartHandlerId = allocateRestartHandlerId();
     const perform = breakPerform(restartHandlerId);
-    const branches = actions.map((action) => ({
-        kind: "Chain",
-        first: action,
-        rest: perform,
-    }));
+    const branches = actions.map((action) => toAction(chain(toAction(action), toAction(perform))));
     const allAction = { kind: "All", actions: branches };
-    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, IDENTITY));
+    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())));
 }
 // ---------------------------------------------------------------------------
 // sleep — Rust builtin that delays for a fixed duration (passthrough)
@@ -69,7 +56,7 @@ export function race(...actions) {
 export function sleep(ms) {
     return typedAction({
         kind: "Invoke",
-        handler: { kind: "Builtin", builtin: { kind: "Sleep", value: ms } },
+        handler: { kind: "Builtin", builtin: { kind: "Sleep", ms } },
     });
 }
 // ---------------------------------------------------------------------------
@@ -120,22 +107,10 @@ Object.defineProperty(dynamicSleep, "__definition", {
 export function withTimeout(ms, body) {
     const restartHandlerId = allocateRestartHandlerId();
     const perform = breakPerform(restartHandlerId);
-    // Branch 1: body → Tag("Ok") → Tag("Break") → RestartPerform
-    const bodyBranch = {
-        kind: "Chain",
-        first: { kind: "Chain", first: body, rest: TAG_OK },
-        rest: perform,
-    };
-    // Branch 2: ms → sleep() → Tag("Err") → Tag("Break") → RestartPerform
-    const sleepBranch = {
-        kind: "Chain",
-        first: {
-            kind: "Chain",
-            first: { kind: "Chain", first: ms, rest: DYNAMIC_SLEEP_INVOKE },
-            rest: TAG_ERR,
-        },
-        rest: perform,
-    };
+    // Branch 1: body → Tag("Ok") → Break → RestartPerform
+    const bodyBranch = toAction(chain(toAction(chain(toAction(body), toAction(Result.ok()))), toAction(perform)));
+    // Branch 2: ms → sleep() → Tag("Err") → Break → RestartPerform
+    const sleepBranch = toAction(chain(toAction(chain(toAction(chain(toAction(ms), toAction(DYNAMIC_SLEEP_INVOKE))), toAction(Result.err()))), toAction(perform)));
     const allAction = { kind: "All", actions: [bodyBranch, sleepBranch] };
-    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, IDENTITY));
+    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())));
 }

package/dist/recursive.d.ts

@@ -5,12 +5,11 @@ type FunctionRefs<TDefs extends FunctionDef[]> = {
 };
 /**
  * Constraint for the entry-point callback return type. Only requires the
- * output phantom fields — omits __in and __in_co so that actions with
- * In = never (e.g. pipelines starting from a call token) are assignable.
+ * output phantom field — omits __in and __in_co so that actions with
+ * any input type (e.g. pipelines starting from a call token) are assignable.
  */
 type BodyResult<TOut> = Action & {
     __out?: () => TOut;
-    __out_contra?: (output: TOut) => void;
 };
 /**
  * Define mutually recursive functions that can call each other.
@@ -27,8 +26,15 @@ type BodyResult<TOut> = Action & {
  * is Chain(Tag("CallN"), ResumePerform(id)). The handler dispatches to the
  * correct function body by tag. The caller's pipeline is preserved as a
  * ResumePerformFrame across each call.
+ *
+ * **Known limitation:** concurrent calls to the same function do not work
+ * as expected. `all(f(x), f(x))` will NOT call `f` twice — both branches
+ * perform on the same ResumeHandle, and the second perform will not
+ * execute independently. Use sequential calls (chain/then) instead of
+ * concurrent calls (all) when calling recursive functions multiple times.
  */
 export declare function defineRecursiveFunctions<TDefs extends FunctionDef[]>(bodiesFn: (...fns: FunctionRefs<TDefs>) => {
     [K in keyof TDefs]: Pipeable<TDefs[K][0], TDefs[K][1]>;
 }): <TOut>(entryFn: (...fns: FunctionRefs<TDefs>) => BodyResult<TOut>) => TypedAction<any, TOut>;
 export {};
+//# sourceMappingURL=recursive.d.ts.map

package/dist/recursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursive.d.ts","sourceRoot":"","sources":["../src/recursive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AAgBlB,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAErD,KAAK,YAAY,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI;KAC9C,CAAC,IAAI,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;GAIG;AACH,KAAK,UAAU,CAAC,IAAI,IAAI,MAAM,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,WAAW,EAAE,EAClE,QAAQ,EAAE,CAAC,GAAG,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK;KACxC,CAAC,IAAI,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvD,GACA,CAAC,IAAI,EACN,OAAO,EAAE,CAAC,GAAG,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,KACvD,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAwD1B"}

package/dist/recursive.js

@@ -1,10 +1,9 @@
-import { typedAction, branch, } from "./ast.js";
+import { toAction, typedAction, branch, } from "./ast.js";
 import { all } from "./all.js";
 import { chain } from "./chain.js";
-import { constant, identity, extractField, extractIndex, tag, } from "./builtins.js";
+import { constant, identity, getField, getIndex, tag, } from "./builtins/index.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const UNUSED_STATE = undefined;
+const UNUSED_STATE = null;
 // ---------------------------------------------------------------------------
 // defineRecursiveFunctions
 // ---------------------------------------------------------------------------
@@ -23,6 +22,12 @@ const UNUSED_STATE = undefined;
  * is Chain(Tag("CallN"), ResumePerform(id)). The handler dispatches to the
  * correct function body by tag. The caller's pipeline is preserved as a
  * ResumePerformFrame across each call.
+ *
+ * **Known limitation:** concurrent calls to the same function do not work
+ * as expected. `all(f(x), f(x))` will NOT call `f` twice — both branches
+ * perform on the same ResumeHandle, and the second perform will not
+ * execute independently. Use sequential calls (chain/then) instead of
+ * concurrent calls (all) when calling recursive functions multiple times.
  */
 export function defineRecursiveFunctions(bodiesFn) {
     const resumeHandlerId = allocateResumeHandlerId();
@@ -32,22 +37,22 @@ export function defineRecursiveFunctions(bodiesFn) {
     };
     // Call tokens: Chain(Tag("CallN"), ResumePerform(resumeHandlerId))
     const fnCount = bodiesFn.length;
-    const callTokens = Array.from({ length: fnCount }, (_, i) => typedAction(chain(tag(`Call${i}`), resumePerform)));
+    const callTokens = Array.from({ length: fnCount }, (_, i) => typedAction(toAction(chain(toAction(tag(`Call${i}`, "RecursiveDispatch")), toAction(resumePerform)))));
     // Get function body ASTs
-    const bodyActions = bodiesFn(...callTokens);
-    // Branch cases: CallN → ExtractField("value") → bodyN
+    const bodyActions = bodiesFn(...callTokens).map(toAction);
+    // Branch cases: CallN → GetField("value") → bodyN
     const cases = {};
     for (let i = 0; i < bodyActions.length; i++) {
-        cases[`Call${i}`] = chain(extractField("value"), bodyActions[i]);
+        cases[`Call${i}`] = toAction(chain(toAction(getField("value")), toAction(bodyActions[i])));
     }
     // Return curried entry-point combinator
     return (entryFn) => {
-        const userBody = entryFn(...callTokens);
-        return typedAction(chain(all(identity, constant(UNUSED_STATE)), {
+        const userBody = toAction(entryFn(...callTokens));
+        return typedAction(toAction(chain(toAction(all(identity(), constant(UNUSED_STATE))), {
             kind: "ResumeHandle",
             resume_handler_id: resumeHandlerId,
-            body: chain(extractIndex(0), userBody),
-            handler: all(chain(extractIndex(0), branch(cases)), constant(UNUSED_STATE)),
-        }));
+            body: toAction(chain(toAction(getIndex(0).unwrap()), toAction(userBody))),
+            handler: toAction(all(chain(toAction(getIndex(0).unwrap()), toAction(branch(cases))), constant(UNUSED_STATE))),
+        })));
     };
 }

package/dist/result.d.ts

@@ -0,0 +1,50 @@
+import { type Option as OptionT, type Pipeable, type Result as ResultT, type TypedAction } from "./ast.js";
+export declare const Result: {
+    /** Tag combinator: wrap value as `Result.Ok`. `TValue → Result<TValue, TError>` */
+    readonly ok: <TValue, TError = never>() => TypedAction<TValue, ResultT<TValue, TError>>;
+    /** Tag combinator: wrap value as `Result.Err`. `TError → Result<TValue, TError>` */
+    readonly err: <TValue = never, TError = unknown>() => 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>>;
+    /**
+     * Extract the Ok value or panic. `Result<TValue, TError> → TValue`
+     *
+     * Panics (fatal, not caught by tryCatch) if the value is Err.
+     */
+    readonly unwrap: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, TValue>;
+    /**
+     * Extract Ok or compute default from Err. `Result<TValue, TError> → TValue`
+     */
+    readonly unwrapOr: <TValue, TError>(defaultAction: Pipeable<TError, TValue>) => TypedAction<ResultT<TValue, TError>, TValue>;
+    /**
+     * Convert Ok to Some, Err to None. `Result<TValue, TError> → Option<TValue>`
+     */
+    readonly asOkOption: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, OptionT<TValue>>;
+    /**
+     * Convert Err to Some, Ok to None. `Result<TValue, TError> → Option<TError>`
+     */
+    readonly asErrOption: <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>;
+};
+//# sourceMappingURL=result.d.ts.map

package/dist/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,QAAQ,EACb,KAAK,MAAM,IAAI,OAAO,EAEtB,KAAK,WAAW,EAEjB,MAAM,UAAU,CAAC;AASlB,eAAO,MAAM,MAAM;IACjB,mFAAmF;kBAChF,MAAM,EAAE,MAAM,eAAa,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAG1E,oFAAoF;mBAChF,MAAM,UAAU,MAAM,iBAAe,WAAW,CAClD,MAAM,EACN,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CACxB;IAID,8EAA8E;mBAC1E,MAAM,EAAE,IAAI,EAAE,MAAM,UACd,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,KAC7B,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAO9D,oFAAoF;sBAC7E,MAAM,EAAE,MAAM,EAAE,SAAS,UACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,KAClC,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAOnE;;;OAGG;uBACK,MAAM,EAAE,IAAI,EAAE,MAAM,UAClB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,KAC9C,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAO9D,uEAAuE;kBACpE,MAAM,EAAE,MAAM,EAAE,SAAS,YAChB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,KACrD,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAOnE;;;;OAIG;sBACI,MAAM,EAAE,MAAM,OAAK,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAOtE;;OAEG;wBACM,MAAM,EAAE,MAAM,iBACN,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KACtC,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAO/C;;OAEG;0BACQ,MAAM,EAAE,MAAM,OAAK,WAAW,CACvC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,CAAC,MAAM,CAAC,CAChB;IAOD;;OAEG;2BACS,MAAM,EAAE,MAAM,OAAK,WAAW,CACxC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,CAAC,MAAM,CAAC,CAChB;IAOD;;;OAGG;yBACO,MAAM,EAAE,MAAM,OAAK,WAAW,CACtC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAChC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CACjC;IAmBD;;OAEG;oBACE,MAAM,EAAE,MAAM,OAAK,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAOrE;;OAEG;qBACG,MAAM,EAAE,MAAM,OAAK,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC;CAM9D,CAAC"}

package/dist/result.js

@@ -0,0 +1,117 @@
+import { branch, } from "./ast.js";
+import { chain } from "./chain.js";
+import { constant, drop, identity, panic, tag } from "./builtins/index.js";
+import { Option } from "./option.js";
+// ---------------------------------------------------------------------------
+// Result namespace — combinators for Result<TValue, TError> tagged unions
+// ---------------------------------------------------------------------------
+export const Result = {
+    /** Tag combinator: wrap value as `Result.Ok`. `TValue → Result<TValue, TError>` */
+    ok() {
+        return tag("Ok", "Result");
+    },
+    /** Tag combinator: wrap value as `Result.Err`. `TError → Result<TValue, TError>` */
+    err() {
+        return tag("Err", "Result");
+    },
+    /** Transform the Ok value. `Result<TValue, TError> → Result<TOut, TError>` */
+    map(action) {
+        return branch({
+            Ok: chain(action, Result.ok()),
+            Err: Result.err(),
+        });
+    },
+    /** Transform the Err value. `Result<TValue, TError> → Result<TValue, TErrorOut>` */
+    mapErr(action) {
+        return branch({
+            Ok: Result.ok(),
+            Err: chain(action, Result.err()),
+        });
+    },
+    /**
+     * Monadic bind (flatMap) for Ok. If Ok, pass value to action which
+     * returns Result<TOut, TError>. If Err, propagate.
+     */
+    andThen(action) {
+        return branch({
+            Ok: action,
+            Err: Result.err(),
+        });
+    },
+    /** Fallback on Err. If Ok, keep it. If Err, pass error to fallback. */
+    or(fallback) {
+        return branch({
+            Ok: Result.ok(),
+            Err: fallback,
+        });
+    },
+    /**
+     * Extract the Ok value or panic. `Result<TValue, TError> → TValue`
+     *
+     * Panics (fatal, not caught by tryCatch) if the value is Err.
+     */
+    unwrap() {
+        return branch({
+            Ok: identity(),
+            Err: panic("called unwrap on Err"),
+        });
+    },
+    /**
+     * Extract Ok or compute default from Err. `Result<TValue, TError> → TValue`
+     */
+    unwrapOr(defaultAction) {
+        return branch({
+            Ok: identity(),
+            Err: defaultAction,
+        });
+    },
+    /**
+     * Convert Ok to Some, Err to None. `Result<TValue, TError> → Option<TValue>`
+     */
+    asOkOption() {
+        return branch({
+            Ok: Option.some(),
+            Err: chain(drop, Option.none()),
+        });
+    },
+    /**
+     * Convert Err to Some, Ok to None. `Result<TValue, TError> → Option<TError>`
+     */
+    asErrOption() {
+        return branch({
+            Ok: chain(drop, Option.none()),
+            Err: Option.some(),
+        });
+    },
+    /**
+     * Swap Result/Option nesting.
+     * `Result<Option<TValue>, TError> → Option<Result<TValue, TError>>`
+     */
+    transpose() {
+        return branch({
+            Ok: branch({
+                Some: chain(Result.ok(), Option.some()),
+                None: chain(drop, Option.none()),
+            }),
+            Err: chain(Result.err(), Option.some()),
+        });
+    },
+    /**
+     * Test if the value is Ok. `Result<TValue, TError> → boolean`
+     */
+    isOk() {
+        return branch({
+            Ok: constant(true),
+            Err: constant(false),
+        });
+    },
+    /**
+     * Test if the value is Err. `Result<TValue, TError> → boolean`
+     */
+    isErr() {
+        return branch({
+            Ok: constant(false),
+            Err: constant(true),
+        });
+    },
+};

package/dist/run.d.ts

@@ -2,6 +2,13 @@
  * Workflow execution: resolves the barnum binary, tsx executor, and worker
  * script, then spawns the workflow as a subprocess.
  */
-import type { Action, ExtractOutput } from "./ast.js";
+import { type Action, type ExtractOutput } from "./ast.js";
+/** Log verbosity for the barnum engine runtime. Passed to the CLI's `--log-level`. */
+export type LogLevel = "off" | "error" | "warn" | "info" | "debug" | "trace";
+export interface RunPipelineOptions {
+    /** Engine log verbosity. Default: "off" (only handler stderr is visible). */
+    logLevel?: LogLevel;
+}
 /** Run a pipeline to completion. Returns the workflow's final output value. */
-export declare function runPipeline<TPipeline extends Action>(pipeline: TPipeline, input?: unknown): Promise<ExtractOutput<TPipeline>>;
+export declare function runPipeline<TPipeline extends Action>(pipeline: TPipeline, input?: unknown, options?: RunPipelineOptions): Promise<ExtractOutput<TPipeline>>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EACL,KAAK,MAAM,EAEX,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAC;AAIlB,sFAAsF;AACtF,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAE7E,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAyGD,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,SAAS,SAAS,MAAM,EAClD,QAAQ,EAAE,SAAS,EACnB,KAAK,CAAC,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAMnC"}

package/dist/run.js

@@ -7,8 +7,9 @@ import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { toAction, } from "./ast.js";
 import { chain } from "./chain.js";
-import { constant } from "./builtins.js";
+import { constant } from "./builtins/index.js";
 const __dirname = import.meta.dirname;
 /** Resolve the TypeScript executor. Uses bun if the workflow was launched with bun, otherwise tsx. */
 function resolveExecutor() {
@@ -79,52 +80,68 @@ function resolveBinary() {
 function resolveWorker() {
     return path.resolve(__dirname, "../src/worker.ts");
 }
-/** Build the barnum binary if using the local dev path. */
-function buildBinary() {
+/** Build the barnum binary if using the local dev path. Skips if binary already exists. */
+function buildBinaryIfNeeded(binaryPath) {
+    if (existsSync(binaryPath)) {
+        return;
+    }
     const repoRoot = path.resolve(__dirname, "../../..");
+    // eslint-disable-next-line no-console
+    console.error("[barnum] building CLI binary (cargo build -p barnum_cli)...");
     execFileSync("cargo", ["build", "-p", "barnum_cli"], {
         cwd: repoRoot,
-        stdio: "ignore",
+        stdio: "inherit",
     });
 }
 /** Run a pipeline to completion. Returns the workflow's final output value. */
-export function runPipeline(pipeline, input) {
+export function runPipeline(pipeline, input, options) {
     const workflow = input === undefined
         ? pipeline
-        : chain(constant(input), pipeline);
-    return spawnBarnum({ workflow });
+        : toAction(chain(toAction(constant(input)), toAction(pipeline)));
+    return spawnBarnum({ workflow }, options?.logLevel);
 }
 /** Spawn the barnum CLI with the given config. Returns the parsed final value from stdout. */
-function spawnBarnum(config) {
+function spawnBarnum(config, logLevel) {
     const binaryResolution = resolveBinary();
     if (binaryResolution.kind === "Local") {
-        buildBinary();
+        buildBinaryIfNeeded(binaryResolution.path);
     }
     const executor = resolveExecutor();
     const worker = resolveWorker();
     const configJson = JSON.stringify(config);
+    const cliArgs = [
+        "run",
+        "--config",
+        configJson,
+        "--executor",
+        executor,
+        "--worker",
+        worker,
+    ];
+    if (logLevel) {
+        cliArgs.push("--log-level", logLevel);
+    }
     return new Promise((resolve, reject) => {
-        const child = nodeSpawn(binaryResolution.path, [
-            "run",
-            "--config",
-            configJson,
-            "--executor",
-            executor,
-            "--worker",
-            worker,
-        ], {
-            stdio: ["inherit", "pipe", "inherit"],
+        const child = nodeSpawn(binaryResolution.path, cliArgs, {
+            stdio: ["inherit", "pipe", "pipe"],
         });
         const stdoutChunks = [];
+        const stderrChunks = [];
         child.stdout?.on("data", (chunk) => {
             stdoutChunks.push(chunk);
         });
+        child.stderr?.on("data", (chunk) => {
+            stderrChunks.push(chunk);
+            process.stderr.write(chunk);
+        });
         child.on("error", (error) => {
             reject(new Error(`Failed to spawn barnum: ${error.message}`));
         });
         child.on("close", (code) => {
             if (code !== 0) {
-                reject(new Error(`barnum exited with code ${code}`));
+                const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+                const detail = stderr ? `\n${stderr}` : "";
+                reject(new Error(`barnum exited with code ${code}${detail}`));
                 return;
             }
             const stdout = Buffer.concat(stdoutChunks).toString("utf8").trim();

package/dist/runtime.d.ts

@@ -0,0 +1,6 @@
+export { ok, err, some, none } from "./values.js";
+export { createHandler, createHandlerWithConfig, type Handler, } from "./handler.js";
+export { resultSchema, optionSchema } from "./schemas.js";
+export { taggedUnionSchema } from "./builtins/index.js";
+export type { Result, Option, TaggedUnion } from "./ast.js";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGlD,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,KAAK,OAAO,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,7 @@
+// Runtime value constructors
+export { ok, err, some, none } from "./values.js";
+// Handler creation
+export { createHandler, createHandlerWithConfig, } from "./handler.js";
+// Schema builders
+export { resultSchema, optionSchema } from "./schemas.js";
+export { taggedUnionSchema } from "./builtins/index.js";

package/dist/schema.d.ts

@@ -6,3 +6,4 @@ import { type z } from "zod";
  * survive the TS → JSON → Rust boundary.
  */
 export declare function zodToCheckedJsonSchema(schema: z.ZodType, label: string): JSONSchema7;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,KAAK,CAAC,EAAgB,MAAM,KAAK,CAAC;AAoF3C;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,CAAC,CAAC,OAAO,EACjB,KAAK,EAAE,MAAM,GACZ,WAAW,CAwBb"}

package/dist/schemas.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+import type { Result, Option } from "./ast.js";
+export declare function resultSchema<TValue, TError>(okSchema: z.ZodType<TValue>, errSchema: z.ZodType<TError>): z.ZodType<Result<TValue, TError>>;
+export declare function optionSchema<TValue>(valueSchema: z.ZodType<TValue>): z.ZodType<Option<TValue>>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAE/C,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EACzC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAC3B,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAC3B,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAKnC;AAED,wBAAgB,YAAY,CAAC,MAAM,EACjC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAC7B,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAK3B"}

package/dist/schemas.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export function resultSchema(okSchema, errSchema) {
+    return z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("Result.Ok"), value: okSchema }),
+        z.object({ kind: z.literal("Result.Err"), value: errSchema }),
+    ]);
+}
+export function optionSchema(valueSchema) {
+    return z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("Option.Some"), value: valueSchema }),
+        z.object({ kind: z.literal("Option.None"), value: z.null() }),
+    ]);
+}

package/dist/try-catch.d.ts

@@ -12,7 +12,7 @@ import { type Pipeable, type TypedAction } from "./ast.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({ Continue: body, Break: recovery })))`
  *
  * throwError = `Chain(Tag("Break"), RestartPerform(id))`
@@ -21,3 +21,4 @@ import { type Pipeable, type TypedAction } from "./ast.js";
  * payload → body restarts → Branch takes Break arm → recovery receives error.
  */
 export declare function tryCatch<TIn, TOut, TError>(body: (throwError: TypedAction<TError, never>) => Pipeable<TIn, TOut>, recovery: Pipeable<TError, TOut>): TypedAction<TIn, TOut>;
+//# sourceMappingURL=try-catch.d.ts.map

package/dist/try-catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"try-catch.d.ts","sourceRoot":"","sources":["../src/try-catch.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AASlB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EACxC,IAAI,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,EACrE,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,GAC/B,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAiBxB"}

package/dist/try-catch.js

@@ -1,4 +1,6 @@
-import { typedAction, buildRestartBranchAction, TAG_BREAK, } from "./ast.js";
+import { toAction, typedAction, buildRestartBranchAction, } from "./ast.js";
+import { chain } from "./chain.js";
+import { tag } from "./builtins/index.js";
 import { allocateRestartHandlerId } from "./effect-id.js";
 // ---------------------------------------------------------------------------
 // tryCatch — type-level error handling via restart+Branch
@@ -16,7 +18,7 @@ import { allocateRestartHandlerId } from "./effect-id.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({ Continue: body, Break: recovery })))`
  *
  * throwError = `Chain(Tag("Break"), RestartPerform(id))`
@@ -26,11 +28,10 @@ import { allocateRestartHandlerId } from "./effect-id.js";
  */
 export function tryCatch(body, recovery) {
     const restartHandlerId = allocateRestartHandlerId();
-    const throwError = typedAction({
-        kind: "Chain",
-        first: TAG_BREAK,
-        rest: { kind: "RestartPerform", restart_handler_id: restartHandlerId },
-    });
-    const bodyAction = body(throwError);
-    return typedAction(buildRestartBranchAction(restartHandlerId, bodyAction, recovery));
+    const throwError = typedAction(toAction(chain(toAction(tag("Break", "LoopResult")), {
+        kind: "RestartPerform",
+        restart_handler_id: restartHandlerId,
+    })));
+    const bodyAction = toAction(body(throwError));
+    return typedAction(buildRestartBranchAction(restartHandlerId, bodyAction, toAction(recovery)));
 }

package/dist/values.d.ts

@@ -0,0 +1,6 @@
+import type { Result, Option } from "./ast.js";
+export declare function ok<TValue, TError = unknown>(value: TValue): Result<TValue, TError>;
+export declare function err<TValue = unknown, TError = never>(error: TError): Result<TValue, TError>;
+export declare function some<T>(value: T): Option<T>;
+export declare function none<T = unknown>(): Option<T>;
+//# sourceMappingURL=values.d.ts.map

package/dist/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../src/values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAE/C,wBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EACzC,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAExB;AAED,wBAAgB,GAAG,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,EAClD,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAExB;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAE3C;AAED,wBAAgB,IAAI,CAAC,CAAC,GAAG,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAE7C"}

package/dist/values.js

@@ -0,0 +1,12 @@
+export function ok(value) {
+    return { kind: "Result.Ok", value };
+}
+export function err(error) {
+    return { kind: "Result.Err", value: error };
+}
+export function some(value) {
+    return { kind: "Option.Some", value };
+}
+export function none() {
+    return { kind: "Option.None", value: null };
+}

package/dist/worker.d.ts

@@ -5,7 +5,11 @@
  *   Rust → stdin:  JSON `{ "value": <any> }`
  *   stdout → Rust: JSON result (handler return value)
  *
+ * stdout is reserved for the protocol. All console output is redirected to
+ * stderr so that handler code can freely use console.log for debugging.
+ *
  * If the handler throws or the module/export can't be resolved, the
  * process exits non-zero. Rust interprets that as a fatal workflow error.
  */
-declare function main(): Promise<void>;
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}