@aztec/bb.js 0.0.1-commit.24de95ac → 0.0.1-commit.5476d83

package/dest/node/bb_backends/node/native_shm.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
+import { openSync, closeSync } from 'fs';
 import { findNapiBinary, findPackageRoot } from './platform.js';
 // Import the NAPI module
 // The addon is built to the nodejs_module directory
@@ -16,6 +17,7 @@ catch (err) {
     // Addon not built yet or not available
     addon = null;
 }
+let instanceCounter = 0;
 /**
  * Synchronous shared memory backend that communicates with bb binary via shared memory.
  * Uses NAPI module to interface with shared memory IPC.
@@ -28,38 +30,47 @@ catch (err) {
  * - Handled internally by IpcClient (no manual length prefixes needed)
  */
 export class BarretenbergNativeShmSyncBackend {
-    constructor(process, client) {
+    process;
+    client; // NAPI MsgpackClient instance
+    logFd; // File descriptor for logs
+    constructor(process, client, logFd) {
         this.process = process;
         this.client = client;
+        this.logFd = logFd;
     }
     /**
      * Create and initialize a shared memory backend.
      * @param bbBinaryPath Path to bb binary
      * @param threads Optional number of threads
-     * @param maxClients Optional maximum concurrent clients (default: 1)
      */
-    static async new(bbBinaryPath, threads, maxClients) {
+    static async new(bbBinaryPath, threads, logger) {
         if (!addon || !addon.MsgpackClient) {
             throw new Error('Shared memory NAPI not available.');
         }
         // Create a unique shared memory name
-        const shmName = `bb-${process.pid}-${Date.now()}`;
-        // Default maxClients to 1 if not specified
-        const clientCount = maxClients ?? 1;
-        // Set HARDWARE_CONCURRENCY if threads specified
-        const env = threads !== undefined ? { ...process.env, HARDWARE_CONCURRENCY: threads.toString() } : process.env;
-        // Spawn bb process with shared memory mode
-        const args = [bbBinaryPath, 'msgpack', 'run', '--input', `${shmName}.shm`, '--max-clients', clientCount.toString()];
-        const bbProcess = spawn(findPackageRoot() + '/scripts/kill_wrapper.sh', args, {
-            stdio: ['ignore', 'ignore', 'ignore'],
+        const shmName = `bb-sync-${process.pid}-${instanceCounter++}`;
+        // If threads not set use 1 thread. We're not expected to do long lived work on sync backends.
+        const hwc = threads ? threads.toString() : '1';
+        const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
+        // Set up file logging if logger is provided.
+        // Direct file redirection bypasses Node event loop - logs are written even if process hangs.
+        let logFd;
+        let logPath;
+        if (logger) {
+            logPath = `/tmp/${shmName}.log`;
+            logFd = openSync(logPath, 'w');
+            logger(`BB process logs redirected to: ${logPath}`);
+        }
+        // Spawn bb process with shared memory mode (SPSC-only, no max-clients needed)
+        const args = ['msgpack', 'run', '--input', `${shmName}.shm`, '--request-ring-size', `${1024 * 1024 * 4}`];
+        const bbProcess = spawn(bbBinaryPath, args, {
+            stdio: ['ignore', logFd ?? 'ignore', logFd ?? 'ignore'],
             env,
         });
-        // Disconnect from event loop so process can exit. The kill wrapper will reap bb once parent (node) dies.
+        // Disconnect from event loop so process can exit without waiting for bb
+        // The bb process has parent death monitoring (prctl on Linux, kqueue on macOS)
+        // so it will automatically exit when Node.js exits
         bbProcess.unref();
-        // Capture stderr for error diagnostics
-        // bbProcess.stderr?.on('data', (data: Buffer) => {
-        //   stderrOutput += data.toString();
-        // });
         // Track if process has exited
         let processExited = false;
         let exitError = null;
@@ -93,8 +104,8 @@ export class BarretenbergNativeShmSyncBackend {
                     await new Promise(resolve => setTimeout(resolve, retryInterval));
                 }
                 try {
-                    // Create NAPI client with matching max_clients value
-                    client = new addon.MsgpackClient(shmName, clientCount);
+                    // Create NAPI client (SPSC-only, no max_clients needed)
+                    client = new addon.MsgpackClient(shmName);
                     break; // Success!
                 }
                 catch (err) {
@@ -111,13 +122,21 @@ export class BarretenbergNativeShmSyncBackend {
             if (!client) {
                 throw new Error('Failed to create client connection');
             }
-            return new BarretenbergNativeShmSyncBackend(bbProcess, client);
+            return new BarretenbergNativeShmSyncBackend(bbProcess, client, logFd);
         }
         finally {
-            // If we failed to connect, ensure the process is killed
+            // If we failed to connect, ensure the process is killed and log file closed
             // kill() returns false if process already exited, but doesn't throw
             if (!client) {
                 bbProcess.kill('SIGKILL');
+                if (logFd !== undefined) {
+                    try {
+                        closeSync(logFd);
+                    }
+                    catch (e) {
+                        // Ignore errors during cleanup
+                    }
+                }
             }
         }
     }
@@ -139,6 +158,14 @@ export class BarretenbergNativeShmSyncBackend {
                 // Ignore errors during cleanup
             }
         }
+        if (this.logFd !== undefined) {
+            try {
+                closeSync(this.logFd);
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
     }
     destroy() {
         this.cleanup();
@@ -147,4 +174,4 @@ export class BarretenbergNativeShmSyncBackend {
         this.process.removeAllListeners();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL25hdGl2ZV9zaG0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUN2QyxPQUFPLEVBQUUsS0FBSyxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxNQUFNLElBQUksQ0FBQztBQUV6QyxPQUFPLEVBQUUsY0FBYyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVoRSx5QkFBeUI7QUFDekIsb0RBQW9EO0FBQ3BELE1BQU0sU0FBUyxHQUFHLGNBQWMsRUFBRSxDQUFDO0FBQ25DLG1GQUFtRjtBQUNuRixJQUFJLEtBQUssR0FBUSxJQUFJLENBQUM7QUFDdEIsSUFBSSxDQUFDO0lBQ0gsSUFBSSxTQUFTLEVBQUUsQ0FBQztRQUNkLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyxlQUFlLEVBQUcsQ0FBQyxDQUFDO1FBQ2xELEtBQUssR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDN0IsQ0FBQztBQUNILENBQUM7QUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO0lBQ2IsdUNBQXVDO0lBQ3ZDLEtBQUssR0FBRyxJQUFJLENBQUM7QUFDZixDQUFDO0FBRUQsSUFBSSxlQUFlLEdBQUcsQ0FBQyxDQUFDO0FBRXhCOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE9BQU8sZ0NBQWdDO0lBQ25DLE9BQU8sQ0FBZTtJQUN0QixNQUFNLENBQU0sQ0FBQyw4QkFBOEI7SUFDM0MsS0FBSyxDQUFVLENBQUMsMkJBQTJCO0lBRW5ELFlBQW9CLE9BQXFCLEVBQUUsTUFBVyxFQUFFLEtBQWMsRUFBRTtRQUN0RSxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUFBLENBQ3BCO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUNkLFlBQW9CLEVBQ3BCLE9BQWdCLEVBQ2hCLE1BQThCLEVBQ2E7UUFDM0MsSUFBSSxDQUFDLEtBQUssSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLEVBQUUsQ0FBQztZQUNuQyxNQUFNLElBQUksS0FBSyxDQUFDLG1DQUFtQyxDQUFDLENBQUM7UUFDdkQsQ0FBQztRQUVELHFDQUFxQztRQUNyQyxNQUFNLE9BQU8sR0FBRyxXQUFXLE9BQU8sQ0FBQyxHQUFHLElBQUksZUFBZSxFQUFFLEVBQUUsQ0FBQztRQUU5RCw4RkFBOEY7UUFDOUYsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztRQUMvQyxNQUFNLEdBQUcsR0FBRyxFQUFFLEdBQUcsT0FBTyxDQUFDLEdBQUcsRUFBRSxvQkFBb0IsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUUxRCw2Q0FBNkM7UUFDN0MsNkZBQTZGO1FBQzdGLElBQUksS0FBeUIsQ0FBQztRQUM5QixJQUFJLE9BQTJCLENBQUM7UUFDaEMsSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUNYLE9BQU8sR0FBRyxRQUFRLE9BQU8sTUFBTSxDQUFDO1lBQ2hDLEtBQUssR0FBRyxRQUFRLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQy9CLE1BQU0sQ0FBQyxrQ0FBa0MsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUN0RCxDQUFDO1FBRUQsOEVBQThFO1FBQzlFLE1BQU0sSUFBSSxHQUFHLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsR0FBRyxPQUFPLE1BQU0sRUFBRSxxQkFBcUIsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUMxRyxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsWUFBWSxFQUFFLElBQUksRUFBRTtZQUMxQyxLQUFLLEVBQUUsQ0FBQyxRQUFRLEVBQUUsS0FBSyxJQUFJLFFBQVEsRUFBRSxLQUFLLElBQUksUUFBUSxDQUFDO1lBQ3ZELEdBQUc7U0FDSixDQUFDLENBQUM7UUFFSCx3RUFBd0U7UUFDeEUsK0VBQStFO1FBQy9FLG1EQUFtRDtRQUNuRCxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFbEIsOEJBQThCO1FBQzlCLElBQUksYUFBYSxHQUFHLEtBQUssQ0FBQztRQUMxQixJQUFJLFNBQVMsR0FBaUIsSUFBSSxDQUFDO1FBRW5DLFNBQVMsQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDM0IsYUFBYSxHQUFHLElBQUksQ0FBQztZQUNyQixTQUFTLEdBQUcsSUFBSSxLQUFLLENBQUMsaUNBQWlDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQUEsQ0FDdkUsQ0FBQyxDQUFDO1FBRUgsU0FBUyxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQztZQUNyQyxhQUFhLEdBQUcsSUFBSSxDQUFDO1lBQ3JCLElBQUksSUFBSSxLQUFLLElBQUksSUFBSSxJQUFJLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ2hDLFNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQywyQ0FBMkMsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMzRSxDQUFDO2lCQUFNLElBQUksTUFBTSxJQUFJLE1BQU0sS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDMUMsU0FBUyxHQUFHLElBQUksS0FBSyxDQUFDLDZDQUE2QyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1lBQy9FLENBQUM7UUFBQSxDQUNGLENBQUMsQ0FBQztRQUVILHNDQUFzQztRQUN0QyxtREFBbUQ7UUFDbkQsTUFBTSxhQUFhLEdBQUcsR0FBRyxDQUFDLENBQUMsS0FBSztRQUNoQyxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsQ0FBQyxLQUFLO1FBQzNCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxHQUFHLGFBQWEsQ0FBQyxDQUFDO1FBQ3hELElBQUksTUFBTSxHQUFRLElBQUksQ0FBQztRQUV2QixJQUFJLENBQUM7WUFDSCxLQUFLLElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxPQUFPLEdBQUcsV0FBVyxFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUM7Z0JBQ3ZELDhEQUE4RDtnQkFDOUQsSUFBSSxhQUFhLEVBQUUsQ0FBQztvQkFDbEIsTUFBTSxTQUFTLElBQUksSUFBSSxLQUFLLENBQUMsMkRBQTJELENBQUMsQ0FBQztnQkFDNUYsQ0FBQztnQkFFRCwyREFBMkQ7Z0JBQzNELElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxDQUFDO29CQUNoQixNQUFNLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDO2dCQUNuRSxDQUFDO2dCQUVELElBQUksQ0FBQztvQkFDSCx3REFBd0Q7b0JBQ3hELE1BQU0sR0FBRyxJQUFJLEtBQUssQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLENBQUM7b0JBQzFDLE1BQU0sQ0FBQyxXQUFXO2dCQUNwQixDQUFDO2dCQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7b0JBQ2xCLGdDQUFnQztvQkFDaEMsSUFBSSxPQUFPLEtBQUssV0FBVyxHQUFHLENBQUMsRUFBRSxDQUFDO3dCQUNoQyw4REFBOEQ7d0JBQzlELElBQUksYUFBYSxJQUFJLFNBQVMsRUFBRSxDQUFDOzRCQUMvQixNQUFNLFNBQVMsQ0FBQzt3QkFDbEIsQ0FBQzt3QkFDRCxNQUFNLElBQUksS0FBSyxDQUFDLDRDQUE0QyxPQUFPLE9BQU8sR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7b0JBQzNGLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7WUFFRCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDO1lBQ3hELENBQUM7WUFFRCxPQUFPLElBQUksZ0NBQWdDLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztRQUN4RSxDQUFDO2dCQUFTLENBQUM7WUFDVCw0RUFBNEU7WUFDNUUsb0VBQW9FO1lBQ3BFLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDWixTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO2dCQUMxQixJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztvQkFDeEIsSUFBSSxDQUFDO3dCQUNILFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztvQkFDbkIsQ0FBQztvQkFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO3dCQUNYLCtCQUErQjtvQkFDakMsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7SUFBQSxDQUNGO0lBRUQsSUFBSSxDQUFDLFdBQXVCLEVBQWM7UUFDeEMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1lBQ2xFLE9BQU8sSUFBSSxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDeEMsQ0FBQztRQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7WUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDL0QsQ0FBQztJQUFBLENBQ0Y7SUFFTyxPQUFPLEdBQVM7UUFDdEIsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDO2dCQUNILElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDdEIsQ0FBQztZQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQ1gsK0JBQStCO1lBQ2pDLENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQztnQkFDSCxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3hCLENBQUM7WUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO2dCQUNYLCtCQUErQjtZQUNqQyxDQUFDO1FBQ0gsQ0FBQztJQUFBLENBQ0Y7SUFFRCxPQUFPLEdBQVM7UUFDZCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDZixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUM3QixvREFBb0Q7UUFDcEQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO0lBQUEsQ0FDbkM7Q0FDRiJ9

package/dest/node/bb_backends/node/native_shm_async.d.ts

@@ -0,0 +1,51 @@
+import { IMsgpackBackendAsync } from '../interface.js';
+/**
+ * Asynchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module with background thread polling for async operations.
+ * Supports request pipelining - multiple requests can be in flight simultaneously.
+ *
+ * Architecture (matches socket backend pattern):
+ * - bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper (MsgpackClientAsync)
+ * - TypeScript manages promise queue (single-threaded, no mutex needed)
+ * - C++ background thread polls for responses, calls JavaScript callback
+ * - JavaScript callback pops queue and resolves promises in FIFO order
+ */
+export declare class BarretenbergNativeShmAsyncBackend implements IMsgpackBackendAsync {
+    private process;
+    private client;
+    private logFd?;
+    private pendingCallbacks;
+    private constructor();
+    /**
+     * Handle response from C++ background thread
+     * Dequeues the next pending callback and resolves it (FIFO order)
+     */
+    private handleResponse;
+    /**
+     * Create and initialize an async shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param threads Optional number of threads (defaults to min(32, num_cpus))
+     * @param logger Optional logger function for bb output
+     */
+    static new(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void): Promise<BarretenbergNativeShmAsyncBackend>;
+    /**
+     * Send a msgpack request asynchronously.
+     * Supports pipelining - can be called multiple times before awaiting responses.
+     * Use Promise.all() to send multiple requests concurrently.
+     *
+     * Example:
+     *   const results = await Promise.all([
+     *     backend.call(buf1),
+     *     backend.call(buf2),
+     *     backend.call(buf3)
+     *   ]);
+     *
+     * @param inputBuffer The msgpack-encoded request
+     * @returns Promise resolving to msgpack-encoded response
+     */
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobV9hc3luYy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NobV9hc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQW9CdkQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEsaUNBQWtDLFlBQVcsb0JBQW9CO0lBQzVFLE9BQU8sQ0FBQyxPQUFPLENBQWU7SUFDOUIsT0FBTyxDQUFDLE1BQU0sQ0FBTTtJQUNwQixPQUFPLENBQUMsS0FBSyxDQUFDLENBQVM7SUFJdkIsT0FBTyxDQUFDLGdCQUFnQixDQUdoQjtJQUVSLE9BQU8sZUFVTjtJQUVEOzs7T0FHRztJQUNILE9BQU8sQ0FBQyxjQUFjO0lBZ0J0Qjs7Ozs7T0FLRztJQUNILE9BQWEsR0FBRyxDQUNkLFlBQVksRUFBRSxNQUFNLEVBQ3BCLE9BQU8sQ0FBQyxFQUFFLE1BQU0sRUFDaEIsTUFBTSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxLQUFLLElBQUksR0FDN0IsT0FBTyxDQUFDLGlDQUFpQyxDQUFDLENBbUg1QztJQUVEOzs7Ozs7Ozs7Ozs7OztPQWNHO0lBQ0csSUFBSSxDQUFDLFdBQVcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQTBCdkQ7SUFFSyxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQWM3QjtDQUNGIn0=

package/dest/node/bb_backends/node/native_shm_async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native_shm_async.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_shm_async.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAoBvD;;;;;;;;;;;;GAYG;AACH,qBAAa,iCAAkC,YAAW,oBAAoB;IAC5E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAC,CAAS;IAIvB,OAAO,CAAC,gBAAgB,CAGhB;IAER,OAAO,eAUN;IAED;;;OAGG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;OAKG;IACH,OAAa,GAAG,CACd,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,OAAO,CAAC,iCAAiC,CAAC,CAmH5C;IAED;;;;;;;;;;;;;;OAcG;IACG,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BvD;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAc7B;CACF"}

package/dest/node/bb_backends/node/native_shm_async.js

@@ -0,0 +1,237 @@
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+import { openSync, closeSync } from 'fs';
+import { findNapiBinary, findPackageRoot } from './platform.js';
+// Import the NAPI module
+// The addon is built to the nodejs_module directory
+const addonPath = findNapiBinary();
+// Try loading, but don't throw if it doesn't exist (will be caught in constructor)
+let addon = null;
+try {
+    if (addonPath) {
+        const require = createRequire(findPackageRoot());
+        addon = require(addonPath);
+    }
+}
+catch (err) {
+    // Addon not built yet or not available
+    addon = null;
+}
+let instanceCounter = 0;
+/**
+ * Asynchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module with background thread polling for async operations.
+ * Supports request pipelining - multiple requests can be in flight simultaneously.
+ *
+ * Architecture (matches socket backend pattern):
+ * - bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper (MsgpackClientAsync)
+ * - TypeScript manages promise queue (single-threaded, no mutex needed)
+ * - C++ background thread polls for responses, calls JavaScript callback
+ * - JavaScript callback pops queue and resolves promises in FIFO order
+ */
+export class BarretenbergNativeShmAsyncBackend {
+    process;
+    client; // NAPI MsgpackClientAsync instance
+    logFd; // File descriptor for logs
+    // Queue of pending callbacks for pipelined requests
+    // Responses come back in FIFO order, so we match them with queued callbacks
+    pendingCallbacks = [];
+    constructor(process, client, logFd) {
+        this.process = process;
+        this.client = client;
+        this.logFd = logFd;
+        // Register our response handler with the C++ client
+        // This callback will be invoked from the background thread via ThreadSafeFunction
+        this.client.setResponseCallback((responseBuffer) => {
+            this.handleResponse(responseBuffer);
+        });
+    }
+    /**
+     * Handle response from C++ background thread
+     * Dequeues the next pending callback and resolves it (FIFO order)
+     */
+    handleResponse(responseBuffer) {
+        // Response is complete - dequeue the next pending callback (FIFO)
+        const callback = this.pendingCallbacks.shift();
+        if (callback) {
+            callback.resolve(new Uint8Array(responseBuffer));
+        }
+        else {
+            // This shouldn't happen - response without a pending request
+            console.warn('Received response but no pending callback');
+        }
+        // If no more pending callbacks, release ref to allow process to exit
+        if (this.pendingCallbacks.length === 0) {
+            this.client.release();
+        }
+    }
+    /**
+     * Create and initialize an async shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param threads Optional number of threads (defaults to min(32, num_cpus))
+     * @param logger Optional logger function for bb output
+     */
+    static async new(bbBinaryPath, threads, logger) {
+        if (!addon || !addon.MsgpackClientAsync) {
+            throw new Error('Shared memory async NAPI not available.');
+        }
+        // Create a unique shared memory name
+        const shmName = `bb-async-${process.pid}-${instanceCounter++}`;
+        // If threads not set use num cpu cores, max 32 (same as socket backend)
+        const hwc = threads ? threads.toString() : '1';
+        const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
+        // Set up file logging if logger is provided
+        // Direct file redirection bypasses Node event loop - logs are written even if process hangs
+        let logFd;
+        let logPath;
+        if (logger) {
+            logPath = `/tmp/${shmName}.log`;
+            logFd = openSync(logPath, 'w');
+            logger(`BB process logs redirected to: ${logPath}`);
+        }
+        // Spawn bb process with shared memory mode
+        // Use larger ring buffers for async mode to support pipelining
+        const args = [
+            'msgpack',
+            'run',
+            '--input',
+            `${shmName}.shm`,
+            '--request-ring-size',
+            `${1024 * 1024 * 4}`,
+            '--response-ring-size',
+            `${1024 * 1024 * 4}`,
+        ];
+        const bbProcess = spawn(bbBinaryPath, args, {
+            stdio: ['ignore', logFd ?? 'ignore', logFd ?? 'ignore'],
+            env,
+        });
+        // Disconnect from event loop so process can exit without waiting for bb
+        // The bb process has parent death monitoring (prctl on Linux, kqueue on macOS)
+        // so it will automatically exit when Node.js exits
+        bbProcess.unref();
+        // Track if process has exited
+        let processExited = false;
+        let exitError = null;
+        bbProcess.on('error', err => {
+            processExited = true;
+            exitError = new Error(`Native backend process error: ${err.message}`);
+        });
+        bbProcess.on('exit', (code, signal) => {
+            processExited = true;
+            if (code !== null && code !== 0) {
+                exitError = new Error(`Native backend process exited with code ${code}`);
+            }
+            else if (signal && signal !== 'SIGTERM') {
+                exitError = new Error(`Native backend process killed with signal ${signal}`);
+            }
+        });
+        // Wait for bb to create shared memory
+        // Retry connection every 100ms for up to 5 seconds (longer than sync for thread startup)
+        const retryInterval = 100; // ms
+        const timeout = 5000; // ms
+        const maxAttempts = Math.floor(timeout / retryInterval);
+        let client = null;
+        try {
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                // Check if bb process has exited before attempting connection
+                if (processExited) {
+                    throw exitError || new Error('Native backend process exited unexpectedly during startup');
+                }
+                // Wait before attempting connection (except first attempt)
+                if (attempt > 0) {
+                    await new Promise(resolve => setTimeout(resolve, retryInterval));
+                }
+                try {
+                    // Create NAPI async client
+                    client = new addon.MsgpackClientAsync(shmName);
+                    break; // Success!
+                }
+                catch (err) {
+                    // Connection failed, will retry
+                    if (attempt === maxAttempts - 1) {
+                        // Last attempt failed - check one more time if process exited
+                        if (processExited && exitError) {
+                            throw exitError;
+                        }
+                        throw new Error(`Failed to connect to shared memory after ${timeout}ms: ${err.message}`);
+                    }
+                }
+            }
+            if (!client) {
+                throw new Error('Failed to create client connection');
+            }
+            return new BarretenbergNativeShmAsyncBackend(bbProcess, client, logFd);
+        }
+        finally {
+            // If we failed to connect, ensure the process is killed and log file closed
+            if (!client) {
+                bbProcess.kill('SIGKILL');
+                if (logFd !== undefined) {
+                    try {
+                        closeSync(logFd);
+                    }
+                    catch (e) {
+                        // Ignore errors during cleanup
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Send a msgpack request asynchronously.
+     * Supports pipelining - can be called multiple times before awaiting responses.
+     * Use Promise.all() to send multiple requests concurrently.
+     *
+     * Example:
+     *   const results = await Promise.all([
+     *     backend.call(buf1),
+     *     backend.call(buf2),
+     *     backend.call(buf3)
+     *   ]);
+     *
+     * @param inputBuffer The msgpack-encoded request
+     * @returns Promise resolving to msgpack-encoded response
+     */
+    async call(inputBuffer) {
+        return new Promise((resolve, reject) => {
+            // If this is the first pending callback, acquire ref to keep event loop alive
+            if (this.pendingCallbacks.length === 0) {
+                this.client.acquire();
+            }
+            // Enqueue this promise's callbacks (FIFO order)
+            this.pendingCallbacks.push({ resolve, reject });
+            try {
+                // Send request to shared memory (synchronous write)
+                // C++ call() no longer returns a promise - we manage them here
+                this.client.call(Buffer.from(inputBuffer));
+            }
+            catch (err) {
+                // Send failed - dequeue the callback we just added and reject
+                this.pendingCallbacks.pop();
+                // If queue is now empty, release ref to allow exit
+                if (this.pendingCallbacks.length === 0) {
+                    this.client.release();
+                }
+                reject(new Error(`Shared memory async call failed: ${err.message}`));
+            }
+        });
+    }
+    async destroy() {
+        // Kill the bb process
+        // Background thread and callbacks will be cleaned up by OS on process exit
+        this.process.kill('SIGTERM');
+        this.process.removeAllListeners();
+        // Close log file if open
+        if (this.logFd !== undefined) {
+            try {
+                closeSync(this.logFd);
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node/bb_backends/node/native_socket.d.ts

@@ -24,11 +24,11 @@ export declare class BarretenbergNativeSocketAsyncBackend implements IMsgpackBac
     private responseLength;
     private responseBuffer;
     private responseBytesRead;
-    constructor(bbBinaryPath: string, threads?: number);
+    constructor(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void);
     private waitForSocketAndConnect;
     private handleData;
     call(inputBuffer: Uint8Array): Promise<Uint8Array>;
     private cleanup;
     destroy(): Promise<void>;
 }
-//# sourceMappingURL=native_socket.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NvY2tldC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NvY2tldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUl2RDs7Ozs7Ozs7Ozs7R0FXRztBQUNILHFCQUFhLG9DQUFxQyxZQUFXLG9CQUFvQjtJQUMvRSxPQUFPLENBQUMsT0FBTyxDQUFlO0lBQzlCLE9BQU8sQ0FBQyxNQUFNLENBQTJCO0lBQ3pDLE9BQU8sQ0FBQyxVQUFVLENBQVM7SUFDM0IsT0FBTyxDQUFDLGlCQUFpQixDQUFnQjtJQUN6QyxPQUFPLENBQUMsaUJBQWlCLENBQStCO0lBSXhELE9BQU8sQ0FBQyxnQkFBZ0IsQ0FHaEI7SUFHUixPQUFPLENBQUMsYUFBYSxDQUFpQjtJQUN0QyxPQUFPLENBQUMsWUFBWSxDQUEyQjtJQUMvQyxPQUFPLENBQUMsZUFBZSxDQUFhO0lBQ3BDLE9BQU8sQ0FBQyxjQUFjLENBQWE7SUFDbkMsT0FBTyxDQUFDLGNBQWMsQ0FBdUI7SUFDN0MsT0FBTyxDQUFDLGlCQUFpQixDQUFhO0lBRXRDLFlBQVksWUFBWSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxLQUFLLElBQUksRUFvR2pGO1lBRWEsdUJBQXVCO0lBaUVyQyxPQUFPLENBQUMsVUFBVTtJQW1EWixJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBd0J2RDtJQUVELE9BQU8sQ0FBQyxPQUFPO0lBaUNULE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTdCO0NBQ0YifQ==

package/dest/node/bb_backends/node/native_socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native_socket.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_socket.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAGvD;;;;;;;;;;;GAWG;AACH,qBAAa,oCAAqC,YAAW,oBAAoB;IAC/E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,iBAAiB,CAA+B;IAIxD,OAAO,CAAC,gBAAgB,CAGhB;IAGR,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,iBAAiB,CAAa;gBAE1B,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;YA4FpC,uBAAuB;IAiErC,OAAO,CAAC,UAAU;IA8CZ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBxD,OAAO,CAAC,OAAO;IAiCT,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAY/B"}
+{"version":3,"file":"native_socket.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_socket.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAIvD;;;;;;;;;;;GAWG;AACH,qBAAa,oCAAqC,YAAW,oBAAoB;IAC/E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,iBAAiB,CAA+B;IAIxD,OAAO,CAAC,gBAAgB,CAGhB;IAGR,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,iBAAiB,CAAa;IAEtC,YAAY,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAoGjF;YAEa,uBAAuB;IAiErC,OAAO,CAAC,UAAU;IAmDZ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAwBvD;IAED,OAAO,CAAC,OAAO;IAiCT,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAI7B;CACF"}