Function execute

cli/src/http/client.ts:146–264

(
  state: ClientState,
  request: Request,
  resolved: ResolvedOptions,
  effectiveTimeoutMs: number | undefined,
  userSignal: AbortSignal | undefined,
)

// low-level `request` entrypoint (oRPC's pre-built Request) share one retry/timeout
// /error policy.
async function execute(
  state: ClientState,
  request: Request,
  resolved: ResolvedOptions,
  effectiveTimeoutMs: number | undefined,
  userSignal: AbortSignal | undefined,
): Promise<Response> {
  const { method, retryAttempts: effectiveRetryAttempts, throwOnError } = resolved

  for (let attempt = 0; ; attempt++) {
    // Fresh timeout budget per attempt, merged with the persistent user/oRPC signal.
    // Mirrors the old recursion that re-ran buildSignal() on every retry. Keep this
    // INSIDE the loop — hoisting it would leak attempt 0's timeout into later attempts.
    const signal = mergeSignal(userSignal, effectiveTimeoutMs)

    // clone-on-retry: the first fetch consumes the Request body, so any attempt that
    // may still be retried sends a clone and keeps `request` as the pristine replay copy.
    const sendable = attempt < effectiveRetryAttempts ? request.clone() : request

    const ctx: FetchContext = {
      request: sendable,
      options: resolved,
      attempt,
      meta: new Map(),
    }

    await runHooks(state.hooks.onRequest, ctx)

    const init: RequestInit & { dispatcher?: unknown, verbose?: boolean } = { signal }
    if (state.dispatcher !== undefined)
      init.dispatcher = state.dispatcher
    if (isVerbose())
      init.verbose = true

    try {
      ctx.response = await fetch(ctx.request, init)
    }
    catch (err) {
      ctx.error = err
      // Snapshot the abort cause before onRequestError hooks rewrite ctx.error into BaseError.
      const userAborted = userSignal?.aborted === true
      await runHooks(state.hooks.onRequestError, ctx)

      // User aborts (ctrl+C) must never retry. Timeouts and other transport errors fall
      // through to shouldRetry, which enforces the method allowlist.
      if (!userAborted && attempt < effectiveRetryAttempts && shouldRetry(ctx.error, ctx)) {
        state.logger?.({ phase: 'retry', method, url: redactBearer(ctx.request.url), attempt: attempt + 1 })
        const delay = backoffDelay(attempt + 1)
        if (delay > 0)
          await new Promise(resolve => setTimeout(resolve, delay))
        continue
      }

      const finalErr = ctx.error
      if (finalErr instanceof Error && typeof Error.captureStackTrace === 'function')
        Error.captureStackTrace(finalErr, execute)
      throw finalErr
    }