test: require core deferred callbacks

src/acp/control-plane/manager.test.ts

@@ -87,10 +87,13 @@ async function flushMicrotasks(rounds = 3): Promise<void> {
 }
 
 function createDeferred(): { promise: Promise<void>; resolve: () => void } {
-  let resolve!: () => void;
+  let resolve: (() => void) | undefined;
   const promise = new Promise<void>((next) => {
     resolve = next;
   });
+  if (!resolve) {
+    throw new Error("Expected deferred resolver to be initialized");
+  }
   return { promise, resolve };
 }
 

src/gateway/server-lanes.test.ts

@@ -5,12 +5,15 @@ import { CommandLane } from "../process/lanes.js";
 import { applyGatewayLaneConcurrency } from "./server-lanes.js";
 
 function createDeferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  let reject!: (reason?: unknown) => void;
+  let resolve: ((value: T | PromiseLike<T>) => void) | undefined;
+  let reject: ((reason?: unknown) => void) | undefined;
   const promise = new Promise<T>((res, rej) => {
     resolve = res;
     reject = rej;
   });
+  if (!resolve || !reject) {
+    throw new Error("Expected deferred callbacks to be initialized");
+  }
   return { promise, resolve, reject };
 }
 

src/gateway/server-methods/models.test.ts

@@ -10,12 +10,15 @@ type Deferred<T> = {
 };
 
 function createDeferred<T>(): Deferred<T> {
-  let resolve!: (value: T) => void;
-  let reject!: (error: unknown) => void;
+  let resolve: ((value: T) => void) | undefined;
+  let reject: ((error: unknown) => void) | undefined;
   const promise = new Promise<T>((resolvePromise, rejectPromise) => {
     resolve = resolvePromise;
     reject = rejectPromise;
   });
+  if (!resolve || !reject) {
+    throw new Error("Expected deferred callbacks to be initialized");
+  }
   return { promise, resolve, reject };
 }
 

src/gateway/server.chat.gateway-server-chat-b.test.ts

@@ -51,12 +51,15 @@ const sendReq = (
 };
 
 function createDeferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  let reject!: (reason?: unknown) => void;
+  let resolve: ((value: T | PromiseLike<T>) => void) | undefined;
+  let reject: ((reason?: unknown) => void) | undefined;
   const promise = new Promise<T>((res, rej) => {
     resolve = res;
     reject = rej;
   });
+  if (!resolve || !reject) {
+    throw new Error("Expected deferred callbacks to be initialized");
+  }
   return { promise, resolve, reject };
 }
 

src/realtime-transcription/websocket-session.test.ts

@@ -60,18 +60,26 @@ async function createRealtimeServer(params?: {
   return { url: `ws://127.0.0.1:${port}` };
 }
 
+function createSignal() {
+  let resolve: (() => void) | undefined;
+  const promise = new Promise<void>((next) => {
+    resolve = next;
+  });
+  if (!resolve) {
+    throw new Error("Expected frame signal resolver to be initialized");
+  }
+  return { promise, resolve };
+}
+
 describe("createRealtimeTranscriptionWebSocketSession", () => {
   it("flushes queued binary audio after an open-ready connection", async () => {
     const frames: Buffer[] = [];
-    let resolveFrames!: () => void;
-    const framesReady = new Promise<void>((resolve) => {
-      resolveFrames = resolve;
-    });
+    const framesReady = createSignal();
     const server = await createRealtimeServer({
       onBinary: (payload) => {
         frames.push(payload);
         if (Buffer.concat(frames).toString() === "queuedafter") {
-          resolveFrames();
+          framesReady.resolve();
         }
       },
     });
@@ -88,7 +96,7 @@ describe("createRealtimeTranscriptionWebSocketSession", () => {
     session.sendAudio(Buffer.from("queued"));
     await session.connect();
     session.sendAudio(Buffer.from("after"));
-    await framesReady;
+    await framesReady.promise;
     expect(Buffer.concat(frames).toString()).toBe("queuedafter");
     expect(session.isConnected()).toBe(true);
     session.close();
@@ -96,16 +104,13 @@ describe("createRealtimeTranscriptionWebSocketSession", () => {
 
   it("lets providers mark ready after a JSON handshake", async () => {
     const frames: unknown[] = [];
-    let resolveFrames!: () => void;
-    const framesReady = new Promise<void>((resolve) => {
-      resolveFrames = resolve;
-    });
+    const framesReady = createSignal();
     const server = await createRealtimeServer({
       initialEvent: { type: "session.created" },
       onText: (payload) => {
         frames.push(payload);
         if (frames.length === 2) {
-          resolveFrames();
+          framesReady.resolve();
         }
       },
     });
@@ -126,7 +131,7 @@ describe("createRealtimeTranscriptionWebSocketSession", () => {
 
     session.sendAudio(Buffer.from("queued"));
     await session.connect();
-    await framesReady;
+    await framesReady.promise;
     expect(frames).toEqual([
       { type: "session.update" },
       { type: "input_audio.append", audio: Buffer.from("queued").toString("base64") },