resultar 3.9.1 → 3.10.0

package/README.md

@@ -405,6 +405,25 @@ Choose the wrapper that matches the external boundary:
 
 Prefer a factory with `tryResultAsync` when creating the promise can also throw synchronously.
 
+## Reusable function composition
+
+Import `pipe`, `flow`, `identity`, and `constant` from the root package:
+
+```ts
+import { constant, flow, identity, ok, pipe } from 'resultar'
+
+const normalize = flow((input: string) => input.trim(), (input) => input.toLowerCase())
+const name = pipe('  ADA  ', normalize, (value) => ok(value))
+const label = name.match({ ok: identity, error: constant('Unavailable') })
+```
+
+`pipe` applies zero through eight transformations; `value.pipe()` also accepts zero
+transformations. `flow` composes one through nine functions and preserves the first
+function's optional/rest parameters and explicit `this`. Later functions receive one
+value. Both compose synchronously: exceptions propagate, Promises pass through unchanged,
+and tasks execute only at a run boundary. `identity` preserves its argument's reference;
+`constant(value)` captures and returns that same value without copying it.
+
 ## Lazy Workflows With ResultTask
 
 `ResultTask<T, E, R>` is the lazy workflow primitive in Resultar. Creating one does not start the
@@ -421,10 +440,10 @@ operation. Mapping, chaining, recovery, service provision, and generator composi
 | Defer synchronous work | `sync`, `try` |
 | Defer promise-producing work | `tryPromise` |
 | Transform, observe, or chain | `map`, `mapError`, `flatMap`, `andThen`, `tap`, `tapError`, `as`, `match` |
-| Recover typed failures | `catchAll` |
-| Write a linear lazy workflow | `gen` with `yield*` |
+| Recover typed failures | `catchAll`, `catchTag`, `catchTags` |
+| Write a linear lazy workflow | `gen` with `yield*`, `fn` for parameterized functions |
 | Declare and provide dependencies | `service`, `provideService`, `provideServices`, `provideServiceResolver` |
-| Own resources and await cleanup | `acquireRelease`, `scoped` |
+| Own resources and await cleanup | `acquireRelease`, `acquireDisposable`, `scoped` |
 | Execute at the application boundary | `runExit`, `runResult`, `runPromise` |
 | Bridge to started promises | `fromResultAsync`, `toResultAsync`, `ResultAsync.fromTask` |
 
@@ -571,6 +590,38 @@ scopes below when both the body and cleanup failure must be preserved.
 Generators also accept `yield* result` for plain `Result` values: `Ok` unwraps its value and
 `Err` short-circuits into `E`.
 
+### Parameterized tasks and tagged recovery
+
+`ResultTask.fn` wraps a synchronous generator function. Calling the wrapper captures
+its arguments and receiver without executing the body. Each run creates a fresh iterator,
+with the same success/error/requirements inference and cleanup policy as `gen`:
+
+```ts
+import { createTaggedError, pipe, ResultTask } from 'resultar'
+
+class NotFound extends createTaggedError({ name: 'NotFound', message: 'User $id was not found' }) {}
+const Users = ResultTask.service<{
+  find(id: string): ResultTask<string, NotFound>
+}>()('Users')
+
+const loadUser = ResultTask.fn(function* (id: string) {
+  const users = yield* Users
+  return yield* users.find(id)
+})
+
+const recovered = pipe(loadUser('user_123'),
+  ResultTask.catchTag('NotFound', (error: NotFound) => ResultTask.succeed(`Guest ${error.id}`)),
+)
+```
+
+`task.catchTag(tag, handler)` narrows the handler's error to that tag. `task.catchTags(handlers)`
+allows partial recovery. Both also support `ResultTask.catchTag(task, tag, handler)` /
+`ResultTask.catchTags(task, handlers)` and curried forms for `pipe`. Unhandled tags remain in
+`E`; handler errors and requirements join the source channels. Scope requirements remain
+until closure. Handlers run only for simple `Fail` causes: defects and interruptions pass
+through, and composites retain the existing `catchAll` policy of `Die(ResultTaskCauseError)`.
+A throwing handler becomes a defect.
+
 ### Resource scopes and application lifecycle
 
 ```ts
@@ -596,6 +647,13 @@ const program = ResultTask.scoped(ResultTask.gen(function* () {
 const exit = await ResultTask.runExit(program)
 ```
 
+For native `Disposable` or `AsyncDisposable` resources, use
+`ResultTask.acquireDisposable(acquireTask)` inside the same scopes. It prefers
+`Symbol.asyncDispose` when both protocols exist, awaits disposal once in LIFO order,
+and registers nothing when acquisition fails. Disposal throws/rejections become `Die`;
+body and disposal failures retain their sequential cause tree. Cancellation does not
+interrupt cleanup. This helper adds a scope requirement to `R`, just like `acquireRelease`.
+
 Every run owns a root scope. `scoped` closes a child scope before the next task continues. Successful
 acquisitions register finalizers in LIFO order; every finalizer is awaited once, even after a body
 failure, defect, or interruption. Failed acquisition does not register its release. Earlier resources

package/dist/agent/SKILL.md

@@ -74,6 +74,12 @@ remains available. Check installed versions before using these overloads.
 - Keep `_unsafeUnwrap()` and `_unsafeUnwrapErr()` in tests. Use `unwrapOrThrow()` only when throwing
   is explicitly the intended boundary behavior.
 
+For reusable synchronous transformations, use root `pipe` / `flow`. `identity` preserves
+its callback input; `constant(value)` captures a fallback. These utilities do not await or
+execute tasks. Use `ResultTask.fn` for parameterized lazy generators and `catchTag` / partial
+`catchTags` for typed task recovery. Native disposables use `acquireDisposable` in a scope;
+async disposal is awaited and disposal failures become defects.
+
 ## Choose The Composition Operator
 
 | Need                                      | Prefer                   |
@@ -187,7 +193,8 @@ Read `references/integrations.md` before implementing request adapters or diagno
 1. Run the `resultar-check` CLI as the authoritative project and CI gate. It runs TypeScript and the
    full Resultar rule set against the project.
 2. Configure `resultar-check lsp` as the editor's stdio language server for inline diagnostics and
-   quick fixes. It reads the same project configuration as the CLI.
+   quick fixes. It analyzes unsaved buffers and dependencies with versioned edits; hover shows
+   `T`, `E`, and `R`. It reads the same project configuration as the CLI.
 3. Use JSONL, SARIF, or JUnit output when another CI or review system needs structured diagnostics;
    do not present those consumers as replacements for the native checker.
 4. Run the repository's native formatting, build, tests, analysis, package smoke, and example
@@ -197,6 +204,15 @@ JSONL fixes distinguish `correction` from `intentional-discard`; LSP actions car
 classification in `data.kind`. Do not apply a discard just to silence the checker: `void task`
 does not execute a lazy task or handle its errors. Corrections still need compilation and tests.
 
+Use `resultar-check overview --json` to inventory exported workflows/errors/services and
+`resultar-check quickfixes --json` to inspect proposed edits without writing files. Preserve
+concrete task requirements: assertions must not hide services or pending scope errors.
+Remove unused suppression entries; disabled rules are excluded from usage checks.
+
+The checker schema combines standard `tsconfig` options and Resultar rules for editor
+completion/validation. Schema resolution and compiler compatibility are separate checks;
+read [checker configuration](references/integrations.md#configure-the-native-checker) for details.
+
 Treat stable `resultar/*` rule IDs as architecture feedback. Fix the typed boundary or composition
 problem instead of suppressing diagnostics broadly. Use narrow ignore patterns only for deliberate
 test, script, generated, or process-boundary exceptions.

package/dist/agent/references/api.md

@@ -207,6 +207,13 @@ const workflow = safeTry(async function* () {
 Use `yield*` for `Result` and `ResultAsync`. Wrap raw promises before yielding. Avoid raw `await`,
 `try/catch`, and legacy `safeUnwrap()` inside the generator.
 
+## Function Utilities
+
+Root `pipe` supports zero through eight transforms; `flow` supports one through nine
+functions and preserves the first function's arguments/receiver. Both compose synchronously.
+`identity` returns the original value; `constant(value)` returns a callback capturing that value.
+Use `result.match({ ok: identity, error: constant(fallback) })` for fixed boundary fallbacks.
+
 ## ResultTask (Lazy Workflows)
 
 `ResultTask<A, E, R>` is a lazy, reusable description of work: building one starts nothing, and
@@ -215,12 +222,19 @@ laziness matters.
 
 - Build: `succeed`, `fail`, `fromResult`, `sync`, `try`, `tryPromise` (`try`/`tryPromise` map
   external throws into `E`; `sync` treats them as defects).
-- Compose lazily: `map`, `flatMap`, `catchAll`, `tap`, `gen` with `yield*` (also accepts
+- Compose lazily: `map`, `flatMap`, `catchAll`, `catchTag`, partial `catchTags`, `tap`, `gen` with `yield*` (also accepts
   `yield* result`: `Ok` unwraps, `Err` short-circuits into `E`).
+- `fn(function* (args) { ... })` creates a lazy parameterized function, capturing arguments/
+  receiver and creating fresh generators on each execution; infer all three task channels.
+- Tagged task recovery has instance/direct/curried forms. Handler errors and requirements
+  join the source; unhandled tags and scope markers remain. Defects/interruptions pass through;
+  composites follow `catchAll`'s `ResultTaskCauseError` policy.
+- `acquireDisposable` prefers async disposal, awaits it once in LIFO order, and treats
+  disposal failures as defects while preserving sequential body/cleanup causes.
 - Provide services: `yield* Tag`, then `provideService` / `provideServices` /
   `provideServiceResolver` (data-first and curried); missing or incompatible providers are
   compile-time errors, never runtime surprises.
-- Resources: `acquireRelease` + `scoped`; LIFO awaited finalizers run on every exit; deferred
+- Resources: `acquireRelease` / `acquireDisposable` + `scoped`; LIFO awaited finalizers run on every exit; deferred
   release errors live in `R` until `scoped` folds them into `E`; `catchAll` recovers a release
   failure only after `scoped`.
 - Boundaries: `runExit` preserves `Success`/`Fail`/`Die`/`Interrupt`/`Sequential`; `runResult`

package/dist/agent/references/integrations.md

@@ -222,6 +222,19 @@ extension. Start `resultar-check lsp` from the editor's language-server configur
 rule IDs such as `resultar/no-discard`; pass `--format json` (or `--json`) when machine-readable JSON
 Lines output is needed.
 
+The `$schema` composes the standard SchemaStore `tsconfig` schema with Resultar rule options.
+Preserve it when configuring the checker so editors can complete and validate both sets of options.
+Resolving the standard reference requires SchemaStore access or an editor cache. The schema is
+independent of the installed TypeScript version; validate compiler compatibility with the native
+checker and, when relevant, the consuming project's installed compiler. The `plugins` entry remains
+configuration for the native checker, including when the project uses TypeScript 7.
+
+The LSP overlays unsaved project buffers and dependencies, debounces changes, and uses
+versioned UTF-16 edits. Hover separates task success/errors/requirements and service contracts.
+Use `resultar-check overview --json` for a sorted exported inventory and
+`resultar-check quickfixes --json` for read-only fix previews. The latter emits diagnostic
+JSONL; inventory output is one document with `schemaVersion: 1`.
+
 Read `packages/check/README.md` for all rules, severities, modes, and command-line flags. Use narrow
 `ignoreFilePatterns` only for deliberate tests, scripts, generated files, or terminal process boundaries.
 
@@ -241,7 +254,8 @@ When an agent encounters a diagnostic, fix the architecture first:
 - replace project-wide `try/catch` with `tryResult` or `tryResultAsync` when `noTryCatch` is enabled;
 - wrap raw promise awaits in Resultar contexts;
 - use `yield*` and avoid `try/catch` inside `Result.gen` / `safeTry`;
-- preserve the inferred error channel instead of asserting it away.
+- preserve inferred error and task requirements channels instead of asserting them away;
+- remove obsolete suppression entries without suppressing their diagnostic broadly.
 
 ## Discover Repository Commands
 

package/dist/agent/references/services.md

@@ -12,7 +12,7 @@ The former `/advanced` subpath has been removed; migrate existing imports to `re
 ({ ... }) })`. The readonly dependency object is inferred; `make` can return the service
   object directly or a ResultTask. Factories remain lazy and synchronous values add no typed
   initialization errors. Promises and thenables are rejected. Use `ResultTask.gen` for
-  initialization with typed failures, additional requirements or owned resources. Without `requires`, pass a task directly as `make` and yield requirements inline or by token.
+  initialization with typed failures, additional requirements or owned resources. Without `requires`, pass a task or a zero-argument factory returning a synchronous value or ResultTask. Tasks can yield requirements inline or by token.
   Both forms support `Service<Contract>()('name', definition)`.
 - Keep provider registration explicit. `requires` does not acquire or register dependencies.
   Inline tokens resolve by name in DI or `provideServices`; core `provideService` supplies an exact

package/dist/agent/versions.json

@@ -1,10 +1,10 @@
 {
-  "resultar-check": "3.2.0",
-  "resultar-di": "0.4.0",
-  "resultar-fastify": "0.4.0",
-  "resultar-hono": "0.4.0",
+  "resultar-check": "3.3.0",
+  "resultar-di": "0.4.1",
+  "resultar-fastify": "0.4.1",
+  "resultar-hono": "0.4.1",
   "resultar-request": "0.1.2",
   "resultar-request-typebox": "0.1.2",
   "resultar-request-zod": "0.1.2",
-  "resultar": "3.9.1"
+  "resultar": "3.10.0"
 }

package/dist/index.d.ts

@@ -12,6 +12,7 @@ declare abstract class Pipeable {
    * Use `pipe` to package reusable Result or ResultAsync combinators without hiding the underlying
    * type.
    */
+  pipe(): this;
   pipe<A>(ab: PipeFn<this, A>): A;
   pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B;
   pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C;
@@ -309,9 +310,15 @@ interface ResultOperations<T, E> {
    * Pipes this Result through reusable transformation functions.
    */
   pipe: {
-    <A>(ab: PipeFn<Result<T, E>, A>): A;
-    <A, B>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>): B;
-    <A, B, C>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C;
+    <Self>(this: Self): Self;
+    <P1>(f0: PipeFn<Result<T, E>, P1>): P1;
+    <P1, P2>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>): P2;
+    <P1, P2, P3>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>): P3;
+    <P1, P2, P3, P4>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>, f3: PipeFn<P3, P4>): P4;
+    <P1, P2, P3, P4, P5>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>, f3: PipeFn<P3, P4>, f4: PipeFn<P4, P5>): P5;
+    <P1, P2, P3, P4, P5, P6>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>, f3: PipeFn<P3, P4>, f4: PipeFn<P4, P5>, f5: PipeFn<P5, P6>): P6;
+    <P1, P2, P3, P4, P5, P6, P7>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>, f3: PipeFn<P3, P4>, f4: PipeFn<P4, P5>, f5: PipeFn<P5, P6>, f6: PipeFn<P6, P7>): P7;
+    <P1, P2, P3, P4, P5, P6, P7, P8>(f0: PipeFn<Result<T, E>, P1>, f1: PipeFn<P1, P2>, f2: PipeFn<P2, P3>, f3: PipeFn<P3, P4>, f4: PipeFn<P4, P5>, f5: PipeFn<P5, P6>, f6: PipeFn<P6, P7>, f7: PipeFn<P7, P8>): P8;
   };
   /**
    * Runs a side effect with the Ok or Err value and returns this same Result.
@@ -847,6 +854,11 @@ type GeneratorRequirements<Yield> = Yield extends {
   readonly _tag: "Service";
   readonly tag: infer Tag;
 } ? Tag : never;
+type FunctionTask<Body extends (...args: never[]) => unknown> = ReturnType<Body> extends Generator<infer Yield, infer Return, infer _Next> ? ResultTask<Return, GeneratorError<Yield>, GeneratorRequirements<Yield>> : never;
+type TaskSuccess<T> = T extends ResultTask<infer A, infer _E, infer _R> ? A : never;
+type TaskError<T> = T extends ResultTask<infer _A, infer E, infer _R> ? E : never;
+type TaskRequirements<T> = T extends ResultTask<infer _A, infer _E, infer R> ? R : never;
+type TaskHandlers<E, H> = CatchTagHandlers<E, H, ResultTask<unknown, unknown, unknown>>;
 type ResultTaskRunArguments<R> = [WithoutScope<R>] extends [never] ? [options?: ResultTaskRunOptions<R>] : [options: ResultTaskRunOptions<R>];
 /** Returns true if a value is a nominal `ServiceTag`. */
 export declare const isServiceTag: (value: unknown) => value is ServiceTag<string, unknown>;
@@ -894,12 +906,16 @@ export declare class ResultTask<out A, out E = never, out R = never> extends Pip
    * scope requirement until `scoped` or a run boundary closes it; catchAll cannot erase them early.
    */
   static acquireRelease<A, E, R, ReleaseError = never, ReleaseR = never>(options: ResultTaskAcquireReleaseOptions<A, E, R, ReleaseError, ReleaseR>): ResultTask<A, E, R | WithoutScope<ReleaseR> | ResultTaskScope<ReleaseError | ScopeError<ReleaseR>>>;
+  /** Acquires a native disposable lazily and releases it in the owning scope. */
+  static acquireDisposable<A extends Disposable | AsyncDisposable, E, R>(acquire: ResultTask<A, E, R>): ResultTask<A, E, R | ResultTaskScope<never>>;
   /** Closes a child scope before continuing, adding its deferred release errors to E. */
   static scoped<A, E, R>(task: ResultTask<A, E, R>): ResultTask<A, E | ScopeError<R>, WithoutScope<R>>;
   /** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
   static service<Service, const Identifier extends string>(identifier: Identifier): ServiceTag<Identifier, Service>;
   /** Infers the literal identifier after specifying the service contract. */
   static service<Service>(): <const Identifier extends string>(identifier: Identifier) => ServiceTag<Identifier, Service>;
+  /** Wraps a generator function without executing it until each task run. */
+  static fn<Body extends (...args: never[]) => Generator<unknown, unknown, never>>(body: Body): (this: ThisParameterType<Body>, ...args: Parameters<Body>) => FunctionTask<Body>;
   /** Builds a task from a generator and short-circuits on the first failed task. */
   static gen<Yield, Return, Next>(body: () => Generator<Yield, Return, Next>): ResultTask<Return, GeneratorError<Yield>, GeneratorRequirements<Yield>>;
   /** Maps the success value without executing the task. */
@@ -913,6 +929,10 @@ export declare class ResultTask<out A, out E = never, out R = never> extends Pip
    * removed E cannot escape through runExit; the original tree remains available on error.cause.
    */
   catchAll<B, E2, R2>(f: (error: E) => ResultTask<B, E2, R2>): ResultTask<A | B, E2, R | R2>;
+  /** Recovers a selected simple tagged failure, preserving other errors and scope requirements. */
+  catchTag<const Tag extends TagsOf<E>, B, E2, R2>(tag: Tag, handler: (error: ErrorForTag$1<E, Tag>) => ResultTask<B, E2, R2>): ResultTask<A | B, ExcludeTag<E, Tag> | E2, R | R2>;
+  /** Recovers any supplied tags; omitted tags remain in the error channel. */
+  catchTags<const H extends object>(handlers: H & TaskHandlers<E, H>): ResultTask<A | TaskSuccess<CatchTagHandlerResult<H>>, ExcludeTag<E, keyof H & string> | TaskError<CatchTagHandlerResult<H>>, R | TaskRequirements<CatchTagHandlerResult<H>>>;
   /** Maps the error value without executing the task. */
   mapError<E2>(f: (error: E) => E2): ResultTask<A, E2, R>;
   /**
@@ -969,6 +989,14 @@ export declare class ResultTask<out A, out E = never, out R = never> extends Pip
   /** Recovers from a typed failure using the canonical functional form or curried for `pipe`. */
   static catchAll<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (error: E) => ResultTask<B, E2, R2>): ResultTask<A | B, E2, R | R2>;
   static catchAll<E, B, E2, R2>(f: (error: E) => ResultTask<B, E2, R2>): <A, R>(task: ResultTask<A, E, R>) => ResultTask<A | B, E2, R | R2>;
+  /** Recovers a tagged failure in direct or pipe-friendly form. */
+  static catchTag<A, E, R, const Tag extends TagsOf<E>, B, E2, R2>(task: ResultTask<A, E, R>, tag: Tag, handler: (error: ErrorForTag$1<E, Tag>) => ResultTask<B, E2, R2>): ResultTask<A | B, ExcludeTag<E, Tag> | E2, R | R2>;
+  static catchTag<const Tag extends string, Handled extends {
+    readonly _tag: Tag;
+  }, B, E2, R2>(tag: Tag, handler: (error: Handled) => ResultTask<B, E2, R2>): <A, E, R>(task: ResultTask<A, E, R> & (Tag extends TagsOf<E> ? (ErrorForTag$1<E, Tag> extends Handled ? unknown : never) : never)) => ResultTask<A | B, ExcludeTag<E, Tag> | E2, R | R2>;
+  /** Recovers supplied tags in direct or pipe-friendly form. */
+  static catchTags<A, E, R, const H extends object>(task: ResultTask<A, E, R>, handlers: H & TaskHandlers<E, H>): ResultTask<A | TaskSuccess<CatchTagHandlerResult<H>>, ExcludeTag<E, keyof H & string> | TaskError<CatchTagHandlerResult<H>>, R | TaskRequirements<CatchTagHandlerResult<H>>>;
+  static catchTags<const H extends object>(handlers: H): <A, E, R>(task: ResultTask<A, E, R> & (H extends TaskHandlers<E, H> ? unknown : never)) => ResultTask<A | TaskSuccess<CatchTagHandlerResult<H>>, ExcludeTag<E, keyof H & string> | TaskError<CatchTagHandlerResult<H>>, R | TaskRequirements<CatchTagHandlerResult<H>>>;
   /** Executes a side effect on the success value using the canonical functional form or curried for `pipe`. */
   static tap<A, E, R, E2 = never, R2 = never>(task: ResultTask<A, E, R>, f: (value: A) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): ResultTask<A, E | E2, R | R2>;
   static tap<A, E2 = never, R2 = never>(f: (value: A) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): <E, R>(task: ResultTask<A, E, R>) => ResultTask<A, E | E2, R | R2>;
@@ -1990,4 +2018,30 @@ export declare const matchError: <ErrorType extends Error, ReturnType>(error: Er
  */
 export declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
+//#region src/function.d.ts
+/** Returns its input, preserving its type and reference. */
+export declare const identity: <A>(value: A) => A;
+/** Captures a value and returns it on every call without copying or recomputing it. */
+export declare const constant: <A>(value: A) => (() => A);
+/** Applies zero through eight synchronous transformations from left to right. */
+export declare function pipe<A>(value: A): A;
+export declare function pipe<A, B>(value: A, f0: PipeFn<A, B>): B;
+export declare function pipe<A, B, C>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>): C;
+export declare function pipe<A, B, C, D>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>): D;
+export declare function pipe<A, B, C, D, E>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>, f3: PipeFn<D, E>): E;
+export declare function pipe<A, B, C, D, E, F>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>, f3: PipeFn<D, E>, f4: PipeFn<E, F>): F;
+export declare function pipe<A, B, C, D, E, F, G>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>, f3: PipeFn<D, E>, f4: PipeFn<E, F>, f5: PipeFn<F, G>): G;
+export declare function pipe<A, B, C, D, E, F, G, H>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>, f3: PipeFn<D, E>, f4: PipeFn<E, F>, f5: PipeFn<F, G>, f6: PipeFn<G, H>): H;
+export declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, f0: PipeFn<A, B>, f1: PipeFn<B, C>, f2: PipeFn<C, D>, f3: PipeFn<D, E>, f4: PipeFn<E, F>, f5: PipeFn<F, G>, f6: PipeFn<G, H>, f7: PipeFn<H, I>): I;
+/** Composes functions, preserving the arguments and receiver of the first function. */
+export declare function flow<First extends (...args: never[]) => unknown>(first: First): (this: ThisParameterType<First>, ...args: Parameters<First>) => ReturnType<First>;
+export declare function flow<First extends (...args: never[]) => unknown, B>(first: First, f1: PipeFn<ReturnType<First>, B>): (this: ThisParameterType<First>, ...args: Parameters<First>) => B;
+export declare function flow<First extends (...args: never[]) => unknown, B, C>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>): (this: ThisParameterType<First>, ...args: Parameters<First>) => C;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>): (this: ThisParameterType<First>, ...args: Parameters<First>) => D;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D, E>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>, f4: PipeFn<D, E>): (this: ThisParameterType<First>, ...args: Parameters<First>) => E;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D, E, F>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>, f4: PipeFn<D, E>, f5: PipeFn<E, F>): (this: ThisParameterType<First>, ...args: Parameters<First>) => F;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D, E, F, G>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>, f4: PipeFn<D, E>, f5: PipeFn<E, F>, f6: PipeFn<F, G>): (this: ThisParameterType<First>, ...args: Parameters<First>) => G;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D, E, F, G, H>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>, f4: PipeFn<D, E>, f5: PipeFn<E, F>, f6: PipeFn<F, G>, f7: PipeFn<G, H>): (this: ThisParameterType<First>, ...args: Parameters<First>) => H;
+export declare function flow<First extends (...args: never[]) => unknown, B, C, D, E, F, G, H, I>(first: First, f1: PipeFn<ReturnType<First>, B>, f2: PipeFn<B, C>, f3: PipeFn<C, D>, f4: PipeFn<D, E>, f5: PipeFn<E, F>, f6: PipeFn<F, G>, f7: PipeFn<G, H>, f8: PipeFn<H, I>): (this: ThisParameterType<First>, ...args: Parameters<First>) => I;
+//#endregion
 export { type Cause, type ErrResult, type Exit, type OkResult, type Redacted, type ResultAsyncAbortSignal, type ResultAsyncCallbackCleanup, type ResultAsyncCallbackContext, type ResultAsyncConcurrency, type ResultAsyncFromCallbackOptions, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, type ResultTaskAcquireReleaseOptions, type ResultTaskMatchOptions, type ResultTaskRunOptions, type ResultTaskScope, type ResultTaskScopeOwner, type ResultTaskServiceResolver, type ResultTaskServices, type ResultTaskTryOptions, type ResultTaskTryPromiseOptions, type SafeTryAsyncOptions, type SafeTryOptions, type ServiceTag, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, tryResult as default, tryResult as try, tryResultAsync as tryAsync };

package/dist/index.js

@@ -20,10 +20,13 @@ const isAbortError = (value) => value instanceof AbortError || hasAbortName(valu
 //#endregion
 //#region src/pipe.ts
 const runPipe = (self, fns) => {
-	const first = fns[0];
-	if (!first) return self;
-	let input = first(self);
-	for (const fn of fns.slice(1)) input = fn(input);
+	let input = self;
+	const length = fns.length;
+	for (let index = 0; index < length; index += 1) {
+		const transform = fns[index];
+		if (transform === void 0) throw new TypeError("pipe requires transformation functions");
+		input = transform(input);
+	}
 	return input;
 };
 var Pipeable = class {
@@ -42,24 +45,9 @@ const createResultAsync = (promise) => {
 	return resultAsyncFactory(promise);
 };
 //#endregion
-//#region src/error.ts
-const defaultErrorConfig = { withStackTrace: false };
-const createResultarError = (message, result, config = defaultErrorConfig) => {
-	const data = result.isOk() ? {
-		type: "Ok",
-		value: result.value
-	} : {
-		type: "Err",
-		value: result.error
-	};
-	const maybeStack = config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0;
-	const error = {
-		name: "ResultarError",
-		data,
-		message
-	};
-	return maybeStack === void 0 ? error : Object.assign(error, { stack: maybeStack });
-};
+//#region src/dual.ts
+/** Internal dispatcher; callers retain explicit overloads and argument validation. */
+const dual = (isDataFirst, body) => (...args) => isDataFirst(args) ? body(...args) : (self) => body(...[self, ...args]);
 //#endregion
 //#region src/tagged-match.ts
 const noTaggedHandlerMatch = Symbol("noTaggedHandlerMatch");
@@ -87,6 +75,25 @@ const matchTaggedOr = (error, handlers, fallback) => {
 	return isTaggedHandlerMatch(handled) ? handled.value : fallback(error);
 };
 //#endregion
+//#region src/error.ts
+const defaultErrorConfig = { withStackTrace: false };
+const createResultarError = (message, result, config = defaultErrorConfig) => {
+	const data = result.isOk() ? {
+		type: "Ok",
+		value: result.value
+	} : {
+		type: "Err",
+		value: result.error
+	};
+	const maybeStack = config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0;
+	const error = {
+		name: "ResultarError",
+		data,
+		message
+	};
+	return maybeStack === void 0 ? error : Object.assign(error, { stack: maybeStack });
+};
+//#endregion
 //#region src/result.ts
 const combineResultList = (resultList) => {
 	const values = [];
@@ -1214,6 +1221,17 @@ var ResultTask = class ResultTask extends Pipeable {
 			return acquired;
 		});
 	}
+	/** Acquires a native disposable lazily and releases it in the owning scope. */
+	static acquireDisposable(acquire) {
+		return ResultTask.acquireRelease({
+			acquire,
+			release: (resource) => new ResultTask(async () => {
+				if (Symbol.asyncDispose in resource) await resource[Symbol.asyncDispose]();
+				else resource[Symbol.dispose]();
+				return success(void 0);
+			})
+		});
+	}
 	/** Closes a child scope before continuing, adding its deferred release errors to E. */
 	static scoped(task) {
 		return new ResultTask(async (context) => {
@@ -1226,6 +1244,12 @@ var ResultTask = class ResultTask extends Pipeable {
 		if (identifier === void 0) return (name) => new ServiceTagValue(name);
 		return new ServiceTagValue(identifier);
 	}
+	/** Wraps a generator function without executing it until each task run. */
+	static fn(body) {
+		return function(...args) {
+			return ResultTask.gen(() => body.call(this, ...args));
+		};
+	}
 	/** Builds a task from a generator and short-circuits on the first failed task. */
 	static gen(body) {
 		return new ResultTask(async (context) => {
@@ -1286,6 +1310,17 @@ var ResultTask = class ResultTask extends Pipeable {
 			f
 		});
 	}
+	/** Recovers a selected simple tagged failure, preserving other errors and scope requirements. */
+	catchTag(tag, handler) {
+		return this.catchAll((error) => hasTag(error, tag) ? handler(error) : ResultTask.fail(error));
+	}
+	/** Recovers any supplied tags; omitted tags remain in the error channel. */
+	catchTags(handlers) {
+		return this.catchAll((error) => {
+			const handled = callTaggedHandler(error, handlers);
+			return isTaggedHandlerMatch(handled) ? handled.value : ResultTask.fail(error);
+		});
+	}
 	/** Maps the error value without executing the task. */
 	mapError(f) {
 		return new ResultTask({
@@ -1465,39 +1500,54 @@ var ResultTask = class ResultTask extends Pipeable {
 		throw new TypeError("ResultTask.provideServices requires a services object");
 	}
 	static map(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.map(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.map requires a mapping function");
-		return taskOrF.map(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.map requires a mapping function");
+			return task.map(callback);
+		})(taskOrF, f);
 	}
 	static mapError(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.mapError(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.mapError requires an error mapping function");
-		return taskOrF.mapError(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.mapError requires an error mapping function");
+			return task.mapError(callback);
+		})(taskOrF, f);
 	}
 	static flatMap(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.flatMap(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.flatMap requires a continuation function");
-		return taskOrF.flatMap(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.flatMap requires a continuation function");
+			return task.flatMap(callback);
+		})(taskOrF, f);
 	}
 	static andThen(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.flatMap(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.andThen requires a continuation function");
-		return taskOrF.flatMap(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.andThen requires a continuation function");
+			return task.flatMap(callback);
+		})(taskOrF, f);
 	}
 	static catchAll(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.catchAll(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.catchAll requires a recovery function");
-		return taskOrF.catchAll(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.catchAll requires a recovery function");
+			return task.catchAll(callback);
+		})(taskOrF, f);
+	}
+	static catchTag(...args) {
+		if (typeof args[0] === "string") return (task) => ResultTask.catchTag(task, args[0], args[1]);
+		return args[0].catchTag(args[1], args[2]);
+	}
+	static catchTags(...args) {
+		if (args.length === 1) return (task) => task.catchTags(args[0]);
+		return args[0].catchTags(args[1]);
 	}
 	static tap(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.tap(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.tap requires a side-effect function");
-		return taskOrF.tap(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.tap requires a side-effect function");
+			return task.tap(callback);
+		})(taskOrF, f);
 	}
 	static tapError(taskOrF, f) {
-		if (typeof taskOrF === "function") return (task) => task.tapError(taskOrF);
-		if (f === void 0) throw new TypeError("ResultTask.tapError requires an error side-effect function");
-		return taskOrF.tapError(f);
+		return dual((args) => typeof args[0] !== "function", (task, callback) => {
+			if (callback === void 0) throw new TypeError("ResultTask.tapError requires an error side-effect function");
+			return task.tapError(callback);
+		})(taskOrF, f);
 	}
 	static as(taskOrValue, value) {
 		if (taskOrValue instanceof ResultTask) {
@@ -2928,4 +2978,18 @@ const runPromise = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 const tryCatchAsync = tryResultAsync;
 //#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, MissingServiceError, Result, ResultAsync, ResultTask, ResultTaskCauseError, ResultTaskTypeId, ResultTaskYieldTypeId, ServiceTagTypeId, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, isResultTask, isServiceTag, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, serviceTag, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+//#region src/function.ts
+/** Returns its input, preserving its type and reference. */
+const identity = (value) => value;
+/** Captures a value and returns it on every call without copying or recomputing it. */
+const constant = (value) => () => value;
+function pipe(value, ...functions) {
+	return runPipe(value, functions);
+}
+function flow(first, ...functions) {
+	return function(...args) {
+		return runPipe(first.apply(this, args), functions);
+	};
+}
+//#endregion
+export { AbortError, DisposableResult, DisposableResultAsync, MissingServiceError, Result, ResultAsync, ResultTask, ResultTaskCauseError, ResultTaskTypeId, ResultTaskYieldTypeId, ServiceTagTypeId, constant, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, flow, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, identity, isAbortError, isError, isRedacted, isResultTask, isServiceTag, matchError, matchErrorPartial, ok, okAsync, pipe, redact, revealRedacted, runPromise, runSync, safeTry, serviceTag, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };

package/dist/llms.txt

@@ -1,4 +1,4 @@
-# Resultar 3.9.1
+# Resultar 3.10.0
 
 Documentation bundled with this package version. Installed declarations remain authoritative.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resultar",
-  "version": "3.9.1",
+  "version": "3.10.0",
   "description": "Result pattern for TypeScript",
   "keywords": [
     "error-handling",
@@ -43,14 +43,14 @@
   "devDependencies": {
     "@stryker-mutator/core": "10.0.0",
     "@stryker-mutator/vitest-runner": "10.0.0",
-    "@types/node": "26.5.1",
-    "@vitest/coverage-v8": "4.1.11",
-    "@vitest/ui": "4.1.11",
-    "fallow": "3.25.0",
-    "tsx": "4.23.13",
+    "@types/node": "26.6.4",
+    "@vitest/coverage-v8": "5.0.3",
+    "@vitest/ui": "5.0.3",
+    "fallow": "3.32.0",
+    "tsx": "4.23.15",
     "typescript": "7.0.2",
-    "vite-plus": "0.3.2",
-    "vitest": "4.1.11"
+    "vite-plus": "1.1.0",
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
     "typescript": ">=7.0.0"