@aztec/bb.js 1.2.0 → 2.0.0-nightly.20250813

package/dest/node-cjs/cbind/schema_compiler.js

@@ -0,0 +1,691 @@
+"use strict";
+/**
+ * Unified schema compiler with integrated strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaCompiler = void 0;
+exports.createSharedTypesCompiler = createSharedTypesCompiler;
+exports.createSyncApiCompiler = createSyncApiCompiler;
+exports.createAsyncApiCompiler = createAsyncApiCompiler;
+exports.createNativeApiCompiler = createNativeApiCompiler;
+// Helper functions
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.substring(1);
+}
+function camelCase(s) {
+    return s
+        .split('_')
+        .map((part, index) => (index === 0 ? part.charAt(0).toLowerCase() + part.substring(1) : capitalize(part)))
+        .join('');
+}
+function pascalCase(s) {
+    return s.split('_').map(capitalize).join('');
+}
+class SchemaCompiler {
+    constructor(config) {
+        this.config = config;
+        this.typeCache = new Map();
+        this.functionMetadata = [];
+        // WORKTODO(bbapi): AI slop fixup - redundant with typeCache, remove
+        this.referencedTypes = new Set();
+    }
+    /**
+     * Process API schema and extract function metadata
+     */
+    processApiSchema(commandsSchema, responsesSchema) {
+        // Process types
+        this.processSchema(commandsSchema);
+        this.processSchema(responsesSchema);
+        // Extract function metadata from named unions
+        if (!Array.isArray(commandsSchema) || commandsSchema[0] !== 'named_union' ||
+            !Array.isArray(responsesSchema) || responsesSchema[0] !== 'named_union') {
+            throw new Error('Expected named_union schema format');
+        }
+        const commands = commandsSchema[1];
+        const responses = responsesSchema[1];
+        for (let i = 0; i < commands.length; i++) {
+            const [commandName] = commands[i];
+            const [responseName] = responses[i];
+            this.functionMetadata.push({
+                name: camelCase(commandName),
+                commandType: pascalCase(commandName),
+                responseType: pascalCase(responseName),
+            });
+        }
+    }
+    /**
+     * Process a schema and populate type cache
+     */
+    processSchema(schema) {
+        const key = this.getSchemaKey(schema);
+        if (this.typeCache.has(key)) {
+            return this.typeCache.get(key);
+        }
+        const typeInfo = this.generateTypeInfo(schema);
+        this.typeCache.set(key, typeInfo);
+        return typeInfo;
+    }
+    /**
+     * Generate the complete output
+     */
+    compile() {
+        const parts = [
+            '// AUTOGENERATED FILE - DO NOT EDIT',
+            '',
+        ];
+        // Generate imports
+        parts.push(...this.generateImports());
+        parts.push('');
+        // Generate type declarations only for 'types' mode
+        if (this.config.mode === 'types') {
+            const sortedTypes = Array.from(this.typeCache.values())
+                .filter(t => t.declaration)
+                .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 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('');
+            }
+            // 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 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);
+            if (conversions.length > 0) {
+                parts.push('// Conversion functions (exported)');
+                for (const type of conversions) {
+                    if (type.toMethod) {
+                        parts.push('export ' + type.toMethod, '');
+                    }
+                    if (type.fromMethod) {
+                        parts.push('export ' + type.fromMethod, '');
+                    }
+                }
+            }
+            // Add BbApiBase interface
+            if (this.functionMetadata.length > 0) {
+                parts.push('', '// Base API interface');
+                parts.push(this.generateBbApiBaseInterface());
+            }
+        }
+        // Add API class for non-types modes
+        if (this.config.mode !== 'types' && this.functionMetadata.length > 0) {
+            parts.push(this.generateApiClass());
+        }
+        return parts.join('\n') + '\n';
+    }
+    getSchemaKey(schema) {
+        if (typeof schema === 'string')
+            return schema;
+        if (Array.isArray(schema))
+            return JSON.stringify(schema);
+        if (typeof schema === 'object')
+            return schema.__typename || JSON.stringify(schema);
+        return String(schema);
+    }
+    needsTupleHelper() {
+        return Array.from(this.typeCache.values()).some(t => t.typeName.includes('Tuple<'));
+    }
+    trackTypeUsage(typeName) {
+        // Only track for API modes
+        if (this.config.mode === 'types')
+            return;
+        // Extract base types from complex types
+        const baseTypes = this.extractBaseTypes(typeName);
+        for (const type of baseTypes) {
+            // Skip built-in types
+            if (['string', 'number', 'boolean', 'Uint8Array'].includes(type)) {
+                continue;
+            }
+            this.referencedTypes.add(type);
+        }
+    }
+    extractBaseTypes(typeName) {
+        const types = [];
+        // Handle arrays
+        const arrayMatch = typeName.match(/^(.+)\[\]$/);
+        if (arrayMatch) {
+            types.push(...this.extractBaseTypes(arrayMatch[1]));
+            return types;
+        }
+        // Handle Tuple
+        const tupleMatch = typeName.match(/^Tuple<(.+),\s*\d+>$/);
+        if (tupleMatch) {
+            types.push(...this.extractBaseTypes(tupleMatch[1]));
+            return types;
+        }
+        // Handle Record
+        const recordMatch = typeName.match(/^Record<(.+),\s*(.+)>$/);
+        if (recordMatch) {
+            types.push(...this.extractBaseTypes(recordMatch[1]));
+            types.push(...this.extractBaseTypes(recordMatch[2]));
+            return types;
+        }
+        // Handle union types
+        if (typeName.includes(' | ')) {
+            const parts = typeName.split(' | ');
+            for (const part of parts) {
+                types.push(...this.extractBaseTypes(part.trim()));
+            }
+            return types;
+        }
+        // Base case - simple type
+        types.push(typeName);
+        return types;
+    }
+    generateTypeInfo(schema) {
+        if (Array.isArray(schema)) {
+            return this.processArraySchema(schema);
+        }
+        else if (typeof schema === 'string') {
+            return this.processPrimitiveSchema(schema);
+        }
+        else if (typeof schema === 'object') {
+            return this.processObjectSchema(schema);
+        }
+        throw new Error(`Unsupported schema type: ${schema}`);
+    }
+    processArraySchema(schema) {
+        const [type, ...args] = schema;
+        switch (type) {
+            case 'array': {
+                const [subtype, size] = args[0];
+                const subtypeInfo = this.processSchema(subtype);
+                return {
+                    typeName: `Tuple<${subtypeInfo.typeName}, ${size}>`,
+                    msgpackTypeName: `Tuple<${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}, ${size}>`,
+                };
+            }
+            case 'variant': {
+                const variants = args[0];
+                const variantInfos = variants.map(v => this.processSchema(v));
+                const typeName = variantInfos.map(v => v.typeName).join(' | ');
+                const msgpackUnion = variantInfos.map(v => v.msgpackTypeName || v.typeName).join(' | ');
+                return {
+                    typeName,
+                    msgpackTypeName: `[number, ${msgpackUnion}]`,
+                };
+            }
+            case 'named_union': {
+                const namedTypes = args[0];
+                const tupleTypes = [];
+                for (const [name, schemaOrName] of namedTypes) {
+                    let typeInfo;
+                    if (typeof schemaOrName === 'string') {
+                        const typeName = pascalCase(schemaOrName);
+                        typeInfo = this.getOrCreateEmptyType(typeName);
+                    }
+                    else {
+                        typeInfo = this.processSchema(schemaOrName);
+                    }
+                    // Track usage of the type
+                    this.trackTypeUsage(typeInfo.typeName);
+                    tupleTypes.push(`["${name}", ${typeInfo.typeName}]`);
+                }
+                return {
+                    typeName: tupleTypes.join(' | '),
+                    msgpackTypeName: tupleTypes.join(' | '),
+                };
+            }
+            case 'vector': {
+                const [subtype] = args[0];
+                if (subtype === 'unsigned char') {
+                    return { typeName: 'Uint8Array' };
+                }
+                const subtypeInfo = this.processSchema(subtype);
+                return {
+                    typeName: `${subtypeInfo.typeName}[]`,
+                    msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
+                };
+            }
+            case 'alias': {
+                const [rawTypeName, msgpackName] = args[0];
+                const typeName = pascalCase(rawTypeName);
+                let targetType;
+                if (msgpackName.startsWith('bin')) {
+                    targetType = 'Uint8Array';
+                }
+                else if (['int', 'unsigned int', 'unsigned short'].includes(msgpackName)) {
+                    targetType = 'number';
+                }
+                else {
+                    throw new Error(`Unsupported alias type: ${msgpackName}`);
+                }
+                // Create a proper type alias declaration
+                return {
+                    typeName,
+                    msgpackTypeName: targetType,
+                    declaration: `export type ${typeName} = ${targetType};`,
+                };
+            }
+            case 'shared_ptr': {
+                const [subtype] = args[0];
+                return this.processSchema(subtype);
+            }
+            case 'map': {
+                const [keyType, valueType] = args[0];
+                const keyInfo = this.processSchema(keyType);
+                const valueInfo = this.processSchema(valueType);
+                return {
+                    typeName: `Record<${keyInfo.typeName}, ${valueInfo.typeName}>`,
+                    msgpackTypeName: `Record<${keyInfo.msgpackTypeName || keyInfo.typeName}, ${valueInfo.msgpackTypeName || valueInfo.typeName}>`,
+                };
+            }
+            default:
+                throw new Error(`Unsupported array schema type: ${type}`);
+        }
+    }
+    processPrimitiveSchema(schema) {
+        switch (schema) {
+            case 'bool':
+                return { typeName: 'boolean' };
+            case 'int':
+            case 'unsigned int':
+            case 'unsigned short':
+            case 'unsigned long':
+            case 'double':
+                return { typeName: 'number' };
+            case 'string':
+                return { typeName: 'string' };
+            case 'bin32':
+                return { typeName: 'Uint8Array' };
+            default:
+                return { typeName: pascalCase(schema) };
+        }
+    }
+    processObjectSchema(schema) {
+        const typeName = pascalCase(schema.__typename);
+        const msgpackTypeName = 'Msgpack' + typeName;
+        const declaration = this.generateInterfaces(typeName, schema);
+        const toMethod = this.generateToMethod(typeName, schema);
+        const fromMethod = this.generateFromMethod(typeName, schema);
+        return {
+            typeName,
+            msgpackTypeName,
+            declaration,
+            toMethod,
+            fromMethod,
+        };
+    }
+    getOrCreateEmptyType(typeName) {
+        const key = `empty_${typeName}`;
+        if (this.typeCache.has(key)) {
+            return this.typeCache.get(key);
+        }
+        const typeInfo = {
+            typeName,
+            msgpackTypeName: 'Msgpack' + typeName,
+            declaration: `export interface ${typeName} {}\n\ninterface Msgpack${typeName} {}`,
+            toMethod: `function to${typeName}(o: Msgpack${typeName}): ${typeName} {\n  return {};\n}`,
+            fromMethod: `function from${typeName}(o: ${typeName}): Msgpack${typeName} {\n  return {};\n}`,
+        };
+        this.typeCache.set(key, typeInfo);
+        return typeInfo;
+    }
+    generateInterfaces(name, schema) {
+        const publicInterface = this.generatePublicInterface(name, schema);
+        const msgpackInterface = this.generateMsgpackInterface(name, schema);
+        return publicInterface + '\n\n' + msgpackInterface;
+    }
+    generatePublicInterface(name, schema) {
+        let result = `export interface ${name} {\n`;
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            const typeInfo = this.processSchema(value);
+            // Track type usage
+            this.trackTypeUsage(typeInfo.typeName);
+            result += `  ${camelCase(key)}: ${typeInfo.typeName};\n`;
+        }
+        result += '}';
+        return result;
+    }
+    generateMsgpackInterface(name, schema) {
+        let result = `interface Msgpack${name} {\n`;
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            const typeInfo = this.processSchema(value);
+            result += `  ${key}: ${typeInfo.msgpackTypeName || typeInfo.typeName};\n`;
+        }
+        result += '}';
+        return result;
+    }
+    generateToMethod(name, schema) {
+        const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+        if (fields.length === 0) {
+            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 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};
+  return {
+${conversions}
+  };
+}`;
+    }
+    generateFromMethod(name, schema) {
+        const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+        if (fields.length === 0) {
+            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 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};
+  return {
+${conversions}
+  };
+}`;
+    }
+    generateConverter(typeInfo, value, direction) {
+        // Handle arrays/tuples
+        if (typeInfo.typeName.includes('[]') || typeInfo.typeName.includes('Tuple<')) {
+            const elementType = typeInfo.typeName.match(/^(.+)\[\]$/) || typeInfo.typeName.match(/^Tuple<(.+),/);
+            if (elementType) {
+                const isTuple = typeInfo.typeName.includes('Tuple<');
+                const mapFn = isTuple ? 'mapTuple' : 'map';
+                return `${value}.${mapFn}((v: any) => v)`; // Simplified for now
+            }
+        }
+        // Handle custom types
+        if (typeInfo.declaration) {
+            return `${direction}${typeInfo.typeName}(${value})`;
+        }
+        return value;
+    }
+    generateImports() {
+        const imports = [];
+        // Base imports
+        if (this.config.imports) {
+            imports.push(...this.config.imports);
+        }
+        // For API modes, import from api_types
+        if (this.config.mode !== 'types') {
+            const neededImports = new Set();
+            // Add types and conversion functions from function metadata
+            for (const metadata of this.functionMetadata) {
+                neededImports.add(metadata.commandType);
+                neededImports.add(metadata.responseType);
+                neededImports.add(`from${metadata.commandType}`);
+                neededImports.add(`to${metadata.responseType}`);
+            }
+            // Add referenced types
+            for (const type of this.referencedTypes) {
+                neededImports.add(type);
+            }
+            // Add BbApiBase interface
+            neededImports.add('BbApiBase');
+            if (neededImports.size > 0) {
+                const sortedImports = Array.from(neededImports).sort();
+                imports.push(`import { ${sortedImports.join(', ')} } from './api_types.js';`);
+            }
+        }
+        return imports;
+    }
+    generateBbApiBaseInterface() {
+        const methods = this.functionMetadata.map(m => `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`).join('\n');
+        return `export interface BbApiBase {
+${methods}
+  destroy(): Promise<void>;
+}`;
+    }
+    generateApiClass() {
+        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`;
+        return (msgpackCallHelper +
+            `export class ${className}${implementsClause} {
+  constructor(protected wasm: ${this.getWasmType()}) {}
+
+${methods}
+
+  destroy(): Promise<void> {
+    return this.wasm.destroy();
+  }
+}`);
+    }
+    getApiClassName() {
+        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}`);
+        }
+    }
+    getWasmType() {
+        switch (this.config.mode) {
+            case 'sync': return 'BarretenbergWasmMain';
+            case 'async': return 'BarretenbergWasmMainWorker';
+            default: return '';
+        }
+    }
+    generateApiMethod(metadata) {
+        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]) => {
+      if (variantName !== '${responseType}') {
+        throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+      }
+      return to${responseType}(result);
+    });
+  }`;
+        }
+        // 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]]);
+    if (variantName !== '${responseType}') {
+      throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+    }
+    return to${responseType}(result);
+  }`;
+    }
+    generateNativeApiClass(methods) {
+        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}
+}`;
+    }
+}
+exports.SchemaCompiler = SchemaCompiler;
+// Factory methods for creating configured compilers
+function createSharedTypesCompiler() {
+    return new SchemaCompiler({
+        mode: 'types',
+        imports: [],
+    });
+}
+function createSyncApiCompiler() {
+    return new SchemaCompiler({
+        mode: 'sync',
+        imports: [
+            `import { BarretenbergWasmMain } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
+            `import { Decoder, Encoder } from 'msgpackr';`,
+        ],
+    });
+}
+function createAsyncApiCompiler() {
+    return new SchemaCompiler({
+        mode: 'async',
+        imports: [
+            `import { BarretenbergWasmMainWorker } from "../../barretenberg_wasm/barretenberg_wasm_main/index.js";`,
+            `import { Decoder, Encoder } from 'msgpackr';`
+        ],
+    });
+}
+function createNativeApiCompiler() {
+    return new SchemaCompiler({
+        mode: 'native',
+        imports: [
+            `import { spawn, ChildProcess } from 'child_process';`,
+            `import { Decoder, Encoder } from 'msgpackr';`
+        ],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema_compiler.js","sourceRoot":"","sources":["../../../src/cbind/schema_compiler.ts"],"names":[],"mappings":"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"}