@barnum/barnum 0.0.0-main-50effdfd → 0.0.0-main-3c07d795

package/dist/ast.d.ts

@@ -68,10 +68,10 @@ export type BuiltinKind = {
 } | {
     kind: "Flatten";
 } | {
-    kind: "ExtractField";
+    kind: "GetField";
     value: string;
 } | {
-    kind: "ExtractIndex";
+    kind: "GetIndex";
     value: number;
 } | {
     kind: "Pick";
@@ -134,8 +134,10 @@ export type TypedAction<In = unknown, Out = unknown, Refs extends string = never
     drop(): TypedAction<In, never, Refs>;
     /** Wrap output as a tagged union member. Requires full variant map TDef so __def is carried. */
     tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind): TypedAction<In, TaggedUnion<TDef>, Refs>;
-    /** Extract a field from the output object. `a.get("name")` ≡ `pipe(a, extractField("name"))`. */
-    get<TField extends keyof Out & string>(field: TField): TypedAction<In, Out[TField], Refs>;
+    /** Extract a field from the output object. `a.getField("name")` ≡ `pipe(a, getField("name"))`. */
+    getField<TField extends keyof Out & string>(field: TField): TypedAction<In, Out[TField], Refs>;
+    /** Extract an element from the output tuple by index. `a.getIndex(0)` ≡ `pipe(a, getIndex(0))`. */
+    getIndex<TIn, TTuple extends unknown[], TIndex extends number, TRefs extends string>(this: TypedAction<TIn, TTuple, TRefs>, index: TIndex): TypedAction<TIn, TTuple[TIndex], TRefs>;
     /** Wrap output in an object under a field name. `a.wrapInField("foo")` ≡ `pipe(a, wrapInField("foo"))`. */
     wrapInField<TField extends string>(field: TField): TypedAction<In, Record<TField, Out>, Refs>;
     /** Merge a tuple of objects into a single object. `a.merge()` ≡ `pipe(a, merge())`. */
@@ -339,7 +341,7 @@ export declare const IDENTITY: Action;
  * If the body completes normally → output is TOut.
  * If restart fires → body re-executes with the restarted value.
  *
- * Compiled form: `RestartHandle(id, ExtractIndex(0), body)`
+ * Compiled form: `RestartHandle(id, GetIndex(0), body)`
  */
 export declare function recur<TIn = never, TOut = any>(bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut>): TypedAction<PipeIn<TIn>, TOut>;
 /**
@@ -357,7 +359,7 @@ export declare function recur<TIn = never, TOut = any>(bodyFn: (restart: TypedAc
 export declare function earlyReturn<TEarlyReturn = never, TIn = any, TOut = any>(bodyFn: (earlyReturn: TypedAction<TEarlyReturn, never>) => Pipeable<TIn, TOut>): TypedAction<TIn, TEarlyReturn | TOut>;
 /**
  * Build the restart+branch compiled form:
- * `Chain(Tag("Continue"), RestartHandle(id, ExtractIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
+ * `Chain(Tag("Continue"), RestartHandle(id, GetIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
  *
  * Input is tagged Continue so the Branch enters the continueArm on first execution.
  * Continue tag → restart → re-enters continueArm. Break tag → restart → runs breakArm, exits `RestartHandle`.

package/dist/ast.js

@@ -49,7 +49,7 @@ function tagMethod(kind) {
         },
     });
 }
-function getMethod(field) {
+function getFieldMethod(field) {
     return typedAction({
         kind: "Chain",
         first: this,
@@ -57,7 +57,20 @@ function getMethod(field) {
             kind: "Invoke",
             handler: {
                 kind: "Builtin",
-                builtin: { kind: "ExtractField", value: field },
+                builtin: { kind: "GetField", value: field },
+            },
+        },
+    });
+}
+function getIndexMethod(index) {
+    return typedAction({
+        kind: "Chain",
+        first: this,
+        rest: {
+            kind: "Invoke",
+            handler: {
+                kind: "Builtin",
+                builtin: { kind: "GetIndex", value: index },
             },
         },
     });
@@ -202,7 +215,8 @@ export function typedAction(action) {
             flatten: { value: flattenMethod, configurable: true },
             drop: { value: dropMethod, configurable: true },
             tag: { value: tagMethod, configurable: true },
-            get: { value: getMethod, 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 },
@@ -231,7 +245,7 @@ export function forEach(action) {
     return typedAction({ kind: "ForEach", action: action });
 }
 /**
- * Insert ExtractField("value") before each case handler in a branch.
+ * Insert GetField("value") before each case handler in a branch.
  * This implements auto-unwrapping: the engine dispatches on `kind`, then
  * extracts `value` before passing to the handler. Case handlers receive
  * the payload directly, not the full `{ kind, value }` variant.
@@ -245,7 +259,7 @@ function unwrapBranchCases(cases) {
                 kind: "Invoke",
                 handler: {
                     kind: "Builtin",
-                    builtin: { kind: "ExtractField", value: "value" },
+                    builtin: { kind: "GetField", value: "value" },
                 },
             },
             rest: cases[key],
@@ -262,7 +276,7 @@ export function branch(cases) {
 // ---------------------------------------------------------------------------
 const EXTRACT_PAYLOAD = {
     kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "ExtractIndex", value: 0 } },
+    handler: { kind: "Builtin", builtin: { kind: "GetIndex", value: 0 } },
 };
 const TAG_CONTINUE = {
     kind: "Invoke",
@@ -286,7 +300,7 @@ export const IDENTITY = {
  * If the body completes normally → output is TOut.
  * If restart fires → body re-executes with the restarted value.
  *
- * Compiled form: `RestartHandle(id, ExtractIndex(0), body)`
+ * Compiled form: `RestartHandle(id, GetIndex(0), body)`
  */
 export function recur(bodyFn) {
     const restartHandlerId = allocateRestartHandlerId();
@@ -332,7 +346,7 @@ export function earlyReturn(bodyFn) {
 // ---------------------------------------------------------------------------
 /**
  * Build the restart+branch compiled form:
- * `Chain(Tag("Continue"), RestartHandle(id, ExtractIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
+ * `Chain(Tag("Continue"), RestartHandle(id, GetIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
  *
  * Input is tagged Continue so the Branch enters the continueArm on first execution.
  * Continue tag → restart → re-enters continueArm. Break tag → restart → runs breakArm, exits `RestartHandle`.

package/dist/bind.d.ts

@@ -3,7 +3,7 @@ import { type Action, type ExtractInput, type ExtractOutput, type TypedAction }
  * A typed reference to a bound value. Output is `TValue`.
  *
  * Use `.then()` (not `pipe()`) when chaining a VarRef into a generic
- * action like `pick` or `extractField` — pipe overloads can't infer
+ * 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>;
@@ -33,7 +33,7 @@ export type InferVarRefs<TBindings extends Action[]> = {
  *     All(...bindings, Identity),
  *     ResumeHandle(r0, readVar(0),
  *       ResumeHandle(r1, readVar(1),
- *         Chain(ExtractIndex(N), body)
+ *         Chain(GetIndex(N), body)
  *       )
  *     )
  *   )

package/dist/bind.js

@@ -18,7 +18,7 @@ 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), GetIndex(n)), GetIndex(1))
  */
 function readVar(n) {
     return {
@@ -30,14 +30,14 @@ function readVar(n) {
                     kind: "Invoke",
                     handler: {
                         kind: "Builtin",
-                        builtin: { kind: "ExtractIndex", value: 1 },
+                        builtin: { kind: "GetIndex", value: 1 },
                     },
                 },
                 rest: {
                     kind: "Invoke",
                     handler: {
                         kind: "Builtin",
-                        builtin: { kind: "ExtractIndex", value: n },
+                        builtin: { kind: "GetIndex", value: n },
                     },
                 },
             },
@@ -45,7 +45,7 @@ function readVar(n) {
                 kind: "Invoke",
                 handler: {
                     kind: "Builtin",
-                    builtin: { kind: "ExtractIndex", value: 1 },
+                    builtin: { kind: "GetIndex", value: 1 },
                 },
             },
         ],
@@ -67,7 +67,7 @@ export function bind(bindings, body) {
             kind: "Invoke",
             handler: {
                 kind: "Builtin",
-                builtin: { kind: "ExtractIndex", value: pipelineInputIndex },
+                builtin: { kind: "GetIndex", value: pipelineInputIndex },
             },
         },
         rest: bodyAction,
@@ -81,7 +81,10 @@ export function bind(bindings, body) {
         };
     }
     // 5. All(...bindings, identity()) → nested Handles
-    const allActions = [...bindings.map((b) => b), identity];
+    const allActions = [
+        ...bindings.map((b) => b),
+        identity(),
+    ];
     return typedAction({
         kind: "Chain",
         first: { kind: "All", actions: allActions },
@@ -102,5 +105,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.d.ts

@@ -6,7 +6,7 @@ import { type Action, type MergeTuple, type Option as OptionT, type Pipeable, ty
  * kinds. The Rust scheduler executes them inline (no subprocess).
  */
 export declare function constant<TValue>(value: TValue): TypedAction<any, TValue>;
-export declare const identity: TypedAction<any, any>;
+export declare function identity<TValue = any>(): TypedAction<TValue, TValue>;
 export declare const drop: TypedAction<any, never>;
 /**
  * Wrap input as a tagged union member. Requires the full variant map TDef
@@ -18,8 +18,8 @@ export declare const drop: TypedAction<any, never>;
 export declare function tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind): TypedAction<TDef[TKind], TaggedUnion<TDef>>;
 export declare function merge<TTuple extends Record<string, unknown>[]>(): TypedAction<TTuple, MergeTuple<TTuple>>;
 export declare function flatten<TElement>(): TypedAction<TElement[][], TElement[]>;
-export declare function extractField<TObj extends Record<string, unknown>, TField extends keyof TObj & string>(field: TField): TypedAction<TObj, TObj[TField]>;
-export declare function extractIndex<TTuple extends unknown[], TIndex extends number>(index: TIndex): TypedAction<TTuple, TTuple[TIndex]>;
+export declare function getField<TObj extends Record<string, unknown>, TField extends keyof TObj & string>(field: TField): TypedAction<TObj, TObj[TField]>;
+export declare function getIndex<TTuple extends unknown[], TIndex extends number>(index: TIndex): TypedAction<TTuple, TTuple[TIndex]>;
 export declare function pick<TObj extends Record<string, unknown>, TKeys extends (keyof TObj & string)[]>(...keys: TKeys): TypedAction<TObj, Pick<TObj, TKeys[number]>>;
 export declare function dropResult<TInput, TOutput>(action: Pipeable<TInput, TOutput>): TypedAction<TInput, never>;
 /**

package/dist/builtins.js

@@ -18,10 +18,12 @@ export function constant(value) {
 // ---------------------------------------------------------------------------
 // Identity — pass input through unchanged
 // ---------------------------------------------------------------------------
-export const identity = typedAction({
-    kind: "Invoke",
-    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-});
+export function identity() {
+    return typedAction({
+        kind: "Invoke",
+        handler: { kind: "Builtin", builtin: { kind: "Identity" } },
+    });
+}
 // ---------------------------------------------------------------------------
 // Drop — discard pipeline value
 // ---------------------------------------------------------------------------
@@ -64,26 +66,26 @@ export function flatten() {
     });
 }
 // ---------------------------------------------------------------------------
-// ExtractField — extract a single field from an object
+// GetField — extract a single field from an object
 // ---------------------------------------------------------------------------
-export function extractField(field) {
+export function getField(field) {
     return typedAction({
         kind: "Invoke",
         handler: {
             kind: "Builtin",
-            builtin: { kind: "ExtractField", value: field },
+            builtin: { kind: "GetField", value: field },
         },
     });
 }
 // ---------------------------------------------------------------------------
-// ExtractIndex — extract a single element from an array by index
+// GetIndex — extract a single element from an array by index
 // ---------------------------------------------------------------------------
-export function extractIndex(index) {
+export function getIndex(index) {
     return typedAction({
         kind: "Invoke",
         handler: {
             kind: "Builtin",
-            builtin: { kind: "ExtractIndex", value: index },
+            builtin: { kind: "GetIndex", value: index },
         },
     });
 }
@@ -138,24 +140,24 @@ export function withResource({ create, action, dispose, }) {
     // Step 1: all(create, identity) → [TResource, TIn] → merge → TResource & TIn
     const acquireAndMerge = chain(typedAction({
         kind: "All",
-        actions: [create, identity],
+        actions: [create, identity()],
     }), typedAction(mergeBuiltin));
     // Step 2: all(action, identity) → [TOut, TResource & TIn]
     // Keep merged object so dispose can access resource fields.
     const actionAndKeepMerged = typedAction({
         kind: "All",
-        actions: [action, identity],
+        actions: [action, identity()],
     });
-    // Step 3: all(extractIndex(0), chain(extractIndex(1), dispose)) → [TOut, unknown]
+    // Step 3: all(getIndex(0), chain(getIndex(1), dispose)) → [TOut, unknown]
     const disposeAndKeepResult = typedAction({
         kind: "All",
         actions: [
-            extractIndex(0),
-            chain(extractIndex(1), dispose),
+            getIndex(0),
+            chain(getIndex(1), dispose),
         ],
     });
-    // Step 4: extractIndex(0) → TOut
-    return chain(chain(chain(acquireAndMerge, actionAndKeepMerged), disposeAndKeepResult), extractIndex(0));
+    // Step 4: getIndex(0) → TOut
+    return chain(chain(chain(acquireAndMerge, actionAndKeepMerged), disposeAndKeepResult), getIndex(0));
 }
 // ---------------------------------------------------------------------------
 // Tap — run an action for side effects, preserve original input
@@ -281,7 +283,7 @@ const EXTRACT_VALUE = {
     kind: "Invoke",
     handler: {
         kind: "Builtin",
-        builtin: { kind: "ExtractField", value: "value" },
+        builtin: { kind: "GetField", value: "value" },
     },
 };
 const DROP = {
@@ -292,7 +294,7 @@ const IDENTITY = {
     kind: "Invoke",
     handler: { kind: "Builtin", builtin: { kind: "Identity" } },
 };
-/** Wrap branch cases with ExtractField("value") auto-unwrapping. */
+/** Wrap branch cases with GetField("value") auto-unwrapping. */
 function optionBranch(someCaseBody, noneCaseBody) {
     return {
         kind: "Branch",
@@ -455,7 +457,7 @@ const TAG_ERR = {
     kind: "Invoke",
     handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Err" } },
 };
-/** Wrap branch cases with ExtractField("value") auto-unwrapping. */
+/** Wrap branch cases with GetField("value") auto-unwrapping. */
 function resultBranch(okCaseBody, errCaseBody) {
     return {
         kind: "Branch",

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/pipe.js

@@ -2,7 +2,7 @@ import { typedAction, } from "./ast.js";
 import { identity } from "./builtins.js";
 export function pipe(...actions) {
     if (actions.length === 0) {
-        return identity;
+        return identity();
     }
     if (actions.length === 1) {
         return actions[0];

package/dist/race.d.ts

@@ -8,7 +8,7 @@ import { type Pipeable, type Result, type TypedAction } from "./ast.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({`
  *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
  *         `Break: identity,`

package/dist/race.js

@@ -35,7 +35,7 @@ function breakPerform(restartHandlerId) {
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({`
  *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
  *         `Break: identity,`

package/dist/recursive.js

@@ -1,7 +1,7 @@
 import { typedAction, branch, } from "./ast.js";
 import { all } from "./all.js";
 import { chain } from "./chain.js";
-import { constant, identity, extractField, extractIndex, tag, } from "./builtins.js";
+import { constant, identity, getField, getIndex, tag } from "./builtins.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const UNUSED_STATE = undefined;
@@ -35,19 +35,19 @@ export function defineRecursiveFunctions(bodiesFn) {
     const callTokens = Array.from({ length: fnCount }, (_, i) => typedAction(chain(tag(`Call${i}`), resumePerform)));
     // Get function body ASTs
     const bodyActions = bodiesFn(...callTokens);
-    // Branch cases: CallN → ExtractField("value") → bodyN
+    // Branch cases: CallN → GetField("value") → bodyN
     const cases = {};
     for (let i = 0; i < bodyActions.length; i++) {
-        cases[`Call${i}`] = chain(extractField("value"), bodyActions[i]);
+        cases[`Call${i}`] = chain(getField("value"), bodyActions[i]);
     }
     // Return curried entry-point combinator
     return (entryFn) => {
         const userBody = entryFn(...callTokens);
-        return typedAction(chain(all(identity, constant(UNUSED_STATE)), {
+        return typedAction(chain(all(identity(), constant(UNUSED_STATE)), {
             kind: "ResumeHandle",
             resume_handler_id: resumeHandlerId,
-            body: chain(extractIndex(0), userBody),
-            handler: all(chain(extractIndex(0), branch(cases)), constant(UNUSED_STATE)),
+            body: chain(getIndex(0), userBody),
+            handler: all(chain(getIndex(0), branch(cases)), constant(UNUSED_STATE)),
         }));
     };
 }

package/dist/try-catch.d.ts

@@ -12,7 +12,7 @@ import { type Pipeable, type TypedAction } from "./ast.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({ Continue: body, Break: recovery })))`
  *
  * throwError = `Chain(Tag("Break"), RestartPerform(id))`

package/dist/try-catch.js

@@ -16,7 +16,7 @@ import { allocateRestartHandlerId } from "./effect-id.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({ Continue: body, Break: recovery })))`
  *
  * throwError = `Chain(Tag("Break"), RestartPerform(id))`

package/package.json

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

package/src/ast.ts

@@ -91,8 +91,8 @@ export type BuiltinKind =
   | { kind: "Tag"; value: string }
   | { kind: "Merge" }
   | { kind: "Flatten" }
-  | { kind: "ExtractField"; value: string }
-  | { kind: "ExtractIndex"; value: number }
+  | { kind: "GetField"; value: string }
+  | { kind: "GetIndex"; value: number }
   | { kind: "Pick"; value: string[] }
   | { kind: "CollectSome" }
   | { kind: "SplitFirst" }
@@ -183,10 +183,20 @@ export type TypedAction<
   tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(
     kind: TKind,
   ): TypedAction<In, TaggedUnion<TDef>, Refs>;
-  /** Extract a field from the output object. `a.get("name")` ≡ `pipe(a, extractField("name"))`. */
-  get<TField extends keyof Out & string>(
+  /** Extract a field from the output object. `a.getField("name")` ≡ `pipe(a, getField("name"))`. */
+  getField<TField extends keyof Out & string>(
     field: TField,
   ): TypedAction<In, Out[TField], Refs>;
+  /** Extract an element from the output tuple by index. `a.getIndex(0)` ≡ `pipe(a, getIndex(0))`. */
+  getIndex<
+    TIn,
+    TTuple extends unknown[],
+    TIndex extends number,
+    TRefs extends string,
+  >(
+    this: TypedAction<TIn, TTuple, TRefs>,
+    index: TIndex,
+  ): TypedAction<TIn, TTuple[TIndex], TRefs>;
   /** Wrap output in an object under a field name. `a.wrapInField("foo")` ≡ `pipe(a, wrapInField("foo"))`. */
   wrapInField<TField extends string>(
     field: TField,
@@ -428,7 +438,21 @@ function tagMethod(this: TypedAction, kind: string): TypedAction {
   });
 }
 
-function getMethod(this: TypedAction, field: string): TypedAction {
+function getFieldMethod(this: TypedAction, field: string): TypedAction {
+  return typedAction({
+    kind: "Chain",
+    first: this,
+    rest: {
+      kind: "Invoke",
+      handler: {
+        kind: "Builtin",
+        builtin: { kind: "GetField", value: field },
+      },
+    },
+  });
+}
+
+function getIndexMethod(this: TypedAction, index: number): TypedAction {
   return typedAction({
     kind: "Chain",
     first: this,
@@ -436,7 +460,7 @@ function getMethod(this: TypedAction, field: string): TypedAction {
       kind: "Invoke",
       handler: {
         kind: "Builtin",
-        builtin: { kind: "ExtractField", value: field },
+        builtin: { kind: "GetIndex", value: index },
       },
     },
   });
@@ -594,7 +618,8 @@ export function typedAction<
       flatten: { value: flattenMethod, configurable: true },
       drop: { value: dropMethod, configurable: true },
       tag: { value: tagMethod, configurable: true },
-      get: { value: getMethod, 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 },
@@ -659,7 +684,7 @@ export function forEach<In, Out>(
 }
 
 /**
- * Insert ExtractField("value") before each case handler in a branch.
+ * Insert GetField("value") before each case handler in a branch.
  * This implements auto-unwrapping: the engine dispatches on `kind`, then
  * extracts `value` before passing to the handler. Case handlers receive
  * the payload directly, not the full `{ kind, value }` variant.
@@ -675,7 +700,7 @@ function unwrapBranchCases(
         kind: "Invoke",
         handler: {
           kind: "Builtin",
-          builtin: { kind: "ExtractField", value: "value" },
+          builtin: { kind: "GetField", value: "value" },
         },
       },
       rest: cases[key],
@@ -725,7 +750,7 @@ export type LoopResult<TContinue, TBreak> = TaggedUnion<
 
 const EXTRACT_PAYLOAD: Action = {
   kind: "Invoke",
-  handler: { kind: "Builtin", builtin: { kind: "ExtractIndex", value: 0 } },
+  handler: { kind: "Builtin", builtin: { kind: "GetIndex", value: 0 } },
 };
 
 const TAG_CONTINUE: Action = {
@@ -754,7 +779,7 @@ export const IDENTITY: Action = {
  * If the body completes normally → output is TOut.
  * If restart fires → body re-executes with the restarted value.
  *
- * Compiled form: `RestartHandle(id, ExtractIndex(0), body)`
+ * Compiled form: `RestartHandle(id, GetIndex(0), body)`
  */
 export function recur<TIn = never, TOut = any>(
   bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut>,
@@ -818,7 +843,7 @@ export function earlyReturn<TEarlyReturn = never, TIn = any, TOut = any>(
 
 /**
  * Build the restart+branch compiled form:
- * `Chain(Tag("Continue"), RestartHandle(id, ExtractIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
+ * `Chain(Tag("Continue"), RestartHandle(id, GetIndex(0), Branch({ Continue: continueArm, Break: breakArm })))`
  *
  * Input is tagged Continue so the Branch enters the continueArm on first execution.
  * Continue tag → restart → re-enters continueArm. Break tag → restart → runs breakArm, exits `RestartHandle`.

package/src/bind.ts

@@ -17,7 +17,7 @@ import { pipe } from "./pipe.js";
  * A typed reference to a bound value. Output is `TValue`.
  *
  * Use `.then()` (not `pipe()`) when chaining a VarRef into a generic
- * action like `pick` or `extractField` — pipe overloads can't infer
+ * 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>;
@@ -61,7 +61,7 @@ export type InferVarRefs<TBindings extends Action[]> = {
  * `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), GetIndex(n)), GetIndex(1))
  */
 function readVar(n: number): Action {
   return {
@@ -73,14 +73,14 @@ function readVar(n: number): Action {
           kind: "Invoke",
           handler: {
             kind: "Builtin",
-            builtin: { kind: "ExtractIndex", value: 1 },
+            builtin: { kind: "GetIndex", value: 1 },
           },
         },
         rest: {
           kind: "Invoke",
           handler: {
             kind: "Builtin",
-            builtin: { kind: "ExtractIndex", value: n },
+            builtin: { kind: "GetIndex", value: n },
           },
         },
       },
@@ -88,7 +88,7 @@ function readVar(n: number): Action {
         kind: "Invoke",
         handler: {
           kind: "Builtin",
-          builtin: { kind: "ExtractIndex", value: 1 },
+          builtin: { kind: "GetIndex", value: 1 },
         },
       },
     ],
@@ -111,7 +111,7 @@ function readVar(n: number): Action {
  *     All(...bindings, Identity),
  *     ResumeHandle(r0, readVar(0),
  *       ResumeHandle(r1, readVar(1),
- *         Chain(ExtractIndex(N), body)
+ *         Chain(GetIndex(N), body)
  *       )
  *     )
  *   )
@@ -148,7 +148,7 @@ export function bind<TBindings extends Action[], TOut>(
       kind: "Invoke",
       handler: {
         kind: "Builtin",
-        builtin: { kind: "ExtractIndex", value: pipelineInputIndex },
+        builtin: { kind: "GetIndex", value: pipelineInputIndex },
       },
     },
     rest: bodyAction,
@@ -163,7 +163,10 @@ export function bind<TBindings extends Action[], TOut>(
   }
 
   // 5. All(...bindings, identity()) → nested Handles
-  const allActions = [...bindings.map((b) => b as Action), identity as Action];
+  const allActions = [
+    ...bindings.map((b) => b as Action),
+    identity() as Action,
+  ];
   return typedAction({
     kind: "Chain",
     first: { kind: "All", actions: allActions },
@@ -188,5 +191,5 @@ export function bind<TBindings extends Action[], TOut>(
 export function bindInput<TIn, TOut = any>(
   body: (input: VarRef<TIn>) => BodyResult<TOut>,
 ): TypedAction<TIn, TOut> {
-  return bind([identity], ([input]) => pipe(drop, body(input)));
+  return bind([identity()], ([input]) => pipe(drop, body(input)));
 }

package/src/builtins.ts

@@ -32,10 +32,12 @@ export function constant<TValue>(value: TValue): TypedAction<any, TValue> {
 // Identity — pass input through unchanged
 // ---------------------------------------------------------------------------
 
-export const identity: TypedAction<any, any> = typedAction({
-  kind: "Invoke",
-  handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-});
+export function identity<TValue = any>(): TypedAction<TValue, TValue> {
+  return typedAction({
+    kind: "Invoke",
+    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
+  });
+}
 
 // ---------------------------------------------------------------------------
 // Drop — discard pipeline value
@@ -93,10 +95,10 @@ export function flatten<TElement>(): TypedAction<TElement[][], TElement[]> {
 }
 
 // ---------------------------------------------------------------------------
-// ExtractField — extract a single field from an object
+// GetField — extract a single field from an object
 // ---------------------------------------------------------------------------
 
-export function extractField<
+export function getField<
   TObj extends Record<string, unknown>,
   TField extends keyof TObj & string,
 >(field: TField): TypedAction<TObj, TObj[TField]> {
@@ -104,23 +106,23 @@ export function extractField<
     kind: "Invoke",
     handler: {
       kind: "Builtin",
-      builtin: { kind: "ExtractField", value: field },
+      builtin: { kind: "GetField", value: field },
     },
   });
 }
 
 // ---------------------------------------------------------------------------
-// ExtractIndex — extract a single element from an array by index
+// GetIndex — extract a single element from an array by index
 // ---------------------------------------------------------------------------
 
-export function extractIndex<TTuple extends unknown[], TIndex extends number>(
+export function getIndex<TTuple extends unknown[], TIndex extends number>(
   index: TIndex,
 ): TypedAction<TTuple, TTuple[TIndex]> {
   return typedAction({
     kind: "Invoke",
     handler: {
       kind: "Builtin",
-      builtin: { kind: "ExtractIndex", value: index },
+      builtin: { kind: "GetIndex", value: index },
     },
   });
 }
@@ -201,7 +203,7 @@ export function withResource<
   const acquireAndMerge = chain(
     typedAction<TIn, [TResource, TIn]>({
       kind: "All",
-      actions: [create as Action, identity as Action],
+      actions: [create as Action, identity() as Action],
     }),
     typedAction<[TResource, TIn], TResource & TIn>(mergeBuiltin),
   );
@@ -213,28 +215,28 @@ export function withResource<
     [TOut, TResource & TIn]
   >({
     kind: "All",
-    actions: [action as Action, identity as Action],
+    actions: [action as Action, identity() as Action],
   });
 
-  // Step 3: all(extractIndex(0), chain(extractIndex(1), dispose)) → [TOut, unknown]
+  // Step 3: all(getIndex(0), chain(getIndex(1), dispose)) → [TOut, unknown]
   const disposeAndKeepResult = typedAction<
     [TOut, TResource & TIn],
     [TOut, unknown]
   >({
     kind: "All",
     actions: [
-      extractIndex<[TOut, TResource & TIn], 0>(0) as Action,
+      getIndex<[TOut, TResource & TIn], 0>(0) as Action,
       chain(
-        extractIndex<[TOut, TResource & TIn], 1>(1),
+        getIndex<[TOut, TResource & TIn], 1>(1),
         dispose as Pipeable<TResource & TIn, unknown>,
       ) as Action,
     ],
   });
 
-  // Step 4: extractIndex(0) → TOut
+  // Step 4: getIndex(0) → TOut
   return chain(
     chain(chain(acquireAndMerge, actionAndKeepMerged), disposeAndKeepResult),
-    extractIndex<[TOut, unknown], 0>(0),
+    getIndex<[TOut, unknown], 0>(0),
   ) as TypedAction<TIn, TOut>;
 }
 
@@ -383,7 +385,7 @@ const EXTRACT_VALUE: Action = {
   kind: "Invoke",
   handler: {
     kind: "Builtin",
-    builtin: { kind: "ExtractField", value: "value" },
+    builtin: { kind: "GetField", value: "value" },
   },
 };
 const DROP: Action = {
@@ -395,7 +397,7 @@ const IDENTITY: Action = {
   handler: { kind: "Builtin", builtin: { kind: "Identity" } },
 };
 
-/** Wrap branch cases with ExtractField("value") auto-unwrapping. */
+/** Wrap branch cases with GetField("value") auto-unwrapping. */
 function optionBranch(someCaseBody: Action, noneCaseBody: Action): Action {
   return {
     kind: "Branch",
@@ -590,7 +592,7 @@ const TAG_ERR: Action = {
   handler: { kind: "Builtin", builtin: { kind: "Tag", value: "Err" } },
 };
 
-/** Wrap branch cases with ExtractField("value") auto-unwrapping. */
+/** Wrap branch cases with GetField("value") auto-unwrapping. */
 function resultBranch(okCaseBody: Action, errCaseBody: Action): Action {
   return {
     kind: "Branch",

package/src/index.ts

@@ -8,8 +8,8 @@ export {
   tag,
   merge,
   flatten,
-  extractField,
-  extractIndex,
+  getField,
+  getIndex,
   pick,
   dropResult,
   withResource,

package/src/pipe.ts

@@ -82,7 +82,7 @@ export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
 ): TypedAction<PipeIn<T1>, T11>;
 export function pipe(...actions: Action[]): Action {
   if (actions.length === 0) {
-    return identity;
+    return identity();
   }
   if (actions.length === 1) {
     return actions[0];

package/src/race.ts

@@ -53,7 +53,7 @@ function breakPerform(restartHandlerId: RestartHandlerId): Action {
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({`
  *         `Continue: All(Chain(a, breakPerform), Chain(b, breakPerform), ...),`
  *         `Break: identity,`

package/src/recursive.ts

@@ -7,13 +7,7 @@ import {
 } from "./ast.js";
 import { all } from "./all.js";
 import { chain } from "./chain.js";
-import {
-  constant,
-  identity,
-  extractField,
-  extractIndex,
-  tag,
-} from "./builtins.js";
+import { constant, identity, getField, getIndex, tag } from "./builtins.js";
 import { allocateResumeHandlerId } from "./effect-id.js";
 
 // ---------------------------------------------------------------------------
@@ -84,11 +78,11 @@ export function defineRecursiveFunctions<TDefs extends FunctionDef[]>(
     ...(callTokens as FunctionRefs<TDefs>),
   ) as Action[];
 
-  // Branch cases: CallN → ExtractField("value") → bodyN
+  // Branch cases: CallN → GetField("value") → bodyN
   const cases: Record<string, Action> = {};
   for (let i = 0; i < bodyActions.length; i++) {
     cases[`Call${i}`] = chain(
-      extractField("value"),
+      getField("value"),
       bodyActions[i] as any,
     ) as Action;
   }
@@ -98,12 +92,12 @@ export function defineRecursiveFunctions<TDefs extends FunctionDef[]>(
     const userBody = entryFn(...(callTokens as FunctionRefs<TDefs>)) as Action;
 
     return typedAction<any, TOut>(
-      chain(all(identity, constant(UNUSED_STATE)), {
+      chain(all(identity(), constant(UNUSED_STATE)), {
         kind: "ResumeHandle",
         resume_handler_id: resumeHandlerId,
-        body: chain(extractIndex(0), userBody as any) as Action,
+        body: chain(getIndex(0), userBody as any) as Action,
         handler: all(
-          chain(extractIndex(0), branch(cases) as any),
+          chain(getIndex(0), branch(cases) as any),
           constant(UNUSED_STATE),
         ) as Action,
       } as Action) as Action,

package/src/try-catch.ts

@@ -25,7 +25,7 @@ import { allocateRestartHandlerId } from "./effect-id.js";
  *
  * Compiled form (restart+Branch, same substrate as loop/earlyReturn):
  *   `Chain(Tag("Continue"),`
- *     `RestartHandle(id, ExtractIndex(0),`
+ *     `RestartHandle(id, GetIndex(0),`
  *       `Branch({ Continue: body, Break: recovery })))`
  *
  * throwError = `Chain(Tag("Break"), RestartPerform(id))`