wstp-node 0.6.2 → 0.6.6

package/index.d.ts

@@ -429,3 +429,12 @@ export class WstpReader {
  *            or `null` / `undefined` to clear a previously-set handler.
  */
 export function setDiagHandler(fn: ((msg: string) => void) | null | undefined): void;
+
+/**
+ * Addon version string — mirrors the `version` field in `package.json`.
+ *
+ * @example
+ * const { version } = require('./build/Release/wstp.node');
+ * console.log(version);  // "0.6.2"
+ */
+export declare const version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wstp-node",
-  "version": "0.6.2",
+  "version": "0.6.6",
   "description": "Native Node.js addon for Wolfram/Mathematica WSTP — kernel sessions with evaluation queue, streaming Print/messages, Dialog subsessions, and side-channel WstpReader",
   "main": "build/Release/wstp.node",
   "types": "index.d.ts",

package/src/addon.cc

@@ -306,20 +306,25 @@ static void drainDialogAbortResponse(WSLINK lp) {
 // about this dialog so there's nobody to call exitDialog().
 // ---------------------------------------------------------------------------
 static void drainStalePackets(WSLINK lp, EvalOptions* opts) {
-    // When dynAutoMode is active, use a short timeout (50ms) so we do NOT
-    // accidentally consume a ScheduledTask Dialog[] that the main eval's
-    // dynAutoMode handler should handle.  The stale packets we are looking
-    // for (from PREVIOUS evals) are already sitting on the link and arrive
-    // instantly, so 50ms is plenty.  The longer 200ms timeout is only needed
-    // for non-dynAutoMode scenarios.
-    int timeoutMs = (opts && opts->dynAutoMode) ? 50 : 200;
-    auto deadline = std::chrono::steady_clock::now() +
-                    std::chrono::milliseconds(timeoutMs);
-    while (std::chrono::steady_clock::now() < deadline) {
+    // Stale packets (from PREVIOUS evals) are already sitting on the link
+    // and arrive instantly.  Use a short idle timeout: if nothing arrives
+    // for idleMs, exit early.  The hard timeout caps the total drain time
+    // in case packets keep arriving (e.g. nested Dialog[] rejections).
+    int hardTimeoutMs = (opts && opts->dynAutoMode) ? 50 : 200;
+    int idleMs = 5;  // exit after 5ms of silence
+    auto hardDeadline = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(hardTimeoutMs);
+    auto idleDeadline = std::chrono::steady_clock::now() +
+                        std::chrono::milliseconds(idleMs);
+    while (std::chrono::steady_clock::now() < hardDeadline &&
+           std::chrono::steady_clock::now() < idleDeadline) {
         if (!WSReady(lp)) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
             continue;
         }
+        // Packet arrived — reset idle deadline.
+        idleDeadline = std::chrono::steady_clock::now() +
+                       std::chrono::milliseconds(idleMs);
         int pkt = WSNextPacket(lp);
         if (pkt == BEGINDLGPKT) {
             // Stale dialog — consume level int then auto-close.
@@ -882,13 +887,18 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
             // Drain any stale packets (e.g. late BEGINDLGPKT from a concurrent
             // interrupt that arrived just as this cell's RETURNPKT was sent).
             // This prevents Pattern D: stale BEGINDLGPKT corrupting next eval.
-            if (!r.aborted) drainStalePackets(lp, opts);
-            // In interactive mode the kernel always follows RETURNEXPRPKT with a
-            // trailing INPUTNAMEPKT (the next "In[n+1]:=" prompt).  We must consume
-            // that packet before returning so the wire is clean for the next eval.
-            // Continue the loop; the INPUTNAMEPKT branch below will break cleanly.
-            if (!opts || !opts->interactive) break;
-            // (fall through to the next WSNextPacket iteration)
+            //
+            // IMPORTANT: In interactive mode (EnterExpressionPacket), the kernel
+            // follows RETURNEXPRPKT with a trailing INPUTNAMEPKT ("In[n+1]:=").
+            // drainStalePackets must NOT run here because it would consume that
+            // INPUTNAMEPKT and discard it, causing the outer loop to block forever
+            // waiting for a packet that was already eaten.  Drain is deferred to
+            // the INPUTNAMEPKT handler below.
+            if (!opts || !opts->interactive) {
+                if (!r.aborted) drainStalePackets(lp, opts);
+                break;
+            }
+            // Interactive mode: fall through to consume trailing INPUTNAMEPKT.
         }
         else if (pkt == INPUTNAMEPKT) {
             const char* s = nullptr; WSGetString(lp, &s);
@@ -906,7 +916,9 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                     break;
                 }
                 // Trailing INPUTNAMEPKT after RETURNEXPRPKT — consume and exit.
-                // (Next eval starts with no leftover INPUTNAMEPKT on the wire.)
+                // Now safe to drain stale packets (Pattern D prevention) —
+                // the trailing INPUTNAMEPKT has already been consumed above.
+                if (!r.aborted) drainStalePackets(lp, opts);
                 break;
             }
             r.cellIndex = parseCellIndex(nameStr);
@@ -985,6 +997,12 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                 WSFlush(lp);
                 DiagLog("[Eval] rejectDialog: sent Return[$Failed], draining until ENDDLGPKT");
                 // Drain until ENDDLGPKT — kernel will close the dialog level.
+                // IMPORTANT: the outer eval's RETURNPKT may land inside the
+                // dialog context (race with ScheduledTask Dialog[]).  We MUST
+                // capture it here; otherwise the outer DrainToEvalResult loop
+                // waits forever for a RETURNPKT that was already consumed.
+                WExpr rejectCaptured;
+                bool  rejectGotOuter = false;
                 {
                     auto dlgDeadline = std::chrono::steady_clock::now() +
                                        std::chrono::milliseconds(2000);
@@ -995,11 +1013,25 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                         }
                         int rp = WSNextPacket(lp);
                         DiagLog("[Eval] rejectDialog: drain pkt=" + std::to_string(rp));
+                        if ((rp == RETURNPKT || rp == RETURNEXPRPKT) && !rejectGotOuter) {
+                            rejectCaptured  = ReadExprRaw(lp);
+                            rejectGotOuter  = true;
+                            DiagLog("[Eval] rejectDialog: captured outer RETURNPKT");
+                        }
                         WSNewPacket(lp);
                         if (rp == ENDDLGPKT) break;
                         if (rp == 0 || rp == ILLEGALPKT) { WSClearError(lp); break; }
                     }
                 }
+                if (rejectGotOuter) {
+                    DiagLog("[Eval] rejectDialog: returning captured outer result");
+                    r.result = std::move(rejectCaptured);
+                    if (r.result.kind == WExpr::Symbol &&
+                        stripCtx(r.result.strVal) == "$Aborted")
+                        r.aborted = true;
+                    drainStalePackets(lp, opts);
+                    return r;
+                }
                 // Continue outer drain loop — the original RETURNPKT is still coming.
                 continue;
             }
@@ -1194,6 +1226,8 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                 WSEndPacket(lp);
                 WSFlush(lp);
                 DiagLog("[Eval] BEGINDLGPKT safety: sent Return[$Failed], draining until ENDDLGPKT");
+                WExpr safetyCaptured;
+                bool  safetyGotOuter = false;
                 {
                     auto dlgDeadline = std::chrono::steady_clock::now() +
                                        std::chrono::milliseconds(2000);
@@ -1204,11 +1238,25 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                         }
                         int rp = WSNextPacket(lp);
                         DiagLog("[Eval] BEGINDLGPKT safety: drain pkt=" + std::to_string(rp));
+                        if ((rp == RETURNPKT || rp == RETURNEXPRPKT) && !safetyGotOuter) {
+                            safetyCaptured = ReadExprRaw(lp);
+                            safetyGotOuter = true;
+                            DiagLog("[Eval] BEGINDLGPKT safety: captured outer RETURNPKT");
+                        }
                         WSNewPacket(lp);
                         if (rp == ENDDLGPKT) break;
                         if (rp == 0 || rp == ILLEGALPKT) { WSClearError(lp); break; }
                     }
                 }
+                if (safetyGotOuter) {
+                    DiagLog("[Eval] BEGINDLGPKT safety: returning captured outer result");
+                    r.result = std::move(safetyCaptured);
+                    if (r.result.kind == WExpr::Symbol &&
+                        stripCtx(r.result.strVal) == "$Aborted")
+                        r.aborted = true;
+                    drainStalePackets(lp, opts);
+                    return r;
+                }
                 // Continue outer drain loop — original RETURNPKT is still coming.
                 continue;
             }
@@ -1351,9 +1399,23 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
             // Legacy dialog path: when dynAutoMode is false and the eval has
             // dialog callbacks, respond 'i' (inspect) so the kernel enters
             // inspect mode and the Internal`AddHandler fires Dialog[].
-            // Otherwise respond 'c' (continue) to dismiss the menu.
+            // For type-1 (interrupt menu) without dialog callbacks, respond
+            // 'a' (abort) rather than 'c' (continue).  On ARM64/Wolfram 3,
+            // 'c' can leave the kernel in a stuck state when the interrupt
+            // handler (Internal`AddHandler["Interrupt", Function[.., Dialog[]]])
+            // is installed — Dialog[] interferes with the continuation and
+            // the kernel never sends RETURNPKT.  Aborting cleanly produces
+            // $Aborted and keeps the session alive.
+            // For non-interrupt menus (type != 1), 'c' is still safe.
             bool wantInspect = opts && !opts->dynAutoMode && opts->hasOnDialogBegin;
-            const char* resp = wantInspect ? "i" : "c";
+            const char* resp;
+            if (wantInspect) {
+                resp = "i";
+            } else if (menuType_ == 1) {
+                resp = "a";
+            } else {
+                resp = "c";
+            }
             DiagLog("[Eval] MENUPKT type=" + std::to_string(menuType_) + " — responding '" + resp + "'");
             WSPutString(lp, resp);
             WSEndPacket(lp);
@@ -1467,6 +1529,21 @@ public:
 
     // ---- thread-pool thread: send packet; block until response ----
     void Execute() override {
+        // ---- Pre-eval drain: consume stale packets on the link --------
+        // If an interrupt was sent just as the previous eval completed,
+        // the kernel may have opened a Dialog[] (via the interrupt handler)
+        // while idle.  The resulting BEGINDLGPKT sits unread on the link.
+        // Without draining it first, our EvaluatePacket is processed inside
+        // the stale Dialog context and its RETURNPKT is consumed during the
+        // BEGINDLGPKT handler's drain — leaving the outer DrainToEvalResult
+        // loop waiting forever for a RETURNPKT that was already eaten.
+        // Only check if data is already buffered (WSReady) to avoid adding
+        // latency in the normal case (no stale packets).
+        if (WSReady(lp_)) {
+            DiagLog("[Eval] pre-eval: stale data on link — draining");
+            drainStalePackets(lp_, nullptr);
+        }
+
         // ---- Phase 2: ScheduledTask[Dialog[], interval] management ----
         // Install a kernel-side ScheduledTask that calls Dialog[] periodically.
         // Only install when:
@@ -1522,12 +1599,33 @@ public:
             }
         }
 
+        // ---- ScheduledTask Dialog[] suppression ----
+        // When a ScheduledTask is installed (dynTaskInstalledInterval > 0),
+        // its Dialog[] calls can fire between evals and during rejectDialog
+        // setup/render evals, causing hangs and adding ~500ms per rejection.
+        // Suppress the task during rejectDialog evals by prepending
+        // $wstpDynTaskStop=True to the expression.  Resume it for the main
+        // eval by prepending $wstpDynTaskStop=. so the dynAutoMode handler
+        // can process Dynamic expressions during the cell's execution.
+        int installedTask = opts_.dynTaskInstalledInterval
+                          ? *opts_.dynTaskInstalledInterval : 0;
+        std::string sendExpr = expr_;
+        if (installedTask > 0) {
+            if (opts_.rejectDialog) {
+                sendExpr = "$wstpDynTaskStop=True;" + expr_;
+                DiagLog("[Eval] prepend $wstpDynTaskStop=True (rejectDialog)");
+            } else {
+                sendExpr = "$wstpDynTaskStop=.;" + expr_;
+                DiagLog("[Eval] prepend $wstpDynTaskStop=. (main eval)");
+            }
+        }
+
         bool sent;
         if (!interactive_) {
             // EvaluatePacket + ToExpression: non-interactive, does NOT populate In[n]/Out[n].
             sent = WSPutFunction(lp_, "EvaluatePacket", 1) &&
                    WSPutFunction(lp_, "ToExpression",   1) &&
-                   WSPutUTF8String(lp_, (const unsigned char *)expr_.c_str(), (int)expr_.size()) &&
+                   WSPutUTF8String(lp_, (const unsigned char *)sendExpr.c_str(), (int)sendExpr.size()) &&
                    WSEndPacket  (lp_)                      &&
                    WSFlush      (lp_);
         } else {
@@ -1536,7 +1634,7 @@ public:
             // as the real Mathematica frontend does.  Responds with RETURNEXPRPKT.
             sent = WSPutFunction(lp_, "EnterExpressionPacket", 1) &&
                    WSPutFunction(lp_, "ToExpression",          1) &&
-                   WSPutUTF8String(lp_, (const unsigned char *)expr_.c_str(), (int)expr_.size()) &&
+                   WSPutUTF8String(lp_, (const unsigned char *)sendExpr.c_str(), (int)sendExpr.size()) &&
                    WSEndPacket  (lp_)                             &&
                    WSFlush      (lp_);
         }
@@ -2645,11 +2743,28 @@ private:
             FlushDialogQueueWithError("session closed");
             dialogOpen_.store(false);
             WSPutMessage(lp_, WSAbortMessage);
-            const auto deadline =
-                std::chrono::steady_clock::now() + std::chrono::seconds(10);
+            // Phase 1: wait up to 2s for WSAbortMessage to unblock the worker.
+            auto deadline =
+                std::chrono::steady_clock::now() + std::chrono::seconds(2);
             while (workerReadingLink_.load(std::memory_order_acquire) &&
                    std::chrono::steady_clock::now() < deadline)
                 std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            // Phase 2: if the worker is still stuck (e.g. Pause[] ignoring
+            // WSAbortMessage), SIGKILL the kernel to break the link.  This
+            // makes WSNextPacket return an error so the worker exits promptly.
+            if (workerReadingLink_.load(std::memory_order_acquire) &&
+                kernelPid_ > 0 && !kernelKilled_) {
+                kernelKilled_ = true;
+                kill(kernelPid_, SIGKILL);
+                DiagLog("[CleanUp] SIGKILL pid " + std::to_string(kernelPid_) +
+                        " — worker still reading after 2s");
+                // Brief wait for the worker to notice the dead link.
+                deadline = std::chrono::steady_clock::now() +
+                           std::chrono::seconds(2);
+                while (workerReadingLink_.load(std::memory_order_acquire) &&
+                       std::chrono::steady_clock::now() < deadline)
+                    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            }
         }
         if (lp_)    { WSClose(lp_);           lp_    = nullptr; }
         if (wsEnv_) { WSDeinitialize(wsEnv_); wsEnv_ = nullptr; }
@@ -3083,6 +3198,8 @@ Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
     WstpReader::Init(env, exports);
     exports.Set("setDiagHandler",
         Napi::Function::New(env, SetDiagHandler, "setDiagHandler"));
+    // version — mirrors package.json "version"; read-only string constant.
+    exports.Set("version", Napi::String::New(env, "0.6.6"));
     return exports;
 }
 

package/test.js

@@ -52,10 +52,20 @@ function withTimeout(p, ms, label) {
 }
 
 // mkSession — open a fresh WstpSession.
+// _lastMkSession tracks the most recently created per-test session so that
+// the test runner can kill it on timeout (unblocking a stuck native WSTP call).
+let _lastMkSession = null;
+let _mainSession   = null;
 function mkSession() {
-    return new WstpSession(KERNEL_PATH);
+    const s = new WstpSession(KERNEL_PATH);
+    _lastMkSession = s;
+    return s;
 }
 
+// Suppress unhandled rejections from timed-out test bodies whose async
+// functions continue running in the background after Promise.race rejects.
+process.on('unhandledRejection', () => {});
+
 // installHandler — install Interrupt→Dialog[] handler on a session.
 // Must be done via evaluate() (EnterExpressionPacket context) so the handler
 // fires on WSInterruptMessage; EvaluatePacket context does not receive it.
@@ -71,14 +81,16 @@ async function installHandler(s) {
 const TEST_TIMEOUT_MS = 30_000;
 
 // Hard suite-level watchdog: if the entire suite takes longer than this the
-// process is force-killed.  Covers cases where a test hangs AND the per-test
-// timeout itself is somehow bypassed (e.g. a blocked native thread).
-const SUITE_TIMEOUT_MS = 10 * 60 * 1000;  // 10 minutes
-const suiteWatchdog = setTimeout(() => {
-    console.error('\nFATAL: suite watchdog expired — process hung, force-exiting.');
-    process.exit(2);
-}, SUITE_TIMEOUT_MS);
-suiteWatchdog.unref();   // does not prevent normal exit
+// process is force-killed.  Uses a SEPARATE OS process that sends SIGKILL,
+// because setTimeout callbacks can't fire while the JS event loop is blocked
+// by synchronous C++ code (e.g. CleanUp() spin-waiting for a stuck worker
+// thread, or the constructor's WSActivate blocking on kernel launch).
+const SUITE_TIMEOUT_S = 180;  // 3 minutes
+const { spawn } = require('child_process');
+const _watchdogProc = spawn('sh',
+    ['-c', `sleep ${SUITE_TIMEOUT_S}; kill -9 ${process.pid} 2>/dev/null`],
+    { stdio: 'ignore', detached: true });
+_watchdogProc.unref();
 
 // ── Test filtering ─────────────────────────────────────────────────────────
 // Usage:  node test.js --only 38,39,40   or  --only 38-52
@@ -114,10 +126,12 @@ async function run(name, fn, timeoutMs = TEST_TIMEOUT_MS) {
         skipped++;
         return;
     }
-    // Race the test body against a per-test timeout.
-    const timeout = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error(`TIMED OUT after ${timeoutMs} ms`)),
-                   timeoutMs));
+    let timer;
+    _lastMkSession = null;  // reset — set by mkSession() if the test creates one
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`TIMED OUT after ${timeoutMs} ms`)),
+                   timeoutMs);
+    });
     try {
         await Promise.race([fn(), timeout]);
         console.log(`  ✓ ${name}`);
@@ -126,6 +140,27 @@ async function run(name, fn, timeoutMs = TEST_TIMEOUT_MS) {
         console.error(`  ✗ ${name}: ${e.message}`);
         failed++;
         process.exitCode = 1;
+        // On timeout: kill the kernel process to immediately unblock the
+        // native WSTP worker thread.  Without this, the stuck evaluate()
+        // blocks the session (cascade-hanging all subsequent tests on the
+        // shared session) and prevents process.exit() from completing.
+        // Match both run()-level "TIMED OUT" and inner withTimeout "TIMEOUT".
+        if (/TIMED? OUT/i.test(e.message)) {
+            const sess = _lastMkSession || _mainSession;
+            if (sess) {
+                const pid = sess.kernelPid;
+                if (pid > 0) {
+                    try { process.kill(pid, 'SIGKILL'); } catch (_) {}
+                    console.error(`    → killed kernel pid ${pid} to unblock stuck WSTP call`);
+                }
+                // Force-close the session so the test body's background async
+                // cannot further interact with the dead kernel/link.
+                try { sess.close(); } catch (_) {}
+            }
+            _lastMkSession = null;
+        }
+    } finally {
+        clearTimeout(timer);
     }
 }
 
@@ -134,6 +169,7 @@ async function run(name, fn, timeoutMs = TEST_TIMEOUT_MS) {
 async function main() {
     console.log('Opening session…');
     const session = new WstpSession(KERNEL_PATH);
+    _mainSession = session;
     assert(session.isOpen, 'session did not open');
     console.log('Session open.\n');
 
@@ -731,14 +767,14 @@ async function main() {
     // 2500ms because Pause[] ignores WSInterruptMessage during a sleep.
     // This test documents the fundamental limitation: Dynamic cannot read a
     // live variable while Pause[N] is running.
-    await run('P1: Pause[8] ignores interrupt within 2500ms', async () => {
+    await run('P1: Pause[4] ignores interrupt within 1500ms', async () => {
         const s = mkSession();
         try {
             await installHandler(s);
 
             let evalDone = false;
             const mainProm = s.evaluate(
-                'pP1 = 0; Pause[8]; pP1 = 1; "p1-done"'
+                'pP1 = 0; Pause[4]; pP1 = 1; "p1-done"'
             ).then(() => { evalDone = true; });
 
             await sleep(300);
@@ -747,12 +783,12 @@ async function main() {
             assert(sent === true, 'interrupt() should return true mid-eval');
 
             const t0 = Date.now();
-            while (!s.isDialogOpen && Date.now() - t0 < 2500) await sleep(25);
+            while (!s.isDialogOpen && Date.now() - t0 < 1500) await sleep(25);
 
             const dlgOpened = s.isDialogOpen;
-            assert(!dlgOpened, 'Pause[8] should NOT open a dialog within 2500ms');
+            assert(!dlgOpened, 'Pause[4] should NOT open a dialog within 1500ms');
 
-            // After the 2500ms window the interrupt may still be queued — the kernel
+            // After the 1500ms window the interrupt may still be queued — the kernel
             // will fire Dialog[] once Pause[] releases.  Abort to unstick the eval
             // rather than waiting for it to return on its own (which could take forever
             // if Dialog[] opens and nobody services it).
@@ -761,7 +797,7 @@ async function main() {
         } finally {
             s.close();
         }
-    }, 20_000);
+    }, 12_000);
 
     // ── P2: Pause[0.3] loop — interrupt opens Dialog and dialogEval works ──
     // Expected: interrupt during a short Pause[] loop opens a Dialog[],
@@ -773,7 +809,7 @@ async function main() {
 
             let evalDone = false;
             const mainProm = s.evaluate(
-                'Do[nP2 = k; Pause[0.3], {k, 1, 30}]; "p2-done"',
+                'Do[nP2 = k; Pause[0.1], {k, 1, 15}]; "p2-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).then(() => { evalDone = true; });
 
@@ -781,19 +817,19 @@ async function main() {
 
             s.interrupt();
             try { await pollUntil(() => s.isDialogOpen, 3000); }
-            catch (_) { throw new Error('Dialog never opened — interrupt not working with Pause[0.3]'); }
+            catch (_) { throw new Error('Dialog never opened — interrupt not working with Pause[0.1]'); }
 
             const val = await withTimeout(s.dialogEval('nP2'), 5000, 'dialogEval nP2');
             assert(val && typeof val.value === 'number' && val.value >= 1,
                 `expected nP2 >= 1, got ${JSON.stringify(val)}`);
 
             await s.exitDialog();
-            await withTimeout(mainProm, 15_000, 'P2 main eval');
+            await withTimeout(mainProm, 8_000, 'P2 main eval');
         } finally {
             try { s.abort(); } catch (_) {}
             s.close();
         }
-    }, 30_000);
+    }, 15_000);
 
     // ── P3: dialogEval timeout — kernel state after (diagnostic) ───────────
     // Simulates the extension failure: dialogEval times out without exitDialog.
@@ -806,7 +842,7 @@ async function main() {
 
             let evalDone = false;
             const mainProm = s.evaluate(
-                'Do[nP3 = k; Pause[0.3], {k, 1, 200}]; "p3-done"',
+                'Do[nP3 = k; Pause[0.1], {k, 1, 15}]; "p3-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).then(() => { evalDone = true; });
 
@@ -841,7 +877,7 @@ async function main() {
                     await s.exitDialog().catch(() => {});
                 }
 
-                if (!evalDone) { try { await withTimeout(mainProm, 20_000, 'P3 loop'); } catch (_) {} }
+                if (!evalDone) { try { await withTimeout(mainProm, 6_000, 'P3 loop'); } catch (_) {} }
 
                 // Diagnostic: document observed outcome but do not hard-fail on dlg2
                 if (!exitOk) {
@@ -853,7 +889,7 @@ async function main() {
             try { s.abort(); } catch (_) {}
             s.close();
         }
-    }, 45_000);
+    }, 20_000);
 
 // ── P4: abort() after stuck dialog — session stays alive ────────────────
     // Note: abort() sends WSAbortMessage which resets the Wolfram kernel's
@@ -867,7 +903,7 @@ async function main() {
             await installHandler(s);
 
             const mainProm = s.evaluate(
-                'Do[nP4=k; Pause[0.3], {k,1,200}]; "p4-done"',
+                'Do[nP4=k; Pause[0.1], {k,1,15}]; "p4-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).catch(() => {});
 
@@ -899,7 +935,7 @@ async function main() {
             try { s.abort(); } catch (_) {}
             s.close();
         }
-    }, 30_000);
+    }, 15_000);
 
     // ── P5: closeAllDialogs()+abort() recovery → reinstall handler → new dialog works
     // closeAllDialogs() is designed to be paired with abort().  It rejects all
@@ -912,7 +948,7 @@ async function main() {
             await installHandler(s);
 
             const mainProm = s.evaluate(
-                'Do[nP5 = k; Pause[0.3], {k, 1, 200}]; "p5-done"',
+                'Do[nP5 = k; Pause[0.1], {k, 1, 15}]; "p5-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).catch(() => {});
 
@@ -938,7 +974,7 @@ async function main() {
 
             let dlg2 = false;
             const mainProm2 = s.evaluate(
-                'Do[nP5b = k; Pause[0.3], {k, 1, 200}]; "p5b-done"',
+                'Do[nP5b = k; Pause[0.1], {k, 1, 15}]; "p5b-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).catch(() => {});
 
@@ -960,7 +996,7 @@ async function main() {
             try { s.abort(); } catch (_) {}
             s.close();
         }
-    }, 60_000);
+    }, 25_000);
 
     // ── P6: Simulate Dynamic + Pause[5] full scenario (diagnostic) ─────────
     // Reproduces: n=RandomInteger[100]; Pause[5] with interrupt every 2.5s.
@@ -973,18 +1009,18 @@ async function main() {
 
             let evalDone = false;
             const mainProm = s.evaluate(
-                'n = RandomInteger[100]; Pause[5]; "p6-done"',
+                'n = RandomInteger[100]; Pause[3]; "p6-done"',
                 { onDialogBegin: () => {}, onDialogEnd: () => {} }
             ).then(() => { evalDone = true; });
 
             await sleep(200);
 
-            const INTERRUPT_WAIT_MS = 2500;
+            const INTERRUPT_WAIT_MS = 1500;
             const DIALOG_EVAL_TIMEOUT_MS = 8000;
             let dialogReadSucceeded = false;
             let pauseIgnoredInterrupt = false;
 
-            for (let cycle = 1; cycle <= 5 && !evalDone; cycle++) {
+            for (let cycle = 1; cycle <= 2 && !evalDone; cycle++) {
                 const t0 = Date.now();
                 s.interrupt();
                 while (!s.isDialogOpen && Date.now() - t0 < INTERRUPT_WAIT_MS) await sleep(25);
@@ -1012,11 +1048,11 @@ async function main() {
                 }
             }
 
-            try { await withTimeout(mainProm, 12_000, 'P6 main eval'); } catch (_) {}
+            try { await withTimeout(mainProm, 7_000, 'P6 main eval'); } catch (_) {}
 
             // Diagnostic: always passes — log observed outcome
             if (pauseIgnoredInterrupt && !dialogReadSucceeded) {
-                console.log('    P6 note: Pause[5] blocked all interrupts — expected behaviour');
+                console.log('    P6 note: Pause[3] blocked all interrupts — expected behaviour');
             } else if (dialogReadSucceeded) {
                 console.log('    P6 note: at least one read succeeded despite Pause');
             }
@@ -1024,7 +1060,7 @@ async function main() {
             try { s.abort(); } catch (_) {}
             s.close();
         }
-    }, 60_000);
+    }, 20_000);
 
     // ── 25. abort() while dialog is open ──────────────────────────────────
     // Must run AFTER all other dialog tests — abort() sends WSAbortMessage
@@ -1407,11 +1443,11 @@ async function main() {
         const s = mkSession();
         try {
             s.registerDynamic('tick', 'ToString[$Line]');
-            s.setDynamicInterval(80);
-            for (let i = 0; i < 8; i++) {
+            s.setDynamicInterval(200);
+            for (let i = 0; i < 5; i++) {
                 const r = await withTimeout(
-                    s.evaluate(`Pause[0.15]; ${i}`),
-                    6000, `test 49 cell ${i}`
+                    s.evaluate(`Pause[0.3]; ${i}`),
+                    10000, `test 49 cell ${i}`
                 );
                 assert(!r.aborted, `cell ${i} must not be aborted`);
                 assert(String(r.result.value) === String(i),
@@ -1489,8 +1525,10 @@ async function main() {
             s.setDynamicInterval(300);
 
             // Step 2: long enough eval for ScheduledTask to fire at least once.
+            // Use interactive mode — matches the extension's actual cell-eval path
+            // and lets the kernel process Dialog[] commands during Pause[].
             const r1 = await withTimeout(
-                s.evaluate('Do[Pause[0.1], {20}]; "cell1"'),
+                s.evaluate('Do[Pause[0.1], {20}]; "cell1"', { interactive: true }),
                 12000, '53 cell1'
             );
             assert(!r1.aborted && r1.result.value === 'cell1',
@@ -1542,10 +1580,102 @@ async function main() {
         }
     }, 30000);
 
+    // ── 55. Interactive mode with non-Null result (no trailing semicolon) ──
+    // In interactive mode (EnterExpressionPacket), a non-Null result produces:
+    //   RETURNEXPRPKT → INPUTNAMEPKT.
+    // Bug: drainStalePackets() consumed the trailing INPUTNAMEPKT, causing the
+    // outer DrainToEvalResult loop to hang forever waiting for a packet already
+    // consumed.  This test verifies that interactive evals with visible results
+    // (no trailing semicolon) complete without hanging.
+    await run('55. interactive eval with non-Null result (drainStalePackets fix)', async () => {
+        const s = mkSession();
+        try {
+            // Simple assignment without semicolon — returns non-Null.
+            const r1 = await withTimeout(
+                s.evaluate('n = 1', { interactive: true }),
+                10000, '55 n=1 interactive — would hang without drainStalePackets fix'
+            );
+            assert(!r1.aborted, 'n=1 must not be aborted');
+            assert(r1.result.value === 1, `n=1 expected 1, got ${r1.result.value}`);
+
+            // Follow-up: another non-Null interactive eval.
+            const r2 = await withTimeout(
+                s.evaluate('n + 41', { interactive: true }),
+                10000, '55 n+41 interactive'
+            );
+            assert(!r2.aborted, 'n+41 must not be aborted');
+            assert(r2.result.value === 42, `n+41 expected 42, got ${r2.result.value}`);
+
+            // Follow-up with semicolon (Null result) — should also work.
+            const r3 = await withTimeout(
+                s.evaluate('m = 99;', { interactive: true }),
+                10000, '55 m=99; interactive'
+            );
+            assert(!r3.aborted, 'm=99; must not be aborted');
+
+            // Follow-up: non-interactive eval still works after interactive ones.
+            const r4 = await withTimeout(
+                s.evaluate('m + 1'),
+                10000, '55 m+1 non-interactive follow-up'
+            );
+            assert(r4.result.value === 100, `m+1 expected 100, got ${r4.result.value}`);
+        } finally {
+            s.close();
+        }
+    }, 45000);
+
+    // ── 56. Stale interrupt aborts eval cleanly (no hang) ──────────────────
+    // When live-watch sends an interrupt just as a cell completes, the kernel
+    // may fire the queued interrupt during the NEXT evaluation.  Without
+    // dialog callbacks, the C++ MENUPKT handler responds 'a' (abort) so the
+    // eval returns $Aborted rather than hanging.  This is safe: the caller
+    // can retry.  A follow-up eval (without stale interrupt) must succeed.
+    await run('56. stale interrupt aborts eval — no hang', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            // Warm up
+            const r0 = await withTimeout(s.evaluate('1 + 1'), 5000, '56 warmup');
+            assert(r0.result.value === 2);
+
+            // Send interrupt to idle kernel — may fire during next eval
+            s.interrupt();
+            await sleep(500);  // give kernel time to queue interrupt
+
+            // Evaluate — stale interrupt fires → MENUPKT → 'a' → $Aborted
+            const r1 = await withTimeout(
+                s.evaluate('42'),
+                10000, '56 eval — would hang without abort-on-MENUPKT fix'
+            );
+            // The eval may return $Aborted (interrupt fired) or 42 (interrupt
+            // was ignored by idle kernel).  Either is acceptable — the critical
+            // thing is that it does NOT hang.
+            if (r1.aborted) {
+                assert(r1.result.value === '$Aborted',
+                    `expected $Aborted, got ${JSON.stringify(r1.result)}`);
+            } else {
+                assert(r1.result.value === 42,
+                    `expected 42, got ${JSON.stringify(r1.result)}`);
+            }
+
+            // Follow-up eval must work regardless
+            const r2 = await withTimeout(s.evaluate('2 + 2'), 5000, '56 follow-up');
+            assert(!r2.aborted, '56 follow-up should not be aborted');
+            assert(r2.result.value === 4);
+        } finally {
+            s.close();
+        }
+    }, 30000);
+
     // ── Teardown ──────────────────────────────────────────────────────────
+    _mainSession = null;
     session.close();
     assert(!session.isOpen, 'main session not closed');
 
+    // Kill the watchdog process — suite completed in time.
+    try { _watchdogProc.kill('SIGKILL'); } catch (_) {}
+
     console.log();
     if (failed === 0) {
         console.log(`All ${passed} tests passed${skipped ? ` (${skipped} skipped)` : ''}.`);
@@ -1555,6 +1685,7 @@ async function main() {
         process.exit(0);
     } else {
         console.log(`${passed} passed, ${failed} failed${skipped ? `, ${skipped} skipped` : ''}.`);
+        process.exit(1);
     }
 }