@barnum/barnum 0.2.3 → 0.4.0

package/src/result.ts

@@ -0,0 +1,168 @@
+import {
+  type Option as OptionT,
+  type Pipeable,
+  type Result as ResultT,
+  type ResultDef,
+  type TypedAction,
+  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<TValue, TError = never>(): TypedAction<TValue, ResultT<TValue, TError>> {
+    return tag<"Result", ResultDef<TValue, TError>, "Ok">("Ok", "Result");
+  },
+  /** Tag combinator: wrap value as `Result.Err`. `TError → Result<TValue, TError>` */
+  err<TValue = never, TError = unknown>(): TypedAction<
+    TError,
+    ResultT<TValue, TError>
+  > {
+    return tag<"Result", ResultDef<TValue, TError>, "Err">("Err", "Result");
+  },
+
+  /** Transform the Ok value. `Result<TValue, TError> → Result<TOut, TError>` */
+  map<TValue, TOut, TError>(
+    action: Pipeable<TValue, TOut>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>> {
+    return branch({
+      Ok: chain(action, Result.ok<TOut, TError>()),
+      Err: Result.err<TOut, TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
+  },
+
+  /** Transform the Err value. `Result<TValue, TError> → Result<TValue, TErrorOut>` */
+  mapErr<TValue, TError, TErrorOut>(
+    action: Pipeable<TError, TErrorOut>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>> {
+    return branch({
+      Ok: Result.ok<TValue, TErrorOut>(),
+      Err: chain(action, Result.err<TValue, TErrorOut>()),
+    }) as 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.
+   */
+  andThen<TValue, TOut, TError>(
+    action: Pipeable<TValue, ResultT<TOut, TError>>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>> {
+    return branch({
+      Ok: action,
+      Err: Result.err<TOut, TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, ResultT<TOut, TError>>;
+  },
+
+  /** Fallback on Err. If Ok, keep it. If Err, pass error to fallback. */
+  or<TValue, TError, TErrorOut>(
+    fallback: Pipeable<TError, ResultT<TValue, TErrorOut>>,
+  ): TypedAction<ResultT<TValue, TError>, ResultT<TValue, TErrorOut>> {
+    return branch({
+      Ok: Result.ok<TValue, TErrorOut>(),
+      Err: fallback,
+    }) as 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.
+   */
+  unwrap<TValue, TError>(): TypedAction<ResultT<TValue, TError>, TValue> {
+    return branch({
+      Ok: identity<TValue>(),
+      Err: panic("called unwrap on Err"),
+    }) as TypedAction<ResultT<TValue, TError>, TValue>;
+  },
+
+  /**
+   * Extract Ok or compute default from Err. `Result<TValue, TError> → TValue`
+   */
+  unwrapOr<TValue, TError>(
+    defaultAction: Pipeable<TError, TValue>,
+  ): TypedAction<ResultT<TValue, TError>, TValue> {
+    return branch({
+      Ok: identity<TValue>(),
+      Err: defaultAction,
+    }) as TypedAction<ResultT<TValue, TError>, TValue>;
+  },
+
+  /**
+   * Convert Ok to Some, Err to None. `Result<TValue, TError> → Option<TValue>`
+   */
+  asOkOption<TValue, TError>(): TypedAction<
+    ResultT<TValue, TError>,
+    OptionT<TValue>
+  > {
+    return branch({
+      Ok: Option.some<TValue>(),
+      Err: chain(drop, Option.none<TValue>()),
+    }) as TypedAction<ResultT<TValue, TError>, OptionT<TValue>>;
+  },
+
+  /**
+   * Convert Err to Some, Ok to None. `Result<TValue, TError> → Option<TError>`
+   */
+  asErrOption<TValue, TError>(): TypedAction<
+    ResultT<TValue, TError>,
+    OptionT<TError>
+  > {
+    return branch({
+      Ok: chain(drop, Option.none<TError>()),
+      Err: Option.some<TError>(),
+    }) as TypedAction<ResultT<TValue, TError>, OptionT<TError>>;
+  },
+
+  /**
+   * Swap Result/Option nesting.
+   * `Result<Option<TValue>, TError> → Option<Result<TValue, TError>>`
+   */
+  transpose<TValue, TError>(): TypedAction<
+    ResultT<OptionT<TValue>, TError>,
+    OptionT<ResultT<TValue, TError>>
+  > {
+    return branch({
+      Ok: branch({
+        Some: chain(
+          Result.ok<TValue, TError>(),
+          Option.some<ResultT<TValue, TError>>(),
+        ),
+        None: chain(drop, Option.none<ResultT<TValue, TError>>()),
+      }),
+      Err: chain(
+        Result.err<TValue, TError>(),
+        Option.some<ResultT<TValue, TError>>(),
+      ),
+    }) as TypedAction<
+      ResultT<OptionT<TValue>, TError>,
+      OptionT<ResultT<TValue, TError>>
+    >;
+  },
+
+  /**
+   * Test if the value is Ok. `Result<TValue, TError> → boolean`
+   */
+  isOk<TValue, TError>(): TypedAction<ResultT<TValue, TError>, boolean> {
+    return branch({
+      Ok: constant<boolean>(true),
+      Err: constant<boolean>(false),
+    }) as TypedAction<ResultT<TValue, TError>, boolean>;
+  },
+
+  /**
+   * Test if the value is Err. `Result<TValue, TError> → boolean`
+   */
+  isErr<TValue, TError>(): TypedAction<ResultT<TValue, TError>, boolean> {
+    return branch({
+      Ok: constant<boolean>(false),
+      Err: constant<boolean>(true),
+    }) as TypedAction<ResultT<TValue, TError>, boolean>;
+  },
+} as const;

package/src/run.ts

@@ -0,0 +1,209 @@
+/**
+ * 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 {
+  type Action,
+  type Config,
+  type ExtractOutput,
+  toAction,
+} from "./ast.js";
+import { chain } from "./chain.js";
+import { constant } from "./builtins/index.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;
+}
+
+const __dirname = import.meta.dirname;
+
+/** 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}`;
+}
+
+/** Resolve the platform-specific binary from the @barnum/barnum package artifacts. */
+function resolveInstalledBinary(): string | undefined {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  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;
+  }
+
+  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;
+}
+
+type BinaryResolution =
+  | { kind: "Env"; path: string }
+  | { kind: "NodeModules"; path: string }
+  | { kind: "Local"; path: string };
+
+/** Resolve the barnum binary. Checks: BARNUM env var, local repo, node_modules. */
+function resolveBinary(): BinaryResolution {
+  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(): string {
+  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: string): void {
+  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<TPipeline extends Action>(
+  pipeline: TPipeline,
+  input?: unknown,
+  options?: RunPipelineOptions,
+): Promise<ExtractOutput<TPipeline>> {
+  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<TOut>(config: Config, logLevel?: LogLevel): Promise<TOut> {
+  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<TOut>((resolve, reject) => {
+    const child = nodeSpawn(binaryResolution.path, cliArgs, {
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdoutChunks.push(chunk);
+    });
+
+    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("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 as TOut);
+        return;
+      }
+      try {
+        resolve(JSON.parse(stdout) as TOut);
+      } catch {
+        reject(
+          new Error(`barnum produced non-JSON output on stdout: ${stdout}`),
+        );
+      }
+    });
+  });
+}

package/src/runtime.ts

@@ -0,0 +1,16 @@
+// Runtime value constructors
+export { ok, err, some, none } from "./values.js";
+
+// Handler creation
+export {
+  createHandler,
+  createHandlerWithConfig,
+  type Handler,
+} from "./handler.js";
+
+// Schema builders
+export { resultSchema, optionSchema } from "./schemas.js";
+export { taggedUnionSchema } from "./builtins/index.js";
+
+// Types only
+export type { Result, Option, TaggedUnion } from "./ast.js";

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/schemas.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { Result, Option } from "./ast.js";
+
+export function resultSchema<TValue, TError>(
+  okSchema: z.ZodType<TValue>,
+  errSchema: z.ZodType<TError>,
+): z.ZodType<Result<TValue, TError>> {
+  return z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("Result.Ok"), value: okSchema }),
+    z.object({ kind: z.literal("Result.Err"), value: errSchema }),
+  ]) as z.ZodType<Result<TValue, TError>>;
+}
+
+export function optionSchema<TValue>(
+  valueSchema: z.ZodType<TValue>,
+): z.ZodType<Option<TValue>> {
+  return z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("Option.Some"), value: valueSchema }),
+    z.object({ kind: z.literal("Option.None"), value: z.null() }),
+  ]) as z.ZodType<Option<TValue>>;
+}

package/src/try-catch.ts

@@ -0,0 +1,57 @@
+import {
+  type Pipeable,
+  type TypedAction,
+  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<TIn, TOut, TError>(
+  body: (throwError: TypedAction<TError, never>) => Pipeable<TIn, TOut>,
+  recovery: Pipeable<TError, TOut>,
+): TypedAction<TIn, TOut> {
+  const restartHandlerId = allocateRestartHandlerId();
+
+  const throwError = typedAction<TError, never>(
+    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/src/values.ts

@@ -0,0 +1,21 @@
+import type { Result, Option } from "./ast.js";
+
+export function ok<TValue, TError = unknown>(
+  value: TValue,
+): Result<TValue, TError> {
+  return { kind: "Result.Ok", value } as Result<TValue, TError>;
+}
+
+export function err<TValue = unknown, TError = never>(
+  error: TError,
+): Result<TValue, TError> {
+  return { kind: "Result.Err", value: error } as Result<TValue, TError>;
+}
+
+export function some<T>(value: T): Option<T> {
+  return { kind: "Option.Some", value } as Option<T>;
+}
+
+export function none<T = unknown>(): Option<T> {
+  return { kind: "Option.None", value: null } as Option<T>;
+}

package/src/worker.ts

@@ -0,0 +1,71 @@
+/**
+ * Worker script: invoked as `tsx worker.ts <module> <export>`.
+ *
+ * Protocol:
+ *   Rust → stdin:  JSON `{ "value": <any> }`
+ *   stdout → Rust: JSON result (handler return value)
+ *
+ * stdout is reserved for the protocol. All console output is redirected to
+ * stderr so that handler code can freely use console.log for debugging.
+ *
+ * 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.
+ */
+
+// Redirect all console output to stderr — stdout is the protocol channel.
+// This must happen before any handler code is imported or executed.
+import { Console } from "node:console";
+
+const stderrConsole = new Console({ stdout: process.stderr });
+globalThis.console = stderrConsole;
+
+// 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);
+
+  if (!modulePath) {
+    process.stderr.write("worker: missing module path argument\n");
+    process.exit(1);
+  }
+
+  // Read entire stdin
+  const chunks: Buffer[] = [];
+  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, then exit. Explicit exit is required because
+  // importing the handler module may leave open handles (timers, servers,
+  // etc.) that keep the Node event loop alive indefinitely.
+  const json = JSON.stringify(result) ?? "null";
+  process.stdout.write(json, () => {
+    process.exit(0);
+  });
+}
+
+main().catch((error) => {
+  process.stderr.write(`worker: ${error}\n`);
+  process.exit(1);
+});