@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.24de95ac

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BarretenbergNativeShmSyncBackend = void 0;
+const module_1 = require("module");
+const child_process_1 = require("child_process");
+const platform_js_1 = require("./platform.js");
+// Import the NAPI module
+// The addon is built to the nodejs_module directory
+const addonPath = (0, platform_js_1.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 = (0, module_1.createRequire)((0, platform_js_1.findPackageRoot)());
+        addon = require(addonPath);
+    }
+}
+catch (err) {
+    // Addon not built yet or not available
+    addon = null;
+}
+/**
+ * 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)
+ */
+class BarretenbergNativeShmSyncBackend {
+    constructor(process, client) {
+        this.process = process;
+        this.client = client;
+    }
+    /**
+     * Create and initialize a shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param threads Optional number of threads
+     * @param maxClients Optional maximum concurrent clients (default: 1)
+     */
+    static async new(bbBinaryPath, threads, maxClients) {
+        if (!addon || !addon.MsgpackClient) {
+            throw new Error('Shared memory NAPI not available.');
+        }
+        // Create a unique shared memory name
+        const shmName = `bb-${process.pid}-${Date.now()}`;
+        // Default maxClients to 1 if not specified
+        const clientCount = maxClients ?? 1;
+        // Set HARDWARE_CONCURRENCY if threads specified
+        const env = threads !== undefined ? { ...process.env, HARDWARE_CONCURRENCY: threads.toString() } : process.env;
+        // Spawn bb process with shared memory mode
+        const args = [bbBinaryPath, 'msgpack', 'run', '--input', `${shmName}.shm`, '--max-clients', clientCount.toString()];
+        const bbProcess = (0, child_process_1.spawn)((0, platform_js_1.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.
+        bbProcess.unref();
+        // Capture stderr for error diagnostics
+        // bbProcess.stderr?.on('data', (data: Buffer) => {
+        //   stderrOutput += data.toString();
+        // });
+        // Track if process has exited
+        let processExited = false;
+        let exitError = null;
+        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 with matching max_clients value
+                    client = new addon.MsgpackClient(shmName, clientCount);
+                    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);
+        }
+        finally {
+            // If we failed to connect, ensure the process is killed
+            // kill() returns false if process already exited, but doesn't throw
+            if (!client) {
+                bbProcess.kill('SIGKILL');
+            }
+        }
+    }
+    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
+            }
+        }
+    }
+    destroy() {
+        this.cleanup();
+        this.process.kill('SIGTERM');
+        // Remove process event listeners to prevent hanging
+        this.process.removeAllListeners();
+    }
+}
+exports.BarretenbergNativeShmSyncBackend = BarretenbergNativeShmSyncBackend;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node-cjs/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);
+    private waitForSocketAndConnect;
+    private handleData;
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    private cleanup;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=native_socket.d.ts.map

package/dest/node-cjs/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;AAGvD;;;;;;;;;;;GAWG;AACH,qBAAa,oCAAqC,YAAW,oBAAoB;IAC/E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,iBAAiB,CAAgB;IACzC,OAAO,CAAC,iBAAiB,CAA+B;IAIxD,OAAO,CAAC,gBAAgB,CAGhB;IAGR,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,iBAAiB,CAAa;gBAE1B,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;YA4FpC,uBAAuB;IAiErC,OAAO,CAAC,UAAU;IA8CZ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBxD,OAAO,CAAC,OAAO;IAiCT,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAY/B"}

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

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BarretenbergNativeSocketAsyncBackend = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const net = tslib_1.__importStar(require("net"));
+const fs = tslib_1.__importStar(require("fs"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const platform_js_1 = require("./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
+ */
+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 = (0, child_process_1.spawn)((0, platform_js_1.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
+        }
+    }
+}
+exports.BarretenbergNativeSocketAsyncBackend = BarretenbergNativeSocketAsyncBackend;
+//# 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-cjs/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-cjs/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-cjs/bb_backends/node/platform.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageRoot = findPackageRoot;
+exports.detectPlatform = detectPlatform;
+exports.findBbBinary = findBbBinary;
+exports.findNapiBinary = findNapiBinary;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const url_1 = require("url");
+function getCurrentDir() {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return path.dirname((0, url_1.fileURLToPath)(""));
+    }
+}
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+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;
+}
+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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