@barnum/barnum 0.2.3 → 0.3.0

package/dist/schema.js

@@ -0,0 +1,95 @@
+import { 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 = {
+    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, label, visited = new WeakSet()) {
+    if (visited.has(schema)) {
+        return;
+    }
+    visited.add(schema);
+    const def = schema._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 = 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, label) {
+    // Pre-validate: catch patterns that toJSONSchema() handles incorrectly
+    assertNoUnsupportedPatterns(schema, label);
+    let raw;
+    try {
+        raw = toJSONSchema(schema, {
+            target: "draft-07",
+            unrepresentable: "throw",
+            io: "output",
+            cycles: "throw",
+            reused: "inline",
+        });
+    }
+    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;
+}

package/dist/try-catch.d.ts

@@ -0,0 +1,23 @@
+import { type Pipeable, type TypedAction } from "./ast.js";
+/**
+ * HOAS combinator for type-level error handling. The body callback receives
+ * a `throwError` token — a `TypedAction<TError, never>` that, when placed
+ * 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!`.
+ *
+ * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
+ *   `Chain(Tag("Continue"),`
+ *     `RestartHandle(id, ExtractIndex(0),`
+ *       `Branch({ Continue: body, Break: recovery })))`
+ *
+ * throwError = `Chain(Tag("Break"), RestartPerform(id))`
+ *
+ * When throwError fires: error tagged Break → `RestartPerform` → handler extracts
+ * 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>;

package/dist/try-catch.js

@@ -0,0 +1,36 @@
+import { typedAction, buildRestartBranchAction, TAG_BREAK, } from "./ast.js";
+import { allocateRestartHandlerId } from "./effect-id.js";
+// ---------------------------------------------------------------------------
+// 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, 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!`.
+ *
+ * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
+ *   `Chain(Tag("Continue"),`
+ *     `RestartHandle(id, ExtractIndex(0),`
+ *       `Branch({ Continue: body, Break: recovery })))`
+ *
+ * throwError = `Chain(Tag("Break"), RestartPerform(id))`
+ *
+ * When throwError fires: error tagged Break → `RestartPerform` → handler extracts
+ * payload → body restarts → Branch takes Break arm → recovery receives error.
+ */
+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));
+}

package/dist/worker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Worker script: invoked as `tsx worker.ts <module> <export>`.
+ *
+ * Protocol:
+ *   Rust → stdin:  JSON `{ "value": <any> }`
+ *   stdout → Rust: JSON result (handler return value)
+ *
+ * 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>;

package/dist/worker.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Worker script: invoked as `tsx worker.ts <module> <export>`.
+ *
+ * Protocol:
+ *   Rust → stdin:  JSON `{ "value": <any> }`
+ *   stdout → Rust: JSON result (handler return value)
+ *
+ * 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.
+ */
+// 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) => {
+    if (error.code === "EPIPE") {
+        process.exit(0);
+    }
+    throw error;
+});
+async function main() {
+    const [modulePath, exportName = "default"] = process.argv.slice(2);
+    if (!modulePath) {
+        process.stderr.write("worker: missing module path argument\n");
+        process.exit(1);
+    }
+    // Read entire stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const input = JSON.parse(Buffer.concat(chunks).toString());
+    // Import handler, call it
+    const mod = await import(modulePath);
+    const handler = mod[exportName];
+    if (!handler?.__definition?.handle) {
+        process.stderr.write(`worker: ${modulePath}:${exportName} is not a barnum handler\n`);
+        process.exit(1);
+    }
+    const result = await handler.__definition.handle({ value: input.value });
+    // Write result to stdout
+    process.stdout.write(JSON.stringify(result) ?? "null");
+}
+main().catch((error) => {
+    process.stderr.write(`worker: ${error}\n`);
+    process.exit(1);
+});

package/package.json

@@ -1,10 +1,28 @@
 {
   "name": "@barnum/barnum",
-  "version": "0.2.3",
-  "description": "Barnum CLI - workflow engine for agents.",
-  "main": "index.js",
+  "version": "0.3.0",
+  "description": "Barnum workflow engine",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
   "bin": {
-    "barnum": "cli.js"
+    "barnum": "cli.cjs"
+  },
+  "scripts": {
+    "prepack": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint src/ tests/"
   },
   "author": "Robert Balicki",
   "license": "MIT",
@@ -16,18 +34,24 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "keywords": [
-    "barnum",
-    "ai",
-    "agents",
-    "automation",
-    "cli"
-  ],
   "files": [
-    "index.js",
-    "cli.js",
-    "artifacts/**/*",
-    "barnum-config-schema.json"
+    "dist/**/*",
+    "src/**/*.ts",
+    "cli.cjs",
+    "artifacts/**/*"
   ],
-  "sideEffects": false
+  "sideEffects": false,
+  "devDependencies": {
+    "@oxlint/binding-darwin-arm64": "^1.57.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^25.5.0",
+    "oxlint": "^1.57.0",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
 }

package/src/all.ts

@@ -0,0 +1,89 @@
+import {
+  type Action,
+  type Pipeable,
+  type TypedAction,
+  typedAction,
+} from "./ast.js";
+import { constant } from "./builtins.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function all(): TypedAction<any, []>;
+export function all<In, O1>(a1: Pipeable<In, O1>): TypedAction<In, [O1]>;
+export function all<In, O1, O2>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+): TypedAction<In, [O1, O2]>;
+export function all<In, O1, O2, O3>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+): TypedAction<In, [O1, O2, O3]>;
+export function all<In, O1, O2, O3, O4>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+): TypedAction<In, [O1, O2, O3, O4]>;
+export function all<In, O1, O2, O3, O4, O5>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+): TypedAction<In, [O1, O2, O3, O4, O5]>;
+export function all<In, O1, O2, O3, O4, O5, O6>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+  a9: Pipeable<In, O9>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+  a9: Pipeable<In, O9>,
+  a10: Pipeable<In, O10>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9, O10]>;
+export function all(...actions: Action[]): Action {
+  if (actions.length === 0) {
+    return constant([]);
+  }
+  return typedAction({ kind: "All", actions });
+}