@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.0208eb9

package/dest/node/bb_backends/node/native_pipe.js

@@ -0,0 +1,114 @@
+import { spawn } from 'child_process';
+/**
+ * Asynchronous native backend that communicates with bb binary via stdin/stdout.
+ * Uses event-based I/O with a state machine to handle partial reads.
+ *
+ * Protocol:
+ * - Request: 4-byte little-endian length + msgpack buffer
+ * - Response: 4-byte little-endian length + msgpack buffer
+ */
+export class BarretenbergNativePipeAsyncBackend {
+    process;
+    pendingResolve = null;
+    pendingReject = null;
+    // State machine for reading responses
+    readingLength = true;
+    lengthBuffer = Buffer.alloc(4);
+    lengthBytesRead = 0;
+    responseLength = 0;
+    responseBuffer = null;
+    responseBytesRead = 0;
+    constructor(bbBinaryPath) {
+        this.process = spawn(bbBinaryPath, ['msgpack', 'run'], {
+            stdio: ['pipe', 'pipe', 'inherit'],
+        });
+        this.process.stdout.on('data', (chunk) => {
+            this.handleData(chunk);
+        });
+        this.process.on('error', err => {
+            if (this.pendingReject) {
+                this.pendingReject(new Error(`Native backend process error: ${err.message}`));
+                this.pendingReject = null;
+                this.pendingResolve = null;
+            }
+        });
+        this.process.on('exit', (code, signal) => {
+            if (this.pendingReject) {
+                if (code !== null && code !== 0) {
+                    this.pendingReject(new Error(`Native backend process exited with code ${code}`));
+                }
+                else if (signal) {
+                    if (signal != 'SIGTERM') {
+                        this.pendingReject(new Error(`Native backend process killed with signal ${signal}`));
+                    }
+                }
+                else {
+                    this.pendingReject(new Error('Native backend process exited unexpectedly'));
+                }
+                this.pendingReject = null;
+                this.pendingResolve = null;
+            }
+        });
+    }
+    handleData(chunk) {
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (this.readingLength) {
+                // Reading 4-byte length prefix
+                const bytesToCopy = Math.min(4 - this.lengthBytesRead, chunk.length - offset);
+                chunk.copy(this.lengthBuffer, this.lengthBytesRead, offset, offset + bytesToCopy);
+                this.lengthBytesRead += bytesToCopy;
+                offset += bytesToCopy;
+                if (this.lengthBytesRead === 4) {
+                    // Length is complete, switch to reading data
+                    this.responseLength = this.lengthBuffer.readUInt32LE(0);
+                    this.responseBuffer = Buffer.alloc(this.responseLength);
+                    this.responseBytesRead = 0;
+                    this.readingLength = false;
+                }
+            }
+            else {
+                // Reading response data
+                const bytesToCopy = Math.min(this.responseLength - this.responseBytesRead, chunk.length - offset);
+                chunk.copy(this.responseBuffer, this.responseBytesRead, offset, offset + bytesToCopy);
+                this.responseBytesRead += bytesToCopy;
+                offset += bytesToCopy;
+                if (this.responseBytesRead === this.responseLength) {
+                    // Response is complete
+                    if (this.pendingResolve) {
+                        this.pendingResolve(new Uint8Array(this.responseBuffer));
+                        this.pendingResolve = null;
+                        this.pendingReject = null;
+                    }
+                    // Reset state for next message
+                    this.readingLength = true;
+                    this.lengthBytesRead = 0;
+                    this.responseLength = 0;
+                    this.responseBuffer = null;
+                    this.responseBytesRead = 0;
+                }
+            }
+        }
+    }
+    async call(inputBuffer) {
+        if (this.pendingResolve) {
+            throw new Error('Cannot call while another call is pending (no pipelining supported)');
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingResolve = resolve;
+            this.pendingReject = reject;
+            // Write request: 4-byte little-endian length + msgpack data
+            const lengthBuf = Buffer.alloc(4);
+            lengthBuf.writeUInt32LE(inputBuffer.length, 0);
+            this.process.stdin.write(lengthBuf);
+            this.process.stdin.write(inputBuffer);
+        });
+    }
+    async destroy() {
+        this.process.kill();
+        return new Promise(resolve => {
+            this.process.once('exit', () => resolve());
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3BpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYmJfYmFja2VuZHMvbm9kZS9uYXRpdmVfcGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUlwRDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxPQUFPLGtDQUFrQztJQUNyQyxPQUFPLENBQWU7SUFDdEIsY0FBYyxHQUF3QyxJQUFJLENBQUM7SUFDM0QsYUFBYSxHQUFvQyxJQUFJLENBQUM7SUFFOUQsc0NBQXNDO0lBQzlCLGFBQWEsR0FBWSxJQUFJLENBQUM7SUFDOUIsWUFBWSxHQUFXLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkMsZUFBZSxHQUFXLENBQUMsQ0FBQztJQUM1QixjQUFjLEdBQVcsQ0FBQyxDQUFDO0lBQzNCLGNBQWMsR0FBa0IsSUFBSSxDQUFDO0lBQ3JDLGlCQUFpQixHQUFXLENBQUMsQ0FBQztJQUV0QyxZQUFZLFlBQW9CLEVBQUU7UUFDaEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUMsWUFBWSxFQUFFLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxFQUFFO1lBQ3JELEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsU0FBUyxDQUFDO1NBQ25DLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTyxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxLQUFhLEVBQUUsRUFBRSxDQUFDO1lBQ2pELElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7UUFBQSxDQUN4QixDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUM5QixJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztnQkFDdkIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQztnQkFDOUUsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7Z0JBQzFCLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDO1lBQzdCLENBQUM7UUFBQSxDQUNGLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDO1lBQ3hDLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO2dCQUN2QixJQUFJLElBQUksS0FBSyxJQUFJLElBQUksSUFBSSxLQUFLLENBQUMsRUFBRSxDQUFDO29CQUNoQyxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksS0FBSyxDQUFDLDJDQUEyQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7Z0JBQ25GLENBQUM7cUJBQU0sSUFBSSxNQUFNLEVBQUUsQ0FBQztvQkFDbEIsSUFBSSxNQUFNLElBQUksU0FBUyxFQUFFLENBQUM7d0JBQ3hCLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxLQUFLLENBQUMsNkNBQTZDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQztvQkFDdkYsQ0FBQztnQkFDSCxDQUFDO3FCQUFNLENBQUM7b0JBQ04sSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLEtBQUssQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDLENBQUM7Z0JBQzlFLENBQUM7Z0JBQ0QsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7Z0JBQzFCLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDO1lBQzdCLENBQUM7UUFBQSxDQUNGLENBQUMsQ0FBQztJQUFBLENBQ0o7SUFFTyxVQUFVLENBQUMsS0FBYSxFQUFRO1FBQ3RDLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQztRQUVmLE9BQU8sTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUM3QixJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztnQkFDdkIsK0JBQStCO2dCQUMvQixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsZUFBZSxFQUFFLEtBQUssQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDLENBQUM7Z0JBQzlFLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsZUFBZSxFQUFFLE1BQU0sRUFBRSxNQUFNLEdBQUcsV0FBVyxDQUFDLENBQUM7Z0JBQ2xGLElBQUksQ0FBQyxlQUFlLElBQUksV0FBVyxDQUFDO2dCQUNwQyxNQUFNLElBQUksV0FBVyxDQUFDO2dCQUV0QixJQUFJLElBQUksQ0FBQyxlQUFlLEtBQUssQ0FBQyxFQUFFLENBQUM7b0JBQy9CLDZDQUE2QztvQkFDN0MsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztvQkFDeEQsSUFBSSxDQUFDLGNBQWMsR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztvQkFDeEQsSUFBSSxDQUFDLGlCQUFpQixHQUFHLENBQUMsQ0FBQztvQkFDM0IsSUFBSSxDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUM7Z0JBQzdCLENBQUM7WUFDSCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sd0JBQXdCO2dCQUN4QixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixFQUFFLEtBQUssQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDLENBQUM7Z0JBQ2xHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWUsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLE1BQU0sR0FBRyxXQUFXLENBQUMsQ0FBQztnQkFDdkYsSUFBSSxDQUFDLGlCQUFpQixJQUFJLFdBQVcsQ0FBQztnQkFDdEMsTUFBTSxJQUFJLFdBQVcsQ0FBQztnQkFFdEIsSUFBSSxJQUFJLENBQUMsaUJBQWlCLEtBQUssSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO29CQUNuRCx1QkFBdUI7b0JBQ3ZCLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO3dCQUN4QixJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksVUFBVSxDQUFDLElBQUksQ0FBQyxjQUFlLENBQUMsQ0FBQyxDQUFDO3dCQUMxRCxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQzt3QkFDM0IsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7b0JBQzVCLENBQUM7b0JBRUQsK0JBQStCO29CQUMvQixJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQztvQkFDMUIsSUFBSSxDQUFDLGVBQWUsR0FBRyxDQUFDLENBQUM7b0JBQ3pCLElBQUksQ0FBQyxjQUFjLEdBQUcsQ0FBQyxDQUFDO29CQUN4QixJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQztvQkFDM0IsSUFBSSxDQUFDLGlCQUFpQixHQUFHLENBQUMsQ0FBQztnQkFDN0IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO0lBQUEsQ0FDRjtJQUVELEtBQUssQ0FBQyxJQUFJLENBQUMsV0FBdUIsRUFBdUI7UUFDdkQsSUFBSSxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxxRUFBcUUsQ0FBQyxDQUFDO1FBQ3pGLENBQUM7UUFFRCxPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLENBQUM7WUFDdEMsSUFBSSxDQUFDLGNBQWMsR0FBRyxPQUFPLENBQUM7WUFDOUIsSUFBSSxDQUFDLGFBQWEsR0FBRyxNQUFNLENBQUM7WUFFNUIsNERBQTREO1lBQzVELE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbEMsU0FBUyxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQy9DLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUNyQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQU0sQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7UUFBQSxDQUN4QyxDQUFDLENBQUM7SUFBQSxDQUNKO0lBRUQsS0FBSyxDQUFDLE9BQU8sR0FBa0I7UUFDN0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNwQixPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDNUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFBQSxDQUM1QyxDQUFDLENBQUM7SUFBQSxDQUNKO0NBQ0YifQ==

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

@@ -0,0 +1,29 @@
+import { IMsgpackBackendSync } from '../interface.js';
+/**
+ * Synchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module to interface with shared memory IPC.
+ *
+ * Architecture: bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper
+ *
+ * Protocol:
+ * - Handled internally by IpcClient (no manual length prefixes needed)
+ */
+export declare class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
+    private process;
+    private client;
+    private logFd?;
+    private constructor();
+    /**
+     * Create and initialize a shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param napiPath Path to NAPI binary
+     * @param threads Optional number of threads
+     */
+    static new(bbBinaryPath: string, napiPath: string, threads?: number, logger?: (msg: string) => void): Promise<BarretenbergNativeShmSyncBackend>;
+    call(inputBuffer: Uint8Array): Uint8Array;
+    private cleanup;
+    destroy(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NobS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQU10RDs7Ozs7Ozs7OztHQVVHO0FBQ0gscUJBQWEsZ0NBQWlDLFlBQVcsbUJBQW1CO0lBQzFFLE9BQU8sQ0FBQyxPQUFPLENBQWU7SUFDOUIsT0FBTyxDQUFDLE1BQU0sQ0FBTTtJQUNwQixPQUFPLENBQUMsS0FBSyxDQUFDLENBQVM7SUFFdkIsT0FBTyxlQUlOO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFhLEdBQUcsQ0FDZCxZQUFZLEVBQUUsTUFBTSxFQUNwQixRQUFRLEVBQUUsTUFBTSxFQUNoQixPQUFPLENBQUMsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sS0FBSyxJQUFJLEdBQzdCLE9BQU8sQ0FBQyxnQ0FBZ0MsQ0FBQyxDQXlJM0M7SUFFRCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLENBT3hDO0lBRUQsT0FBTyxDQUFDLE9BQU87SUFpQmYsT0FBTyxJQUFJLElBQUksQ0FLZDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"native_shm.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_shm.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAMtD;;;;;;;;;;GAUG;AACH,qBAAa,gCAAiC,YAAW,mBAAmB;IAC1E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAC,CAAS;IAEvB,OAAO,eAIN;IAED;;;;;OAKG;IACH,OAAa,GAAG,CACd,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,OAAO,CAAC,gCAAgC,CAAC,CAyI3C;IAED,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAOxC;IAED,OAAO,CAAC,OAAO;IAiBf,OAAO,IAAI,IAAI,CAKd;CACF"}

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

@@ -0,0 +1,196 @@
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+import { openSync, closeSync, unlinkSync } from 'fs';
+import { findNapiBinary, findPackageRoot } from './platform.js';
+import { threadId } from 'worker_threads';
+let instanceCounter = 0;
+/**
+ * Synchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module to interface with shared memory IPC.
+ *
+ * Architecture: bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper
+ *
+ * Protocol:
+ * - Handled internally by IpcClient (no manual length prefixes needed)
+ */
+export class BarretenbergNativeShmSyncBackend {
+    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 napiPath Path to NAPI binary
+     * @param threads Optional number of threads
+     */
+    static async new(bbBinaryPath, napiPath, threads, logger) {
+        // Import the NAPI module
+        // The addon is built to the nodejs_module directory
+        const addonPath = findNapiBinary(napiPath);
+        // Try loading
+        let addon = null;
+        try {
+            const require = createRequire(findPackageRoot());
+            addon = require(addonPath);
+        }
+        catch (err) {
+            // Addon not built yet or not available
+            throw new Error('Shared memory sync NAPI not available.');
+        }
+        // Create a unique shared memory name
+        const shmName = `bb-sync-${process.pid}-${threadId}-${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}`);
+        }
+        // Clean up any stale shared memory files from previous runs
+        // This handles the case where a previous process crashed without cleanup
+        const shmRequestPath = `/dev/shm/${shmName}_request`;
+        const shmResponsePath = `/dev/shm/${shmName}_response`;
+        try {
+            unlinkSync(shmRequestPath);
+        }
+        catch (err) {
+            const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+            if (!isNotFound) {
+                throw new Error(`Failed to clean up stale shared memory file ${shmRequestPath}: ${err}`);
+            }
+        }
+        try {
+            unlinkSync(shmResponsePath);
+        }
+        catch (err) {
+            const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+            if (!isNotFound) {
+                throw new Error(`Failed to clean up stale shared memory file ${shmResponsePath}: ${err}`);
+            }
+        }
+        // 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 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 3 seconds
+        const retryInterval = 100; // ms
+        const timeout = 3000; // 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 client (SPSC-only, no max_clients needed)
+                    client = new addon.MsgpackClient(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 BarretenbergNativeShmSyncBackend(bbProcess, client, logFd);
+        }
+        finally {
+            // 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
+                    }
+                }
+            }
+        }
+    }
+    call(inputBuffer) {
+        try {
+            const responseBuffer = this.client.call(Buffer.from(inputBuffer));
+            return new Uint8Array(responseBuffer);
+        }
+        catch (err) {
+            throw new Error(`Shared memory call failed: ${err.message}`);
+        }
+    }
+    cleanup() {
+        if (this.client) {
+            try {
+                this.client.close();
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+        if (this.logFd !== undefined) {
+            try {
+                closeSync(this.logFd);
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+    }
+    destroy() {
+        this.cleanup();
+        this.process.kill('SIGTERM');
+        // Remove process event listeners to prevent hanging
+        this.process.removeAllListeners();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL25hdGl2ZV9zaG0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUN2QyxPQUFPLEVBQUUsS0FBSyxFQUFnQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFFckQsT0FBTyxFQUFFLGNBQWMsRUFBRSxlQUFlLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDaEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTFDLElBQUksZUFBZSxHQUFHLENBQUMsQ0FBQztBQUV4Qjs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxPQUFPLGdDQUFnQztJQUNuQyxPQUFPLENBQWU7SUFDdEIsTUFBTSxDQUFNLENBQUMsOEJBQThCO0lBQzNDLEtBQUssQ0FBVSxDQUFDLDJCQUEyQjtJQUVuRCxZQUFvQixPQUFxQixFQUFFLE1BQVcsRUFBRSxLQUFjLEVBQUU7UUFDdEUsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFBQSxDQUNwQjtJQUVEOzs7OztPQUtHO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQ2QsWUFBb0IsRUFDcEIsUUFBZ0IsRUFDaEIsT0FBZ0IsRUFDaEIsTUFBOEIsRUFDYTtRQUMzQyx5QkFBeUI7UUFDekIsb0RBQW9EO1FBQ3BELE1BQU0sU0FBUyxHQUFHLGNBQWMsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMzQyxjQUFjO1FBQ2QsSUFBSSxLQUFLLEdBQVEsSUFBSSxDQUFDO1FBQ3RCLElBQUksQ0FBQztZQUNILE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyxlQUFlLEVBQUcsQ0FBQyxDQUFDO1lBQ2xELEtBQUssR0FBRyxPQUFPLENBQUMsU0FBVSxDQUFDLENBQUM7UUFDOUIsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYix1Q0FBdUM7WUFDdkMsTUFBTSxJQUFJLEtBQUssQ0FBQyx3Q0FBd0MsQ0FBQyxDQUFDO1FBQzVELENBQUM7UUFFRCxxQ0FBcUM7UUFDckMsTUFBTSxPQUFPLEdBQUcsV0FBVyxPQUFPLENBQUMsR0FBRyxJQUFJLFFBQVEsSUFBSSxlQUFlLEVBQUUsRUFBRSxDQUFDO1FBRTFFLDhGQUE4RjtRQUM5RixNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQy9DLE1BQU0sR0FBRyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLG9CQUFvQixFQUFFLEdBQUcsRUFBRSxDQUFDO1FBRTFELDZDQUE2QztRQUM3Qyw2RkFBNkY7UUFDN0YsSUFBSSxLQUF5QixDQUFDO1FBQzlCLElBQUksT0FBMkIsQ0FBQztRQUNoQyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsT0FBTyxHQUFHLFFBQVEsT0FBTyxNQUFNLENBQUM7WUFDaEMsS0FBSyxHQUFHLFFBQVEsQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLENBQUM7WUFDL0IsTUFBTSxDQUFDLGtDQUFrQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFFRCw0REFBNEQ7UUFDNUQseUVBQXlFO1FBQ3pFLE1BQU0sY0FBYyxHQUFHLFlBQVksT0FBTyxVQUFVLENBQUM7UUFDckQsTUFBTSxlQUFlLEdBQUcsWUFBWSxPQUFPLFdBQVcsQ0FBQztRQUN2RCxJQUFJLENBQUM7WUFDSCxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDN0IsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixNQUFNLFVBQVUsR0FBRyxHQUFHLElBQUksT0FBTyxHQUFHLEtBQUssUUFBUSxJQUFJLE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxDQUFDLElBQUksS0FBSyxRQUFRLENBQUM7WUFDNUYsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUNoQixNQUFNLElBQUksS0FBSyxDQUFDLCtDQUErQyxjQUFjLEtBQUssR0FBRyxFQUFFLENBQUMsQ0FBQztZQUMzRixDQUFDO1FBQ0gsQ0FBQztRQUVELElBQUksQ0FBQztZQUNILFVBQVUsQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUM5QixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLE1BQU0sVUFBVSxHQUFHLEdBQUcsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLElBQUksTUFBTSxJQUFJLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FBQztZQUM1RixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7Z0JBQ2hCLE1BQU0sSUFBSSxLQUFLLENBQUMsK0NBQStDLGVBQWUsS0FBSyxHQUFHLEVBQUUsQ0FBQyxDQUFDO1lBQzVGLENBQUM7UUFDSCxDQUFDO1FBRUQsOEVBQThFO1FBQzlFLE1BQU0sSUFBSSxHQUFHLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsR0FBRyxPQUFPLE1BQU0sRUFBRSxxQkFBcUIsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUMxRyxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsWUFBWSxFQUFFLElBQUksRUFBRTtZQUMxQyxLQUFLLEVBQUUsQ0FBQyxRQUFRLEVBQUUsS0FBSyxJQUFJLFFBQVEsRUFBRSxLQUFLLElBQUksUUFBUSxDQUFDO1lBQ3ZELEdBQUc7U0FDSixDQUFDLENBQUM7UUFFSCx3RUFBd0U7UUFDeEUsK0VBQStFO1FBQy9FLG1EQUFtRDtRQUNuRCxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFbEIsOEJBQThCO1FBQzlCLElBQUksYUFBYSxHQUFHLEtBQUssQ0FBQztRQUMxQixJQUFJLFNBQVMsR0FBaUIsSUFBSSxDQUFDO1FBRW5DLFNBQVMsQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDM0IsYUFBYSxHQUFHLElBQUksQ0FBQztZQUNyQixTQUFTLEdBQUcsSUFBSSxLQUFLLENBQUMsaUNBQWlDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQUEsQ0FDdkUsQ0FBQyxDQUFDO1FBRUgsU0FBUyxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQztZQUNyQyxhQUFhLEdBQUcsSUFBSSxDQUFDO1lBQ3JCLElBQUksSUFBSSxLQUFLLElBQUksSUFBSSxJQUFJLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ2hDLFNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQywyQ0FBMkMsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMzRSxDQUFDO2lCQUFNLElBQUksTUFBTSxJQUFJLE1BQU0sS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDMUMsU0FBUyxHQUFHLElBQUksS0FBSyxDQUFDLDZDQUE2QyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1lBQy9FLENBQUM7UUFBQSxDQUNGLENBQUMsQ0FBQztRQUVILHNDQUFzQztRQUN0QyxtREFBbUQ7UUFDbkQsTUFBTSxhQUFhLEdBQUcsR0FBRyxDQUFDLENBQUMsS0FBSztRQUNoQyxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsQ0FBQyxLQUFLO1FBQzNCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxHQUFHLGFBQWEsQ0FBQyxDQUFDO1FBQ3hELElBQUksTUFBTSxHQUFRLElBQUksQ0FBQztRQUV2QixJQUFJLENBQUM7WUFDSCxLQUFLLElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxPQUFPLEdBQUcsV0FBVyxFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUM7Z0JBQ3ZELDhEQUE4RDtnQkFDOUQsSUFBSSxhQUFhLEVBQUUsQ0FBQztvQkFDbEIsTUFBTSxTQUFTLElBQUksSUFBSSxLQUFLLENBQUMsMkRBQTJELENBQUMsQ0FBQztnQkFDNUYsQ0FBQztnQkFFRCwyREFBMkQ7Z0JBQzNELElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxDQUFDO29CQUNoQixNQUFNLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDO2dCQUNuRSxDQUFDO2dCQUVELElBQUksQ0FBQztvQkFDSCx3REFBd0Q7b0JBQ3hELE1BQU0sR0FBRyxJQUFJLEtBQUssQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLENBQUM7b0JBQzFDLE1BQU0sQ0FBQyxXQUFXO2dCQUNwQixDQUFDO2dCQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7b0JBQ2xCLGdDQUFnQztvQkFDaEMsSUFBSSxPQUFPLEtBQUssV0FBVyxHQUFHLENBQUMsRUFBRSxDQUFDO3dCQUNoQyw4REFBOEQ7d0JBQzlELElBQUksYUFBYSxJQUFJLFNBQVMsRUFBRSxDQUFDOzRCQUMvQixNQUFNLFNBQVMsQ0FBQzt3QkFDbEIsQ0FBQzt3QkFDRCxNQUFNLElBQUksS0FBSyxDQUFDLDRDQUE0QyxPQUFPLE9BQU8sR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7b0JBQzNGLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7WUFFRCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFDO1lBQ3hELENBQUM7WUFFRCxPQUFPLElBQUksZ0NBQWdDLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztRQUN4RSxDQUFDO2dCQUFTLENBQUM7WUFDVCw0RUFBNEU7WUFDNUUsb0VBQW9FO1lBQ3BFLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDWixTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO2dCQUMxQixJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztvQkFDeEIsSUFBSSxDQUFDO3dCQUNILFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztvQkFDbkIsQ0FBQztvQkFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO3dCQUNYLCtCQUErQjtvQkFDakMsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7SUFBQSxDQUNGO0lBRUQsSUFBSSxDQUFDLFdBQXVCLEVBQWM7UUFDeEMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1lBQ2xFLE9BQU8sSUFBSSxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDeEMsQ0FBQztRQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7WUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDL0QsQ0FBQztJQUFBLENBQ0Y7SUFFTyxPQUFPLEdBQVM7UUFDdEIsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDO2dCQUNILElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDdEIsQ0FBQztZQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQ1gsK0JBQStCO1lBQ2pDLENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQztnQkFDSCxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3hCLENBQUM7WUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO2dCQUNYLCtCQUErQjtZQUNqQyxDQUFDO1FBQ0gsQ0FBQztJQUFBLENBQ0Y7SUFFRCxPQUFPLEdBQVM7UUFDZCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDZixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUM3QixvREFBb0Q7UUFDcEQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO0lBQUEsQ0FDbkM7Q0FDRiJ9

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, napiPath: 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobV9hc3luYy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NobV9hc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQU12RDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCxxQkFBYSxpQ0FBa0MsWUFBVyxvQkFBb0I7SUFDNUUsT0FBTyxDQUFDLE9BQU8sQ0FBZTtJQUM5QixPQUFPLENBQUMsTUFBTSxDQUFNO0lBQ3BCLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBUztJQUl2QixPQUFPLENBQUMsZ0JBQWdCLENBR2hCO0lBRVIsT0FBTyxlQVVOO0lBRUQ7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLGNBQWM7SUFnQnRCOzs7OztPQUtHO0lBQ0gsT0FBYSxHQUFHLENBQ2QsWUFBWSxFQUFFLE1BQU0sRUFDcEIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsT0FBTyxDQUFDLEVBQUUsTUFBTSxFQUNoQixNQUFNLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssSUFBSSxHQUM3QixPQUFPLENBQUMsaUNBQWlDLENBQUMsQ0E0SDVDO0lBRUQ7Ozs7Ozs7Ozs7Ozs7O09BY0c7SUFDRyxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBMEJ2RDtJQUVLLE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBYzdCO0NBQ0YifQ==

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;AAMvD;;;;;;;;;;;;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,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,OAAO,CAAC,iCAAiC,CAAC,CA4H5C;IAED;;;;;;;;;;;;;;OAcG;IACG,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BvD;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAc7B;CACF"}