fix: handle workerFactory throw in scheduleRestart + cancel restart on shutdown

- Wrap initWorker() in try-catch inside scheduleRestart setTimeout callback
  to prevent permanently hung workerReadyPromise when factory throws
- Store restart timer ID and clearTimeout it in shutdown() to prevent
  zombie worker spawning after explicit shutdown
- Re-check shuttingDown flag inside setTimeout callback as belt-and-suspenders
- Add 2 regression tests that prove both bugs before fix

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: BrainSlugs83

embed-pool.js

@@ -29,12 +29,19 @@ export function createEmbedPool(workerFactory, opts = {}) {
     pendingEmbeds.clear();
   }
 
+  let restartTimer = null;
+
   function scheduleRestart(code) {
     if (shuttingDown) return;
     process.stderr.write(`[vector-memory] Worker exited (code ${code}) — restarting in ${RESTART_DELAY_MS}ms\n`);
     workerReadyPromise = new Promise(resolve => { workerReadyResolve = resolve; });
-    setTimeout(() => {
-      initWorker();
+    restartTimer = setTimeout(() => {
+      restartTimer = null;
+      try {
+        initWorker();
+      } catch (err) {
+        process.stderr.write(`[vector-memory] Worker restart failed: ${err.message}\n`);
+      }
       if (workerReadyResolve) {
         workerReadyResolve();
         workerReadyResolve = null;
@@ -116,6 +123,10 @@ export function createEmbedPool(workerFactory, opts = {}) {
 
   function shutdown() {
     shuttingDown = true;
+    if (restartTimer) {
+      clearTimeout(restartTimer);
+      restartTimer = null;
+    }
     rejectAllPending("Pool shutting down");
     if (worker) {
       worker.terminate();

test.js

@@ -664,6 +664,54 @@ describe("createEmbedPool", () => {
     pool.shutdown();
   });
 
+  it("BUG: workerFactory() throwing in scheduleRestart leaves pool permanently hung", async () => {
+    let callCount = 0;
+    const workers = [];
+    const factory = () => {
+      callCount++;
+      if (callCount >= 2) throw new Error("Worker constructor exploded");
+      const w = new MockWorker();
+      workers.push(w);
+      return w;
+    };
+    const pool = createEmbedPool(factory, { restartDelay: 50, workerReadyTimeout: 200 });
+    pool.initWorker();
+
+    // Worker exits cleanly — scheduleRestart fires, but second initWorker() throws
+    workers[0].emit("exit", 0);
+
+    // Wait for the restart attempt to fire and throw
+    await new Promise(r => setTimeout(r, 100));
+
+    // Now try to embed — should fail fast, NOT hang until workerReadyTimeout
+    const start = Date.now();
+    await assert.rejects(() => pool.embed("hello"), /not running|constructor exploded/i);
+    const elapsed = Date.now() - start;
+
+    // If this takes close to workerReadyTimeout (200ms), the promise was stuck
+    assert.ok(elapsed < 150, `embed() took ${elapsed}ms — pool is hung on a never-resolving promise`);
+    pool.shutdown();
+  });
+
+  it("BUG: shutdown during restart delay still spawns zombie worker", async () => {
+    const factory = mockWorkerFactory();
+    const pool = createEmbedPool(factory, { restartDelay: 200 });
+    pool.initWorker();
+
+    // Worker exits — restart is scheduled with 200ms delay
+    factory.workers[0].emit("exit", 1);
+
+    // Shutdown immediately (before the 200ms restart fires)
+    pool.shutdown();
+
+    // Wait for the restart timer to fire
+    await new Promise(r => setTimeout(r, 350));
+
+    // Should NOT have created a second worker — shutdown should cancel the restart
+    assert.equal(factory.workers.length, 1,
+      `Expected 1 worker but got ${factory.workers.length} — zombie worker spawned after shutdown`);
+  });
+
   it("shutdown resolves pending restart waiters", async () => {
     const factory = mockWorkerFactory();
     const pool = createEmbedPool(factory, { restartDelay: 10000, workerReadyTimeout: 5000 });