@barnum/barnum 0.0.0-main-cb3a2cd4 → 0.0.0-main-9c142eea

package/src/handler.ts

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
 import type { JSONSchema7 } from "json-schema";
 import type { z } from "zod";
-import { type TypedAction, toAction, typedAction } from "./ast.js";
+import { type TypedAction, typedAction } from "./ast.js";
 import { chain } from "./chain.js";
 import { all } from "./all.js";
 import { constant, identity } from "./builtins/index.js";
@@ -248,7 +248,7 @@ export function createHandlerWithConfig(
   // __definition for the worker to find (the worker imports the module
   // and accesses the named export, which is this function).
   const factory = (config: unknown): TypedAction =>
-    chain(toAction(all(identity(), constant(config))), toAction(invokeAction));
+    chain(all(identity(), constant(config)), invokeAction);
 
   Object.defineProperty(factory, HANDLER_BRAND, {
     value: true,

package/src/iterator.ts

@@ -102,7 +102,7 @@ export const Iterator = {
   ): TypedAction<IteratorT<TIn>, IteratorT<TOut>> {
     return chain(
       toAction(getField("value")),
-      chain(toAction(forEach(action)), Iterator.fromArray<TOut>()),
+      chain(forEach(action), Iterator.fromArray<TOut>()),
     ) as TypedAction<IteratorT<TIn>, IteratorT<TOut>>;
   },
 
@@ -114,7 +114,7 @@ export const Iterator = {
       toAction(getField("value")),
       chain(
         toAction(forEach(chain(action, intoIteratorNormalize))),
-        chain(toAction(flatten()), Iterator.fromArray<TOut>()),
+        chain(flatten<TOut>(), Iterator.fromArray<TOut>()),
       ),
     ) as TypedAction<IteratorT<TIn>, IteratorT<TOut>>;
   },
@@ -178,39 +178,35 @@ export const Iterator = {
     // Use bind + typedAction to bridge VoidToNull<TAcc> → TAcc (TypeScript
     // can't simplify the conditional type for generic TAcc).
     return typedAction<IteratorT<TElement>, TAcc>(
-      toAction(
-        Iterator.collect<TElement>().then(
-          bind([identity<Array<TElement>>()], ([elements]) =>
-            pipe(
-              drop,
-              all(init, elements).then(
-                loop<[TAcc, Array<TElement>], TAcc>((recur, done) => {
-                  const doneTAcc = typedAction<TAcc, never>(toAction(done));
-
-                  return typedAction<[TAcc, Array<TElement>], never>(
-                    toAction(
-                      bindInput<[TAcc, Array<TElement>], never>((state) => {
-                        const [acc, remaining] = state.split();
-
-                        return remaining.splitFirst().branch({
-                          None: acc.then(doneTAcc),
-                          Some: bindInput<[TElement, Array<TElement>], never>(
-                            (headTail) => {
-                              const [head, tail] = headTail.split();
-
-                              return all(acc, head)
-                                .then(body)
-                                .bindInput<never>((newAcc) =>
-                                  all(newAcc, tail).then(recur),
-                                );
-                            },
-                          ),
-                        });
-                      }),
-                    ),
-                  );
-                }),
-              ),
+      Iterator.collect<TElement>().then(
+        bind([identity<Array<TElement>>()], ([elements]) =>
+          pipe(
+            drop,
+            all(init, elements).then(
+              loop<[TAcc, Array<TElement>], TAcc>((recur, done) => {
+                const doneTAcc = typedAction<TAcc, never>(done);
+
+                return typedAction<[TAcc, Array<TElement>], never>(
+                  bindInput<[TAcc, Array<TElement>], never>((state) => {
+                    const [acc, remaining] = state.split();
+
+                    return remaining.splitFirst().branch({
+                      None: acc.then(doneTAcc),
+                      Some: bindInput<[TElement, Array<TElement>], never>(
+                        (headTail) => {
+                          const [head, tail] = headTail.split();
+
+                          return all(acc, head)
+                            .then(body)
+                            .bindInput<never>((newAcc) =>
+                              all(newAcc, tail).then(recur),
+                            );
+                        },
+                      ),
+                    });
+                  }),
+                );
+              }),
             ),
           ),
         ),
@@ -225,10 +221,7 @@ export const Iterator = {
   ): TypedAction<IteratorT<TElement>, IteratorT<TElement>> {
     return chain(
       Iterator.collect<TElement>(),
-      chain(
-        toAction(slice<TElement>(start, end)),
-        Iterator.fromArray<TElement>(),
-      ),
+      chain(slice<TElement>(start, end), Iterator.fromArray<TElement>()),
     );
   },
 

package/src/option.ts

@@ -5,7 +5,6 @@ import {
   type Result as ResultT,
   type TypedAction,
   branch,
-  toAction,
   typedAction,
 } from "./ast.js";
 import { chain } from "./chain.js";
@@ -171,10 +170,10 @@ export function first<TElement>(): TypedAction<
   Array<TElement>,
   OptionT<TElement>
 > {
-  return chain(
-    toAction(splitFirst()),
-    toAction(Option.map(toAction(getIndex(0).unwrap()))),
-  ) as TypedAction<Array<TElement>, OptionT<TElement>>;
+  return chain(splitFirst(), Option.map(getIndex(0).unwrap())) as TypedAction<
+    Array<TElement>,
+    OptionT<TElement>
+  >;
 }
 
 // ---------------------------------------------------------------------------
@@ -192,8 +191,8 @@ export function last<TElement>(): TypedAction<
   Array<TElement>,
   OptionT<TElement>
 > {
-  return chain(
-    toAction(splitLast()),
-    toAction(Option.map(toAction(getIndex(1).unwrap()))),
-  ) as TypedAction<Array<TElement>, OptionT<TElement>>;
+  return chain(splitLast(), Option.map(getIndex(1).unwrap())) as TypedAction<
+    Array<TElement>,
+    OptionT<TElement>
+  >;
 }

package/src/pipe.ts

@@ -1,10 +1,4 @@
-import {
-  type Action,
-  type PipeIn,
-  type Pipeable,
-  type TypedAction,
-  toAction,
-} from "./ast.js";
+import type { Action, PipeIn, Pipeable, TypedAction } from "./ast.js";
 import { chain } from "./chain.js";
 import { identity } from "./builtins/index.js";
 
@@ -1098,7 +1092,5 @@ export function pipe(...actions: Array<Action>): Action {
   if (actions.length === 1) {
     return actions[0];
   }
-  return actions.reduceRight((rest, first) =>
-    toAction(chain(toAction(first), toAction(rest))),
-  );
+  return actions.reduceRight((rest, first) => chain(first, rest));
 }

package/src/race.ts

@@ -4,7 +4,6 @@ import {
   type Result as ResultT,
   type TypedAction,
   buildRestartBranchAction,
-  toAction,
   typedAction,
 } from "./ast.js";
 import { chain } from "./chain.js";
@@ -21,12 +20,10 @@ import {
  * restarts the body; Branch takes the Break arm (identity), `RestartHandle` exits.
  */
 function breakPerform(restartHandlerId: RestartHandlerId): Action {
-  return toAction(
-    chain(toAction(tag("Break", "LoopResult")), {
-      kind: "RestartPerform",
-      restart_handler_id: restartHandlerId,
-    }),
-  );
+  return chain(tag("Break", "LoopResult"), {
+    kind: "RestartPerform",
+    restart_handler_id: restartHandlerId,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -57,14 +54,14 @@ export function race<TIn, TOut>(
   const restartHandlerId = allocateRestartHandlerId();
   const perform = breakPerform(restartHandlerId);
 
-  const branches = actions.map((action) =>
-    toAction(chain(toAction(action), toAction(perform))),
+  const branches: Array<Action> = actions.map((action) =>
+    chain(action, perform),
   );
 
   const allAction: Action = { kind: "All", actions: branches };
 
   return typedAction(
-    buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())),
+    buildRestartBranchAction(restartHandlerId, allAction, identity()),
   );
 }
 
@@ -144,30 +141,18 @@ export function withTimeout<TIn, TOut>(
   const restartHandlerId = allocateRestartHandlerId();
   const perform = breakPerform(restartHandlerId);
 
-  // Branch 1: body → Tag("Ok") → Break → RestartPerform
-  const bodyBranch = toAction(
-    chain(
-      toAction(chain(toAction(body), toAction(Result.ok()))),
-      toAction(perform),
-    ),
-  );
+  // Branch 1: body → Ok → Break → RestartPerform
+  const bodyBranch: Action = chain(chain(body, Result.ok()), 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),
-    ),
+  // Branch 2: ms → sleep() → Err → Break → RestartPerform
+  const sleepBranch: Action = chain(
+    chain(chain(ms, DYNAMIC_SLEEP_INVOKE), Result.err()),
+    perform,
   );
 
   const allAction: Action = { kind: "All", actions: [bodyBranch, sleepBranch] };
 
   return typedAction(
-    buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())),
+    buildRestartBranchAction(restartHandlerId, allAction, identity()),
   );
 }

package/src/recursive.ts

@@ -73,49 +73,34 @@ export function defineRecursiveFunctions<TDefs extends Array<FunctionDef>>(
   // Call tokens: Chain(Tag("CallN"), ResumePerform(resumeHandlerId))
   const fnCount = bodiesFn.length;
   const callTokens = Array.from({ length: fnCount }, (_, i) =>
-    typedAction(
-      toAction(
-        chain(
-          toAction(tag(`Call${i}`, "RecursiveDispatch")),
-          toAction(resumePerform),
-        ),
-      ),
-    ),
+    typedAction(chain(tag(`Call${i}`, "RecursiveDispatch"), resumePerform)),
   );
 
   // Get function body ASTs
-  const bodyActions = (
-    bodiesFn(...(callTokens as FunctionRefs<TDefs>)) as Array<Pipeable>
-  ).map(toAction);
+  const bodyActions: Array<Action> = bodiesFn(
+    ...(callTokens as FunctionRefs<TDefs>),
+  ) as Array<Pipeable>;
 
   // Branch cases: CallN → GetField("value") → bodyN
   const cases: Record<string, Action> = {};
   for (let i = 0; i < bodyActions.length; i++) {
-    cases[`Call${i}`] = toAction(
-      chain(toAction(getField("value")), toAction(bodyActions[i])),
-    );
+    cases[`Call${i}`] = chain(getField("value"), bodyActions[i]);
   }
 
   // Return curried entry-point combinator
   return <TOut>(entryFn: (...fns: FunctionRefs<TDefs>) => BodyResult<TOut>) => {
-    const userBody = toAction(entryFn(...(callTokens as FunctionRefs<TDefs>)));
+    const userBody: Action = entryFn(...(callTokens as FunctionRefs<TDefs>));
 
     return typedAction<any, TOut>(
-      toAction(
-        chain(toAction(all(identity(), constant(UNUSED_STATE))), {
-          kind: "ResumeHandle",
-          resume_handler_id: resumeHandlerId,
-          body: toAction(
-            chain(toAction(getIndex(0).unwrap()), toAction(userBody)),
-          ),
-          handler: toAction(
-            all(
-              chain(toAction(getIndex(0).unwrap()), toAction(branch(cases))),
-              constant(UNUSED_STATE),
-            ),
-          ),
-        }),
-      ),
+      chain(all(identity(), constant(UNUSED_STATE)), {
+        kind: "ResumeHandle",
+        resume_handler_id: resumeHandlerId,
+        body: chain(toAction(getIndex(0).unwrap()), userBody),
+        handler: all(
+          chain(toAction(getIndex(0).unwrap()), branch(cases)),
+          constant(UNUSED_STATE),
+        ),
+      }),
     );
   };
 }

package/src/run.ts

@@ -8,12 +8,7 @@ import { createRequire } from "node:module";
 import { existsSync, mkdtempSync, unlinkSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import {
-  type Action,
-  type Config,
-  type ExtractOutput,
-  toAction,
-} from "./ast.js";
+import type { Action, Config, ExtractOutput } from "./ast.js";
 import { chain } from "./chain.js";
 import { constant } from "./builtins/index.js";
 
@@ -135,9 +130,7 @@ export function runPipeline<TPipeline extends Action>(
   options?: RunPipelineOptions,
 ): Promise<ExtractOutput<TPipeline>> {
   const workflow =
-    input === undefined
-      ? pipeline
-      : toAction(chain(toAction(constant(input)), toAction(pipeline)));
+    input === undefined ? pipeline : chain(constant(input), pipeline);
   return spawnBarnum({ workflow }, options?.logLevel);
 }
 

package/src/try-catch.ts

@@ -1,8 +1,8 @@
 import {
+  type Action,
   type Pipeable,
   type TypedAction,
   buildRestartBranchAction,
-  toAction,
   typedAction,
 } from "./ast.js";
 import { chain } from "./chain.js";
@@ -41,17 +41,15 @@ export function tryCatch<TIn, TOut, TError>(
   const restartHandlerId = allocateRestartHandlerId();
 
   const throwError = typedAction<TError, never>(
-    toAction(
-      chain(toAction(tag("Break", "LoopResult")), {
-        kind: "RestartPerform",
-        restart_handler_id: restartHandlerId,
-      }),
-    ),
+    chain(tag("Break", "LoopResult"), {
+      kind: "RestartPerform",
+      restart_handler_id: restartHandlerId,
+    }),
   );
 
-  const bodyAction = toAction(body(throwError));
+  const bodyAction: Action = body(throwError);
 
   return typedAction(
-    buildRestartBranchAction(restartHandlerId, bodyAction, toAction(recovery)),
+    buildRestartBranchAction(restartHandlerId, bodyAction, recovery),
   );
 }