@aztec/bb.js 3.0.0-nightly.20251016 → 3.0.0-nightly.20251023

package/src/barretenberg/poseidon.test.ts

@@ -10,30 +10,30 @@ describe('poseidon sync', () => {
   });
 
   it('poseidonHash', () => {
-    const result = api.poseidon2Hash([new Fr(4n), new Fr(8n)]);
+    const result = api.poseidon2Hash({ inputs: [new Fr(4n).toBuffer(), new Fr(8n).toBuffer()] });
     expect(result).toMatchSnapshot();
   });
 
   it('poseidonHash perf test', () => {
     const loops = 1000;
-    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random());
+    const fields = Array.from({ length: loops * 2 }).map(() => Fr.random().toBuffer());
     const t = new Timer();
     for (let i = 0; i < loops; ++i) {
-      api.poseidon2Hash([fields[i * 2], fields[i * 2 + 1]]);
+      api.poseidon2Hash({ inputs: [fields[i * 2], fields[i * 2 + 1]] });
     }
     const us = t.us() / loops;
     console.log(`Executed ${loops} hashes at an average ${us}us / hash`);
   });
 
-  it('poseidonHashes perf test', () => {
-    const loops = 10;
-    const numHashesPerLoop = 1024;
-    const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
-    const t = new Timer();
-    for (let i = 0; i < loops; ++i) {
-      api.poseidon2Hashes(fields);
-    }
-    const us = t.us() / (numHashesPerLoop * loops);
-    console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
-  });
+  // it('poseidonHashes perf test', () => {
+  //   const loops = 10;
+  //   const numHashesPerLoop = 1024;
+  //   const fields = Array.from({ length: numHashesPerLoop * 2 }).map(() => Fr.random());
+  //   const t = new Timer();
+  //   for (let i = 0; i < loops; ++i) {
+  //     api.poseidon2Hashes(fields);
+  //   }
+  //   const us = t.us() / (numHashesPerLoop * loops);
+  //   console.log(`Executed ${numHashesPerLoop * loops} hashes at an average ${us}us / hash`);
+  // });
 });

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -121,12 +121,12 @@ export class BarretenbergWasmBase {
     mem.set(arr, offset);
   }
 
-  // PRIVATE METHODS
-
-  private getMemory() {
+  public getMemory() {
     return new Uint8Array(this.memory.buffer);
   }
 
+  // PRIVATE METHODS
+
   private stringFromAddress(addr: number) {
     addr = addr >>> 0;
     const m = this.getMemory();

package/src/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.ts

@@ -5,25 +5,29 @@ import { type BarretenbergWasmMain } from './index.js';
  * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
  * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
  * Heap allocations will be created for input/output args that don't fit into the scratch space.
- * Input and output args can use the same scratch space as it's assume all input reads will be performed before any
- * output writes are performed.
+ * Input scratch grows UP from 0, output scratch grows DOWN from 1024, meeting in the middle.
+ * This maximizes space utilization while preventing overlap.
  */
 export class HeapAllocator {
   private allocs: number[] = [];
-  private inScratchRemaining = 1024;
-  private outScratchRemaining = 1024;
+  private inScratchPtr = 0;      // Next input starts here, grows UP
+  private outScratchPtr = 1024;  // Next output ends here, grows DOWN
 
   constructor(private wasm: BarretenbergWasmMain) {}
 
   getInputs(buffers: (Uint8Array | number)[]) {
     return buffers.map(bufOrNum => {
       if (typeof bufOrNum === 'object') {
-        if (bufOrNum.length <= this.inScratchRemaining) {
-          const ptr = (this.inScratchRemaining -= bufOrNum.length);
+        const size = bufOrNum.length;
+        // Check if there's room in scratch space (inputs grow up, outputs grow down)
+        if (this.inScratchPtr + size <= this.outScratchPtr) {
+          const ptr = this.inScratchPtr;
+          this.inScratchPtr += size;  // Grow UP
           this.wasm.writeMemory(ptr, bufOrNum);
           return ptr;
         } else {
-          const ptr = this.wasm.call('bbmalloc', bufOrNum.length);
+          // Fall back to heap allocation
+          const ptr = this.wasm.call('bbmalloc', size);
           this.wasm.writeMemory(ptr, bufOrNum);
           this.allocs.push(ptr);
           return ptr;
@@ -40,9 +44,12 @@ export class HeapAllocator {
       // WARNING: 4 only works with WASM as it has 32 bit memory.
       const size = len || 4;
 
-      if (size <= this.outScratchRemaining) {
-        return (this.outScratchRemaining -= size);
+      // Check if there's room in scratch space (inputs grow up, outputs grow down)
+      if (this.inScratchPtr + size <= this.outScratchPtr) {
+        this.outScratchPtr -= size;  // Grow DOWN
+        return this.outScratchPtr;
       } else {
+        // Fall back to heap allocation
         const ptr = this.wasm.call('bbmalloc', size);
         this.allocs.push(ptr);
         return ptr;
@@ -51,6 +58,7 @@ export class HeapAllocator {
   }
 
   addOutputPtr(ptr: number) {
+    // Only add to dealloc list if it's a heap allocation (not in scratch space 0-1023)
     if (ptr >= 1024) {
       this.allocs.push(ptr);
     }

package/src/barretenberg_wasm/barretenberg_wasm_main/index.ts

@@ -19,6 +19,11 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   private nextWorker = 0;
   private nextThreadId = 1;
 
+  // Pre-allocated scratch buffers for msgpack I/O to avoid malloc/free overhead
+  private msgpackInputScratch: number = 0; // 8MB input buffer
+  private msgpackOutputScratch: number = 0; // 8MB output buffer
+  private readonly MSGPACK_SCRATCH_SIZE = 1024 * 1024 * 8; // 8MB
+
   public getNumThreads() {
     return this.workers.length + 1;
   }
@@ -54,6 +59,14 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
     // Init all global/static data.
     this.call('_initialize');
 
+    // Allocate dedicated msgpack scratch buffers (never freed, reused for all msgpack calls)
+    this.msgpackInputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.msgpackOutputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+    this.logger(
+      `Allocated msgpack scratch buffers: ` +
+        `input @ ${this.msgpackInputScratch}, output @ ${this.msgpackOutputScratch} (${this.MSGPACK_SCRATCH_SIZE} bytes each)`,
+    );
+
     // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
     if (threads > 1) {
       this.logger(`Creating ${threads} worker threads`);
@@ -138,25 +151,63 @@ export class BarretenbergWasmMain extends BarretenbergWasmBase {
   }
 
   cbindCall(cbind: string, inputBuffer: Uint8Array): any {
-    const outputSizePtr = this.call('bbmalloc', 4);
-    const outputMsgpackPtr = this.call('bbmalloc', 4);
+    const needsCustomInputBuffer = inputBuffer.length > this.MSGPACK_SCRATCH_SIZE;
+    let inputPtr: number;
+
+    if (needsCustomInputBuffer) {
+      // Allocate temporary buffer for oversized input
+      inputPtr = this.call('bbmalloc', inputBuffer.length);
+    } else {
+      // Use pre-allocated scratch buffer
+      inputPtr = this.msgpackInputScratch;
+    }
 
-    const inputPtr = this.call('bbmalloc', inputBuffer.length);
+    // Write input to buffer
     this.writeMemory(inputPtr, inputBuffer);
-    this.call(cbind, inputPtr, inputBuffer.length, outputMsgpackPtr, outputSizePtr);
 
-    const readPtr32 = (ptr32: number) => {
-      const dataView = new DataView(this.getMemorySlice(ptr32, ptr32 + 4).buffer);
-      return dataView.getUint32(0, true);
-    };
+    // Setup output scratch buffer with IN-OUT parameter pattern:
+    // Reserve 8 bytes for metadata (pointer + size), rest is scratch data space
+    const METADATA_SIZE = 8;
+    const outputPtrLocation = this.msgpackOutputScratch;
+    const outputSizeLocation = this.msgpackOutputScratch + 4;
+    const scratchDataPtr = this.msgpackOutputScratch + METADATA_SIZE;
+    const scratchDataSize = this.MSGPACK_SCRATCH_SIZE - METADATA_SIZE;
+
+    // Get memory and create DataView for writing IN values
+    let mem = this.getMemory();
+    let view = new DataView(mem.buffer);
+
+    // Write IN values: provide scratch buffer pointer and size to C++
+    view.setUint32(outputPtrLocation, scratchDataPtr, true);
+    view.setUint32(outputSizeLocation, scratchDataSize, true);
+
+    // Call WASM
+    this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+
+    // Free custom input buffer if allocated
+    if (needsCustomInputBuffer) {
+      this.call('bbfree', inputPtr);
+    }
+
+    // Re-fetch memory after WASM call, as the buffer may have been detached if memory grew
+    mem = this.getMemory();
+    view = new DataView(mem.buffer);
+
+    // Read OUT values: C++ returns actual buffer pointer and size
+    const outputDataPtr = view.getUint32(outputPtrLocation, true);
+    const outputSize = view.getUint32(outputSizeLocation, true);
+
+    // Check if C++ used scratch (pointer unchanged) or allocated (pointer changed)
+    const usedScratch = outputDataPtr === scratchDataPtr;
+
+    // Copy output data from WASM memory
+    const encodedResult = this.getMemorySlice(outputDataPtr, outputDataPtr + outputSize);
+
+    // Only free if C++ allocated beyond scratch
+    if (!usedScratch) {
+      this.call('bbfree', outputDataPtr);
+    }
 
-    const encodedResult = this.getMemorySlice(
-      readPtr32(outputMsgpackPtr),
-      readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr),
-    );
-    this.call('bbfree', inputPtr);
-    this.call('bbfree', outputSizePtr);
-    this.call('bbfree', outputMsgpackPtr);
     return encodedResult;
   }
 }

package/src/barretenberg_wasm/index.test.ts

@@ -1,17 +1,23 @@
-import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from './barretenberg_wasm_main/index.js';
-import { Barretenberg } from '../index.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { Worker } from 'worker_threads';
 
 describe('barretenberg wasm', () => {
-  let api: Barretenberg;
   let wasm: BarretenbergWasmMainWorker;
+  let worker: Worker;
 
   beforeAll(async () => {
-    api = await Barretenberg.new({ threads: 2 });
-    wasm = api.getWasm();
+    worker = await createMainWorker();
+    wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+    const { module, threads } = await fetchModuleAndThreads(2);
+    await wasm.init(module, threads);
   }, 20000);
 
   afterAll(async () => {
-    await api.destroy();
+    await wasm.destroy();
+    await worker.terminate();
   });
 
   it('should new malloc, transfer and slice mem', async () => {
@@ -28,11 +34,6 @@ describe('barretenberg wasm', () => {
     await expect(() => wasm.call('test_abort')).rejects.toThrow();
   });
 
-  it('test c/c++ stdout/stderr', async () => {
-    // We're checking we don't crash, but you can manually confirm you see log lines handled by logstr.
-    await wasm.call('test_stdout_stderr');
-  });
-
   it('should new malloc, transfer and slice mem', async () => {
     const length = 1024;
     const ptr = await wasm.call('bbmalloc', length);

package/src/bb_backends/browser/index.ts

@@ -0,0 +1,50 @@
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<Barretenberg> {
+  switch (type) {
+    case BackendType.Wasm:
+    case BackendType.WasmWorker: {
+      const useWorker = type === BackendType.WasmWorker;
+      logger(`Using WASM backend (worker: ${useWorker})`);
+      const wasm = await BarretenbergWasmAsyncBackend.new({
+        threads: options.threads,
+        wasmPath: options.wasmPath,
+        logger,
+        memory: options.memory,
+        useWorker,
+      });
+      return new Barretenberg(wasm, options);
+    }
+
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<BarretenbergSync> {
+  switch (type) {
+    case BackendType.Wasm:
+      logger('Using WASM backend');
+      const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+      return new BarretenbergSync(wasm);
+
+    default:
+      throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+  }
+}

package/src/bb_backends/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Backend types for Barretenberg
+ */
+export enum BackendType {
+  /** WASM direct execution (no worker) */
+  Wasm = 'wasm',
+  /** WASM with worker threads */
+  WasmWorker = 'wasm-worker',
+  /** Native via Unix domain socket (async only) */
+  NativeUnixSocket = 'native-unix-socket',
+  /** Native via shared memory (sync only currently) */
+  NativeSharedMemory = 'native-shared-mem',
+}
+
+export type BackendOptions = {
+  /** @description Number of threads to run the backend worker on */
+  threads?: number;
+
+  /** @description Initial and Maximum memory to be alloted to the backend worker */
+  memory?: { initial?: number; maximum?: number };
+
+  /** @description Path to download CRS files */
+  crsPath?: string;
+
+  /** @description Path to download WASM files */
+  wasmPath?: string;
+
+  /** @description Custom path to bb binary for native backend (overrides automatic detection) */
+  bbPath?: string;
+
+  /** @description Logging function */
+  logger?: (msg: string) => void;
+
+  /**
+   * @description Maximum concurrent clients for shared memory IPC server (default: 1)
+   * Only applies to NativeSharedMemory backend
+   */
+  maxClients?: number;
+
+  /**
+   * @description Specify exact backend to use
+   * - If unset: tries backends in default order with fallback
+   * - If set: must succeed with specified backend or throw error (no fallback)
+   *
+   * Barretenberg (async) supports: all types
+   * BarretenbergSync supports: Wasm, NativeSharedMem only
+   */
+  backend?: BackendType;
+};

package/src/bb_backends/interface.ts

@@ -0,0 +1,35 @@
+/**
+ * Generic interface for msgpack backend implementations.
+ * Both WASM and native binary backends implement this interface.
+ */
+export interface IMsgpackBackend {
+  /**
+   * Execute a msgpack command and return the msgpack response.
+   * @param inputBuffer The msgpack-encoded input buffer
+   * @returns The msgpack-encoded response buffer (sync or async)
+   */
+  call(inputBuffer: Uint8Array): Uint8Array | Promise<Uint8Array>;
+
+  /**
+   * Clean up resources.
+   */
+  destroy(): void | Promise<void>;
+}
+
+/**
+ * Synchronous variant of IMsgpackBackend.
+ * Used by BarretenbergSync and SyncApi.
+ */
+export interface IMsgpackBackendSync extends IMsgpackBackend {
+  call(inputBuffer: Uint8Array): Uint8Array;
+  destroy(): void;
+}
+
+/**
+ * Asynchronous variant of IMsgpackBackend.
+ * Used by Barretenberg and AsyncApi.
+ */
+export interface IMsgpackBackendAsync extends IMsgpackBackend {
+  call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+  destroy(): Promise<void>;
+}

package/src/bb_backends/node/index.ts

@@ -0,0 +1,94 @@
+import { BarretenbergNativeSocketAsyncBackend } from './native_socket.js';
+import { BarretenbergWasmSyncBackend, BarretenbergWasmAsyncBackend } from '../wasm.js';
+import { BarretenbergNativeShmSyncBackend } from './native_shm.js';
+import { SyncToAsyncAdapter } from '../sync_to_async_adapter.js';
+import { findBbBinary, findNapiBinary } from './platform.js';
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createAsyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<Barretenberg> {
+  switch (type) {
+    case BackendType.NativeUnixSocket: {
+      const bbPath = findBbBinary(options.bbPath);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      logger(`Using native Unix socket backend: ${bbPath}`);
+      const socket = new BarretenbergNativeSocketAsyncBackend(bbPath, options.threads);
+      return new Barretenberg(socket, options);
+    }
+
+    case BackendType.NativeSharedMemory: {
+      const bbPath = findBbBinary(options.bbPath);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      const napiPath = findNapiBinary();
+      if (!napiPath) {
+        throw new Error('Native sync backend requires napi client stub.');
+      }
+      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 asyncBackend = new SyncToAsyncAdapter(syncBackend);
+      return new Barretenberg(asyncBackend, options);
+    }
+
+    case BackendType.Wasm:
+    case BackendType.WasmWorker: {
+      const useWorker = type === BackendType.WasmWorker;
+      logger(`Using WASM backend (worker: ${useWorker})`);
+      const wasm = await BarretenbergWasmAsyncBackend.new({
+        threads: options.threads,
+        wasmPath: options.wasmPath,
+        logger: options.logger,
+        memory: options.memory,
+        useWorker,
+      });
+      return new Barretenberg(wasm, options);
+    }
+
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
+/**
+ * Create backend of specific type (no fallback)
+ */
+export async function createSyncBackend(
+  type: BackendType,
+  options: BackendOptions,
+  logger: (msg: string) => void,
+): Promise<BarretenbergSync> {
+  switch (type) {
+    case BackendType.NativeSharedMemory: {
+      const bbPath = findBbBinary(options.bbPath);
+      if (!bbPath) {
+        throw new Error('Native backend requires bb binary.');
+      }
+      const napiPath = findNapiBinary();
+      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.maxClients);
+      return new BarretenbergSync(shm);
+    }
+
+    case BackendType.Wasm:
+      logger('Using WASM backend');
+      const wasm = await BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+      return new BarretenbergSync(wasm);
+
+    default:
+      throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+  }
+}

package/src/bb_backends/node/native_pipe.ts

@@ -0,0 +1,127 @@
+import { spawn, ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from '../interface.js';
+
+/**
+ * Asynchronous native backend that communicates with bb binary via stdin/stdout.
+ * Uses event-based I/O with a state machine to handle partial reads.
+ *
+ * Protocol:
+ * - Request: 4-byte little-endian length + msgpack buffer
+ * - Response: 4-byte little-endian length + msgpack buffer
+ */
+export class BarretenbergNativePipeAsyncBackend implements IMsgpackBackendAsync {
+  private process: ChildProcess;
+  private pendingResolve: ((data: Uint8Array) => void) | null = null;
+  private pendingReject: ((error: Error) => void) | null = null;
+
+  // State machine for reading responses
+  private readingLength: boolean = true;
+  private lengthBuffer: Buffer = Buffer.alloc(4);
+  private lengthBytesRead: number = 0;
+  private responseLength: number = 0;
+  private responseBuffer: Buffer | null = null;
+  private responseBytesRead: number = 0;
+
+  constructor(bbBinaryPath: string) {
+    this.process = spawn(bbBinaryPath, ['msgpack', 'run'], {
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+
+    this.process.stdout!.on('data', (chunk: Buffer) => {
+      this.handleData(chunk);
+    });
+
+    this.process.on('error', err => {
+      if (this.pendingReject) {
+        this.pendingReject(new Error(`Native backend process error: ${err.message}`));
+        this.pendingReject = null;
+        this.pendingResolve = null;
+      }
+    });
+
+    this.process.on('exit', (code, signal) => {
+      if (this.pendingReject) {
+        if (code !== null && code !== 0) {
+          this.pendingReject(new Error(`Native backend process exited with code ${code}`));
+        } else if (signal) {
+          if (signal != 'SIGTERM') {
+            this.pendingReject(new Error(`Native backend process killed with signal ${signal}`));
+          }
+        } else {
+          this.pendingReject(new Error('Native backend process exited unexpectedly'));
+        }
+        this.pendingReject = null;
+        this.pendingResolve = null;
+      }
+    });
+  }
+
+  private handleData(chunk: Buffer): void {
+    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
+          if (this.pendingResolve) {
+            this.pendingResolve(new Uint8Array(this.responseBuffer!));
+            this.pendingResolve = null;
+            this.pendingReject = null;
+          }
+
+          // Reset state for next message
+          this.readingLength = true;
+          this.lengthBytesRead = 0;
+          this.responseLength = 0;
+          this.responseBuffer = null;
+          this.responseBytesRead = 0;
+        }
+      }
+    }
+  }
+
+  async call(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    if (this.pendingResolve) {
+      throw new Error('Cannot call while another call is pending (no pipelining supported)');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.pendingResolve = resolve;
+      this.pendingReject = reject;
+
+      // Write request: 4-byte little-endian length + msgpack data
+      const lengthBuf = Buffer.alloc(4);
+      lengthBuf.writeUInt32LE(inputBuffer.length, 0);
+      this.process.stdin!.write(lengthBuf);
+      this.process.stdin!.write(inputBuffer);
+    });
+  }
+
+  async destroy(): Promise<void> {
+    this.process.kill();
+    return new Promise(resolve => {
+      this.process.once('exit', () => resolve());
+    });
+  }
+}