@cartanova/qgrid-cli 2.10.1 → 2.10.3

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -18,7 +18,6 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 
-import { resolveAnthropicEffort } from "../common/effort";
 import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "../common/provider-types";
 import {
   ARGV_SAFE_MAX_UTF8_BYTES,
@@ -28,14 +27,13 @@ import { createTtftTracker } from "../common/ttft";
 import {
   ANTHROPIC_CLAUDE_CWD,
   anthropicConfigDir,
-  ANTHROPIC_DEFAULT_EFFORT,
   ANTHROPIC_DISALLOWED_TOOLS,
   assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
   needsCli1mSuffix,
   supports1MContext,
-  usesAdaptiveThinking,
 } from "./anthropic-constants";
+import { assertAnthropicThinkingRuntime, resolveAnthropicThinking } from "./anthropic-thinking";
 import {
   buildStreamJsonInput,
   type ClaudeStreamJsonState,
@@ -106,6 +104,7 @@ export interface ClaudeSessionRequest {
   system?: string;
   jsonSchema?: string; // 있으면 structured output
   effort?: string;
+  thinking?: boolean;
   timeoutMs: number;
   coldHistory?: Array<JsonValue>;
   input: Array<UserInput>;
@@ -149,18 +148,6 @@ export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONT
   return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
 }
 
-export function thinkingEnv(model: string): {
-  CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: "1";
-  MAX_THINKING_TOKENS?: "0";
-} {
-  return usesAdaptiveThinking(model)
-    ? {}
-    : {
-        CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
-        MAX_THINKING_TOKENS: "0",
-      };
-}
-
 // SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면
 // `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를
 // 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에
@@ -206,11 +193,13 @@ export function buildClaudeArgs(opts: {
   system?: string;
   systemPromptFile?: string;
   effort?: string;
+  thinking?: boolean;
   jsonSchema?: string;
   sessionId: string;
   needsOneMillionSuffix?: boolean;
   includePartialMessages?: boolean;
 }): Array<string> {
+  const thinking = resolveAnthropicThinking(opts.model, opts.thinking, opts.effort);
   const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);
   if (useStructured) assertAnthropicSchemaArgvSize(opts.jsonSchema!);
   // --tools "" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.
@@ -244,11 +233,10 @@ export function buildClaudeArgs(opts: {
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
     ...systemArgs,
-    // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.
-    ...(usesAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
-    // Claude Code 어휘 밖의 effort(OpenAI 전용 ultra, 옛 none/minimal 등)는 조용히 버리고 qgrid 기본을 쓴다.
+    // One CLI control owns thinking; no competing adaptive/budget environment overrides.
+    ...(thinking.mode ? ["--thinking", thinking.mode] : []),
     "--effort",
-    resolveAnthropicEffort(opts.effort) ?? ANTHROPIC_DEFAULT_EFFORT,
+    thinking.effort,
     "--disable-slash-commands",
     "--session-id",
     opts.sessionId,
@@ -269,6 +257,8 @@ export function runClaudeSession(
   // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).
   assertSupportedOneMillionSuffix(req.model);
   const model = canonicalAnthropicModel(req.model);
+  const thinking = resolveAnthropicThinking(model, req.thinking, req.effort);
+  assertAnthropicThinkingRuntime(thinking.extraBody);
   const supportsOneMillion = supports1MContext(model);
   const needsOneMillionSuffix = needsCli1mSuffix(model);
   const sessionId = randomUUID();
@@ -293,6 +283,7 @@ export function runClaudeSession(
       system: useSystemPromptFile ? undefined : req.system,
       systemPromptFile,
       effort: req.effort,
+      thinking: req.thinking,
       jsonSchema: req.jsonSchema,
       sessionId,
       needsOneMillionSuffix,
@@ -324,8 +315,8 @@ export function runClaudeSession(
           TMPDIR: process.env.TMPDIR,
           CLAUDE_CODE_OAUTH_TOKEN: req.token,
           CLAUDE_CONFIG_DIR: configDir,
+          ...(thinking.extraBody ? { CLAUDE_CODE_EXTRA_BODY: thinking.extraBody } : {}),
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
-          ...thinkingEnv(model),
           ...oneMillionEnv(supportsOneMillion),
           CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
           CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",

package/bundle/src/utils/providers/common/effort.ts

@@ -14,7 +14,7 @@ const logger = getLogger(["qgrid", "effort"]);
  */
 
 // Codex 구독 백엔드 모델 카탈로그(~/.codex/models_cache.json) 의 supported_reasoning_levels 합집합.
-// 공개 OpenAI API 의 `none`/`minimal` 은 이 경로에 없다. 모델별 상한은 model-cost.ts 의 카탈로그에 있다.
+// Public effort options exclude none/minimal. thinking:false maps to wire-level none separately.
 export const OPENAI_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"] as const;
 export type OpenAIEffort = (typeof OPENAI_EFFORTS)[number];
 

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -53,7 +53,11 @@ export interface GenerateRequest {
   model?: string;
   systemPrompt?: string;
   outputSchema?: JsonValue;
+  // A completed control message can yield to the caller before speculative later text.
+  // The transport must still drain to completion for usage, cancellation and errors.
+  stopAfterOutputMessage?: (text: string, phase?: string) => boolean;
   effort?: string;
+  thinking?: boolean;
   verbosity?: string;
   reasoningSummary?: string;
   serviceTier?: string;

package/bundle/src/utils/providers/common/smooth-weighted-round-robin.ts

@@ -1,6 +1,6 @@
 export class SmoothWeightedRoundRobin {
-  private readonly weights = new Map<number, number>();
-  private readonly currentScores = new Map<number, number>();
+  readonly weights = new Map<number, number>();
+  readonly currentScores = new Map<number, number>();
 
   setToken(tokenId: number, weight: number): void {
     if (!Number.isInteger(weight) || weight < 1 || weight > 100) {
@@ -31,7 +31,7 @@ export class SmoothWeightedRoundRobin {
     let selectedScore = Number.NEGATIVE_INFINITY;
     let totalWeight = 0;
 
-    for (const tokenId of candidates) {
+    candidates.forEach((tokenId) => {
       const weight = this.weights.get(tokenId)!;
       totalWeight += weight;
       const score = (this.currentScores.get(tokenId) ?? 0) + weight;
@@ -40,7 +40,7 @@ export class SmoothWeightedRoundRobin {
         selected = tokenId;
         selectedScore = score;
       }
-    }
+    });
 
     this.currentScores.set(selected, selectedScore - totalWeight);
     return selected;

package/bundle/src/utils/providers/common/thinking.ts

@@ -0,0 +1,10 @@
+import { BadRequestException } from "sonamu";
+
+import { type LocalizedString } from "../../../i18n/sd.generated";
+
+export class ThinkingValidationError extends BadRequestException {
+  constructor(message: string) {
+    super(message as LocalizedString);
+    this.name = "ThinkingValidationError";
+  }
+}

package/bundle/src/utils/providers/openai/openai-backend-protocol.ts

@@ -61,7 +61,7 @@ export interface OpenAIResponsesOptions {
   toolChoice?: string | OpenAIResponseItem;
   parallelToolCalls?: boolean;
   reasoning?: {
-    effort?: OpenAIEffort;
+    effort?: OpenAIEffort | "none";
     summary?: "auto" | "concise" | "detailed";
   };
   verbosity?: "low" | "medium" | "high";
@@ -170,7 +170,7 @@ export interface OpenAIUsage {
 
 export type OpenAINormalizedEvent =
   | { type: "created"; responseId?: string }
-  | { type: "text-delta"; text: string }
+  | { type: "text-delta"; text: string; itemId?: string }
   | {
       type: "image";
       id?: string;
@@ -235,7 +235,11 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
     return { type: "created", ...(response?.id ? { responseId: String(response.id) } : {}) };
   }
   if (type === "response.output_text.delta" && typeof event.delta === "string") {
-    return { type: "text-delta", text: event.delta };
+    return {
+      type: "text-delta",
+      text: event.delta,
+      ...(typeof event.item_id === "string" ? { itemId: event.item_id } : {}),
+    };
   }
   if (
     (type === "response.output_item.added" || type === "response.output_item.done") &&

package/bundle/src/utils/providers/openai/openai-direct-client.test.ts

@@ -177,7 +177,7 @@ class MockSocket implements OpenAIWebSocketLike {
   }
 
   emit(event: string, ...args: unknown[]): void {
-    for (const listener of this.listeners.get(event) ?? []) listener(...(args as never[]));
+    (this.listeners.get(event) ?? []).forEach((listener) => listener(...(args as never[])));
   }
 
   send(data: string, callback?: (error?: Error) => void): void {
@@ -534,10 +534,10 @@ describe("OpenAI direct Responses WebSocket client", () => {
     mock.sockets[2]!.emit("open");
     await expect(sendFailure).rejects.toThrow("send failed");
 
-    for (const socket of mock.sockets) {
+    mock.sockets.forEach((socket) => {
       expect(socket.terminated).toBe(true);
       expect([...socket.listeners.values()].flat()).toHaveLength(0);
-    }
+    });
   });
 
   it("terminates on iterator cancellation and when the receive buffer exceeds 1600 records", async () => {

package/bundle/src/utils/providers/openai/openai-direct-client.ts

@@ -31,7 +31,6 @@ export interface OpenAITransportRequest {
   clientRequestId: string;
 }
 
-/** Transport-independent streaming interface; HTTPS is the first implementation. */
 export interface OpenAIResponsesTransport {
   stream(request: OpenAITransportRequest): OpenAIEventStream;
   close?(): void;
@@ -150,7 +149,7 @@ function socketEvents(socket: OpenAIWebSocketLike, signal?: AbortSignal) {
         kind: "error" as const,
         error: new OpenAIProtocolError("OpenAI WebSocket event stream was closed"),
       };
-      for (const waiter of waiters.splice(0)) waiter(closed);
+      waiters.splice(0).forEach((waiter) => waiter(closed));
     },
     detachAbort: () => signal?.removeEventListener("abort", onAbort),
   };
@@ -198,12 +197,12 @@ type AffinityConnection = {
 };
 
 export class OpenAIWebSocketTransport implements OpenAIResponsesTransport {
-  private static readonly MAX_AFFINITY_CONNECTIONS = 16;
-  private credentials: OpenAIDirectCredentials;
-  private readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;
-  private readonly webSocketFactory: OpenAIWebSocketFactory;
-  private readonly affinityConnections = new Map<string, AffinityConnection>();
-  private readonly busyAffinities = new Set<string>();
+  static readonly MAX_AFFINITY_CONNECTIONS = 16;
+  credentials: OpenAIDirectCredentials;
+  readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;
+  readonly webSocketFactory: OpenAIWebSocketFactory;
+  readonly affinityConnections = new Map<string, AffinityConnection>();
+  readonly busyAffinities = new Set<string>();
 
   constructor(options: OpenAIWebSocketTransportOptions) {
     this.credentials = options.credentials;
@@ -212,24 +211,17 @@ export class OpenAIWebSocketTransport implements OpenAIResponsesTransport {
       options.webSocketFactory ?? ((url, wsOptions) => new WsClient(url, wsOptions));
   }
 
-  stream(request: OpenAITransportRequest): OpenAIEventStream {
-    return this.run(request);
-  }
-
   close(): void {
-    for (const { socket, events } of this.affinityConnections.values()) {
+    this.affinityConnections.forEach(({ socket, events }) => {
       events.cleanup();
       socket.close(1000, "transport closed");
-    }
+    });
     this.affinityConnections.clear();
     this.busyAffinities.clear();
   }
 
-  /**
-   * 캐시에 연결을 등록한다. 자리가 없으면 유휴 연결만 축출하고, 전부 사용 중이면
-   * 진행 중인 응답을 끊는 대신 등록을 포기한다(false → 이 요청은 일회성 소켓으로 처리).
-   */
-  private rememberAffinityConnection(threadId: string, connection: AffinityConnection): boolean {
+  // 유휴 연결만 축출한다. 전부 사용 중이면 false를 반환해 일회성 소켓으로 처리한다.
+  rememberAffinityConnection(threadId: string, connection: AffinityConnection): boolean {
     if (
       !this.affinityConnections.has(threadId) &&
       this.affinityConnections.size >= OpenAIWebSocketTransport.MAX_AFFINITY_CONNECTIONS
@@ -257,7 +249,7 @@ export class OpenAIWebSocketTransport implements OpenAIResponsesTransport {
     return true;
   }
 
-  private async *run(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {
+  async *stream(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {
     let refreshed = false;
     while (true) {
       if (request.signal?.aborted) throw abortError(request.signal);
@@ -270,7 +262,6 @@ export class OpenAIWebSocketTransport implements OpenAIResponsesTransport {
         entry.events.cleanup();
       }
       const cached = entry?.closed ? undefined : entry;
-      // 캐시 등록에 실패하면 이 요청은 재사용 대상이 아니다.
       let retained = retainConnection;
       const socket =
         cached?.socket ??
@@ -392,9 +383,9 @@ async function responseError(response: Response): Promise<OpenAIProtocolError> {
 }
 
 export class OpenAIHttpsTransport implements OpenAIResponsesTransport {
-  private credentials: OpenAIDirectCredentials;
-  private readonly fetchImpl: typeof fetch;
-  private readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;
+  credentials: OpenAIDirectCredentials;
+  readonly fetchImpl: typeof fetch;
+  readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;
 
   constructor(options: OpenAIHttpsTransportOptions) {
     this.credentials = options.credentials;
@@ -402,11 +393,7 @@ export class OpenAIHttpsTransport implements OpenAIResponsesTransport {
     this.refreshCredentials = options.refreshCredentials;
   }
 
-  stream(request: OpenAITransportRequest): OpenAIEventStream {
-    return this.run(request);
-  }
-
-  private async *run(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {
+  async *stream(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {
     let refreshed = false;
 
     while (true) {
@@ -449,10 +436,10 @@ export interface OpenAIDirectClientOptions extends OpenAIHttpsTransportOptions {
 }
 
 export class OpenAIDirectClient {
-  private readonly transport: OpenAIResponsesTransport;
-  private imageCredentials: OpenAIDirectCredentials;
+  readonly transport: OpenAIResponsesTransport;
+  imageCredentials: OpenAIDirectCredentials;
 
-  constructor(private readonly options: OpenAIDirectClientOptions) {
+  constructor(readonly options: OpenAIDirectClientOptions) {
     this.imageCredentials = options.credentials;
     this.transport =
       options.transport ??
@@ -484,7 +471,7 @@ export class OpenAIDirectClient {
     });
   }
 
-  private async *standaloneImages(
+  async *standaloneImages(
     options: OpenAIResponsesOptions,
     signal?: AbortSignal,
   ): OpenAIEventStream {

package/bundle/src/utils/providers/openai/openai-dispatcher.test.ts

@@ -51,6 +51,80 @@ async function tickTimer(): Promise<void> {
 }
 
 describe("OpenAIDispatcher direct runtime", () => {
+  it.each(["gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"])(
+    "disables thinking and omits summaries through generate/stream for %s",
+    async (model) => {
+      const run = vi.fn((options: OpenAIResponsesOptions) => {
+        expect(buildOpenAIResponsesRequest(options).reasoning).toEqual({ effort: "none" });
+        expect(options.outputSchema).toEqual({ schema: { type: "object" } });
+        return events({ type: "completed", responseId: "r" });
+      });
+      const d = dispatcher(run);
+      await d.onTokenAdded(1, "one", credentials);
+      const req = request({ model, thinking: false, effort: "high", reasoningSummary: "detailed", outputSchema: { type: "object" } });
+      await d.generate(req);
+      const complete = vi.fn();
+      await d.generateStream(req, { onDelta: vi.fn(), onComplete: complete, onError: vi.fn() });
+      expect(complete).toHaveBeenCalledOnce();
+      expect(run).toHaveBeenCalledTimes(2);
+    },
+  );
+
+  it.each([
+    ["gpt-6-astra", "requires thinking"],
+    ["gpt-6.1-sol", "requires thinking"],
+    ["gpt-5.4", "has not been verified"],
+  ])("rejects thinking:false for %s before token selection", async (model, reason) => {
+    const run = vi.fn(() => events());
+    // No tokens: validation must win over NO_OPENAI_WORKERS and never contact transport.
+    const d = dispatcher(run);
+    const req = request({ model, thinking: false });
+    await expect(d.generate(req)).rejects.toMatchObject({ statusCode: 400, message: expect.stringContaining(reason) });
+    const onError = vi.fn();
+    const onComplete = vi.fn();
+    await expect(d.generateStream(req, { onDelta: vi.fn(), onError, onComplete })).rejects.toThrow(model);
+    expect(onError).toHaveBeenCalledOnce();
+    expect(onComplete).not.toHaveBeenCalled();
+    expect(run).not.toHaveBeenCalled();
+  });
+
+  it.each([true, undefined])("preserves effort and summary with thinking=%s on an off-unsupported model", async (thinking) => {
+    const run = vi.fn((options: OpenAIResponsesOptions) => {
+      expect(options.reasoning).toEqual({ effort: "high", summary: "detailed" });
+      return events({ type: "completed", responseId: "r" });
+    });
+    const d = dispatcher(run);
+    await d.onTokenAdded(1, "one", credentials);
+    await d.generate(request({ model: "gpt-6-astra", thinking, effort: "high", reasoningSummary: "detailed" }));
+    expect(run).toHaveBeenCalledOnce();
+  });
+
+  it("explicit true enables reasoning with absent or invalid effort without changing omission", async () => {
+    const observed: Array<OpenAIResponsesOptions["reasoning"]> = [];
+    const d = dispatcher((options) => {
+      observed.push(options.reasoning);
+      return events({ type: "completed", responseId: "r" });
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    for (const effort of [undefined, "invalid"]) {
+      await d.generate(request({ model: "gpt-6-sol", thinking: true, effort }));
+      await d.generate(request({ model: "gpt-6-sol", effort }));
+    }
+    expect(observed).toEqual([{ effort: "low" }, undefined, { effort: "low" }, undefined]);
+  });
+
+  it("applies thinking:false to the automatic image text driver", async () => {
+    const run = vi.fn((options: OpenAIResponsesOptions) => {
+      expect(options.reasoning).toEqual({ effort: "none" });
+      expect(options.imageGeneration).toBe(true);
+      return events({ type: "text-delta", text: "hello" }, { type: "completed", responseId: "r" });
+    });
+    const d = dispatcher(run);
+    await d.onTokenAdded(1, "one", credentials);
+    await d.generate(request({ model: "gpt-6-sol", thinking: false, imageGeneration: "auto" }));
+    expect(run).toHaveBeenCalledOnce();
+  });
+
   it.each(["png", "jpeg", "webp"] as const)("forwards %s format and preserves returned MIME", async (outputFormat) => {
     const args = QueryInput.parse({ prompt: "draw", imageGeneration: true, imageGenerationOptions: { outputFormat } });
     let body: ReturnType<typeof buildOpenAIResponsesRequest> | undefined;
@@ -112,7 +186,7 @@ describe("OpenAIDispatcher direct runtime", () => {
     await d.onTokenAdded(1, "one", credentials);
     await expect(d.getRateLimitsByTokenId(1)).rejects.toThrow(`HTTP ${status}`);
     expect(refreshMock).not.toHaveBeenCalled();
-    expect(d.tokenCount).toBe(1);
+    expect(d.countActiveTokens()).toBe(1);
   });
 
   it("propagates refresh failure instead of retrying rejected credentials", async () => {
@@ -275,18 +349,20 @@ describe("OpenAIDispatcher direct runtime", () => {
     });
   });
 
-  it("streams deltas and reports completion", async () => {
+  it("streams final-answer deltas incrementally while checking message boundaries", async () => {
     const d = dispatcher(() =>
       events(
-        { type: "text-delta", text: "a" },
-        { type: "text-delta", text: "b" },
+        { type: "output-item", item: { id: "m", type: "message", phase: "final_answer", content: [] } },
+        { type: "text-delta", text: "a", itemId: "m" },
+        { type: "text-delta", text: "b", itemId: "m" },
+        { type: "output-item", completed: true, item: { id: "m", type: "message", phase: "final_answer", content: [{type: "output_text", text: "ab"}] } },
         { type: "completed", responseId: "r" },
       ),
     );
     await d.onTokenAdded(1, "one", credentials);
     const deltas: string[] = [];
     const complete = vi.fn();
-    await d.generateStream(request(), {
+    await d.generateStream(request({stopAfterOutputMessage: () => false}), {
       onDelta: (v) => deltas.push(v),
       onComplete: complete,
       onError: vi.fn(),
@@ -295,6 +371,21 @@ describe("OpenAIDispatcher direct runtime", () => {
     expect(complete).toHaveBeenCalledWith(expect.objectContaining({ text: "ab" }));
   });
 
+  it("still rejects an upstream failure after accepting a completed output message", async () => {
+    const failure = new Error("upstream failed after tool request");
+    const d = dispatcher(() => events(
+      {type: "text-delta", text: "tool request"},
+      {type: "output-item", completed: true, item: {type: "message", content: [{type: "output_text", text: "tool request"}]}},
+      {type: "error", error: failure},
+    ));
+    await d.onTokenAdded(1, "one", credentials);
+    const complete = vi.fn();
+    const onError = vi.fn();
+    await expect(d.generateStream(request({stopAfterOutputMessage: () => true}), {onDelta: vi.fn(), onComplete: complete, onError})).rejects.toBe(failure);
+    expect(complete).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalledWith(failure);
+  });
+
   it("returns multiple hosted images with one driver request", async () => {
     const run = vi.fn(() => events(
       { type: "image", id: "first", base64: "first", mimeType: "image/png" },
@@ -492,7 +583,7 @@ describe("OpenAIDispatcher direct runtime", () => {
     await vi.waitFor(() => expect(releases).toHaveLength(3));
     expect(d.inFlight).toBe(3);
 
-    for (const release of releases.splice(0)) release();
+    releases.splice(0).forEach((release) => release());
     await Promise.all([first, second, third]);
     expect(d.inFlight).toBe(0);
   });