@aztec/bb.js 3.0.0-nightly.20251115 → 3.0.0-nightly.20251119

package/src/barretenberg/poseidon.bench.test.ts

@@ -1,9 +1,8 @@
 import { Barretenberg, BarretenbergSync } from '../index.js';
-import { Fr } from '../types/fields.js';
-import { serializeBufferable } from '../serialize/index.js';
 import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
 import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
 import { BackendType } from './index.js';
+import { Fr } from './testing/fields.js';
 
 /**
  * Async API benchmark test: WASM vs Native backends with proper non-blocking I/O
@@ -67,170 +66,129 @@ describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
     }
   }, 20000);
 
-  afterAll(async () => {
-    await wasm.destroy();
-    if (wasmApi) {
-      await wasmApi.destroy();
-    }
-    if (nativeSocketApi) {
-      await nativeSocketApi.destroy();
-    }
-    if (nativeShmApi) {
-      await nativeShmApi.destroy();
-    }
-    if (nativeShmSyncApi) {
-      nativeShmSyncApi.destroy();
-    }
-  });
-
-  async function directPoseidon2Hash(inputsBuffer: Fr[]): Promise<Fr> {
-    const inArgs = [inputsBuffer].map(serializeBufferable);
-    const outTypes = [Fr];
-    const result = wasm.callWasmExport(
-      'poseidon2_hash',
-      inArgs,
-      outTypes.map(t => t.SIZE_IN_BYTES),
-    );
-    const out = result.map((r, i) => outTypes[i].fromBuffer(r));
-    return Promise.resolve(out[0]);
-  }
-
-  it.each(SIZES)('benchmark with %p field elements', async size => {
-    // Generate random inputs
-    const inputs = Array(size)
-      .fill(0)
-      .map(() => Fr.random());
-
-    // Benchmark 1: Direct WASM (baseline - always available)
-    const directStart = performance.now();
-    for (let i = 0; i < ITERATIONS; i++) {
-      await directPoseidon2Hash(inputs);
-    }
-    const directTime = performance.now() - directStart;
+  it.each(SIZES)(
+    'benchmark with %p field elements',
+    async size => {
+      // Generate random inputs
+      const inputs = Array(size)
+        .fill(0)
+        .map(() => Fr.random().toBuffer());
 
-    // Benchmark 2: WASM (async)
-    let wasmTime = 0;
-    if (wasmApi) {
-      const wasmStart = performance.now();
-      for (let i = 0; i < ITERATIONS; i++) {
-        await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      // Benchmark 1: WASM (async)
+      let wasmTime = 0;
+      if (wasmApi) {
+        const wasmStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await wasmApi.poseidon2Hash({ inputs });
+        }
+        wasmTime = performance.now() - wasmStart;
       }
-      wasmTime = performance.now() - wasmStart;
-    }
 
-    // Benchmark 3: Native Socket (async with non-blocking I/O)
-    let nativeSocketTime = 0;
-    if (nativeSocketApi) {
-      const nativeSocketStart = performance.now();
-      for (let i = 0; i < ITERATIONS; i++) {
-        await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      // Benchmark 2: Native Socket (async with non-blocking I/O)
+      let nativeSocketTime = 0;
+      if (nativeSocketApi) {
+        const nativeSocketStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await nativeSocketApi.poseidon2Hash({ inputs });
+        }
+        nativeSocketTime = performance.now() - nativeSocketStart;
       }
-      nativeSocketTime = performance.now() - nativeSocketStart;
-    }
 
-    // Benchmark 4: Native Shared Memory (async)
-    let nativeShmTime = 0;
-    if (nativeShmApi) {
-      const nativeShmStart = performance.now();
-      for (let i = 0; i < ITERATIONS; i++) {
-        await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      // Benchmark 3: Native Shared Memory (async)
+      let nativeShmTime = 0;
+      if (nativeShmApi) {
+        const nativeShmStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          await nativeShmApi.poseidon2Hash({ inputs });
+        }
+        nativeShmTime = performance.now() - nativeShmStart;
       }
-      nativeShmTime = performance.now() - nativeShmStart;
-    }
 
-    // Benchmark 5: Native Shared Memory (sync)
-    let nativeShmSyncTime = 0;
-    if (nativeShmSyncApi) {
-      const nativeShmSyncStart = performance.now();
-      for (let i = 0; i < ITERATIONS; i++) {
-        nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
+      // Benchmark 4: Native Shared Memory (sync)
+      let nativeShmSyncTime = 0;
+      if (nativeShmSyncApi) {
+        const nativeShmSyncStart = performance.now();
+        for (let i = 0; i < ITERATIONS; i++) {
+          nativeShmSyncApi.poseidon2Hash({ inputs });
+        }
+        nativeShmSyncTime = performance.now() - nativeShmSyncStart;
       }
-      nativeShmSyncTime = performance.now() - nativeShmSyncStart;
-    }
-
-    // Calculate metrics (all relative to WASM baseline)
-    const directOverhead = ((directTime - wasmTime) / wasmTime) * 100;
-    const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
-    const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
-    const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
 
-    const avgDirectTimeUs = (directTime / ITERATIONS) * 1000; // microseconds
-    const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
-    const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
-    const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
-    const avgNativeShmSyncTimeUs = (nativeShmSyncTime / ITERATIONS) * 1000;
+      // Calculate metrics (all relative to WASM baseline)
+      const nativeSocketOverhead = ((nativeSocketTime - wasmTime) / wasmTime) * 100;
+      const nativeShmOverhead = ((nativeShmTime - wasmTime) / wasmTime) * 100;
+      const nativeShmSyncOverhead = ((nativeShmSyncTime - wasmTime) / wasmTime) * 100;
 
-    process.stdout.write(`┌─ Size ${size.toString().padStart(3)} field elements ──────────────────────────────────┐\n`);
-    const formatOverhead = (overhead: number): string => {
-      const sign = overhead >= 0 ? '+' : '-';
-      const value = Math.abs(overhead).toFixed(1).padStart(6);
-      return `${sign}${value}%`;
-    };
+      const avgWasmTimeUs = (wasmTime / ITERATIONS) * 1000;
+      const avgNativeSocketTimeUs = (nativeSocketTime / ITERATIONS) * 1000;
+      const avgNativeShmTimeUs = (nativeShmTime / ITERATIONS) * 1000;
+      const avgNativeShmSyncTimeUs = (nativeShmSyncTime / ITERATIONS) * 1000;
 
-    if (wasmApi) {
       process.stdout.write(
-        `│ WASM:               ${wasmTime.toFixed(2).padStart(8)}ms (${avgWasmTimeUs.toFixed(2).padStart(7)}µs/call) [baseline] │\n`,
+        `┌─ Size ${size.toString().padStart(3)} field elements ──────────────────────────────────┐\n`,
       );
-    } else {
-      process.stdout.write(`│ WASM:                                          unavailable │\n`);
-    }
+      const formatOverhead = (overhead: number): string => {
+        const sign = overhead >= 0 ? '+' : '-';
+        const value = Math.abs(overhead).toFixed(1).padStart(6);
+        return `${sign}${value}%`;
+      };
 
-    process.stdout.write(
-      `│ Direct WASM:        ${directTime.toFixed(2).padStart(8)}ms (${avgDirectTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(directOverhead)}   │\n`,
-    );
-
-    if (nativeSocketApi) {
-      process.stdout.write(
-        `│ Native Socket:      ${nativeSocketTime.toFixed(2).padStart(8)}ms (${avgNativeSocketTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeSocketOverhead)}   │\n`,
-      );
-    } else {
-      process.stdout.write(`│ Native Socket:                                 unavailable │\n`);
-    }
+      if (wasmApi) {
+        process.stdout.write(
+          `│ WASM:               ${wasmTime.toFixed(2).padStart(8)}ms (${avgWasmTimeUs.toFixed(2).padStart(7)}µs/call) [baseline] │\n`,
+        );
+      } else {
+        process.stdout.write(`│ WASM:                                          unavailable │\n`);
+      }
 
-    if (nativeShmApi) {
-      process.stdout.write(
-        `│ Native Shared:      ${nativeShmTime.toFixed(2).padStart(8)}ms (${avgNativeShmTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmOverhead)}   │\n`,
-      );
-    } else {
-      process.stdout.write(`│ Native Shared:                                 unavailable │\n`);
-    }
+      if (nativeSocketApi) {
+        process.stdout.write(
+          `│ Native Socket:      ${nativeSocketTime.toFixed(2).padStart(8)}ms (${avgNativeSocketTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeSocketOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Socket:                                 unavailable │\n`);
+      }
 
-    if (nativeShmSyncApi) {
-      process.stdout.write(
-        `│ Native Shared Sync: ${nativeShmSyncTime.toFixed(2).padStart(8)}ms (${avgNativeShmSyncTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmSyncOverhead)}   │\n`,
-      );
-    } else {
-      process.stdout.write(`│ Native Shared Sync:                            unavailable │\n`);
-    }
+      if (nativeShmApi) {
+        process.stdout.write(
+          `│ Native Shared:      ${nativeShmTime.toFixed(2).padStart(8)}ms (${avgNativeShmTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared:                                 unavailable │\n`);
+      }
 
-    process.stdout.write(`└────────────────────────────────────────────────────────────┘\n`);
+      if (nativeShmSyncApi) {
+        process.stdout.write(
+          `│ Native Shared Sync: ${nativeShmSyncTime.toFixed(2).padStart(8)}ms (${avgNativeShmSyncTimeUs.toFixed(2).padStart(7)}µs/call) ${formatOverhead(nativeShmSyncOverhead)}   │\n`,
+        );
+      } else {
+        process.stdout.write(`│ Native Shared Sync:                            unavailable │\n`);
+      }
 
-    // Sanity check: verify all backends produce same result as direct WASM
-    const directResult = await directPoseidon2Hash(inputs);
+      process.stdout.write(`└────────────────────────────────────────────────────────────┘\n`);
 
-    if (wasmApi) {
-      const wasmResult = await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(wasmResult.hash)).toEqual(directResult.toBuffer());
-    }
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
 
-    if (nativeSocketApi) {
-      const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
-    }
+      if (nativeSocketApi) {
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
+      }
 
-    if (nativeShmApi) {
-      const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
-    }
+      if (nativeShmApi) {
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
+      }
 
-    if (nativeShmSyncApi) {
-      const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-      expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
-    }
+      if (nativeShmSyncApi) {
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
+      }
 
-    // Test always passes, this is just for measuring performance
-    expect(true).toBe(true);
-  });
+      // Test always passes, this is just for measuring performance
+      expect(true).toBe(true);
+    },
+    10000,
+  );
 
   const TEST_VECTORS = [1, 2, 3, 5, 10, 50, 100];
   const NUM_RANDOM_TESTS = 10;
@@ -240,28 +198,23 @@ describe('poseidon2Hash benchmark (Async API): WASM vs Native', () => {
     for (let test = 0; test < NUM_RANDOM_TESTS; test++) {
       const inputs = Array(size)
         .fill(0)
-        .map(() => Fr.random());
+        .map(() => Fr.random().toBuffer());
 
-      const directResult = await directPoseidon2Hash(inputs);
-
-      if (wasmApi) {
-        const wasmResult = await wasmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(wasmResult.hash)).toEqual(directResult.toBuffer());
-      }
+      const wasmResult = await wasmApi!.poseidon2Hash({ inputs });
 
       if (nativeSocketApi) {
-        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeSocketResult.hash)).toEqual(directResult.toBuffer());
+        const nativeSocketResult = await nativeSocketApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeSocketResult.hash)).toEqual(wasmResult.hash);
       }
 
       if (nativeShmApi) {
-        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeShmResult.hash)).toEqual(directResult.toBuffer());
+        const nativeShmResult = await nativeShmApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmResult.hash)).toEqual(wasmResult.hash);
       }
 
       if (nativeShmSyncApi) {
-        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs: inputs.map(fr => fr.toBuffer()) });
-        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(directResult.toBuffer());
+        const nativeShmSyncResult = nativeShmSyncApi.poseidon2Hash({ inputs });
+        expect(Buffer.from(nativeShmSyncResult.hash)).toEqual(wasmResult.hash);
       }
     }
   });

package/src/barretenberg/poseidon.test.ts

@@ -1,6 +1,6 @@
 import { BarretenbergSync } from './index.js';
 import { Timer } from '../benchmark/timer.js';
-import { Fr } from '../types/index.js';
+import { Fr } from './testing/fields.js';
 
 describe('poseidon sync', () => {
   let api: BarretenbergSync;

package/src/{types → barretenberg/testing}/fields.ts

@@ -1,17 +1,11 @@
-import { randomBytes } from '../random/index.js';
+import { randomBytes } from '../../random/index.js';
 import {
   buffer32BytesToBigIntBE,
   uint8ArrayToBigIntBE,
   bigIntToBufferBE,
   bigIntToUint8ArrayBE,
-} from '../bigint-array/index.js';
+} from './bigint-buffer.js';
 
-/**
- * Internal Fr field class for tests.
- * @dev This minimal implementation is provided for testing barretenberg directly.
- * Projects using bb.js should create their own field abstraction using the curve constants
- * exported from the barretenberg binary (see CurveConstants generation).
- */
 export class Fr {
   static ZERO = new Fr(0n);
   static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
@@ -41,24 +35,6 @@ export class Fr {
     return new this(r);
   }
 
-  static fromBuffer(buffer: Uint8Array | Buffer) {
-    if (buffer.length !== this.SIZE_IN_BYTES) {
-      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
-    }
-    return new this(buffer);
-  }
-
-  static fromBufferReduce(buffer: Uint8Array | Buffer) {
-    if (buffer.length !== this.SIZE_IN_BYTES) {
-      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
-    }
-    return new this(uint8ArrayToBigIntBE(buffer instanceof Buffer ? new Uint8Array(buffer) : buffer) % Fr.MODULUS);
-  }
-
-  static fromString(str: string) {
-    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ''), 'hex'));
-  }
-
   toBuffer() {
     return this.value;
   }
@@ -74,4 +50,14 @@ export class Fr {
   isZero() {
     return this.value.every(v => v === 0);
   }
+
+  static fromBuffer(value: Uint8Array): Fr {
+    return Fr.fromBufferReduce(value);
+  }
+
+  static fromBufferReduce(value: Uint8Array): Fr {
+    const valueBigInt = uint8ArrayToBigIntBE(value);
+    const reducedValue = valueBigInt % Fr.MODULUS;
+    return new Fr(reducedValue);
+  }
 }

package/src/bb_backends/browser/platform.ts

@@ -0,0 +1,11 @@
+export function findPackageRoot(): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findBbBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}
+
+export function findNapiBinary(customPath?: string): string | null {
+  throw new Error('Not implemented in browser environment.');
+}

package/src/bb_backends/index.ts

@@ -3,13 +3,13 @@
  */
 export enum BackendType {
   /** WASM direct execution (no worker) */
-  Wasm = 'wasm',
+  Wasm = 'Wasm',
   /** WASM with worker threads */
-  WasmWorker = 'wasm-worker',
+  WasmWorker = 'WasmWorker',
   /** Native via Unix domain socket (async only) */
-  NativeUnixSocket = 'native-unix-socket',
+  NativeUnixSocket = 'NativeUnixSocket',
   /** Native via shared memory (sync only currently) */
-  NativeSharedMemory = 'native-shared-mem',
+  NativeSharedMemory = 'NativeSharedMemory',
 }
 
 export type BackendOptions = {
@@ -28,7 +28,10 @@ export type BackendOptions = {
   /** @description Custom path to bb binary for native backend (overrides automatic detection) */
   bbPath?: string;
 
-  /** @description Logging function */
+  /**
+   * @description Logging function
+   * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.
+   */
   logger?: (msg: string) => void;
 
   /**

package/src/bb_backends/node/index.ts

@@ -14,6 +14,11 @@ export async function createAsyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<Barretenberg> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeUnixSocket: {
       const bbPath = findBbBinary(options.bbPath);
@@ -21,7 +26,7 @@ export async function createAsyncBackend(
         throw new Error('Native backend requires bb binary.');
       }
       logger(`Using native Unix socket backend: ${bbPath}`);
-      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads);
+      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
       return new Barretenberg(socket, options);
     }
 
@@ -36,7 +41,12 @@ export async function createAsyncBackend(
       }
       logger(`Using native shared memory backend (via sync adapter): ${bbPath}`);
       // Use sync backend with adapter to provide async interface
-      const syncBackend = await BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.maxClients);
+      const syncBackend = await BarretenbergNativeShmSyncBackend.new(
+        bbPath,
+        options.threads,
+        options.maxClients,
+        options.logger,
+      );
       const asyncBackend = new SyncToAsyncAdapter(syncBackend);
       return new Barretenberg(asyncBackend, options);
     }
@@ -68,6 +78,11 @@ export async function createSyncBackend(
   options: BackendOptions,
   logger: (msg: string) => void,
 ): Promise<BarretenbergSync> {
+  options = {
+    ...options,
+    wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+  };
+
   switch (type) {
     case BackendType.NativeSharedMemory: {
       const bbPath = findBbBinary(options.bbPath);
@@ -79,7 +94,12 @@ export async function createSyncBackend(
         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.maxClients);
+      const shm = await BarretenbergNativeShmSyncBackend.new(
+        bbPath,
+        options.threads,
+        options.maxClients,
+        options.logger,
+      );
       return new BarretenbergSync(shm);
     }
 

package/src/bb_backends/node/native_shm.ts

@@ -1,7 +1,9 @@
 import { createRequire } from 'module';
 import { spawn, ChildProcess } from 'child_process';
+import { openSync, closeSync } from 'fs';
 import { IMsgpackBackendSync } from '../interface.js';
 import { findNapiBinary, findPackageRoot } from './platform.js';
+import readline from 'readline';
 
 // Import the NAPI module
 // The addon is built to the nodejs_module directory
@@ -32,10 +34,12 @@ try {
 export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
   private process: ChildProcess;
   private client: any; // NAPI MsgpackClient instance
+  private logFd?: number; // File descriptor for logs
 
-  private constructor(process: ChildProcess, client: any) {
+  private constructor(process: ChildProcess, client: any, logFd?: number) {
     this.process = process;
     this.client = client;
+    this.logFd = logFd;
   }
 
   /**
@@ -48,6 +52,7 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
     bbBinaryPath: string,
     threads?: number,
     maxClients?: number,
+    logger?: (msg: string) => void,
   ): Promise<BarretenbergNativeShmSyncBackend> {
     if (!addon || !addon.MsgpackClient) {
       throw new Error('Shared memory NAPI not available.');
@@ -59,22 +64,40 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
     // 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;
+    // If threads not set use 1 thread. We're not expected to do long lived work on sync backends.
+    const hwc = threads ? threads.toString() : '1';
+    const env = { ...process.env, HARDWARE_CONCURRENCY: '1' };
+
+    // Set up file logging if logger is provided.
+    // Direct file redirection bypasses Node event loop - logs are written even if process hangs.
+    let logFd: number | undefined;
+    let logPath: string | undefined;
+    if (logger) {
+      logPath = `/tmp/${shmName}.log`;
+      logFd = openSync(logPath, 'w');
+      logger(`BB process logs redirected to: ${logPath}`);
+    }
 
     // Spawn bb process with shared memory mode
-    const args = [bbBinaryPath, 'msgpack', 'run', '--input', `${shmName}.shm`, '--max-clients', clientCount.toString()];
-    const bbProcess = spawn(findPackageRoot() + '/scripts/kill_wrapper.sh', args, {
-      stdio: ['ignore', 'ignore', 'ignore'],
+    const args = [
+      'msgpack',
+      'run',
+      '--input',
+      `${shmName}.shm`,
+      '--max-clients',
+      clientCount.toString(),
+      '--request-ring-size',
+      `${1024 * 1024 * 2}`,
+    ];
+    const bbProcess = spawn(bbBinaryPath, args, {
+      stdio: ['ignore', logFd ?? 'ignore', logFd ?? '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();
-    // });
+    // 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;
@@ -133,12 +156,19 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
         throw new Error('Failed to create client connection');
       }
 
-      return new BarretenbergNativeShmSyncBackend(bbProcess, client);
+      return new BarretenbergNativeShmSyncBackend(bbProcess, client, logFd);
     } finally {
-      // If we failed to connect, ensure the process is killed
+      // If we failed to connect, ensure the process is killed and log file closed
       // kill() returns false if process already exited, but doesn't throw
       if (!client) {
         bbProcess.kill('SIGKILL');
+        if (logFd !== undefined) {
+          try {
+            closeSync(logFd);
+          } catch (e) {
+            // Ignore errors during cleanup
+          }
+        }
       }
     }
   }
@@ -160,6 +190,13 @@ export class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
         // Ignore errors during cleanup
       }
     }
+    if (this.logFd !== undefined) {
+      try {
+        closeSync(this.logFd);
+      } catch (e) {
+        // Ignore errors during cleanup
+      }
+    }
   }
 
   destroy(): void {