Method next

packages/testing/src/screen.ts:63–118

* Wait for the next screen update. * * Handles re-renders within the same prompt (e.g., validation errors, * async updates) and prompt transitions in multi-prompt flows * (automatically waits for the next prompt). * * Note: The initial prompt render is available immediately via get

()

   * — no next() call is needed before reading it.
   */
  async next(): Promise<void> {
    if (this.#activePromise) {
      const currentPromise = this.#activePromise;

      // Consume any renders that happened synchronously (e.g., loading state).
      // We want to wait for the next meaningful state change, not an intermediate render.
      this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;

      // Race: a future render (validation error, async update) vs the promise settling
      // (prompt completed, possibly synchronously before any new render arrives).
      const renderPromise = this.#waitForNextRender();
      const settlePromise = currentPromise.then(
        () => 'settled' as const,
        () => 'settled' as const,
      );

      const result = await Promise.race([
        renderPromise.then(() => 'render' as const),
        settlePromise,
      ]);

      if (result === 'settled') {
        if (this.#activePromise !== currentPromise) {
          // New prompt already started — its render was caught by the race's renderPromise.
          this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
        } else {
          // Prompt settled but no new prompt yet. Wait for the next prompt's first render.
          await this.#waitForNextRender();
        }
      } else {
        // Got a render. Check if the prompt also completed (making this a "done" render).
        // Microtasks (promise settlement) always drain before macrotasks (setImmediate),
        // so if the prompt resolved, its .then wins the race.
        const settled = await Promise.race([
          currentPromise.then(
            () => true,
            () => true,
          ),
          new Promise<false>((resolve) => setImmediate(() => resolve(false))),
        ]);

        if (settled) {
          if (this.#activePromise !== currentPromise) {
            // New prompt already started — its render was caught by the race.
            this.#rendersConsumed = this.#currentOutput?.writeCount ?? 0;
          } else {
            // Prompt completed but no new prompt yet. Wait for it.
            await this.#waitForNextRender();
          }
        }
      }
    } else {
      // No active promise — wait for a render (e.g., prompt hasn't started yet)
      await this.#waitForNextRender();
    }
  }

  async #waitForNextRender(): Promise<void> {