@5ive-tech/sdk 1.1.10 → 1.1.12

package/dist/wasm/compiler/CompilationLogic.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile } from "fs/promises";
-import { createCompilerError, extractMetrics, extractAbi } from "./utils.js";
+import { createCompilerError, extractMetrics, extractAbi, extractFormattedErrors, extractDiagnostics, } from "./utils.js";
 export async function compile(ctx, source, options) {
     if (!ctx.compiler) {
         throw createCompilerError("Compiler not initialized");
@@ -25,7 +25,8 @@ export async function compile(ctx, source, options) {
             .with_metrics(includeMetrics)
             .with_comprehensive_metrics(comprehensiveMetrics)
             .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
+            .with_error_format(errorFormat)
+            .with_source_file(options?.sourceFile || "input.v");
         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`);
@@ -50,6 +51,8 @@ export async function compile(ctx, source, options) {
             }
         }
         const metricsPayload = extractMetrics(result, metricsFormat);
+        const formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         if (result.success && result.bytecode) {
             return {
                 success: true,
@@ -58,79 +61,33 @@ export async function compile(ctx, source, options) {
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
         else {
             return {
                 success: false,
-                errors: result.compiler_errors || [],
+                errors: diagnostics,
+                warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+                diagnostics,
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
     }
     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
+        if (error &&
+            typeof error === "object" &&
+            error.code === "COMPILER_ERROR") {
+            throw error;
         }
-        // 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`);
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error, {
+            phase: "compile",
+        });
     }
 }
 export async function compileFile(ctx, options) {
@@ -233,60 +190,17 @@ export async function compileFile(ctx, options) {
         }
         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 formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         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") || [],
+            errors: diagnostics,
+            warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+            diagnostics,
+            formattedErrorsTerminal: formattedErrors.terminal,
+            formattedErrorsJson: formattedErrors.json,
             metrics: {
                 compilationTime: result.compilation_time || compilationTime,
                 bytecodeSize: result.bytecode_size || 0,
@@ -353,9 +267,12 @@ export async function compileWithDiscovery(ctx, entryPoint, options) {
             .with_metrics(includeMetrics)
             .with_comprehensive_metrics(comprehensiveMetrics)
             .with_metrics_format(metricsFormat)
-            .with_error_format(errorFormat);
+            .with_error_format(errorFormat)
+            .with_source_file(entryPoint);
         const result = ctx.compiler.compileMultiWithDiscovery(entryPoint, compilationOptions);
         const metricsPayload = extractMetrics(result, metricsFormat);
+        const formattedErrors = extractFormattedErrors(result);
+        const diagnostics = extractDiagnostics(result, ctx.logger);
         if (result.success && result.bytecode) {
             return {
                 success: true,
@@ -364,68 +281,33 @@ export async function compileWithDiscovery(ctx, entryPoint, options) {
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
         else {
             return {
                 success: false,
-                errors: result.compiler_errors || [],
+                errors: diagnostics,
+                warnings: diagnostics.filter((diag) => diag.severity === "warning"),
+                diagnostics,
                 metadata: result.metadata,
                 metrics: metricsPayload,
                 metricsReport: metricsPayload,
+                formattedErrorsTerminal: formattedErrors.terminal,
+                formattedErrorsJson: formattedErrors.json,
             };
         }
     }
     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;
+        if (error &&
+            typeof error === "object" &&
+            error.code === "COMPILER_ERROR") {
+            throw error;
         }
-        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);
+        throw createCompilerError(`Compilation error: ${error instanceof Error ? error.message : "Unknown error"}`, error, {
+            phase: "compileWithDiscovery",
+            entryPoint,
+        });
     }
 }

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

@@ -17,13 +17,8 @@ export declare class FiveCompiler {
     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>;

package/dist/wasm/compiler/FiveCompiler.js

@@ -121,18 +121,12 @@ export class FiveCompiler {
     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);

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

@@ -1,5 +1,38 @@
 import { CLIError } from "../../types.js";
-export declare function createCompilerError(message: string, cause?: Error): CLIError;
+export interface NormalizedCompilationSuggestion {
+    message: string;
+    explanation?: string;
+    confidence?: number;
+    codeSuggestion?: string;
+}
+export interface NormalizedCompilationDiagnostic {
+    type: string;
+    code: string;
+    severity: string;
+    category: string;
+    message: string;
+    description?: string;
+    line?: number;
+    column?: number;
+    sourceLocation?: string;
+    location?: any;
+    suggestion?: string;
+    suggestions?: NormalizedCompilationSuggestion[];
+    sourceLine?: string;
+    sourceSnippet?: string;
+    rendered?: string;
+    raw?: any;
+}
+export interface FormattedErrors {
+    terminal?: string;
+    json?: string;
+}
+export declare function createCompilerError(message: string, cause?: Error, details?: Record<string, unknown>): CLIError;
+export declare function extractFormattedErrors(result: any): FormattedErrors;
+export declare function normalizeDiagnostic(error: any): NormalizedCompilationDiagnostic;
+export declare function extractDiagnostics(result: any, logger?: {
+    debug?: (...args: any[]) => void;
+}): NormalizedCompilationDiagnostic[];
 export declare function extractMetrics(result: any, defaultFormat: string): {
     format: string;
     exported: string;

package/dist/wasm/compiler/utils.js

@@ -1,17 +1,235 @@
-export function createCompilerError(message, cause) {
+const COMPILER_ERROR_CODE = "COMPILER_ERROR";
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : undefined;
+}
+function toOptionalNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function readStringMethod(target, methodName) {
+    if (!target || typeof target !== "object") {
+        return undefined;
+    }
+    const maybeMethod = target[methodName];
+    if (typeof maybeMethod !== "function") {
+        return undefined;
+    }
+    try {
+        const value = maybeMethod.call(target);
+        return toOptionalString(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readStringProperty(target, propName) {
+    if (!target || typeof target !== "object") {
+        return undefined;
+    }
+    return toOptionalString(target[propName]);
+}
+function normalizeSuggestion(suggestion) {
+    if (typeof suggestion === "string") {
+        return { message: suggestion };
+    }
+    if (!isObject(suggestion)) {
+        return undefined;
+    }
+    const message = toOptionalString(suggestion.message) ??
+        toOptionalString(suggestion.explanation);
+    if (!message) {
+        return undefined;
+    }
+    return {
+        message,
+        explanation: toOptionalString(suggestion.explanation),
+        confidence: toOptionalNumber(suggestion.confidence),
+        codeSuggestion: toOptionalString(suggestion.code_suggestion) ??
+            toOptionalString(suggestion.codeSuggestion),
+    };
+}
+function pickSuggestions(rawSuggestions) {
+    if (!Array.isArray(rawSuggestions)) {
+        return undefined;
+    }
+    const normalized = rawSuggestions
+        .map((item) => normalizeSuggestion(item))
+        .filter((item) => Boolean(item));
+    return normalized.length > 0 ? normalized : undefined;
+}
+function buildFallbackSuggestions(code) {
+    switch (code) {
+        case "E2000":
+            return [
+                {
+                    message: "Declare the variable before use with `let <name> = ...`.",
+                    confidence: 0.8,
+                },
+                {
+                    message: "Check for spelling differences between parameter/field names and usages.",
+                    confidence: 0.7,
+                },
+            ];
+        case "E0002":
+            return [
+                {
+                    message: "Check for missing closing `}`, `)`, or an incomplete function signature.",
+                    confidence: 0.75,
+                },
+            ];
+        case "E0001":
+        case "E0004":
+            return [
+                {
+                    message: "Check for missing punctuation (`;`, `{`, `}`) near the reported statement.",
+                    confidence: 0.7,
+                },
+            ];
+        default:
+            return [];
+    }
+}
+export function createCompilerError(message, cause, details) {
+    if (cause &&
+        isObject(cause) &&
+        cause.code === COMPILER_ERROR_CODE) {
+        return cause;
+    }
     const error = new Error(message);
     error.name = "CompilerError";
-    error.code = "COMPILER_ERROR";
+    error.code = COMPILER_ERROR_CODE;
     error.category = "wasm";
     error.exitCode = 1;
-    if (cause) {
+    if (cause || details) {
+        const inheritedDetails = cause && isObject(cause.details)
+            ? cause.details
+            : undefined;
         error.details = {
-            cause: cause.message,
-            stack: cause.stack,
+            ...(inheritedDetails || {}),
+            ...(details || {}),
+            ...(cause
+                ? {
+                    cause: cause.message,
+                    stack: cause.stack,
+                }
+                : {}),
         };
     }
     return error;
 }
+export function extractFormattedErrors(result) {
+    const terminal = readStringMethod(result, "get_formatted_errors_terminal") ||
+        readStringProperty(result, "formattedErrorsTerminal") ||
+        readStringProperty(result, "formatted_errors_terminal") ||
+        readStringMethod(result, "format_all_terminal");
+    const json = readStringMethod(result, "format_all_json") ||
+        readStringMethod(result, "get_formatted_errors_json") ||
+        readStringProperty(result, "formattedErrorsJson") ||
+        readStringProperty(result, "formatted_errors_json");
+    return { terminal, json };
+}
+export function normalizeDiagnostic(error) {
+    let parsedJson;
+    if (error && typeof error?.format_json === "function") {
+        try {
+            const raw = error.format_json();
+            const parsed = JSON.parse(raw);
+            if (isObject(parsed)) {
+                parsedJson = parsed;
+            }
+        }
+        catch {
+            // Ignore formatter/parsing failures and continue with direct field access.
+        }
+    }
+    const merged = {
+        ...(parsedJson || {}),
+        ...(isObject(error) ? error : {}),
+    };
+    const location = isObject(merged.location) ? merged.location : undefined;
+    const line = toOptionalNumber(merged.line) ?? toOptionalNumber(location?.line);
+    const column = toOptionalNumber(merged.column) ?? toOptionalNumber(location?.column);
+    const file = toOptionalString(merged.sourceLocation) ??
+        toOptionalString(location?.file);
+    const code = toOptionalString(merged.code) || "E0000";
+    const suggestionList = pickSuggestions(merged.suggestions) || buildFallbackSuggestions(code);
+    const rendered = toOptionalString(merged.rendered) ||
+        (typeof merged.format_terminal === "function"
+            ? toOptionalString(merged.format_terminal())
+            : undefined);
+    return {
+        type: toOptionalString(merged.type) || "enhanced",
+        code,
+        severity: toOptionalString(merged.severity) || "error",
+        category: toOptionalString(merged.category) || "compilation",
+        message: toOptionalString(merged.message) ||
+            toOptionalString(merged.description) ||
+            "Unknown compiler error",
+        description: toOptionalString(merged.description),
+        line,
+        column,
+        sourceLocation: file,
+        location,
+        suggestion: suggestionList?.[0]?.message,
+        suggestions: suggestionList,
+        sourceLine: toOptionalString(merged.source_line) ||
+            toOptionalString(merged.sourceLine),
+        sourceSnippet: toOptionalString(merged.source_snippet) ||
+            toOptionalString(merged.sourceSnippet),
+        rendered,
+        raw: error,
+    };
+}
+function parseDiagnosticsJson(jsonPayload, logger) {
+    try {
+        const parsed = JSON.parse(jsonPayload);
+        const arr = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed?.errors)
+                ? parsed.errors
+                : [];
+        return arr.map((item) => normalizeDiagnostic(item));
+    }
+    catch (error) {
+        logger?.debug?.("[Compilation] Failed to parse formatted JSON diagnostics", error);
+        return [];
+    }
+}
+export function extractDiagnostics(result, logger) {
+    const formatted = extractFormattedErrors(result);
+    if (formatted.json) {
+        const parsed = parseDiagnosticsJson(formatted.json, logger);
+        if (parsed.length > 0) {
+            return parsed;
+        }
+    }
+    if (Array.isArray(result?.compiler_errors)) {
+        const fromCompiler = result.compiler_errors.map((item) => normalizeDiagnostic(item));
+        if (fromCompiler.length > 0) {
+            return fromCompiler;
+        }
+    }
+    if (Array.isArray(result?.errors)) {
+        const fromErrors = result.errors.map((item) => normalizeDiagnostic(item));
+        if (fromErrors.length > 0) {
+            return fromErrors;
+        }
+    }
+    return [];
+}
 export function extractMetrics(result, defaultFormat) {
     if (!result || typeof result !== "object") {
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@5ive-tech/sdk",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "description": "Client-agnostic TypeScript SDK for Five VM scripts on Solana",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,8 @@
     "sync:wasm:rebuild": "bash ../scripts/sync-wasm-assets.sh --rebuild",
     "verify:wasm": "bash ../scripts/verify-wasm-sync.sh",
     "copy-assets": "mkdir -p dist/assets/vm && COPYFILE_DISABLE=1 cp src/assets/vm/* dist/assets/vm/",
-    "test": "node examples/basic-usage.js",
+    "test": "npm run test:jest --",
+    "test:example": "node src/examples/basic-usage.js",
     "test:jest": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand",
     "test:localnet": "USE_SOLANA_MOCKS=0 RUN_LOCALNET_VALIDATOR_TESTS=1 NODE_OPTIONS=--experimental-vm-modules jest --runInBand src/__tests__/integration/localnet-fee-vault.test.ts",
     "gen-types": "node ./node_modules/typescript/bin/tsc && node dist/bin/gen-types.js",
@@ -57,4 +58,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}