refactor: make worker initialization lazy in workerPool

Defer worker thread creation until first use. Previously the worker
was initialized at module load time, causing unnecessary overhead.
Now createWorker() is called lazily from run(), reducing startup
cost.

Author: ThomasK33

src/utils/main/workerPool.ts

@@ -32,48 +32,53 @@ const pendingPromises = new Map<
 // This is safe because the heavy ai-tokenizer imports happen in the worker thread, not the main thread
 const requireForResolve = createRequire(__filename);
 const workerPath = requireForResolve.resolve("./tokenizer.worker");
-const worker = new Worker(workerPath);
+let worker: Worker | null = null;
+function createWorker(): Worker {
+  const worker = new Worker(workerPath);
 
-// Handle messages from worker
-worker.on("message", (response: WorkerResponse) => {
-  const pending = pendingPromises.get(response.messageId);
-  if (!pending) {
-    console.error(`[workerPool] No pending promise for messageId ${response.messageId}`);
-    return;
-  }
+  // Handle messages from worker
+  worker.on("message", (response: WorkerResponse) => {
+    const pending = pendingPromises.get(response.messageId);
+    if (!pending) {
+      console.error(`[workerPool] No pending promise for messageId ${response.messageId}`);
+      return;
+    }
 
-  pendingPromises.delete(response.messageId);
+    pendingPromises.delete(response.messageId);
 
-  if ("error" in response) {
-    const error = new Error(response.error.message);
-    error.stack = response.error.stack;
-    pending.reject(error);
-  } else {
-    pending.resolve(response.result);
-  }
-});
-
-// Handle worker errors
-worker.on("error", (error) => {
-  console.error("[workerPool] Worker error:", error);
-  // Reject all pending promises
-  for (const pending of pendingPromises.values()) {
-    pending.reject(error);
-  }
-  pendingPromises.clear();
-});
+    if ("error" in response) {
+      const error = new Error(response.error.message);
+      error.stack = response.error.stack;
+      pending.reject(error);
+    } else {
+      pending.resolve(response.result);
+    }
+  });
 
-// Handle worker exit
-worker.on("exit", (code) => {
-  if (code !== 0) {
-    console.error(`[workerPool] Worker stopped with exit code ${code}`);
-    const error = new Error(`Worker stopped with exit code ${code}`);
+  // Handle worker errors
+  worker.on("error", (error) => {
+    console.error("[workerPool] Worker error:", error);
+    // Reject all pending promises
     for (const pending of pendingPromises.values()) {
       pending.reject(error);
     }
     pendingPromises.clear();
-  }
-});
+  });
+
+  // Handle worker exit
+  worker.on("exit", (code) => {
+    if (code !== 0) {
+      console.error(`[workerPool] Worker stopped with exit code ${code}`);
+      const error = new Error(`Worker stopped with exit code ${code}`);
+      for (const pending of pendingPromises.values()) {
+        pending.reject(error);
+      }
+      pendingPromises.clear();
+    }
+  });
+
+  return worker;
+}
 
 /**
  * Run a task on the worker thread
@@ -82,6 +87,10 @@ worker.on("exit", (code) => {
  * @returns A promise that resolves with the task result
  */
 export function run<T>(taskName: string, data: unknown): Promise<T> {
+  if (worker === null) {
+    worker = createWorker();
+  }
+
   const messageId = messageIdCounter++;
   const request: WorkerRequest = { messageId, taskName, data };
 
@@ -90,6 +99,6 @@ export function run<T>(taskName: string, data: unknown): Promise<T> {
       resolve: resolve as (value: unknown) => void,
       reject,
     });
-    worker.postMessage(request);
+    worker!.postMessage(request);
   });
 }