@barnum/barnum 0.3.0 → 0.4.0

package/dist/bind.js

@@ -1,5 +1,7 @@
-import { typedAction, } from "./ast.js";
-import { identity, drop } from "./builtins.js";
+import { toAction, typedAction, } from "./ast.js";
+import { chain } from "./chain.js";
+import { all } from "./all.js";
+import { identity, drop, getIndex } from "./builtins/index.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 import { pipe } from "./pipe.js";
 function createVarRef(resumeHandlerId) {
@@ -18,38 +20,10 @@ function createVarRef(resumeHandlerId) {
  * `state` (index 1) is the full All output tuple. The handler produces
  * `[state[n], state]` — value is state[n], new_state is state (unchanged).
  *
- * Expanded AST: All(Chain(ExtractIndex(1), ExtractIndex(n)), ExtractIndex(1))
+ * Expanded AST: All(Chain(GetIndex(1).unwrap(), GetIndex(n).unwrap()), GetIndex(1).unwrap())
  */
 function readVar(n) {
-    return {
-        kind: "All",
-        actions: [
-            {
-                kind: "Chain",
-                first: {
-                    kind: "Invoke",
-                    handler: {
-                        kind: "Builtin",
-                        builtin: { kind: "ExtractIndex", value: 1 },
-                    },
-                },
-                rest: {
-                    kind: "Invoke",
-                    handler: {
-                        kind: "Builtin",
-                        builtin: { kind: "ExtractIndex", value: n },
-                    },
-                },
-            },
-            {
-                kind: "Invoke",
-                handler: {
-                    kind: "Builtin",
-                    builtin: { kind: "ExtractIndex", value: 1 },
-                },
-            },
-        ],
-    };
+    return toAction(all(chain(toAction(getIndex(1).unwrap()), toAction(getIndex(n).unwrap())), toAction(getIndex(1).unwrap())));
 }
 export function bind(bindings, body) {
     // 1. Gensym one resumeHandlerId per binding.
@@ -57,21 +31,11 @@ export function bind(bindings, body) {
     // 2. Create VarRefs (ResumePerform nodes) for each binding.
     const varRefs = resumeHandlerIds.map((id) => createVarRef(id));
     // 3. Invoke the body callback with the VarRefs.
-    const bodyAction = body(varRefs);
+    const bodyAction = toAction(body(varRefs));
     // 4. Build nested Handles from inside out.
     //    Innermost: extract pipeline_input (last All element) → user body
     const pipelineInputIndex = bindings.length;
-    let inner = {
-        kind: "Chain",
-        first: {
-            kind: "Invoke",
-            handler: {
-                kind: "Builtin",
-                builtin: { kind: "ExtractIndex", value: pipelineInputIndex },
-            },
-        },
-        rest: bodyAction,
-    };
+    let inner = toAction(chain(toAction(getIndex(pipelineInputIndex).unwrap()), toAction(bodyAction)));
     for (let i = resumeHandlerIds.length - 1; i >= 0; i--) {
         inner = {
             kind: "ResumeHandle",
@@ -81,12 +45,11 @@ export function bind(bindings, body) {
         };
     }
     // 5. All(...bindings, identity()) → nested Handles
-    const allActions = [...bindings.map((b) => b), identity];
-    return typedAction({
-        kind: "Chain",
-        first: { kind: "All", actions: allActions },
-        rest: inner,
-    });
+    const allAction = {
+        kind: "All",
+        actions: [...bindings.map((b) => toAction(b)), toAction(identity())],
+    };
+    return typedAction(toAction(chain(toAction(allAction), toAction(inner))));
 }
 // ---------------------------------------------------------------------------
 // bindInput — bind the pipeline input
@@ -102,5 +65,5 @@ export function bind(bindings, body) {
  *   bindInput<FileEntry>((entry) => ...)
  */
 export function bindInput(body) {
-    return bind([identity], ([input]) => pipe(drop, body(input)));
+    return bind([identity()], ([input]) => pipe(drop, body(input)));
 }

package/dist/builtins/array.d.ts

@@ -0,0 +1,36 @@
+import { type Option as OptionT, type TypedAction } from "../ast.js";
+export declare function getIndex<TTuple extends unknown[], TIndex extends number>(index: TIndex): TypedAction<TTuple, OptionT<TTuple[TIndex]>>;
+export declare function flatten<TElement>(): TypedAction<TElement[][], TElement[]>;
+/**
+ * Deconstruct an array into its first element and the remaining elements.
+ * `TElement[] → Option<[TElement, TElement[]]>`
+ *
+ * Returns `Some([first, rest])` for non-empty arrays, `None` for empty arrays.
+ * This is the array equivalent of cons/uncons — enables recursive iteration
+ * patterns via `loop` + `splitFirst` + `branch`.
+ *
+ * This is a builtin (SplitFirst) because it requires array-length branching
+ * that can't be composed from existing AST nodes.
+ */
+export declare function splitFirst<TElement>(): TypedAction<TElement[], OptionT<[TElement, TElement[]]>>;
+/**
+ * Deconstruct an array into the leading elements and the last element.
+ * `TElement[] → Option<[TElement[], TElement]>`
+ *
+ * Returns `Some([init, last])` for non-empty arrays, `None` for empty arrays.
+ * Mirror of `splitFirst` — enables processing from the tail end.
+ *
+ * This is a builtin (SplitLast) because it requires array-length branching
+ * that can't be composed from existing AST nodes.
+ */
+export declare function splitLast<TElement>(): TypedAction<TElement[], OptionT<[TElement[], TElement]>>;
+/**
+ * Slice an array from `start` (inclusive) to `end` (exclusive).
+ * `T[] → T[]`
+ *
+ * Both indices are clamped to array length. If `end` is omitted, slices
+ * to the end of the array. Returns empty array if `start >= end`.
+ */
+export declare function slice<TElement>(start: number, end?: number): TypedAction<TElement[], TElement[]>;
+export declare function range(start: number, end: number): TypedAction<any, number[]>;
+//# sourceMappingURL=array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/builtins/array.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,WAAW,EAEjB,MAAM,WAAW,CAAC;AAMnB,wBAAgB,QAAQ,CAAC,MAAM,SAAS,OAAO,EAAE,EAAE,MAAM,SAAS,MAAM,EACtE,KAAK,EAAE,MAAM,GACZ,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAQ9C;AAMD,wBAAgB,OAAO,CAAC,QAAQ,KAAK,WAAW,CAAC,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAKzE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,QAAQ,KAAK,WAAW,CACjD,QAAQ,EAAE,EACV,OAAO,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,CAChC,CAKA;AAMD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,QAAQ,KAAK,WAAW,CAChD,QAAQ,EAAE,EACV,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,CAChC,CAKA;AAMD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAC5B,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,GACX,WAAW,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,CAAC,CASrC;AAMD,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,CAS5E"}

package/dist/builtins/array.js

@@ -0,0 +1,93 @@
+import { typedAction, } from "../ast.js";
+// ---------------------------------------------------------------------------
+// GetIndex — extract a single element from an array by index
+// ---------------------------------------------------------------------------
+export function getIndex(index) {
+    return typedAction({
+        kind: "Invoke",
+        handler: {
+            kind: "Builtin",
+            builtin: { kind: "GetIndex", index },
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Flatten — flatten a nested array one level
+// ---------------------------------------------------------------------------
+export function flatten() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Flatten" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// SplitFirst — head/tail decomposition of an array
+// ---------------------------------------------------------------------------
+/**
+ * Deconstruct an array into its first element and the remaining elements.
+ * `TElement[] → Option<[TElement, TElement[]]>`
+ *
+ * Returns `Some([first, rest])` for non-empty arrays, `None` for empty arrays.
+ * This is the array equivalent of cons/uncons — enables recursive iteration
+ * patterns via `loop` + `splitFirst` + `branch`.
+ *
+ * This is a builtin (SplitFirst) because it requires array-length branching
+ * that can't be composed from existing AST nodes.
+ */
+export function splitFirst() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "SplitFirst" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// SplitLast — init/last decomposition of an array
+// ---------------------------------------------------------------------------
+/**
+ * Deconstruct an array into the leading elements and the last element.
+ * `TElement[] → Option<[TElement[], TElement]>`
+ *
+ * Returns `Some([init, last])` for non-empty arrays, `None` for empty arrays.
+ * Mirror of `splitFirst` — enables processing from the tail end.
+ *
+ * This is a builtin (SplitLast) because it requires array-length branching
+ * that can't be composed from existing AST nodes.
+ */
+export function splitLast() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "SplitLast" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// Slice — extract a sub-array from start to end
+// ---------------------------------------------------------------------------
+/**
+ * Slice an array from `start` (inclusive) to `end` (exclusive).
+ * `T[] → T[]`
+ *
+ * Both indices are clamped to array length. If `end` is omitted, slices
+ * to the end of the array. Returns empty array if `start >= end`.
+ */
+export function slice(start, end) {
+    const builtin = end === undefined
+        ? { kind: "Slice", start }
+        : { kind: "Slice", start, end };
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin },
+    });
+}
+// ---------------------------------------------------------------------------
+// Range — produce an integer array [start, start+1, ..., end-1]
+// ---------------------------------------------------------------------------
+export function range(start, end) {
+    const result = [];
+    for (let i = start; i < end; i++) {
+        result.push(i);
+    }
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Constant", value: result } },
+    });
+}

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

@@ -1,2 +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

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

package/dist/effect-id.d.ts

@@ -12,3 +12,4 @@ export declare function allocateResumeHandlerId(): ResumeHandlerId;
 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"}