fix: restore post-bundle ready timing

Pause startup readiness timeout while Metro is actively building the first app bundle.

Author: V3RON

packages/bundler-metro/src/__tests__/startup.test.ts

@@ -47,6 +47,13 @@ const emitBundleRequestObserved = (
   });
 };
 
+const emitMetroEvent = (
+  metroInstance: MetroInstance,
+  event: ReportableEvent
+) => {
+  metroInstance.events.emit(event);
+};
+
 afterEach(() => {
   vi.useRealTimers();
 });
@@ -135,9 +142,93 @@ describe('waitForMetroBackedAppReady', () => {
     expect(waitForReady).toHaveBeenCalledTimes(1);
   });
 
+  it('does not count Metro bundle build time against readyTimeout', async () => {
+    vi.useFakeTimers();
+
+    const metroInstance = createMetroInstance();
+    let resolveReady!: () => void;
+    const startAttempt = vi.fn(async () => {
+      emitBundleRequestObserved(metroInstance, 'app');
+      setTimeout(() => {
+        emitMetroEvent(metroInstance, { type: 'bundle_build_started' } as never);
+      }, 0);
+    });
+    const waitForReady = vi.fn(
+      async () =>
+        await new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        })
+    );
+
+    let settled = false;
+    const promise = waitForMetroBackedAppReady({
+      metro: metroInstance,
+      platformId: 'ios',
+      bundleStartTimeout: 1_000,
+      readyTimeout: 2_000,
+      maxAppRestarts: 2,
+      signal: new AbortController().signal,
+      startAttempt,
+      waitForReady,
+      waitForCrash: async (signal) => await waitForAbort(signal),
+    }).finally(() => {
+      settled = true;
+    });
+
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(settled).toBe(false);
+
+    emitMetroEvent(metroInstance, { type: 'bundle_build_done' } as never);
+    await vi.advanceTimersByTimeAsync(1_500);
+
+    expect(settled).toBe(false);
+
+    resolveReady();
+    await promise;
+
+    expect(waitForReady).toHaveBeenCalledTimes(1);
+  });
+
   it('fails when the app requests its bundle but never reports ready', async () => {
     vi.useFakeTimers();
 
+    const metroInstance = createMetroInstance();
+    const startAttempt = vi.fn(async () => {
+      emitBundleRequestObserved(metroInstance, 'app');
+      setTimeout(() => {
+        emitMetroEvent(metroInstance, { type: 'bundle_build_started' } as never);
+        emitMetroEvent(metroInstance, { type: 'bundle_build_done' } as never);
+      }, 0);
+    });
+
+    const promise = waitForMetroBackedAppReady({
+      metro: metroInstance,
+      platformId: 'ios',
+      bundleStartTimeout: 1_000,
+      readyTimeout: 2_000,
+      maxAppRestarts: 2,
+      signal: new AbortController().signal,
+      startAttempt,
+      waitForReady: async (signal) => await waitForAbort(signal),
+      waitForCrash: async (signal) => await waitForAbort(signal),
+    });
+
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(2_000);
+
+    await expect(promise).rejects.toMatchObject({
+      name: 'StartupStallError',
+      code: 'ready_not_reported',
+      attempts: 1,
+    });
+    expect(startAttempt).toHaveBeenCalledTimes(1);
+  });
+
+  it('starts readyTimeout immediately when Metro does not emit bundle build events', async () => {
+    vi.useFakeTimers();
+
     const metroInstance = createMetroInstance();
     const startAttempt = vi.fn(async () => {
       emitBundleRequestObserved(metroInstance, 'app');

packages/bundler-metro/src/startup.ts

@@ -15,6 +15,13 @@ type BundleRequestObservation = {
   sawPrewarmRequest: boolean;
 };
 
+class ReadyTimeoutError extends Error {
+  constructor() {
+    super('Timed out waiting for the app to become ready after Metro bundling.');
+    this.name = 'ReadyTimeoutError';
+  }
+}
+
 export type WaitForMetroBackedAppReadyOptions = {
   metro: MetroInstance;
   platformId: string;
@@ -98,6 +105,106 @@ const waitForBundleRequest = async ({
   });
 };
 
+const waitForReadyAfterBundleRequest = async (options: {
+  events: MetroInstance['events'];
+  readyTimeout: number;
+  signal: AbortSignal;
+  waitForReady: (signal: AbortSignal) => Promise<void>;
+}): Promise<void> => {
+  const { events, readyTimeout, signal, waitForReady } = options;
+
+  return await new Promise<void>((resolve, reject) => {
+    let bundlingInProgress = false;
+    let settled = false;
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+    const readyController = new AbortController();
+    const readySignal = raceAbortSignals([signal, readyController.signal]);
+
+    const clearReadyTimer = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+
+    const cleanup = () => {
+      clearReadyTimer();
+      events.removeListener(onMetroEvent);
+      signal.removeEventListener('abort', onAbort);
+    };
+
+    const resolveOnce = () => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      cleanup();
+      resolve();
+    };
+
+    const rejectOnce = (error: unknown) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+
+    const startReadyTimer = () => {
+      clearReadyTimer();
+      timeoutId = setTimeout(() => {
+        readyController.abort(new DOMException('The operation was aborted', 'AbortError'));
+        rejectOnce(new ReadyTimeoutError());
+      }, readyTimeout);
+    };
+
+    const onAbort = () => {
+      rejectOnce(signal.reason ?? new DOMException('The operation was aborted', 'AbortError'));
+    };
+
+    const onMetroEvent = (event: ReportableEvent) => {
+      if (event.type === 'bundle_build_started') {
+        bundlingInProgress = true;
+        clearReadyTimer();
+        return;
+      }
+
+      if (
+        bundlingInProgress &&
+        (event.type === 'bundle_build_done' ||
+          event.type === 'bundle_build_failed')
+      ) {
+        bundlingInProgress = false;
+        startReadyTimer();
+      }
+    };
+
+    startReadyTimer();
+    events.addListener(onMetroEvent);
+    signal.addEventListener('abort', onAbort, { once: true });
+
+    void waitForReady(readySignal)
+      .then(() => {
+        resolveOnce();
+      })
+      .catch((error) => {
+        if (
+          readyController.signal.aborted &&
+          !signal.aborted &&
+          error instanceof DOMException &&
+          error.name === 'AbortError'
+        ) {
+          return;
+        }
+
+        rejectOnce(error);
+      });
+  });
+};
+
 export const waitForMetroBackedAppReady = async ({
   metro,
   platformId,
@@ -157,9 +264,12 @@ export const waitForMetroBackedAppReady = async ({
       ]);
       sawPrewarmRequest = bundleRequestResult.sawPrewarmRequest;
 
-      const readyPromise = waitForReady(
-        withAbortTimeout(attemptSignal, readyTimeout)
-      );
+      const readyPromise = waitForReadyAfterBundleRequest({
+        events: metro.events,
+        readyTimeout,
+        signal: attemptSignal,
+        waitForReady,
+      });
       await Promise.race([readyPromise, crashPromise]);
       attemptController.abort();
       onAttemptReset?.();
@@ -186,14 +296,18 @@ export const waitForMetroBackedAppReady = async ({
         continue;
       }
 
-      if (isAbortError(error)) {
+      if (error instanceof ReadyTimeoutError) {
         throw new StartupStallError(readyTimeout, attempt, {
           code: 'ready_not_reported',
           lastMetroStatus,
           sawPrewarmRequest,
         });
       }
 
+      if (isAbortError(error)) {
+        throw error;
+      }
+
       throw error;
     }
   }