@barnum/barnum 0.2.3 → 0.4.0

package/dist/builtins/index.d.ts

@@ -0,0 +1,6 @@
+export { constant, identity, drop, panic } from "./scalar.js";
+export { getField, wrapInField, merge, pick, allObject } from "./struct.js";
+export { getIndex, flatten, splitFirst, splitLast, slice, range, } from "./array.js";
+export { tag, extractPrefix, asOption, taggedUnionSchema, } from "./tagged-union.js";
+export { withResource } from "./with-resource.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/builtins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/builtins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EACL,QAAQ,EACR,OAAO,EACP,UAAU,EACV,SAAS,EACT,KAAK,EACL,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,GAAG,EACH,aAAa,EACb,QAAQ,EACR,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/builtins/index.js

@@ -0,0 +1,5 @@
+export { constant, identity, drop, panic } from "./scalar.js";
+export { getField, wrapInField, merge, pick, allObject } from "./struct.js";
+export { getIndex, flatten, splitFirst, splitLast, slice, range, } from "./array.js";
+export { tag, extractPrefix, asOption, taggedUnionSchema, } from "./tagged-union.js";
+export { withResource } from "./with-resource.js";

package/dist/builtins/scalar.d.ts

@@ -0,0 +1,12 @@
+import { type TypedAction } from "../ast.js";
+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, void>;
+/**
+ * Halt execution with a fatal error. Not caught by tryCatch.
+ * Analogous to Rust's `panic!`.
+ *
+ * Output type is `never` — a panic never produces a value.
+ */
+export declare function panic(message: string): TypedAction<any, never>;
+//# sourceMappingURL=scalar.d.ts.map

package/dist/builtins/scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar.d.ts","sourceRoot":"","sources":["../../src/builtins/scalar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,WAAW,CAAC;AAM1D,wBAAgB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAKxE;AAMD,wBAAgB,QAAQ,CAAC,MAAM,GAAG,GAAG,KAAK,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAKpE;AAMD,eAAO,MAAM,IAAI,EAAE,WAAW,CAAC,GAAG,EAAE,IAAI,CAGtC,CAAC;AAMH;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAK9D"}

package/dist/builtins/scalar.js

@@ -0,0 +1,41 @@
+import { typedAction } from "../ast.js";
+// ---------------------------------------------------------------------------
+// Constant — produce a fixed value (takes no pipeline input)
+// ---------------------------------------------------------------------------
+export function constant(value) {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Constant", value } },
+    });
+}
+// ---------------------------------------------------------------------------
+// Identity — pass input through unchanged
+// ---------------------------------------------------------------------------
+export function identity() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Identity" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// Drop — discard pipeline value
+// ---------------------------------------------------------------------------
+export const drop = typedAction({
+    kind: "Invoke",
+    handler: { kind: "Builtin", builtin: { kind: "Drop" } },
+});
+// ---------------------------------------------------------------------------
+// Panic — halt execution with an error message
+// ---------------------------------------------------------------------------
+/**
+ * Halt execution with a fatal error. Not caught by tryCatch.
+ * Analogous to Rust's `panic!`.
+ *
+ * Output type is `never` — a panic never produces a value.
+ */
+export function panic(message) {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Panic", message } },
+    });
+}

package/dist/builtins/struct.d.ts

@@ -0,0 +1,25 @@
+import { type ExtractOutput, type MergeTuple, type Pipeable, type TypedAction } from "../ast.js";
+export declare function getField<TObj extends Record<string, unknown>, TField extends keyof TObj & string>(field: TField): TypedAction<TObj, TObj[TField]>;
+export declare function wrapInField<TField extends string, TValue>(field: TField): TypedAction<TValue, Record<TField, TValue>>;
+export declare function merge<TTuple extends Record<string, unknown>[]>(): TypedAction<TTuple, MergeTuple<TTuple>>;
+export declare function pick<TObj extends Record<string, unknown>, TKeys extends (keyof TObj & string)[]>(...keys: TKeys): TypedAction<TObj, Pick<TObj, TKeys[number]>>;
+/**
+ * Run named actions concurrently on the same input, collecting results
+ * into an object with matching keys.
+ *
+ * ```ts
+ * allObject({
+ *   files: listFiles,
+ *   config: loadConfig,
+ * })
+ * // TIn → { files: string[], config: Config }
+ * ```
+ *
+ * Each action receives the pipeline input. Results are wrapped in
+ * `{ key: value }` via `wrapInField`, run concurrently via `All`,
+ * then merged into a single object.
+ */
+export declare function allObject<TActions extends Record<string, Pipeable<any, any>>>(actions: TActions): TypedAction<any, {
+    [K in keyof TActions & string]: ExtractOutput<TActions[K]>;
+}>;
+//# sourceMappingURL=struct.d.ts.map

package/dist/builtins/struct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"struct.d.ts","sourceRoot":"","sources":["../../src/builtins/struct.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,WAAW,EAGjB,MAAM,WAAW,CAAC;AAOnB,wBAAgB,QAAQ,CACtB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,MAAM,SAAS,MAAM,IAAI,GAAG,MAAM,EAClC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAQhD;AAMD,wBAAgB,WAAW,CAAC,MAAM,SAAS,MAAM,EAAE,MAAM,EACvD,KAAK,EAAE,MAAM,GACZ,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ7C;AAMD,wBAAgB,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,WAAW,CAC5E,MAAM,EACN,UAAU,CAAC,MAAM,CAAC,CACnB,CAKA;AAMD,wBAAgB,IAAI,CAClB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,KAAK,SAAS,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,EACrC,GAAG,IAAI,EAAE,KAAK,GAAG,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAS9D;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EAC3E,OAAO,EAAE,QAAQ,GAChB,WAAW,CACZ,GAAG,EACH;KAAG,CAAC,IAAI,MAAM,QAAQ,GAAG,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAAE,CAC/D,CASA"}

package/dist/builtins/struct.js

@@ -0,0 +1,67 @@
+import { toAction, typedAction, } from "../ast.js";
+import { chain } from "../chain.js";
+// ---------------------------------------------------------------------------
+// GetField — extract a single field from an object
+// ---------------------------------------------------------------------------
+export function getField(field) {
+    return typedAction({
+        kind: "Invoke",
+        handler: {
+            kind: "Builtin",
+            builtin: { kind: "GetField", field },
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// WrapInField — wrap input as { <field>: <input> }
+// ---------------------------------------------------------------------------
+export function wrapInField(field) {
+    return typedAction({
+        kind: "Invoke",
+        handler: {
+            kind: "Builtin",
+            builtin: { kind: "WrapInField", field },
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Merge — merge a tuple of objects into a single object
+// ---------------------------------------------------------------------------
+export function merge() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Merge" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// Pick — select named fields from an object
+// ---------------------------------------------------------------------------
+export function pick(...keys) {
+    const actions = keys.map((key) => toAction(chain(toAction(getField(key)), toAction(wrapInField(key)))));
+    const allAction = { kind: "All", actions };
+    return chain(toAction(allAction), toAction(merge()));
+}
+// ---------------------------------------------------------------------------
+// AllObject — run named actions concurrently, collect into an object
+// ---------------------------------------------------------------------------
+/**
+ * Run named actions concurrently on the same input, collecting results
+ * into an object with matching keys.
+ *
+ * ```ts
+ * allObject({
+ *   files: listFiles,
+ *   config: loadConfig,
+ * })
+ * // TIn → { files: string[], config: Config }
+ * ```
+ *
+ * Each action receives the pipeline input. Results are wrapped in
+ * `{ key: value }` via `wrapInField`, run concurrently via `All`,
+ * then merged into a single object.
+ */
+export function allObject(actions) {
+    const wrapped = Object.entries(actions).map(([key, action]) => toAction(chain(action, wrapInField(key))));
+    const allAction = { kind: "All", actions: wrapped };
+    return chain(toAction(allAction), toAction(merge()));
+}

package/dist/builtins/tagged-union.d.ts

@@ -0,0 +1,54 @@
+import { type Option, type TaggedUnion, type TypedAction } from "../ast.js";
+import { z } from "zod";
+/**
+ * Wrap input as a tagged union member. Requires the full variant map TDef
+ * so the output type carries __def for branch decomposition.
+ *
+ * Usage: tag<{ Ok: string; Err: number }, "Ok">("Ok")
+ *        input: string → output: TaggedUnion<{ Ok: string; Err: number }>
+ */
+export declare function tag<TEnumName extends string, TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind, enumName: TEnumName): TypedAction<TDef[TKind], TaggedUnion<TEnumName, TDef>>;
+/**
+ * Extract the enum prefix from a tagged value's `kind` field.
+ *
+ * Input:  `{ kind: "Result.Ok", value: 42 }`
+ * Output: `{ kind: "Result", value: { kind: "Result.Ok", value: 42 } }`
+ *
+ * If `kind` contains no `'.'`, the entire kind string becomes the prefix.
+ * Used internally by `branchFamily` for two-level dispatch.
+ */
+export declare function extractPrefix(): TypedAction;
+/**
+ * Convert a boolean to `Option<void>`.
+ *
+ * `true`  → `{ kind: "Option.Some", value: null }`
+ * `false` → `{ kind: "Option.None", value: null }`
+ */
+export declare function asOption(): TypedAction<boolean, Option<void>>;
+/**
+ * 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<TEnumName, TDef>` — a discriminated
+ * union of `{ kind: "EnumName.Variant"; value: V }` objects.
+ *
+ * Each key in `cases` becomes a variant with a namespaced kind string.
+ * Use `z.null()` for void variants.
+ *
+ * ```ts
+ * const schema = taggedUnionSchema("ClassifyResult", {
+ *   HasErrors: z.array(TypeErrorValidator),
+ *   Clean: z.null(),
+ * });
+ * ```
+ */
+export declare function taggedUnionSchema<TEnumName extends string, TDef extends Record<string, z.ZodTypeAny>>(enumName: TEnumName, cases: TDef): z.ZodType<TaggedUnion<TEnumName, NullToVoid<{
+    [K in keyof TDef & string]: z.infer<TDef[K]>;
+}>>>;
+export {};
+//# sourceMappingURL=tagged-union.d.ts.map

package/dist/builtins/tagged-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tagged-union.d.ts","sourceRoot":"","sources":["../../src/builtins/tagged-union.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,WAAW,EAGjB,MAAM,WAAW,CAAC;AAKnB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;GAMG;AACH,wBAAgB,GAAG,CACjB,SAAS,SAAS,MAAM,EACxB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,KAAK,SAAS,MAAM,IAAI,GAAG,MAAM,EAEjC,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,SAAS,GAClB,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAcxD;AAMD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAAI,WAAW,CAK3C;AAMD;;;;;GAKG;AACH,wBAAgB,QAAQ,IAAI,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAK7D;AAMD;;;;GAIG;AACH,KAAK,UAAU,CAAC,IAAI,IAAI;KACrB,CAAC,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC;CACzD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,SAAS,MAAM,EACxB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,EAEzC,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,IAAI,GACV,CAAC,CAAC,OAAO,CACV,WAAW,CACT,SAAS,EACT,UAAU,CAAC;KAAG,CAAC,IAAI,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAC7D,CACF,CAmBA"}

package/dist/builtins/tagged-union.js

@@ -0,0 +1,81 @@
+import { toAction, typedAction, } from "../ast.js";
+import { chain } from "../chain.js";
+import { all } from "../all.js";
+import { constant } from "./scalar.js";
+import { wrapInField, merge } from "./struct.js";
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Tag — wrap input as a tagged union variant
+// ---------------------------------------------------------------------------
+/**
+ * Wrap input as a tagged union member. Requires the full variant map TDef
+ * so the output type carries __def for branch decomposition.
+ *
+ * Usage: tag<{ Ok: string; Err: number }, "Ok">("Ok")
+ *        input: string → output: TaggedUnion<{ Ok: string; Err: number }>
+ */
+export function tag(kind, enumName) {
+    const namespacedKind = `${enumName}.${kind}`;
+    return chain(toAction(all(chain(toAction(constant(namespacedKind)), toAction(wrapInField("kind"))), wrapInField("value"))), toAction(merge()));
+}
+// ---------------------------------------------------------------------------
+// ExtractPrefix — extract enum prefix from tagged value kind
+// ---------------------------------------------------------------------------
+/**
+ * Extract the enum prefix from a tagged value's `kind` field.
+ *
+ * Input:  `{ kind: "Result.Ok", value: 42 }`
+ * Output: `{ kind: "Result", value: { kind: "Result.Ok", value: 42 } }`
+ *
+ * If `kind` contains no `'.'`, the entire kind string becomes the prefix.
+ * Used internally by `branchFamily` for two-level dispatch.
+ */
+export function extractPrefix() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "ExtractPrefix" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// AsOption — convert boolean to Option<void>
+// ---------------------------------------------------------------------------
+/**
+ * Convert a boolean to `Option<void>`.
+ *
+ * `true`  → `{ kind: "Option.Some", value: null }`
+ * `false` → `{ kind: "Option.None", value: null }`
+ */
+export function asOption() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "AsOption" } },
+    });
+}
+/**
+ * Build a Zod schema for a `TaggedUnion<TEnumName, TDef>` — a discriminated
+ * union of `{ kind: "EnumName.Variant"; value: V }` objects.
+ *
+ * Each key in `cases` becomes a variant with a namespaced kind string.
+ * Use `z.null()` for void variants.
+ *
+ * ```ts
+ * const schema = taggedUnionSchema("ClassifyResult", {
+ *   HasErrors: z.array(TypeErrorValidator),
+ *   Clean: z.null(),
+ * });
+ * ```
+ */
+export function taggedUnionSchema(enumName, cases) {
+    const variants = Object.entries(cases).map(([kind, valueSchema]) => z.object({ kind: z.literal(`${enumName}.${kind}`), value: valueSchema }));
+    if (variants.length === 0) {
+        return z.never();
+    }
+    if (variants.length === 1) {
+        return variants[0];
+    }
+    return z.discriminatedUnion("kind", [
+        variants[0],
+        variants[1],
+        ...variants.slice(2),
+    ]);
+}

package/dist/builtins/with-resource.d.ts

@@ -0,0 +1,23 @@
+import { type Pipeable, type TypedAction } from "../ast.js";
+/**
+ * RAII-style resource management combinator.
+ *
+ * Runs `create` to acquire a resource, then merges the resource with the
+ * original input into a flat object (`TResource & TIn`) for the action.
+ * After the action completes, `dispose` receives the resource for cleanup.
+ * The overall combinator returns the action's output.
+ *
+ * ```
+ * TIn → create → TResource
+ *     → merge(TResource, TIn) → TResource & TIn
+ *     → action(TResource & TIn) → TOut
+ *     → dispose(TResource) → (discarded)
+ *     → TOut
+ * ```
+ */
+export declare function withResource<TIn extends Record<string, unknown>, TResource extends Record<string, unknown>, TOut, TDisposeOut = unknown>({ create, action, dispose, }: {
+    create: Pipeable<TIn, TResource>;
+    action: Pipeable<TResource & TIn, TOut>;
+    dispose: Pipeable<TResource, TDisposeOut>;
+}): TypedAction<TIn, TOut>;
+//# sourceMappingURL=with-resource.d.ts.map

package/dist/builtins/with-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-resource.d.ts","sourceRoot":"","sources":["../../src/builtins/with-resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAY,MAAM,WAAW,CAAC;AAWtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,IAAI,EACJ,WAAW,GAAG,OAAO,EACrB,EACA,MAAM,EACN,MAAM,EACN,OAAO,GACR,EAAE;IACD,MAAM,EAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACjC,MAAM,EAAE,QAAQ,CAAC,SAAS,GAAG,GAAG,EAAE,IAAI,CAAC,CAAC;IACxC,OAAO,EAAE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;CAC3C,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CA4BzB"}

package/dist/builtins/with-resource.js

@@ -0,0 +1,35 @@
+import { toAction } from "../ast.js";
+import { chain } from "../chain.js";
+import { all } from "../all.js";
+import { identity } from "./scalar.js";
+import { merge } from "./struct.js";
+import { getIndex } from "./array.js";
+// ---------------------------------------------------------------------------
+// WithResource — RAII-style create/action/dispose
+// ---------------------------------------------------------------------------
+/**
+ * RAII-style resource management combinator.
+ *
+ * Runs `create` to acquire a resource, then merges the resource with the
+ * original input into a flat object (`TResource & TIn`) for the action.
+ * After the action completes, `dispose` receives the resource for cleanup.
+ * The overall combinator returns the action's output.
+ *
+ * ```
+ * TIn → create → TResource
+ *     → merge(TResource, TIn) → TResource & TIn
+ *     → action(TResource & TIn) → TOut
+ *     → dispose(TResource) → (discarded)
+ *     → TOut
+ * ```
+ */
+export function withResource({ create, action, dispose, }) {
+    // Step 1: all(create, identity) → [TResource, TIn] → merge → TResource & TIn
+    const acquireAndMerge = chain(toAction(all(create, identity())), toAction(merge()));
+    // Step 2: all(action, identity) → [TOut, TResource & TIn]
+    const actionAndKeepMerged = all(toAction(action), toAction(identity()));
+    // Step 3: all(getIndex(0).unwrap(), chain(getIndex(1).unwrap(), dispose)) → [TOut, unknown]
+    const disposeAndKeepResult = all(toAction(getIndex(0).unwrap()), chain(toAction(getIndex(1).unwrap()), toAction(dispose)));
+    // Step 4: getIndex(0).unwrap() → TOut
+    return chain(toAction(chain(toAction(chain(toAction(acquireAndMerge), toAction(actionAndKeepMerged))), toAction(disposeAndKeepResult))), toAction(getIndex(0).unwrap()));
+}

package/dist/chain.d.ts

@@ -0,0 +1,3 @@
+import { type Pipeable, type TypedAction } from "./ast.js";
+export declare function chain<T1, T2, T3>(first: Pipeable<T1, T2>, rest: Pipeable<T2, T3>): TypedAction<T1, T3>;
+//# sourceMappingURL=chain.d.ts.map

package/dist/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../src/chain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAGjB,MAAM,UAAU,CAAC;AAElB,wBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAC9B,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,EACvB,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,GACrB,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,CAMrB"}

package/dist/chain.js

@@ -0,0 +1,8 @@
+import { toAction, typedAction, } from "./ast.js";
+export function chain(first, rest) {
+    return typedAction({
+        kind: "Chain",
+        first: toAction(first),
+        rest: toAction(rest),
+    });
+}

package/dist/effect-id.d.ts

@@ -0,0 +1,15 @@
+/** Branded ID for resume-style effect handlers. */
+export type ResumeHandlerId = number & {
+    readonly __resumeHandlerBrand: unique symbol;
+};
+/** Branded ID for restart-style effect handlers. */
+export type RestartHandlerId = number & {
+    readonly __restartHandlerBrand: unique symbol;
+};
+/** Allocate a fresh, unique resume handler ID. */
+export declare function allocateResumeHandlerId(): ResumeHandlerId;
+/** Allocate a fresh, unique restart handler ID. */
+export declare function allocateRestartHandlerId(): RestartHandlerId;
+/** Reset the ID counter. For test isolation only. */
+export declare function resetEffectIdCounter(): void;
+//# sourceMappingURL=effect-id.d.ts.map

package/dist/effect-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-id.d.ts","sourceRoot":"","sources":["../src/effect-id.ts"],"names":[],"mappings":"AAIA,mDAAmD;AACnD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IACrC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,MAAM,CAAC;CAC9C,CAAC;AAEF,oDAAoD;AACpD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IACtC,QAAQ,CAAC,qBAAqB,EAAE,OAAO,MAAM,CAAC;CAC/C,CAAC;AAIF,kDAAkD;AAClD,wBAAgB,uBAAuB,IAAI,eAAe,CAEzD;AAED,mDAAmD;AACnD,wBAAgB,wBAAwB,IAAI,gBAAgB,CAE3D;AAED,qDAAqD;AACrD,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

package/dist/effect-id.js

@@ -0,0 +1,16 @@
+// ---------------------------------------------------------------------------
+// Shared effect ID counter for gensym'd effect identifiers
+// ---------------------------------------------------------------------------
+let nextId = 0;
+/** Allocate a fresh, unique resume handler ID. */
+export function allocateResumeHandlerId() {
+    return nextId++;
+}
+/** Allocate a fresh, unique restart handler ID. */
+export function allocateRestartHandlerId() {
+    return nextId++;
+}
+/** Reset the ID counter. For test isolation only. */
+export function resetEffectIdCounter() {
+    nextId = 0;
+}

package/dist/handler.d.ts

@@ -0,0 +1,51 @@
+import type { z } from "zod";
+import { type TypedAction } from "./ast.js";
+export interface HandlerDefinition<TValue = unknown, TOutput = unknown, TStepConfig = unknown> {
+    inputValidator?: z.ZodType<TValue>;
+    outputValidator?: z.ZodType<TOutput>;
+    stepConfigValidator?: z.ZodType<TStepConfig>;
+    handle: (context: {
+        value: TValue;
+        stepConfig: TStepConfig;
+    }) => Promise<TOutput>;
+}
+/** Runtime-only handler definition shape — erases generic type info. */
+interface UntypedHandlerDefinition {
+    inputValidator?: z.ZodType;
+    outputValidator?: z.ZodType;
+    stepConfigValidator?: z.ZodType;
+    handle: (...args: any[]) => Promise<unknown>;
+}
+declare const HANDLER_BRAND: unique symbol;
+/**
+ * Opaque handler reference with typed metadata. The `__definition` property
+ * is non-enumerable — invisible to `JSON.stringify`, visible to the worker.
+ */
+export type Handler<TValue = unknown, TOutput = unknown> = TypedAction<TValue, TOutput> & {
+    readonly [HANDLER_BRAND]: true;
+    readonly __definition: UntypedHandlerDefinition;
+};
+/**
+ * Handlers that return `Promise<void>` produce `void` output (null at
+ * runtime). This is honest — the handler completes and returns nothing
+ * useful, but execution continues.
+ */
+type HandlerOutput<TOutput> = [TOutput] extends [void] ? void : TOutput;
+export declare function createHandler<TValue = void, TOutput = unknown>(definition: {
+    inputValidator?: z.ZodType<TValue>;
+    outputValidator?: z.ZodType<NoInfer<TOutput>>;
+    handle: (context: {
+        value: TValue;
+    }) => Promise<TOutput>;
+}, exportName?: string): Handler<TValue, HandlerOutput<TOutput>>;
+export declare function createHandlerWithConfig<TValue = void, TOutput = unknown, TStepConfig = unknown>(definition: {
+    inputValidator?: z.ZodType<TValue>;
+    outputValidator?: z.ZodType<NoInfer<TOutput>>;
+    stepConfigValidator?: z.ZodType<TStepConfig>;
+    handle: (context: {
+        value: TValue;
+        stepConfig: TStepConfig;
+    }) => Promise<TOutput>;
+}, exportName?: string): (config: TStepConfig) => TypedAction<TValue, HandlerOutput<TOutput>>;
+export {};
+//# sourceMappingURL=handler.d.ts.map

package/dist/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,KAAK,WAAW,EAAyB,MAAM,UAAU,CAAC;AAUnE,MAAM,WAAW,iBAAiB,CAChC,MAAM,GAAG,OAAO,EAChB,OAAO,GAAG,OAAO,EACjB,WAAW,GAAG,OAAO;IAErB,cAAc,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,mBAAmB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7C,MAAM,EAAE,CAAC,OAAO,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,WAAW,CAAC;KACzB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxB;AAED,wEAAwE;AACxE,UAAU,wBAAwB;IAChC,cAAc,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC;IAEhC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9C;AAMD,QAAA,MAAM,aAAa,eAA+B,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,OAAO,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,WAAW,CACpE,MAAM,EACN,OAAO,CACR,GAAG;IACF,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,wBAAwB,CAAC;CACjD,CAAC;AAwCF;;;;GAIG;AACH,KAAK,aAAa,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC;AAMxE,wBAAgB,aAAa,CAAC,MAAM,GAAG,IAAI,EAAE,OAAO,GAAG,OAAO,EAC5D,UAAU,EAAE;IACV,cAAc,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C,MAAM,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1D,EACD,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;AAoD3C,wBAAgB,uBAAuB,CACrC,MAAM,GAAG,IAAI,EACb,OAAO,GAAG,OAAO,EACjB,WAAW,GAAG,OAAO,EAErB,UAAU,EAAE;IACV,cAAc,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C,mBAAmB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7C,MAAM,EAAE,CAAC,OAAO,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,WAAW,CAAC;KACzB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxB,EACD,UAAU,CAAC,EAAE,MAAM,GAClB,CAAC,MAAM,EAAE,WAAW,KAAK,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/dist/handler.js

@@ -0,0 +1,130 @@
+import { fileURLToPath } from "node:url";
+import { toAction, typedAction } from "./ast.js";
+import { chain } from "./chain.js";
+import { all } from "./all.js";
+import { constant, identity } from "./builtins/index.js";
+import { zodToCheckedJsonSchema } from "./schema.js";
+// ---------------------------------------------------------------------------
+// Handler — opaque typed handler reference
+// ---------------------------------------------------------------------------
+const HANDLER_BRAND = Symbol.for("barnum:handler");
+// ---------------------------------------------------------------------------
+// getCallerFilePath
+// ---------------------------------------------------------------------------
+/**
+ * Deduces the caller's file path from the V8 stack trace API.
+ * Frame 0 = getCallerFilePath, Frame 1 = createHandler, Frame 2 = the caller.
+ */
+function getCallerFilePath() {
+    const original = Error.prepareStackTrace;
+    let callerFile;
+    Error.prepareStackTrace = (_err, stack) => {
+        const frame = stack[2];
+        callerFile = frame?.getFileName() ?? undefined;
+        return "";
+    };
+    const err = new Error("stack trace capture");
+    void err.stack;
+    Error.prepareStackTrace = original;
+    if (!callerFile) {
+        throw new Error("createHandler: could not determine caller file path from stack trace.");
+    }
+    if (callerFile.startsWith("file://")) {
+        return fileURLToPath(callerFile);
+    }
+    return callerFile;
+}
+// Implementation
+export function createHandler(definition, exportName) {
+    const filePath = getCallerFilePath();
+    const funcName = exportName ?? "default";
+    const inputSchema = definition.inputValidator
+        ? zodToCheckedJsonSchema(definition.inputValidator, `${filePath}:${funcName} input`)
+        : undefined;
+    const outputSchema = definition.outputValidator
+        ? zodToCheckedJsonSchema(definition.outputValidator, `${filePath}:${funcName} output`)
+        : undefined;
+    const action = typedAction({
+        kind: "Invoke",
+        handler: {
+            kind: "TypeScript",
+            module: filePath,
+            func: funcName,
+            ...(inputSchema && { input_schema: inputSchema }),
+            ...(outputSchema && { output_schema: outputSchema }),
+        },
+    });
+    // Non-enumerable: invisible to JSON.stringify, visible to the worker
+    Object.defineProperty(action, HANDLER_BRAND, {
+        value: true,
+        enumerable: false,
+    });
+    Object.defineProperty(action, "__definition", {
+        value: definition,
+        enumerable: false,
+    });
+    return action;
+}
+// Implementation
+export function createHandlerWithConfig(definition, exportName) {
+    const filePath = getCallerFilePath();
+    const funcName = exportName ?? "default";
+    // The invoke receives [value, config] from All(Identity, Constant(config)).
+    // Build a tuple schema manually — the Rust engine doesn't support draft-07
+    // array-form `items` for tuples, so use `prefixItems` (2020-12 style).
+    const valueSchema = definition.inputValidator
+        ? zodToCheckedJsonSchema(definition.inputValidator, `${filePath}:${funcName} input`)
+        : {};
+    const configSchema = definition.stepConfigValidator
+        ? zodToCheckedJsonSchema(definition.stepConfigValidator, `${filePath}:${funcName} stepConfig`)
+        : {};
+    const inputSchema = {
+        type: "array",
+        prefixItems: [valueSchema, configSchema],
+        items: false,
+        minItems: 2,
+        maxItems: 2,
+    };
+    const outputSchema = definition.outputValidator
+        ? zodToCheckedJsonSchema(definition.outputValidator, `${filePath}:${funcName} output`)
+        : undefined;
+    // Internal handle that unpacks the [value, config] tuple from All
+    const internalDefinition = {
+        handle: ({ value }) => {
+            const [pipelineValue, config] = value;
+            return definition.handle({ value: pipelineValue, stepConfig: config });
+        },
+    };
+    const invokeAction = typedAction({
+        kind: "Invoke",
+        handler: {
+            kind: "TypeScript",
+            module: filePath,
+            func: funcName,
+            input_schema: inputSchema,
+            ...(outputSchema && { output_schema: outputSchema }),
+        },
+    });
+    // Non-enumerable: invisible to JSON.stringify, visible to the worker
+    Object.defineProperty(invokeAction, HANDLER_BRAND, {
+        value: true,
+        enumerable: false,
+    });
+    Object.defineProperty(invokeAction, "__definition", {
+        value: internalDefinition,
+        enumerable: false,
+    });
+    // The factory function is the module export, so it must also carry
+    // __definition for the worker to find (the worker imports the module
+    // and accesses the named export, which is this function).
+    const factory = (config) => chain(toAction(all(identity(), constant(config))), toAction(invokeAction));
+    Object.defineProperty(factory, HANDLER_BRAND, {
+        value: true,
+        enumerable: false,
+    });
+    Object.defineProperty(factory, "__definition", {
+        value: internalDefinition,
+        enumerable: false,
+    });
+    return factory;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { TaggedUnion, OptionDef, ResultDef, IteratorDef } from "./ast.js";
+export * from "./ast.js";
+export { allObject, asOption, constant, drop, flatten, getField, getIndex, identity, panic, pick, range, splitFirst, splitLast, tag, taggedUnionSchema, withResource, wrapInField, } from "./builtins/index.js";
+export { Option, first, last } from "./option.js";
+export { Result } from "./result.js";
+export { Iterator } from "./iterator.js";
+export { runPipeline, type RunPipelineOptions, type LogLevel } from "./run.js";
+export { zodToCheckedJsonSchema } from "./schema.js";
+export type Option<T> = TaggedUnion<"Option", OptionDef<T>>;
+export type Result<TValue, TError> = TaggedUnion<"Result", ResultDef<TValue, TError>>;
+export type Iterator<TElement> = TaggedUnion<"Iterator", IteratorDef<TElement>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/E,cAAc,UAAU,CAAC;AACzB,OAAO,EACL,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,KAAK,EACL,UAAU,EACV,SAAS,EACT,GAAG,EACH,iBAAiB,EACjB,YAAY,EACZ,WAAW,GACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAKrD,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5D,MAAM,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,WAAW,CAC9C,QAAQ,EACR,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAC1B,CAAC;AACF,MAAM,MAAM,QAAQ,CAAC,QAAQ,IAAI,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC"}