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

package/src/bb_backends/wasm.ts

@@ -0,0 +1,110 @@
+import { BarretenbergWasmMain, BarretenbergWasmMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
+import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';
+import { IMsgpackBackendSync, IMsgpackBackendAsync } from './interface.js';
+import { createMainWorker } from '../barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js';
+import { getRemoteBarretenbergWasm } from '../barretenberg_wasm/helpers/index.js';
+import { createDebugLogger } from '../log/index.js';
+import { proxy } from 'comlink';
+
+/**
+ * Synchronous WASM backend that wraps BarretenbergWasmMain.
+ * Encapsulates all WASM initialization and memory management.
+ */
+export class BarretenbergWasmSyncBackend implements IMsgpackBackendSync {
+  private constructor(private wasm: BarretenbergWasmMain) {}
+
+  /**
+   * Create and initialize a synchronous WASM backend.
+   * @param wasmPath Optional path to WASM files
+   * @param logger Optional logging function
+   */
+  static async new(wasmPath?: string, logger?: (msg: string) => void): Promise<BarretenbergWasmSyncBackend> {
+    const wasm = new BarretenbergWasmMain();
+    const { module, threads } = await fetchModuleAndThreads(1, wasmPath, logger);
+    await wasm.init(module, threads, logger);
+    return new BarretenbergWasmSyncBackend(wasm);
+  }
+
+  call(inputBuffer: Uint8Array): Uint8Array {
+    return this.wasm.cbindCall('bbapi', inputBuffer);
+  }
+
+  destroy(): void {
+    // BarretenbergWasmMain has async destroy, but for sync API we call it without awaiting
+    // This is consistent with the synchronous semantics expected by the caller
+    void this.wasm.destroy();
+  }
+}
+
+/**
+ * Asynchronous WASM backend that supports both direct WASM and worker-based modes.
+ *
+ * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread.
+ *   - Browser-safe: Won't block UI during long operations
+ *   - Overhead: ~3-4x slower due to serialize/deserialize for each call
+ *   - Use for: Browser environments, long-running operations
+ *
+ * Direct mode (useWorker: false): Runs WASM directly on the calling thread.
+ *   - Performance: ~3-4x faster (no serialize/deserialize overhead)
+ *   - Warning: Will block the thread during operations
+ *   - Use for: Node.js, benchmarks, tight loops where performance is critical
+ */
+export class BarretenbergWasmAsyncBackend implements IMsgpackBackendAsync {
+  private constructor(
+    private wasm: BarretenbergWasmMain | BarretenbergWasmMainWorker,
+    private worker?: any,
+  ) {}
+
+  /**
+   * Create and initialize an asynchronous WASM backend.
+   * @param options.threads Number of threads (defaults to hardware max, up to 32 for parallel proving)
+   * @param options.wasmPath Optional path to WASM files
+   * @param options.logger Optional logging function
+   * @param options.memory Optional initial and maximum memory configuration
+   * @param options.useWorker Run on worker thread (default: true for browser safety)
+   */
+  static async new(
+    options: {
+      threads?: number;
+      wasmPath?: string;
+      logger?: (msg: string) => void;
+      memory?: { initial?: number; maximum?: number };
+      useWorker?: boolean;
+    } = {},
+  ): Promise<BarretenbergWasmAsyncBackend> {
+    // Default to worker mode for browser safety
+    const useWorker = options.useWorker ?? true;
+
+    if (useWorker) {
+      // Worker-based mode: runs on worker thread (browser-safe)
+      const worker = await createMainWorker();
+      const wasm = getRemoteBarretenbergWasm<BarretenbergWasmMainWorker>(worker);
+      const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+      await wasm.init(
+        module,
+        threads,
+        proxy(options.logger ?? createDebugLogger('bb_wasm_async')),
+        options.memory?.initial,
+        options.memory?.maximum,
+      );
+      return new BarretenbergWasmAsyncBackend(wasm, worker);
+    } else {
+      // Direct mode: runs on calling thread (faster but blocks thread)
+      const wasm = new BarretenbergWasmMain();
+      const { module, threads } = await fetchModuleAndThreads(options.threads, options.wasmPath, options.logger);
+      await wasm.init(module, threads, options.logger, options.memory?.initial, options.memory?.maximum);
+      return new BarretenbergWasmAsyncBackend(wasm);
+    }
+  }
+
+  async call(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    return this.wasm.cbindCall('bbapi', inputBuffer);
+  }
+
+  async destroy(): Promise<void> {
+    await this.wasm.destroy();
+    if (this.worker) {
+      await this.worker.terminate();
+    }
+  }
+}

package/src/cbind/README.md

@@ -1 +1 @@
-Derive bindings from the reported scheme of msgpack from bb. Currently redundant with bindgen, until that is supplanted.
+Derives bindings from the reported msgpack schema from bb.

package/src/cbind/generate.ts

@@ -11,7 +11,6 @@ import {
   createSharedTypesCompiler,
   createSyncApiCompiler,
   createAsyncApiCompiler,
-  createNativeApiCompiler,
   type SchemaCompiler,
 } from './schema_compiler.js';
 
@@ -39,11 +38,6 @@ const GENERATORS: GeneratorConfig[] = [
     outputFile: 'generated/async.ts',
     createCompiler: createAsyncApiCompiler,
   },
-  {
-    name: 'Native API',
-    outputFile: 'generated/native.ts',
-    createCompiler: createNativeApiCompiler,
-  },
 ];
 
 // @ts-ignore

package/src/cbind/schema_compiler.ts

@@ -34,7 +34,7 @@ export interface FunctionMetadata {
 
 // Compiler configuration
 export interface CompilerConfig {
-  mode: 'types' | 'sync' | 'async' | 'native';
+  mode: 'types' | 'sync' | 'async';
   imports?: string[];
   wasmImport?: string;
 }
@@ -72,8 +72,12 @@ export class SchemaCompiler {
     this.processSchema(responsesSchema);
 
     // Extract function metadata from named unions
-    if (!Array.isArray(commandsSchema) || commandsSchema[0] !== 'named_union' ||
-        !Array.isArray(responsesSchema) || responsesSchema[0] !== 'named_union') {
+    if (
+      !Array.isArray(commandsSchema) ||
+      commandsSchema[0] !== 'named_union' ||
+      !Array.isArray(responsesSchema) ||
+      responsesSchema[0] !== 'named_union'
+    ) {
       throw new Error('Expected named_union schema format');
     }
 
@@ -115,10 +119,7 @@ export class SchemaCompiler {
    * Generate the complete output
    */
   compile(): string {
-    const parts: string[] = [
-      '// AUTOGENERATED FILE - DO NOT EDIT',
-      '',
-    ];
+    const parts: string[] = ['// AUTOGENERATED FILE - DO NOT EDIT', ''];
 
     // Generate imports
     parts.push(...this.generateImports());
@@ -131,55 +132,51 @@ export class SchemaCompiler {
         .sort((a, b) => a.typeName.localeCompare(b.typeName));
 
       // Group declarations
-      const typeAliases = sortedTypes.filter(t =>
-        t.declaration?.startsWith('export type') && !t.declaration?.includes('interface')
+      const typeAliases = sortedTypes.filter(
+        t => t.declaration?.startsWith('export type') && !t.declaration?.includes('interface'),
       );
-      const publicInterfaces = sortedTypes.filter(t =>
-        t.declaration?.includes('export interface')
-      );
-      const privateInterfaces = sortedTypes.filter(t =>
-        t.declaration?.includes('interface Msgpack')
-      );
-
-    // Add type aliases if needed
-    if (typeAliases.length > 0) {
-      parts.push('// Type aliases');
-      for (const type of typeAliases) {
-        parts.push(type.declaration!);
+      const publicInterfaces = sortedTypes.filter(t => t.declaration?.includes('export interface'));
+      const privateInterfaces = sortedTypes.filter(t => t.declaration?.includes('interface Msgpack'));
+
+      // Add type aliases if needed
+      if (typeAliases.length > 0) {
+        parts.push('// Type aliases');
+        for (const type of typeAliases) {
+          parts.push(type.declaration!);
+        }
+        parts.push('');
       }
-      parts.push('');
-    }
 
-    // Add tuple helper if needed
-    if (this.needsTupleHelper()) {
-      parts.push(
-        '// Tuple type for fixed-size arrays',
-        'type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;',
-        'type _TupleOf<T, N extends number, R extends unknown[]> = R[\'length\'] extends N ? R : _TupleOf<T, N, [T, ...R]>;',
-        '',
-        '// Helper functions',
-        'function mapTuple<T, S, N extends number>(tuple: Tuple<T, N>, fn: (item: T) => S): Tuple<S, N> {',
-        '  return tuple.map(fn) as Tuple<S, N>;',
-        '}',
-        ''
-      );
-    }
+      // Add tuple helper if needed
+      if (this.needsTupleHelper()) {
+        parts.push(
+          '// Tuple type for fixed-size arrays',
+          'type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;',
+          "type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;",
+          '',
+          '// Helper functions',
+          'function mapTuple<T, S, N extends number>(tuple: Tuple<T, N>, fn: (item: T) => S): Tuple<S, N> {',
+          '  return tuple.map(fn) as Tuple<S, N>;',
+          '}',
+          '',
+        );
+      }
 
-    // Add public interfaces
-    if (publicInterfaces.length > 0) {
-      parts.push('// Public interfaces (exported)');
-      for (const type of publicInterfaces) {
-        parts.push(type.declaration!, '');
+      // Add public interfaces
+      if (publicInterfaces.length > 0) {
+        parts.push('// Public interfaces (exported)');
+        for (const type of publicInterfaces) {
+          parts.push(type.declaration!, '');
+        }
       }
-    }
 
-    // Add private interfaces
-    if (privateInterfaces.length > 0) {
-      parts.push('// Private Msgpack interfaces (not exported)');
-      for (const type of privateInterfaces) {
-        parts.push(type.declaration!, '');
+      // Add private interfaces
+      if (privateInterfaces.length > 0) {
+        parts.push('// Private Msgpack interfaces (not exported)');
+        for (const type of privateInterfaces) {
+          parts.push(type.declaration!, '');
+        }
       }
-    }
 
       // Add conversion functions (only for api_types.ts)
       const conversions = sortedTypes.filter(t => t.toMethod || t.fromMethod);
@@ -218,9 +215,7 @@ export class SchemaCompiler {
   }
 
   private needsTupleHelper(): boolean {
-    return Array.from(this.typeCache.values()).some(t =>
-      t.typeName.includes('Tuple<')
-    );
+    return Array.from(this.typeCache.values()).some(t => t.typeName.includes('Tuple<'));
   }
 
   private trackTypeUsage(typeName: string): void {
@@ -296,10 +291,15 @@ export class SchemaCompiler {
     switch (type) {
       case 'array': {
         const [subtype, size] = args[0];
+        // Special case: byte arrays should be Uint8Array
+        if (subtype === 'unsigned char') {
+          return { typeName: 'Uint8Array' };
+        }
+        // For other types, use T[] - idiomatic TypeScript for fixed-length homogeneous arrays
         const subtypeInfo = this.processSchema(subtype);
         return {
-          typeName: `Tuple<${subtypeInfo.typeName}, ${size}>`,
-          msgpackTypeName: `Tuple<${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}, ${size}>`,
+          typeName: `${subtypeInfo.typeName}[]`,
+          msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
         };
       }
 
@@ -392,6 +392,7 @@ export class SchemaCompiler {
       case 'unsigned int':
       case 'unsigned short':
       case 'unsigned long':
+      case 'unsigned char':
       case 'double':
         return { typeName: 'number' };
       case 'string':
@@ -477,15 +478,19 @@ export class SchemaCompiler {
       return `function to${name}(o: Msgpack${name}): ${name} {\n  return {};\n}`;
     }
 
-    const checks = fields.map(([key]) =>
-      `  if (o.${key} === undefined) { throw new Error("Expected ${key} in ${name} deserialization"); }`
-    ).join('\n');
+    const checks = fields
+      .map(
+        ([key]) => `  if (o.${key} === undefined) { throw new Error("Expected ${key} in ${name} deserialization"); }`,
+      )
+      .join('\n');
 
-    const conversions = fields.map(([key, value]) => {
-      const typeInfo = this.processSchema(value);
-      const converter = this.generateConverter(typeInfo, `o.${key}`, 'to');
-      return `    ${camelCase(key)}: ${converter},`;
-    }).join('\n');
+    const conversions = fields
+      .map(([key, value]) => {
+        const typeInfo = this.processSchema(value);
+        const converter = this.generateConverter(typeInfo, `o.${key}`, 'to');
+        return `    ${camelCase(key)}: ${converter},`;
+      })
+      .join('\n');
 
     return `function to${name}(o: Msgpack${name}): ${name} {
 ${checks};
@@ -502,15 +507,20 @@ ${conversions}
       return `function from${name}(o: ${name}): Msgpack${name} {\n  return {};\n}`;
     }
 
-    const checks = fields.map(([key]) =>
-      `  if (o.${camelCase(key)} === undefined) { throw new Error("Expected ${camelCase(key)} in ${name} serialization"); }`
-    ).join('\n');
+    const checks = fields
+      .map(
+        ([key]) =>
+          `  if (o.${camelCase(key)} === undefined) { throw new Error("Expected ${camelCase(key)} in ${name} serialization"); }`,
+      )
+      .join('\n');
 
-    const conversions = fields.map(([key, value]) => {
-      const typeInfo = this.processSchema(value);
-      const converter = this.generateConverter(typeInfo, `o.${camelCase(key)}`, 'from');
-      return `  ${key}: ${converter},`;
-    }).join('\n');
+    const conversions = fields
+      .map(([key, value]) => {
+        const typeInfo = this.processSchema(value);
+        const converter = this.generateConverter(typeInfo, `o.${camelCase(key)}`, 'from');
+        return `  ${key}: ${converter},`;
+      })
+      .join('\n');
 
     return `function from${name}(o: ${name}): Msgpack${name} {
 ${checks};
@@ -531,8 +541,8 @@ ${conversions}
       }
     }
 
-    // Handle custom types
-    if (typeInfo.declaration) {
+    // Handle custom types that have conversion methods (not just type aliases)
+    if (typeInfo.toMethod || typeInfo.fromMethod) {
       return `${direction}${typeInfo.typeName}(${value})`;
     }
 
@@ -579,9 +589,9 @@ ${conversions}
   }
 
   private generateBbApiBaseInterface(): string {
-    const methods = this.functionMetadata.map(m =>
-      `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`
-    ).join('\n');
+    const methods = this.functionMetadata
+      .map(m => `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`)
+      .join('\n');
 
     return `export interface BbApiBase {
 ${methods}
@@ -593,69 +603,77 @@ ${methods}
     const className = this.getApiClassName();
     const methods = this.functionMetadata.map(m => this.generateApiMethod(m)).join('\n\n');
 
-    if (this.config.mode === 'native') {
-      return this.generateNativeApiClass(methods);
-    }
-
     // For sync API, don't implement BbApiBase since methods are synchronous
     const implementsClause = this.config.mode === 'sync' ? '' : ' implements BbApiBase';
 
-    const msgpackCallHelper = `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(wasm: ${this.getWasmType()}, cbind: string, input: any[]) {` +
-    `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);` +
-    `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}wasm.cbindCall(cbind, inputBuffer);` +
-    `  return new Decoder({ useRecords: false }).unpack(encodedResult);` +
-    `}\n`;
+    // For tracing all calls to bb.
+    // const msgpackCallHelper =
+    //   `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {\n` +
+    //   `  const commandName = input[0]?.[0] || 'unknown';\n` +
+    //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName}\\n\`);\n` +
+    //   `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);\n` +
+    //   `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);\n` +
+    //   `  const result = new Decoder({ useRecords: false }).unpack(encodedResult);\n` +
+    //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName} => completed\\n\`);\n` +
+    //   `  return result;\n` +
+    //   `}\n`;
+    const msgpackCallHelper =
+      `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {` +
+      `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);` +
+      `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);` +
+      `  return new Decoder({ useRecords: false }).unpack(encodedResult);` +
+      `}\n`;
+    const destroyMethod =
+      this.config.mode === 'sync'
+        ? `  destroy(): void {
+    if (this.backend.destroy) this.backend.destroy();
+  }`
+        : `  destroy(): Promise<void> {
+    return this.backend.destroy ? this.backend.destroy() : Promise.resolve();
+  }`;
+
     return (
       msgpackCallHelper +
       `export class ${className}${implementsClause} {
-  constructor(protected wasm: ${this.getWasmType()}) {}
+  constructor(protected backend: ${this.getBackendType()}) {}
 
 ${methods}
 
-  destroy(): Promise<void> {
-    return this.wasm.destroy();
-  }
+${destroyMethod}
 }`
     );
   }
 
   private getApiClassName(): string {
     switch (this.config.mode) {
-      case 'sync': return 'SyncApi';
-      case 'async': return 'AsyncApi';
-      case 'native': return 'NativeApi';
-      default: throw new Error(`Invalid mode: ${this.config.mode}`);
+      case 'sync':
+        return 'SyncApi';
+      case 'async':
+        return 'AsyncApi';
+      default:
+        throw new Error(`Invalid mode: ${this.config.mode}`);
     }
   }
 
-  private getWasmType(): string {
+  private getBackendType(): string {
     switch (this.config.mode) {
-      case 'sync': return 'BarretenbergWasmMain';
-      case 'async': return 'BarretenbergWasmMainWorker';
-      default: return '';
+      case 'sync':
+        return 'IMsgpackBackendSync';
+      case 'async':
+        return 'IMsgpackBackendAsync';
+      default:
+        return '';
     }
   }
 
   private generateApiMethod(metadata: FunctionMetadata): string {
     const { name, commandType, responseType } = metadata;
 
-    if (this.config.mode === 'native') {
-      return `  ${name}(command: ${commandType}): Promise<${responseType}> {
-    const msgpackCommand = from${commandType}(command);
-    return this.sendCommand(['${metadata.commandType}', msgpackCommand]).then(([variantName, result]: [string, any]) => {
-      if (variantName !== '${responseType}') {
-        throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
-      }
-      return to${responseType}(result);
-    });
-  }`;
-    }
-
     // For async mode, queue immediately and return promise
     if (this.config.mode === 'async') {
       return `  ${name}(command: ${commandType}): Promise<${responseType}> {
     const msgpackCommand = from${commandType}(command);
-    return msgpackCall(this.wasm, 'bbapi', [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+    return msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
       if (variantName !== '${responseType}') {
         throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
       }
@@ -667,131 +685,13 @@ ${methods}
     // For sync mode, keep the synchronous behavior
     return `  ${name}(command: ${commandType}): ${responseType} {
     const msgpackCommand = from${commandType}(command);
-    const [variantName, result] = msgpackCall(this.wasm, 'bbapi', [["${capitalize(name)}", msgpackCommand]]);
+    const [variantName, result] = msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]);
     if (variantName !== '${responseType}') {
       throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
     }
     return to${responseType}(result);
   }`;
   }
-
-  private generateNativeApiClass(methods: string): string {
-    return `interface NativeApiRequest {
-  resolve: (value: any) => void;
-  reject: (error: any) => void;
-}
-
-class StreamBuffer {
-  private buffer = Buffer.alloc(0);
-  private expectedLength: number | null = null;
-
-  addData(data: Buffer): Buffer[] {
-    // Create buffer to grow as needed
-    const newBuffer = Buffer.allocUnsafe(this.buffer.length + data.length);
-    this.buffer.copy(newBuffer, 0);
-    data.copy(newBuffer, this.buffer.length);
-    this.buffer = newBuffer;
-
-    const messages: Buffer[] = [];
-
-    while (true) {
-      if (this.expectedLength === null) {
-        if (this.buffer.length < 4) break;
-        this.expectedLength = this.buffer.readUInt32LE(0);
-        this.buffer = this.buffer.subarray(4);
-      }
-
-      if (this.buffer.length < this.expectedLength) break;
-
-      // Extract complete message
-      const messageBuffer = this.buffer.subarray(0, this.expectedLength);
-      messages.push(messageBuffer);
-      this.buffer = this.buffer.subarray(this.expectedLength);
-      this.expectedLength = null;
-    }
-
-    return messages;
-  }
-}
-
-export class NativeApi implements BbApiBase {
-  private decoder = new Decoder({ useRecords: false });
-  private encoder = new Encoder({ useRecords: false });
-  private pendingRequests: NativeApiRequest[] = [];
-
-  private constructor(private proc: ChildProcess) {}
-
-  static async new(bbPath = 'bb', logger = console.log): Promise<NativeApi> {
-    const proc = spawn(bbPath, ['msgpack', 'run'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    if (!proc.stdout || !proc.stdin) {
-      throw new Error('Failed to initialize bb process');
-    }
-
-    const api = new NativeApi(proc);
-    const streamBuffer = new StreamBuffer();
-
-    proc.stdout.on('data', (data: Buffer) => {
-      const messages = streamBuffer.addData(data);
-
-      for (const messageBuffer of messages) {
-        const pendingRequest = api.pendingRequests.shift();
-        if (!pendingRequest) {
-          throw new Error('Received response without a pending request');
-        }
-
-        try {
-          const decoded = api.decoder.decode(messageBuffer);
-          if (!Array.isArray(decoded) || decoded.length !== 2) {
-            throw new Error(\`Invalid response format: \${JSON.stringify(decoded)}\`);
-          }
-          const [variantName, result] = decoded;
-          pendingRequest.resolve([variantName, result]);
-        } catch (error) {
-          pendingRequest.reject(error);
-          break;
-        }
-      }
-    });
-
-    proc.stderr.on('data', (data: Buffer) => {
-      logger(data.toString().trim());
-    });
-
-    proc.on('error', err => {
-      throw new Error(err.message);
-    });
-    return api;
-  }
-
-  private sendCommand(command: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.push({ resolve, reject });
-      const encoded = this.encoder.encode(command);
-
-      // Write length prefix (4 bytes, little-endian)
-      const lengthBuffer = Buffer.allocUnsafe(4);
-      lengthBuffer.writeUInt32LE(encoded.length, 0);
-
-      // Write length prefix followed by the encoded data
-      this.proc.stdin!.write(lengthBuffer);
-      this.proc.stdin!.write(encoded);
-    });
-  }
-
-  async close(): Promise<void> {
-    this.proc.kill();
-  }
-
-  destroy(): Promise<void> {
-    return this.close();
-  }
-
-${methods}
-}`;
-  }
 }
 
 // Factory methods for creating configured compilers
@@ -806,7 +706,7 @@ export function createSyncApiCompiler(): SchemaCompiler {
   return new SchemaCompiler({
     mode: 'sync',
     imports: [
-      `import { BarretenbergWasmMain } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
+      `import { IMsgpackBackendSync } from '../../bb_backends/interface.js';`,
       `import { Decoder, Encoder } from 'msgpackr';`,
     ],
   });
@@ -816,18 +716,8 @@ export function createAsyncApiCompiler(): SchemaCompiler {
   return new SchemaCompiler({
     mode: 'async',
     imports: [
-      `import { BarretenbergWasmMainWorker } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
-      `import { Decoder, Encoder } from 'msgpackr';`
-    ],
-  });
-}
-
-export function createNativeApiCompiler(): SchemaCompiler {
-  return new SchemaCompiler({
-    mode: 'native',
-    imports: [
-      `import { spawn, ChildProcess } from 'child_process';`,
-      `import { Decoder, Encoder } from 'msgpackr';`
+      `import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';`,
+      `import { Decoder, Encoder } from 'msgpackr';`,
     ],
   });
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 export { Crs, GrumpkinCrs } from './crs/index.js';
 export {
   type BackendOptions,
+  BackendType,
   Barretenberg,
   BarretenbergSync,
   UltraHonkVerifierBackend,
@@ -9,5 +10,5 @@ export {
 } from './barretenberg/index.js';
 
 export { randomBytes } from './random/index.js';
-export { RawBuffer, Fr } from './types/index.js';
+export { Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';

package/src/serialize/index.ts

@@ -1,3 +1,2 @@
 export * from './buffer_reader.js';
-export * from './output_type.js';
 export * from './serialize.js';