@aztec/bb.js 0.0.1-commit.5daedc8 → 0.0.1-commit.6230a0c

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);
   }

package/src/cbind/generate.ts

@@ -1,5 +1,8 @@
 /**
- * Generate TypeScript bindings from msgpack schema
+ * Multi-language code generation from BB msgpack schema
+ *
+ * Architecture:
+ *   Raw Schema → SchemaVisitor → CompiledSchema IR → Language Codegens → Files
  */
 
 import { writeFileSync, mkdirSync } from 'fs';
@@ -8,36 +11,42 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import { unpack } from 'msgpackr';
-import {
-  createSharedTypesCompiler,
-  createSyncApiCompiler,
-  createAsyncApiCompiler,
-  type SchemaCompiler,
-} from './schema_compiler.js';
+import { SchemaVisitor, type CompiledSchema } from './schema_visitor.js';
+import { TypeScriptCodegen } from './typescript_codegen.js';
+import { RustCodegen } from './rust_codegen.js';
 
 const execAsync = promisify(exec);
 
-interface GeneratorConfig {
+// Language generators - all use the same CompiledSchema IR
+interface LanguageGenerator {
   name: string;
-  outputFile: string;
-  createCompiler: () => SchemaCompiler;
+  enabled: boolean;
+  generate: (compiled: CompiledSchema) => Array<{ path: string; content: string }>;
 }
 
-const GENERATORS: GeneratorConfig[] = [
+const LANGUAGE_GENERATORS: LanguageGenerator[] = [
   {
-    name: 'Shared types',
-    outputFile: 'generated/api_types.ts',
-    createCompiler: createSharedTypesCompiler,
+    name: 'TypeScript',
+    enabled: true,
+    generate: (compiled) => {
+      const tsGen = new TypeScriptCodegen();
+      return [
+        { path: 'generated/api_types.ts', content: tsGen.generateTypes(compiled) },
+        { path: 'generated/sync.ts', content: tsGen.generateSyncApi(compiled) },
+        { path: 'generated/async.ts', content: tsGen.generateAsyncApi(compiled) },
+      ];
+    },
   },
   {
-    name: 'Sync API',
-    outputFile: 'generated/sync.ts',
-    createCompiler: createSyncApiCompiler,
-  },
-  {
-    name: 'Async API',
-    outputFile: 'generated/async.ts',
-    createCompiler: createAsyncApiCompiler,
+    name: 'Rust',
+    enabled: true,
+    generate: (compiled) => {
+      const rustGen = new RustCodegen();
+      return [
+        { path: '../../../rust/barretenberg-rs/src/generated_types.rs', content: rustGen.generateTypes(compiled) },
+        { path: '../../../rust/barretenberg-rs/src/api.rs', content: rustGen.generateApi(compiled) },
+      ];
+    },
   },
 ];
 
@@ -56,29 +65,39 @@ async function generate() {
     throw new Error('Invalid schema: missing commands or responses');
   }
 
-  console.log('Generating TypeScript bindings...\n');
+  // Compile schema once using visitor pattern
+  console.log('Compiling schema...');
+  const visitor = new SchemaVisitor();
+  const compiled = visitor.visit(schema.commands, schema.responses);
+
+  console.log(`Found ${compiled.commands.length} commands, ${compiled.structs.size} structs\n`);
 
   // Ensure output directory exists
   const outputDir = join(__dirname, 'generated');
   mkdirSync(outputDir, { recursive: true });
 
-  // Generate each output file
-  for (const config of GENERATORS) {
-    const compiler = config.createCompiler();
-    compiler.processApiSchema(schema.commands, schema.responses);
+  // Generate all language bindings from compiled IR
+  for (const generator of LANGUAGE_GENERATORS) {
+    if (!generator.enabled) {
+      console.log(`⊘ ${generator.name}: disabled`);
+      continue;
+    }
 
-    const outputPath = join(__dirname, config.outputFile);
-    const content = compiler.compile();
-    writeFileSync(outputPath, content);
+    const files = generator.generate(compiled);
 
-    console.log(`✓ ${config.name}: ${outputPath}`);
+    for (const file of files) {
+      const outputPath = join(__dirname, file.path);
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, file.content);
+      console.log(`✓ ${generator.name}: ${outputPath}`);
+    }
   }
 
   // Generate curve constants
   console.log('\nGenerating curve constants...');
   await generateCurveConstants(bbBuildPath, outputDir);
 
-  console.log('\nGeneration complete!');
+  console.log('\n✨ Generation complete! Clean, maintainable, multi-language architecture.');
 }
 
 async function generateCurveConstants(bbBuildPath: string, outputDir: string) {