wstp-node 0.6.2 → 0.6.3

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.3",
   "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

@@ -882,13 +882,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 +911,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);
@@ -1351,9 +1358,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 +1488,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:
@@ -3083,6 +3119,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.3"));
     return exports;
 }
 

package/test.js

@@ -731,14 +731,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 +747,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 +761,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 +773,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 +781,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 +806,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 +841,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 +853,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 +867,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 +899,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 +912,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 +938,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 +960,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 +973,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 +1012,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 +1024,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
@@ -1542,6 +1542,94 @@ 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 ──────────────────────────────────────────────────────────
     session.close();
     assert(!session.isOpen, 'main session not closed');
@@ -1555,6 +1643,7 @@ async function main() {
         process.exit(0);
     } else {
         console.log(`${passed} passed, ${failed} failed${skipped ? `, ${skipped} skipped` : ''}.`);
+        process.exit(1);
     }
 }