@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-fake-c83136db25

package/dest/node/bb_backends/node/native_socket.js

@@ -0,0 +1,269 @@
+import { spawn } from 'child_process';
+import * as net from 'net';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { findPackageRoot } from './platform.js';
+/**
+ * Asynchronous native backend that communicates with bb binary via Unix Domain Socket.
+ * Uses event-based I/O with a state machine to handle partial reads.
+ *
+ * Architecture: bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the socket and listens for connections
+ * - TypeScript waits for socket file to exist, then connects
+ *
+ * Protocol:
+ * - Request: 4-byte little-endian length + msgpack buffer
+ * - Response: 4-byte little-endian length + msgpack buffer
+ */
+export class BarretenbergNativeSocketAsyncBackend {
+    constructor(bbBinaryPath, threads) {
+        this.socket = null;
+        this.connectionTimeout = null;
+        // Queue of pending callbacks for pipelined requests
+        // Responses come back in FIFO order, so we match them with queued callbacks
+        this.pendingCallbacks = [];
+        // State machine for reading responses
+        this.readingLength = true;
+        this.lengthBuffer = Buffer.alloc(4);
+        this.lengthBytesRead = 0;
+        this.responseLength = 0;
+        this.responseBuffer = null;
+        this.responseBytesRead = 0;
+        // Create a unique socket path in temp directory
+        this.socketPath = path.join(os.tmpdir(), `bb-${process.pid}-${Date.now()}.sock`);
+        // Ensure socket path doesn't already exist (cleanup from previous crashes)
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+        let connectionResolve = null;
+        let connectionReject = null;
+        this.connectionPromise = new Promise((resolve, reject) => {
+            connectionResolve = resolve;
+            connectionReject = reject;
+        });
+        // Set HARDWARE_CONCURRENCY if threads specified
+        const env = threads !== undefined ? { ...process.env, HARDWARE_CONCURRENCY: threads.toString() } : process.env;
+        // Spawn bb process - it will create the socket server
+        const args = [bbBinaryPath, 'msgpack', 'run', '--input', this.socketPath];
+        this.process = spawn(findPackageRoot() + '/scripts/kill_wrapper.sh', args, {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            env,
+        });
+        // Disconnect from event loop so process can exit. The kill wrapper will reap bb once parent (node) dies.
+        this.process.unref();
+        this.process.on('error', err => {
+            if (connectionReject) {
+                connectionReject(new Error(`Native backend process error: ${err.message}`));
+                connectionReject = null;
+                connectionResolve = null;
+            }
+            // Reject all pending callbacks
+            const error = new Error(`Native backend process error: ${err.message}`);
+            for (const callback of this.pendingCallbacks) {
+                callback.reject(error);
+            }
+            this.pendingCallbacks = [];
+        });
+        this.process.on('exit', (code, signal) => {
+            const errorMsg = code !== null && code !== 0
+                ? `Native backend process exited with code ${code}`
+                : signal && signal !== 'SIGTERM'
+                    ? `Native backend process killed with signal ${signal}`
+                    : 'Native backend process exited unexpectedly';
+            if (connectionReject) {
+                connectionReject(new Error(errorMsg));
+                connectionReject = null;
+                connectionResolve = null;
+            }
+            // Reject all pending callbacks
+            const error = new Error(errorMsg);
+            for (const callback of this.pendingCallbacks) {
+                callback.reject(error);
+            }
+            this.pendingCallbacks = [];
+        });
+        // Wait for bb to create socket file, then connect
+        this.waitForSocketAndConnect()
+            .then(() => {
+            if (connectionResolve) {
+                connectionResolve();
+                connectionResolve = null;
+                connectionReject = null;
+            }
+        })
+            .catch(err => {
+            if (connectionReject) {
+                connectionReject(err);
+                connectionReject = null;
+                connectionResolve = null;
+            }
+        });
+        // Set a timeout for connection
+        this.connectionTimeout = setTimeout(() => {
+            if (connectionReject) {
+                connectionReject(new Error('Timeout waiting for bb socket connection'));
+                connectionReject = null;
+                connectionResolve = null;
+                this.cleanup();
+            }
+        }, 5000);
+    }
+    async waitForSocketAndConnect() {
+        // Poll for socket file to exist (bb is creating it)
+        const startTime = Date.now();
+        while (!fs.existsSync(this.socketPath)) {
+            if (Date.now() - startTime > 5000) {
+                throw new Error('Timeout waiting for bb to create socket file');
+            }
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        // Additional check: ensure it's actually a socket
+        const stats = fs.statSync(this.socketPath);
+        if (!stats.isSocket()) {
+            throw new Error(`Path exists but is not a socket: ${this.socketPath}`);
+        }
+        // Connect to bb's socket server as a client
+        return new Promise((resolve, reject) => {
+            this.socket = net.connect(this.socketPath);
+            // Disable Nagle's algorithm for lower latency
+            this.socket.setNoDelay(true);
+            // Set up event handlers
+            this.socket.once('connect', () => {
+                this.socket.unref();
+                // Clear connection timeout on successful connection
+                if (this.connectionTimeout) {
+                    clearTimeout(this.connectionTimeout);
+                    this.connectionTimeout = null;
+                }
+                resolve();
+            });
+            this.socket.once('error', err => {
+                reject(new Error(`Failed to connect to bb socket: ${err.message}`));
+            });
+            // Set up data handler after connection is established
+            this.socket.on('data', (chunk) => {
+                this.handleData(chunk);
+            });
+            // Handle ongoing errors after initial connection
+            this.socket.on('error', err => {
+                // Reject all pending callbacks
+                const error = new Error(`Socket error: ${err.message}`);
+                for (const callback of this.pendingCallbacks) {
+                    callback.reject(error);
+                }
+                this.pendingCallbacks = [];
+            });
+            this.socket.on('end', () => {
+                // Reject all pending callbacks
+                const error = new Error('Socket connection ended unexpectedly');
+                for (const callback of this.pendingCallbacks) {
+                    callback.reject(error);
+                }
+                this.pendingCallbacks = [];
+            });
+        });
+    }
+    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 - dequeue the next pending callback (FIFO)
+                    const callback = this.pendingCallbacks.shift();
+                    if (callback) {
+                        callback.resolve(new Uint8Array(this.responseBuffer));
+                    }
+                    else {
+                        // This shouldn't happen - response without a pending request
+                        console.warn('Received response but no pending callback');
+                    }
+                    // Reset state for next message
+                    this.readingLength = true;
+                    this.lengthBytesRead = 0;
+                    this.responseLength = 0;
+                    this.responseBuffer = null;
+                    this.responseBytesRead = 0;
+                }
+            }
+        }
+    }
+    async call(inputBuffer) {
+        // Wait for connection to be established
+        await this.connectionPromise;
+        if (!this.socket) {
+            throw new Error('Socket not connected');
+        }
+        return new Promise((resolve, reject) => {
+            // Enqueue this promise's callbacks (FIFO order)
+            this.pendingCallbacks.push({ resolve, reject });
+            // Write request: 4-byte little-endian length + msgpack data
+            // Socket will buffer these if needed, maintaining order
+            const lengthBuf = Buffer.alloc(4);
+            lengthBuf.writeUInt32LE(inputBuffer.length, 0);
+            this.socket.write(lengthBuf);
+            this.socket.write(inputBuffer);
+        });
+    }
+    cleanup() {
+        // Reject any remaining pending callbacks
+        const error = new Error('Backend connection closed');
+        for (const callback of this.pendingCallbacks) {
+            callback.reject(error);
+        }
+        this.pendingCallbacks = [];
+        try {
+            // Remove all event listeners to prevent hanging
+            if (this.socket) {
+                this.socket.removeAllListeners();
+                // Unref so socket doesn't keep event loop alive
+                // this.socket.unref();
+                this.socket.destroy();
+            }
+        }
+        catch (e) {
+            // Ignore errors during cleanup
+        }
+        // Clear connection timeout if still pending
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+        // Remove process event listeners and unref to not block event loop
+        this.process.removeAllListeners();
+        // this.process.unref();
+        // Don't try to unlink socket - bb owns it and will clean it up
+    }
+    async destroy() {
+        // Cleanup first (closes socket, unrefs everything)
+        this.cleanup();
+        // Send SIGTERM for graceful shutdown
+        // Process is unref'd so won't block event loop - just kill and return
+        try {
+            this.process.kill('SIGTERM');
+        }
+        catch (e) {
+            // Already dead
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native_socket.js","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_socket.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,27 @@
+/**
+ * Find package root by climbing directory tree until package.json is found.
+ * @param startDir Starting directory to search from
+ * @returns Absolute path to package root, or null if not found
+ */
+export declare function findPackageRoot(): string | null;
+/**
+ * Supported platform/architecture combinations.
+ */
+export type Platform = 'x86_64-linux' | 'x86_64-darwin' | 'aarch64-linux' | 'aarch64-darwin';
+/**
+ * Detect the current platform and architecture.
+ * @returns Platform identifier or null if unsupported
+ */
+export declare function detectPlatform(): Platform | null;
+/**
+ * Find the bb binary for the native backend.
+ * @param customPath Optional custom path to bb binary (overrides automatic detection)
+ * @returns Absolute path to bb binary, or null if not found
+ *
+ * Search order:
+ * 1. If customPath is provided and exists, return it
+ * 2. Otherwise search in <package-root>/build/<platform>/bb
+ */
+export declare function findBbBinary(customPath?: string): string | null;
+export declare function findNapiBinary(customPath?: string): string | null;
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/platform.ts"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAa/C;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,eAAe,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAY7F;;;GAGG;AACH,wBAAgB,cAAc,IAAI,QAAQ,GAAG,IAAI,CAkBhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiC/D;AAED,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiCjE"}

package/dest/node/bb_backends/node/platform.js

@@ -0,0 +1,124 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+function getCurrentDir() {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return path.dirname(fileURLToPath(import.meta.url));
+    }
+}
+/**
+ * Find package root by climbing directory tree until package.json is found.
+ * @param startDir Starting directory to search from
+ * @returns Absolute path to package root, or null if not found
+ */
+export function findPackageRoot() {
+    let currentDir = getCurrentDir();
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+/**
+ * Map from Platform to build directory name.
+ */
+const PLATFORM_TO_BUILD_DIR = {
+    'x86_64-linux': 'amd64-linux',
+    'x86_64-darwin': 'amd64-macos',
+    'aarch64-linux': 'arm64-linux',
+    'aarch64-darwin': 'arm64-macos',
+};
+/**
+ * Detect the current platform and architecture.
+ * @returns Platform identifier or null if unsupported
+ */
+export function detectPlatform() {
+    const arch = process.arch; // 'x64' | 'arm64' | ...
+    const platform = process.platform; // 'linux' | 'darwin' | 'win32' | ...
+    if (arch === 'x64' && platform === 'linux') {
+        return 'x86_64-linux';
+    }
+    if (arch === 'x64' && platform === 'darwin') {
+        return 'x86_64-darwin';
+    }
+    if (arch === 'arm64' && platform === 'linux') {
+        return 'aarch64-linux';
+    }
+    if (arch === 'arm64' && platform === 'darwin') {
+        return 'aarch64-darwin';
+    }
+    return null;
+}
+/**
+ * Find the bb binary for the native backend.
+ * @param customPath Optional custom path to bb binary (overrides automatic detection)
+ * @returns Absolute path to bb binary, or null if not found
+ *
+ * Search order:
+ * 1. If customPath is provided and exists, return it
+ * 2. Otherwise search in <package-root>/build/<platform>/bb
+ */
+export function findBbBinary(customPath) {
+    // Check custom path first if provided
+    if (customPath) {
+        if (fs.existsSync(customPath)) {
+            return path.resolve(customPath);
+        }
+        // Custom path provided but doesn't exist - return null
+        return null;
+    }
+    // Automatic detection
+    const platform = detectPlatform();
+    if (!platform) {
+        return null;
+    }
+    const buildDir = PLATFORM_TO_BUILD_DIR[platform];
+    // Get package root by climbing directory tree to find package.json
+    const packageRoot = findPackageRoot();
+    if (!packageRoot) {
+        return null;
+    }
+    // Check in build/<platform>/bb
+    const bbPath = path.join(packageRoot, 'build', buildDir, 'bb');
+    if (fs.existsSync(bbPath)) {
+        return bbPath;
+    }
+    return null;
+}
+export function findNapiBinary(customPath) {
+    // Check custom path first if provided
+    if (customPath) {
+        if (fs.existsSync(customPath)) {
+            return path.resolve(customPath);
+        }
+        // Custom path provided but doesn't exist - return null
+        return null;
+    }
+    // Automatic detection
+    const platform = detectPlatform();
+    if (!platform) {
+        return null;
+    }
+    const buildDir = PLATFORM_TO_BUILD_DIR[platform];
+    // Get package root by climbing directory tree to find package.json
+    const packageRoot = findPackageRoot();
+    if (!packageRoot) {
+        return null;
+    }
+    // Check in build/<platform>/nodejs_module.node
+    const bbPath = path.join(packageRoot, 'build', buildDir, 'nodejs_module.node');
+    if (fs.existsSync(bbPath)) {
+        return bbPath;
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from './interface.js';
+/**
+ * Adapter that wraps a synchronous backend to provide an async interface.
+ * The sync backend's blocking calls are simply wrapped in Promise.resolve().
+ *
+ * This is useful for backends like shared memory where the call is actually
+ * synchronous but we want to use it with the async API.
+ */
+export declare class SyncToAsyncAdapter implements IMsgpackBackendAsync {
+    private syncBackend;
+    constructor(syncBackend: IMsgpackBackendSync);
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=sync_to_async_adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync_to_async_adapter.d.ts","sourceRoot":"","sources":["../../../src/bb_backends/sync_to_async_adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3E;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,oBAAoB;IACjD,OAAO,CAAC,WAAW;gBAAX,WAAW,EAAE,mBAAmB;IAE9C,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAKlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dest/node/bb_backends/sync_to_async_adapter.js

@@ -0,0 +1,20 @@
+/**
+ * Adapter that wraps a synchronous backend to provide an async interface.
+ * The sync backend's blocking calls are simply wrapped in Promise.resolve().
+ *
+ * This is useful for backends like shared memory where the call is actually
+ * synchronous but we want to use it with the async API.
+ */
+export class SyncToAsyncAdapter {
+    constructor(syncBackend) {
+        this.syncBackend = syncBackend;
+    }
+    async call(inputBuffer) {
+        // The sync backend blocks until complete, so just wrap in a resolved promise
+        return Promise.resolve(this.syncBackend.call(inputBuffer));
+    }
+    async destroy() {
+        this.syncBackend.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190b19hc3luY19hZGFwdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL3N5bmNfdG9fYXN5bmNfYWRhcHRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFlBQW9CLFdBQWdDO1FBQWhDLGdCQUFXLEdBQVgsV0FBVyxDQUFxQjtJQUFHLENBQUM7SUFFeEQsS0FBSyxDQUFDLElBQUksQ0FBQyxXQUF1QjtRQUNoQyw2RUFBNkU7UUFDN0UsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFPO1FBQ1gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM3QixDQUFDO0NBQ0YifQ==

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

@@ -0,0 +1,49 @@
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from './interface.js';
+/**
+ * Synchronous WASM backend that wraps BarretenbergWasmMain.
+ * Encapsulates all WASM initialization and memory management.
+ */
+export declare class BarretenbergWasmSyncBackend implements IMsgpackBackendSync {
+    private wasm;
+    private constructor();
+    /**
+     * Create and initialize a synchronous WASM backend.
+     * @param wasmPath Optional path to WASM files
+     * @param logger Optional logging function
+     */
+    static new(wasmPath?: string, logger?: (msg: string) => void): Promise<BarretenbergWasmSyncBackend>;
+    call(inputBuffer: Uint8Array): Uint8Array;
+    destroy(): void;
+}
+/**
+ * Asynchronous WASM backend that supports both direct WASM and worker-based modes.
+ *
+ * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread. Used in browsers.
+ * Direct mode: Runs WASM directly on the calling thread. Used by node.js for better performance.
+ */
+export declare class BarretenbergWasmAsyncBackend implements IMsgpackBackendAsync {
+    private wasm;
+    private worker?;
+    private constructor();
+    /**
+     * Create and initialize an asynchronous WASM backend.
+     * @param options.threads Number of threads (defaults to hardware max, up to 32 for parallel proving)
+     * @param options.wasmPath Optional path to WASM files
+     * @param options.logger Optional logging function
+     * @param options.memory Optional initial and maximum memory configuration
+     * @param options.useWorker Run on worker thread (default: true for browser safety)
+     */
+    static new(options?: {
+        threads?: number;
+        wasmPath?: string;
+        logger?: (msg: string) => void;
+        memory?: {
+            initial?: number;
+            maximum?: number;
+        };
+        useWorker?: boolean;
+    }): Promise<BarretenbergWasmAsyncBackend>;
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=wasm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.d.ts","sourceRoot":"","sources":["../../../src/bb_backends/wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAM3E;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,mBAAmB;IACjD,OAAO,CAAC,IAAI;IAAhC,OAAO;IAEP;;;;OAIG;WACU,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAOzG,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU;IAIzC,OAAO,IAAI,IAAI;CAKhB;AAED;;;;;GAKG;AACH,qBAAa,4BAA6B,YAAW,oBAAoB;IAErE,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM,CAAC;IAFjB,OAAO;IAKP;;;;;;;OAOG;WACU,GAAG,CACd,OAAO,GAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAC/B,MAAM,CAAC,EAAE;YAAE,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAChD,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB,GACL,OAAO,CAAC,4BAA4B,CAAC;IA0BlC,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAIlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAM/B"}

package/dest/node/bb_backends/wasm.js

@@ -0,0 +1,83 @@
+import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { createDebugLogger } from '../log/index.js';
+import { proxy } from 'comlink';
+/**
+ * Synchronous WASM backend that wraps BarretenbergWasmMain.
+ * Encapsulates all WASM initialization and memory management.
+ */
+export class BarretenbergWasmSyncBackend {
+    constructor(wasm) {
+        this.wasm = wasm;
+    }
+    /**
+     * Create and initialize a synchronous WASM backend.
+     * @param wasmPath Optional path to WASM files
+     * @param logger Optional logging function
+     */
+    static async new(wasmPath, logger) {
+        const wasm = new BarretenbergWasmMain();
+        const { module, threads } = await fetchModuleAndThreads(1, wasmPath, logger);
+        await wasm.init(module, threads, logger);
+        return new BarretenbergWasmSyncBackend(wasm);
+    }
+    call(inputBuffer) {
+        return this.wasm.cbindCall('bbapi', inputBuffer);
+    }
+    destroy() {
+        // BarretenbergWasmMain has async destroy, but for sync API we call it without awaiting
+        // This is consistent with the synchronous semantics expected by the caller
+        void this.wasm.destroy();
+    }
+}
+/**
+ * Asynchronous WASM backend that supports both direct WASM and worker-based modes.
+ *
+ * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread. Used in browsers.
+ * Direct mode: Runs WASM directly on the calling thread. Used by node.js for better performance.
+ */
+export class BarretenbergWasmAsyncBackend {
+    constructor(wasm, worker) {
+        this.wasm = wasm;
+        this.worker = worker;
+    }
+    /**
+     * Create and initialize an asynchronous WASM backend.
+     * @param options.threads Number of threads (defaults to hardware max, up to 32 for parallel proving)
+     * @param options.wasmPath Optional path to WASM files
+     * @param options.logger Optional logging function
+     * @param options.memory Optional initial and maximum memory configuration
+     * @param options.useWorker Run on worker thread (default: true for browser safety)
+     */
+    static async new(options = {}) {
+        // Default to worker mode for browser safety
+        const useWorker = options.useWorker ?? true;
+        if (useWorker) {
+            // Worker-based mode: runs on worker thread (browser-safe)
+            const worker = await createMainWorker();
+            const wasm = getRemoteBarretenbergWasm(worker);
+            const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+            await wasm.init(module, threads, proxy(options.logger ?? createDebugLogger('bb_wasm_async')), options.memory?.initial, options.memory?.maximum);
+            return new BarretenbergWasmAsyncBackend(wasm, worker);
+        }
+        else {
+            // Direct mode: runs on calling thread (faster but blocks thread)
+            const wasm = new BarretenbergWasmMain();
+            const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+            await wasm.init(module, threads, options.logger, options.memory?.initial, options.memory?.maximum);
+            return new BarretenbergWasmAsyncBackend(wasm);
+        }
+    }
+    async call(inputBuffer) {
+        return this.wasm.cbindCall('bbapi', inputBuffer);
+    }
+    async destroy() {
+        await this.wasm.destroy();
+        if (this.worker) {
+            await this.worker.terminate();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node/bbapi_exception.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exception thrown when barretenberg API operations fail
+ */
+export declare class BBApiException extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=bbapi_exception.d.ts.map

package/dest/node/bbapi_exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bbapi_exception.d.ts","sourceRoot":"","sources":["../../src/bbapi_exception.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAQ5B"}