@barnum/barnum 0.0.0-main-5534c655 → 0.0.0-main-ef57b8fd

package/dist/ast.d.ts

@@ -132,15 +132,8 @@ export type TypedAction<In = unknown, Out = unknown, Refs extends string = never
     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>;
-    /**
-     * Run this sub-pipeline, then merge its output back into the original input.
-     * `pipe(extractField("x"), transform).augment()` takes `In`, runs the
-     * sub-pipeline to get `Out`, and returns `In & Out`.
-     *
-     * Unlike the standalone `augment()` function, the postfix form has access
-     * to `In` so the intersection types correctly.
-     */
-    augment(): TypedAction<In, In & Out, Refs>;
+    /** 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())`. */
     merge(): TypedAction<In, MergeTuple<Out>, Refs>;
     /** Select fields from the output. `a.pick("x", "y")` ≡ `pipe(a, pick("x", "y"))`. */

package/dist/ast.js

@@ -62,25 +62,16 @@ function getMethod(field) {
         },
     });
 }
-function augmentMethod() {
-    // Construct: All(this, identity) → Merge
-    // "this" is the sub-pipeline. augment() wraps it so the original input
-    // flows through identity alongside the sub-pipeline, then merges the results.
+function wrapInFieldMethod(field) {
     return typedAction({
         kind: "Chain",
-        first: {
-            kind: "All",
-            actions: [
-                this,
-                {
-                    kind: "Invoke",
-                    handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-                },
-            ],
-        },
+        first: this,
         rest: {
             kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Merge" } },
+            handler: {
+                kind: "Builtin",
+                builtin: { kind: "WrapInField", value: field },
+            },
         },
     });
 }
@@ -192,7 +183,7 @@ export function typedAction(action) {
             drop: { value: dropMethod, configurable: true },
             tag: { value: tagMethod, configurable: true },
             get: { value: getMethod, configurable: true },
-            augment: { value: augmentMethod, configurable: true },
+            wrapInField: { value: wrapInFieldMethod, configurable: true },
             merge: { value: mergeMethod, configurable: true },
             pick: { value: pickMethod, configurable: true },
             mapOption: { value: mapOptionMethod, configurable: true },

package/dist/builtins.d.ts

@@ -1,4 +1,4 @@
-import { type Action, type Option as OptionT, type Pipeable, type Result as ResultT, type TaggedUnion, type TypedAction } from "./ast.js";
+import { type Action, type MergeTuple, type Option as OptionT, type Pipeable, type Result as ResultT, type TaggedUnion, type TypedAction } from "./ast.js";
 /**
  * Typed combinators for structural data transformations.
  *
@@ -16,8 +16,7 @@ export declare const drop: TypedAction<any, never>;
  *        input: string → output: TaggedUnion<{ Ok: string; Err: number }>
  */
 export declare function tag<TDef extends Record<string, unknown>, TKind extends keyof TDef & string>(kind: TKind): TypedAction<TDef[TKind], TaggedUnion<TDef>>;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export declare function merge<TObjects extends Record<string, unknown>[]>(): TypedAction<TObjects, UnionToIntersection<TObjects[number]>>;
+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]>;
@@ -44,24 +43,13 @@ export declare function withResource<TIn extends Record<string, unknown>, TResou
     action: Pipeable<TResource & TIn, TOut>;
     dispose: Pipeable<TResource, TDisposeOut>;
 }): TypedAction<TIn, TOut>;
-/**
- * Run `action` on the input, then merge the action's output fields back
- * into the original input object. The action must accept exactly `TInput`.
- * Use `pick` inside the action's pipe if the inner handler needs a subset.
- *
- * Example:
- *   augment(pipe(pick("file"), migrate))
- *   // { file, outputPath } → { file, outputPath, content, migrated }
- */
-export declare function augment<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>>(action: Pipeable<TInput, TOutput>): TypedAction<TInput, TInput & TOutput>;
 /**
  * Run `action` on the input for its side effects, then discard the action's
  * output and return the original input unchanged. The action must accept
  * exactly `TInput`. Use `pick` inside the action's pipe if the inner
  * handler needs a subset.
  *
- * Constraint: input must be an object (uses augment internally, which
- * relies on all + merge).
+ * Constraint: input must be an object (uses all + merge internally).
  *
  * Example:
  *   pipe(tap(pipe(pick("worktreePath", "description"), implement)), createPR)
@@ -255,4 +243,3 @@ export declare const Result: {
      */
     readonly isErr: <TValue, TError>() => TypedAction<ResultT<TValue, TError>, boolean>;
 };
-export {};

package/dist/builtins.js

@@ -45,6 +45,9 @@ export function tag(kind) {
         handler: { kind: "Builtin", builtin: { kind: "Tag", value: kind } },
     });
 }
+// ---------------------------------------------------------------------------
+// Merge — merge a tuple of objects into a single object
+// ---------------------------------------------------------------------------
 export function merge() {
     return typedAction({
         kind: "Invoke",
@@ -155,33 +158,6 @@ export function withResource({ create, action, dispose, }) {
     return chain(chain(chain(acquireAndMerge, actionAndKeepMerged), disposeAndKeepResult), extractIndex(0));
 }
 // ---------------------------------------------------------------------------
-// Augment — run a transform, merge its output back into the original input
-// ---------------------------------------------------------------------------
-/**
- * Run `action` on the input, then merge the action's output fields back
- * into the original input object. The action must accept exactly `TInput`.
- * Use `pick` inside the action's pipe if the inner handler needs a subset.
- *
- * Example:
- *   augment(pipe(pick("file"), migrate))
- *   // { file, outputPath } → { file, outputPath, content, migrated }
- */
-export function augment(action) {
-    // Build AST directly — chain inference fails because [TOutput, TInput]
-    // doesn't match merge()'s Record<string, unknown>[] with invariance.
-    return typedAction({
-        kind: "Chain",
-        first: {
-            kind: "All",
-            actions: [action, identity],
-        },
-        rest: {
-            kind: "Invoke",
-            handler: { kind: "Builtin", builtin: { kind: "Merge" } },
-        },
-    });
-}
-// ---------------------------------------------------------------------------
 // Tap — run an action for side effects, preserve original input
 // ---------------------------------------------------------------------------
 /**
@@ -190,16 +166,13 @@ export function augment(action) {
  * exactly `TInput`. Use `pick` inside the action's pipe if the inner
  * handler needs a subset.
  *
- * Constraint: input must be an object (uses augment internally, which
- * relies on all + merge).
+ * Constraint: input must be an object (uses all + merge internally).
  *
  * Example:
  *   pipe(tap(pipe(pick("worktreePath", "description"), implement)), createPR)
  */
 export function tap(action) {
-    // 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
+    // all(chain(action, constant({})), identity) → merge
     return typedAction({
         kind: "Chain",
         first: {

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, augment, tap, range, wrapInField, Option, Result, } from "./builtins.js";
+export { constant, identity, drop, tag, merge, flatten, extractField, extractIndex, pick, dropResult, withResource, tap, range, 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, augment, tap, range, wrapInField, Option, Result, } from "./builtins.js";
+export { constant, identity, drop, tag, merge, flatten, extractField, extractIndex, pick, dropResult, withResource, tap, range, wrapInField, Option, Result, } from "./builtins.js";
 export * from "./handler.js";
 export { runPipeline } from "./run.js";
 export { zodToCheckedJsonSchema } from "./schema.js";

package/package.json

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

package/src/ast.ts

@@ -185,15 +185,10 @@ export type TypedAction<
   get<TField extends keyof Out & string>(
     field: TField,
   ): TypedAction<In, Out[TField], Refs>;
-  /**
-   * Run this sub-pipeline, then merge its output back into the original input.
-   * `pipe(extractField("x"), transform).augment()` takes `In`, runs the
-   * sub-pipeline to get `Out`, and returns `In & Out`.
-   *
-   * Unlike the standalone `augment()` function, the postfix form has access
-   * to `In` so the intersection types correctly.
-   */
-  augment(): TypedAction<In, In & Out, Refs>;
+  /** 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())`. */
   merge(): TypedAction<In, MergeTuple<Out>, Refs>;
   /** Select fields from the output. `a.pick("x", "y")` ≡ `pipe(a, pick("x", "y"))`. */
@@ -437,25 +432,16 @@ function getMethod(this: TypedAction, field: string): TypedAction {
   });
 }
 
-function augmentMethod(this: TypedAction): TypedAction {
-  // Construct: All(this, identity) → Merge
-  // "this" is the sub-pipeline. augment() wraps it so the original input
-  // flows through identity alongside the sub-pipeline, then merges the results.
+function wrapInFieldMethod(this: TypedAction, field: string): TypedAction {
   return typedAction({
     kind: "Chain",
-    first: {
-      kind: "All",
-      actions: [
-        this as Action,
-        {
-          kind: "Invoke",
-          handler: { kind: "Builtin", builtin: { kind: "Identity" } },
-        },
-      ],
-    },
+    first: this,
     rest: {
       kind: "Invoke",
-      handler: { kind: "Builtin", builtin: { kind: "Merge" } },
+      handler: {
+        kind: "Builtin",
+        builtin: { kind: "WrapInField", value: field },
+      },
     },
   });
 }
@@ -577,7 +563,7 @@ export function typedAction<
       drop: { value: dropMethod, configurable: true },
       tag: { value: tagMethod, configurable: true },
       get: { value: getMethod, configurable: true },
-      augment: { value: augmentMethod, configurable: true },
+      wrapInField: { value: wrapInFieldMethod, configurable: true },
       merge: { value: mergeMethod, configurable: true },
       pick: { value: pickMethod, configurable: true },
       mapOption: { value: mapOptionMethod, configurable: true },

package/src/builtins.ts

@@ -1,5 +1,6 @@
 import {
   type Action,
+  type MergeTuple,
   type Option as OptionT,
   type Pipeable,
   type Result as ResultT,
@@ -70,16 +71,10 @@ export function tag<
 // Merge — merge a tuple of objects into a single object
 // ---------------------------------------------------------------------------
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
-  x: infer I,
-) => void
-  ? I
-  : never;
-
-export function merge<
-  TObjects extends Record<string, unknown>[],
->(): TypedAction<TObjects, UnionToIntersection<TObjects[number]>> {
+export function merge<TTuple extends Record<string, unknown>[]>(): TypedAction<
+  TTuple,
+  MergeTuple<TTuple>
+> {
   return typedAction({
     kind: "Invoke",
     handler: { kind: "Builtin", builtin: { kind: "Merge" } },
@@ -243,38 +238,6 @@ export function withResource<
   ) as TypedAction<TIn, TOut>;
 }
 
-// ---------------------------------------------------------------------------
-// Augment — run a transform, merge its output back into the original input
-// ---------------------------------------------------------------------------
-
-/**
- * Run `action` on the input, then merge the action's output fields back
- * into the original input object. The action must accept exactly `TInput`.
- * Use `pick` inside the action's pipe if the inner handler needs a subset.
- *
- * Example:
- *   augment(pipe(pick("file"), migrate))
- *   // { file, outputPath } → { file, outputPath, content, migrated }
- */
-export function augment<
-  TInput extends Record<string, unknown>,
-  TOutput extends Record<string, unknown>,
->(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({
-    kind: "Chain",
-    first: {
-      kind: "All",
-      actions: [action as Action, identity as Action],
-    },
-    rest: {
-      kind: "Invoke",
-      handler: { kind: "Builtin", builtin: { kind: "Merge" } },
-    },
-  });
-}
-
 // ---------------------------------------------------------------------------
 // Tap — run an action for side effects, preserve original input
 // ---------------------------------------------------------------------------
@@ -285,8 +248,7 @@ export function augment<
  * exactly `TInput`. Use `pick` inside the action's pipe if the inner
  * handler needs a subset.
  *
- * Constraint: input must be an object (uses augment internally, which
- * relies on all + merge).
+ * Constraint: input must be an object (uses all + merge internally).
  *
  * Example:
  *   pipe(tap(pipe(pick("worktreePath", "description"), implement)), createPR)
@@ -294,9 +256,7 @@ export function augment<
 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
+  // all(chain(action, constant({})), identity) → merge
   return typedAction({
     kind: "Chain",
     first: {

package/src/index.ts

@@ -13,7 +13,6 @@ export {
   pick,
   dropResult,
   withResource,
-  augment,
   tap,
   range,
   wrapInField,