@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5daedc8

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

@@ -0,0 +1,34 @@
+import { IMsgpackBackendAsync } from '../interface.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 declare class BarretenbergNativeSocketAsyncBackend implements IMsgpackBackendAsync {
+    private process;
+    private socket;
+    private socketPath;
+    private connectionPromise;
+    private connectionTimeout;
+    private pendingCallbacks;
+    private readingLength;
+    private lengthBuffer;
+    private lengthBytesRead;
+    private responseLength;
+    private responseBuffer;
+    private responseBytesRead;
+    constructor(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void);
+    private waitForSocketAndConnect;
+    private handleData;
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    private cleanup;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NvY2tldC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NvY2tldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUl2RDs7Ozs7Ozs7Ozs7R0FXRztBQUNILHFCQUFhLG9DQUFxQyxZQUFXLG9CQUFvQjtJQUMvRSxPQUFPLENBQUMsT0FBTyxDQUFlO0lBQzlCLE9BQU8sQ0FBQyxNQUFNLENBQTJCO0lBQ3pDLE9BQU8sQ0FBQyxVQUFVLENBQVM7SUFDM0IsT0FBTyxDQUFDLGlCQUFpQixDQUFnQjtJQUN6QyxPQUFPLENBQUMsaUJBQWlCLENBQStCO0lBSXhELE9BQU8sQ0FBQyxnQkFBZ0IsQ0FHaEI7SUFHUixPQUFPLENBQUMsYUFBYSxDQUFpQjtJQUN0QyxPQUFPLENBQUMsWUFBWSxDQUEyQjtJQUMvQyxPQUFPLENBQUMsZUFBZSxDQUFhO0lBQ3BDLE9BQU8sQ0FBQyxjQUFjLENBQWE7SUFDbkMsT0FBTyxDQUFDLGNBQWMsQ0FBdUI7SUFDN0MsT0FBTyxDQUFDLGlCQUFpQixDQUFhO0lBRXRDLFlBQVksWUFBWSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxLQUFLLElBQUksRUFvR2pGO1lBRWEsdUJBQXVCO0lBaUVyQyxPQUFPLENBQUMsVUFBVTtJQW1EWixJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBd0J2RDtJQUVELE9BQU8sQ0FBQyxPQUFPO0lBaUNULE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTdCO0NBQ0YifQ==

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

@@ -0,0 +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;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"}

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

@@ -0,0 +1,281 @@
+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 readline from 'readline';
+/**
+ * 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 {
+    process;
+    socket = null;
+    socketPath;
+    connectionPromise;
+    connectionTimeout = null;
+    // Queue of pending callbacks for pipelined requests
+    // Responses come back in FIFO order, so we match them with queued callbacks
+    pendingCallbacks = [];
+    // State machine for reading responses
+    readingLength = true;
+    lengthBuffer = Buffer.alloc(4);
+    lengthBytesRead = 0;
+    responseLength = 0;
+    responseBuffer = null;
+    responseBytesRead = 0;
+    constructor(bbBinaryPath, threads, logger) {
+        // 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;
+        });
+        // If threads not set use num cpu cores, max 32.
+        const hwc = threads ? threads.toString() : Math.min(32, os.cpus.length).toString();
+        const env = { ...process.env, HARDWARE_CONCURRENCY: '1' };
+        // Spawn bb process - it will create the socket server
+        const args = ['msgpack', 'run', '--input', this.socketPath];
+        this.process = spawn(bbBinaryPath, args, {
+            stdio: ['ignore', logger ? 'pipe' : 'ignore', logger ? 'pipe' : '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
+        this.process.unref();
+        if (logger) {
+            logger("Logger attached to bb process. DON'T FORGET TO DESTROY THE BACKEND to allow Node.js to exit.");
+            readline.createInterface({ input: this.process.stdout }).on('line', logger);
+            readline.createInterface({ input: this.process.stderr }).on('line', logger);
+        }
+        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', () => {
+                // Socket starts referenced - will be unreferenced when no callbacks pending
+                // 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');
+                    }
+                    // If no more pending callbacks, unref socket to allow process to exit
+                    if (this.pendingCallbacks.length === 0 && this.socket) {
+                        this.socket.unref();
+                    }
+                    // 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) => {
+            // If this is the first pending callback, ref the socket to keep event loop alive
+            if (this.pendingCallbacks.length === 0) {
+                this.socket.ref();
+            }
+            // 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() {
+        this.cleanup();
+        this.process.kill('SIGTERM');
+        this.process.removeAllListeners();
+    }
+}
+//# 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL3BsYXRmb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWNBOzs7O0dBSUc7QUFDSCx3QkFBZ0IsZUFBZSxJQUFJLE1BQU0sR0FBRyxJQUFJLENBYS9DO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLE1BQU0sUUFBUSxHQUFHLGNBQWMsR0FBRyxlQUFlLEdBQUcsZUFBZSxHQUFHLGdCQUFnQixDQUFDO0FBWTdGOzs7R0FHRztBQUNILHdCQUFnQixjQUFjLElBQUksUUFBUSxHQUFHLElBQUksQ0FrQmhEO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCx3QkFBZ0IsWUFBWSxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsSUFBSSxDQWlDL0Q7QUFFRCx3QkFBZ0IsY0FBYyxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsSUFBSSxDQWlDakUifQ==

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