fix(cloudflare): Replace fixed delay with event-based envelope waiting in test

Replace the hardcoded 50ms setTimeout delay between requests with a proper
event-based mechanism that waits for envelope delivery. This eliminates test
flakiness by ensuring each envelope is actually received before proceeding
to the next request, rather than relying on a fixed timeout that may be
insufficient under CI load.

Changes:
- Add waitForEnvelopes() method to test runner that waits for a specific
  number of envelopes to be received
- Update durableobject-spans test to use waitForEnvelopes() instead of
  setTimeout delays
- Track envelope waiters in runner and resolve them when envelopes arrive

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: cursoragent

dev-packages/cloudflare-integration-tests/runner.ts

@@ -50,6 +50,7 @@ type StartResult = {
     path: string,
     options?: { headers?: Record<string, string>; data?: BodyInit; expectError?: boolean },
   ): Promise<T | undefined>;
+  waitForEnvelopes(count: number): Promise<void>;
 };
 
 /** Creates a test runner */
@@ -112,12 +113,23 @@ export function createRunner(...paths: string[]) {
       let child: ReturnType<typeof spawn> | undefined;
       let childSubWorker: ReturnType<typeof spawn> | undefined;
 
+      // Track promises waiting for specific envelope counts
+      const envelopeWaiters: Array<{ count: number; resolve: () => void }> = [];
+
       /** Called after each expect callback to check if we're complete */
       function expectCallbackCalled(): void {
         envelopeCount++;
         if (envelopeCount === expectedEnvelopeCount) {
           resolve();
         }
+
+        // Resolve any waiters that are waiting for this envelope count
+        for (let i = envelopeWaiters.length - 1; i >= 0; i--) {
+          if (envelopeCount >= envelopeWaiters[i].count) {
+            envelopeWaiters[i].resolve();
+            envelopeWaiters.splice(i, 1);
+          }
+        }
       }
 
       function assertEnvelopeMatches(expected: Expected, envelope: Envelope): void {
@@ -308,6 +320,15 @@ export function createRunner(...paths: string[]) {
             return;
           }
         },
+        waitForEnvelopes: async function (count: number): Promise<void> {
+          if (envelopeCount >= count) {
+            return Promise.resolve();
+          }
+
+          return new Promise<void>(resolveWaiter => {
+            envelopeWaiters.push({ count, resolve: resolveWaiter });
+          });
+        },
       };
     },
   };

dev-packages/cloudflare-integration-tests/suites/tracing/durableobject-spans/test.ts

@@ -45,20 +45,14 @@ it('sends child spans on repeated Durable Object calls', async ({ signal }) => {
   // Expect 5 transaction envelopes — one per call.
   const runner = createRunner(__dirname).expectN(5, assertDoWorkEnvelope).start(signal);
 
-  // Small delay between requests to allow waitUntil to process in wrangler dev.
-  // This is needed because wrangler dev may not guarantee waitUntil completion
-  // the same way production Cloudflare does. Without this delay, the last
-  // envelope's HTTP request may not complete before the test moves on.
-  const delay = () => new Promise(resolve => setTimeout(resolve, 50));
-
   await runner.makeRequest('get', '/');
-  await delay();
+  await runner.waitForEnvelopes(1);
   await runner.makeRequest('get', '/');
-  await delay();
+  await runner.waitForEnvelopes(2);
   await runner.makeRequest('get', '/');
-  await delay();
+  await runner.waitForEnvelopes(3);
   await runner.makeRequest('get', '/');
-  await delay();
+  await runner.waitForEnvelopes(4);
   await runner.makeRequest('get', '/');
   await runner.completed();
 });