fix: prevent rebuild hang

Author: hardfist

src/lib/bundle/index.ts

@@ -3,22 +3,31 @@ import type { BundleWorkerRequest, BundleWorkerResponse } from "./protocol";
 
 let nextRequestId = 0;
 let bundleWorker: Worker | null = null;
+const bundleRequestTimeoutMs = 60_000;
 
 const pendingRequests = new Map<
   number,
   {
     resolve: (result: BundleResult) => void;
     reject: (error: Error) => void;
+    timeout: ReturnType<typeof setTimeout>;
   }
 >();
 
 function rejectPendingRequests(error: Error) {
-  for (const { reject } of pendingRequests.values()) {
+  for (const { reject, timeout } of pendingRequests.values()) {
+    clearTimeout(timeout);
     reject(error);
   }
   pendingRequests.clear();
 }
 
+function resetWorker(error: Error) {
+  rejectPendingRequests(error);
+  bundleWorker?.terminate();
+  bundleWorker = null;
+}
+
 function ensureWorker() {
   if (bundleWorker) {
     return bundleWorker;
@@ -34,6 +43,7 @@ function ensureWorker() {
     }
 
     pendingRequests.delete(response.id);
+    clearTimeout(pending.timeout);
     if (response.ok) {
       pending.resolve(response.result);
       return;
@@ -44,9 +54,7 @@ function ensureWorker() {
 
   bundleWorker.onerror = (event) => {
     const error = new Error(event.message || "Rspack worker crashed");
-    rejectPendingRequests(error);
-    bundleWorker?.terminate();
-    bundleWorker = null;
+    resetWorker(error);
   };
 
   return bundleWorker;
@@ -63,9 +71,18 @@ export async function bundle(files: SourceFile[], version: string): Promise<Bund
   };
 
   return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (!pendingRequests.has(id)) {
+        return;
+      }
+
+      resetWorker(new Error("Rspack worker timed out while bundling"));
+    }, bundleRequestTimeoutMs);
+
     pendingRequests.set(id, {
       resolve,
       reject,
+      timeout,
     });
     worker.postMessage(request);
   });

src/lib/bundle/worker.ts

@@ -1,23 +1,65 @@
 import { bundle } from "./core";
 import type { BundleWorkerRequest, BundleWorkerResponse } from "./protocol";
 
-self.onmessage = async (event: MessageEvent<BundleWorkerRequest>) => {
-  const { id, files, version } = event.data;
+async function handleBundleRequest({ id, files, version }: BundleWorkerRequest) {
+  let response: BundleWorkerResponse;
 
   try {
     const result = await bundle(files, version);
-    const response: BundleWorkerResponse = {
+    response = {
       id,
       ok: true,
       result,
     };
-    self.postMessage(response);
   } catch (error) {
-    const response: BundleWorkerResponse = {
+    response = {
       id,
       ok: false,
       error: error instanceof Error ? error.message : "Failed to bundle with rspack",
     };
-    self.postMessage(response);
   }
+  self.postMessage(response);
+}
+
+function rejectSupersededRequest({ id }: BundleWorkerRequest) {
+  const response: BundleWorkerResponse = {
+    id,
+    ok: false,
+    error: "Bundle request superseded by a newer request",
+  };
+  self.postMessage(response);
+}
+
+let isBundling = false;
+let queuedRequest: BundleWorkerRequest | null = null;
+
+async function drainQueue() {
+  if (isBundling) {
+    return;
+  }
+
+  isBundling = true;
+  try {
+    while (queuedRequest) {
+      const request = queuedRequest;
+      queuedRequest = null;
+      await handleBundleRequest(request);
+    }
+  } finally {
+    isBundling = false;
+    if (queuedRequest) {
+      void drainQueue();
+    }
+  }
+}
+
+self.onmessage = (event: MessageEvent<BundleWorkerRequest>) => {
+  const supersededRequest = queuedRequest;
+  const request = event.data;
+
+  queuedRequest = request;
+  if (supersededRequest) {
+    rejectSupersededRequest(supersededRequest);
+  }
+  void drainQueue();
 };