@barnum/barnum 0.0.0-main-e8b82cff → 0.0.0-main-d605f564

package/package.json

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

package/src/all.ts

@@ -8,217 +8,79 @@ import { constant } from "./builtins.js";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function all(): TypedAction<any, []>;
-export function all<In, O1, R1 extends string>(
-  a1: Pipeable<In, O1, R1>,
-): TypedAction<In, [O1], R1>;
-export function all<In, O1, O2, R1 extends string, R2 extends string>(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-): TypedAction<In, [O1, O2], R1 | R2>;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-): TypedAction<In, [O1, O2, O3], R1 | R2 | R3>;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-): TypedAction<In, [O1, O2, O3, O4], R1 | R2 | R3 | R4>;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-): TypedAction<In, [O1, O2, O3, O4, O5], R1 | R2 | R3 | R4 | R5>;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  O6,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-  a6: Pipeable<In, O6, R6>,
-): TypedAction<In, [O1, O2, O3, O4, O5, O6], R1 | R2 | R3 | R4 | R5 | R6>;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  O6,
-  O7,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-  a6: Pipeable<In, O6, R6>,
-  a7: Pipeable<In, O7, R7>,
-): TypedAction<
-  In,
-  [O1, O2, O3, O4, O5, O6, O7],
-  R1 | R2 | R3 | R4 | R5 | R6 | R7
->;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  O6,
-  O7,
-  O8,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-  a6: Pipeable<In, O6, R6>,
-  a7: Pipeable<In, O7, R7>,
-  a8: Pipeable<In, O8, R8>,
-): TypedAction<
-  In,
-  [O1, O2, O3, O4, O5, O6, O7, O8],
-  R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8
->;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  O6,
-  O7,
-  O8,
-  O9,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
-  R9 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-  a6: Pipeable<In, O6, R6>,
-  a7: Pipeable<In, O7, R7>,
-  a8: Pipeable<In, O8, R8>,
-  a9: Pipeable<In, O9, R9>,
-): TypedAction<
-  In,
-  [O1, O2, O3, O4, O5, O6, O7, O8, O9],
-  R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9
->;
-export function all<
-  In,
-  O1,
-  O2,
-  O3,
-  O4,
-  O5,
-  O6,
-  O7,
-  O8,
-  O9,
-  O10,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
-  R9 extends string,
-  R10 extends string,
->(
-  a1: Pipeable<In, O1, R1>,
-  a2: Pipeable<In, O2, R2>,
-  a3: Pipeable<In, O3, R3>,
-  a4: Pipeable<In, O4, R4>,
-  a5: Pipeable<In, O5, R5>,
-  a6: Pipeable<In, O6, R6>,
-  a7: Pipeable<In, O7, R7>,
-  a8: Pipeable<In, O8, R8>,
-  a9: Pipeable<In, O9, R9>,
-  a10: Pipeable<In, O10, R10>,
-): TypedAction<
-  In,
-  [O1, O2, O3, O4, O5, O6, O7, O8, O9, O10],
-  R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9 | R10
->;
+export function all<In, O1>(a1: Pipeable<In, O1>): TypedAction<In, [O1]>;
+export function all<In, O1, O2>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+): TypedAction<In, [O1, O2]>;
+export function all<In, O1, O2, O3>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+): TypedAction<In, [O1, O2, O3]>;
+export function all<In, O1, O2, O3, O4>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+): TypedAction<In, [O1, O2, O3, O4]>;
+export function all<In, O1, O2, O3, O4, O5>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+): TypedAction<In, [O1, O2, O3, O4, O5]>;
+export function all<In, O1, O2, O3, O4, O5, O6>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+  a9: Pipeable<In, O9>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9]>;
+export function all<In, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10>(
+  a1: Pipeable<In, O1>,
+  a2: Pipeable<In, O2>,
+  a3: Pipeable<In, O3>,
+  a4: Pipeable<In, O4>,
+  a5: Pipeable<In, O5>,
+  a6: Pipeable<In, O6>,
+  a7: Pipeable<In, O7>,
+  a8: Pipeable<In, O8>,
+  a9: Pipeable<In, O9>,
+  a10: Pipeable<In, O10>,
+): TypedAction<In, [O1, O2, O3, O4, O5, O6, O7, O8, O9, O10]>;
 export function all(...actions: Action[]): Action {
   if (actions.length === 0) {
     return constant([]);

package/src/ast.ts

@@ -148,59 +148,41 @@ export type MergeTuple<TTuple> = TTuple extends unknown[]
  * so the covariant __in is needed for the entry point check).
  *
  */
-export type TypedAction<
-  In = unknown,
-  Out = unknown,
-  Refs extends string = never,
-> = Action & {
+export type TypedAction<In = unknown, Out = unknown> = Action & {
   __phantom_in?: (input: In) => void;
   __phantom_out?: () => Out;
   __phantom_out_check?: (output: Out) => void;
   __in?: In;
-  __refs?: { _brand: Refs };
   /** Chain this action with another. `a.then(b)` ≡ `chain(a, b)`. */
-  then<TNext, TRefs2 extends string = never>(
-    next: Pipeable<Out, TNext, TRefs2>,
-  ): TypedAction<In, TNext, Refs | TRefs2>;
+  then<TNext>(next: Pipeable<Out, TNext>): TypedAction<In, TNext>;
   /** Apply an action to each element of an array output. `a.forEach(b)` ≡ `a.then(forEach(b))`. */
-  forEach<
-    TIn,
-    TElement,
-    TNext,
-    TRefs extends string,
-    TRefs2 extends string = never,
-  >(
-    this: TypedAction<TIn, TElement[], TRefs>,
-    action: Pipeable<TElement, TNext, TRefs2>,
-  ): TypedAction<TIn, TNext[], TRefs | TRefs2>;
+  forEach<TIn, TElement, TNext>(
+    this: TypedAction<TIn, TElement[]>,
+    action: Pipeable<TElement, TNext>,
+  ): TypedAction<TIn, TNext[]>;
   /** Dispatch on a tagged union output. Auto-unwraps `value` before each case handler. */
   branch<
     TCases extends {
-      [K in BranchKeys<Out>]: CaseHandler<
-        BranchPayload<Out, K>,
-        unknown,
-        string
-      >;
+      [K in BranchKeys<Out>]: CaseHandler<BranchPayload<Out, K>>;
     },
   >(
     cases: [BranchKeys<Out>] extends [never] ? never : TCases,
-  ): TypedAction<In, ExtractOutput<TCases[keyof TCases & string]>, Refs>;
+  ): TypedAction<In, ExtractOutput<TCases[keyof TCases & string]>>;
   /** Flatten a nested array output. `a.flatten()` ≡ `pipe(a, flatten())`. */
   flatten(): TypedAction<
     In,
-    Out extends (infer TElement)[][] ? TElement[] : Out,
-    Refs
+    Out extends (infer TElement)[][] ? TElement[] : Out
   >;
   /** Discard output. `a.drop()` ≡ `pipe(a, drop)`. */
-  drop(): TypedAction<In, never, Refs>;
+  drop(): TypedAction<In, never>;
   /** 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>;
+  ): TypedAction<In, TaggedUnion<TDef>>;
   /** 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>;
+  ): TypedAction<In, Out[TField]>;
   /**
    * Run this sub-pipeline, then merge its output back into the original input.
    * `pipe(extractField("x"), transform).augment()` takes `In`, runs the
@@ -209,21 +191,21 @@ export type TypedAction<
    * Unlike the standalone `augment()` function, the postfix form has access
    * to `In` so the intersection types correctly.
    */
-  augment(): TypedAction<In, In & Out, Refs>;
+  augment(): TypedAction<In, In & Out>;
   /** Merge a tuple of objects into a single object. `a.merge()` ≡ `pipe(a, merge())`. */
-  merge(): TypedAction<In, MergeTuple<Out>, Refs>;
+  merge(): TypedAction<In, MergeTuple<Out>>;
   /** Select fields from the output. `a.pick("x", "y")` ≡ `pipe(a, pick("x", "y"))`. */
   pick<TKeys extends (keyof Out & string)[]>(
     ...keys: TKeys
-  ): TypedAction<In, Pick<Out, TKeys[number]>, Refs>;
+  ): TypedAction<In, Pick<Out, TKeys[number]>>;
   /**
    * Transform the Some value inside an Option output. Only callable when
    * Out is Option<T>. Uses `this` parameter constraint to gate availability.
    */
-  mapOption<TIn, T, U, TRefs extends string>(
-    this: TypedAction<TIn, Option<T>, TRefs>,
+  mapOption<TIn, T, U>(
+    this: TypedAction<TIn, Option<T>>,
     action: Pipeable<T, U>,
-  ): TypedAction<TIn, Option<U>, TRefs>;
+  ): TypedAction<TIn, Option<U>>;
   /**
    * Transform the Err value of a Result output.
    * `Result<TValue, TError> → Result<TValue, TErrorOut>`
@@ -231,9 +213,9 @@ export type TypedAction<
    * Only callable when Out is Result<TValue, TError>.
    */
   mapErr<TIn, TValue, TError, TErrorOut>(
-    this: TypedAction<TIn, Result<TValue, TError>, any>,
+    this: TypedAction<TIn, Result<TValue, TError>>,
     action: Pipeable<TError, TErrorOut>,
-  ): TypedAction<TIn, Result<TValue, TErrorOut>, Refs>;
+  ): TypedAction<TIn, Result<TValue, TErrorOut>>;
   /**
    * Unwrap a Result output. If Ok, pass through the value. If Err, apply
    * the default action. Only callable when Out is Result<TValue, TError>.
@@ -244,15 +226,11 @@ export type TypedAction<
    *
    * Uses CaseHandler for defaultAction (covariant output only) so that
    * `TypedAction<TError, never>` is assignable to `CaseHandler<TError, TValue>`.
-   *
-   * Refs position uses `any` in the `this` constraint to avoid TS
-   * falling back to the constraint bound `string` when Refs = never.
-   * The return type uses the enclosing TypedAction's `Refs` directly.
    */
   unwrapOr<TIn, TValue, TError>(
-    this: TypedAction<TIn, Result<TValue, TError>, any>,
+    this: TypedAction<TIn, Result<TValue, TError>>,
     defaultAction: CaseHandler<TError, TValue>,
-  ): TypedAction<TIn, TValue, Refs>;
+  ): TypedAction<TIn, TValue>;
 };
 
 /**
@@ -273,16 +251,11 @@ export type TypedAction<
  * TypedAction (with methods) is assignable to Pipeable because Pipeable
  * only requires a subset of properties.
  */
-export type Pipeable<
-  In = unknown,
-  Out = unknown,
-  Refs extends string = never,
-> = Action & {
+export type Pipeable<In = unknown, Out = unknown> = Action & {
   __phantom_in?: (input: In) => void;
   __phantom_out?: () => Out;
   __phantom_out_check?: (output: Out) => void;
   __in?: In;
-  __refs?: { _brand: Refs };
 };
 
 /**
@@ -305,14 +278,9 @@ export type Pipeable<
  * TypedAction is assignable to CaseHandler because CaseHandler only
  * requires a subset of TypedAction's phantom fields.
  */
-type CaseHandler<
-  TIn = unknown,
-  TOut = unknown,
-  TRefs extends string = never,
-> = Action & {
+export type CaseHandler<TIn = unknown, TOut = unknown> = Action & {
   __phantom_in?: (input: TIn) => void;
   __phantom_out?: () => TOut;
-  __refs?: { _brand: TRefs };
 };
 
 // ---------------------------------------------------------------------------
@@ -390,16 +358,10 @@ type BranchPayload<Out, K extends string> = [ExtractDef<Out>] extends [never]
 // ---------------------------------------------------------------------------
 
 // Shared implementations (one closure, not per-instance)
-function thenMethod<
-  TIn,
-  TOut,
-  TRefs extends string,
-  TNext,
-  TRefs2 extends string,
->(
-  this: TypedAction<TIn, TOut, TRefs>,
-  next: Pipeable<TOut, TNext, TRefs2>,
-): TypedAction<TIn, TNext, TRefs | TRefs2> {
+function thenMethod<TIn, TOut, TNext>(
+  this: TypedAction<TIn, TOut>,
+  next: Pipeable<TOut, TNext>,
+): TypedAction<TIn, TNext> {
   return typedAction({ kind: "Chain", first: this, rest: next as Action });
 }
 
@@ -595,11 +557,9 @@ function unwrapOrMethod(this: TypedAction, defaultAction: Action): TypedAction {
  * Attach `.then()` and `.forEach()` methods to a plain Action object.
  * Methods are non-enumerable: invisible to JSON.stringify and toEqual.
  */
-export function typedAction<
-  In = unknown,
-  Out = unknown,
-  Refs extends string = never,
->(action: Action): TypedAction<In, Out, Refs> {
+export function typedAction<In = unknown, Out = unknown>(
+  action: Action,
+): TypedAction<In, Out> {
   if (!("then" in action)) {
     Object.defineProperties(action, {
       then: { value: thenMethod, configurable: true },
@@ -617,7 +577,7 @@ export function typedAction<
       unwrapOr: { value: unwrapOrMethod, configurable: true },
     });
   }
-  return action as TypedAction<In, Out, Refs>;
+  return action as TypedAction<In, Out>;
 }
 
 // ---------------------------------------------------------------------------
@@ -663,9 +623,9 @@ import {
 export { tryCatch } from "./try-catch.js";
 export { race, sleep, withTimeout } from "./race.js";
 
-export function forEach<In, Out, R extends string = never>(
-  action: Pipeable<In, Out, R>,
-): TypedAction<In[], Out[], R> {
+export function forEach<In, Out>(
+  action: Pipeable<In, Out>,
+): TypedAction<In[], Out[]> {
   return typedAction({ kind: "ForEach", action: action as Action });
 }
 
@@ -767,9 +727,9 @@ export const IDENTITY: Action = {
  *
  * Compiled form: `RestartHandle(id, ExtractIndex(0), body)`
  */
-export function recur<TIn = never, TOut = any, TRefs extends string = never>(
-  bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut, TRefs>,
-): TypedAction<PipeIn<TIn>, TOut, TRefs> {
+export function recur<TIn = never, TOut = any>(
+  bodyFn: (restart: TypedAction<TIn, never>) => Pipeable<TIn, TOut>,
+): TypedAction<PipeIn<TIn>, TOut> {
   const restartHandlerId = allocateRestartHandlerId();
 
   const restartAction = typedAction<TIn, never>({
@@ -803,16 +763,11 @@ export function recur<TIn = never, TOut = any, TRefs extends string = never>(
  * a Branch. earlyReturn tags with Break and performs — the handler restarts
  * the body, Branch takes the Break path, and the value exits.
  */
-export function earlyReturn<
-  TEarlyReturn = never,
-  TIn = any,
-  TOut = any,
-  TRefs extends string = never,
->(
+export function earlyReturn<TEarlyReturn = never, TIn = any, TOut = any>(
   bodyFn: (
     earlyReturn: TypedAction<TEarlyReturn, never>,
-  ) => Pipeable<TIn, TOut, TRefs>,
-): TypedAction<TIn, TEarlyReturn | TOut, TRefs> {
+  ) => Pipeable<TIn, TOut>,
+): TypedAction<TIn, TEarlyReturn | TOut> {
   const restartHandlerId = allocateRestartHandlerId();
 
   const earlyReturnAction = typedAction<TEarlyReturn, never>({
@@ -873,12 +828,12 @@ export function buildRestartBranchAction(
  *
  * Compiles to `RestartHandle`/`RestartPerform`/Branch — same effect substrate as tryCatch and earlyReturn.
  */
-export function loop<TBreak = never, TIn = never, TRefs extends string = never>(
+export function loop<TBreak = never, TIn = never>(
   bodyFn: (
     recur: TypedAction<TIn, never>,
     done: TypedAction<VoidToNull<TBreak>, never>,
-  ) => Pipeable<TIn, never, TRefs>,
-): TypedAction<PipeIn<TIn>, VoidToNull<TBreak>, TRefs> {
+  ) => Pipeable<TIn, never>,
+): TypedAction<PipeIn<TIn>, VoidToNull<TBreak>> {
   const restartHandlerId = allocateRestartHandlerId();
 
   const perform: Action = {

package/src/builtins.ts

@@ -1,5 +1,6 @@
 import {
   type Action,
+  type CaseHandler,
   type Option as OptionT,
   type Pipeable,
   type Result as ResultT,
@@ -148,9 +149,9 @@ export function pick<
 // DropResult — run an action for side effects, discard its output
 // ---------------------------------------------------------------------------
 
-export function dropResult<TInput, TOutput, TRefs extends string = never>(
-  action: Pipeable<TInput, TOutput, TRefs>,
-): TypedAction<TInput, never, TRefs> {
+export function dropResult<TInput, TOutput>(
+  action: Pipeable<TInput, TOutput>,
+): TypedAction<TInput, never> {
   // Build AST directly — chain inference fails when drop's TValue
   // isn't constrained by context (resolves to unknown ≠ TOutput).
   return typedAction({
@@ -259,10 +260,7 @@ export function withResource<
 export function augment<
   TInput extends Record<string, unknown>,
   TOutput extends Record<string, unknown>,
-  TRefs extends string = never,
->(
-  action: Pipeable<TInput, TOutput, TRefs>,
-): TypedAction<TInput, TInput & TOutput, TRefs> {
+>(action: Pipeable<TInput, TOutput>): TypedAction<TInput, TInput & TOutput> {
   // Build AST directly — chain inference fails because [TOutput, TInput]
   // doesn't match merge()'s Record<string, unknown>[] with invariance.
   return typedAction({
@@ -294,10 +292,9 @@ export function augment<
  * Example:
  *   pipe(tap(pipe(pick("worktreePath", "description"), implement)), createPR)
  */
-export function tap<
-  TInput extends Record<string, unknown>,
-  TRefs extends string = never,
->(action: Pipeable<TInput, any, TRefs>): TypedAction<TInput, TInput, TRefs> {
+export function tap<TInput extends Record<string, unknown>>(
+  action: Pipeable<TInput, any>,
+): TypedAction<TInput, TInput> {
   // Build AST directly — internal plumbing (action → constant → augment)
   // can't go through typed chain/augment with invariant phantom fields.
   // tap: all(chain(action, constant({})), identity()) → merge
@@ -685,10 +682,7 @@ export const Result = {
    * Desugars to: `branch({ Ok: identity(), Err: defaultAction })`
    */
   unwrapOr<TValue, TError>(
-    defaultAction: Action & {
-      __phantom_in?: (input: TError) => void;
-      __phantom_out?: () => TValue;
-    },
+    defaultAction: CaseHandler<TError, TValue>,
   ): TypedAction<ResultT<TValue, TError>, TValue> {
     return typedAction(resultBranch(IDENTITY, defaultAction as Action));
   },

package/src/chain.ts

@@ -5,10 +5,10 @@ import {
   typedAction,
 } from "./ast.js";
 
-export function chain<T1, T2, T3, R1 extends string, R2 extends string>(
-  first: Pipeable<T1, T2, R1>,
-  rest: Pipeable<T2, T3, R2>,
-): TypedAction<T1, T3, R1 | R2> {
+export function chain<T1, T2, T3>(
+  first: Pipeable<T1, T2>,
+  rest: Pipeable<T2, T3>,
+): TypedAction<T1, T3> {
   return typedAction({
     kind: "Chain",
     first: first as Action,

package/src/pipe.ts

@@ -7,205 +7,79 @@ import {
 } from "./ast.js";
 import { identity } from "./builtins.js";
 
-export function pipe<T1, T2, R1 extends string>(
-  a1: Pipeable<T1, T2, R1>,
-): TypedAction<PipeIn<T1>, T2, R1>;
-export function pipe<T1, T2, T3, R1 extends string, R2 extends string>(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-): TypedAction<PipeIn<T1>, T3, R1 | R2>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-): TypedAction<PipeIn<T1>, T4, R1 | R2 | R3>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-): TypedAction<PipeIn<T1>, T5, R1 | R2 | R3 | R4>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-): TypedAction<PipeIn<T1>, T6, R1 | R2 | R3 | R4 | R5>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  T7,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-  a6: Pipeable<T6, T7, R6>,
-): TypedAction<PipeIn<T1>, T7, R1 | R2 | R3 | R4 | R5 | R6>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  T7,
-  T8,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-  a6: Pipeable<T6, T7, R6>,
-  a7: Pipeable<T7, T8, R7>,
-): TypedAction<PipeIn<T1>, T8, R1 | R2 | R3 | R4 | R5 | R6 | R7>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  T7,
-  T8,
-  T9,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-  a6: Pipeable<T6, T7, R6>,
-  a7: Pipeable<T7, T8, R7>,
-  a8: Pipeable<T8, T9, R8>,
-): TypedAction<PipeIn<T1>, T9, R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  T7,
-  T8,
-  T9,
-  T10,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
-  R9 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-  a6: Pipeable<T6, T7, R6>,
-  a7: Pipeable<T7, T8, R7>,
-  a8: Pipeable<T8, T9, R8>,
-  a9: Pipeable<T9, T10, R9>,
-): TypedAction<PipeIn<T1>, T10, R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9>;
-export function pipe<
-  T1,
-  T2,
-  T3,
-  T4,
-  T5,
-  T6,
-  T7,
-  T8,
-  T9,
-  T10,
-  T11,
-  R1 extends string,
-  R2 extends string,
-  R3 extends string,
-  R4 extends string,
-  R5 extends string,
-  R6 extends string,
-  R7 extends string,
-  R8 extends string,
-  R9 extends string,
-  R10 extends string,
->(
-  a1: Pipeable<T1, T2, R1>,
-  a2: Pipeable<T2, T3, R2>,
-  a3: Pipeable<T3, T4, R3>,
-  a4: Pipeable<T4, T5, R4>,
-  a5: Pipeable<T5, T6, R5>,
-  a6: Pipeable<T6, T7, R6>,
-  a7: Pipeable<T7, T8, R7>,
-  a8: Pipeable<T8, T9, R8>,
-  a9: Pipeable<T9, T10, R9>,
-  a10: Pipeable<T10, T11, R10>,
-): TypedAction<
-  PipeIn<T1>,
-  T11,
-  R1 | R2 | R3 | R4 | R5 | R6 | R7 | R8 | R9 | R10
->;
+export function pipe<T1, T2>(a1: Pipeable<T1, T2>): TypedAction<PipeIn<T1>, T2>;
+export function pipe<T1, T2, T3>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+): TypedAction<PipeIn<T1>, T3>;
+export function pipe<T1, T2, T3, T4>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+): TypedAction<PipeIn<T1>, T4>;
+export function pipe<T1, T2, T3, T4, T5>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+): TypedAction<PipeIn<T1>, T5>;
+export function pipe<T1, T2, T3, T4, T5, T6>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+): TypedAction<PipeIn<T1>, T6>;
+export function pipe<T1, T2, T3, T4, T5, T6, T7>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+  a6: Pipeable<T6, T7>,
+): TypedAction<PipeIn<T1>, T7>;
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+  a6: Pipeable<T6, T7>,
+  a7: Pipeable<T7, T8>,
+): TypedAction<PipeIn<T1>, T8>;
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+  a6: Pipeable<T6, T7>,
+  a7: Pipeable<T7, T8>,
+  a8: Pipeable<T8, T9>,
+): TypedAction<PipeIn<T1>, T9>;
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+  a6: Pipeable<T6, T7>,
+  a7: Pipeable<T7, T8>,
+  a8: Pipeable<T8, T9>,
+  a9: Pipeable<T9, T10>,
+): TypedAction<PipeIn<T1>, T10>;
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
+  a1: Pipeable<T1, T2>,
+  a2: Pipeable<T2, T3>,
+  a3: Pipeable<T3, T4>,
+  a4: Pipeable<T4, T5>,
+  a5: Pipeable<T5, T6>,
+  a6: Pipeable<T6, T7>,
+  a7: Pipeable<T7, T8>,
+  a8: Pipeable<T8, T9>,
+  a9: Pipeable<T9, T10>,
+  a10: Pipeable<T10, T11>,
+): TypedAction<PipeIn<T1>, T11>;
 export function pipe(...actions: Action[]): Action {
   if (actions.length === 0) {
     return identity;