@5ive-tech/sdk 1.1.2

package/dist/wasm/compiler/CompilationLogic.js

@@ -0,0 +1,431 @@
+import { readFile, writeFile } from "fs/promises";
+import { createCompilerError, extractMetrics, extractAbi } from "./utils.js";
+export async function compile(ctx, source, options) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    const startTime = Date.now();
+    const metricsFormat = options?.metricsFormat || "json";
+    try {
+        let result;
+        let WasmCompilationOptions = ctx.WasmCompilationOptions;
+        // Use unified compilation method (module already loaded in initialize)
+        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
+            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+        }
+        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput) || Boolean(options?.metricsFormat);
+        const errorFormat = options?.errorFormat || "terminal";
+        const comprehensiveMetrics = options?.comprehensiveMetrics || Boolean(options?.metricsOutput);
+        const compilationOptions = new WasmCompilationOptions()
+            .with_mode(options?.target || "deployment")
+            .with_optimization_level(options?.optimizationLevel || "production")
+            .with_v2_preview(true)
+            .with_constraint_cache(false)
+            .with_enhanced_errors(true)
+            .with_metrics(includeMetrics)
+            .with_comprehensive_metrics(comprehensiveMetrics)
+            .with_metrics_format(metricsFormat)
+            .with_error_format(errorFormat);
+        result = ctx.compiler.compile(source, compilationOptions);
+        if (result.compiler_errors && result.compiler_errors.length > 0) {
+            ctx.logger.debug(`WASM returned ${result.compiler_errors.length} compiler errors`);
+            for (const error of result.compiler_errors) {
+                ctx.logger.debug(`Compiler error details:`, error);
+                try {
+                    const message = error.message ? error.message : "No message";
+                    const code = error.code ? error.code : "No code";
+                    const severity = error.severity ? error.severity : "Unknown";
+                    const category = error.category ? error.category : "Unknown";
+                    ctx.logger.error(`Detailed error: [${code}] ${severity} - ${message}`);
+                    ctx.logger.error(`Category: ${category}`);
+                    if (error.location) {
+                        const location = error.location;
+                        ctx.logger.error(`Location: line ${location.line}, column ${location.column}`);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.debug(`Failed to extract error details:`, e);
+                    ctx.logger.debug(`Raw error object:`, error);
+                }
+            }
+        }
+        const metricsPayload = extractMetrics(result, metricsFormat);
+        if (result.success && result.bytecode) {
+            return {
+                success: true,
+                bytecode: result.bytecode,
+                abi: extractAbi(result, ctx.logger),
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+        else {
+            return {
+                success: false,
+                errors: result.compiler_errors || [],
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+    }
+    catch (error) {
+        if (options && options.debug) { // Check if debug option is available, though not strictly in CompilationOptions type used here as any
+            // Actually 'options' is any in signature
+        }
+        // Logic from original code had specialized try/catch for WASM error inside compileFile
+        // but here in compile it just throws
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+}
+export async function compileModules(ctx, mainSource, modules, options) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    const startTime = Date.now();
+    try {
+        let WasmCompilationOptions = ctx.WasmCompilationOptions;
+        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
+            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+        }
+        const metricsFormat = options?.metricsFormat || "json";
+        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput);
+        const errorFormat = options?.errorFormat || "terminal";
+        const comprehensiveMetrics = options?.comprehensiveMetrics || false;
+        const compilationOptions = new WasmCompilationOptions()
+            .with_mode(options?.target || "deployment")
+            .with_optimization_level(options?.optimizationLevel || "production")
+            .with_v2_preview(true)
+            .with_constraint_cache(false)
+            .with_enhanced_errors(true)
+            .with_metrics(includeMetrics)
+            .with_comprehensive_metrics(comprehensiveMetrics)
+            .with_metrics_format(metricsFormat)
+            .with_error_format(errorFormat);
+        const result = ctx.compiler.compile_multi(mainSource, modules, compilationOptions);
+        const metricsPayload = extractMetrics(result, metricsFormat);
+        if (result.success && result.bytecode) {
+            return {
+                success: true,
+                bytecode: result.bytecode,
+                abi: extractAbi(result, ctx.logger),
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+        else {
+            return {
+                success: false,
+                errors: result.compiler_errors || [],
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+    }
+    catch (error) {
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+    finally {
+        const compilationTime = Date.now() - startTime;
+        ctx.logger.debug(`Multi-file compilation completed in ${compilationTime}ms`);
+    }
+}
+export async function compileFile(ctx, options) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    const startTime = Date.now();
+    const metricsFormat = options.metricsFormat || "json";
+    try {
+        const sourceCode = await readFile(options.sourceFile, "utf8");
+        ctx.logger.debug(`Compiling source file: ${options.sourceFile}`);
+        let result;
+        try {
+            let WasmCompilationOptions = ctx.WasmCompilationOptions;
+            if (!WasmCompilationOptions && ctx.wasmModuleRef) {
+                WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+            }
+            const includeMetrics = options.includeMetrics || Boolean(options.metricsOutput) || Boolean(options.metricsFormat);
+            const errorFormat = options.errorFormat || "terminal";
+            const comprehensiveMetrics = options.comprehensiveMetrics || Boolean(options.metricsOutput);
+            const compilationOptions = new WasmCompilationOptions()
+                .with_mode(options.target || "deployment")
+                .with_optimization_level(options.optimizationLevel || "production")
+                .with_v2_preview(true)
+                .with_constraint_cache(options.enable_constraint_cache !== false)
+                .with_enhanced_errors(true)
+                .with_metrics(includeMetrics)
+                .with_comprehensive_metrics(comprehensiveMetrics)
+                .with_metrics_format(metricsFormat)
+                .with_error_format(errorFormat)
+                .with_source_file(options.sourceFile);
+            result = ctx.compiler.compile(sourceCode, compilationOptions);
+            if (result.compiler_errors && result.compiler_errors.length > 0) {
+                ctx.logger.debug(`WASM returned ${result.compiler_errors.length} compiler errors`);
+                for (const error of result.compiler_errors) {
+                    ctx.logger.debug(`Compiler error details:`, error);
+                    try {
+                        const message = error.message ? error.message : "No message";
+                        const code = error.code ? error.code : "No code";
+                        const severity = error.severity ? error.severity : "Unknown";
+                        const category = error.category ? error.category : "Unknown";
+                        ctx.logger.error(`Detailed error: [${code}] ${severity} - ${message}`);
+                        ctx.logger.error(`Category: ${category}`);
+                        if (error.location) {
+                            const location = error.location;
+                            ctx.logger.error(`Location: line ${location.line}, column ${location.column}`);
+                        }
+                    }
+                    catch (e) {
+                        ctx.logger.debug(`Failed to extract error details:`, e);
+                    }
+                }
+            }
+        }
+        catch (wasmError) {
+            ctx.logger.error("WASM compiler threw exception:", wasmError);
+            result = {
+                success: false,
+                bytecode: null,
+                bytecode_size: 0,
+                compilation_time: 0,
+                compiler_errors: [
+                    {
+                        code: "E9999",
+                        severity: "error",
+                        category: "wasm_exception",
+                        message: wasmError instanceof Error
+                            ? wasmError.message
+                            : String(wasmError),
+                        description: "WASM compiler threw an exception",
+                        location: null,
+                        suggestions: [],
+                    },
+                ],
+                error_count: 1,
+                warning_count: 0,
+            };
+        }
+        if (!result.success &&
+            result.compiler_errors &&
+            result.compiler_errors.length > 0) {
+            ctx.logger.debug(`Enhanced Error Count: ${result.error_count}`);
+            try {
+                const terminalOutput = result.format_all_terminal
+                    ? result.format_all_terminal()
+                    : null;
+                if (terminalOutput) {
+                    ctx.logger.debug("Terminal formatted errors:", terminalOutput);
+                }
+                const jsonOutput = result.format_all_json
+                    ? result.format_all_json()
+                    : null;
+                if (jsonOutput) {
+                    ctx.logger.debug("JSON formatted errors:", jsonOutput);
+                }
+            }
+            catch (formatError) {
+                ctx.logger.debug("Failed to get formatted errors:", formatError);
+            }
+        }
+        const compilationTime = Date.now() - startTime;
+        const metricsPayload = extractMetrics(result, metricsFormat);
+        let convertedErrors = [];
+        if (result.compiler_errors && result.compiler_errors.length > 0) {
+            try {
+                const jsonErrors = result.format_all_json
+                    ? result.format_all_json()
+                    : null;
+                if (jsonErrors) {
+                    const parsedErrors = JSON.parse(jsonErrors);
+                    convertedErrors = parsedErrors.map((error) => ({
+                        type: "enhanced",
+                        ...error,
+                        code: error.code || "E0000",
+                        severity: error.severity || "error",
+                        category: error.category || "compilation",
+                        message: error.message || "Unknown error",
+                    }));
+                }
+                else {
+                    convertedErrors = [
+                        {
+                            type: "enhanced",
+                            code: "E0004",
+                            severity: "error",
+                            category: "compilation",
+                            message: "InvalidScript",
+                            description: "The script contains syntax or semantic errors",
+                            location: undefined,
+                            suggestions: [],
+                        },
+                    ];
+                }
+            }
+            catch (parseError) {
+                ctx.logger.debug("Failed to parse JSON errors from WASM:", parseError);
+                convertedErrors = [
+                    {
+                        type: "enhanced",
+                        code: "E0004",
+                        severity: "error",
+                        category: "compilation",
+                        message: "InvalidScript",
+                        description: "Compilation failed with enhanced error system",
+                        location: undefined,
+                        suggestions: [],
+                    },
+                ];
+            }
+        }
+        const compilationResult = {
+            success: result.success,
+            bytecode: result.bytecode ? new Uint8Array(result.bytecode) : undefined,
+            abi: result.abi || undefined,
+            errors: convertedErrors,
+            warnings: convertedErrors.filter((e) => e.severity === "warning") || [],
+            metrics: {
+                compilationTime: result.compilation_time || compilationTime,
+                bytecodeSize: result.bytecode_size || 0,
+                memoryUsed: 0,
+                optimizationTime: 0,
+                instructionCount: 0,
+                functionCount: 0,
+            },
+            metricsReport: metricsPayload,
+        };
+        if (options.outputFile && compilationResult.bytecode) {
+            await writeFile(options.outputFile, compilationResult.bytecode);
+            ctx.logger.debug(`Bytecode written to: ${options.outputFile}`);
+        }
+        if (options.abiOutputFile && compilationResult.abi) {
+            await writeFile(options.abiOutputFile, JSON.stringify(compilationResult.abi, null, 2));
+            ctx.logger.debug(`ABI written to: ${options.abiOutputFile}`);
+        }
+        ctx.logger.debug(`Compilation completed in ${compilationTime}ms`);
+        return compilationResult;
+    }
+    catch (error) {
+        const compilationTime = Date.now() - startTime;
+        return {
+            success: false,
+            errors: [
+                {
+                    type: "runtime",
+                    message: error instanceof Error ? error.message : String(error),
+                    sourceLocation: options.sourceFile,
+                },
+            ],
+            warnings: [],
+            metrics: {
+                compilationTime,
+                memoryUsed: 0,
+                optimizationTime: 0,
+                bytecodeSize: 0,
+                instructionCount: 0,
+                functionCount: 0,
+            },
+        };
+    }
+}
+export async function compileWithDiscovery(ctx, entryPoint, options) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        let WasmCompilationOptions = ctx.WasmCompilationOptions;
+        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
+            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+        }
+        const metricsFormat = options?.metricsFormat || "json";
+        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput);
+        const errorFormat = options?.errorFormat || "terminal";
+        const comprehensiveMetrics = options?.comprehensiveMetrics || false;
+        const compilationOptions = new WasmCompilationOptions()
+            .with_mode(options?.target || "deployment")
+            .with_optimization_level(options?.optimizationLevel || "production")
+            .with_v2_preview(true)
+            .with_constraint_cache(false)
+            .with_enhanced_errors(true)
+            .with_metrics(includeMetrics)
+            .with_comprehensive_metrics(comprehensiveMetrics)
+            .with_metrics_format(metricsFormat)
+            .with_error_format(errorFormat);
+        const result = ctx.compiler.compileMultiWithDiscovery(entryPoint, compilationOptions);
+        const metricsPayload = extractMetrics(result, metricsFormat);
+        if (result.success && result.bytecode) {
+            return {
+                success: true,
+                bytecode: result.bytecode,
+                abi: result.abi,
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+        else {
+            return {
+                success: false,
+                errors: result.compiler_errors || [],
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+    }
+    catch (error) {
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+}
+export async function compileModulesExplicit(ctx, moduleFiles, entryPoint, options) {
+    if (!ctx.compiler) {
+        throw createCompilerError("Compiler not initialized");
+    }
+    try {
+        let WasmCompilationOptions = ctx.WasmCompilationOptions;
+        if (!WasmCompilationOptions && ctx.wasmModuleRef) {
+            WasmCompilationOptions = ctx.wasmModuleRef.WasmCompilationOptions;
+        }
+        const metricsFormat = options?.metricsFormat || "json";
+        const includeMetrics = options?.includeMetrics || Boolean(options?.metricsOutput);
+        const errorFormat = options?.errorFormat || "terminal";
+        const comprehensiveMetrics = options?.comprehensiveMetrics || false;
+        const compilationOptions = new WasmCompilationOptions()
+            .with_mode(options?.target || "deployment")
+            .with_optimization_level(options?.optimizationLevel || "production")
+            .with_v2_preview(true)
+            .with_constraint_cache(false)
+            .with_enhanced_errors(true)
+            .with_metrics(includeMetrics)
+            .with_comprehensive_metrics(comprehensiveMetrics)
+            .with_metrics_format(metricsFormat)
+            .with_error_format(errorFormat);
+        const result = ctx.compiler.compileModules(moduleFiles, entryPoint, compilationOptions);
+        const metricsPayload = extractMetrics(result, metricsFormat);
+        if (result.success && result.bytecode) {
+            return {
+                success: true,
+                bytecode: result.bytecode,
+                abi: result.abi,
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+        else {
+            return {
+                success: false,
+                errors: result.compiler_errors || [],
+                metadata: result.metadata,
+                metrics: metricsPayload,
+                metricsReport: metricsPayload,
+            };
+        }
+    }
+    catch (error) {
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+}

package/dist/wasm/compiler/FiveCompiler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Five Compiler WASM Integration
+ *
+ * Real integration with Five VM WASM bindings for DSL compilation,
+ * ABI generation, and bytecode optimization.
+ */
+import { CompilationOptions, CompilationResult, Logger } from "../../types.js";
+export declare class FiveCompiler {
+    private compiler;
+    private logger;
+    private initialized;
+    constructor(logger: Logger);
+    /**
+     * Initialize the compiler with real Five VM WASM module
+     * The Node.js target (from wasm-pack --target nodejs) is pre-initialized
+     */
+    initialize(): Promise<void>;
+    private getContext;
+    compile(source: string, options?: any): Promise<any>;
+    compileModules(mainSource: string, modules: Array<{
+        name: string;
+        source: string;
+    }>, options?: any): Promise<any>;
+    compileFile(options: CompilationOptions): Promise<CompilationResult>;
+    compileWithDiscovery(entryPoint: string, options?: any): Promise<any>;
+    compileModulesExplicit(moduleFiles: string[], entryPoint: string, options?: any): Promise<any>;
+    generateABI(sourceCode: string): Promise<any>;
+    extractAccountDefinitions(sourceCode: string): Promise<any>;
+    extractFunctionSignatures(sourceCode: string): Promise<any>;
+    validateSource(sourceCode: string): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    validateAccountConstraints(sourceCode: string, functionName: string, accounts: any[]): Promise<any>;
+    optimizeBytecode(bytecode: Uint8Array): Promise<Uint8Array>;
+    analyzeBytecode(bytecode: Uint8Array): Promise<any>;
+    analyzeInstructionAt(bytecode: Uint8Array, offset: number): Promise<any>;
+    getBytecodeStats(bytecode: Uint8Array): Promise<any>;
+    getOpcodeUsage(sourceCode: string): Promise<any>;
+    getOpcodeAnalysis(sourceCode: string): Promise<any>;
+    getCompilerInfo(): {
+        version: string;
+        features: string[];
+    };
+    discoverModules(entryPoint: string): Promise<string[]>;
+    isReady(): boolean;
+}

package/dist/wasm/compiler/FiveCompiler.js

@@ -0,0 +1,183 @@
+/**
+ * Five Compiler WASM Integration
+ *
+ * Real integration with Five VM WASM bindings for DSL compilation,
+ * ABI generation, and bytecode optimization.
+ */
+import { ConfigManager } from "../../config/ConfigManager.js";
+import * as CompilationLogic from "./CompilationLogic.js";
+import * as AnalysisLogic from "./AnalysisLogic.js";
+import * as AbiLogic from "./AbiLogic.js";
+import * as ValidationLogic from "./ValidationLogic.js";
+import * as OptimizationLogic from "./OptimizationLogic.js";
+import * as InfoLogic from "./InfoLogic.js";
+import { createCompilerError } from "./utils.js";
+// Global refs to loaded modules
+let wasmModuleRef = null;
+let FiveCompilerWasm;
+let FiveVMWasm;
+let BytecodeAnalyzer;
+let WasmCompilationOptions;
+export class FiveCompiler {
+    constructor(logger) {
+        this.compiler = null;
+        this.initialized = false;
+        this.logger = logger;
+    }
+    /**
+     * Initialize the compiler with real Five VM WASM module
+     * The Node.js target (from wasm-pack --target nodejs) is pre-initialized
+     */
+    async initialize() {
+        try {
+            // Try multiple candidate locations (mirrors vm.ts logic)
+            const cfg = await ConfigManager.getInstance().get();
+            const prefer = cfg.wasm?.loader || "auto";
+            const configured = Array.isArray(cfg.wasm?.modulePaths)
+                ? cfg.wasm.modulePaths
+                : [];
+            const nodeCandidates = [
+                "../../five_vm_wasm.cjs",
+                "../five_vm_wasm.cjs",
+                "../../five_vm_wasm.js",
+                "../five_vm_wasm.js",
+            ];
+            const bundlerCandidates = [
+                "../../assets/vm/five_vm_wasm.cjs",
+                "../assets/vm/five_vm_wasm.cjs",
+                "../../assets/vm/five_vm_wasm.js",
+                "../assets/vm/five_vm_wasm.js",
+            ];
+            let candidates = [];
+            candidates.push(...configured);
+            if (prefer === "node") {
+                candidates.push(...nodeCandidates);
+            }
+            else if (prefer === "bundler") {
+                candidates.push(...bundlerCandidates);
+            }
+            else {
+                candidates.push(...nodeCandidates, ...bundlerCandidates);
+            }
+            let wasmModule = null;
+            const tried = [];
+            for (const candidate of candidates) {
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    const mod = await import(candidate);
+                    // The Node.js target (wasm-pack --target nodejs) is pre-initialized
+                    // No need to call initSync() - just check if it has the expected exports
+                    if (mod &&
+                        (mod.WasmFiveCompiler || mod.FiveCompilerWasm) &&
+                        mod.FiveVMWasm) {
+                        wasmModule = mod;
+                        break;
+                    }
+                    if (!(mod.WasmFiveCompiler || mod.FiveCompilerWasm)) {
+                        tried.push({ path: candidate, error: "Missing WasmFiveCompiler export" });
+                    }
+                    else if (!mod.FiveVMWasm) {
+                        tried.push({ path: candidate, error: "Missing FiveVMWasm export" });
+                    }
+                    else {
+                        tried.push({ path: candidate, error: "Module loaded but invalid" });
+                    }
+                }
+                catch (e) {
+                    tried.push({ path: candidate, error: e });
+                }
+            }
+            if (!wasmModule) {
+                const attempted = tried
+                    .map((t) => `  - ${t.path}: ${t.error instanceof Error ? t.error.message : String(t.error)}`)
+                    .join("\n");
+                throw new Error(`Failed to load WASM compiler module. Attempted:\n${attempted}`);
+            }
+            wasmModuleRef = wasmModule;
+            FiveCompilerWasm =
+                wasmModule.WasmFiveCompiler || wasmModule.FiveCompilerWasm;
+            FiveVMWasm = wasmModule.FiveVMWasm;
+            BytecodeAnalyzer = wasmModule.BytecodeAnalyzer;
+            WasmCompilationOptions = wasmModule.WasmCompilationOptions;
+            // Initialize the compiler instance
+            this.compiler = new FiveCompilerWasm();
+            this.initialized = true;
+            // WASM compiler initialized silently
+        }
+        catch (error) {
+            throw createCompilerError(`Five VM WASM modules not found. Please run "npm run build:wasm" to build the required WebAssembly modules. Error: ${error}`, error);
+        }
+    }
+    getContext() {
+        return {
+            compiler: this.compiler,
+            wasmModuleRef,
+            WasmCompilationOptions,
+            BytecodeAnalyzer,
+            logger: this.logger,
+        };
+    }
+    // --- Compilation ---
+    async compile(source, options) {
+        return CompilationLogic.compile(this.getContext(), source, options);
+    }
+    async compileModules(mainSource, modules, options) {
+        return CompilationLogic.compileModules(this.getContext(), mainSource, modules, options);
+    }
+    async compileFile(options) {
+        return CompilationLogic.compileFile(this.getContext(), options);
+    }
+    async compileWithDiscovery(entryPoint, options) {
+        return CompilationLogic.compileWithDiscovery(this.getContext(), entryPoint, options);
+    }
+    async compileModulesExplicit(moduleFiles, entryPoint, options) {
+        return CompilationLogic.compileModulesExplicit(this.getContext(), moduleFiles, entryPoint, options);
+    }
+    // --- ABI & Extraction ---
+    async generateABI(sourceCode) {
+        return AbiLogic.generateABI(this.getContext(), sourceCode);
+    }
+    async extractAccountDefinitions(sourceCode) {
+        return AbiLogic.extractAccountDefinitions(this.getContext(), sourceCode);
+    }
+    async extractFunctionSignatures(sourceCode) {
+        return AbiLogic.extractFunctionSignatures(this.getContext(), sourceCode);
+    }
+    // --- Validation ---
+    async validateSource(sourceCode) {
+        return ValidationLogic.validateSource(this.getContext(), sourceCode);
+    }
+    async validateAccountConstraints(sourceCode, functionName, accounts) {
+        return ValidationLogic.validateAccountConstraints(this.getContext(), sourceCode, functionName, accounts);
+    }
+    // --- Optimization ---
+    async optimizeBytecode(bytecode) {
+        return OptimizationLogic.optimizeBytecode(this.getContext(), bytecode);
+    }
+    // --- Analysis ---
+    async analyzeBytecode(bytecode) {
+        return AnalysisLogic.analyzeBytecode(this.getContext(), bytecode);
+    }
+    async analyzeInstructionAt(bytecode, offset) {
+        return AnalysisLogic.analyzeInstructionAt(this.getContext(), bytecode, offset);
+    }
+    async getBytecodeStats(bytecode) {
+        return AnalysisLogic.getBytecodeStats(this.getContext(), bytecode);
+    }
+    async getOpcodeUsage(sourceCode) {
+        return AnalysisLogic.getOpcodeUsage(this.getContext(), sourceCode);
+    }
+    async getOpcodeAnalysis(sourceCode) {
+        return AnalysisLogic.getOpcodeAnalysis(this.getContext(), sourceCode);
+    }
+    // --- Info ---
+    getCompilerInfo() {
+        return InfoLogic.getCompilerInfo(this.getContext());
+    }
+    async discoverModules(entryPoint) {
+        return InfoLogic.discoverModules(this.getContext(), entryPoint);
+    }
+    isReady() {
+        return this.initialized && this.compiler !== null;
+    }
+}

package/dist/wasm/compiler/InfoLogic.d.ts

@@ -0,0 +1,6 @@
+import { CompilationContext } from "./types.js";
+export declare function getCompilerInfo(ctx: CompilationContext): {
+    version: string;
+    features: string[];
+};
+export declare function discoverModules(ctx: CompilationContext, entryPoint: string): Promise<string[]>;