resultar 3.6.0 → 3.7.0

package/dist/index.d.ts

@@ -15,6 +15,11 @@ declare abstract class Pipeable {
   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;
+  pipe<A, B, C, D>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>, de: PipeFn<C, D>): D;
+  pipe<A, B, C, D, E>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>, de: PipeFn<C, D>, ef: PipeFn<D, E>): E;
+  pipe<A, B, C, D, E, F>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>, de: PipeFn<C, D>, ef: PipeFn<D, E>, fg: PipeFn<E, F>): F;
+  pipe<A, B, C, D, E, F, G>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>, de: PipeFn<C, D>, ef: PipeFn<D, E>, fg: PipeFn<E, F>, gh: PipeFn<F, G>): G;
+  pipe<A, B, C, D, E, F, G, H>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>, de: PipeFn<C, D>, ef: PipeFn<D, E>, fg: PipeFn<E, F>, gh: PipeFn<F, G>, hi: PipeFn<G, H>): H;
 }
 //#endregion
 //#region src/utils.d.ts
@@ -711,6 +716,293 @@ declare class AbortError extends Error {
  */
 declare const isAbortError: (value: unknown) => value is AbortError;
 //#endregion
+//#region src/result-task.d.ts
+/** A failure cause produced by a `ResultTask` execution. */
+type Cause<E> = {
+  readonly _tag: "Fail";
+  readonly error: E;
+} | {
+  readonly _tag: "Die";
+  readonly defect: unknown;
+} | {
+  readonly _tag: "Interrupt";
+  readonly reason: unknown;
+} | {
+  readonly _tag: "Sequential";
+  readonly left: Cause<E>;
+  readonly right: Cause<E>;
+};
+/** Rejection used when a simplified boundary cannot represent multiple failures. */
+declare class ResultTaskCauseError extends Error {
+  override readonly cause: Cause<unknown>;
+  constructor(cause: Cause<unknown>);
+}
+/** Type identifier symbol for nominal `ResultTask` branding and variance checks. */
+declare const ResultTaskTypeId: unique symbol;
+/** Type identifier symbol for nominal `ServiceTag` branding. */
+declare const ServiceTagTypeId: unique symbol;
+/** Type identifier symbol for nominal `ResultTask` yieldable objects. */
+declare const ResultTaskYieldTypeId: unique symbol;
+/** Error thrown as a Die cause when a requested service is not provided in the environment. */
+declare class MissingServiceError extends Error {
+  readonly serviceIdentifier: string;
+  constructor(serviceIdentifier: string);
+}
+declare const scopeTypeId: unique symbol;
+/** Tracks deferred release failures until the owning scope is closed. */
+interface ResultTaskScope<out E> {
+  readonly [scopeTypeId]: E;
+}
+type ScopeError<R> = R extends ResultTaskScope<infer E> ? E : never;
+type WithoutScope<R> = Exclude<R, ResultTaskScope<unknown>>;
+/** Resource acquisition and release share one execution and service environment. */
+interface ResultTaskAcquireReleaseOptions<A, E, R, ReleaseError, ReleaseR> {
+  readonly acquire: ResultTask<A, E, R>;
+  readonly release: (resource: A, exit: Exit<unknown, unknown>) => ResultTask<void, ReleaseError, ReleaseR>;
+}
+/** The complete outcome of a `ResultTask` execution. */
+type Exit<A, E> = {
+  readonly _tag: "Success";
+  readonly value: A;
+} | {
+  readonly _tag: "Failure";
+  readonly cause: Cause<E>;
+};
+/** Handlers for matching both success and failure cases of a ResultTask. */
+type ResultTaskMatchOptions<A, E, B, C = B> = {
+  readonly onSuccess: (value: A) => B;
+  readonly onFailure: (error: E) => C;
+} | {
+  readonly ok: (value: A) => B;
+  readonly err: (error: E) => C;
+};
+/** A service that can be requested from a `ResultTask.gen` workflow. */
+interface ServiceTag<Identifier extends string, Service> {
+  readonly [ServiceTagTypeId]: typeof ServiceTagTypeId;
+  readonly _tag: "ServiceTag";
+  readonly identifier: Identifier;
+  readonly key: symbol;
+  readonly [Symbol.iterator]: () => Generator<ResultTaskServiceYield<ServiceTag<Identifier, Service>>, Service, Service>;
+}
+/** Resolves a service requested by a `ResultTask.gen` workflow. */
+type ResultTaskServiceResolver<R, E = never, ResolverR = never> = { readonly [Tag in Extract<R, AnyServiceTag> as Tag["identifier"]]: () => ResultTask<ServiceForTag<Tag>, E, ResolverR>; };
+type ResolverTasks<Resolvers> = Resolvers[keyof Resolvers] extends (() => infer Task) ? Task : never;
+type ResolverError<Resolvers> = [ResolverTasks<Resolvers>] extends [never] ? never : ResolverTasks<Resolvers> extends ResultTask<unknown, infer E, unknown> ? E : never;
+type ResolverRequirements<Resolvers> = [ResolverTasks<Resolvers>] extends [never] ? never : ResolverTasks<Resolvers> extends ResultTask<unknown, unknown, infer R> ? R : never;
+type EliminateProvidedServices<R, Services> = R extends AnyServiceTag ? R["identifier"] extends keyof Services ? Services[R["identifier"]] extends ServiceForTag<R> ? never : R : R : R;
+type EliminateResolvedServices<R, Resolvers> = R extends AnyServiceTag ? R["identifier"] extends keyof Resolvers ? Resolvers[R["identifier"]] extends (() => ResultTask<infer S, unknown, unknown>) ? S extends ServiceForTag<R> ? never : R : R : R : R;
+type IncompatibleProvidedServices<R, Services> = R extends AnyServiceTag ? R["identifier"] extends keyof Services ? Services[R["identifier"]] extends ServiceForTag<R> ? never : R["identifier"] : never : never;
+type IncompatibleResolvedServices<R, Resolvers> = R extends AnyServiceTag ? R["identifier"] extends keyof Resolvers ? Resolvers[R["identifier"]] extends (() => ResultTask<infer S, unknown, unknown>) ? S extends ServiceForTag<R> ? never : R["identifier"] : R["identifier"] : never : never;
+/** Owns resources across executions. Close it after its consumers have finished. */
+interface ResultTaskScopeOwner {
+  readonly use: <A, E, R>(task: ResultTask<A, E, R>) => ResultTask<A, E, R>;
+  readonly close: (exit?: Exit<unknown, unknown>) => ResultTask<void, unknown>;
+}
+/** Options for running a `ResultTask` with an optional signal and its required services. */
+type ResultTaskRunOptions<R = never> = {
+  readonly signal?: AbortSignal;
+} & ([WithoutScope<R>] extends [never] ? {
+  readonly services?: never;
+} : {
+  readonly services: ResultTaskServices<R>;
+});
+/** The object-shaped service environment required by a task. */
+type ResultTaskServices<R> = { readonly [Tag in Extract<R, AnyServiceTag> as Tag["identifier"]]: ServiceForTag<Tag>; };
+/** Options for creating a synchronous task with an explicit error boundary. */
+interface ResultTaskTryOptions<A, E> {
+  readonly try: () => A;
+  readonly catch: (cause: unknown) => E;
+}
+/** Options for creating a lazy promise-producing task with an explicit error boundary. */
+interface ResultTaskTryPromiseOptions<A, E> {
+  readonly try: (signal: AbortSignal) => PromiseLike<A>;
+  readonly catch: (cause: unknown) => E;
+}
+type AnyServiceTag = Pick<ServiceTag<string, unknown>, "_tag" | "identifier" | "key">;
+type ServiceForTag<Tag> = Tag extends ServiceTag<string, infer Service> ? Service : never;
+type WithoutServices<R> = Exclude<R, AnyServiceTag>;
+interface ResultTaskYield<A, E, R> {
+  readonly [ResultTaskYieldTypeId]: typeof ResultTaskYieldTypeId;
+  readonly _tag: "ResultTask";
+  readonly task: ResultTask<A, E, R>;
+}
+interface ResultTaskServiceYield<Tag extends AnyServiceTag> {
+  readonly [ResultTaskYieldTypeId]: typeof ResultTaskYieldTypeId;
+  readonly _tag: "Service";
+  readonly tag: Tag;
+}
+type GeneratorError<Yield> = Yield extends {
+  readonly _tag: "ResultTask";
+  readonly task: infer Task;
+} ? Task extends ResultTask<infer _A, infer E, infer _R> ? E : never : Yield extends {
+  readonly error: infer E;
+  readonly isErr: unknown;
+} ? E : never;
+type GeneratorRequirements<Yield> = Yield extends {
+  readonly _tag: "ResultTask";
+  readonly task: infer Task;
+} ? Task extends ResultTask<infer _A, infer _E, infer R> ? R : never : Yield extends {
+  readonly _tag: "Service";
+  readonly tag: infer Tag;
+} ? Tag : never;
+type ResultTaskRunArguments<R> = [WithoutScope<R>] extends [never] ? [options?: ResultTaskRunOptions<R>] : [options: ResultTaskRunOptions<R>];
+/** Returns true if a value is a nominal `ServiceTag`. */
+declare const isServiceTag: (value: unknown) => value is ServiceTag<string, unknown>;
+/** Returns true if a value is a `ResultTask` instance. */
+declare const isResultTask: (value: unknown) => value is ResultTask<unknown, unknown, unknown>;
+/** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
+declare const serviceTag: <Service, const Identifier extends string = string>(identifier: Identifier) => ServiceTag<Identifier, Service>;
+interface ContinuationStep {
+  readonly current: ResultTask<unknown, unknown, unknown> | undefined;
+  readonly currentExit: Exit<unknown, unknown> | undefined;
+}
+/**
+ * A lazy, composable workflow that can succeed with `A` or fail with `E`.
+ *
+ * Constructing a `ResultTask` never runs its work. Use `runResult`, `runExit`, or `runPromise` at an
+ * explicit application boundary to execute it.
+ */
+interface ResultTask<out A, out E = never, out R = never> {
+  readonly [ResultTaskTypeId]: {
+    readonly success: (_: never) => A;
+    readonly error: (_: never) => E;
+    readonly requirements: (_: never) => R;
+  };
+}
+declare class ResultTask<out A, out E = never, out R = never> extends Pipeable {
+  private readonly typeWitness;
+  private readonly instruction;
+  private readonly execute;
+  private constructor();
+  /** @internal */
+  static toTapContinuationStep(res: unknown, onSuccess: () => ResultTask<unknown, unknown, unknown>, passThroughExit: Exit<unknown, unknown>): ContinuationStep;
+  private static runTaskLoop;
+  /** Creates a task that succeeds with `value` when it is executed. */
+  static succeed<A>(value: A): ResultTask<A, never>;
+  static succeed<A, E>(value: A): ResultTask<A, E>;
+  /** Creates a task that fails with `error` when it is executed. */
+  static fail<const E>(error: E): ResultTask<never, E>;
+  /** Lifts an already computed Result into a lazy task. */
+  static fromResult<A, E>(result: Result<A, E>): ResultTask<A, E>;
+  /** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
+  static sync<A>(evaluate: () => A): ResultTask<A>;
+  /** Creates a task that maps synchronous throws into the typed error channel. */
+  static try<A, E>(options: ResultTaskTryOptions<A, E>): ResultTask<A, E>;
+  /** Creates a lazy task that preserves synchronous throws and promise rejections as unknown. */
+  static tryPromise<A>(run: (signal: AbortSignal) => PromiseLike<A>): ResultTask<A, unknown>;
+  /** Creates a lazy task that maps synchronous throws and promise rejections into `E`. */
+  static tryPromise<A, E>(options: ResultTaskTryPromiseOptions<A, E>): ResultTask<A, E>;
+  /**
+   * Acquires lazily and registers release in the current scope. Release failures remain in the
+   * 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>>>;
+  /** 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>;
+  /** 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. */
+  map<B>(f: (value: A) => B): ResultTask<B, E, R>;
+  /** Chains another task from the success value without executing either task immediately. */
+  flatMap<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  /** Alias for `flatMap`, matching the existing Resultar vocabulary. */
+  andThen<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  /**
+   * Recovers a single typed failure. Composite causes become a Die(ResultTaskCauseError) so the
+   * 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>;
+  /** Maps the error value without executing the task. */
+  mapError<E2>(f: (error: E) => E2): ResultTask<A, E2, R>;
+  /**
+   * Executes a side effect on the success value without modifying it.
+   * If the callback returns a `ResultTask`, its requirements and errors are merged.
+   */
+  tap<E2 = never, R2 = never>(f: (value: A) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): ResultTask<A, E | E2, R | R2>;
+  /**
+   * Executes a side effect on the error value without modifying it.
+   * If the callback returns a `ResultTask`, its requirements and errors are merged.
+   */
+  tapError<E2 = never, R2 = never>(f: (error: E) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): ResultTask<A, E | E2, R | R2>;
+  /** Replaces the success value with a constant. */
+  as<B>(value: B): ResultTask<B, E, R>;
+  /**
+   * Transforms both success and failure cases into a single value type.
+   */
+  match<B, C = B>(handlers: ResultTaskMatchOptions<A, E, B, C>): ResultTask<B | C, never, R>;
+  /** Converts this ResultTask into an eagerly started ResultAsync using the standard runtime. */
+  toResultAsync(this: ResultTask<A, E, never>): ResultAsync<A, E>;
+  /** Provides one required service and removes it from the task's requirements. */
+  provideService<Tag extends Extract<R, AnyServiceTag>>(tag: Tag, ...args: [service: ServiceForTag<Tag>]): ResultTask<A, E, Exclude<R, Tag>>;
+  /** Provides all requirements using an object keyed by service identifier. */
+  provideServices(services: ResultTaskServices<R>): ResultTask<A, E, Extract<R, ResultTaskScope<unknown>>>;
+  /** Provides a lazy resolver for service tags that are not already in the environment. */
+  provideServiceResolver<Resolvers extends ResultTaskServiceResolver<NoInfer<R>, unknown, unknown>>(resolvers: Resolvers): ResultTask<A, E | ResolverError<Resolvers>, WithoutServices<R> | ResolverRequirements<Resolvers>>;
+  /** Enables `yield* task` inside `ResultTask.gen` workflows. */
+  [Symbol.iterator](): Generator<ResultTaskYield<A, E, R>, A, Exit<A, E>>;
+  /** Provides one required service and removes it from the task's requirements. */
+  static provideService<A, E, R, Tag extends Extract<R, AnyServiceTag>>(task: ResultTask<A, E, R>, tag: Tag, service: ServiceForTag<Tag>): ResultTask<A, E, Exclude<R, Tag>>;
+  static provideService<Tag extends AnyServiceTag>(tag: Tag, service: ServiceForTag<Tag>): <A, E, R>(task: ResultTask<A, E, R>) => ResultTask<A, E, Exclude<R, Tag>>;
+  /** Provides a lazy resolver for service tags that are not already in the environment. */
+  static provideServiceResolver<A, E, R, Resolvers extends ResultTaskServiceResolver<NoInfer<R>, unknown, unknown>>(task: ResultTask<A, E, R>, resolvers: Resolvers): ResultTask<A, E | ResolverError<Resolvers>, WithoutServices<R> | ResolverRequirements<Resolvers>>;
+  static provideServiceResolver<const Resolvers extends Readonly<Record<string, () => ResultTask<unknown, unknown, unknown>>>>(resolvers: Resolvers): <A, E, R>(task: [IncompatibleResolvedServices<R, Resolvers>] extends [never] ? ResultTask<A, E, R> : never) => ResultTask<A, E | ResolverError<Resolvers>, EliminateResolvedServices<R, Resolvers> | ResolverRequirements<Resolvers>>;
+  /** Shares one in-flight execution and successful value. Failed executions can be retried. */
+  static memoize<A, E, R>(task: ResultTask<A, E, R>): ResultTask<A, E, R>;
+  /** Creates an explicit resource owner for adapters that manage long-lived scopes. */
+  static makeScope(): ResultTaskScopeOwner;
+  /** Provides all requirements using an object keyed by service identifier. */
+  static provideServices<A, E, R>(task: ResultTask<A, E, R>, services: ResultTaskServices<R>): ResultTask<A, E, Extract<R, ResultTaskScope<unknown>>>;
+  static provideServices<const Services extends Readonly<Record<string, unknown>>>(services: Services): <A, E, R>(task: [IncompatibleProvidedServices<R, Services>] extends [never] ? ResultTask<A, E, R> : never) => ResultTask<A, E, EliminateProvidedServices<R, Services>>;
+  /** Maps the success value using the canonical functional form or curried for `pipe`. */
+  static map<A, E, R, B>(task: ResultTask<A, E, R>, f: (value: A) => B): ResultTask<B, E, R>;
+  static map<A, B>(f: (value: A) => B): <E, R>(task: ResultTask<A, E, R>) => ResultTask<B, E, R>;
+  /** Maps the error value using the canonical functional form or curried for `pipe`. */
+  static mapError<A, E, R, E2>(task: ResultTask<A, E, R>, f: (error: E) => E2): ResultTask<A, E2, R>;
+  static mapError<E, E2>(f: (error: E) => E2): <A, R>(task: ResultTask<A, E, R>) => ResultTask<A, E2, R>;
+  /** Chains a task using the canonical functional form or curried for `pipe`. */
+  static flatMap<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  static flatMap<A, B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): <E, R>(task: ResultTask<A, E, R>) => ResultTask<B, E | E2, R | R2>;
+  /** Alias for `flatMap`, matching the existing Resultar vocabulary. */
+  static andThen<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
+  static andThen<A, B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): <E, R>(task: ResultTask<A, E, R>) => ResultTask<B, E | E2, R | R2>;
+  /** 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>;
+  /** 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>;
+  /** Executes a side effect on the error value using the canonical functional form or curried for `pipe`. */
+  static tapError<A, E, R, E2 = never, R2 = never>(task: ResultTask<A, E, R>, f: (error: E) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): ResultTask<A, E | E2, R | R2>;
+  static tapError<E, E2 = never, R2 = never>(f: (error: E) => ResultTask<unknown, E2, R2> | Promise<unknown> | void): <A, R>(task: ResultTask<A, E, R>) => ResultTask<A, E | E2, R | R2>;
+  /** Replaces the success value with a constant using the canonical functional form or curried for `pipe`. */
+  static as<A, E, R, B>(task: ResultTask<A, E, R>, value: B): ResultTask<B, E, R>;
+  static as<B>(value: B): <A, E, R>(task: ResultTask<A, E, R>) => ResultTask<B, E, R>;
+  /** Matches both success and error cases using the canonical functional form or curried for `pipe`. */
+  static match<A, E, R, B, C = B>(task: ResultTask<A, E, R>, handlers: ResultTaskMatchOptions<A, E, B, C>): ResultTask<B | C, never, R>;
+  static match<A, E, B, C = B>(handlers: ResultTaskMatchOptions<A, E, B, C>): <R>(task: ResultTask<A, E, R>) => ResultTask<B | C, never, R>;
+  /**
+   * Eagerly executes a ResultTask using the standard runtime and returns a ResultAsync.
+   */
+  static toResultAsync<A, E>(task: ResultTask<A, E, never>): ResultAsync<A, E>;
+  /**
+   * Captures an existing ResultAsync or creates a lazy task from a ResultAsync factory.
+   */
+  static fromResultAsync<A, E>(asyncResultOrFactory: ResultAsync<A, E> | ((signal: AbortSignal) => ResultAsync<A, E>)): ResultTask<A, E>;
+  private static runExitInternal;
+  private static runResultInternal;
+  /** Runs a task and preserves success, typed failure, and runtime defects in an `Exit`. */
+  static runExit<A, E>(task: ResultTask<A, E, never>): Promise<Exit<A, E>>;
+  static runExit<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Exit<A, E | ScopeError<R>>>;
+  /** Returns single typed failures as Err; rejects defects, interruption, and composite causes. */
+  static runResult<A, E>(task: ResultTask<A, E, never>): Promise<Result<A, E>>;
+  static runResult<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Result<A, E | ScopeError<R>>>;
+  /** Runs a task and returns the success value, rejecting on typed failures or defects. */
+  static runPromise<A, E>(task: ResultTask<A, E, never>): Promise<A>;
+  static runPromise<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<A>;
+}
+//#endregion
 //#region src/result-async.d.ts
 type ResultAsyncFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void | Promise<void>;
 /**
@@ -1126,6 +1418,10 @@ declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T
    * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
    */
   static fromSafePromise<T, E = never>(this: void, promise: PromiseLike<T>): ResultAsync<T, E>;
+  /**
+   * Eagerly executes a ResultTask using the standard runtime and wraps it in a ResultAsync.
+   */
+  static fromTask<T, E>(this: void, task: ResultTask<T, E, never>): ResultAsync<T, E>;
   /**
    * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
    * based on the provided promise.
@@ -1531,128 +1827,6 @@ declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
  */
 declare const revealRedacted: <T>(value: Redacted<T>) => T;
 //#endregion
-//#region src/result-task.d.ts
-/** A failure cause produced by a `ResultTask` execution. */
-type Cause<E> = {
-  readonly _tag: "Fail";
-  readonly error: E;
-} | {
-  readonly _tag: "Die";
-  readonly defect: unknown;
-};
-/** The complete outcome of a `ResultTask` execution. */
-type Exit<A, E> = {
-  readonly _tag: "Success";
-  readonly value: A;
-} | {
-  readonly _tag: "Failure";
-  readonly cause: Cause<E>;
-};
-/** A service that can be requested from a `ResultTask.gen` workflow. */
-interface ServiceTag<Identifier extends string, Service> {
-  readonly _tag: "ServiceTag";
-  readonly identifier: Identifier;
-  readonly key: symbol;
-  readonly [Symbol.iterator]: () => Generator<ResultTaskServiceYield<ServiceTag<Identifier, Service>>, Service, Service>;
-}
-/** Options for running a `ResultTask` with an optional signal and its required services. */
-type ResultTaskRunOptions<R = never> = {
-  readonly signal?: AbortSignal;
-} & ([R] extends [never] ? {
-  readonly services?: never;
-} : {
-  readonly services: ResultTaskServices<R>;
-});
-/** The object-shaped service environment required by a task. */
-type ResultTaskServices<R> = { readonly [Tag in Extract<R, AnyServiceTag> as Tag["identifier"]]: ServiceForTag<Tag>; };
-/** Options for creating a synchronous task with an explicit error boundary. */
-interface ResultTaskTryOptions<A, E> {
-  readonly try: () => A;
-  readonly catch: (cause: unknown) => E;
-}
-/** Options for creating a lazy promise-producing task with an explicit error boundary. */
-interface ResultTaskTryPromiseOptions<A, E> {
-  readonly try: (signal: AbortSignal) => PromiseLike<A>;
-  readonly catch: (cause: unknown) => E;
-}
-type AnyServiceTag = Pick<ServiceTag<string, unknown>, "_tag" | "identifier" | "key">;
-type ServiceForTag<Tag> = Tag extends ServiceTag<string, infer Service> ? Service : never;
-interface ResultTaskYield<A, E, R> {
-  readonly _tag: "ResultTask";
-  readonly task: ResultTask<A, E, R>;
-}
-interface ResultTaskServiceYield<Tag extends AnyServiceTag> {
-  readonly _tag: "Service";
-  readonly tag: Tag;
-}
-type GeneratorError<Yield> = Yield extends {
-  readonly _tag: "ResultTask";
-  readonly task: infer Task;
-} ? Task extends ResultTask<infer _A, infer E, infer _R> ? E : never : never;
-type GeneratorRequirements<Yield> = Yield extends {
-  readonly _tag: "ResultTask";
-  readonly task: infer Task;
-} ? Task extends ResultTask<infer _A, infer _E, infer R> ? R : never : Yield extends {
-  readonly _tag: "Service";
-  readonly tag: infer Tag;
-} ? Tag : never;
-type ResultTaskRunArguments<R> = [R] extends [never] ? [options?: ResultTaskRunOptions<R>] : [options: ResultTaskRunOptions<R>];
-/**
- * A lazy, composable workflow that can succeed with `A` or fail with `E`.
- *
- * Constructing a `ResultTask` never runs its work. Use `runResult`, `runExit`, or `runPromise` at an
- * explicit application boundary to execute it.
- */
-declare class ResultTask<A, E = never, R = never> extends Pipeable {
-  private readonly execute;
-  private constructor();
-  private readonly typeWitness;
-  /** Creates a task that succeeds with `value` when it is executed. */
-  static succeed<A, E = never>(value: A): ResultTask<A, E>;
-  /** Creates a task that fails with `error` when it is executed. */
-  static fail<const E>(error: E): ResultTask<never, E>;
-  /** Lifts an already computed Result into a lazy task. */
-  static fromResult<A, E>(result: Result<A, E>): ResultTask<A, E>;
-  /** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
-  static sync<A>(evaluate: () => A): ResultTask<A>;
-  /** Creates a task that maps synchronous throws into the typed error channel. */
-  static try<A, E>(options: ResultTaskTryOptions<A, E>): ResultTask<A, E>;
-  /** Creates a lazy task that maps synchronous throws and promise rejections into `E`. */
-  static tryPromise<A, E>(options: ResultTaskTryPromiseOptions<A, E>): ResultTask<A, E>;
-  /** 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>;
-  /** 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. */
-  map<B>(f: (value: A) => B): ResultTask<B, E, R>;
-  /** Chains another task from the success value without executing either task immediately. */
-  flatMap<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
-  /** Alias for `flatMap`, matching the existing Resultar vocabulary. */
-  andThen<B, E2, R2>(f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
-  /** Recovers from a typed failure without recovering from a runtime defect. */
-  catchAll<B, E2, R2>(f: (error: E) => ResultTask<B, E2, R2>): ResultTask<A | B, E2, R | R2>;
-  /** Enables `yield* task` inside `ResultTask.gen` workflows. */
-  [Symbol.iterator](): Generator<ResultTaskYield<A, E, R>, A, Exit<A, E>>;
-  /** Provides one required service and removes it from the task's requirements. */
-  static provideService<A, E, R, Tag extends Extract<R, AnyServiceTag>>(task: ResultTask<A, E, R>, tag: Tag, service: ServiceForTag<Tag>): ResultTask<A, E, Exclude<R, Tag>>;
-  /** Provides all requirements using an object keyed by service identifier. */
-  static provideServices<A, E, R>(task: ResultTask<A, E, R>, services: ResultTaskServices<R>): ResultTask<A, E>;
-  /** Maps the success value using the canonical functional form. */
-  static map<A, E, R, B>(task: ResultTask<A, E, R>, f: (value: A) => B): ResultTask<B, E, R>;
-  /** Chains a task using the canonical functional form. */
-  static flatMap<A, E, R, B, E2, R2>(task: ResultTask<A, E, R>, f: (value: A) => ResultTask<B, E2, R2>): ResultTask<B, E | E2, R | R2>;
-  /** Recovers from a typed failure using the canonical functional form. */
-  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>;
-  private static runExitInternal;
-  private static runResultInternal;
-  /** Runs a task and preserves success, typed failure, and runtime defects in an `Exit`. */
-  static runExit<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Exit<A, E>>;
-  /** Runs a task and returns a Result, rejecting only when a runtime defect occurs. */
-  static runResult<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<Result<A, E>>;
-  /** Runs a task and returns the success value, rejecting on typed failures or defects. */
-  static runPromise<A, E, R>(task: ResultTask<A, E, R>, ...args: ResultTaskRunArguments<R>): Promise<A>;
-}
-//#endregion
 //#region src/tagged-error.d.ts
 type Alpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_";
 type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
@@ -1817,4 +1991,4 @@ declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType
  */
 declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { AbortError, type Cause, DisposableResult, DisposableResultAsync, type ErrResult, type Exit, type OkResult, type Redacted, Result, ResultAsync, 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, ResultTask, type ResultTaskRunOptions, 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, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { AbortError, type Cause, DisposableResult, DisposableResultAsync, type ErrResult, type Exit, MissingServiceError, type OkResult, type Redacted, Result, ResultAsync, 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, ResultTask, type ResultTaskAcquireReleaseOptions, ResultTaskCauseError, type ResultTaskMatchOptions, type ResultTaskRunOptions, type ResultTaskScope, type ResultTaskScopeOwner, type ResultTaskServiceResolver, type ResultTaskServices, type ResultTaskTryOptions, type ResultTaskTryPromiseOptions, ResultTaskTypeId, ResultTaskYieldTypeId, type SafeTryAsyncOptions, type SafeTryOptions, type ServiceTag, ServiceTagTypeId, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, 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 };