@nlozgachev/pipelined 0.36.0 → 0.37.0

package/dist/{Task-zAY4kSVB.d.ts → Task-DIgwvoIb.d.ts}

@@ -304,6 +304,28 @@ declare namespace Result {
      * ```
      */
     const ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
+    /**
+     * Converts a Result value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: Result<E, A>) => Result<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Result using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.ok({ a: 1 }),
+     *   Result.bind("b", ({ a }) => Result.ok(a + 1))
+     * ); // Ok({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, A & { [P in K]: B; }>;
 }
 
 type Some<A> = WithKind<"Some"> & WithValue<A>;
@@ -519,6 +541,28 @@ declare namespace Maybe {
      * ```
      */
     const ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
+    /**
+     * Converts a Maybe value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: Maybe<A>) => Maybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new Maybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Maybe.some({ a: 1 }),
+     *   Maybe.bind("b", ({ a }) => Maybe.some(a + 1))
+     * ); // Some({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<A & { [P in K]: B; }>;
 }
 
 declare const _deferred: unique symbol;
@@ -1024,6 +1068,28 @@ declare namespace Task {
      * ```
      */
     const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
+    /**
+     * Converts a Task value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new Task using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.resolve({ a: 1 }),
+     *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
+     * ); // Task({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
 }
 
-export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Err as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithDuration as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };
+export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithConcurrency as W, type Err as a, Ordering as b, type RetryOptions as c, type TimeoutOptions as d, type WithCooldown as e, type WithDuration as f, type WithError as g, type WithErrors as h, type WithFirst as i, type WithKind as j, type WithLog as k, type WithMinInterval as l, type WithN as m, type WithSecond as n, type WithSize as o, type WithTimeout as p, type WithValue as q };

package/dist/{Task-DXsuurnc.d.mts → Task-fn1n--6H.d.mts}

@@ -304,6 +304,28 @@ declare namespace Result {
      * ```
      */
     const ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
+    /**
+     * Converts a Result value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: Result<E, A>) => Result<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Result using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.ok({ a: 1 }),
+     *   Result.bind("b", ({ a }) => Result.ok(a + 1))
+     * ); // Ok({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, A & { [P in K]: B; }>;
 }
 
 type Some<A> = WithKind<"Some"> & WithValue<A>;
@@ -519,6 +541,28 @@ declare namespace Maybe {
      * ```
      */
     const ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
+    /**
+     * Converts a Maybe value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: Maybe<A>) => Maybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new Maybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Maybe.some({ a: 1 }),
+     *   Maybe.bind("b", ({ a }) => Maybe.some(a + 1))
+     * ); // Some({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<A & { [P in K]: B; }>;
 }
 
 declare const _deferred: unique symbol;
@@ -1024,6 +1068,28 @@ declare namespace Task {
      * ```
      */
     const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
+    /**
+     * Converts a Task value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new Task using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.resolve({ a: 1 }),
+     *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
+     * ); // Task({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
 }
 
-export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Err as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithDuration as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };
+export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithConcurrency as W, type Err as a, Ordering as b, type RetryOptions as c, type TimeoutOptions as d, type WithCooldown as e, type WithDuration as f, type WithError as g, type WithErrors as h, type WithFirst as i, type WithKind as j, type WithLog as k, type WithMinInterval as l, type WithN as m, type WithSecond as n, type WithSize as o, type WithTimeout as p, type WithValue as q };

package/dist/{chunk-IJFFWBKW.mjs → chunk-72BGUEQM.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-DLBHVYII.mjs";
+} from "./chunk-PUMSVZB4.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";

package/dist/{chunk-DLBHVYII.mjs → chunk-PUMSVZB4.mjs}

@@ -30,6 +30,10 @@ var Maybe;
   Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
   Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Maybe || (Maybe = {}));
 
 // src/Core/Result.ts
@@ -78,6 +82,10 @@ var Result;
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Result || (Result = {}));
 
 // src/Core/Deferred.ts
@@ -312,6 +320,10 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
 export {

package/dist/{chunk-4QMYKCWE.mjs → chunk-SHO53CQC.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-DLBHVYII.mjs";
+} from "./chunk-PUMSVZB4.mjs";
 import {
   Duration
 } from "./chunk-VWVPHDZO.mjs";
@@ -103,6 +103,10 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
 // src/internal/Op.util.ts
@@ -1277,6 +1281,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -1449,6 +1457,10 @@ var State;
   State2.run = (initialState) => (st) => st(initialState);
   State2.evaluate = (initialState) => (st) => st(initialState)[0];
   State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(State || (State = {}));
 
 // src/Core/TaskMaybe.ts
@@ -1474,6 +1486,10 @@ var TaskMaybe;
   TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
   TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
   TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -1505,6 +1521,10 @@ var TaskResult;
     )
   );
   TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/core.d.mts

@@ -1,5 +1,5 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithDuration, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-DXsuurnc.mjs';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DXsuurnc.mjs';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, h as WithErrors, i as WithFirst, n as WithSecond } from './Task-fn1n--6H.mjs';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-fn1n--6H.mjs';
 import { Duration, NonEmptyList } from './types.mjs';
 
 /**
@@ -561,6 +561,27 @@ declare namespace Logged {
      * ```
      */
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+    /**
+     * Lifts a Logged value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Logged.make<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Logged using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, { a: number }>({ a: 1 }),
+     *   Logged.bind("b", ({ a }) => Logged.make<string, number>(a + 1))
+     * ); // Logged({ value: { a: 1, b: 2 } })
+     * ```
+     */
+    const bind: <K extends string, W, A, B>(key: K, f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, A & { [P in K]: B; }>;
 }
 
 type MaybeRetry<E, O> = O extends {
@@ -1715,6 +1736,27 @@ declare namespace Reader {
      * ```
      */
     const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+    /**
+     * Lifts a Reader value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Reader using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.resolve({ a: 1 }),
+     *   Reader.bind("b", ({ a }) => Reader.resolve(a + 1))
+     * ); // Reader({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
 }
 
 type NotAsked = WithKind<"NotAsked">;
@@ -2092,6 +2134,28 @@ declare namespace TaskResult {
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    /**
+     * Converts a TaskResult value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskResult.ok({ a: 1 }),
+     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
+     * ); // TaskResult({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2379,6 +2443,27 @@ declare namespace State {
      * ```
      */
     const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+    /**
+     * Lifts a State value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
+    /**
+     * Evaluates a new State using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.resolve({ a: 1 }),
+     *   State.bind("b", ({ a }) => State.resolve(a + 1))
+     * ); // State({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2508,6 +2593,27 @@ declare namespace TaskMaybe {
      * ```
      */
     const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a TaskMaybe value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskMaybe.some({ a: 1 }),
+     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
+     * ); // TaskMaybe({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
 }
 
 type Passed<A> = WithKind<"Passed"> & WithValue<A>;

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithDuration, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-zAY4kSVB.js';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-zAY4kSVB.js';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, h as WithErrors, i as WithFirst, n as WithSecond } from './Task-DIgwvoIb.js';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DIgwvoIb.js';
 import { Duration, NonEmptyList } from './types.js';
 
 /**
@@ -561,6 +561,27 @@ declare namespace Logged {
      * ```
      */
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+    /**
+     * Lifts a Logged value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Logged.make<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Logged using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, { a: number }>({ a: 1 }),
+     *   Logged.bind("b", ({ a }) => Logged.make<string, number>(a + 1))
+     * ); // Logged({ value: { a: 1, b: 2 } })
+     * ```
+     */
+    const bind: <K extends string, W, A, B>(key: K, f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, A & { [P in K]: B; }>;
 }
 
 type MaybeRetry<E, O> = O extends {
@@ -1715,6 +1736,27 @@ declare namespace Reader {
      * ```
      */
     const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+    /**
+     * Lifts a Reader value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Reader using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.resolve({ a: 1 }),
+     *   Reader.bind("b", ({ a }) => Reader.resolve(a + 1))
+     * ); // Reader({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
 }
 
 type NotAsked = WithKind<"NotAsked">;
@@ -2092,6 +2134,28 @@ declare namespace TaskResult {
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    /**
+     * Converts a TaskResult value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskResult.ok({ a: 1 }),
+     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
+     * ); // TaskResult({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2379,6 +2443,27 @@ declare namespace State {
      * ```
      */
     const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+    /**
+     * Lifts a State value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
+    /**
+     * Evaluates a new State using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.resolve({ a: 1 }),
+     *   State.bind("b", ({ a }) => State.resolve(a + 1))
+     * ); // State({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2508,6 +2593,27 @@ declare namespace TaskMaybe {
      * ```
      */
     const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a TaskMaybe value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskMaybe.some({ a: 1 }),
+     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
+     * ); // TaskMaybe({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
 }
 
 type Passed<A> = WithKind<"Passed"> & WithValue<A>;

package/dist/core.js

@@ -93,6 +93,10 @@ var Result;
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -123,6 +127,10 @@ var Maybe;
   Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
   Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Maybe || (Maybe = {}));
 
 // src/Core/Combinable.ts
@@ -230,6 +238,10 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
 // src/Types/Brand.ts
@@ -1429,6 +1441,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -1748,6 +1764,10 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -1825,6 +1845,10 @@ var State;
   State2.run = (initialState) => (st) => st(initialState);
   State2.evaluate = (initialState) => (st) => st(initialState)[0];
   State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(State || (State = {}));
 
 // src/Core/TaskMaybe.ts
@@ -1850,6 +1874,10 @@ var TaskMaybe;
   TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
   TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
   TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -1881,6 +1909,10 @@ var TaskResult;
     )
   );
   TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/core.mjs

@@ -19,13 +19,13 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-4QMYKCWE.mjs";
+} from "./chunk-SHO53CQC.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-DLBHVYII.mjs";
+} from "./chunk-PUMSVZB4.mjs";
 import "./chunk-VWVPHDZO.mjs";
 export {
   Combinable,

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.mjs';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-DXsuurnc.mjs';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-fn1n--6H.mjs';
 export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.mjs';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.js';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-zAY4kSVB.js';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-DIgwvoIb.js';
 export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.js';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.js';

package/dist/index.js

@@ -463,6 +463,10 @@ var Result;
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -493,6 +497,10 @@ var Maybe;
   Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
   Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Maybe || (Maybe = {}));
 
 // src/Core/Combinable.ts
@@ -600,6 +608,10 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
 // src/Types/Brand.ts
@@ -1799,6 +1811,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -2118,6 +2134,10 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -2195,6 +2215,10 @@ var State;
   State2.run = (initialState) => (st) => st(initialState);
   State2.evaluate = (initialState) => (st) => st(initialState)[0];
   State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(State || (State = {}));
 
 // src/Core/TaskMaybe.ts
@@ -2220,6 +2244,10 @@ var TaskMaybe;
   TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
   TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
   TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -2251,6 +2279,10 @@ var TaskResult;
     )
   );
   TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/index.mjs

@@ -49,7 +49,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-4QMYKCWE.mjs";
+} from "./chunk-SHO53CQC.mjs";
 import {
   Arr,
   Dict,
@@ -57,13 +57,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-IJFFWBKW.mjs";
+} from "./chunk-72BGUEQM.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-DLBHVYII.mjs";
+} from "./chunk-PUMSVZB4.mjs";
 import "./chunk-IPP4XFYH.mjs";
 import {
   isNonEmptyList

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-DXsuurnc.mjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-fn1n--6H.mjs';
 import { NonEmptyList } from './types.mjs';
 
 /**

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-zAY4kSVB.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-DIgwvoIb.js';
 import { NonEmptyList } from './types.js';
 
 /**

package/dist/utils.js

@@ -85,6 +85,10 @@ var Result;
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -115,6 +119,10 @@ var Maybe;
   Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
   Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Maybe || (Maybe = {}));
 
 // src/Types/Brand.ts
@@ -364,6 +372,10 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
 // src/Types/NonEmptyList.ts

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-IJFFWBKW.mjs";
-import "./chunk-DLBHVYII.mjs";
+} from "./chunk-72BGUEQM.mjs";
+import "./chunk-PUMSVZB4.mjs";
 import "./chunk-DBIC62UV.mjs";
 import "./chunk-VWVPHDZO.mjs";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.36.0",
+	"version": "0.37.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",
@@ -18,7 +18,7 @@
 	"types": "./dist/index.d.ts",
 	"sideEffects": false,
 	"engines": {
-		"node": ">=22"
+		"node": ">=24"
 	},
 	"files": [
 		"dist"
@@ -53,11 +53,16 @@
 		"format:check": "dprint check && dprint check --config dprint.md.json docs/**/*.md docs/**/*.mdx README.md",
 		"typecheck": "tsc --noEmit",
 		"lint": "oxlint src/",
-		"publish:npm": "pnpm build && npm publish --access public"
+		"publish:npm": "pnpm build && npm publish --access public",
+		"release:patch": "bumpp --patch -c -t -p",
+		"release:minor": "bumpp --minor -c -t -p",
+		"docs:dev": "pnpm --filter pipelined-docs dev",
+		"docs:build": "pnpm --filter pipelined-docs build"
 	},
 	"devDependencies": {
 		"@types/node": "25.9.1",
 		"@vitest/coverage-v8": "4.1.7",
+		"bumpp": "11.1.0",
 		"dprint": "0.54.0",
 		"fast-check": "4.8.0",
 		"oxlint": "1.66.0",