Change race() methods to return PromiseLike instead of Promise

Author: adelrodriguez

src/lib/executors/base.ts

@@ -39,7 +39,7 @@ export abstract class BaseExecution<TResult = unknown> {
   protected readonly config: BuilderConfig
   protected readonly ctx: TryCtx
   protected readonly executionSignal: AbortSignal | undefined
-  readonly #wrapCtx: WrapCtx
+  #wrapCtxCache: WrapCtx | undefined
   readonly #signalController: SignalController | undefined
   readonly #timeoutController: TimeoutController | undefined
 
@@ -52,7 +52,6 @@ export abstract class BaseExecution<TResult = unknown> {
     )
     this.executionSignal = this.#signalController?.signal
     this.ctx = BaseExecution.createContext(config, this.executionSignal, options.retryLimit)
-    this.#wrapCtx = BaseExecution.createWrapContext(this.ctx)
   }
 
   execute(): TResult {
@@ -77,6 +76,10 @@ export abstract class BaseExecution<TResult = unknown> {
   protected abstract executeCore(): TResult
 
   [Symbol.dispose](): void {
+    if (!this.#timeoutController && !this.#signalController) {
+      return
+    }
+
     using disposer = new DisposableStack()
     if (this.#timeoutController) {
       disposer.use(this.#timeoutController)
@@ -248,4 +251,9 @@ export abstract class BaseExecution<TResult = unknown> {
       shouldAttemptRetry,
     }
   }
+
+  get #wrapCtx(): WrapCtx {
+    this.#wrapCtxCache ??= BaseExecution.createWrapContext(this.ctx)
+    return this.#wrapCtxCache
+  }
 }

src/lib/executors/run.ts

@@ -132,7 +132,7 @@ class RunExecution<T, E, Ctx extends BaseTryCtx> extends BaseExecution<
 
         if (checkIsPromiseLike(result)) {
           // oxlint-disable-next-line no-await-in-loop
-          const raced = await this.race(Promise.resolve(result))
+          const raced = await this.race(result)
           return raced
         }
 

src/lib/executors/shared.ts

@@ -109,7 +109,7 @@ export abstract class OrchestrationExecution<TResult> extends BaseExecution<Prom
     })
   }
 
-  protected override async executeCore(): Promise<TResult> {
+  protected override executeCore(): Promise<TResult> {
     // Orchestration executors still share outer wraps/cancellation checks even
     // though their task execution strategies differ.
     const controlBeforeExecution = this.checkDidControlFail()
@@ -118,7 +118,7 @@ export abstract class OrchestrationExecution<TResult> extends BaseExecution<Prom
       throw controlBeforeExecution
     }
 
-    return await this.executeTasks()
+    return this.executeTasks()
   }
 
   protected abstract executeTasks(): Promise<TResult>

src/lib/modifiers/signal.ts

@@ -22,18 +22,18 @@ export class SignalController {
     return new CancellationError(undefined, { cause: cause ?? this.signal.reason })
   }
 
-  async race<V>(promise: PromiseLike<V>, cause?: unknown): Promise<V | CancellationError> {
+  race<V>(promise: PromiseLike<V>, cause?: unknown): PromiseLike<V | CancellationError> {
     const cancelled = this.checkDidCancel(cause)
 
     if (cancelled) {
-      return cancelled
+      return Promise.resolve(cancelled)
     }
 
     if (!this.signal) {
       return promise
     }
 
-    return await resolveWithAbort(
+    return resolveWithAbort(
       this.signal,
       promise,
       () => new CancellationError(undefined, { cause: cause ?? this.signal?.reason })

src/lib/modifiers/timeout.ts

@@ -73,22 +73,22 @@ export class TimeoutController {
     return this.#abort(cause)
   }
 
-  async race<V>(promise: PromiseLike<V>, cause?: unknown): Promise<V | TimeoutError> {
+  race<V>(promise: PromiseLike<V>, cause?: unknown): PromiseLike<V | TimeoutError> {
     if (!this.signal) {
       return promise
     }
 
     if (this.#remaining <= 0) {
-      return this.#abort(cause)
+      return Promise.resolve(this.#abort(cause))
     }
 
     const timedOut = this.checkDidTimeout(cause)
 
     if (timedOut) {
-      return timedOut
+      return Promise.resolve(timedOut)
     }
 
-    return await resolveWithAbort(
+    return resolveWithAbort(
       this.signal,
       promise,
       () =>