@barnum/barnum 0.2.3 → 0.4.0

package/dist/recursive.js

@@ -0,0 +1,58 @@
+import { toAction, typedAction, branch, } from "./ast.js";
+import { all } from "./all.js";
+import { chain } from "./chain.js";
+import { constant, identity, getField, getIndex, tag, } from "./builtins/index.js";
+import { allocateResumeHandlerId } from "./effect-id.js";
+const UNUSED_STATE = null;
+// ---------------------------------------------------------------------------
+// defineRecursiveFunctions
+// ---------------------------------------------------------------------------
+/**
+ * Define mutually recursive functions that can call each other.
+ *
+ * The type parameter is an array of [In, Out] tuples — one per function.
+ * TypeScript can't infer these from circular definitions, so they must be
+ * explicit.
+ *
+ * Returns a curried combinator: the first callback defines function bodies,
+ * the second receives the same call tokens and returns the workflow entry
+ * point.
+ *
+ * Desugars to a ResumeHandle with a Branch-based handler. Each call token
+ * 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();
+    const resumePerform = {
+        kind: "ResumePerform",
+        resume_handler_id: resumeHandlerId,
+    };
+    // 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)))));
+    // Get function body ASTs
+    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}`] = toAction(chain(toAction(getField("value")), toAction(bodyActions[i])));
+    }
+    // Return curried entry-point combinator
+    return (entryFn) => {
+        const userBody = toAction(entryFn(...callTokens));
+        return typedAction(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))),
+        })));
+    };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Workflow execution: resolves the barnum binary, tsx executor, and worker
+ * script, then spawns the workflow as a subprocess.
+ */
+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, 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

@@ -0,0 +1,160 @@
+/**
+ * Workflow execution: resolves the barnum binary, tsx executor, and worker
+ * script, then spawns the workflow as a subprocess.
+ */
+import { execFileSync, spawn as nodeSpawn } from "node:child_process";
+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/index.js";
+const __dirname = import.meta.dirname;
+/** Resolve the TypeScript executor. Uses bun if the workflow was launched with bun, otherwise tsx. */
+function resolveExecutor() {
+    if (process.versions.bun) {
+        return "bun";
+    }
+    const callerRequire = createRequire(process.argv[1] || import.meta.url);
+    const tsxPath = callerRequire.resolve("tsx/cli");
+    return `node ${tsxPath}`;
+}
+/** Resolve the platform-specific binary from the @barnum/barnum package artifacts. */
+function resolveInstalledBinary() {
+    const platform = os.platform();
+    const arch = os.arch();
+    let artifactDir;
+    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;
+    }
+    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;
+        }
+    }
+    catch {
+        // Package not installed
+    }
+    return undefined;
+}
+/** Resolve the barnum binary. Checks: BARNUM env var, local repo, node_modules. */
+function resolveBinary() {
+    if (process.env.BARNUM) {
+        return { kind: "Env", path: process.env.BARNUM };
+    }
+    const repoRoot = path.resolve(__dirname, "../../..");
+    if (existsSync(path.join(repoRoot, "Cargo.toml"))) {
+        return {
+            kind: "Local",
+            path: path.join(repoRoot, "target/debug/barnum"),
+        };
+    }
+    const installedBinaryPath = resolveInstalledBinary();
+    if (installedBinaryPath) {
+        return { kind: "NodeModules", path: installedBinaryPath };
+    }
+    throw new Error("Could not find barnum binary. Set BARNUM env var or install @barnum/barnum.");
+}
+/** Resolve worker.ts relative to this package. */
+function resolveWorker() {
+    return path.resolve(__dirname, "../src/worker.ts");
+}
+/** 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: "inherit",
+    });
+}
+/** Run a pipeline to completion. Returns the workflow's final output value. */
+export function runPipeline(pipeline, input, options) {
+    const workflow = input === undefined
+        ? pipeline
+        : 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, logLevel) {
+    const binaryResolution = resolveBinary();
+    if (binaryResolution.kind === "Local") {
+        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, 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) {
+                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();
+            if (!stdout) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch {
+                reject(new Error(`barnum produced non-JSON output on stdout: ${stdout}`));
+            }
+        });
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { JSONSchema7 } from "json-schema";
+import { type z } from "zod";
+/**
+ * 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 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/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/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

@@ -0,0 +1,24 @@
+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, GetIndex(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>;
+//# 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

@@ -0,0 +1,37 @@
+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
+// ---------------------------------------------------------------------------
+/**
+ * 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, GetIndex(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(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 };
+}