node-pty 1.1.0-beta9 → 1.2.0-beta.1

package/scripts/gen-compile-commands.js

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2025, Microsoft Corporation (MIT License).
+ */
+
+const { execSync } = require('child_process');
+
+console.log(`\x1b[32m> Generating compile_commands.json...\x1b[0m`);
+execSync('npx --offline node-gyp configure -- -f compile_commands_json');

package/scripts/{publish.js → increment-version.js}

@@ -7,30 +7,19 @@ const fs = require('fs');
 const path = require('path');
 const packageJson = require('../package.json');
 
-// Setup auth
-fs.writeFileSync(`${process.env['HOME']}/.npmrc`, `//registry.npmjs.org/:_authToken=${process.env['NPM_AUTH_TOKEN']}`);
-
 // Determine if this is a stable or beta release
 const publishedVersions = getPublishedVersions();
-const isStableRelease = publishedVersions.indexOf(packageJson.version) === -1;
+const isStableRelease = !publishedVersions.includes(packageJson.version);
 
 // Get the next version
-let nextVersion = isStableRelease ? packageJson.version : getNextBetaVersion();
-console.log(`Publishing version: ${nextVersion}`);
+const nextVersion = isStableRelease ? packageJson.version : getNextBetaVersion();
+console.log(`Setting version to ${nextVersion}`);
 
 // Set the version in package.json
 const packageJsonFile = path.resolve(__dirname, '..', 'package.json');
 packageJson.version = nextVersion;
 fs.writeFileSync(packageJsonFile, JSON.stringify(packageJson, null, 2));
 
-// Publish
-const args = ['publish'];
-if (!isStableRelease) {
-  args.push('--tag', 'beta');
-}
-const result = cp.spawn('npm', args, { stdio: 'inherit' });
-result.on('exit', code => process.exit(code));
-
 function getNextBetaVersion() {
   if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.exec(packageJson.version)) {
     console.error('The package.json version must be of the form x.y.z');
@@ -41,7 +30,7 @@ function getNextBetaVersion() {
   const nextStableVersion = `${stableVersion[0]}.${parseInt(stableVersion[1]) + 1}.0`;
   const publishedVersions = getPublishedVersions(nextStableVersion, tag);
   if (publishedVersions.length === 0) {
-    return `${nextStableVersion}-${tag}1`;
+    return `${nextStableVersion}-${tag}.1`;
   }
   const latestPublishedVersion = publishedVersions.sort((a, b) => {
     const aVersion = parseInt(a.substr(a.search(/[0-9]+$/)));
@@ -49,14 +38,17 @@ function getNextBetaVersion() {
     return aVersion > bVersion ? -1 : 1;
   })[0];
   const latestTagVersion = parseInt(latestPublishedVersion.substr(latestPublishedVersion.search(/[0-9]+$/)), 10);
-  return `${nextStableVersion}-${tag}${latestTagVersion + 1}`;
+  return `${nextStableVersion}-${tag}.${latestTagVersion + 1}`;
 }
 
 function getPublishedVersions(version, tag) {
-  const versionsProcess = cp.spawnSync('npm', ['view', packageJson.name, 'versions', '--json']);
+  const isWin32 = process.platform === 'win32';
+  const versionsProcess = isWin32 ?
+    cp.spawnSync('npm.cmd', ['view', packageJson.name, 'versions', '--json'], { shell: true }) :
+    cp.spawnSync('npm', ['view', packageJson.name, 'versions', '--json']);
   const versionsJson = JSON.parse(versionsProcess.stdout);
   if (tag) {
-    return versionsJson.filter(v => !v.search(new RegExp(`${version}-${tag}[0-9]+`)));
+    return versionsJson.filter(v => !v.search(new RegExp(`${version}-${tag}\.[0-9]+`)));
   }
   return versionsJson;
 }

package/scripts/post-install.js

@@ -1,8 +1,11 @@
-var fs = require('fs');
-var path = require('path');
+//@ts-check
 
-var RELEASE_DIR = path.join(__dirname, '..', 'build', 'Release');
-var BUILD_FILES = [
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const RELEASE_DIR = path.join(__dirname, '../build/Release');
+const BUILD_FILES = [
   path.join(RELEASE_DIR, 'conpty.node'),
   path.join(RELEASE_DIR, 'conpty.pdb'),
   path.join(RELEASE_DIR, 'conpty_console_list.node'),
@@ -15,14 +18,19 @@ var BUILD_FILES = [
   path.join(RELEASE_DIR, 'winpty.dll'),
   path.join(RELEASE_DIR, 'winpty.pdb')
 ];
+const CONPTY_DIR = path.join(__dirname, '../third_party/conpty');
+const CONPTY_SUPPORTED_ARCH = ['x64', 'arm64'];
+
+console.log('\x1b[32m> Cleaning release folder...\x1b[0m');
 
-cleanFolderRecursive = function(folder) {
+/** @param {string} folder  */
+function cleanFolderRecursive(folder) {
   var files = [];
-  if( fs.existsSync(folder) ) {
+  if (fs.existsSync(folder)) {
     files = fs.readdirSync(folder);
     files.forEach(function(file,index) {
       var curPath = path.join(folder, file);
-      if(fs.lstatSync(curPath).isDirectory()) { // recurse
+      if (fs.lstatSync(curPath).isDirectory()) { // recurse
         cleanFolderRecursive(curPath);
         fs.rmdirSync(curPath);
       } else if (BUILD_FILES.indexOf(curPath) < 0){ // delete file
@@ -36,7 +44,37 @@ try {
   cleanFolderRecursive(RELEASE_DIR);
 } catch(e) {
   console.log(e);
-  //process.exit(1);
-} finally {
-  process.exit(0);
+  process.exit(1);
+}
+
+console.log(`\x1b[32m> Moving conpty.dll...\x1b[0m`);
+if (os.platform() !== 'win32') {
+  console.log('  SKIPPED (not Windows)');
+} else {
+  let windowsArch;
+  if (process.env.npm_config_arch) {
+    windowsArch = process.env.npm_config_arch;
+    console.log(`  Using $npm_config_arch: ${windowsArch}`);
+  } else {
+    windowsArch = os.arch();
+    console.log(`  Using os.arch(): ${windowsArch}`);
+  }
+
+  if (!CONPTY_SUPPORTED_ARCH.includes(windowsArch)) {
+    console.log(`  SKIPPED (unsupported architecture ${windowsArch})`);
+  } else {
+    const versionFolder = fs.readdirSync(CONPTY_DIR)[0];
+    console.log(`  Found version ${versionFolder}`);
+    const sourceFolder = path.join(CONPTY_DIR, versionFolder, `win10-${windowsArch}`);
+    const destFolder = path.join(RELEASE_DIR, 'conpty');
+    fs.mkdirSync(destFolder, { recursive: true });
+    for (const file of ['conpty.dll', 'OpenConsole.exe']) {
+      const sourceFile = path.join(sourceFolder, file);
+      const destFile = path.join(destFolder, file);
+      console.log(`  Copying ${sourceFile} -> ${destFile}`);
+      fs.copyFileSync(sourceFile, destFile);
+    }
+  }
 }
+
+process.exit(0);

package/scripts/prebuild.js

@@ -0,0 +1,34 @@
+//@ts-check
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * This script checks for the prebuilt binaries for the current platform and
+ * architecture. It exits with 0 if prebuilds are found and 1 if not.
+ *
+ * If npm_config_build_from_source is set then it removes the prebuilds for the
+ * current platform so they are not loaded at runtime.
+ *
+ * Usage:
+ *     node scripts/prebuild.js
+ */
+
+const PREBUILDS_ROOT = path.join(__dirname, '..', 'prebuilds');
+const PREBUILD_DIR = path.join(__dirname, '..', 'prebuilds', `${process.platform}-${process.arch}`);
+
+// Do not use prebuilds when npm_config_build_from_source is set
+if (process.env.npm_config_build_from_source === 'true') {
+  console.log('\x1b[33m> Removing prebuilds and rebuilding because npm_config_build_from_source is set\x1b[0m');
+  fs.rmSync(PREBUILDS_ROOT, { recursive: true, force: true });
+  process.exit(1);
+}
+
+// Check whether the correct prebuilt files exist
+console.log('\x1b[32m> Checking prebuilds...\x1b[0m');
+if (!fs.existsSync(PREBUILD_DIR)) {
+  console.log(`\x1b[33m> Rebuilding because directory ${PREBUILD_DIR} does not exist\x1b[0m`);
+  process.exit(1);
+}
+
+process.exit(0);

package/src/conpty_console_list_agent.ts

@@ -6,13 +6,9 @@
  * single console attached to a process.
  */
 
-let getConsoleProcessList: any;
-try {
-  getConsoleProcessList = require('../build/Release/conpty_console_list.node').getConsoleProcessList;
-} catch (err) {
-  getConsoleProcessList = require('../build/Debug/conpty_console_list.node').getConsoleProcessList;
-}
+import { loadNativeModule } from './utils';
 
+const getConsoleProcessList = loadNativeModule('conpty_console_list').module.getConsoleProcessList;
 const shellPid = parseInt(process.argv[2], 10);
 const consoleProcessList = getConsoleProcessList(shellPid);
 process.send!({ consoleProcessList });

package/src/index.ts

@@ -6,6 +6,7 @@
 
 import { ITerminal, IPtyOpenOptions, IPtyForkOptions, IWindowsPtyForkOptions } from './interfaces';
 import { ArgvOrCommandLine } from './types';
+import { loadNativeModule } from './utils';
 
 let terminalCtor: any;
 if (process.platform === 'win32') {
@@ -48,4 +49,4 @@ export function open(options: IPtyOpenOptions): ITerminal {
  * Expose the native API when not Windows, note that this is not public API and
  * could be removed at any time.
  */
-export const native = (process.platform !== 'win32' ? require('../build/Release/pty.node') : null);
+export const native = (process.platform !== 'win32' ? loadNativeModule('pty').module : null);

package/src/interfaces.ts

@@ -22,7 +22,7 @@ export interface ITerminal {
    * Writes data to the socket.
    * @param data The data to write.
    */
-  write(data: string): void;
+  write(data: string | Buffer): void;
 
   /**
    * Resize the pty.
@@ -119,6 +119,7 @@ export interface IPtyForkOptions extends IBasePtyForkOptions {
 
 export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
   useConpty?: boolean;
+  useConptyDll?: boolean;
   conptyInheritCursor?: boolean;
 }
 

package/src/native.d.ts

@@ -3,11 +3,11 @@
  */
 
 interface IConptyNative {
-  startProcess(file: string, cols: number, rows: number, debug: boolean, pipeName: string, conptyInheritCursor: boolean): IConptyProcess;
-  connect(ptyId: number, commandLine: string, cwd: string, env: string[], onExitCallback: (exitCode: number) => void): { pid: number };
-  resize(ptyId: number, cols: number, rows: number): void;
-  clear(ptyId: number): void;
-  kill(ptyId: number): void;
+  startProcess(file: string, cols: number, rows: number, debug: boolean, pipeName: string, conptyInheritCursor: boolean, useConptyDll: boolean): IConptyProcess;
+  connect(ptyId: number, commandLine: string, cwd: string, env: string[], useConptyDll: boolean, onExitCallback: (exitCode: number) => void): { pid: number };
+  resize(ptyId: number, cols: number, rows: number, useConptyDll: boolean): void;
+  clear(ptyId: number, useConptyDll: boolean): void;
+  kill(ptyId: number, useConptyDll: boolean): void;
 }
 
 interface IWinptyNative {

package/src/terminal.test.ts

@@ -23,7 +23,7 @@ class TestTerminal extends Terminal {
   public checkType<T>(name: string, value: T, type: string, allowArray: boolean = false): void {
     this._checkType(name, value, type, allowArray);
   }
-  protected _write(data: string): void {
+  protected _write(data: string | Buffer): void {
     throw new Error('Method not implemented.');
   }
   public resize(cols: number, rows: number): void {

package/src/terminal.ts

@@ -74,9 +74,9 @@ export abstract class Terminal implements ITerminal {
     this._checkType('encoding', opt.encoding ? opt.encoding : undefined, 'string');
   }
 
-  protected abstract _write(data: string): void;
+  protected abstract _write(data: string | Buffer): void;
 
-  public write(data: string): void {
+  public write(data: string | Buffer): void {
     if (this.handleFlowControl) {
       // PAUSE/RESUME messages are not forwarded to the pty
       if (data === this._flowControlPause) {

package/src/unix/pty.cc

@@ -41,6 +41,10 @@
 #include <util.h>
 #elif defined(__FreeBSD__)
 #include <libutil.h>
+#include <termios.h>
+#elif defined(__OpenBSD__)
+#include <util.h>
+#include <termios.h>
 #endif
 
 /* Some platforms name VWERASE and VDISCARD differently */
@@ -189,9 +193,22 @@ void SetupExitCallback(Napi::Env env, Napi::Function cb, pid_t pid) {
       exit_event->signal_code = WTERMSIG(stat_loc);
     }
     auto status = tsfn.BlockingCall(exit_event, callback); // In main thread
-    assert(status == napi_ok);
+    switch (status) {
+      case napi_closing:
+        break;
+
+      case napi_queue_full:
+        Napi::Error::Fatal("SetupExitCallback", "Queue was full");
 
-    tsfn.Release();
+      case napi_ok:
+        if (tsfn.Release() != napi_ok) {
+          Napi::Error::Fatal("SetupExitCallback", "ThreadSafeFunction.Release() failed");
+        }
+        break;
+
+      default:
+        Napi::Error::Fatal("SetupExitCallback", "ThreadSafeFunction.BlockingCall() failed");
+    }
   });
 }
 
@@ -353,7 +370,7 @@ Napi::Value PtyFork(const Napi::CallbackInfo& info) {
   int err = -1;
   pty_posix_spawn(argv, env, term, &winp, &master, &pid, &err);
   if (err != 0) {
-    throw Napi::Error::New(napiEnv, "posix_spawnp failed.");
+    throw Napi::Error::New(napiEnv, std::string("pty_posix_spawn failed with error: ") + std::to_string(err) + " (" + strerror(err) + ")");
   }
   if (pty_nonblock(master) == -1) {
     throw Napi::Error::New(napiEnv, "Could not set master fd to nonblocking.");
@@ -431,10 +448,10 @@ Napi::Value PtyFork(const Napi::CallbackInfo& info) {
   }
 #endif
 
-  Napi::Object obj = Napi::Object::New(napiEnv);  
-  obj.Set("fd", Napi::Number::New(napiEnv, master));  
-  obj.Set("pid", Napi::Number::New(napiEnv, pid));  
-  obj.Set("pty", Napi::String::New(napiEnv, ptsname(master)));  
+  Napi::Object obj = Napi::Object::New(napiEnv);
+  obj.Set("fd", Napi::Number::New(napiEnv, master));
+  obj.Set("pid", Napi::Number::New(napiEnv, pid));
+  obj.Set("pty", Napi::String::New(napiEnv, ptsname(master)));
 
   // Set up process exit callback.
   Napi::Function cb = info[10].As<Napi::Function>();
@@ -475,10 +492,10 @@ Napi::Value PtyOpen(const Napi::CallbackInfo& info) {
     throw Napi::Error::New(env, "Could not set slave fd to nonblocking.");
   }
 
-  Napi::Object obj = Napi::Object::New(env);  
-  obj.Set("master", Napi::Number::New(env, master));  
-  obj.Set("slave", Napi::Number::New(env, slave));  
-  obj.Set("pty", Napi::String::New(env, ptsname(master)));  
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("master", Napi::Number::New(env, master));
+  obj.Set("slave", Napi::Number::New(env, slave));
+  obj.Set("pty", Napi::String::New(env, ptsname(master)));
 
   return obj;
 }

package/src/unixTerminal.test.ts

@@ -272,10 +272,9 @@ if (process.platform !== 'win32') {
           ptyProcess.on('data', function (data) {
             if (ptyProcess.process === 'Python') {
               console.log('title', ptyProcess.process);
+              console.log('ready', ptyProcess.pid);
             }
           });
-          setTimeout(() => null, 500);
-          console.log('ready', ptyProcess.pid);
           `;
           const p = cp.spawn('node', ['-e', data]);
           let sub = '';
@@ -283,12 +282,10 @@ if (process.platform !== 'win32') {
           p.stdout.on('data', (data) => {
             if (!data.toString().indexOf('title')) {
               sub = data.toString().split(' ')[1].slice(0, -1);
-              setTimeout(() => {
-                process.kill(parseInt(pid), 'SIGINT');
-                p.kill('SIGINT');
-              }, 200);
             } else if (!data.toString().indexOf('ready')) {
               pid = data.toString().split(' ')[1].slice(0, -1);
+              process.kill(parseInt(pid), 'SIGINT');
+              p.kill('SIGINT');
             }
           });
           p.on('exit', () => {

package/src/unixTerminal.ts

@@ -3,29 +3,18 @@
  * Copyright (c) 2016, Daniel Imms (MIT License).
  * Copyright (c) 2018, Microsoft Corporation (MIT License).
  */
+import * as fs from 'fs';
 import * as net from 'net';
 import * as path from 'path';
+import * as tty from 'tty';
 import { Terminal, DEFAULT_COLS, DEFAULT_ROWS } from './terminal';
 import { IProcessEnv, IPtyForkOptions, IPtyOpenOptions } from './interfaces';
-import { ArgvOrCommandLine } from './types';
-import { assign } from './utils';
-
-let pty: IUnixNative;
-let helperPath: string;
-try {
-  pty = require('../build/Release/pty.node');
-  helperPath = '../build/Release/spawn-helper';
-} catch (outerError) {
-  try {
-    pty = require('../build/Debug/pty.node');
-    helperPath = '../build/Debug/spawn-helper';
-  } catch (innerError) {
-    console.error('innerError', innerError);
-    // Re-throw the exception from the Release require if the Debug require fails as well
-    throw outerError;
-  }
-}
+import { ArgvOrCommandLine, IDisposable } from './types';
+import { assign, loadNativeModule } from './utils';
 
+const native = loadNativeModule('pty');
+const pty: IUnixNative = native.module;
+let helperPath = native.dir + '/spawn-helper';
 helperPath = path.resolve(__dirname, helperPath);
 helperPath = helperPath.replace('app.asar', 'app.asar.unpacked');
 helperPath = helperPath.replace('node_modules.asar', 'node_modules.asar.unpacked');
@@ -46,6 +35,9 @@ export class UnixTerminal extends Terminal {
 
   private _boundClose: boolean = false;
   private _emittedClose: boolean = false;
+
+  private _writeStream: CustomWriteStream;
+
   private _master: net.Socket | undefined;
   private _slave: net.Socket | undefined;
 
@@ -113,10 +105,11 @@ export class UnixTerminal extends Terminal {
     // fork
     const term = pty.fork(file, args, parsedEnv, cwd, this._cols, this._rows, uid, gid, (encoding === 'utf8'), helperPath, onexit);
 
-    this._socket = new PipeSocket(term.fd);
+    this._socket = new tty.ReadStream(term.fd);
     if (encoding !== null) {
       this._socket.setEncoding(encoding);
     }
+    this._writeStream = new CustomWriteStream(term.fd, (encoding || undefined) as BufferEncoding);
 
     // setup
     this._socket.on('error', (err: any) => {
@@ -173,8 +166,8 @@ export class UnixTerminal extends Terminal {
     this._forwardEvents();
   }
 
-  protected _write(data: string): void {
-    this._socket.write(data);
+  protected _write(data: string | Buffer): void {
+    this._writeStream.write(data);
   }
 
   /* Accessors */
@@ -203,13 +196,13 @@ export class UnixTerminal extends Terminal {
     // open
     const term: IUnixOpenProcess = pty.open(cols, rows);
 
-    self._master = new PipeSocket(<number>term.master);
+    self._master = new tty.ReadStream(term.master);
     if (encoding !== null) {
       self._master.setEncoding(encoding);
     }
     self._master.resume();
 
-    self._slave = new PipeSocket(term.slave);
+    self._slave = new tty.ReadStream(term.slave);
     if (encoding !== null) {
       self._slave.setEncoding(encoding);
     }
@@ -250,6 +243,7 @@ export class UnixTerminal extends Terminal {
     });
 
     this._socket.destroy();
+    this._writeStream.dispose();
   }
 
   public kill(signal?: string): void {
@@ -264,7 +258,7 @@ export class UnixTerminal extends Terminal {
   public get process(): string {
     if (process.platform === 'darwin') {
       const title = pty.process(this._fd);
-      return (title !== 'kernel_task' ) ? title : this._file;
+      return (title !== 'kernel_task') ? title : this._file;
     }
 
     return pty.process(this._fd, this._pty) || this._file;
@@ -305,17 +299,90 @@ export class UnixTerminal extends Terminal {
   }
 }
 
+interface IWriteTask {
+  /** The buffer being written. */
+  buffer: Buffer;
+  /** The current offset of not yet written data. */
+  offset: number;
+}
+
 /**
- * Wraps net.Socket to force the handle type "PIPE" by temporarily overwriting
- * tty_wrap.guessHandleType.
- * See: https://github.com/chjj/pty.js/issues/103
+ * A custom write stream that writes directly to a file descriptor with proper
+ * handling of backpressure and errors. This avoids some event loop exhaustion
+ * issues that can occur when using the standard APIs in Node.
  */
-class PipeSocket extends net.Socket {
-  constructor(fd: number) {
-    const pipeWrap = (<any>process).binding('pipe_wrap'); // tslint:disable-line
-    // @types/node has fd as string? https://github.com/DefinitelyTyped/DefinitelyTyped/pull/18275
-    const handle = new pipeWrap.Pipe(pipeWrap.constants.SOCKET);
-    handle.open(fd);
-    super(<any>{ handle });
+class CustomWriteStream implements IDisposable {
+
+  private readonly _writeQueue: IWriteTask[] = [];
+  private _writeImmediate: NodeJS.Immediate | undefined;
+
+  constructor(
+    private readonly _fd: number,
+    private readonly _encoding: BufferEncoding
+  ) {
+  }
+
+  dispose(): void {
+    clearImmediate(this._writeImmediate);
+    this._writeImmediate = undefined;
+  }
+
+  write(data: string | Buffer): void {
+    // Writes are put in a queue and processed asynchronously in order to handle
+    // backpressure from the kernel buffer.
+    const buffer = typeof data === 'string'
+      ? Buffer.from(data, this._encoding)
+      : Buffer.from(data);
+
+    if (buffer.byteLength !== 0) {
+      this._writeQueue.push({ buffer, offset: 0 });
+      if (this._writeQueue.length === 1) {
+        this._processWriteQueue();
+      }
+    }
+  }
+
+  private _processWriteQueue(): void {
+    this._writeImmediate = undefined;
+
+    if (this._writeQueue.length === 0) {
+      return;
+    }
+
+    const task = this._writeQueue[0];
+
+    // Write to the underlying file descriptor and handle it directly, rather
+    // than using the `net.Socket`/`tty.WriteStream` wrappers which swallow and
+    // mask errors like EAGAIN and can cause the thread to block indefinitely.
+    fs.write(this._fd, task.buffer, task.offset, (err, written) => {
+      if (err) {
+        if ('code' in err && err.code === 'EAGAIN') {
+          // `setImmediate` is used to yield to the event loop and re-attempt
+          // the write later.
+          this._writeImmediate = setImmediate(() => this._processWriteQueue());
+        } else {
+          // Stop processing immediately on unexpected error and log
+          this._writeQueue.length = 0;
+          console.error('Unhandled pty write error', err);
+        }
+        return;
+      }
+
+      task.offset += written;
+      if (task.offset >= task.buffer.byteLength) {
+        this._writeQueue.shift();
+      }
+
+      // Since there is more room in the kernel buffer, we can continue to write
+      // until we hit EAGAIN or exhaust the queue.
+      //
+      // Note that old versions of bash, like v3.2 which ships in macOS, appears
+      // to have a bug in its readline implementation that causes data
+      // corruption when writes to the pty happens too quickly. Instead of
+      // trying to workaround that we just accept it so that large pastes are as
+      // fast as possible.
+      // Context: https://github.com/microsoft/node-pty/issues/833
+      this._processWriteQueue();
+    });
   }
 }

package/src/utils.ts

@@ -7,3 +7,23 @@ export function assign(target: any, ...sources: any[]): any {
   sources.forEach(source => Object.keys(source).forEach(key => target[key] = source[key]));
   return target;
 }
+
+
+export function loadNativeModule(name: string): {dir: string, module: any} {
+  // Check build, debug, and then prebuilds.
+  const dirs = ['build/Release', 'build/Debug', `prebuilds/${process.platform}-${process.arch}`];
+  // Check relative to the parent dir for unbundled and then the current dir for bundled
+  const relative = ['..', '.'];
+  let lastError: unknown;
+  for (const d of dirs) {
+    for (const r of relative) {
+      const dir = `${r}/${d}/`;
+      try {
+        return { dir, module: require(`${dir}/${name}.node`) };
+      } catch (e) {
+        lastError = e;
+      }
+    }
+  }
+  throw new Error(`Failed to load native module: ${name}.node, checked: ${dirs.join(', ')}: ${lastError}`);
+}