Function triggerOne

src/commands/test.ts:2426–2754

* Trigger (and optionally poll) a single testId. * * When `opts.wait` is set, a per-spec wall-clock deadline is set * immediately before the first trigger attempt. Every throttle/retry sleep * and the final `pollRunUntilTerminal` call receive only the remaining * seconds so the `--wa

(testId: string)

   * into the result's `error` field so one failure doesn't abort siblings.
   */
  async function triggerOne(testId: string): Promise<CliBatchRunResult> {
    // Mint a fresh idempotency key per run — MUST NOT reuse the create key.
    const runIdempotencyKey = `cli-batch-run-${randomUUID()}`;
    if (opts.debug) {
      stderrFn(`[batch-run] ${testId} idempotency-key: ${runIdempotencyKey}`);
    }

    // MAJOR 2: record the wall-clock deadline before the first trigger attempt
    // when --wait is set so that throttle/retry sleeps + the subsequent poll all
    // draw from the SAME budget. Triggering at t=0, waiting 60 s for throttle,
    // then starting a fresh full-timeout poll would allow the spec to consume
    // 2× the intended budget.
    const specDeadlineMs: number | undefined = opts.wait
      ? Date.now() + timeoutSeconds * 1000
      : undefined;

    /** Returns remaining milliseconds until the per-spec deadline, or Infinity when no deadline. */
    function remainingMs(): number {
      if (specDeadlineMs === undefined) return Infinity;
      return Math.max(0, specDeadlineMs - Date.now());
    }

    let triggerResponse: TriggerRunResponse;

    // Outer RATE_LIMITED retry loop.
    // The batch call site passes `retryOnRateLimit: false` to `triggerRunWithMeta`
    // so the HTTP layer throws on the first 429 — this loop is the SOLE owner of
    // rate-limit handling. Single `test run` / `test create --run` still use
    // retryOnRateLimit: true (the default) and are unaffected by this loop.
    let outerRateLimitAttempt = 0;
    while (true) {
      // Fix 2: deadline check BEFORE acquiring a throttle slot or firing a trigger.
      // Without this guard, an outer retry could acquire a slot and send a new
      // POST even after the --wait deadline has already expired.
      if (opts.wait && remainingMs() <= 0) {
        return {
          testId,
          runId: '',
          status: 'timeout',
          codeVersion: '',
          error: {
            code: 'UNSUPPORTED',
            message: `Timed out after ${timeoutSeconds}s before trigger attempt for ${testId}.`,
            exitCode: 7,
          },
        };
      }

      // Acquire a slot in the client-side rate window before firing the trigger.
      // If the window is full, sleep until the oldest slot ages out — clamped to
      // the remaining deadline so we don't overshoot the --wait budget.
      let throttleWait: number;
      while ((throttleWait = rateThrottle.acquire()) > 0) {
        const clampedWait = Math.min(throttleWait, remainingMs());
        if (clampedWait <= 0) {
          // Deadline already passed while waiting for a throttle slot.
          return {
            testId,