@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5476d83

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

@@ -0,0 +1,33 @@
+/**
+ * Generic interface for msgpack backend implementations.
+ * Both WASM and native binary backends implement this interface.
+ */
+export interface IMsgpackBackend {
+    /**
+     * Execute a msgpack command and return the msgpack response.
+     * @param inputBuffer The msgpack-encoded input buffer
+     * @returns The msgpack-encoded response buffer (sync or async)
+     */
+    call(inputBuffer: Uint8Array): Uint8Array | Promise<Uint8Array>;
+    /**
+     * Clean up resources.
+     */
+    destroy(): void | Promise<void>;
+}
+/**
+ * Synchronous variant of IMsgpackBackend.
+ * Used by BarretenbergSync and SyncApi.
+ */
+export interface IMsgpackBackendSync extends IMsgpackBackend {
+    call(inputBuffer: Uint8Array): Uint8Array;
+    destroy(): void;
+}
+/**
+ * Asynchronous variant of IMsgpackBackend.
+ * Used by Barretenberg and AsyncApi.
+ */
+export interface IMsgpackBackendAsync extends IMsgpackBackend {
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmJfYmFja2VuZHMvaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE1BQU0sV0FBVyxlQUFlO0lBQzlCOzs7O09BSUc7SUFDSCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRWhFOztPQUVHO0lBQ0gsT0FBTyxJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDakM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsbUJBQW9CLFNBQVEsZUFBZTtJQUMxRCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDMUMsT0FBTyxJQUFJLElBQUksQ0FBQztDQUNqQjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxvQkFBcUIsU0FBUSxlQUFlO0lBQzNELElBQUksQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNuRCxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQzFCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/bb_backends/interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEhE;;OAEG;IACH,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dest/node/bb_backends/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

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

@@ -0,0 +1,11 @@
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+/**
+ * Create backend of specific type (no fallback)
+ */
+export declare function createAsyncBackend(type: BackendType, options: BackendOptions, logger: (msg: string) => void): Promise<Barretenberg>;
+/**
+ * Create backend of specific type (no fallback)
+ */
+export declare function createSyncBackend(type: BackendType, options: BackendOptions, logger: (msg: string) => void): Promise<BarretenbergSync>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUM3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxRDs7R0FFRztBQUNILHdCQUFzQixrQkFBa0IsQ0FDdEMsSUFBSSxFQUFFLFdBQVcsRUFDakIsT0FBTyxFQUFFLGNBQWMsRUFDdkIsTUFBTSxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sS0FBSyxJQUFJLEdBQzVCLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FnRHZCO0FBRUQ7O0dBRUc7QUFDSCx3QkFBc0IsaUJBQWlCLENBQ3JDLElBQUksRUFBRSxXQUFXLEVBQ2pCLE9BQU8sRUFBRSxjQUFjLEVBQ3ZCLE1BQU0sRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssSUFBSSxHQUM1QixPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0E2QjNCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC5B,OAAO,CAAC,YAAY,CAAC,CAgDvB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CA6B3B"}

package/dest/node/bb_backends/node/index.js

@@ -0,0 +1,86 @@
+import { BarretenbergNativeSocketAsyncBackend } from './native_socket.js';
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { BarretenbergNativeShmSyncBackend } from './native_shm.js';
+import { BarretenbergNativeShmAsyncBackend } from './native_shm_async.js';
+import { findBbBinary, findNapiBinary } from './platform.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendType } from '../index.js';
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(type, options, logger) {
+    options = {
+        ...options,
+        wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+    };
+    switch (type) {
+        case BackendType.NativeUnixSocket: {
+            const bbPath = findBbBinary(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            logger(`Using native Unix socket backend: ${bbPath}`);
+            const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
+            return new Barretenberg(socket, options);
+        }
+        case BackendType.NativeSharedMemory: {
+            const bbPath = findBbBinary(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            const napiPath = findNapiBinary();
+            if (!napiPath) {
+                throw new Error('Native async backend requires napi client stub.');
+            }
+            logger(`Using native shared memory async backend: ${bbPath}`);
+            const asyncBackend = await BarretenbergNativeShmAsyncBackend.new(bbPath, options.threads, options.logger);
+            return new Barretenberg(asyncBackend, options);
+        }
+        case BackendType.Wasm:
+        case BackendType.WasmWorker: {
+            const useWorker = type === BackendType.WasmWorker;
+            logger(`Using WASM backend (worker: ${useWorker})`);
+            const wasm = await BarretenbergWasmAsyncBackend.new({
+                threads: options.threads,
+                wasmPath: options.wasmPath,
+                logger: options.logger,
+                memory: options.memory,
+                useWorker,
+            });
+            return new Barretenberg(wasm, options);
+        }
+        default:
+            throw new Error(`Unknown backend type: ${type}`);
+    }
+}
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(type, options, logger) {
+    options = {
+        ...options,
+        wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+    };
+    switch (type) {
+        case BackendType.NativeSharedMemory: {
+            const bbPath = findBbBinary(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            const napiPath = findNapiBinary();
+            if (!napiPath) {
+                throw new Error('Native sync backend requires napi client stub.');
+            }
+            logger(`Using native shared memory backend: ${bbPath}`);
+            const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.logger);
+            return new BarretenbergSync(shm);
+        }
+        case BackendType.Wasm:
+            logger('Using WASM backend');
+            const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+            return new BarretenbergSync(wasm);
+        default:
+            throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,25 @@
+import { IMsgpackBackendAsync } from '../interface.js';
+/**
+ * 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 declare class BarretenbergNativePipeAsyncBackend implements IMsgpackBackendAsync {
+    private process;
+    private pendingResolve;
+    private pendingReject;
+    private readingLength;
+    private lengthBuffer;
+    private lengthBytesRead;
+    private responseLength;
+    private responseBuffer;
+    private responseBytesRead;
+    constructor(bbBinaryPath: string);
+    private handleData;
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3BpcGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL25hdGl2ZV9waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBdUIsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUU1RTs7Ozs7OztHQU9HO0FBQ0gscUJBQWEsa0NBQW1DLFlBQVcsb0JBQW9CO0lBQzdFLE9BQU8sQ0FBQyxPQUFPLENBQWU7SUFDOUIsT0FBTyxDQUFDLGNBQWMsQ0FBNkM7SUFDbkUsT0FBTyxDQUFDLGFBQWEsQ0FBeUM7SUFHOUQsT0FBTyxDQUFDLGFBQWEsQ0FBaUI7SUFDdEMsT0FBTyxDQUFDLFlBQVksQ0FBMkI7SUFDL0MsT0FBTyxDQUFDLGVBQWUsQ0FBYTtJQUNwQyxPQUFPLENBQUMsY0FBYyxDQUFhO0lBQ25DLE9BQU8sQ0FBQyxjQUFjLENBQXVCO0lBQzdDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBYTtJQUV0QyxZQUFZLFlBQVksRUFBRSxNQUFNLEVBZ0MvQjtJQUVELE9BQU8sQ0FBQyxVQUFVO0lBNENaLElBQUksQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FldkQ7SUFFSyxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUs3QjtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"native_pipe.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_pipe.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,kCAAmC,YAAW,oBAAoB;IAC7E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,cAAc,CAA6C;IACnE,OAAO,CAAC,aAAa,CAAyC;IAG9D,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,EAgC/B;IAED,OAAO,CAAC,UAAU;IA4CZ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAevD;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;CACF"}

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,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

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

@@ -0,0 +1,28 @@
+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 threads Optional number of threads
+     */
+    static new(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void): Promise<BarretenbergNativeShmSyncBackend>;
+    call(inputBuffer: Uint8Array): Uint8Array;
+    private cleanup;
+    destroy(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NobS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQW9CdEQ7Ozs7Ozs7Ozs7R0FVRztBQUNILHFCQUFhLGdDQUFpQyxZQUFXLG1CQUFtQjtJQUMxRSxPQUFPLENBQUMsT0FBTyxDQUFlO0lBQzlCLE9BQU8sQ0FBQyxNQUFNLENBQU07SUFDcEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFTO0lBRXZCLE9BQU8sZUFJTjtJQUVEOzs7O09BSUc7SUFDSCxPQUFhLEdBQUcsQ0FDZCxZQUFZLEVBQUUsTUFBTSxFQUNwQixPQUFPLENBQUMsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sS0FBSyxJQUFJLEdBQzdCLE9BQU8sQ0FBQyxnQ0FBZ0MsQ0FBQyxDQTBHM0M7SUFFRCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLENBT3hDO0lBRUQsT0FBTyxDQUFDLE9BQU87SUFpQmYsT0FBTyxJQUFJLElBQUksQ0FLZDtDQUNGIn0=

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;AAoBtD;;;;;;;;;;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;;;;OAIG;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,gCAAgC,CAAC,CA0G3C;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,177 @@
+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;
+/**
+ * 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 threads Optional number of threads
+     */
+    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-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 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,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

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"}