wstp-node 0.6.3 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wstp-node",
-  "version": "0.6.3",
+  "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.
@@ -992,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);
@@ -1002,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;
             }
@@ -1201,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);
@@ -1211,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;
             }
@@ -1558,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 {
@@ -1572,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_);
         }
@@ -2681,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; }
@@ -3120,7 +3199,7 @@ Napi::Object InitModule(Napi::Env env, Napi::Object 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.3"));
+    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');
 
@@ -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',
@@ -1631,9 +1669,13 @@ async function main() {
     }, 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)` : ''}.`);