@barnum/barnum 0.0.0-main-330fcf0a → 0.0.0-main-ef6df91f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barnum/barnum",
-  "version": "0.0.0-main-330fcf0a",
+  "version": "0.0.0-main-ef6df91f",
   "description": "Barnum workflow engine",
   "type": "module",
   "main": "dist/index.js",

package/src/ast.ts

@@ -1089,7 +1089,7 @@ export class RunnableConfig<Out = any> {
     // Dynamic import to avoid pulling in Node.js APIs at module load time
     // (keeps ast.ts importable in non-Node environments for type checking).
     const { run } = await import("./run.js");
-    run(this.toJSON());
+    await run(this.toJSON());
   }
 
   /** Serialize to the same shape as Config. */

package/src/bind.ts

@@ -131,7 +131,7 @@ export function bind<TBindings extends Action[], TOut>(
   }
 
   // 5. All(...bindings, identity()) → nested Handles
-  const allActions = [...bindings.map((b) => b as Action), identity() as Action];
+  const allActions = [...bindings.map((b) => b as Action), identity as Action];
   return typedAction({
     kind: "Chain",
     first: { kind: "All", actions: allActions },
@@ -156,7 +156,7 @@ export function bind<TBindings extends Action[], TOut>(
 export function bindInput<TIn, TOut = any>(
   body: (input: VarRef<TIn>) => BodyResult<TOut>,
 ): TypedAction<TIn, TOut> {
-  return bind([identity<TIn>()], ([input]) =>
+  return bind([identity], ([input]) =>
     pipe(drop, body(input)),
   );
 }

package/src/builtins.ts

@@ -23,12 +23,10 @@ export function constant<TValue>(value: TValue): TypedAction<any, TValue> {
 // Identity — pass input through unchanged
 // ---------------------------------------------------------------------------
 
-export function identity<TValue>(): TypedAction<TValue, TValue> {
-  return typedAction({
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-  });
-}
+export const identity: TypedAction<any, any> = typedAction({
+  kind: "Invoke",
+  handler: { kind: "Builtin", builtin: { kind: "Identity" } },
+});
 
 // ---------------------------------------------------------------------------
 // Drop — discard pipeline value
@@ -200,7 +198,7 @@ export function withResource<
   const acquireAndMerge = chain(
     typedAction<TIn, [TResource, TIn]>({
       kind: "All",
-      actions: [create as Action, identity() as Action],
+      actions: [create as Action, identity as Action],
     }),
     typedAction<[TResource, TIn], TResource & TIn>(mergeBuiltin),
   );
@@ -209,7 +207,7 @@ export function withResource<
   // Keep merged object so dispose can access resource fields.
   const actionAndKeepMerged = typedAction<TResource & TIn, [TOut, TResource & TIn]>({
     kind: "All",
-    actions: [action as Action, identity() as Action],
+    actions: [action as Action, identity as Action],
   });
 
   // Step 3: all(extractIndex(0), chain(extractIndex(1), dispose)) → [TOut, unknown]
@@ -257,7 +255,7 @@ export function augment<
     kind: "Chain",
     first: {
       kind: "All",
-      actions: [action as Action, identity() as Action],
+      actions: [action as Action, identity as Action],
     },
     rest: { kind: "Invoke", handler: { kind: "Builtin", builtin: { kind: "Merge" } } },
   });

package/src/pipe.ts

@@ -113,7 +113,7 @@ export function pipe<
 ): TypedAction<PipeIn<T1>, T11, R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9 | R10>;
 export function pipe(...actions: Action[]): Action {
   if (actions.length === 0) {
-    return identity();
+    return identity;
   }
   if (actions.length === 1) {
     return actions[0];

package/src/run.ts

@@ -3,7 +3,7 @@
  * script, then spawns the workflow as a subprocess.
  */
 
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import os from "node:os";
@@ -90,7 +90,7 @@ function buildBinary(): void {
 }
 
 /** Run a workflow config to completion. Prints result to stdout. */
-export function run(config: Config): void {
+export async function run(config: Config): Promise<void> {
   const binaryResolution = resolveBinary();
   if (binaryResolution.kind === "Local") {
     buildBinary();
@@ -99,10 +99,37 @@ export function run(config: Config): void {
   const worker = resolveWorker();
   const configJson = JSON.stringify(config);
 
-  execFileSync(binaryResolution.path, [
-    "run",
-    "--config", configJson,
-    "--executor", executor,
-    "--worker", worker,
-  ], { stdio: "inherit" });
+  return new Promise<void>((resolve, reject) => {
+    const child = nodeSpawn(binaryResolution.path, [
+      "run",
+      "--config", configJson,
+      "--executor", executor,
+      "--worker", worker,
+    ], {
+      stdio: ["inherit", "inherit", "pipe"],
+    });
+
+    const stderrChunks: Buffer[] = [];
+
+    child.stderr!.on("data", (chunk: Buffer) => {
+      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) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        const message = stderr
+          ? `barnum exited with code ${code}:\n${stderr}`
+          : `barnum exited with code ${code} (no stderr output)`;
+        reject(new Error(message));
+        return;
+      }
+      resolve();
+    });
+  });
 }