@barnum/barnum 0.0.0-main-54c41bbb → 0.0.0-main-57736a4e

package/dist/ast.js

@@ -1,5 +1,23 @@
 import { chain } from "./chain.js";
-import { drop, flatten as flattenBuiltin, getField, getIndex, identity, merge, Option, pick, Result, splitFirst, splitLast, tag, wrapInField, } from "./builtins.js";
+import { constant, drop, extractPrefix, flatten as flattenBuiltin, getField, getIndex, identity, panic, pick, splitFirst, splitLast, tag, wrapInField, asOption as asOptionStandalone, } from "./builtins/index.js";
+import { Option } from "./option.js";
+import { Result } from "./result.js";
+// Lazy import — iterator.ts imports from ast.ts, but these are only called inside
+// methods (after all modules load), so the circular reference is safe at runtime.
+import { Iterator as IteratorNs } from "./iterator.js";
+// Lazy import — bind.ts imports from ast.ts, but these are only called inside
+// methods (after all modules load), so the circular reference is safe at runtime.
+import { bind as bindStandalone, bindInput as bindInputStandalone, } from "./bind.js";
+/**
+ * Strip phantom types from a Pipeable, returning a plain Action.
+ *
+ * Replaces `x as Action` casts throughout the codebase. The constraint
+ * ensures the argument is structurally a Pipeable — unlike a bare cast,
+ * `toAction(123)` is a type error.
+ */
+export function toAction(pipeable) {
+    return pipeable;
+}
 // ---------------------------------------------------------------------------
 // typedAction — attach .then() and .forEach() as non-enumerable methods
 // ---------------------------------------------------------------------------
@@ -7,50 +25,182 @@ import { drop, flatten as flattenBuiltin, getField, getIndex, identity, merge, O
 function thenMethod(next) {
     return chain(this, next);
 }
-function forEachMethod(action) {
-    return chain(this, forEach(action));
-}
 function branchMethod(cases) {
-    return chain(this, branch(cases));
+    return chain(toAction(this), toAction(branch(cases)));
 }
 function flattenMethod() {
-    return chain(this, flattenBuiltin());
+    return chain(toAction(this), toAction(flattenBuiltin()));
 }
 function dropMethod() {
-    return chain(this, drop);
+    return chain(toAction(this), toAction(drop));
 }
-function tagMethod(kind) {
-    return chain(this, tag(kind));
+function tagMethod(kind, enumName) {
+    return chain(toAction(this), toAction(tag(kind, enumName)));
+}
+function someMethod() {
+    return chain(toAction(this), toAction(Option.some()));
+}
+function okMethod() {
+    return chain(toAction(this), toAction(Result.ok()));
+}
+function errMethod() {
+    return chain(toAction(this), toAction(Result.err()));
 }
 function getFieldMethod(field) {
-    return chain(this, getField(field));
+    return chain(toAction(this), toAction(getField(field)));
 }
 function getIndexMethod(index) {
-    return chain(this, getIndex(index));
+    return chain(toAction(this), toAction(getIndex(index)));
 }
 function wrapInFieldMethod(field) {
-    return chain(this, wrapInField(field));
-}
-function mergeMethod() {
-    return chain(this, merge());
+    return chain(toAction(this), toAction(wrapInField(field)));
 }
 function pickMethod(...keys) {
-    return chain(this, pick(...keys));
+    return chain(toAction(this), toAction(pick(...keys)));
 }
 function splitFirstMethod() {
-    return chain(this, splitFirst());
+    return chain(toAction(this), toAction(splitFirst()));
 }
 function splitLastMethod() {
-    return chain(this, splitLast());
+    return chain(toAction(this), toAction(splitLast()));
 }
-function mapOptionMethod(action) {
-    return chain(this, Option.map(action));
+// --- Shared postfix methods (Option + Result) — dispatch via branchFamily ---
+function mapMethod(action) {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({
+            Ok: chain(toAction(action), toAction(Result.ok())),
+            Err: Result.err(),
+        }),
+        Option: branch({
+            Some: chain(toAction(action), toAction(Option.some())),
+            None: Option.none(),
+        }),
+        Iterator: IteratorNs.map(action),
+    })));
 }
-function mapErrMethod(action) {
-    return chain(this, Result.mapErr(action));
+function unwrapMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: identity(), Err: panic("called unwrap on Err") }),
+        Option: branch({
+            Some: identity(),
+            None: panic("called unwrap on None"),
+        }),
+    })));
 }
 function unwrapOrMethod(defaultAction) {
-    return chain(this, Result.unwrapOr(defaultAction));
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: identity(), Err: defaultAction }),
+        Option: branch({ Some: identity(), None: defaultAction }),
+    })));
+}
+function andThenMethod(action) {
+    return chain(toAction(this), toAction(branchFamily({
+        Result: branch({ Ok: action, Err: Result.err() }),
+        Option: branch({ Some: action, None: Option.none() }),
+    })));
+}
+function transposeMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: branch({
+            Some: branch({
+                Ok: chain(toAction(Option.some()), toAction(Result.ok())),
+                Err: Result.err(),
+            }),
+            None: chain(toAction(chain(toAction(drop), toAction(Option.none()))), toAction(Result.ok())),
+        }),
+        Result: branch({
+            Ok: branch({
+                Some: chain(toAction(Result.ok()), toAction(Option.some())),
+                None: chain(toAction(drop), toAction(Option.none())),
+            }),
+            Err: chain(toAction(Result.err()), toAction(Option.some())),
+        }),
+    })));
+}
+// --- Result-only postfix methods ---
+function mapErrMethod(action) {
+    return chain(toAction(this), toAction(branch({
+        Ok: Result.ok(),
+        Err: chain(toAction(action), toAction(Result.err())),
+    })));
+}
+function orMethod(fallback) {
+    return chain(toAction(this), toAction(branch({
+        Ok: Result.ok(),
+        Err: fallback,
+    })));
+}
+function asOkOptionMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: Option.some(),
+        Err: chain(toAction(drop), toAction(Option.none())),
+    })));
+}
+function asErrOptionMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: chain(toAction(drop), toAction(Option.none())),
+        Err: Option.some(),
+    })));
+}
+function isOkMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: constant(true),
+        Err: constant(false),
+    })));
+}
+function isErrMethod() {
+    return chain(toAction(this), toAction(branch({
+        Ok: constant(false),
+        Err: constant(true),
+    })));
+}
+// --- Option-only postfix methods ---
+function filterMethod(predicate) {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: branch({
+            Some: predicate,
+            None: Option.none(),
+        }),
+        Iterator: IteratorNs.filter(predicate),
+    })));
+}
+function isSomeMethod() {
+    return chain(toAction(this), toAction(branch({
+        Some: constant(true),
+        None: constant(false),
+    })));
+}
+function isNoneMethod() {
+    return chain(toAction(this), toAction(branch({
+        Some: constant(false),
+        None: constant(true),
+    })));
+}
+function asOptionMethod() {
+    return chain(toAction(this), toAction(asOptionStandalone()));
+}
+// --- Iterator postfix methods ---
+function iterateMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Option: IteratorNs.fromOption(),
+        Result: IteratorNs.fromResult(),
+        Array: IteratorNs.fromArray(),
+    })));
+}
+function flatMapMethod(action) {
+    return chain(toAction(this), toAction(IteratorNs.flatMap(action)));
+}
+function collectMethod() {
+    return chain(toAction(this), toAction(branchFamily({
+        Array: Option.collect(),
+        Iterator: IteratorNs.collect(),
+    })));
+}
+function bindMethod(bindings, body) {
+    return chain(toAction(this), toAction(bindStandalone(bindings, body)));
+}
+function bindInputMethod(body) {
+    return chain(toAction(this), toAction(bindInputStandalone(body)));
 }
 /**
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
@@ -60,21 +210,39 @@ export function typedAction(action) {
     if (!("then" in action)) {
         Object.defineProperties(action, {
             then: { value: thenMethod, configurable: true },
-            forEach: { value: forEachMethod, configurable: true },
             branch: { value: branchMethod, configurable: true },
             flatten: { value: flattenMethod, configurable: true },
             drop: { value: dropMethod, configurable: true },
             tag: { value: tagMethod, configurable: true },
+            some: { value: someMethod, configurable: true },
+            ok: { value: okMethod, configurable: true },
+            err: { value: errMethod, configurable: true },
             getField: { value: getFieldMethod, configurable: true },
             getIndex: { value: getIndexMethod, configurable: true },
             wrapInField: { value: wrapInFieldMethod, configurable: true },
-            merge: { value: mergeMethod, configurable: true },
             pick: { value: pickMethod, configurable: true },
             splitFirst: { value: splitFirstMethod, configurable: true },
             splitLast: { value: splitLastMethod, configurable: true },
-            mapOption: { value: mapOptionMethod, configurable: true },
+            map: { value: mapMethod, configurable: true },
             mapErr: { value: mapErrMethod, configurable: true },
+            unwrap: { value: unwrapMethod, configurable: true },
             unwrapOr: { value: unwrapOrMethod, configurable: true },
+            andThen: { value: andThenMethod, configurable: true },
+            filter: { value: filterMethod, configurable: true },
+            isSome: { value: isSomeMethod, configurable: true },
+            isNone: { value: isNoneMethod, configurable: true },
+            asOption: { value: asOptionMethod, configurable: true },
+            collect: { value: collectMethod, configurable: true },
+            or: { value: orMethod, configurable: true },
+            iterate: { value: iterateMethod, configurable: true },
+            flatMap: { value: flatMapMethod, configurable: true },
+            asOkOption: { value: asOkOptionMethod, configurable: true },
+            asErrOption: { value: asErrOptionMethod, configurable: true },
+            isOk: { value: isOkMethod, configurable: true },
+            isErr: { value: isErrMethod, configurable: true },
+            transpose: { value: transposeMethod, configurable: true },
+            bind: { value: bindMethod, configurable: true },
+            bindInput: { value: bindInputMethod, configurable: true },
         });
     }
     return action;
@@ -92,7 +260,7 @@ import { allocateRestartHandlerId, } from "./effect-id.js";
 export { tryCatch } from "./try-catch.js";
 export { race, sleep, withTimeout } from "./race.js";
 export function forEach(action) {
-    return typedAction({ kind: "ForEach", action: action });
+    return typedAction({ kind: "ForEach", action: toAction(action) });
 }
 /**
  * Insert GetField("value") before each case handler in a branch.
@@ -103,7 +271,7 @@ export function forEach(action) {
 function unwrapBranchCases(cases) {
     const unwrapped = {};
     for (const key of Object.keys(cases)) {
-        unwrapped[key] = chain(getField("value"), cases[key]);
+        unwrapped[key] = toAction(chain(toAction(getField("value")), toAction(cases[key])));
     }
     return unwrapped;
 }
@@ -111,6 +279,21 @@ function unwrapBranchCases(cases) {
 export function branch(cases) {
     return typedAction({ kind: "Branch", cases: unwrapBranchCases(cases) });
 }
+/**
+ * Two-level dispatch: extract the enum prefix from a tagged value's `kind`,
+ * then branch on that prefix. Used by postfix methods (`.map()`, `.unwrapOr()`,
+ * etc.) to dispatch across union families (Option, Result) without runtime
+ * metadata.
+ *
+ * `branchFamily({ Result: ..., Option: ... })` ≡ `chain(extractPrefix(), branch(cases))`
+ */
+export function branchFamily(cases) {
+    return typedAction({
+        kind: "Chain",
+        first: toAction(extractPrefix()),
+        rest: toAction(branch(cases)),
+    });
+}
 // ---------------------------------------------------------------------------
 // recur — restart body primitive
 // ---------------------------------------------------------------------------
@@ -129,12 +312,12 @@ export function recur(bodyFn) {
         kind: "RestartPerform",
         restart_handler_id: restartHandlerId,
     });
-    const body = bodyFn(restartAction);
+    const body = toAction(bodyFn(restartAction));
     return typedAction({
         kind: "RestartHandle",
         restart_handler_id: restartHandlerId,
         body,
-        handler: getIndex(0),
+        handler: toAction(getIndex(0).unwrap()),
     });
 }
 // ---------------------------------------------------------------------------
@@ -154,12 +337,12 @@ export function recur(bodyFn) {
  */
 export function earlyReturn(bodyFn) {
     const restartHandlerId = allocateRestartHandlerId();
-    const earlyReturnAction = typedAction(chain(tag("Break"), {
+    const earlyReturnAction = typedAction(toAction(chain(toAction(tag("Break", "LoopResult")), {
         kind: "RestartPerform",
         restart_handler_id: restartHandlerId,
-    }));
-    const body = bodyFn(earlyReturnAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, identity()));
+    })));
+    const body = toAction(bodyFn(earlyReturnAction));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, toAction(identity())));
 }
 // ---------------------------------------------------------------------------
 // loop — iterative restart with break
@@ -174,12 +357,12 @@ export function earlyReturn(bodyFn) {
  * Used by earlyReturn, loop, tryCatch, and race.
  */
 export function buildRestartBranchAction(restartHandlerId, continueArm, breakArm) {
-    return chain(tag("Continue"), {
+    return toAction(chain(toAction(tag("Continue", "LoopResult")), {
         kind: "RestartHandle",
         restart_handler_id: restartHandlerId,
-        body: branch({ Continue: continueArm, Break: breakArm }),
-        handler: getIndex(0),
-    });
+        body: toAction(branch({ Continue: continueArm, Break: breakArm })),
+        handler: toAction(getIndex(0).unwrap()),
+    }));
 }
 /**
  * Iterative loop. The body callback receives `recur` and `done`:
@@ -196,10 +379,10 @@ export function loop(bodyFn) {
         kind: "RestartPerform",
         restart_handler_id: restartHandlerId,
     };
-    const recurAction = typedAction(chain(tag("Continue"), perform));
-    const doneAction = typedAction(chain(tag("Break"), perform));
-    const body = bodyFn(recurAction, doneAction);
-    return typedAction(buildRestartBranchAction(restartHandlerId, body, identity()));
+    const recurAction = typedAction(toAction(chain(toAction(tag("Continue", "LoopResult")), toAction(perform))));
+    const doneAction = typedAction(toAction(chain(toAction(tag("Break", "LoopResult")), toAction(perform))));
+    const body = toAction(bodyFn(recurAction, doneAction));
+    return typedAction(buildRestartBranchAction(restartHandlerId, body, toAction(identity())));
 }
 // ---------------------------------------------------------------------------
 // Config builders

package/dist/bind.d.ts

@@ -6,17 +6,14 @@ import { type Action, type ExtractInput, type ExtractOutput, type TypedAction }
  * action like `pick` or `getField` — pipe overloads can't infer
  * the generic's type parameter from the VarRef's output.
  */
-export type VarRef<TValue> = TypedAction<never, TValue>;
+export type VarRef<TValue> = TypedAction<any, TValue>;
 /**
  * Maps each binding's output type to a VarRef. TypeScript resolves
  * ExtractOutput from each binding expression.
  *
- * Constraint is `Action[]` (not `Pipeable<any, any>[]`) because
- * `TypedAction<never, X>` (e.g. from `constant()`) fails the invariant
- * `__in` check against `Pipeable<any, any>` on the 9-variant
- * Action union. Using raw `Action[]` avoids the phantom field
- * assignability issue while `ExtractOutput` still extracts the correct
- * output type from the phantom fields on the concrete types.
+ * Constraint is `Action[]` (not `Pipeable<any, any>[]`) so that
+ * `ExtractOutput` extracts the correct output type from the phantom
+ * fields on the concrete types without fighting invariant `__in` checks.
  */
 export type InferVarRefs<TBindings extends Action[]> = {
     [K in keyof TBindings]: VarRef<ExtractOutput<TBindings[K]>>;
@@ -40,12 +37,11 @@ export type InferVarRefs<TBindings extends Action[]> = {
  */
 /**
  * Constraint for the body callback return type. Only requires the output
- * phantom fields — omits `__in` and `__in_co` so that body actions with
- * `In = never` (e.g. pipelines starting from a VarRef) are assignable.
+ * phantom field — omits `__in` and `__in_co` so that body actions with
+ * any input type (e.g. pipelines starting from a VarRef) are assignable.
  */
 type BodyResult<TOut> = Action & {
     __out?: () => TOut;
-    __out_contra?: (output: TOut) => void;
 };
 export declare function bind<TBindings extends Action[], TOut>(bindings: [...TBindings], body: (vars: InferVarRefs<TBindings>) => BodyResult<TOut>): TypedAction<ExtractInput<TBindings[number]>, TOut>;
 /**
@@ -60,3 +56,4 @@ export declare function bind<TBindings extends Action[], TOut>(bindings: [...TBi
  */
 export declare function bindInput<TIn, TOut = any>(body: (input: VarRef<TIn>) => BodyResult<TOut>): TypedAction<TIn, TOut>;
 export {};
+//# sourceMappingURL=bind.d.ts.map

package/dist/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../src/bind.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAGjB,MAAM,UAAU,CAAC;AAWlB;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,IAAI,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAetD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI;KACpD,CAAC,IAAI,MAAM,SAAS,GAAG,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5D,CAAC;AA4BF;;;;;;;;;;;;;;;;GAgBG;AACH;;;;GAIG;AACH,KAAK,UAAU,CAAC,IAAI,IAAI,MAAM,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,wBAAgB,IAAI,CAAC,SAAS,SAAS,MAAM,EAAE,EAAE,IAAI,EACnD,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,EACxB,IAAI,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,SAAS,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,GACxD,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAkCpD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EACvC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,IAAI,CAAC,GAC7C,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAExB"}

package/dist/bind.js

@@ -1,7 +1,7 @@
-import { typedAction, } from "./ast.js";
+import { toAction, typedAction, } from "./ast.js";
 import { chain } from "./chain.js";
 import { all } from "./all.js";
-import { identity, drop, getIndex } from "./builtins.js";
+import { identity, drop, getIndex } from "./builtins/index.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 import { pipe } from "./pipe.js";
 function createVarRef(resumeHandlerId) {
@@ -20,10 +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(GetIndex(1), GetIndex(n)), GetIndex(1))
+ * Expanded AST: All(Chain(GetIndex(1).unwrap(), GetIndex(n).unwrap()), GetIndex(1).unwrap())
  */
 function readVar(n) {
-    return all(chain(getIndex(1), getIndex(n)), getIndex(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.
@@ -31,11 +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 = chain(getIndex(pipelineInputIndex), bodyAction);
+    let inner = toAction(chain(toAction(getIndex(pipelineInputIndex).unwrap()), toAction(bodyAction)));
     for (let i = resumeHandlerIds.length - 1; i >= 0; i--) {
         inner = {
             kind: "ResumeHandle",
@@ -47,9 +47,9 @@ export function bind(bindings, body) {
     // 5. All(...bindings, identity()) → nested Handles
     const allAction = {
         kind: "All",
-        actions: [...bindings.map((b) => b), identity()],
+        actions: [...bindings.map((b) => toAction(b)), toAction(identity())],
     };
-    return typedAction(chain(allAction, inner));
+    return typedAction(toAction(chain(toAction(allAction), toAction(inner))));
 }
 // ---------------------------------------------------------------------------
 // bindInput — bind the pipeline input

package/dist/builtins/array.d.ts

@@ -0,0 +1,28 @@
+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]>>;
+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,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,74 @@
+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" } },
+    });
+}
+// ---------------------------------------------------------------------------
+// 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, 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,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC7E,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, 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 } },
+    });
+}