@barnum/barnum 0.0.0-main-ef6df91f → 0.0.0-main-e8b82cff

package/src/run.ts

@@ -9,12 +9,17 @@ import { existsSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { Config } from "./ast.js";
+import type { Action, Config, Pipeable } from "./ast.js";
+import { chain } from "./chain.js";
+import { constant } from "./builtins.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-/** Resolve the tsx executor from the caller's node_modules. */
+/** Resolve the TypeScript executor. Uses bun if the workflow was launched with bun, otherwise tsx. */
 function resolveExecutor(): string {
+  if (process.versions.bun) {
+    return "bun";
+  }
   const callerRequire = createRequire(process.argv[1] || import.meta.url);
   const tsxPath = callerRequire.resolve("tsx/cli");
   return `node ${tsxPath}`;
@@ -28,18 +33,35 @@ function resolveInstalledBinary(): string | undefined {
   let artifactDir: string;
   let binaryName = "barnum";
 
-  if (platform === "darwin" && arch === "arm64") artifactDir = "macos-arm64";
-  else if (platform === "darwin") artifactDir = "macos-x64";
-  else if (platform === "linux" && arch === "arm64") artifactDir = "linux-arm64";
-  else if (platform === "linux") artifactDir = "linux-x64";
-  else if (platform === "win32") { artifactDir = "win-x64"; binaryName = "barnum.exe"; }
-  else return undefined;
+  if (platform === "darwin" && arch === "arm64") {
+    artifactDir = "macos-arm64";
+  } else if (platform === "darwin") {
+    artifactDir = "macos-x64";
+  } else if (platform === "linux" && arch === "arm64") {
+    artifactDir = "linux-arm64";
+  } else if (platform === "linux") {
+    artifactDir = "linux-x64";
+  } else if (platform === "win32") {
+    artifactDir = "win-x64";
+    binaryName = "barnum.exe";
+  } else {
+    return undefined;
+  }
 
   const callerRequire = createRequire(process.argv[1] || import.meta.url);
   try {
-    const packageDir = path.dirname(callerRequire.resolve("@barnum/barnum/package.json"));
-    const binaryPath = path.join(packageDir, "artifacts", artifactDir, binaryName);
-    if (existsSync(binaryPath)) return binaryPath;
+    const packageDir = path.dirname(
+      callerRequire.resolve("@barnum/barnum/package.json"),
+    );
+    const binaryPath = path.join(
+      packageDir,
+      "artifacts",
+      artifactDir,
+      binaryName,
+    );
+    if (existsSync(binaryPath)) {
+      return binaryPath;
+    }
   } catch {
     // Package not installed
   }
@@ -89,8 +111,20 @@ function buildBinary(): void {
   });
 }
 
-/** Run a workflow config to completion. Prints result to stdout. */
-export async function run(config: Config): Promise<void> {
+/** Run a pipeline to completion. Optionally provide input (prepended as a constant node). */
+export async function runPipeline(
+  pipeline: Action,
+  input?: unknown,
+): Promise<void> {
+  const workflow =
+    input === undefined
+      ? pipeline
+      : (chain(constant(input) as Pipeable, pipeline as Pipeable) as Action);
+  await spawnBarnum({ workflow });
+}
+
+/** Spawn the barnum CLI with the given config. */
+function spawnBarnum(config: Config): Promise<void> {
   const binaryResolution = resolveBinary();
   if (binaryResolution.kind === "Local") {
     buildBinary();
@@ -100,18 +134,25 @@ export async function run(config: Config): Promise<void> {
   const configJson = JSON.stringify(config);
 
   return new Promise<void>((resolve, reject) => {
-    const child = nodeSpawn(binaryResolution.path, [
-      "run",
-      "--config", configJson,
-      "--executor", executor,
-      "--worker", worker,
-    ], {
-      stdio: ["inherit", "inherit", "pipe"],
-    });
+    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) => {
+    child.stderr?.on("data", (chunk: Buffer) => {
       stderrChunks.push(chunk);
       process.stderr.write(chunk);
     });
@@ -122,7 +163,7 @@ export async function run(config: Config): Promise<void> {
 
     child.on("close", (code) => {
       if (code !== 0) {
-        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
         const message = stderr
           ? `barnum exited with code ${code}:\n${stderr}`
           : `barnum exited with code ${code} (no stderr output)`;

package/src/schema.ts

@@ -0,0 +1,118 @@
+import type { JSONSchema7 } from "json-schema";
+import { type z, toJSONSchema } from "zod";
+
+// Zod v4 schema def types that have child schemas.
+// Verified against Zod 4.3.6 internals — every compound type's def
+// shape and child property name is listed here.
+const CHILD_ACCESSORS: Record<string, (def: any) => z.ZodType[]> = {
+  object: (def) => Object.values(def.shape),
+  array: (def) => [def.element],
+  tuple: (def) => [...def.items, ...(def.rest ? [def.rest] : [])],
+  union: (def) => def.options,
+  intersection: (def) => [def.left, def.right],
+  record: (def) => [def.keyType, def.valueType],
+  // Wrappers with a single inner type
+  nullable: (def) => [def.innerType],
+  optional: (def) => [def.innerType],
+  nonoptional: (def) => [def.innerType],
+  default: (def) => [def.innerType],
+  catch: (def) => [def.innerType],
+  readonly: (def) => [def.innerType],
+  promise: (def) => [def.innerType],
+  // Pipe has two children
+  pipe: (def) => [def.in, def.out],
+  // Lazy resolves to inner schema
+  lazy: (def) => [def.getter()],
+};
+
+/**
+ * Walk the Zod schema tree and reject patterns that `toJSONSchema()`
+ * handles incorrectly or silently drops:
+ *
+ * - `z.intersection()` — produces `allOf` with `additionalProperties: false`
+ *   on both sides (from `io: "output"`), making the intersection unmatchable
+ *   on Draft 7.
+ *
+ * - `.refine()` / `.superRefine()` — silently stripped from JSON Schema
+ *   output, so the Rust side would accept values that fail the refinement.
+ *   Detected by checking for custom checks (`check._zod.def.check === "custom"`)
+ *   in the schema's checks array.
+ */
+function assertNoUnsupportedPatterns(
+  schema: z.ZodType,
+  label: string,
+  visited = new WeakSet<z.ZodType>(),
+): void {
+  if (visited.has(schema)) {
+    return;
+  }
+  visited.add(schema);
+
+  const def = (schema as any)._zod.def;
+
+  // Reject intersections
+  if (def.type === "intersection") {
+    throw new Error(
+      `Handler "${label}": z.intersection() is not supported. ` +
+        `It produces broken JSON Schema on Draft 7 because both sides ` +
+        `get additionalProperties: false. Use z.object().extend() or ` +
+        `z.object().merge() instead.`,
+    );
+  }
+
+  // Reject custom checks (from .refine() and .superRefine())
+  const checks: any[] | undefined = def.checks;
+  if (checks) {
+    for (const check of checks) {
+      if (check._zod.def.check === "custom") {
+        throw new Error(
+          `Handler "${label}": .refine() and .superRefine() are not ` +
+            `supported. Custom validations cannot be expressed in JSON ` +
+            `Schema and would be silently dropped.`,
+        );
+      }
+    }
+  }
+
+  // Recurse into children
+  const getChildren = CHILD_ACCESSORS[def.type];
+  if (getChildren) {
+    for (const child of getChildren(def)) {
+      assertNoUnsupportedPatterns(child, label, visited);
+    }
+  }
+}
+
+/**
+ * Convert a Zod schema to a JSON Schema document suitable for embedding
+ * in the serialized AST. Throws if the schema contains types that can't
+ * survive the TS → JSON → Rust boundary.
+ */
+export function zodToCheckedJsonSchema(
+  schema: z.ZodType,
+  label: string,
+): JSONSchema7 {
+  // Pre-validate: catch patterns that toJSONSchema() handles incorrectly
+  assertNoUnsupportedPatterns(schema, label);
+
+  let raw: Record<string, unknown>;
+  try {
+    raw = toJSONSchema(schema, {
+      target: "draft-07",
+      unrepresentable: "throw",
+      io: "output",
+      cycles: "throw",
+      reused: "inline",
+    }) as Record<string, unknown>;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Handler "${label}": Zod schema cannot be converted to JSON Schema: ${message}`,
+      { cause: error },
+    );
+  }
+
+  // Strip $schema — embedded schemas don't need the draft URI.
+  const { $schema: _, ...rest } = raw;
+  return rest as JSONSchema7;
+}

package/src/try-catch.ts

@@ -1,54 +1,53 @@
-import { type Action, type Pipeable, type TypedAction, typedAction } from "./ast.js";
-import { allocateEffectId } from "./effect-id.js";
+import {
+  type Action,
+  type Pipeable,
+  type TypedAction,
+  typedAction,
+  buildRestartBranchAction,
+  TAG_BREAK,
+} from "./ast.js";
+import { allocateRestartHandlerId } from "./effect-id.js";
 
 // ---------------------------------------------------------------------------
-// tryCatch — type-level error handling via Handle/Perform
+// tryCatch — type-level error handling via restart+Branch
 // ---------------------------------------------------------------------------
 
 /**
  * HOAS combinator for type-level error handling. The body callback receives
  * a `throwError` token — a `TypedAction<TError, never>` that, when placed
- * in the pipeline, causes the Handle frame to discard the continuation and
- * run the recovery branch with the error payload.
+ * in the pipeline, tags the error as Break, performs to the handler, which
+ * restarts the body. The body-level Branch routes to the recovery arm.
  *
  * This handles **type-level errors only** — values returned by handlers via
  * the `Result` type. If a handler panics, throws a JavaScript exception, or
  * the runtime crashes, the existing error propagation path handles it.
  * tryCatch does not catch those. Analogous to Rust's `Result` vs `panic!`.
  *
- * Compiles to:
- *   Handle(effectId, handlerDag, body)
+ * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
+ *   `Chain(Tag("Continue"),`
+ *     `RestartHandle(id, ExtractIndex(0),`
+ *       `Branch({ Continue: body, Break: recovery })))`
  *
- * Handler DAG:
- *   Chain(ExtractField("payload"), Chain(recovery, Tag("Discard")))
+ * throwError = `Chain(Tag("Break"), RestartPerform(id))`
  *
- * The handler extracts the error payload, runs recovery, and tags the result
- * as Discard — the Handle frame tears down the body and exits with recovery's
- * result.
+ * When throwError fires: error tagged Break → `RestartPerform` → handler extracts
+ * payload → body restarts → Branch takes Break arm → recovery receives error.
  */
 export function tryCatch<TIn, TOut, TError>(
   body: (throwError: TypedAction<TError, never>) => Pipeable<TIn, TOut>,
   recovery: Pipeable<TError, TOut>,
 ): TypedAction<TIn, TOut> {
-  const effectId = allocateEffectId();
-  const throwError = typedAction<TError, never>({ kind: "Perform", effect_id: effectId });
-  const bodyAction = body(throwError) as Action;
+  const restartHandlerId = allocateRestartHandlerId();
 
-  const handlerDag: Action = {
+  const throwError = typedAction<TError, never>({
     kind: "Chain",
-    first: { kind: "Invoke", handler: { kind: "Builtin", builtin: { kind: "ExtractField", value: "payload" } } },
-    rest: {
-      kind: "Chain",
-      first: recovery as Action,
-      rest: { kind: "Invoke", handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Discard" } } },
-    },
-  };
-
-  return typedAction({
-    kind: "Handle",
-    effect_id: effectId,
-    handler: handlerDag,
-    body: bodyAction,
+    first: TAG_BREAK,
+    rest: { kind: "RestartPerform", restart_handler_id: restartHandlerId },
   });
-}
 
+  const bodyAction = body(throwError) as Action;
+
+  return typedAction(
+    buildRestartBranchAction(restartHandlerId, bodyAction, recovery as Action),
+  );
+}

package/src/worker.ts

@@ -9,6 +9,15 @@
  * process exits non-zero. Rust interprets that as a fatal workflow error.
  */
 
+// Suppress EPIPE — when the Rust binary exits (e.g., a race was resolved),
+// orphan workers get broken pipe on stdout. This is expected, not an error.
+process.stdout.on("error", (error: NodeJS.ErrnoException) => {
+  if (error.code === "EPIPE") {
+    process.exit(0);
+  }
+  throw error;
+});
+
 async function main(): Promise<void> {
   const [modulePath, exportName = "default"] = process.argv.slice(2);
 
@@ -38,7 +47,7 @@ async function main(): Promise<void> {
   const result = await handler.__definition.handle({ value: input.value });
 
   // Write result to stdout
-  process.stdout.write(JSON.stringify(result));
+  process.stdout.write(JSON.stringify(result) ?? "null");
 }
 
 main().catch((error) => {