@aztec/bb.js 0.0.1-commit.d3ec352c → 0.0.1-commit.e310a4c8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/bb.js",
   "packageManager": "yarn@4.5.2",
-  "version": "0.0.1-commit.d3ec352c",
+  "version": "0.0.1-commit.e310a4c8",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",

package/src/barretenberg/backend.test.ts

@@ -0,0 +1,122 @@
+import { fieldToString, fieldsToStrings } from './backend.js';
+
+describe('field helper functions', () => {
+  describe('fieldToString', () => {
+    it('converts zero field to "0"', () => {
+      const zeroField = new Uint8Array(32).fill(0);
+      expect(fieldToString(zeroField)).toBe('0');
+    });
+
+    it('converts field with value 1 to "1"', () => {
+      const oneField = new Uint8Array(32).fill(0);
+      oneField[31] = 1;
+      expect(fieldToString(oneField)).toBe('1');
+    });
+
+    it('converts field with value 256 to "256"', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[30] = 1;
+      field[31] = 0;
+      expect(fieldToString(field)).toBe('256');
+    });
+
+    it('converts field with max uint8 in last byte to "255"', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 255;
+      expect(fieldToString(field)).toBe('255');
+    });
+
+    it('converts larger values correctly', () => {
+      // 0x0100 = 256 in decimal
+      const field = new Uint8Array(32).fill(0);
+      field[30] = 0x01;
+      field[31] = 0x00;
+      expect(fieldToString(field)).toBe('256');
+    });
+
+    it('handles multi-byte values', () => {
+      // 0x010203 = 66051 in decimal
+      const field = new Uint8Array(32).fill(0);
+      field[29] = 0x01;
+      field[30] = 0x02;
+      field[31] = 0x03;
+      expect(fieldToString(field)).toBe('66051');
+    });
+
+    it('handles large field values', () => {
+      // A known value: all bytes set to 1
+      const field = new Uint8Array(32).fill(1);
+      const result = fieldToString(field);
+      // Verify it's a valid decimal string
+      expect(result).toMatch(/^\d+$/);
+      // Verify the length is reasonable for a 256-bit number
+      expect(result.length).toBeGreaterThan(70);
+    });
+
+    it('converts to hex with radix 16', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 255;
+      expect(fieldToString(field, 16)).toBe('ff');
+    });
+
+    it('converts to hex for multi-byte values', () => {
+      // 0x010203
+      const field = new Uint8Array(32).fill(0);
+      field[29] = 0x01;
+      field[30] = 0x02;
+      field[31] = 0x03;
+      expect(fieldToString(field, 16)).toBe('10203');
+    });
+
+    it('converts to binary with radix 2', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 5;
+      expect(fieldToString(field, 2)).toBe('101');
+    });
+  });
+
+  describe('fieldsToStrings', () => {
+    it('converts empty array to empty array', () => {
+      expect(fieldsToStrings([])).toEqual([]);
+    });
+
+    it('converts single field', () => {
+      const oneField = new Uint8Array(32).fill(0);
+      oneField[31] = 42;
+      expect(fieldsToStrings([oneField])).toEqual(['42']);
+    });
+
+    it('converts multiple fields', () => {
+      const field1 = new Uint8Array(32).fill(0);
+      field1[31] = 1;
+
+      const field2 = new Uint8Array(32).fill(0);
+      field2[31] = 2;
+
+      const field3 = new Uint8Array(32).fill(0);
+      field3[31] = 3;
+
+      expect(fieldsToStrings([field1, field2, field3])).toEqual(['1', '2', '3']);
+    });
+
+    it('preserves order of fields', () => {
+      const fields = [10, 20, 30, 40, 50].map(v => {
+        const field = new Uint8Array(32).fill(0);
+        field[31] = v;
+        return field;
+      });
+
+      expect(fieldsToStrings(fields)).toEqual(['10', '20', '30', '40', '50']);
+    });
+
+    it('converts to hex with radix 16', () => {
+      const fields = [15, 16, 255].map(v => {
+        const field = new Uint8Array(32).fill(0);
+        field[31] = v;
+        return field;
+      });
+
+      expect(fieldsToStrings(fields, 16)).toEqual(['f', '10', 'ff']);
+    });
+  });
+});

package/src/barretenberg/backend.ts

@@ -1,6 +1,6 @@
 import { Barretenberg } from './index.js';
 import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
-import { fromChonkProof, toChonkProof } from '../cbind/generated/api_types.js';
+import { fromChonkProof, toChonkProof, ChonkProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
 import { Decoder, Encoder } from 'msgpackr';
 
@@ -10,29 +10,46 @@ export class AztecClientBackendError extends Error {
   }
 }
 
+/**
+ * Target verification environment for proof generation.
+ * This determines the hash function used and whether zero-knowledge is enabled.
+ */
+export type VerifierTarget =
+  | 'evm' // Ethereum/Solidity verification (keccak, ZK enabled)
+  | 'evm-no-zk' // Ethereum/Solidity without zero-knowledge
+  | 'noir-recursive' // Recursive verification in Noir circuits (poseidon2, ZK enabled)
+  | 'noir-recursive-no-zk' // Recursive verification without ZK
+  | 'noir-rollup' // Rollup circuits with IPA accumulation (poseidon2, ZK enabled)
+  | 'noir-rollup-no-zk' // Rollup circuits without ZK
+  | 'starknet' // Starknet verification via Garaga (ZK enabled)
+  | 'starknet-no-zk'; // Starknet without zero-knowledge
+
 /**
  * Options for the UltraHonkBackend.
  */
 export type UltraHonkBackendOptions = {
-  /** Selecting this option will use the keccak hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an EVM chain.
+  /**
+   * Target verification environment. Determines hash function and ZK settings.
+   * This is the recommended way to configure proof generation.
+   *
+   * @example
+   * // For EVM/Solidity verification
+   * backend.generateProof(witness, { verifierTarget: 'evm' });
+   *
+   * // For recursive verification in Noir
+   * backend.generateProof(witness, { verifierTarget: 'noir-recursive' });
    */
+  verifierTarget?: VerifierTarget;
+
+  // Legacy options - prefer using verifierTarget instead
+
+  /** @deprecated Use verifierTarget: 'evm-no-zk' instead */
   keccak?: boolean;
-  /** Selecting this option will use the keccak hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an EVM chain.
-   */
+  /** @deprecated Use verifierTarget: 'evm' instead */
   keccakZK?: boolean;
-  /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an Starknet chain with Garaga.
-   */
+  /** @deprecated Use verifierTarget: 'starknet-no-zk' instead */
   starknet?: boolean;
-  /** Selecting this option will use the poseidon/stark252 hash function instead of poseidon
-   * when generating challenges in the proof.
-   * Use this when you want to verify the created proof on an Starknet chain with Garaga.
-   */
+  /** @deprecated Use verifierTarget: 'starknet' instead */
   starknetZK?: boolean;
 };
 
@@ -42,6 +59,67 @@ function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
   disableZk: boolean;
   optimizedSolidityVerifier: boolean;
 } {
+  // Check for conflicting options - verifierTarget should not be combined with legacy options
+  if (options?.verifierTarget) {
+    const legacyOptions = [options.keccak, options.keccakZK, options.starknet, options.starknetZK].filter(Boolean);
+    if (legacyOptions.length > 0) {
+      throw new Error(
+        'Cannot use verifierTarget with legacy options (keccak, keccakZK, starknet, starknetZK). ' +
+          'Use verifierTarget alone.',
+      );
+    }
+
+    switch (options.verifierTarget) {
+      case 'evm':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: false, optimizedSolidityVerifier: false };
+      case 'evm-no-zk':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: true, optimizedSolidityVerifier: false };
+      case 'noir-recursive':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-recursive-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup-no-zk':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+    }
+  }
+
+  // Legacy options support (deprecated)
   return {
     ipaAccumulation: false,
     oracleHashType:
@@ -50,7 +128,6 @@ function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
         : options?.starknet || options?.starknetZK
           ? 'starknet'
           : 'poseidon2',
-    // TODO no current way to target non-zk poseidon2 hash
     disableZk: options?.keccak || options?.starknet ? true : false,
     optimizedSolidityVerifier: false,
   };
@@ -162,6 +239,7 @@ export class UltraHonkBackend {
     _proof: Uint8Array,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _numOfPublicInputs: number,
+    options?: UltraHonkBackendOptions,
   ): Promise<{ proofAsFields: string[]; vkAsFields: string[]; vkHash: string }> {
     // TODO(https://github.com/noir-lang/noir/issues/5661): This needs to be updated to handle recursive aggregation.
     // There is still a proofAsFields method but we could consider getting rid of it as the proof itself
@@ -171,14 +249,12 @@ export class UltraHonkBackend {
     // const proof = reconstructProofWithPublicInputs(proofData);
     // const proofAsFields = (await this.api.acirProofAsFieldsUltraHonk(proof)).slice(numOfPublicInputs);
 
-    // TODO: perhaps we should put this in the init function. Need to benchmark
-    // TODO how long it takes.
     const vkResult = await this.api.circuitComputeVk({
       circuit: {
         name: 'circuit',
         bytecode: this.acirUncompressedBytecode,
       },
-      settings: getProofSettingsFromOptions({}),
+      settings: getProofSettingsFromOptions(options),
     });
 
     // Convert VK bytes to field elements (32-byte chunks)
@@ -250,7 +326,7 @@ export class AztecClientBackend {
     // The API currently expects a msgpack-encoded API.
     const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
     // Generate the VK
-    const vkResult = await this.api.chonkComputeIvcVk({
+    const vkResult = await this.api.chonkComputeVk({
       circuit: {
         name: 'hiding',
         bytecode: this.acirBuf[this.acirBuf.length - 1],
@@ -265,8 +341,8 @@ export class AztecClientBackend {
       proveResult.proof.goblinProof.translatorProof,
     ].flat();
 
-    // Note: Verification may not work correctly until we properly serialize the proof
-    if (!(await this.verify(proof, vkResult.bytes))) {
+    // Verify using native proof directly to avoid redundant encode/decode cycle
+    if (!(await this.verifyNative(proveResult.proof, vkResult.bytes))) {
       throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
     }
     return [proofFields, proof, vkResult.bytes];
@@ -280,6 +356,18 @@ export class AztecClientBackend {
     return result.valid;
   }
 
+  /**
+   * Internal verification using native ChonkProof type.
+   * Avoids encode/decode cycle when called from prove().
+   */
+  private async verifyNative(proof: ChonkProof, vk: Uint8Array): Promise<boolean> {
+    const result = await this.api.chonkVerify({
+      proof,
+      vk,
+    });
+    return result.valid;
+  }
+
   async gates(): Promise<number[]> {
     const circuitSizes: number[] = [];
     for (const buf of this.acirBuf) {
@@ -310,3 +398,41 @@ function base64Decode(input: string): Uint8Array {
     throw new Error('atob is not available. Node.js 18+ or browser required.');
   }
 }
+
+/**
+ * Convert a field element (32-byte Uint8Array) to a string.
+ *
+ * @param field - A 32-byte field element
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns The field value as a string in the specified radix
+ *
+ * @example
+ * const decimal = fieldToString(field);        // "12345678"
+ * const hex = fieldToString(field, 16);        // "bc614e"
+ */
+export function fieldToString(field: Uint8Array, radix: number = 10): string {
+  let result = 0n;
+  for (const byte of field) {
+    result <<= 8n;
+    result += BigInt(byte);
+  }
+  return result.toString(radix);
+}
+
+/**
+ * Convert an array of field elements to an array of strings.
+ * Useful for passing VK fields to Noir circuits.
+ *
+ * @param fields - Array of 32-byte field elements
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns Array of strings in the specified radix
+ *
+ * @example
+ * const vkAsFields = await barretenbergAPI.vkAsFields({ verificationKey: vk });
+ * const vkDecimalStrings = fieldsToStrings(vkAsFields.fields);      // ["12345678", "87654321", ...]
+ * const vkHexStrings = fieldsToStrings(vkAsFields.fields, 16);      // ["bc614e", "5397fb1", ...]
+ */
+export function fieldsToStrings(fields: Uint8Array[], radix: number = 10): string[] {
+  return fields.map(field => fieldToString(field, radix));
+}
+

package/src/barretenberg/index.ts

@@ -5,7 +5,15 @@ import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../bb_backends/interf
 import { BackendOptions, BackendType } from '../bb_backends/index.js';
 import { createAsyncBackend, createSyncBackend } from '../bb_backends/node/index.js';
 
-export { UltraHonkBackend, UltraHonkVerifierBackend, AztecClientBackend } from './backend.js';
+export {
+  UltraHonkBackend,
+  UltraHonkVerifierBackend,
+  AztecClientBackend,
+  fieldToString,
+  fieldsToStrings,
+  type UltraHonkBackendOptions,
+  type VerifierTarget,
+} from './backend.js';
 export * from '../bb_backends/index.js';
 
 export type CircuitOptions = {

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -35,7 +35,7 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     module: WebAssembly.Module,
     threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS),
     logger?: (msg: string) => void,
-    initial = 33,
+    initial = 35,
     maximum = this.getDefaultMaximumMemoryPages(),
   ) {
     // Track whether a custom logger was provided so workers know whether to postMessage logs

package/src/bb_backends/index.ts

@@ -28,6 +28,9 @@ export type BackendOptions = {
   /** @description Custom path to bb binary for native backend (overrides automatic detection) */
   bbPath?: string;
 
+  /** @description Custom path to bb NAPI module for native backend (overrides automatic detection) */
+  napiPath?: string;
+
   /**
    * @description Logging function
    * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.

package/src/bb_backends/node/index.ts

@@ -35,12 +35,17 @@ export async function createAsyncBackend(
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      const napiPath = findNapiBinary(options.napiPath);
       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);
+      const asyncBackend = await BarretenbergNativeShmAsyncBackend.new(
+        bbPath,
+        napiPath,
+        options.threads,
+        options.logger,
+      );
       return new Barretenberg(asyncBackend, options);
     }
 
@@ -82,12 +87,12 @@ export async function createSyncBackend(
       if (!bbPath) {
         throw new Error('Native backend requires bb binary.');
       }
-      const napiPath = findNapiBinary();
+      const napiPath = findNapiBinary(options.napiPath);
       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);
+      const shm = await BarretenbergNativeShmSyncBackend.new(bbPath, napiPath, options.threads, options.logger);
       return new BarretenbergSync(shm);
     }
 

package/src/bb_backends/node/native_shm.ts

@@ -1,23 +1,9 @@
 import { createRequire } from 'module';
 import { spawn, ChildProcess } from 'child_process';
-import { openSync, closeSync } from 'fs';
+import { openSync, closeSync, unlinkSync } from 'fs';
 import { IMsgpackBackendSync } from '../interface.js';
 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: any = null;
-try {
-  if (addonPath) {
-    const require = createRequire(findPackageRoot()!);
-    addon = require(addonPath);
-  }
-} catch (err) {
-  // Addon not built yet or not available
-  addon = null;
-}
+import { threadId } from 'worker_threads';
 
 let instanceCounter = 0;
 
@@ -46,19 +32,30 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
   /**
    * Create and initialize a shared memory backend.
    * @param bbBinaryPath Path to bb binary
+   * @param napiPath Path to NAPI binary
    * @param threads Optional number of threads
    */
   static async new(
     bbBinaryPath: string,
+    napiPath: string,
     threads?: number,
     logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmSyncBackend> {
-    if (!addon || !addon.MsgpackClient) {
-      throw new Error('Shared memory NAPI not available.');
+    // Import the NAPI module
+    // The addon is built to the nodejs_module directory
+    const addonPath = findNapiBinary(napiPath);
+    // Try loading
+    let addon: any = null;
+    try {
+      const require = createRequire(findPackageRoot()!);
+      addon = require(addonPath!);
+    } catch (err) {
+      // Addon not built yet or not available
+      throw new Error('Shared memory sync NAPI not available.');
     }
 
     // Create a unique shared memory name
-    const shmName = `bb-sync-${process.pid}-${instanceCounter++}`;
+    const shmName = `bb-sync-${process.pid}-${threadId}-${instanceCounter++}`;
 
     // If threads not set use 1 thread. We're not expected to do long lived work on sync backends.
     const hwc = threads ? threads.toString() : '1';
@@ -74,6 +71,28 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
       logger(`BB process logs redirected to: ${logPath}`);
     }
 
+    // Clean up any stale shared memory files from previous runs
+    // This handles the case where a previous process crashed without cleanup
+    const shmRequestPath = `/dev/shm/${shmName}_request`;
+    const shmResponsePath = `/dev/shm/${shmName}_response`;
+    try {
+      unlinkSync(shmRequestPath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmRequestPath}: ${err}`);
+      }
+    }
+
+    try {
+      unlinkSync(shmResponsePath);
+    } catch (err) {
+      const isNotFound = err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT';
+      if (!isNotFound) {
+        throw new Error(`Failed to clean up stale shared memory file ${shmResponsePath}: ${err}`);
+      }
+    }
+
     // Spawn bb process with shared memory mode (SPSC-only, no max-clients needed)
     const args = ['msgpack', 'run', '--input', `${shmName}.shm`, '--request-ring-size', `${1024 * 1024 * 4}`];
     const bbProcess = spawn(bbBinaryPath, args, {

package/src/bb_backends/node/native_shm_async.ts

@@ -3,21 +3,7 @@ import { spawn, ChildProcess } from 'child_process';
 import { openSync, closeSync } from 'fs';
 import { IMsgpackBackendAsync } from '../interface.js';
 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: any = null;
-try {
-  if (addonPath) {
-    const require = createRequire(findPackageRoot()!);
-    addon = require(addonPath);
-  }
-} catch (err) {
-  // Addon not built yet or not available
-  addon = null;
-}
+import { threadId } from 'worker_threads';
 
 let instanceCounter = 0;
 
@@ -86,18 +72,28 @@ export class BarretenbergNativeShmAsyncBackend implements IMsgpackBackendAsync {
    */
   static async new(
     bbBinaryPath: string,
+    napiPath: string,
     threads?: number,
     logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmAsyncBackend> {
-    if (!addon || !addon.MsgpackClientAsync) {
+    // Import the NAPI module
+    // The addon is built to the nodejs_module directory
+    const addonPath = findNapiBinary(napiPath);
+    // Try loading
+    let addon: any = null;
+    try {
+      const require = createRequire(findPackageRoot()!);
+      addon = require(addonPath!);
+    } catch (err) {
+      // Addon not built yet or not available
       throw new Error('Shared memory async NAPI not available.');
     }
 
     // Create a unique shared memory name
-    const shmName = `bb-async-${process.pid}-${instanceCounter++}`;
+    const shmName = `bb-async-${process.pid}-${threadId}-${instanceCounter++}`;
 
-    // If threads not set use num cpu cores, max 32 (same as socket backend)
-    const hwc = threads ? threads.toString() : '1';
+    // If threads not set use num cpu cores, max 16 (same as socket backend)
+    const hwc = threads ? threads.toString() : '16';
     const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
 
     // Set up file logging if logger is provided

package/src/bb_backends/node/native_socket.ts

@@ -4,8 +4,10 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { IMsgpackBackendAsync } from '../interface.js';
-import { findPackageRoot } from './platform.js';
 import readline from 'readline';
+import { threadId } from 'worker_threads';
+
+let instanceCounter = 0;
 
 /**
  * Asynchronous native backend that communicates with bb binary via Unix Domain Socket.
@@ -43,7 +45,7 @@ export class BarretenbergNativeSocketAsyncBackend implements IMsgpackBackendAsyn
 
   constructor(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void) {
     // Create a unique socket path in temp directory
-    this.socketPath = path.join(os.tmpdir(), `bb-${process.pid}-${Date.now()}.sock`);
+    this.socketPath = path.join(os.tmpdir(), `bb-${process.pid}-${threadId}-${instanceCounter++}.sock`);
 
     // Ensure socket path doesn't already exist (cleanup from previous crashes)
     if (fs.existsSync(this.socketPath)) {
@@ -58,9 +60,9 @@ export class BarretenbergNativeSocketAsyncBackend implements IMsgpackBackendAsyn
       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' };
+    // If threads not set use num cpu cores, max 16.
+    const hwc = threads ? threads.toString() : Math.min(16, os.cpus().length).toString();
+    const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
 
     // Spawn bb process - it will create the socket server
     const args = ['msgpack', 'run', '--input', this.socketPath];

package/src/bb_backends/node/platform.ts

@@ -24,7 +24,12 @@ export function findPackageRoot(): string | null {
   while (currentDir !== root) {
     const packageJsonPath = path.join(currentDir, 'package.json');
     if (fs.existsSync(packageJsonPath)) {
-      return currentDir;
+      // Check if this is the actual package root by verifying it has a 'build' directory
+      // This ensures we skip intermediate package.json files (e.g., in dest/node-cjs/)
+      const buildDir = path.join(currentDir, 'build');
+      if (fs.existsSync(buildDir)) {
+        return currentDir;
+      }
     }
     currentDir = path.dirname(currentDir);
   }