@barnum/barnum 0.0.0-main-3c07d795 → 0.0.0-main-18fb14ce

package/dist/builtins.d.ts

@@ -1,10 +1,36 @@
 import { type Action, type MergeTuple, type Option as OptionT, type Pipeable, type Result as ResultT, type TaggedUnion, type TypedAction } from "./ast.js";
+import { z } from "zod";
 /**
  * Typed combinators for structural data transformations.
  *
  * All builtins emit `{ kind: "Builtin", builtin: { kind: ... } }` handler
  * kinds. The Rust scheduler executes them inline (no subprocess).
  */
+/**
+ * Reverse of VoidToNull: maps `null` back to `void` in the def so that
+ * `taggedUnionSchema({ Clean: z.null() })` produces the same phantom __def
+ * as `TaggedUnion<{ Clean: void }>`.
+ */
+type NullToVoid<TDef> = {
+    [K in keyof TDef]: TDef[K] extends null ? void : TDef[K];
+};
+/**
+ * Build a Zod schema for a `TaggedUnion<TDef>` — a discriminated union of
+ * `{ kind: K; value: V }` objects.
+ *
+ * Each key in `cases` becomes a variant. The value Zod schema validates the
+ * `value` field. Use `z.null()` for void variants.
+ *
+ * ```ts
+ * const schema = taggedUnionSchema({
+ *   HasErrors: z.array(TypeErrorValidator),
+ *   Clean: z.null(),
+ * });
+ * ```
+ */
+export declare function taggedUnionSchema<TDef extends Record<string, z.ZodTypeAny>>(cases: TDef): z.ZodType<TaggedUnion<NullToVoid<{
+    [K in keyof TDef & string]: z.infer<TDef[K]>;
+}>>>;
 export declare function constant<TValue>(value: TValue): TypedAction<any, TValue>;
 export declare function identity<TValue = any>(): TypedAction<TValue, TValue>;
 export declare const drop: TypedAction<any, never>;
@@ -171,6 +197,15 @@ export declare const Option: {
      * Desugars to: `branch({ Some: pipe(drop(), constant(false)), None: pipe(drop(), constant(true)) })`
      */
     readonly isNone: <T>() => TypedAction<OptionT<T>, boolean>;
+    /**
+     * Build a Zod schema for `Option<T>`.
+     *
+     * ```ts
+     * const schema = Option.schema(z.string());
+     * // validates: { kind: "Some", value: "hello" } or { kind: "None", value: null }
+     * ```
+     */
+    readonly schema: <TValue>(valueSchema: z.ZodType<TValue>) => z.ZodType<OptionT<TValue>>;
 };
 /**
  * Result namespace. All combinators produce TypedAction AST nodes that
@@ -265,4 +300,14 @@ export declare const Result: {
      * Test if the value is Err. `Result<TValue, TError> → boolean`
      */
     readonly isErr: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, boolean>;
+    /**
+     * Build a Zod schema for `Result<TValue, TError>`.
+     *
+     * ```ts
+     * const schema = Result.schema(z.string(), z.number());
+     * // validates: { kind: "Ok", value: "hello" } or { kind: "Err", value: 42 }
+     * ```
+     */
+    readonly schema: <TValue, TError>(okSchema: z.ZodType<TValue>, errSchema: z.ZodType<TError>) => z.ZodType<ResultT<TValue, TError>>;
 };
+export {};

package/dist/builtins.js

@@ -1,11 +1,31 @@
 import { typedAction, } from "./ast.js";
 import { chain } from "./chain.js";
+import { z } from "zod";
 /**
- * Typed combinators for structural data transformations.
+ * Build a Zod schema for a `TaggedUnion<TDef>` — a discriminated union of
+ * `{ kind: K; value: V }` objects.
  *
- * All builtins emit `{ kind: "Builtin", builtin: { kind: ... } }` handler
- * kinds. The Rust scheduler executes them inline (no subprocess).
+ * Each key in `cases` becomes a variant. The value Zod schema validates the
+ * `value` field. Use `z.null()` for void variants.
+ *
+ * ```ts
+ * const schema = taggedUnionSchema({
+ *   HasErrors: z.array(TypeErrorValidator),
+ *   Clean: z.null(),
+ * });
+ * ```
  */
+export function taggedUnionSchema(cases) {
+    const variants = Object.entries(cases).map(([kind, valueSchema]) => z.object({ kind: z.literal(kind), value: valueSchema }));
+    if (variants.length < 2) {
+        throw new Error("taggedUnionSchema requires at least 2 variants");
+    }
+    return z.discriminatedUnion("kind", [
+        variants[0],
+        variants[1],
+        ...variants.slice(2),
+    ]);
+}
 // ---------------------------------------------------------------------------
 // Constant — produce a fixed value (takes no pipeline input)
 // ---------------------------------------------------------------------------
@@ -444,6 +464,20 @@ export const Option = {
         };
         return typedAction(optionBranch({ kind: "Chain", first: DROP, rest: constFalse }, { kind: "Chain", first: DROP, rest: constTrue }));
     },
+    /**
+     * Build a Zod schema for `Option<T>`.
+     *
+     * ```ts
+     * const schema = Option.schema(z.string());
+     * // validates: { kind: "Some", value: "hello" } or { kind: "None", value: null }
+     * ```
+     */
+    schema(valueSchema) {
+        return z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("Some"), value: valueSchema }),
+            z.object({ kind: z.literal("None"), value: z.null() }),
+        ]);
+    },
 };
 // ---------------------------------------------------------------------------
 // Result namespace — combinators for Result<TValue, TError> tagged unions
@@ -623,4 +657,18 @@ export const Result = {
         };
         return typedAction(resultBranch({ kind: "Chain", first: DROP, rest: constFalse }, { kind: "Chain", first: DROP, rest: constTrue }));
     },
+    /**
+     * Build a Zod schema for `Result<TValue, TError>`.
+     *
+     * ```ts
+     * const schema = Result.schema(z.string(), z.number());
+     * // validates: { kind: "Ok", value: "hello" } or { kind: "Err", value: 42 }
+     * ```
+     */
+    schema(okSchema, errSchema) {
+        return z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("Ok"), value: okSchema }),
+            z.object({ kind: z.literal("Err"), value: errSchema }),
+        ]);
+    },
 };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { TaggedUnion, OptionDef, ResultDef } from "./ast.js";
 export * from "./ast.js";
-export { constant, identity, drop, tag, merge, flatten, getField, getIndex, pick, dropResult, withResource, tap, range, splitFirst, splitLast, wrapInField, Option, Result, } from "./builtins.js";
+export { constant, identity, drop, tag, merge, flatten, getField, getIndex, pick, dropResult, withResource, tap, range, splitFirst, splitLast, wrapInField, taggedUnionSchema, Option, Result, } from "./builtins.js";
 export * from "./handler.js";
 export { runPipeline, type RunPipelineOptions, type LogLevel } from "./run.js";
 export { zodToCheckedJsonSchema } from "./schema.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from "./ast.js";
-export { constant, identity, drop, tag, merge, flatten, getField, getIndex, pick, dropResult, withResource, tap, range, splitFirst, splitLast, wrapInField, Option, Result, } from "./builtins.js";
+export { constant, identity, drop, tag, merge, flatten, getField, getIndex, pick, dropResult, withResource, tap, range, splitFirst, splitLast, wrapInField, taggedUnionSchema, Option, Result, } from "./builtins.js";
 export * from "./handler.js";
 export { runPipeline } from "./run.js";
 export { zodToCheckedJsonSchema } from "./schema.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barnum/barnum",
-  "version": "0.0.0-main-3c07d795",
+  "version": "0.0.0-main-18fb14ce",
   "description": "Barnum workflow engine",
   "type": "module",
   "main": "dist/index.js",

package/src/builtins.ts

@@ -9,6 +9,7 @@ import {
   typedAction,
 } from "./ast.js";
 import { chain } from "./chain.js";
+import { z } from "zod";
 
 /**
  * Typed combinators for structural data transformations.
@@ -17,6 +18,53 @@ import { chain } from "./chain.js";
  * kinds. The Rust scheduler executes them inline (no subprocess).
  */
 
+// ---------------------------------------------------------------------------
+// TaggedUnion Zod schema constructor
+// ---------------------------------------------------------------------------
+
+/**
+ * Reverse of VoidToNull: maps `null` back to `void` in the def so that
+ * `taggedUnionSchema({ Clean: z.null() })` produces the same phantom __def
+ * as `TaggedUnion<{ Clean: void }>`.
+ */
+type NullToVoid<TDef> = {
+  [K in keyof TDef]: TDef[K] extends null ? void : TDef[K];
+};
+
+/**
+ * Build a Zod schema for a `TaggedUnion<TDef>` — a discriminated union of
+ * `{ kind: K; value: V }` objects.
+ *
+ * Each key in `cases` becomes a variant. The value Zod schema validates the
+ * `value` field. Use `z.null()` for void variants.
+ *
+ * ```ts
+ * const schema = taggedUnionSchema({
+ *   HasErrors: z.array(TypeErrorValidator),
+ *   Clean: z.null(),
+ * });
+ * ```
+ */
+export function taggedUnionSchema<TDef extends Record<string, z.ZodTypeAny>>(
+  cases: TDef,
+): z.ZodType<
+  TaggedUnion<NullToVoid<{ [K in keyof TDef & string]: z.infer<TDef[K]> }>>
+> {
+  const variants = Object.entries(cases).map(([kind, valueSchema]) =>
+    z.object({ kind: z.literal(kind), value: valueSchema }),
+  );
+  if (variants.length < 2) {
+    throw new Error("taggedUnionSchema requires at least 2 variants");
+  }
+  return z.discriminatedUnion("kind", [
+    variants[0],
+    variants[1],
+    ...variants.slice(2),
+  ]) as z.ZodType<
+    TaggedUnion<NullToVoid<{ [K in keyof TDef & string]: z.infer<TDef[K]> }>>
+  >;
+}
+
 // ---------------------------------------------------------------------------
 // Constant — produce a fixed value (takes no pipeline input)
 // ---------------------------------------------------------------------------
@@ -576,6 +624,21 @@ export const Option = {
       ),
     );
   },
+
+  /**
+   * Build a Zod schema for `Option<T>`.
+   *
+   * ```ts
+   * const schema = Option.schema(z.string());
+   * // validates: { kind: "Some", value: "hello" } or { kind: "None", value: null }
+   * ```
+   */
+  schema<TValue>(valueSchema: z.ZodType<TValue>): z.ZodType<OptionT<TValue>> {
+    return z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("Some"), value: valueSchema }),
+      z.object({ kind: z.literal("None"), value: z.null() }),
+    ]) as z.ZodType<OptionT<TValue>>;
+  },
 } as const;
 
 // ---------------------------------------------------------------------------
@@ -828,4 +891,22 @@ export const Result = {
       ),
     );
   },
+
+  /**
+   * Build a Zod schema for `Result<TValue, TError>`.
+   *
+   * ```ts
+   * const schema = Result.schema(z.string(), z.number());
+   * // validates: { kind: "Ok", value: "hello" } or { kind: "Err", value: 42 }
+   * ```
+   */
+  schema<TValue, TError>(
+    okSchema: z.ZodType<TValue>,
+    errSchema: z.ZodType<TError>,
+  ): z.ZodType<ResultT<TValue, TError>> {
+    return z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("Ok"), value: okSchema }),
+      z.object({ kind: z.literal("Err"), value: errSchema }),
+    ]) as z.ZodType<ResultT<TValue, TError>>;
+  },
 } as const;

package/src/index.ts

@@ -18,6 +18,7 @@ export {
   splitFirst,
   splitLast,
   wrapInField,
+  taggedUnionSchema,
   Option,
   Result,
 } from "./builtins.js";