wstp-node 0.6.0 → 0.6.2

package/README.md

@@ -98,7 +98,7 @@ The script automatically locates the WSTP SDK inside the default Wolfram install
 node test.js
 ```
 
-Expected last line: `All 52 tests passed.`
+Expected last line: `All 61 tests passed.`
 
 A more comprehensive suite (both modes + In/Out + comparison) lives in `tmp/tests_all.js`:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wstp-node",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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

@@ -1159,6 +1159,60 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                 continue;
             }
 
+            // ---- Safety fallback: no onDialogBegin callback registered -----
+            // Legacy dialog loop (below) requires JS to call dialogEval()/
+            // exitDialog() in response to the onDialogBegin callback.  If no
+            // callback is registered (e.g. stale ScheduledTask Dialog[] call
+            // arriving during a non-Dynamic cell), nobody will ever call those
+            // functions and the eval hangs permanently.  Auto-close the dialog
+            // using the same inline path as rejectDialog.
+            if (!opts || !opts->hasOnDialogBegin) {
+                DiagLog("[Eval] BEGINDLGPKT: no onDialogBegin callback — auto-closing "
+                        "(dynAutoMode=false, hasOnDialogBegin=false)");
+                // Pre-drain INPUTNAMEPKT — Dialog[] from ScheduledTask sends
+                // INPUTNAMEPKT before accepting EnterTextPacket.
+                {
+                    auto preDl = std::chrono::steady_clock::now() +
+                                 std::chrono::milliseconds(500);
+                    while (std::chrono::steady_clock::now() < preDl) {
+                        if (!WSReady(lp)) {
+                            std::this_thread::sleep_for(std::chrono::milliseconds(2));
+                            continue;
+                        }
+                        int ipkt = WSNextPacket(lp);
+                        DiagLog("[Eval] BEGINDLGPKT safety: pre-drain pkt=" + std::to_string(ipkt));
+                        WSNewPacket(lp);
+                        if (ipkt == INPUTNAMEPKT) break;
+                        if (ipkt == 0 || ipkt == ILLEGALPKT) { WSClearError(lp); break; }
+                    }
+                }
+                const char* closeExpr = "Return[$Failed]";
+                WSPutFunction(lp, "EnterTextPacket", 1);
+                WSPutUTF8String(lp,
+                    reinterpret_cast<const unsigned char*>(closeExpr),
+                    static_cast<int>(std::strlen(closeExpr)));
+                WSEndPacket(lp);
+                WSFlush(lp);
+                DiagLog("[Eval] BEGINDLGPKT safety: sent Return[$Failed], draining until ENDDLGPKT");
+                {
+                    auto dlgDeadline = std::chrono::steady_clock::now() +
+                                       std::chrono::milliseconds(2000);
+                    while (std::chrono::steady_clock::now() < dlgDeadline) {
+                        if (!WSReady(lp)) {
+                            std::this_thread::sleep_for(std::chrono::milliseconds(2));
+                            continue;
+                        }
+                        int rp = WSNextPacket(lp);
+                        DiagLog("[Eval] BEGINDLGPKT safety: drain pkt=" + std::to_string(rp));
+                        WSNewPacket(lp);
+                        if (rp == ENDDLGPKT) break;
+                        if (rp == 0 || rp == ILLEGALPKT) { WSClearError(lp); break; }
+                    }
+                }
+                // Continue outer drain loop — original RETURNPKT is still coming.
+                continue;
+            }
+
             if (opts && opts->dialogOpen)
                 opts->dialogOpen->store(true);
             if (opts && opts->hasOnDialogBegin)
@@ -2337,6 +2391,8 @@ public:
         int ms = static_cast<int>(info[0].As<Napi::Number>().Int32Value());
         if (ms < 0) ms = 0;
         int prev = dynIntervalMs_.exchange(ms);
+        // Auto-enable dynAutoMode when interval > 0, auto-disable when 0.
+        dynAutoMode_.store(ms > 0);
         // Start timer thread if transitioning from 0 to non-zero.
         if (prev == 0 && ms > 0 && !dynTimerRunning_.load()) {
             StartDynTimer();
@@ -2346,8 +2402,8 @@ public:
 
     // -----------------------------------------------------------------------
     // setDynAutoMode(auto) → void
-    // true  = C++-internal inline dialog path (default)
-    // false = legacy JS dialogEval/exitDialog path (for debugger)
+    // true  = C++-internal inline dialog path
+    // false = legacy JS dialogEval/exitDialog path (default; for debugger)
     // -----------------------------------------------------------------------
     Napi::Value SetDynAutoMode(const Napi::CallbackInfo& info) {
         Napi::Env env = info.Env();
@@ -2356,7 +2412,15 @@ public:
                 .ThrowAsJavaScriptException();
             return env.Undefined();
         }
-        dynAutoMode_.store(info[0].As<Napi::Boolean>().Value());
+        bool newMode = info[0].As<Napi::Boolean>().Value();
+        bool oldMode = dynAutoMode_.exchange(newMode);
+        // When transitioning true→false (Dynamic cleanup), stop the timer
+        // thread.  Prevents stale ScheduledTask Dialog[] calls from reaching
+        // the BEGINDLGPKT handler after cleanup.  The safety fallback in
+        // BEGINDLGPKT handles any Dialog[] that fires before this takes effect.
+        if (oldMode && !newMode) {
+            dynIntervalMs_.store(0);
+        }
         return env.Undefined();
     }
 
@@ -2717,7 +2781,7 @@ private:
     std::vector<DynRegistration>          dynRegistry_;        // registered exprs
     std::vector<DynResult>                dynResults_;         // accumulated results (swapped on getDynamicResults)
     std::atomic<int>                      dynIntervalMs_{0};   // 0 = disabled
-    std::atomic<bool>                     dynAutoMode_{true};  // true = inline C++ path; false = legacy JS path
+    std::atomic<bool>                     dynAutoMode_{false}; // true = inline C++ path; false = legacy JS path
     int                                   dynTaskInstalledInterval_{0}; // interval of currently installed ScheduledTask (0 = none)
     std::chrono::steady_clock::time_point dynLastEval_{};      // time of last successful dialog eval
     std::thread                           dynTimerThread_;

package/test.js

@@ -1,12 +1,13 @@
 'use strict';
 
-// ── Test suite for wstp-backend v0.6.0 ────────────────────────────────────
+// ── Test suite for wstp-backend v0.6.2 ────────────────────────────────────
 // Covers: evaluation queue, streaming callbacks, sub() priority, abort
 //         behaviour, WstpReader side-channel, edge cases, Dialog[] subsession
 //         (dialogEval, exitDialog, isDialogOpen, onDialogBegin/End/Print),
 //         subWhenIdle() (background queue, timeout, close rejection), kernelPid,
 //         Dynamic eval API (registerDynamic, getDynamicResults, setDynamicInterval,
 //         setDynAutoMode, dynamicActive, rejectDialog, abort deduplication).
+// 0.6.2: BEGINDLGPKT safety fallback (Bug 1A), setDynAutoMode cleanup (Bug 1B).
 
 const { WstpSession, WstpReader, setDiagHandler } = require('./build/Release/wstp.node');
 
@@ -508,11 +509,12 @@ async function main() {
     });
 
     // ── 17. Unhandled dialog does not corrupt the link ────────────────────
-    // Call Dialog[] from a plain evaluate().  No onDialogBegin callback is
-    // registered.  We still use dialogEval('DialogReturn[]') to close it and
-    // confirm the outer Promise resolves correctly afterwards.
+    // Call Dialog[] from a plain evaluate() using only isDialogOpen polling
+    // (no onDialogBegin handler).  onDialogBegin: () => {} is still required
+    // to opt into the legacy dialog loop — without it Fix 1A auto-closes the
+    // dialog before JS can interact with it.
     await run('17. unhandled dialog does not corrupt link', async () => {
-        const evalPromise = session.evaluate('Dialog[]; 42');
+        const evalPromise = session.evaluate('Dialog[]; 42', { onDialogBegin: () => {} });
 
         await pollUntil(() => session.isDialogOpen);
         assert(session.isDialogOpen, 'dialog should have opened');
@@ -529,7 +531,7 @@ async function main() {
     // exitDialog('21') sends EnterTextPacket["Return[21]"].  The value 21
     // becomes the value of Dialog[] in the outer expression, so x$$*2 == 42.
     await run('19. exitDialog() with a return value', async () => {
-        const p = session.evaluate('x$$ = Dialog[]; x$$ * 2');
+        const p = session.evaluate('x$$ = Dialog[]; x$$ * 2', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         await session.exitDialog('21');
         const r = await p;
@@ -542,7 +544,7 @@ async function main() {
     // ── 20. dialogEval() sees outer variable state ────────────────────────
     // Variables set before Dialog[] are in scope inside the subsession.
     await run('20. dialogEval sees outer variable state', async () => {
-        const p = session.evaluate('myVar$$ = 123; Dialog[]; myVar$$');
+        const p = session.evaluate('myVar$$ = 123; Dialog[]; myVar$$', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         const v = await session.dialogEval('myVar$$');
         assert(
@@ -556,7 +558,7 @@ async function main() {
     // ── 21. dialogEval() can mutate kernel state ──────────────────────────
     // Variables set inside the dialog persist after the dialog closes.
     await run('21. dialogEval can mutate kernel state', async () => {
-        const p = session.evaluate('Dialog[]; mutated$$');
+        const p = session.evaluate('Dialog[]; mutated$$', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         await session.dialogEval('mutated$$ = 777');
         await session.exitDialog();
@@ -571,7 +573,7 @@ async function main() {
     // ── 22. Multiple dialogEval() calls are serviced FIFO ─────────────────
     // Three concurrent dialogEval() calls queue up and resolve in order.
     await run('22. multiple dialogEval calls are serviced FIFO', async () => {
-        const p = session.evaluate('Dialog[]');
+        const p = session.evaluate('Dialog[]', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         const [a, b, c] = await Promise.all([
             session.dialogEval('1'),
@@ -590,7 +592,7 @@ async function main() {
     // false → true (on Dialog[]) → false (after exitDialog).
     await run('23. isDialogOpen transitions correctly', async () => {
         assert(!session.isDialogOpen, 'initially false');
-        const p = session.evaluate('Dialog[]');
+        const p = session.evaluate('Dialog[]', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         assert(session.isDialogOpen, 'true while dialog open');
         await session.exitDialog();
@@ -604,6 +606,7 @@ async function main() {
         let dlgPrintResolve;
         const dlgPrintDelivered = new Promise(r => { dlgPrintResolve = r; });
         const p = session.evaluate('Dialog[]', {
+            onDialogBegin: () => {},
             onDialogPrint: (line) => { dialogLines.push(line); dlgPrintResolve(); },
         });
         await pollUntil(() => session.isDialogOpen);
@@ -659,7 +662,7 @@ async function main() {
     // A plain evaluate() queued while the dialog inner loop is running must
     // wait and then be dispatched normally after ENDDLGPKT.
     await run('27. evaluate() queued during dialog runs after dialog closes', async () => {
-        const p1 = session.evaluate('Dialog[]');
+        const p1 = session.evaluate('Dialog[]', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         // Queue a normal eval WHILE the dialog is open — it must wait.
         const p2 = session.evaluate('"queued-during-dialog"');
@@ -688,7 +691,7 @@ async function main() {
         const sub = session.createSubsession();
         try {
             // Open a Dialog[] on the subsession.
-            const pEval = sub.evaluate('Dialog[]');
+            const pEval = sub.evaluate('Dialog[]', { onDialogBegin: () => {} });
             await pollUntil(() => sub.isDialogOpen);
             assert(sub.isDialogOpen, 'dialog should be open');
 
@@ -735,8 +738,7 @@ async function main() {
 
             let evalDone = false;
             const mainProm = s.evaluate(
-                'pP1 = 0; Pause[8]; pP1 = 1; "p1-done"',
-                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+                'pP1 = 0; Pause[8]; pP1 = 1; "p1-done"'
             ).then(() => { evalDone = true; });
 
             await sleep(300);
@@ -1030,7 +1032,7 @@ async function main() {
     // evaluations.  Tests 26 and 27 need a clean session, so test 25 runs last
     // (just before test 18 which also corrupts the link via WSInterruptMessage).
     await run('25. abort while dialog is open', async () => {
-        const p = session.evaluate('Dialog[]');
+        const p = session.evaluate('Dialog[]', { onDialogBegin: () => {} });
         await pollUntil(() => session.isDialogOpen);
         session.abort();
         const r = await p;
@@ -1475,6 +1477,71 @@ async function main() {
         }
     });
 
+    // ── 53. Bug 1A: stale ScheduledTask + non-Dynamic cell does not hang ───
+    // Simulates the subsession.js teardown: Dynamic cell runs → cleanup calls
+    // setDynAutoMode(false) but the kernel-side ScheduledTask may still fire
+    // one more Dialog[].  The next plain cell (no onDialogBegin) must not hang.
+    await run('53. stale ScheduledTask Dialog[] after setDynAutoMode(false) — no hang (Bug 1A)', async () => {
+        const s = mkSession();
+        try {
+            // Step 1: register a Dynamic expr and start the interval.
+            s.registerDynamic('dyn0', 'ToString[AbsoluteTime[], InputForm]');
+            s.setDynamicInterval(300);
+
+            // Step 2: long enough eval for ScheduledTask to fire at least once.
+            const r1 = await withTimeout(
+                s.evaluate('Do[Pause[0.1], {20}]; "cell1"'),
+                12000, '53 cell1'
+            );
+            assert(!r1.aborted && r1.result.value === 'cell1',
+                `cell1 result: ${JSON.stringify(r1.result)}`);
+
+            // Step 3: simulate subsession.js cleanup.
+            // Fix 1B: setDynAutoMode(false) now also sets dynIntervalMs_=0.
+            s.unregisterDynamic('dyn0');
+            s.setDynAutoMode(false);
+
+            // Step 4: plain cell with no onDialogBegin — must not hang.
+            const r2 = await withTimeout(
+                s.evaluate('n = 1'),
+                10000, '53 cell2 — would hang without Fix 1A'
+            );
+            assert(!r2.aborted, 'cell2 must not be aborted');
+
+            // Step 5: follow-up eval also works.
+            const r3 = await withTimeout(s.evaluate('1 + 1'), 6000, '53 cell3');
+            assert(r3.result.value === 2, `cell3 expected 2, got ${r3.result.value}`);
+        } finally {
+            s.close();
+        }
+    }, 45000);
+
+    // ── 54. Bug 1A: BEGINDLGPKT with dynAutoMode=false, no JS callback ────
+    // With dynAutoMode=false and no onDialogBegin registered, any BEGINDLGPKT
+    // must be auto-closed by the safety fallback rather than entering the
+    // legacy loop where nobody will ever call exitDialog().
+    await run('54. BEGINDLGPKT safety fallback — auto-close when no onDialogBegin (Bug 1A)', async () => {
+        const s = mkSession();
+        try {
+            s.setDynAutoMode(false);
+            // Eval runs for ~2s; no onDialogBegin registered.  Any BEGINDLGPKT
+            // that arrives (from a stale ScheduledTask or concurrent interrupt)
+            // must be auto-closed by the safety fallback.
+            const r = await withTimeout(
+                s.evaluate('Do[Pause[0.2], {10}]; "done"'),
+                15000, '54 eval — would hang without Fix 1A'
+            );
+            assert(!r.aborted, 'eval must not be aborted');
+            assert(r.result.value === 'done', `expected "done", got "${r.result.value}"`);
+
+            // Follow-up eval must work — no leftover packets.
+            const r2 = await withTimeout(s.evaluate('2 + 2'), 6000, '54 follow-up');
+            assert(r2.result.value === 4, `follow-up expected 4, got ${r2.result.value}`);
+        } finally {
+            s.close();
+        }
+    }, 30000);
+
     // ── Teardown ──────────────────────────────────────────────────────────
     session.close();
     assert(!session.isOpen, 'main session not closed');