@barnum/barnum 0.2.3 → 0.4.0

package/dist/index.js

@@ -0,0 +1,7 @@
+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 } from "./run.js";
+export { zodToCheckedJsonSchema } from "./schema.js";

package/dist/iterator.d.ts

@@ -0,0 +1,32 @@
+import { type Iterator as IteratorT, type Option as OptionT, type Pipeable, type Result as ResultT, type TypedAction } from "./ast.js";
+export declare const Iterator: {
+    /** Wrap an array as Iterator. `T[] → Iterator<T>` */
+    readonly fromArray: <TElement>() => TypedAction<TElement[], IteratorT<TElement>>;
+    /** Wrap an Option as Iterator. `Option<T> → Iterator<T>` */
+    readonly fromOption: <TElement>() => TypedAction<OptionT<TElement>, IteratorT<TElement>>;
+    /** Wrap a Result as Iterator (Ok kept, Err dropped). `Result<T, E> → Iterator<T>` */
+    readonly fromResult: <TElement, TError>() => TypedAction<ResultT<TElement, TError>, IteratorT<TElement>>;
+    /** Unwrap Iterator to array. `Iterator<T> → T[]` */
+    readonly collect: <TElement>() => TypedAction<IteratorT<TElement>, TElement[]>;
+    /** Transform each element. `Iterator<T> → Iterator<U>` */
+    readonly map: <TIn, TOut>(action: Pipeable<TIn, TOut>) => TypedAction<IteratorT<TIn>, IteratorT<TOut>>;
+    /** Flat-map each element. `f` returns any IntoIterator type. `Iterator<T> → Iterator<U>` */
+    readonly flatMap: <TIn, TOut>(action: Pipeable<TIn, unknown>) => TypedAction<IteratorT<TIn>, IteratorT<TOut>>;
+    /** Keep elements where predicate returns true. `Iterator<T> → Iterator<T>` */
+    readonly filter: <TElement>(predicate: Pipeable<TElement, boolean>) => TypedAction<IteratorT<TElement>, IteratorT<TElement>>;
+    /** Head/tail decomposition. `Iterator<T> → Option<[T, Iterator<T>]>` */
+    readonly splitFirst: <TElement>() => TypedAction<IteratorT<TElement>, OptionT<[TElement, IteratorT<TElement>]>>;
+    /** Init/last decomposition. `Iterator<T> → Option<[Iterator<T>, T]>` */
+    readonly splitLast: <TElement>() => TypedAction<IteratorT<TElement>, OptionT<[IteratorT<TElement>, TElement]>>;
+    /** Fold elements with accumulator. `Iterator<T> → TAcc` */
+    readonly fold: <TElement, TAcc>(init: Pipeable<void, TAcc>, body: Pipeable<[TAcc, TElement], TAcc>) => TypedAction<IteratorT<TElement>, TAcc>;
+    /** Slice elements from start to end. `Iterator<T> → Iterator<T>` */
+    readonly slice: <TElement>(start: number, end?: number) => TypedAction<IteratorT<TElement>, IteratorT<TElement>>;
+    /** First n elements. `Iterator<T> → Iterator<T>` */
+    readonly take: <TElement>(n: number) => TypedAction<IteratorT<TElement>, IteratorT<TElement>>;
+    /** Drop first n elements. `Iterator<T> → Iterator<T>` */
+    readonly skip: <TElement>(n: number) => TypedAction<IteratorT<TElement>, IteratorT<TElement>>;
+    /** Check if iterator is empty. `Iterator<T> → boolean` */
+    readonly isEmpty: <TElement>() => TypedAction<IteratorT<TElement>, boolean>;
+};
+//# sourceMappingURL=iterator.d.ts.map

package/dist/iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterator.d.ts","sourceRoot":"","sources":["../src/iterator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,IAAI,SAAS,EAE1B,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,QAAQ,EACb,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,WAAW,EAOjB,MAAM,UAAU,CAAC;AA6ClB,eAAO,MAAM,QAAQ;IACnB,qDAAqD;yBAC3C,QAAQ,OAAK,WAAW,CAAC,QAAQ,EAAE,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAOnE,4DAA4D;0BACjD,QAAQ,OAAK,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAO3E,qFAAqF;0BAC1E,QAAQ,EAAE,MAAM,OAAK,WAAW,CACzC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,EACzB,SAAS,CAAC,QAAQ,CAAC,CACpB;IAOD,oDAAoD;uBAC5C,QAAQ,OAAK,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;IAIjE,0DAA0D;mBACtD,GAAG,EAAE,IAAI,UACH,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,KAC1B,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IAO/C,4FAA4F;uBACpF,GAAG,EAAE,IAAI,UACP,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,KAC7B,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IAU/C,8EAA8E;sBACvE,QAAQ,aACF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,KACrC,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAcxD,wEAAwE;0BAC7D,QAAQ,OAAK,WAAW,CACjC,SAAS,CAAC,QAAQ,CAAC,EACnB,OAAO,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CACzC;IAaD,wEAAwE;yBAC9D,QAAQ,OAAK,WAAW,CAChC,SAAS,CAAC,QAAQ,CAAC,EACnB,OAAO,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CACzC;IAaD,2DAA2D;oBACtD,QAAQ,EAAE,IAAI,QACX,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QACpB,QAAQ,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,KACrC,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAyCzC,oEAAoE;qBAC9D,QAAQ,SACL,MAAM,QACP,MAAM,KACX,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAUxD,oDAAoD;oBAC/C,QAAQ,KACR,MAAM,KACR,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAIxD,yDAAyD;oBACpD,QAAQ,KACR,MAAM,KACR,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAIxD,0DAA0D;uBAClD,QAAQ,OAAK,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAGtD,CAAC"}

package/dist/iterator.js

@@ -0,0 +1,123 @@
+import { toAction, typedAction, branch, branchFamily, forEach, loop, } from "./ast.js";
+import { chain } from "./chain.js";
+import { constant, drop, flatten, getField, getIndex, identity, slice, splitFirst, splitLast, tag, } from "./builtins/index.js";
+import { all } from "./all.js";
+import { Option } from "./option.js";
+import { bindInput } from "./bind.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Wrap a single value in an array. `T → T[]`
+ * Implemented as `all(identity())`. May warrant a dedicated builtin later.
+ */
+function wrapInArray() {
+    return all(identity());
+}
+/**
+ * Normalize any IntoIterator return type to a plain array.
+ * Used inside `.flatMap()` to handle Iterator, Option, Result, and Array returns.
+ */
+const intoIteratorNormalize = branchFamily({
+    Iterator: branch({ Iterator: identity() }),
+    Option: branch({ Some: wrapInArray(), None: constant([]) }),
+    Result: branch({ Ok: wrapInArray(), Err: constant([]) }),
+    Array: identity(),
+});
+// ---------------------------------------------------------------------------
+// Iterator namespace
+// ---------------------------------------------------------------------------
+export const Iterator = {
+    /** Wrap an array as Iterator. `T[] → Iterator<T>` */
+    fromArray() {
+        return tag("Iterator", "Iterator");
+    },
+    /** Wrap an Option as Iterator. `Option<T> → Iterator<T>` */
+    fromOption() {
+        return branch({
+            Some: chain(wrapInArray(), Iterator.fromArray()),
+            None: chain(constant([]), Iterator.fromArray()),
+        });
+    },
+    /** Wrap a Result as Iterator (Ok kept, Err dropped). `Result<T, E> → Iterator<T>` */
+    fromResult() {
+        return branch({
+            Ok: chain(wrapInArray(), Iterator.fromArray()),
+            Err: chain(constant([]), Iterator.fromArray()),
+        });
+    },
+    /** Unwrap Iterator to array. `Iterator<T> → T[]` */
+    collect() {
+        return getField("value");
+    },
+    /** Transform each element. `Iterator<T> → Iterator<U>` */
+    map(action) {
+        return chain(toAction(getField("value")), chain(toAction(forEach(action)), Iterator.fromArray()));
+    },
+    /** Flat-map each element. `f` returns any IntoIterator type. `Iterator<T> → Iterator<U>` */
+    flatMap(action) {
+        return chain(toAction(getField("value")), chain(toAction(forEach(chain(action, intoIteratorNormalize))), chain(toAction(flatten()), Iterator.fromArray())));
+    },
+    /** Keep elements where predicate returns true. `Iterator<T> → Iterator<T>` */
+    filter(predicate) {
+        return Iterator.flatMap(bindInput((element) => element
+            .then(predicate)
+            .asOption()
+            .branch({
+            Some: element.some(),
+            None: chain(drop, Option.none()),
+        })));
+    },
+    /** Head/tail decomposition. `Iterator<T> → Option<[T, Iterator<T>]>` */
+    splitFirst() {
+        return Iterator.collect()
+            .then(splitFirst())
+            .then(Option.map(all(getIndex(0).unwrap(), getIndex(1).unwrap().iterate())));
+    },
+    /** Init/last decomposition. `Iterator<T> → Option<[Iterator<T>, T]>` */
+    splitLast() {
+        return Iterator.collect()
+            .then(splitLast())
+            .then(Option.map(all(getIndex(0).unwrap().iterate(), getIndex(1).unwrap())));
+    },
+    /** Fold elements with accumulator. `Iterator<T> → TAcc` */
+    fold(init, body) {
+        return Iterator.collect().then(bindInput((elements) => all(init, elements).then(loop((recur, done) => {
+            // Re-wrap done to bridge VoidToNull<TAcc> → TAcc (TypeScript
+            // can't simplify the conditional type for generic TAcc).
+            const doneTAcc = typedAction(toAction(done));
+            // Wrap return with typedAction — branch output inference fails
+            // for generic types inside loop bodies.
+            return typedAction(toAction(bindInput((state) => {
+                const acc = state.getIndex(0).unwrap();
+                const remaining = state.getIndex(1).unwrap();
+                return remaining.splitFirst().branch({
+                    None: acc.then(doneTAcc),
+                    Some: bindInput((headTail) => {
+                        const head = headTail.getIndex(0).unwrap();
+                        const tail = headTail.getIndex(1).unwrap();
+                        return all(acc, head)
+                            .then(body)
+                            .then(bindInput((newAcc) => all(newAcc, tail).then(recur)));
+                    }),
+                });
+            })));
+        }))));
+    },
+    /** Slice elements from start to end. `Iterator<T> → Iterator<T>` */
+    slice(start, end) {
+        return chain(Iterator.collect(), chain(toAction(slice(start, end)), Iterator.fromArray()));
+    },
+    /** First n elements. `Iterator<T> → Iterator<T>` */
+    take(n) {
+        return Iterator.slice(0, n);
+    },
+    /** Drop first n elements. `Iterator<T> → Iterator<T>` */
+    skip(n) {
+        return Iterator.slice(n);
+    },
+    /** Check if iterator is empty. `Iterator<T> → boolean` */
+    isEmpty() {
+        return Iterator.collect().splitFirst().isNone();
+    },
+};

package/dist/option.d.ts

@@ -0,0 +1,74 @@
+import { type Option as OptionT, type Pipeable, type Result as ResultT, type TypedAction } from "./ast.js";
+/**
+ * Option namespace. All combinators produce TypedAction AST nodes that
+ * desugar to branch + existing builtins, except collect which uses the
+ * CollectSome builtin.
+ */
+export declare const Option: {
+    /** Tag combinator: wrap value as `Option.Some`. `T → Option<T>` */
+    readonly some: <T>() => TypedAction<T, OptionT<T>>;
+    /** Tag combinator: wrap value as `Option.None`. `void → Option<T>` */
+    readonly none: <T>() => TypedAction<void, OptionT<T>>;
+    /** Transform the Some value. `Option<T> → Option<U>` */
+    readonly map: <T, U>(action: Pipeable<T, U>) => TypedAction<OptionT<T>, OptionT<U>>;
+    /**
+     * Monadic bind (flatMap). If Some, pass the value to action which
+     * returns Option<U>. If None, stay None. `Option<T> → Option<U>`
+     */
+    readonly andThen: <T, U>(action: Pipeable<T, OptionT<U>>) => TypedAction<OptionT<T>, OptionT<U>>;
+    /**
+     * Extract the Some value or panic. `Option<T> → T`
+     *
+     * Panics (fatal, not caught by tryCatch) if the value is None.
+     */
+    readonly unwrap: <T>() => TypedAction<OptionT<T>, T>;
+    /**
+     * Extract the Some value or produce a default from an action.
+     * `Option<T> → T`
+     */
+    readonly unwrapOr: <T>(defaultAction: Pipeable<void, T>) => TypedAction<OptionT<T>, T>;
+    /**
+     * Conditional keep. If Some, pass value to predicate which returns
+     * Option<T>. If None, stay None. `Option<T> → Option<T>`
+     */
+    readonly filter: <T>(predicate: Pipeable<T, OptionT<T>>) => TypedAction<OptionT<T>, OptionT<T>>;
+    /**
+     * Collect Some values from an array, discarding Nones.
+     * `Option<T>[] → T[]`
+     */
+    readonly collect: <T = any>() => TypedAction<OptionT<T>[], T[]>;
+    /**
+     * Test if the value is Some. `Option<T> → boolean`
+     */
+    readonly isSome: <T>() => TypedAction<OptionT<T>, boolean>;
+    /**
+     * Test if the value is None. `Option<T> → boolean`
+     */
+    readonly isNone: <T>() => TypedAction<OptionT<T>, boolean>;
+    /**
+     * Swap Option/Result nesting.
+     * `Option<Result<TValue, TError>> → Result<Option<TValue>, TError>`
+     *
+     * - Some(Ok(t))  → Ok(Some(t))
+     * - Some(Err(e)) → Err(e)
+     * - None         → Ok(None)
+     */
+    readonly transpose: <TValue, TError>() => TypedAction<OptionT<ResultT<TValue, TError>>, ResultT<OptionT<TValue>, TError>>;
+};
+/**
+ * Extract the first element of an array.
+ * `readonly TElement[] → Option<TElement>`
+ *
+ * Composes `splitFirst` (which returns `Option<[TElement, TElement[]]>`)
+ * with `Option.map(getIndex(0))` to extract just the element.
+ */
+export declare function first<TElement>(): TypedAction<readonly TElement[], OptionT<TElement>>;
+/**
+ * Extract the last element of an array.
+ * `readonly TElement[] → Option<TElement>`
+ *
+ * Composes `splitLast` (which returns `Option<[TElement[], TElement]>`)
+ * with `Option.map(getIndex(1))` to extract just the element.
+ */
+export declare function last<TElement>(): TypedAction<readonly TElement[], OptionT<TElement>>;
+//# sourceMappingURL=option.d.ts.map

package/dist/option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../src/option.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,IAAI,OAAO,EAEtB,KAAK,QAAQ,EACb,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AAkBlB;;;;GAIG;AACH,eAAO,MAAM,MAAM;IACjB,mEAAmE;oBAC9D,CAAC,OAAK,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAGrC,sEAAsE;oBACjE,CAAC,OAAK,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAIxC,wDAAwD;mBACpD,CAAC,EAAE,CAAC,UAAU,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAOtE;;;OAGG;uBACK,CAAC,EAAE,CAAC,UACF,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,KAC9B,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAOtC;;;;OAIG;sBACI,CAAC,OAAK,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAOvC;;;OAGG;wBACM,CAAC,iBAAiB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAOzE;;;OAGG;sBACI,CAAC,aACK,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,KACjC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAOtC;;;OAGG;uBACK,CAAC,aAAW,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;IAOlD;;OAEG;sBACI,CAAC,OAAK,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IAO7C;;OAEG;sBACI,CAAC,OAAK,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IAO7C;;;;;;;OAOG;yBACO,MAAM,EAAE,MAAM,OAAK,WAAW,CACtC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CACjC;CAeO,CAAC;AAMX;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,QAAQ,KAAK,WAAW,CAC5C,SAAS,QAAQ,EAAE,EACnB,OAAO,CAAC,QAAQ,CAAC,CAClB,CAKA;AAMD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,QAAQ,KAAK,WAAW,CAC3C,SAAS,QAAQ,EAAE,EACnB,OAAO,CAAC,QAAQ,CAAC,CAClB,CAKA"}

package/dist/option.js

@@ -0,0 +1,141 @@
+import { toAction, typedAction, branch, } from "./ast.js";
+import { chain } from "./chain.js";
+import { constant, drop, getIndex, identity, panic, splitFirst, splitLast, tag, } from "./builtins/index.js";
+import { Result } from "./result.js";
+// ---------------------------------------------------------------------------
+// Option namespace — combinators for Option<T> tagged unions
+// ---------------------------------------------------------------------------
+/**
+ * Option namespace. All combinators produce TypedAction AST nodes that
+ * desugar to branch + existing builtins, except collect which uses the
+ * CollectSome builtin.
+ */
+export const Option = {
+    /** Tag combinator: wrap value as `Option.Some`. `T → Option<T>` */
+    some() {
+        return tag("Some", "Option");
+    },
+    /** Tag combinator: wrap value as `Option.None`. `void → Option<T>` */
+    none() {
+        return tag("None", "Option");
+    },
+    /** Transform the Some value. `Option<T> → Option<U>` */
+    map(action) {
+        return branch({
+            Some: chain(action, Option.some()),
+            None: Option.none(),
+        });
+    },
+    /**
+     * Monadic bind (flatMap). If Some, pass the value to action which
+     * returns Option<U>. If None, stay None. `Option<T> → Option<U>`
+     */
+    andThen(action) {
+        return branch({
+            Some: action,
+            None: Option.none(),
+        });
+    },
+    /**
+     * Extract the Some value or panic. `Option<T> → T`
+     *
+     * Panics (fatal, not caught by tryCatch) if the value is None.
+     */
+    unwrap() {
+        return branch({
+            Some: identity(),
+            None: panic("called unwrap on None"),
+        });
+    },
+    /**
+     * Extract the Some value or produce a default from an action.
+     * `Option<T> → T`
+     */
+    unwrapOr(defaultAction) {
+        return branch({
+            Some: identity(),
+            None: defaultAction,
+        });
+    },
+    /**
+     * Conditional keep. If Some, pass value to predicate which returns
+     * Option<T>. If None, stay None. `Option<T> → Option<T>`
+     */
+    filter(predicate) {
+        return branch({
+            Some: predicate,
+            None: Option.none(),
+        });
+    },
+    /**
+     * Collect Some values from an array, discarding Nones.
+     * `Option<T>[] → T[]`
+     */
+    collect() {
+        return typedAction({
+            kind: "Invoke",
+            handler: { kind: "Builtin", builtin: { kind: "CollectSome" } },
+        });
+    },
+    /**
+     * Test if the value is Some. `Option<T> → boolean`
+     */
+    isSome() {
+        return branch({
+            Some: constant(true),
+            None: constant(false),
+        });
+    },
+    /**
+     * Test if the value is None. `Option<T> → boolean`
+     */
+    isNone() {
+        return branch({
+            Some: constant(false),
+            None: constant(true),
+        });
+    },
+    /**
+     * Swap Option/Result nesting.
+     * `Option<Result<TValue, TError>> → Result<Option<TValue>, TError>`
+     *
+     * - Some(Ok(t))  → Ok(Some(t))
+     * - Some(Err(e)) → Err(e)
+     * - None         → Ok(None)
+     */
+    transpose() {
+        return branch({
+            Some: branch({
+                Ok: chain(Option.some(), Result.ok()),
+                Err: Result.err(),
+            }),
+            None: chain(chain(drop, Option.none()), Result.ok()),
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// First — extract the first element of an array as Option<TElement>
+// ---------------------------------------------------------------------------
+/**
+ * Extract the first element of an array.
+ * `readonly TElement[] → Option<TElement>`
+ *
+ * Composes `splitFirst` (which returns `Option<[TElement, TElement[]]>`)
+ * with `Option.map(getIndex(0))` to extract just the element.
+ */
+export function first() {
+    return chain(toAction(splitFirst()), toAction(Option.map(toAction(getIndex(0).unwrap()))));
+}
+// ---------------------------------------------------------------------------
+// Last — extract the last element of an array as Option<TElement>
+// ---------------------------------------------------------------------------
+/**
+ * Extract the last element of an array.
+ * `readonly TElement[] → Option<TElement>`
+ *
+ * Composes `splitLast` (which returns `Option<[TElement[], TElement]>`)
+ * with `Option.map(getIndex(1))` to extract just the element.
+ */
+export function last() {
+    return chain(toAction(splitLast()), toAction(Option.map(toAction(getIndex(1).unwrap()))));
+}

package/dist/pipe.d.ts

@@ -0,0 +1,12 @@
+import { type PipeIn, type Pipeable, type TypedAction } from "./ast.js";
+export declare function pipe<TStep1, TStep2>(a1: Pipeable<TStep1, TStep2>): TypedAction<PipeIn<TStep1>, TStep2>;
+export declare function pipe<TStep1, TStep2, TStep3>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>): TypedAction<PipeIn<TStep1>, TStep3>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>): TypedAction<PipeIn<TStep1>, TStep4>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>): TypedAction<PipeIn<TStep1>, TStep5>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>): TypedAction<PipeIn<TStep1>, TStep6>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>, a6: Pipeable<TStep6, TStep7>): TypedAction<PipeIn<TStep1>, TStep7>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7, TStep8>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>, a6: Pipeable<TStep6, TStep7>, a7: Pipeable<TStep7, TStep8>): TypedAction<PipeIn<TStep1>, TStep8>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7, TStep8, TStep9>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>, a6: Pipeable<TStep6, TStep7>, a7: Pipeable<TStep7, TStep8>, a8: Pipeable<TStep8, TStep9>): TypedAction<PipeIn<TStep1>, TStep9>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7, TStep8, TStep9, TStep10>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>, a6: Pipeable<TStep6, TStep7>, a7: Pipeable<TStep7, TStep8>, a8: Pipeable<TStep8, TStep9>, a9: Pipeable<TStep9, TStep10>): TypedAction<PipeIn<TStep1>, TStep10>;
+export declare function pipe<TStep1, TStep2, TStep3, TStep4, TStep5, TStep6, TStep7, TStep8, TStep9, TStep10, TStep11>(a1: Pipeable<TStep1, TStep2>, a2: Pipeable<TStep2, TStep3>, a3: Pipeable<TStep3, TStep4>, a4: Pipeable<TStep4, TStep5>, a5: Pipeable<TStep5, TStep6>, a6: Pipeable<TStep6, TStep7>, a7: Pipeable<TStep7, TStep8>, a8: Pipeable<TStep8, TStep9>, a9: Pipeable<TStep9, TStep10>, a10: Pipeable<TStep10, TStep11>): TypedAction<PipeIn<TStep1>, TStep11>;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../src/pipe.ts"],"names":[],"mappings":"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"}

package/dist/pipe.js

@@ -0,0 +1,12 @@
+import { toAction, } from "./ast.js";
+import { chain } from "./chain.js";
+import { identity } from "./builtins/index.js";
+export function pipe(...actions) {
+    if (actions.length === 0) {
+        return identity();
+    }
+    if (actions.length === 1) {
+        return actions[0];
+    }
+    return actions.reduceRight((rest, first) => toAction(chain(toAction(first), toAction(rest))));
+}

package/dist/race.d.ts

@@ -0,0 +1,54 @@
+import { type Pipeable, type Result as ResultT, type TypedAction } from "./ast.js";
+/**
+ * Run multiple actions concurrently. The first to complete wins; losers
+ * are cancelled during `RestartHandle` frame teardown.
+ *
+ * All branches must have the same input and output type (since either
+ * could win).
+ *
+ * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
+ *   `Chain(Tag("Continue"),`
+ *     `RestartHandle(id, GetIndex(0),`
+ *       `Branch({`
+ *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
+ *         `Break: identity,`
+ *       `})))`
+ *
+ * First branch to complete tags Break → `RestartPerform` → handler restarts →
+ * Branch takes Break arm → identity → `RestartHandle` exits with winner's value.
+ */
+export declare function race<TIn, TOut>(...actions: Pipeable<TIn, TOut>[]): TypedAction<TIn, TOut>;
+/**
+ * Sleep for a fixed duration, ignoring input and returning void.
+ *
+ * `ms` is baked into the AST at construction time. Executed by the Rust
+ * scheduler via `tokio::time::sleep` — no subprocess spawned.
+ *
+ * To preserve data across a sleep, use `bindInput`.
+ */
+export declare function sleep(ms: number): TypedAction<any, void>;
+/**
+ * @internal TypeScript handler that takes ms as pipeline input and returns
+ * void after the timer fires. Used by `withTimeout` where the duration
+ * comes from a runtime pipeline, not a build-time constant.
+ */
+export declare function dynamicSleep(): void;
+/**
+ * Race the body against a sleep timer. Returns `Result<TOut, void>`:
+ * - Ok(value) if the body completed first
+ * - Err(void) if the timeout fired first
+ *
+ * The `ms` parameter is an AST node that evaluates to the timeout duration
+ * in milliseconds. Use `constant(5000)` for a fixed timeout, or any action
+ * that computes a duration from the pipeline input.
+ *
+ * Built as raw AST rather than through `race()` because each branch wraps
+ * its result differently (Ok vs Err) before the Break+Perform. `race()`
+ * requires homogeneous output types, but withTimeout needs heterogeneous
+ * tagging.
+ *
+ * Same restart+Branch substrate as race: each branch tags Break after
+ * wrapping its result as Ok or Err.
+ */
+export declare function withTimeout<TIn, TOut>(ms: Pipeable<TIn, number>, body: Pipeable<TIn, TOut>): TypedAction<TIn, ResultT<TOut, void>>;
+//# sourceMappingURL=race.d.ts.map

package/dist/race.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"race.d.ts","sourceRoot":"","sources":["../src/race.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,MAAM,IAAI,OAAO,EACtB,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AA2BlB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,IAAI,EAC5B,GAAG,OAAO,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,GAChC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAaxB;AAMD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAKxD;AAgBD;;;;GAIG;AAEH,wBAAgB,YAAY,IAAI,IAAI,CAAG;AAavC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,IAAI,EACnC,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,EACzB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,GACxB,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CA8BvC"}

package/dist/race.js

@@ -0,0 +1,116 @@
+import { toAction, typedAction, buildRestartBranchAction, } from "./ast.js";
+import { chain } from "./chain.js";
+import { identity, tag } from "./builtins/index.js";
+import { Result } from "./result.js";
+import { allocateRestartHandlerId, } from "./effect-id.js";
+/**
+ * `Chain(Tag("Break"), RestartPerform(id))` — shared by race branches.
+ * The winning branch tags its result as Break, then performs. The handler
+ * restarts the body; Branch takes the Break arm (identity), `RestartHandle` exits.
+ */
+function breakPerform(restartHandlerId) {
+    return toAction(chain(toAction(tag("Break", "LoopResult")), {
+        kind: "RestartPerform",
+        restart_handler_id: restartHandlerId,
+    }));
+}
+// ---------------------------------------------------------------------------
+// race — first branch to complete wins, losers cancelled
+// ---------------------------------------------------------------------------
+/**
+ * Run multiple actions concurrently. The first to complete wins; losers
+ * are cancelled during `RestartHandle` frame teardown.
+ *
+ * All branches must have the same input and output type (since either
+ * could win).
+ *
+ * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
+ *   `Chain(Tag("Continue"),`
+ *     `RestartHandle(id, GetIndex(0),`
+ *       `Branch({`
+ *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
+ *         `Break: identity,`
+ *       `})))`
+ *
+ * First branch to complete tags Break → `RestartPerform` → handler restarts →
+ * Branch takes Break arm → identity → `RestartHandle` exits with winner's value.
+ */
+export function race(...actions) {
+    const restartHandlerId = allocateRestartHandlerId();
+    const perform = breakPerform(restartHandlerId);
+    const branches = actions.map((action) => toAction(chain(toAction(action), toAction(perform))));
+    const allAction = { kind: "All", actions: branches };
+    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())));
+}
+// ---------------------------------------------------------------------------
+// sleep — Rust builtin that delays for a fixed duration (passthrough)
+// ---------------------------------------------------------------------------
+/**
+ * Sleep for a fixed duration, ignoring input and returning void.
+ *
+ * `ms` is baked into the AST at construction time. Executed by the Rust
+ * scheduler via `tokio::time::sleep` — no subprocess spawned.
+ *
+ * To preserve data across a sleep, use `bindInput`.
+ */
+export function sleep(ms) {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Sleep", ms } },
+    });
+}
+// ---------------------------------------------------------------------------
+// dynamicSleep — TypeScript handler for withTimeout (takes ms as input)
+// ---------------------------------------------------------------------------
+/** The raw Invoke node for the dynamic sleep handler. */
+const DYNAMIC_SLEEP_INVOKE = {
+    kind: "Invoke",
+    handler: {
+        kind: "TypeScript",
+        module: import.meta.url,
+        func: "dynamicSleep",
+    },
+};
+/**
+ * @internal TypeScript handler that takes ms as pipeline input and returns
+ * void after the timer fires. Used by `withTimeout` where the duration
+ * comes from a runtime pipeline, not a build-time constant.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function dynamicSleep() { }
+Object.defineProperty(dynamicSleep, "__definition", {
+    value: {
+        handle: ({ value }) => new Promise((resolve) => setTimeout(resolve, value)),
+    },
+    enumerable: false,
+});
+// ---------------------------------------------------------------------------
+// withTimeout — race body against sleep, return Result
+// ---------------------------------------------------------------------------
+/**
+ * Race the body against a sleep timer. Returns `Result<TOut, void>`:
+ * - Ok(value) if the body completed first
+ * - Err(void) if the timeout fired first
+ *
+ * The `ms` parameter is an AST node that evaluates to the timeout duration
+ * in milliseconds. Use `constant(5000)` for a fixed timeout, or any action
+ * that computes a duration from the pipeline input.
+ *
+ * Built as raw AST rather than through `race()` because each branch wraps
+ * its result differently (Ok vs Err) before the Break+Perform. `race()`
+ * requires homogeneous output types, but withTimeout needs heterogeneous
+ * tagging.
+ *
+ * Same restart+Branch substrate as race: each branch tags Break after
+ * wrapping its result as Ok or Err.
+ */
+export function withTimeout(ms, body) {
+    const restartHandlerId = allocateRestartHandlerId();
+    const perform = breakPerform(restartHandlerId);
+    // Branch 1: body → Tag("Ok") → Break → RestartPerform
+    const bodyBranch = toAction(chain(toAction(chain(toAction(body), toAction(Result.ok()))), toAction(perform)));
+    // Branch 2: ms → sleep() → Tag("Err") → Break → RestartPerform
+    const sleepBranch = toAction(chain(toAction(chain(toAction(chain(toAction(ms), toAction(DYNAMIC_SLEEP_INVOKE))), toAction(Result.err()))), toAction(perform)));
+    const allAction = { kind: "All", actions: [bodyBranch, sleepBranch] };
+    return typedAction(buildRestartBranchAction(restartHandlerId, allAction, toAction(identity())));
+}

package/dist/recursive.d.ts

@@ -0,0 +1,40 @@
+import { type Action, type Pipeable, type TypedAction } from "./ast.js";
+type FunctionDef = [input: unknown, output: unknown];
+type FunctionRefs<TDefs extends FunctionDef[]> = {
+    [K in keyof TDefs]: TypedAction<TDefs[K][0], TDefs[K][1]>;
+};
+/**
+ * Constraint for the entry-point callback return type. Only requires the
+ * output phantom field — omits __in and __in_co so that actions with
+ * any input type (e.g. pipelines starting from a call token) are assignable.
+ */
+type BodyResult<TOut> = Action & {
+    __out?: () => TOut;
+};
+/**
+ * Define mutually recursive functions that can call each other.
+ *
+ * The type parameter is an array of [In, Out] tuples — one per function.
+ * TypeScript can't infer these from circular definitions, so they must be
+ * explicit.
+ *
+ * Returns a curried combinator: the first callback defines function bodies,
+ * the second receives the same call tokens and returns the workflow entry
+ * point.
+ *
+ * Desugars to a ResumeHandle with a Branch-based handler. Each call token
+ * is Chain(Tag("CallN"), ResumePerform(id)). The handler dispatches to the
+ * correct function body by tag. The caller's pipeline is preserved as a
+ * ResumePerformFrame across each call.
+ *
+ * **Known limitation:** concurrent calls to the same function do not work
+ * as expected. `all(f(x), f(x))` will NOT call `f` twice — both branches
+ * perform on the same ResumeHandle, and the second perform will not
+ * execute independently. Use sequential calls (chain/then) instead of
+ * concurrent calls (all) when calling recursive functions multiple times.
+ */
+export declare function defineRecursiveFunctions<TDefs extends FunctionDef[]>(bodiesFn: (...fns: FunctionRefs<TDefs>) => {
+    [K in keyof TDefs]: Pipeable<TDefs[K][0], TDefs[K][1]>;
+}): <TOut>(entryFn: (...fns: FunctionRefs<TDefs>) => BodyResult<TOut>) => TypedAction<any, TOut>;
+export {};
+//# sourceMappingURL=recursive.d.ts.map

package/dist/recursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursive.d.ts","sourceRoot":"","sources":["../src/recursive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AAgBlB,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAErD,KAAK,YAAY,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI;KAC9C,CAAC,IAAI,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;GAIG;AACH,KAAK,UAAU,CAAC,IAAI,IAAI,MAAM,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,WAAW,EAAE,EAClE,QAAQ,EAAE,CAAC,GAAG,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK;KACxC,CAAC,IAAI,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvD,GACA,CAAC,IAAI,EACN,OAAO,EAAE,CAAC,GAAG,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,KACvD,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAwD1B"}