wstp-node 0.3.0 → 0.4.1

package/InstallationWindows.md

@@ -0,0 +1,171 @@
+# Building wstp-node on Windows
+
+This guide walks through compiling the native WSTP addon (`wstp.node`) on a
+Windows 10 / 11 x64 machine so that the
+[Wolfbook VS Code extension](https://github.com/vanbaalon/wolfbook) can use it
+without any build step on the end-user's machine.
+
+---
+
+## Prerequisites
+
+### 1. Wolfram Engine (or Mathematica)
+
+Download the free **Wolfram Engine** from:  
+https://wolfram.com/engine/
+
+Default installation path after setup:
+```
+C:\Program Files\Wolfram Research\Wolfram Engine\14.x\
+```
+
+Verify the WSTP DeveloperKit is present:
+```
+C:\Program Files\Wolfram Research\Wolfram Engine\14.x\SystemFiles\Links\WSTP\DeveloperKit\Windows-x86-64\CompilerAdditions\
+```
+The key files needed are `wstp64i4s.lib` and `wstp.h` inside that folder.
+
+> If your Wolfram version or install path differs, set the `WSTP_DIR` environment
+> variable to the `CompilerAdditions` folder before building:
+> ```powershell
+> $env:WSTP_DIR = "C:\Program Files\Wolfram Research\Wolfram Engine\14.x\SystemFiles\Links\WSTP\DeveloperKit\Windows-x86-64\CompilerAdditions"
+> ```
+
+---
+
+### 2. Visual Studio Build Tools (C++ compiler)
+
+Run the following in **PowerShell as Administrator**:
+
+```powershell
+winget install Microsoft.VisualStudio.2022.BuildTools
+```
+
+Then open **Visual Studio Installer** → **Modify** → select the
+**"Desktop development with C++"** workload.  Make sure these components
+are checked:
+
+- ✅ MSVC v143 – VS 2022 C++ x64/x86 build tools
+- ✅ Windows 11 SDK (or Windows 10 SDK)
+- ✅ C++ CMake tools (optional but useful)
+
+---
+
+### 3. Node.js ≥ 18 (LTS)
+
+```powershell
+winget install OpenJS.NodeJS.LTS
+```
+
+Restart your shell after installation, then verify:
+
+```powershell
+node --version   # 20.x or 22.x
+npm  --version
+```
+
+---
+
+### 4. Git
+
+```powershell
+winget install Git.Git
+```
+
+---
+
+## Build
+
+Open a **Developer PowerShell for VS 2022** (or a regular PowerShell — `node-gyp`
+finds MSVC automatically if the Build Tools are installed correctly).
+
+```powershell
+git clone https://github.com/vanbaalon/mathematica-wstp-node.git
+cd mathematica-wstp-node
+
+npm install
+npm run build
+```
+
+A successful build prints:
+```
+Build succeeded: build\Release\wstp.node
+```
+
+### Verify the build
+
+```powershell
+node -e "const {WstpSession}=require('./build/Release/wstp.node'); const s=new WstpSession(); s.evaluate('1+1').then(r=>{console.log(r.result.value); s.close()})"
+```
+Expected output: `2`
+
+---
+
+## Contributing the binary to the Wolfbook extension
+
+After building, copy the binary to the extension's `wstp/prebuilt/` folder and
+commit it so CI can package the Windows VSIX:
+
+```powershell
+# from inside the mathematica-wstp-node directory:
+copy build\Release\wstp.node ..\wolfbook\wstp\prebuilt\wstp-win32-x64.node
+```
+
+Then on macOS / Linux, run the deploy script to build both platform VSIXs:
+
+```bash
+bash deploy-extension.sh package
+```
+
+---
+
+## Setting up a self-hosted GitHub Actions runner (optional)
+
+If you want CI to build the Windows binary automatically on every release tag:
+
+**In your browser:** go to  
+`https://github.com/vanbaalon/mathematica-wstp-node` →  
+Settings → Actions → Runners → **New self-hosted runner** → Windows x64
+
+GitHub shows you a unique token and the exact download URL. Run those commands
+in **PowerShell as Administrator**:
+
+```powershell
+mkdir C:\actions-runner; cd C:\actions-runner
+
+# Replace the URL and token with what GitHub shows you:
+Invoke-WebRequest -Uri https://github.com/actions/runner/releases/download/v2.x.x/actions-runner-win-x64-2.x.x.zip -OutFile runner.zip
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+[System.IO.Compression.ZipFile]::ExtractToDirectory("$PWD\runner.zip", "$PWD")
+
+.\config.cmd --url https://github.com/vanbaalon/mathematica-wstp-node --token YOUR_TOKEN_HERE
+
+# Install as a Windows service so it runs even when you are logged out:
+.\svc.cmd install
+.\svc.cmd start
+```
+
+Verify the runner is online: GitHub → Settings → Actions → Runners → green dot.
+
+Once both the macOS and Windows runners are registered, push a version tag from
+your Mac to trigger a full build:
+
+```bash
+git tag v0.5.0 && git push origin v0.5.0
+```
+
+The workflow builds both binaries and publishes them as assets on the
+`mathematica-wstp-node` GitHub Release. The `wolfbook` workflow then downloads
+those assets and packages the platform-specific VSIXs automatically.
+
+---
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `gyp ERR! find VS` | Open Developer PowerShell for VS 2022, or run `npm config set msvs_version 2022` |
+| `LINK : fatal error LNK1181: cannot open input file 'wstp64i4s.lib'` | WSTP DeveloperKit not found — set `WSTP_DIR` (see Prerequisites) |
+| `node.exe` crashes on `require('./build/Release/wstp.node')` | Node.js architecture mismatch — ensure you installed 64-bit Node |
+| Runner shows offline | `cd C:\actions-runner && .\svc.cmd status`, then `.\svc.cmd start` |
+| `error MSB8036: The Windows SDK version X was not found` | Install the matching Windows SDK via Visual Studio Installer |

package/README.md

@@ -23,6 +23,7 @@ const { WstpSession, WstpReader, setDiagHandler } = require('./build/Release/wst
    - [`evaluate(expr, opts?)`](#evaluateexpr-opts) — queue an expression for evaluation; supports streaming `Print` callbacks
    - [`sub(expr)`](#subexpr) — priority evaluation that jumps ahead of the queue, for quick queries during a long computation
    - [`abort()`](#abort) — interrupt the currently running evaluation
+   - [`closeAllDialogs()`](#closealldialogs) — immediately reject all pending dialog promises and reset dialog state
    - [`dialogEval(expr)`](#dialogevalexpr) — evaluate inside an active `Dialog[]` subsession
    - [`exitDialog(retVal?)`](#exitdialogretval) — exit the current dialog and resume the main evaluation
    - [`interrupt()`](#interrupt) — send a low-level interrupt signal to the kernel
@@ -53,11 +54,16 @@ const { WstpSession, WstpReader, setDiagHandler } = require('./build/Release/wst
 
 | Requirement | Notes |
 |-------------|-------|
-| macOS | Tested on macOS 13+; Linux should work with minor path changes |
+| macOS | Tested on macOS 13+ (ARM64 and x86-64) |
+| Windows 10/11 x64 | See [InstallationWindows.md](InstallationWindows.md) for the full Windows guide |
+| Linux x86-64 / ARM64 | Should work with standard `node-gyp` toolchain |
 | Node.js ≥ 18 | Earlier versions may work but are untested |
-| Clang / Xcode Command Line Tools | `xcode-select --install` |
+| Clang / Xcode Command Line Tools (macOS) | `xcode-select --install` |
+| MSVC Build Tools with C++ workload (Windows) | Visual Studio 2019+ or Build Tools |
 | Wolfram Mathematica or Wolfram Engine | Provides `WolframKernel` and the WSTP SDK headers/libraries |
 
+> **Windows users:** follow [InstallationWindows.md](InstallationWindows.md) instead of the steps below.
+
 ### 1. Clone
 
 ```bash
@@ -91,7 +97,7 @@ The script automatically locates the WSTP SDK inside the default Wolfram install
 node test.js
 ```
 
-Expected last line: `All 28 tests passed.`
+Expected last line: `All 36 tests passed.`
 
 A more comprehensive suite (both modes + In/Out + comparison) lives in `tmp/tests_all.js`:
 
@@ -317,6 +323,43 @@ const r = await p;
 
 ---
 
+### `closeAllDialogs()`
+
+```ts
+session.closeAllDialogs(): boolean
+```
+
+Unconditionally reset all dialog state on the Node.js side.
+
+- Drains the internal dialog queue, immediately **rejecting** every pending `dialogEval()` and
+  `exitDialog()` promise with an error — no callers are left waiting forever.
+- Clears `isDialogOpen` to `false`.
+
+This does **not** send any packet to the kernel — it only fixes Node-side bookkeeping.  Use
+it in error-recovery paths, before `abort()`, or whenever you need to guarantee clean dialog
+state without knowing whether a dialog is actually still running.
+
+Returns `true` if `isDialogOpen` was `true` before the call (something was cleaned up),
+`false` if it was already clear.
+
+```js
+// Safe no-op when there is no open dialog:
+const cleaned = session.closeAllDialogs();  // false
+
+// Reliable recovery pattern before abort:
+session.closeAllDialogs();  // reject any hanging dialog promises immediately
+session.abort();
+
+// Queued dialogEval() promises reject with a descriptive error:
+const p = session.evaluate('Dialog[]');
+await pollUntil(() => session.isDialogOpen);
+const pe = session.dialogEval('1 + 1').catch(e => e.message);
+session.closeAllDialogs();  // pe rejects → "dialog closed by closeAllDialogs"
+session.abort();
+```
+
+---
+
 ### `dialogEval(expr)`
 
 ```ts
@@ -990,6 +1033,8 @@ kb.close();
 | Abort | `evaluate()` **resolves** with `aborted: true`, `result.value === '$Aborted'` |
 | Kernel crashes | `evaluate()` rejects with a link error message — create a new `WstpSession` |
 | `dialogEval()` / `exitDialog()` when no dialog open | Rejects with `"no dialog subsession is open"` |
+| `dialogEval()` / `exitDialog()` when flushed by `closeAllDialogs()` | Rejects with `"dialog closed by closeAllDialogs"` |
+| `abort()` / `closeAllDialogs()` flushes dialog queue | Pending `dialogEval()`/`exitDialog()` promises reject immediately |
 | `evaluate()` after `close()` | Rejects with `"Session is closed"` |
 | `WstpReader.readNext()` after link closes | Rejects with a link-closed error |
 

package/binding.gyp

@@ -1,8 +1,9 @@
 {
   "variables": {
-    # Detect arch: arm64 → MacOSX-ARM64, x86_64 → MacOSX-x86-64
-    # Override the whole path by setting WSTP_DIR in the environment.
-    "wstp_dir%": "<!(echo \"${WSTP_DIR:-/Applications/Wolfram 3.app/Contents/SystemFiles/Links/WSTP/DeveloperKit/$(uname -m | sed 's/x86_64/MacOSX-x86-64/;s/arm64/MacOSX-ARM64/')/CompilerAdditions}\")"
+    # Cross-platform WSTP DeveloperKit path.
+    # Override by setting WSTP_DIR in the environment.
+    # See scripts/wstp_dir.js for auto-detection logic.
+    "wstp_dir%": "<!@(node scripts/wstp_dir.js)"
   },
   "targets": [
     {
@@ -16,13 +17,9 @@
 
       "defines": ["NAPI_DISABLE_CPP_EXCEPTIONS"],
 
-      "libraries": [
-        # The static library ships as libWSTPi4.a in the macOS DeveloperKit.
-        "<(wstp_dir)/libWSTPi4.a"
-      ],
-
       "conditions": [
         ["OS=='mac'", {
+          "libraries": ["<(wstp_dir)/libWSTPi4.a"],
           "xcode_settings": {
             "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
             "MACOSX_DEPLOYMENT_TARGET": "11.0",
@@ -37,8 +34,9 @@
           }
         }],
         ["OS=='linux'", {
+          "libraries": ["<(wstp_dir)/libWSTPi4.a"],
           "cflags_cc": ["-std=c++17", "-Wall", "-Wextra"],
-          "libraries": ["-lrt", "-lpthread", "-ldl", "-lm"]
+          "link_settings": { "libraries": ["-lrt", "-lpthread", "-ldl", "-lm"] }
         }],
         ["OS=='win'", {
           "msvs_settings": {

package/index.d.ts

@@ -158,6 +158,19 @@ export class WstpSession {
     /** True while a Dialog[] subsession is open on this link. */
     readonly isDialogOpen: boolean;
 
+    /**
+     * True when the session is fully ready to accept a new evaluation:
+     * the kernel is running (`isOpen`), no evaluation is currently executing
+     * or queued, and no Dialog[] subsession is open.
+     *
+     * Equivalent to:
+     *   `isOpen && !busy && !isDialogOpen && queue.empty() && subQueue.empty()`
+     *
+     * This is a synchronous snapshot; the value may change on the next tick
+     * if an async operation starts or finishes concurrently.
+     */
+    readonly isReady: boolean;
+
     /**
      * Interrupt the currently running evaluate() call.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wstp-node",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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",
@@ -20,16 +20,19 @@
   "license": "MIT",
   "os": [
     "darwin",
-    "linux"
+    "linux",
+    "win32"
   ],
   "engines": {
     "node": ">=18"
   },
   "files": [
     "src/addon.cc",
+    "scripts/wstp_dir.js",
     "build.sh",
     "binding.gyp",
     "index.d.ts",
+    "InstallationWindows.md",
     "examples/",
     "test.js",
     "test_interrupt_dialog.js"
@@ -43,9 +46,9 @@
     "demo": "node examples/demo.js"
   },
   "dependencies": {
-    "node-addon-api": "^8.0.0"
+    "node-addon-api": "^8.6.0"
   },
   "devDependencies": {
-    "node-gyp": "^10.0.0"
+    "node-gyp": "^12.2.0"
   }
 }

package/scripts/wstp_dir.js

@@ -0,0 +1,78 @@
+/**
+ * wstp_dir.js
+ * Cross-platform helper used by binding.gyp to locate the WSTP DeveloperKit.
+ *
+ * Usage in binding.gyp:  "wstp_dir%": "<!@(node scripts/wstp_dir.js)"
+ *
+ * Precedence:
+ *   1. WSTP_DIR environment variable  (always wins)
+ *   2. Platform-specific auto-detect below
+ */
+
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+
+function resolve () {
+  // ── 1. Explicit override ────────────────────────────────────────────────
+  if (process.env.WSTP_DIR) {
+    return process.env.WSTP_DIR;
+  }
+
+  // ── 2. Windows ──────────────────────────────────────────────────────────
+  if (process.platform === 'win32') {
+    const base = 'C:\\Program Files\\Wolfram Research\\Wolfram Engine';
+    let versions;
+    try {
+      versions = fs.readdirSync(base)
+        .filter(d => /^\d/.test(d))
+        .sort()
+        .reverse();
+    } catch (e) {
+      throw new Error(
+        `WSTP DeveloperKit not found at "${base}".\n` +
+        `Install Wolfram Engine or set WSTP_DIR to the CompilerAdditions folder.`
+      );
+    }
+    if (!versions.length) throw new Error(`No Wolfram Engine version found under "${base}"`);
+    return path.join(
+      base, versions[0],
+      'SystemFiles', 'Links', 'WSTP', 'DeveloperKit',
+      'Windows-x86-64', 'CompilerAdditions'
+    );
+  }
+
+  // ── 3. macOS ────────────────────────────────────────────────────────────
+  if (process.platform === 'darwin') {
+    const { execSync } = require('child_process');
+    const machine = execSync('uname -m').toString().trim();
+    const archDir  = machine === 'arm64' ? 'MacOSX-ARM64' : 'MacOSX-x86-64';
+    return path.join(
+      '/Applications/Wolfram 3.app/Contents/SystemFiles/Links/WSTP/DeveloperKit',
+      archDir, 'CompilerAdditions'
+    );
+  }
+
+  // ── 4. Linux ────────────────────────────────────────────────────────────
+  {
+    const { execSync } = require('child_process');
+    const machine = execSync('uname -m').toString().trim();
+    const archDir  = machine === 'aarch64' ? 'Linux-ARM64' : 'Linux-x86-64';
+    const candidates = [
+      path.join(process.env.HOME || '/root', 'Wolfram', 'WolframEngine',
+                'SystemFiles', 'Links', 'WSTP', 'DeveloperKit', archDir, 'CompilerAdditions'),
+      path.join('/usr/local/Wolfram/WolframEngine',
+                'SystemFiles', 'Links', 'WSTP', 'DeveloperKit', archDir, 'CompilerAdditions'),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    throw new Error(
+      'WSTP DeveloperKit not found for Linux.\n' +
+      'Set WSTP_DIR to the CompilerAdditions directory.'
+    );
+  }
+}
+
+process.stdout.write(resolve());

package/src/addon.cc

@@ -222,6 +222,46 @@ static WExpr ReadExprRaw(WSLINK lp, int depth = 0) {
 // Forward declaration — WExprToNapi is defined after WstpSession.
 static Napi::Value WExprToNapi(Napi::Env env, const WExpr& e);
 
+// ---------------------------------------------------------------------------
+// drainDialogAbortResponse — drain the WSTP link after aborting out of a
+// dialog inner loop.
+//
+// When abort() fires proactively (abortFlag_ is true before the kernel has
+// sent its response), WSAbortMessage has already been posted but the kernel's
+// abort response — RETURNPKT[$Aborted] or ILLEGALPKT — has not yet been read.
+// Leaving it on the link corrupts the next evaluation: it becomes the first
+// packet seen by the next DrainToEvalResult call, which resolves immediately
+// with $Aborted and leaves the real response on the link — permanently
+// degrading the session and disabling subsequent interrupts.
+//
+// Reads and discards packets until RETURNPKT, RETURNEXPRPKT, ILLEGALPKT, or a
+// 10-second wall-clock deadline.  Intermediate packets (ENDDLGPKT, TEXTPKT,
+// MESSAGEPKT, MENUPKT, etc.) are silently consumed.
+// ---------------------------------------------------------------------------
+static void drainDialogAbortResponse(WSLINK lp) {
+    const auto deadline =
+        std::chrono::steady_clock::now() + std::chrono::seconds(10);
+    while (std::chrono::steady_clock::now() < deadline) {
+        // Poll until data is available or the deadline passes.
+        while (std::chrono::steady_clock::now() < deadline) {
+            if (WSReady(lp)) break;
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+        if (!WSReady(lp)) return; // timed out — give up
+        int pkt = WSNextPacket(lp);
+        if (pkt == RETURNPKT || pkt == RETURNEXPRPKT) {
+            WSNewPacket(lp);
+            return; // outer-eval abort response consumed — link is clean
+        }
+        if (pkt == ILLEGALPKT || pkt == 0) {
+            WSClearError(lp);
+            WSNewPacket(lp);
+            return; // link reset — clean
+        }
+        WSNewPacket(lp); // discard intermediate packet (ENDDLGPKT, MENUPKT, …)
+    }
+}
+
 // ---------------------------------------------------------------------------
 // DrainToEvalResult — consume all packets for one cell, capturing Print[]
 // output and messages.  Blocks until RETURNPKT.  Thread-pool thread only.
@@ -273,19 +313,32 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                 WSReleaseString(lp, s);
                 static const std::string NL = "\\012";
                 std::string msg;
+                // Extract the message starting from the Symbol::tag position.
+                // Wolfram's TEXTPKT for MESSAGEPKT may contain multiple \012-separated
+                // sections (e.g. the tag on one line, the body on subsequent lines).
+                // Old code stopped at the first \012 after ::, which truncated long
+                // messages like NIntegrate::ncvb to just their tag.
+                // Fixed: take the whole text from the start of the Symbol name,
+                // stripping only leading/trailing \012 groups, and replacing
+                // internal \012 with spaces so the full message is one readable line.
                 auto dc = text.find("::");
+                size_t raw_start = 0;
                 if (dc != std::string::npos) {
                     auto nl_before = text.rfind(NL, dc);
-                    size_t start = (nl_before != std::string::npos) ? nl_before + 4 : 0;
-                    auto nl_after = text.find(NL, dc);
-                    size_t end = (nl_after != std::string::npos) ? nl_after : text.size();
-                    while (start < end && text[start] == ' ') ++start;
-                    msg = text.substr(start, end - start);
-                } else {
-                    for (size_t i = 0; i < text.size(); ) {
-                        if (text.compare(i, 4, NL) == 0) { msg += ' '; i += 4; }
-                        else { msg += text[i++]; }
-                    }
+                    raw_start = (nl_before != std::string::npos) ? nl_before + 4 : 0;
+                }
+                // Strip trailing \012 sequences from the raw text
+                std::string raw = text.substr(raw_start);
+                while (raw.size() >= 4 && raw.compare(raw.size() - 4, 4, NL) == 0)
+                    raw.resize(raw.size() - 4);
+                // Strip leading spaces
+                size_t sp = 0;
+                while (sp < raw.size() && raw[sp] == ' ') ++sp;
+                raw = raw.substr(sp);
+                // Replace all remaining \012 with a single space
+                for (size_t i = 0; i < raw.size(); ) {
+                    if (raw.compare(i, 4, NL) == 0) { msg += ' '; i += 4; }
+                    else { msg += raw[i++]; }
                 }
                 if (!forDialog) {
                     r.messages.push_back(msg);
@@ -680,10 +733,14 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                 // The kernel may be slow to respond (or send RETURNPKT[$Aborted]
                 // without a preceding ENDDLGPKT); bail out proactively to avoid
                 // spinning forever.
+                // CRITICAL: always drain the link before returning.  If we exit
+                // here before the kernel sends its RETURNPKT[$Aborted], that
+                // response stays on the link and corrupts the next evaluation.
                 if (opts && opts->abortFlag && opts->abortFlag->load()) {
                     if (opts->dialogOpen) opts->dialogOpen->store(false);
                     r.result = WExpr::mkSymbol("System`$Aborted");
                     r.aborted = true;
+                    drainDialogAbortResponse(lp); // consume pending abort response
                     return r;
                 }
 
@@ -821,6 +878,7 @@ static EvalResult DrainToEvalResult(WSLINK lp, EvalOptions* opts = nullptr) {
                     if (opts->dialogOpen) opts->dialogOpen->store(false);
                     r.result = WExpr::mkSymbol("System`$Aborted");
                     r.aborted = true;
+                    drainDialogAbortResponse(lp); // consume pending abort response
                     return r;
                 }
                 if (opts && opts->dialogPending && opts->dialogPending->load()) {
@@ -1037,6 +1095,7 @@ public:
                    std::string                   expr,
                    EvalOptions                   opts,
                    std::atomic<bool>&            abortFlag,
+                   std::atomic<bool>&            workerReadingLink,
                    std::function<void()>         completionCb,
                    int64_t                       cellIndex,
                    bool                          interactive = false)
@@ -1047,6 +1106,7 @@ public:
           interactive_(interactive),
           opts_(std::move(opts)),
           abortFlag_(abortFlag),
+          workerReadingLink_(workerReadingLink),
           completionCb_(std::move(completionCb)),
           cellIndex_(cellIndex)
     {}
@@ -1072,10 +1132,12 @@ public:
                    WSFlush      (lp_);
         }
         if (!sent) {
+            workerReadingLink_.store(false, std::memory_order_release);
             SetError("Failed to send packet to kernel");
         } else {
             opts_.interactive = interactive_;
             result_ = DrainToEvalResult(lp_, &opts_);
+            workerReadingLink_.store(false, std::memory_order_release); // lp_ no longer in use
             if (!interactive_) {
                 // EvaluatePacket mode: kernel never sends INPUTNAMEPKT/OUTPUTNAMEPKT,
                 // so stamp the pre-captured counter and derive outputName manually.
@@ -1160,6 +1222,7 @@ private:
     std::string              expr_;
     EvalOptions              opts_;
     std::atomic<bool>&       abortFlag_;
+    std::atomic<bool>&       workerReadingLink_;
     std::function<void()>    completionCb_;
     int64_t                  cellIndex_;
     bool                     interactive_;
@@ -1182,10 +1245,12 @@ public:
             InstanceMethod<&WstpSession::ExitDialog>      ("exitDialog"),
             InstanceMethod<&WstpSession::Interrupt>       ("interrupt"),
             InstanceMethod<&WstpSession::Abort>           ("abort"),
+            InstanceMethod<&WstpSession::CloseAllDialogs>  ("closeAllDialogs"),
             InstanceMethod<&WstpSession::CreateSubsession>("createSubsession"),
             InstanceMethod<&WstpSession::Close>           ("close"),
             InstanceAccessor<&WstpSession::IsOpen>        ("isOpen"),
             InstanceAccessor<&WstpSession::IsDialogOpen>  ("isDialogOpen"),
+            InstanceAccessor<&WstpSession::IsReady>       ("isReady"),
         });
 
         Napi::FunctionReference* ctor = new Napi::FunctionReference();
@@ -1401,12 +1466,14 @@ public:
         bool evalInteractive = (item.interactiveOverride == -1)
                                 ? interactiveMode_
                                 : (item.interactiveOverride == 1);
+        workerReadingLink_.store(true, std::memory_order_release);
         auto* worker = new EvaluateWorker(
             std::move(item.deferred),
             lp_,
             std::move(item.expr),
             std::move(item.opts),
             abortFlag_,
+            workerReadingLink_,
             [this]() { busy_.store(false); MaybeStartNext(); },
             nextLine_.fetch_add(1),
             evalInteractive
@@ -1419,10 +1486,11 @@ public:
     void StartSubIdleWorker(QueuedSubIdle item) {
         struct SubIdleWorker : public Napi::AsyncWorker {
             SubIdleWorker(Napi::Promise::Deferred d, WSLINK lp, std::string expr,
+                          std::atomic<bool>& workerReadingLink,
                           std::function<void()> done)
                 : Napi::AsyncWorker(d.Env()),
                   deferred_(std::move(d)), lp_(lp), expr_(std::move(expr)),
-                  done_(std::move(done)) {}
+                  workerReadingLink_(workerReadingLink), done_(std::move(done)) {}
 
             void Execute() override {
                 if (!WSPutFunction(lp_, "EvaluatePacket", 1) ||
@@ -1430,10 +1498,12 @@ public:
                     !WSPutUTF8String(lp_, (const unsigned char *)expr_.c_str(), (int)expr_.size()) ||
                     !WSEndPacket(lp_)                        ||
                     !WSFlush(lp_)) {
+                    workerReadingLink_.store(false, std::memory_order_release);
                     SetError("sub (idle): failed to send EvaluatePacket");
                     return;
                 }
                 result_ = DrainToEvalResult(lp_);
+                workerReadingLink_.store(false, std::memory_order_release); // lp_ no longer in use
             }
             void OnOK() override {
                 Napi::Env env = Env();
@@ -1456,11 +1526,14 @@ public:
             Napi::Promise::Deferred deferred_;
             WSLINK                  lp_;
             std::string             expr_;
+            std::atomic<bool>&      workerReadingLink_;
             std::function<void()>   done_;
             EvalResult              result_;
         };
 
+        workerReadingLink_.store(true, std::memory_order_release);
         (new SubIdleWorker(std::move(item.deferred), lp_, std::move(item.expr),
+                           workerReadingLink_,
                            [this]() { busy_.store(false); MaybeStartNext(); }))->Queue();
     }
 
@@ -1521,6 +1594,15 @@ public:
                 "no dialog subsession is open").Value());
             return promise;
         }
+        // Stale-state guard: dialogOpen_=true but the drain loop has already
+        // exited (busy_=false).  Nobody will service the queue, so resolve
+        // immediately and clean up rather than enqueuing a hanging request.
+        if (!busy_.load()) {
+            FlushDialogQueueWithError("dialog closed: session idle");
+            dialogOpen_.store(false);
+            deferred.Resolve(env.Null());
+            return promise;
+        }
         // Build "Return[]" or "Return[retVal]" as the exit expression.
         std::string exitExpr = "Return[]";
         if (info.Length() >= 1 && info[0].IsString())
@@ -1649,10 +1731,37 @@ public:
         // spurious RETURNPKT[$Aborted] that would corrupt the next evaluation.
         if (!busy_.load()) return Napi::Boolean::New(env, false);
         abortFlag_.store(true);
+        // Flush any queued dialogEval/exitDialog requests so their promises
+        // reject immediately instead of hanging forever.
+        FlushDialogQueueWithError("abort");
+        dialogOpen_.store(false);
         int ok = WSPutMessage(lp_, WSAbortMessage);
         return Napi::Boolean::New(env, ok != 0);
     }
 
+    // -----------------------------------------------------------------------
+    // closeAllDialogs() → boolean
+    //
+    // Unconditionally resets all dialog state on the JS side:
+    //   • Drains dialogQueue_, rejecting every pending dialogEval/exitDialog
+    //     promise with an error (so callers don't hang).
+    //   • Clears dialogOpen_ so isDialogOpen returns false.
+    //
+    // This does NOT send any packet to the kernel — it only fixes the Node
+    // side bookkeeping.  Use it in error-recovery paths (before abort() or
+    // after an unexpected kernel state change) to guarantee clean state.
+    //
+    // Returns true if dialogOpen_ was set before the call (i.e. something
+    // was actually cleaned up), false if it was already clear.
+    // -----------------------------------------------------------------------
+    Napi::Value CloseAllDialogs(const Napi::CallbackInfo& info) {
+        Napi::Env env = info.Env();
+        bool wasOpen = dialogOpen_.load();
+        FlushDialogQueueWithError("dialog closed by closeAllDialogs");
+        dialogOpen_.store(false);
+        return Napi::Boolean::New(env, wasOpen);
+    }
+
     // -----------------------------------------------------------------------
     // createSubsession(kernelPath?) → WstpSession
     //
@@ -1690,6 +1799,23 @@ public:
         return Napi::Boolean::New(info.Env(), dialogOpen_.load());
     }
 
+    // -----------------------------------------------------------------------
+    // isReady  (read-only accessor)
+    // true iff the session is open, the kernel has no active evaluation
+    // (busy_ is false), no dialog is open, and the eval + sub queues are
+    // both empty — i.e. the next evaluate() will start immediately.
+    // All reads are on the JS main thread (same thread that writes open_ and
+    // the queues), so no extra locking is needed.
+    // -----------------------------------------------------------------------
+    Napi::Value IsReady(const Napi::CallbackInfo& info) {
+        return Napi::Boolean::New(info.Env(),
+            open_
+            && !busy_.load(std::memory_order_relaxed)
+            && !dialogOpen_.load(std::memory_order_relaxed)
+            && queue_.empty()
+            && subIdleQueue_.empty());
+    }
+
 private:
     // Queue entry — one pending evaluate() call.
     // interactiveOverride: -1 = use session default, 0 = force batch, 1 = force interactive
@@ -1700,14 +1826,58 @@ private:
         int                     interactiveOverride = -1;
     };
 
+    // -----------------------------------------------------------------------
+    // FlushDialogQueueWithError — drain dialogQueue_, rejecting every pending
+    // promise with errMsg.  Caller must hold no locks; this acquires
+    // dialogMutex_ internally.  Resets dialogPending_.
+    // -----------------------------------------------------------------------
+    void FlushDialogQueueWithError(const std::string& errMsg) {
+        std::queue<DialogRequest> toFlush;
+        {
+            std::lock_guard<std::mutex> lk(dialogMutex_);
+            std::swap(toFlush, dialogQueue_);
+            dialogPending_.store(false);
+        }
+        while (!toFlush.empty()) {
+            DialogRequest req = std::move(toFlush.front());
+            toFlush.pop();
+            std::string msg = errMsg;
+            req.resolve.NonBlockingCall([msg](Napi::Env e, Napi::Function cb) {
+                auto obj = Napi::Object::New(e);
+                obj.Set("error", Napi::String::New(e, msg));
+                cb.Call({obj});
+            });
+            req.resolve.Release();
+        }
+    }
+
     void CleanUp() {
+        // If a worker thread is currently reading from lp_, calling WSClose()
+        // on it from the JS main thread causes a concurrent-access crash
+        // (heap-use-after-free / SIGSEGV).
+        //
+        // We spin on workerReadingLink_ (set false by Execute() on the background
+        // thread) rather than busy_ (set false by OnOK/OnError on the main thread).
+        // Spinning on busy_ from the main thread would deadlock because the main
+        // thread's event loop is blocked — NAPI never gets to call OnOK.
+        open_ = false; // prevent new evals from queuing during shutdown
+        if (workerReadingLink_.load(std::memory_order_acquire) && lp_) {
+            abortFlag_.store(true);
+            FlushDialogQueueWithError("session closed");
+            dialogOpen_.store(false);
+            WSPutMessage(lp_, WSAbortMessage);
+            const auto deadline =
+                std::chrono::steady_clock::now() + std::chrono::seconds(10);
+            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; }
         // Kill the child kernel process so it doesn't become a zombie.
         // WSClose() closes the link but does not terminate the WolframKernel
         // child process — without this, each session leaks a kernel.
         if (kernelPid_ > 0) { kill(kernelPid_, SIGTERM); kernelPid_ = 0; }
-        open_ = false;
     }
 
 
@@ -1805,6 +1975,11 @@ private:
     std::atomic<int64_t>        nextLine_{1};      // 1-based In[n] counter for EvalResult.cellIndex
     std::atomic<bool>           abortFlag_{false};
     std::atomic<bool>           busy_{false};
+    // Set true before queuing a worker, set false from within Execute() (background
+    // thread) right after DrainToEvalResult returns.  CleanUp() spins on this flag
+    // rather than busy_ (which is cleared on the main thread and cannot be polled
+    // from a main-thread spin loop).
+    std::atomic<bool>           workerReadingLink_{false};
     std::mutex                  queueMutex_;
     std::queue<QueuedEval>      queue_;
     std::queue<QueuedSubIdle>   subIdleQueue_;    // sub() — runs before queue_ items

package/test.js

@@ -39,6 +39,30 @@ function pollUntil(condition, timeoutMs = 3000, intervalMs = 50) {
     });
 }
 
+// withTimeout — race a promise against a named deadline.
+function withTimeout(p, ms, label) {
+    return Promise.race([
+        p,
+        new Promise((_, rej) =>
+            setTimeout(() => rej(new Error(`TIMEOUT(${ms}ms): ${label}`)), ms)),
+    ]);
+}
+
+// mkSession — open a fresh WstpSession.
+function mkSession() {
+    return new WstpSession(KERNEL_PATH);
+}
+
+// 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.
+async function installHandler(s) {
+    await s.evaluate(
+        'Quiet[Internal`AddHandler["Interrupt", Function[{}, Dialog[]]]]',
+        { onDialogBegin: () => {}, onDialogEnd: () => {} }
+    );
+}
+
 // Per-test timeout (ms).  Any test that does not complete within this window
 // is failed immediately with a "TIMED OUT" error.  Prevents indefinite hangs.
 const TEST_TIMEOUT_MS = 30_000;
@@ -56,11 +80,11 @@ suiteWatchdog.unref();   // does not prevent normal exit
 let passed = 0;
 let failed = 0;
 
-async function run(name, fn) {
+async function run(name, fn, timeoutMs = TEST_TIMEOUT_MS) {
     // Race the test body against a per-test timeout.
     const timeout = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error(`TIMED OUT after ${TEST_TIMEOUT_MS} ms`)),
-                   TEST_TIMEOUT_MS));
+        setTimeout(() => reject(new Error(`TIMED OUT after ${timeoutMs} ms`)),
+                   timeoutMs));
     try {
         await Promise.race([fn(), timeout]);
         console.log(`  ✓ ${name}`);
@@ -616,6 +640,353 @@ async function main() {
         );
     });
 
+    // ── 28. closeAllDialogs() is a no-op when no dialog is open ───────────
+    await run('28. closeAllDialogs() no-op when idle', async () => {
+        assert(!session.isDialogOpen, 'precondition: no dialog open');
+        const closed = session.closeAllDialogs();
+        assert(closed === false,
+            `closeAllDialogs() should return false when idle, got: ${closed}`);
+        assert(!session.isDialogOpen, 'isDialogOpen should stay false');
+    });
+
+    // ── 29. closeAllDialogs() rejects all queued dialogEval promises ───────
+    // Uses a subsession so the main session stays intact for tests 25 and 18.
+    // Verifies: return value = true, isDialogOpen cleared, queued promises rejected.
+    await run('29. closeAllDialogs() rejects queued dialogEval promises', async () => {
+        const sub = session.createSubsession();
+        try {
+            // Open a Dialog[] on the subsession.
+            const pEval = sub.evaluate('Dialog[]');
+            await pollUntil(() => sub.isDialogOpen);
+            assert(sub.isDialogOpen, 'dialog should be open');
+
+            // Queue two dialogEval() calls — neither will be serviced before
+            // closeAllDialogs() runs (the JS event loop hasn't yielded yet).
+            const pe1 = sub.dialogEval('"expr-1"')
+                .then(() => 'resolved').catch(e => 'rejected:' + e.message);
+            const pe2 = sub.dialogEval('"expr-2"')
+                .then(() => 'resolved').catch(e => 'rejected:' + e.message);
+
+            // closeAllDialogs() should flush both and return true.
+            const closed = sub.closeAllDialogs();
+            assert(closed === true,
+                `closeAllDialogs() should return true when dialog was open, got: ${closed}`);
+            assert(!sub.isDialogOpen,
+                'isDialogOpen should be false after closeAllDialogs()');
+
+            // Both queued promises must reject immediately.
+            const [r1, r2] = await Promise.all([pe1, pe2]);
+            assert(r1.startsWith('rejected:'),
+                `pe1 should have rejected, got: ${r1}`);
+            assert(r2.startsWith('rejected:'),
+                `pe2 should have rejected, got: ${r2}`);
+
+            // Abort the subsession to unstick the kernel (still inside Dialog[]).
+            sub.abort();
+            const ra = await pEval;
+            assert(ra.aborted === true,
+                `subsession evaluate should resolve with aborted=true, got: ${JSON.stringify(ra.aborted)}`);
+        } finally {
+            sub.close();
+        }
+    });
+
+    // ── P1: Pause[8] ignores interrupt ────────────────────────────────────
+    // Expected: interrupt() returns true but isDialogOpen stays false within
+    // 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 () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            let evalDone = false;
+            const mainProm = s.evaluate(
+                'pP1 = 0; Pause[8]; pP1 = 1; "p1-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).then(() => { evalDone = true; });
+
+            await sleep(300);
+
+            const sent = s.interrupt();
+            assert(sent === true, 'interrupt() should return true mid-eval');
+
+            const t0 = Date.now();
+            while (!s.isDialogOpen && Date.now() - t0 < 2500) await sleep(25);
+
+            const dlgOpened = s.isDialogOpen;
+            assert(!dlgOpened, 'Pause[8] should NOT open a dialog within 2500ms');
+
+            // After the 2500ms 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).
+            s.abort();
+            await mainProm; // resolves immediately after abort()
+        } finally {
+            s.close();
+        }
+    }, 20_000);
+
+    // ── P2: Pause[0.3] loop — interrupt opens Dialog and dialogEval works ──
+    // Expected: interrupt during a short Pause[] loop opens a Dialog[],
+    // dialogEval can read the live variable, and exitDialog resumes the loop.
+    await run('P2: Pause[0.3] loop — interrupt opens Dialog and dialogEval succeeds', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            let evalDone = false;
+            const mainProm = s.evaluate(
+                'Do[nP2 = k; Pause[0.3], {k, 1, 30}]; "p2-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).then(() => { evalDone = true; });
+
+            await sleep(500);
+
+            s.interrupt();
+            try { await pollUntil(() => s.isDialogOpen, 3000); }
+            catch (_) { throw new Error('Dialog never opened — interrupt not working with Pause[0.3]'); }
+
+            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');
+        } finally {
+            try { s.abort(); } catch (_) {}
+            s.close();
+        }
+    }, 30_000);
+
+    // ── P3: dialogEval timeout — kernel state after (diagnostic) ───────────
+    // Simulates the extension failure: dialogEval times out without exitDialog.
+    // Verifies the kernel is NOT permanently broken by a timeout alone.
+    // Always passes — records the observed behaviour.
+    await run('P3: dialogEval timeout — kernel still recovers via exitDialog', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            let evalDone = false;
+            const mainProm = s.evaluate(
+                'Do[nP3 = k; Pause[0.3], {k, 1, 200}]; "p3-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).then(() => { evalDone = true; });
+
+            await sleep(500);
+
+            s.interrupt();
+            try { await pollUntil(() => s.isDialogOpen, 3000); }
+            catch (_) { throw new Error('Dialog #1 never opened'); }
+
+            // Simulate a timed-out dialogEval (abandon it at 200ms)
+            try { await withTimeout(s.dialogEval('nP3'), 200, 'deliberate-timeout'); } catch (_) {}
+
+            // Attempt exitDialog — should succeed
+            let exitOk = false;
+            try { await withTimeout(s.exitDialog(), 2000, 'exitDialog after timeout'); exitOk = true; }
+            catch (_) {}
+
+            // Attempt a second interrupt to confirm kernel state
+            await sleep(400);
+            s.interrupt();
+            let dlg2 = false;
+            const t2 = Date.now();
+            while (!s.isDialogOpen && Date.now() - t2 < 3000) await sleep(30);
+            dlg2 = s.isDialogOpen;
+
+            if (dlg2) {
+                await withTimeout(s.dialogEval('nP3'), 4000, 'dialogEval #2').catch(() => {});
+                await s.exitDialog().catch(() => {});
+            }
+
+            if (!evalDone) { try { await withTimeout(mainProm, 20_000, 'P3 loop'); } catch (_) {} }
+
+            // Diagnostic: document observed outcome but do not hard-fail on dlg2
+            if (!exitOk) {
+                console.log(`    P3 note: exitDialog failed, dlg2=${dlg2} (expected=false for unfixed build)`);
+            }
+            // Test passes unconditionally.
+        } finally {
+            try { s.abort(); } catch (_) {}
+            s.close();
+        }
+    }, 45_000);
+
+// ── P4: abort() after stuck dialog — session stays alive ────────────────
+    // Note: abort() sends WSAbortMessage which resets the Wolfram kernel's
+    // Internal`AddHandler["Interrupt", ...] registration.  Subsequent interrupts
+    // therefore do not open a new Dialog[]; that is expected, not a bug.
+    // What this test verifies: after abort() the session is NOT dead —
+    // evaluate() still works so the extension can queue more cells.
+    await run('P4: abort() after stuck dialog — session can still evaluate', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            const mainProm = s.evaluate(
+                'Do[nP4=k; Pause[0.3], {k,1,200}]; "p4-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).catch(() => {});
+
+            await sleep(500);
+
+            // Trigger a dialog, force dialogEval timeout, then abort
+            s.interrupt();
+            try { await pollUntil(() => s.isDialogOpen, 3000); }
+            catch (_) { throw new Error('Dialog #1 never opened'); }
+
+            try { await withTimeout(s.dialogEval('nP4'), 300, 'deliberate'); } catch (_) {}
+            try { s.abort(); } catch (_) {}
+
+            // Let execute() drain the abort response and OnOK fire
+            const tAbort = Date.now();
+            while (s.isDialogOpen && Date.now() - tAbort < 5000) await sleep(50);
+            try { await withTimeout(mainProm, 5000, 'P4 abort settle'); } catch (_) {}
+            await sleep(300);
+
+            // KEY assertion: the session is still functional for evaluate()
+            // (abort() must NOT permanently close the link)
+            const r = await withTimeout(
+                s.evaluate('"session-alive-after-abort"'),
+                8000, 'post-abort evaluate'
+            );
+            assert(r && r.result && r.result.value === 'session-alive-after-abort',
+                `evaluate() after abort returned unexpected result: ${JSON.stringify(r)}`);
+        } finally {
+            try { s.abort(); } catch (_) {}
+            s.close();
+        }
+    }, 30_000);
+
+    // ── P5: closeAllDialogs()+abort() recovery → reinstall handler → new dialog works
+    // closeAllDialogs() is designed to be paired with abort().  It rejects all
+    // pending dialogEval() promises (JS-side), while abort() signals the kernel.
+    // After recovery the interrupt handler must be reinstalled because abort()
+    // clears Wolfram's Internal`AddHandler["Interrupt",...] registration.
+    await run('P5: closeAllDialogs()+abort() recovery — new dialog works after reinstallHandler', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            const mainProm = s.evaluate(
+                'Do[nP5 = k; Pause[0.3], {k, 1, 200}]; "p5-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).catch(() => {});
+
+            await sleep(500);
+
+            // ── Phase 1: open dialog #1, call closeAllDialogs()+abort() ──────
+            s.interrupt();
+            try { await pollUntil(() => s.isDialogOpen, 3000); }
+            catch (_) { throw new Error('Dialog #1 never opened'); }
+
+            // Start a dialogEval — closeAllDialogs() will reject it synchronously.
+            const de1 = s.dialogEval('nP5').catch(() => {});
+            try { s.closeAllDialogs(); } catch (_) {}
+            await de1;           // resolves immediately (rejected by closeAllDialogs)
+            await sleep(100);
+            try { s.abort(); } catch (_) {}
+            await mainProm;      // should resolve promptly after abort()
+
+            // ── Phase 2: reinstall handler, start new loop, interrupt → dialog #2 ──
+            // abort() clears Internal`AddHandler["Interrupt",...] in the kernel,
+            // so we must reinstall before the next interrupt cycle.
+            await withTimeout(installHandler(s), 8000, 'reinstall handler after abort');
+
+            let dlg2 = false;
+            const mainProm2 = s.evaluate(
+                'Do[nP5b = k; Pause[0.3], {k, 1, 200}]; "p5b-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).catch(() => {});
+
+            await sleep(500);
+            s.interrupt();
+            try { await pollUntil(() => s.isDialogOpen, 3000); }
+            catch (_) { throw new Error('Dialog #2 never opened after closeAllDialogs()+abort() recovery'); }
+            dlg2 = true;
+
+            // Read a live variable inside the dialog.
+            const val2 = await withTimeout(s.dialogEval('nP5b'), 4000, 'dialogEval #2');
+            assert(val2 !== null && val2.value !== undefined, 'dialogEval #2 should return nP5b value');
+
+            assert(dlg2, 'after closeAllDialogs()+abort()+reinstallHandler, interrupt must open a new dialog');
+            // Abort the dialog and remaining Do loop promptly (no exitDialog needed).
+            try { s.abort(); } catch (_) {}
+            await mainProm2.catch(() => {});  // drains immediately after abort
+        } finally {
+            try { s.abort(); } catch (_) {}
+            s.close();
+        }
+    }, 60_000);
+
+    // ── P6: Simulate Dynamic + Pause[5] full scenario (diagnostic) ─────────
+    // Reproduces: n=RandomInteger[100]; Pause[5] with interrupt every 2.5s.
+    // Pause[5] is expected to block all interrupts.  Test always passes —
+    // it documents whether reads succeed despite long Pause.
+    await run('P6: Pause[5] + interrupt cycle — dynamic read diagnostic', async () => {
+        const s = mkSession();
+        try {
+            await installHandler(s);
+
+            let evalDone = false;
+            const mainProm = s.evaluate(
+                'n = RandomInteger[100]; Pause[5]; "p6-done"',
+                { onDialogBegin: () => {}, onDialogEnd: () => {} }
+            ).then(() => { evalDone = true; });
+
+            await sleep(200);
+
+            const INTERRUPT_WAIT_MS = 2500;
+            const DIALOG_EVAL_TIMEOUT_MS = 8000;
+            let dialogReadSucceeded = false;
+            let pauseIgnoredInterrupt = false;
+
+            for (let cycle = 1; cycle <= 5 && !evalDone; cycle++) {
+                const t0 = Date.now();
+                s.interrupt();
+                while (!s.isDialogOpen && Date.now() - t0 < INTERRUPT_WAIT_MS) await sleep(25);
+                const dlg = s.isDialogOpen;
+
+                if (!dlg) {
+                    pauseIgnoredInterrupt = true;
+                    await sleep(300);
+                    continue;
+                }
+
+                try {
+                    const val = await withTimeout(
+                        s.dialogEval('n'), DIALOG_EVAL_TIMEOUT_MS, `P6 dialogEval cycle ${cycle}`);
+                    dialogReadSucceeded = true;
+                    await s.exitDialog();
+                    break;
+                } catch (e) {
+                    let exitOk = false;
+                    for (let a = 0; a < 3 && !exitOk; a++) {
+                        try { await withTimeout(s.exitDialog(), 2000, `exitDialog ${a+1}`); exitOk = true; }
+                        catch (_) {}
+                    }
+                    if (!exitOk) { try { s.abort(); } catch (_) {} await sleep(1000); break; }
+                }
+            }
+
+            try { await withTimeout(mainProm, 12_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');
+            } else if (dialogReadSucceeded) {
+                console.log('    P6 note: at least one read succeeded despite Pause');
+            }
+        } finally {
+            try { s.abort(); } catch (_) {}
+            s.close();
+        }
+    }, 60_000);
+
     // ── 25. abort() while dialog is open ──────────────────────────────────
     // Must run AFTER all other dialog tests — abort() sends WSAbortMessage
     // which resets the WSTP link, leaving the session unusable for further
@@ -649,6 +1020,10 @@ async function main() {
     console.log();
     if (failed === 0) {
         console.log(`All ${passed} tests passed.`);
+        // Force-exit: WSTP library may keep libuv handles alive after WSClose,
+        // preventing the event loop from draining naturally.  All assertions are
+        // done; a clean exit(0) is safe.
+        process.exit(0);
     } else {
         console.log(`${passed} passed, ${failed} failed.`);
     }