@5ive-tech/sdk 1.1.13 → 1.1.14

package/dist/modules/execute.js

@@ -277,56 +277,100 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         : selectFeeShard(shardCount);
     const feeVault = await deriveProgramFeeVault(programId, feeShardIndex);
     const instructionAccounts = [
+        // Execute runtime reads script/vm_state; keep them readonly.
         { pubkey: scriptAccount, isSigner: false, isWritable: false },
         { pubkey: vmState, isSigner: false, isWritable: false },
     ];
     const abiAccountMetadata = new Map();
-    const hasFullParameterList = !!funcDef &&
-        Array.isArray(funcDef.parameters) &&
-        parameters.length === funcDef.parameters.length;
-    if (funcDef && funcDef.parameters && hasFullParameterList) {
-        // First pass: detect if there's an @init constraint and find the payer
+    const normalizeAccountPubkey = (value) => {
+        if (!value)
+            return undefined;
+        if (typeof value === "string")
+            return value;
+        if (typeof value.toBase58 === "function")
+            return value.toBase58();
+        if (typeof value.toString === "function") {
+            const str = value.toString();
+            if (str && str !== "[object Object]")
+                return str;
+        }
+        return undefined;
+    };
+    const isAccountParam = (param) => {
+        if (!param)
+            return false;
+        if (param.is_account || param.isAccount)
+            return true;
+        const type = (param.type || param.param_type || "").toString().trim().toLowerCase();
+        return type === "account" || type === "mint" || type === "tokenaccount";
+    };
+    const allParams = funcDef && Array.isArray(funcDef.parameters) ? funcDef.parameters : [];
+    const accountParams = allParams.filter((param) => isAccountParam(param));
+    const hasFullParameterList = allParams.length > 0 && parameters.length === allParams.length;
+    if (accountParams.length > 0) {
+        // First pass: detect if there's an @init constraint and identify payer param.
         let hasInit = false;
-        let payerPubkey;
-        for (let i = 0; i < funcDef.parameters.length; i++) {
-            const param = funcDef.parameters[i];
-            if (param.is_account || param.isAccount) {
-                const attributes = param.attributes || [];
-                if (attributes.includes('init')) {
-                    hasInit = true;
-                    for (let j = 0; j < funcDef.parameters.length; j++) {
-                        const payerParam = funcDef.parameters[j];
-                        if (i !== j &&
-                            (payerParam.is_account || payerParam.isAccount) &&
-                            (payerParam.attributes || []).includes('signer')) {
-                            const payerValue = parameters[j];
-                            payerPubkey = payerValue?.toString();
-                            break;
-                        }
-                    }
+        let initParamName;
+        let payerParamName;
+        for (const param of accountParams) {
+            const attributes = param.attributes || [];
+            if (attributes.includes("init")) {
+                hasInit = true;
+                initParamName = param.name;
+                break;
+            }
+        }
+        if (hasInit) {
+            for (const param of accountParams) {
+                if (param.name !== initParamName &&
+                    (param.attributes || []).includes("signer")) {
+                    payerParamName = param.name;
                     break;
                 }
             }
         }
-        funcDef.parameters.forEach((param, paramIndex) => {
-            if (param.is_account || param.isAccount) {
-                const value = parameters[paramIndex];
-                const pubkey = value?.toString();
+        // Resolve pubkeys for account params in either full-param mode or args-only mode.
+        const accountPubkeysByParamName = new Map();
+        if (hasFullParameterList) {
+            allParams.forEach((param, paramIndex) => {
+                if (!isAccountParam(param))
+                    return;
+                const pubkey = normalizeAccountPubkey(parameters[paramIndex]);
                 if (pubkey) {
-                    const attributes = param.attributes || [];
-                    const isSigner = attributes.includes('signer');
-                    const isWritable = attributes.includes('mut') ||
-                        attributes.includes('init') ||
-                        (hasInit && pubkey === payerPubkey);
-                    const existing = abiAccountMetadata.get(pubkey) || { isSigner: false, isWritable: false };
-                    abiAccountMetadata.set(pubkey, {
-                        isSigner: existing.isSigner || isSigner,
-                        isWritable: existing.isWritable || isWritable
-                    });
+                    accountPubkeysByParamName.set(param.name, pubkey);
+                }
+            });
+        }
+        else {
+            const count = Math.min(accountParams.length, accounts.length);
+            for (let i = 0; i < count; i++) {
+                const paramName = accountParams[i]?.name;
+                const pubkey = accounts[i];
+                if (paramName && pubkey) {
+                    accountPubkeysByParamName.set(paramName, pubkey);
                 }
             }
-        });
+        }
+        for (const param of accountParams) {
+            const pubkey = accountPubkeysByParamName.get(param.name);
+            if (!pubkey)
+                continue;
+            const attributes = param.attributes || [];
+            const isSigner = attributes.includes("signer");
+            const isWritable = attributes.includes("mut") ||
+                attributes.includes("init") ||
+                (hasInit && payerParamName === param.name);
+            const existing = abiAccountMetadata.get(pubkey) || {
+                isSigner: false,
+                isWritable: false,
+            };
+            abiAccountMetadata.set(pubkey, {
+                isSigner: existing.isSigner || isSigner,
+                isWritable: existing.isWritable || isWritable,
+            });
+        }
     }
+    const unknownAccounts = [];
     const userInstructionAccounts = accounts.map((acc) => {
         // Check both derived ABI metadata and passed-in metadata (from FunctionBuilder)
         const abiMetadata = abiAccountMetadata.get(acc);
@@ -335,25 +379,40 @@ export async function generateExecuteInstruction(scriptAccount, functionName, pa
         const isSigner = metadata ? metadata.isSigner : false;
         const isWritable = metadata
             ? (metadata.isSystemAccount ? false : metadata.isWritable)
-            : true;
+            : false;
+        if (!metadata) {
+            unknownAccounts.push(acc);
+        }
         return {
             pubkey: acc,
             isSigner,
             isWritable
         };
     });
+    if (unknownAccounts.length > 0) {
+        const deduped = Array.from(new Set(unknownAccounts));
+        console.warn(`[FiveSDK] Missing account metadata for ${deduped.join(", ")}; defaulting readonly. Pass accountMetadata or use FiveProgram.function(...).instruction().`);
+    }
     instructionAccounts.push(...userInstructionAccounts);
     const instructionData = encodeExecuteInstruction(functionIndex, encodedParams, actualParamCount, feeShardIndex, options.debug === true);
     // Runtime requires strict tail: [payer, fee_vault, system_program].
+    // Prefer explicit payer, otherwise infer from signer+writable account metadata only.
     const signerCandidates = instructionAccounts
         .filter((acc) => acc.isSigner)
         .map((acc) => acc.pubkey);
-    const inferredPayer = options.payerAccount ||
-        (signerCandidates.length > 0
-            ? signerCandidates[signerCandidates.length - 1]
-            : accounts[0]);
+    const metadataFor = (pubkey) => options.accountMetadata?.get(pubkey) || abiAccountMetadata.get(pubkey);
+    const writableSignerCandidates = signerCandidates.filter((pubkey) => {
+        const metadata = metadataFor(pubkey);
+        if (!metadata)
+            return false;
+        return !metadata.isSystemAccount && metadata.isWritable;
+    });
+    const inferredPayer = options.payerAccount || writableSignerCandidates[0];
     if (!inferredPayer) {
-        throw new Error("Could not infer execute fee payer account. Provide a signer account or set options.payerAccount.");
+        if (signerCandidates.length > 0) {
+            throw new Error("Could not infer execute fee payer account from writable signer metadata. Pass options.payerAccount or use FiveProgram.function(...).payer(...).instruction().");
+        }
+        throw new Error("Could not infer execute fee payer account. Provide options.payerAccount or include a writable signer account.");
     }
     const feeTailAccounts = [
         { pubkey: inferredPayer, isSigner: true, isWritable: true },
@@ -404,6 +463,7 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
                 vmStateAccount: options.vmStateAccount,
                 fiveVMProgramId: options.fiveVMProgramId,
                 abi: options.abi,
+                accountMetadata: options.accountMetadata,
                 feeShardIndex: options.feeShardIndex,
                 payerAccount: options.payerAccount || signerKeypair.publicKey.toString(),
             });
@@ -430,7 +490,6 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
         for (const meta of accountKeys) {
             if (meta.pubkey === signerPubkey) {
                 meta.isSigner = true;
-                meta.isWritable = true;
                 signerFound = true;
             }
         }
@@ -438,7 +497,7 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             accountKeys.push({
                 pubkey: signerPubkey,
                 isSigner: true,
-                isWritable: true,
+                isWritable: false,
             });
         }
         const executeInstruction = new TransactionInstruction({
@@ -452,8 +511,8 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
         });
         transaction.add(executeInstruction);
         transaction.feePayer = signerKeypair.publicKey;
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        transaction.recentBlockhash = blockhash;
+        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+        transaction.recentBlockhash = latestBlockhash.blockhash;
         transaction.partialSign(signerKeypair);
         const firstSig = transaction.signatures[0]?.signature;
         if (firstSig) {
@@ -465,12 +524,11 @@ export async function executeOnSolana(scriptAccount, connection, signerKeypair,
             maxRetries: options.maxRetries || 3,
         });
         lastSignature = signature;
-        const latestBlockhash = await connection.getLatestBlockhash("confirmed");
         const confirmation = await confirmTransactionRobust(connection, signature, {
             commitment: "confirmed",
             timeoutMs: 120000,
             debug: options.debug,
-            blockhash,
+            blockhash: latestBlockhash.blockhash,
             lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
         });
         if (!confirmation.success) {

package/dist/modules/fees.js

@@ -24,7 +24,7 @@ export async function getFees(connection, fiveVMProgramId) {
 export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgramId) {
     try {
         const accountSize = 64 + bytecodeSize;
-        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        const rentLamports = await RentCalculator.calculateRentExemptionWithConnection(accountSize, connection);
         const vmState = await getVMState(connection, fiveVMProgramId);
         const deployFeeLamports = vmState.deployFeeLamports;
         return {
@@ -41,7 +41,7 @@ export async function calculateDeployFee(bytecodeSize, connection, fiveVMProgram
     }
     catch (error) {
         const accountSize = 64 + bytecodeSize;
-        const rentLamports = await RentCalculator.calculateRentExemption(accountSize);
+        const rentLamports = await RentCalculator.calculateRentExemptionWithConnection(accountSize, connection);
         return {
             feeBps: 0,
             basisLamports: rentLamports,

package/dist/modules/namespaces.d.ts

@@ -36,4 +36,15 @@ export declare function resolveNamespaceOnChain(namespaceValue: string, options:
     resolvedScript?: string;
     bindingAddress: string;
 }>;
+export declare function setNamespaceSymbolPriceOnChain(symbol: string, priceLamports: number, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    symbol: ScopedNamespace["symbol"];
+    priceLamports: number;
+}>;
+export declare function getNamespaceSymbolPriceOnChain(symbol: string, options: NamespaceOnChainOptions): Promise<{
+    transactionId?: string;
+    symbol: ScopedNamespace["symbol"];
+    priceLamports: number;
+    priceSol: number;
+}>;
 export {};

package/dist/modules/namespaces.js

@@ -2,6 +2,7 @@ const SYMBOLS = new Set(["!", "@", "#", "$", "%"]);
 const NAMESPACE_CONFIG_SEED = "5ns_config";
 const NAMESPACE_TLD_SEED = "5ns_tld";
 const NAMESPACE_BINDING_SEED = "5ns_binding";
+const LAMPORTS_PER_SOL = 1000000000;
 export function canonicalizeScopedNamespace(input) {
     const value = input.trim();
     if (value.length < 2) {
@@ -52,6 +53,17 @@ export function resolveNamespaceFromLockfile(namespaceValue, lockfile) {
 function asBuffer(value) {
     return Buffer.from(value, "utf8");
 }
+function validateSymbol(symbol) {
+    if (!SYMBOLS.has(symbol)) {
+        throw new Error("namespace symbol must be one of ! @ # $ %");
+    }
+    return symbol;
+}
+async function deriveNamespaceConfigAccount(fiveVMProgramId) {
+    const { PDAUtils } = await import("../crypto/index.js");
+    const cfg = await PDAUtils.findProgramAddress([asBuffer(NAMESPACE_CONFIG_SEED)], fiveVMProgramId);
+    return cfg.address;
+}
 export async function deriveNamespaceAccounts(namespaceValue, fiveVMProgramId) {
     const { PDAUtils } = await import("../crypto/index.js");
     const parsed = canonicalizeScopedNamespace(namespaceValue);
@@ -188,3 +200,55 @@ export async function resolveNamespaceOnChain(namespaceValue, options) {
         bindingAddress: addresses.binding,
     };
 }
+export async function setNamespaceSymbolPriceOnChain(symbol, priceLamports, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const validatedSymbol = validateSymbol(symbol);
+    if (!Number.isFinite(priceLamports) || priceLamports <= 0 || !Number.isInteger(priceLamports)) {
+        throw new Error("priceLamports must be a positive integer");
+    }
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const configAddress = await deriveNamespaceConfigAccount(vmProgramId);
+    const admin = options.signerKeypair.publicKey.toBase58();
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "set_symbol_price", [configAddress, admin, validatedSymbol, priceLamports], [configAddress, admin], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 300000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "set_symbol_price failed");
+    }
+    return {
+        transactionId: result.transactionId,
+        symbol: validatedSymbol,
+        priceLamports,
+    };
+}
+export async function getNamespaceSymbolPriceOnChain(symbol, options) {
+    const { ProgramIdResolver } = await import("../config/ProgramIdResolver.js");
+    const { executeOnSolana } = await import("./execute.js");
+    const validatedSymbol = validateSymbol(symbol);
+    const vmProgramId = ProgramIdResolver.resolve(options.fiveVMProgramId);
+    const configAddress = await deriveNamespaceConfigAccount(vmProgramId);
+    const result = await executeOnSolana(options.managerScriptAccount, options.connection, options.signerKeypair, "get_symbol_price", [configAddress, validatedSymbol], [configAddress], {
+        debug: options.debug,
+        fiveVMProgramId: vmProgramId,
+        computeUnitLimit: 300000,
+    });
+    if (!result.success) {
+        throw new Error(result.error || "get_symbol_price failed");
+    }
+    const priceLamportsRaw = typeof result.result === "number"
+        ? result.result
+        : Number(result.result);
+    if (!Number.isFinite(priceLamportsRaw) || priceLamportsRaw < 0) {
+        throw new Error(`invalid get_symbol_price result: ${String(result.result)}`);
+    }
+    const priceLamports = Math.trunc(priceLamportsRaw);
+    return {
+        transactionId: result.transactionId,
+        symbol: validatedSymbol,
+        priceLamports,
+        priceSol: priceLamports / LAMPORTS_PER_SOL,
+    };
+}

package/dist/program/FiveProgram.js

@@ -48,12 +48,13 @@ export class FiveProgram {
                 if (typeof prop === 'string') {
                     return (...args) => {
                         const builder = target.function(prop);
-                        // TODO: Robust argument mapping based on ABI types
-                        // Simple map: if args[0] is object, assume named params
                         if (args.length === 1 && typeof args[0] === 'object' && !Array.isArray(args[0])) {
                             builder.args(args[0]);
                         }
-                        // Logic for positional args would go here
+                        else if (args.length > 0) {
+                            throw new Error(`FiveProgram.methods.${prop} only supports a single named-arguments object. ` +
+                                `Use program.function("${prop}").args({...}) for now.`);
+                        }
                         return builder;
                     };
                 }

package/dist/program/TypeGenerator.js

@@ -20,12 +20,19 @@
  * }
  * ```
  */
+import { normalizeAbiFunctions } from '../utils/abi.js';
 /**
  * TypeGenerator creates TypeScript interfaces from ABI
  */
 export class TypeGenerator {
     constructor(abi, options) {
-        this.abi = abi;
+        this.abi = {
+            ...abi,
+            functions: normalizeAbiFunctions(abi.functions ?? abi).map((func) => ({
+                ...func,
+                visibility: func.visibility ?? 'public',
+            })),
+        };
         this.options = {
             scriptName: abi.name || 'Program',
             debug: false,

package/dist/project/config.js

@@ -1,14 +1,28 @@
+const SUPPORTED_SCHEMA_VERSION = 1;
 /**
  * Parses a raw TOML object into a strict ProjectConfig.
  */
 export function parseProjectConfig(parsedToml) {
+    const schemaVersionRaw = parsedToml.schema_version;
+    if (schemaVersionRaw === undefined) {
+        throw new Error(`Missing required top-level 'schema_version'. Add:\nschema_version = ${SUPPORTED_SCHEMA_VERSION}`);
+    }
+    if (!Number.isInteger(schemaVersionRaw) || Number(schemaVersionRaw) <= 0) {
+        throw new Error('schema_version must be a positive integer');
+    }
+    const schemaVersion = Number(schemaVersionRaw);
+    if (schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
+        throw new Error(`Unsupported schema_version=${schemaVersion}. Supported schema_version: ${SUPPORTED_SCHEMA_VERSION}`);
+    }
     const project = parsedToml.project ?? {};
     const build = parsedToml.build ?? {};
     const optimizations = parsedToml.optimizations ?? {};
+    const dependencies = parsedToml.dependencies ?? {};
     const deploy = parsedToml.deploy ?? {};
     const name = project.name ?? 'five-project';
     const target = (project.target ?? 'vm');
     return {
+        schemaVersion,
         name,
         version: project.version ?? '0.1.0',
         description: project.description,
@@ -25,8 +39,106 @@ export function parseProjectConfig(parsedToml) {
         optimizations: {
             enableCompression: optimizations.enable_compression ?? true,
             enableConstraintOptimization: optimizations.enable_constraint_optimization ?? true,
+            // Public SDK config is locked to the canonical production mode.
             optimizationLevel: 'production'
         },
-        dependencies: []
+        dependencies: parseDependencies(dependencies)
     };
 }
+function parseDependencies(rawDeps) {
+    const out = [];
+    const seenNamespaces = new Set();
+    const seenAddresses = new Set();
+    const seenMoatTargets = new Set();
+    for (const [alias, rawValue] of Object.entries(rawDeps ?? {})) {
+        const value = (rawValue ?? {});
+        const dependency = {
+            alias,
+            package: String(value.package ?? ''),
+            version: value.version !== undefined ? String(value.version) : undefined,
+            source: String(value.source ?? ''),
+            link: String(value.link ?? ''),
+            path: value.path !== undefined ? String(value.path) : undefined,
+            namespace: value.namespace !== undefined ? String(value.namespace) : undefined,
+            address: value.address !== undefined ? String(value.address) : undefined,
+            moatAccount: value.moat_account !== undefined ? String(value.moat_account) : undefined,
+            module: value.module !== undefined ? String(value.module) : undefined,
+            pin: value.pin !== undefined ? String(value.pin) : undefined,
+            cluster: value.cluster !== undefined ? String(value.cluster) : undefined,
+        };
+        if (!dependency.package) {
+            throw new Error(`Invalid dependency '${alias}': missing required field 'package'`);
+        }
+        if (dependency.source !== 'bundled' &&
+            dependency.source !== 'path' &&
+            dependency.source !== 'namespace' &&
+            dependency.source !== 'address' &&
+            dependency.source !== 'moat') {
+            throw new Error(`Invalid dependency '${alias}': source must be one of bundled|path|namespace|address|moat`);
+        }
+        if (dependency.link !== 'inline' && dependency.link !== 'external') {
+            throw new Error(`Invalid dependency '${alias}': link must be one of inline|external`);
+        }
+        const hasPath = Boolean(dependency.path);
+        const hasNamespace = Boolean(dependency.namespace);
+        const hasAddress = Boolean(dependency.address);
+        const hasMoatAccount = Boolean(dependency.moatAccount);
+        const hasModule = Boolean(dependency.module);
+        if (dependency.source === 'path' && !hasPath) {
+            throw new Error(`Invalid dependency '${alias}': source=path requires 'path'`);
+        }
+        if (dependency.source === 'namespace' && !hasNamespace) {
+            throw new Error(`Invalid dependency '${alias}': source=namespace requires 'namespace'`);
+        }
+        if (dependency.source === 'address' && !hasAddress) {
+            throw new Error(`Invalid dependency '${alias}': source=address requires 'address'`);
+        }
+        if (dependency.source === 'moat' && (!hasMoatAccount || !hasModule)) {
+            throw new Error(`Invalid dependency '${alias}': source=moat requires 'moat_account' and 'module'`);
+        }
+        if (dependency.source !== 'path' && hasPath) {
+            throw new Error(`Invalid dependency '${alias}': 'path' is only valid for source=path`);
+        }
+        if (dependency.source !== 'namespace' && hasNamespace) {
+            throw new Error(`Invalid dependency '${alias}': 'namespace' is only valid for source=namespace`);
+        }
+        if (dependency.source !== 'address' && hasAddress) {
+            throw new Error(`Invalid dependency '${alias}': 'address' is only valid for source=address`);
+        }
+        if (dependency.source !== 'moat' && hasMoatAccount) {
+            throw new Error(`Invalid dependency '${alias}': 'moat_account' is only valid for source=moat`);
+        }
+        if (dependency.source !== 'moat' && hasModule) {
+            throw new Error(`Invalid dependency '${alias}': 'module' is only valid for source=moat`);
+        }
+        if (dependency.source === 'bundled' || dependency.source === 'path') {
+            if (dependency.link !== 'inline') {
+                throw new Error(`Invalid dependency '${alias}': source=${dependency.source} currently requires link=inline`);
+            }
+        }
+        else if (dependency.link !== 'external') {
+            throw new Error(`Invalid dependency '${alias}': source=${dependency.source} currently requires link=external`);
+        }
+        if (dependency.namespace) {
+            if (seenNamespaces.has(dependency.namespace)) {
+                throw new Error(`Invalid dependencies: duplicate namespace '${dependency.namespace}'`);
+            }
+            seenNamespaces.add(dependency.namespace);
+        }
+        if (dependency.address) {
+            if (seenAddresses.has(dependency.address)) {
+                throw new Error(`Invalid dependencies: duplicate address '${dependency.address}'`);
+            }
+            seenAddresses.add(dependency.address);
+        }
+        if (dependency.moatAccount && dependency.module) {
+            const moatTarget = `${dependency.moatAccount}::${dependency.module}`;
+            if (seenMoatTargets.has(moatTarget)) {
+                throw new Error(`Invalid dependencies: duplicate moat target '${moatTarget}'`);
+            }
+            seenMoatTargets.add(moatTarget);
+        }
+        out.push(dependency);
+    }
+    return out;
+}

package/dist/project/workspace.d.ts

@@ -106,6 +106,11 @@ export interface LockEntry {
     address: string;
     bytecode_hash: string;
     deployed_at?: string;
+    package?: string;
+    source?: 'bundled' | 'path' | 'namespace' | 'address';
+    link?: LinkType;
+    resolved_namespace?: string;
+    resolved_script_account?: string;
 }
 /**
  * Resolved workspace state for IDE

package/dist/testing/TestDiscovery.d.ts

@@ -45,6 +45,7 @@ export interface DiscoveredTest {
  * Discover tests from directory
  */
 export declare class TestDiscovery {
+    private static normalizeJsonTestCases;
     /**
      * Discover all tests in a directory
      */

package/dist/testing/TestDiscovery.js

@@ -12,6 +12,16 @@ import { FiveSDK } from '../FiveSDK.js';
  * Discover tests from directory
  */
 export class TestDiscovery {
+    static normalizeJsonTestCases(data) {
+        const testCases = data.tests || data.testCases || [];
+        if (Array.isArray(testCases)) {
+            return testCases;
+        }
+        if (testCases && typeof testCases === 'object') {
+            return null;
+        }
+        return [];
+    }
     /**
      * Discover all tests in a directory
      */
@@ -66,7 +76,10 @@ export class TestDiscovery {
                 try {
                     const content = await readFile(file, 'utf8');
                     const data = JSON.parse(content);
-                    const testCases = data.tests || data.testCases || [];
+                    const testCases = this.normalizeJsonTestCases(data);
+                    if (testCases === null) {
+                        continue;
+                    }
                     for (const testCase of testCases) {
                         tests.push({
                             name: testCase.name,
@@ -98,7 +111,10 @@ export class TestDiscovery {
             try {
                 const content = await readFile(file, 'utf8');
                 const data = JSON.parse(content);
-                const testCases = data.tests || data.testCases || [];
+                const testCases = this.normalizeJsonTestCases(data);
+                if (testCases === null) {
+                    return [];
+                }
                 return testCases.map((testCase) => ({
                     name: testCase.name,
                     path: file,

package/dist/testing/TestRunner.js

@@ -211,10 +211,13 @@ export class FiveTestRunner {
                 try {
                     const content = await readFile(test.path, 'utf8');
                     const data = JSON.parse(content);
+                    const testCases = Array.isArray(data.tests || data.testCases)
+                        ? (data.tests || data.testCases)
+                        : [];
                     suites.push({
                         name: data.name || basename(test.path, '.test.json'),
                         description: data.description,
-                        testCases: data.tests || data.testCases || []
+                        testCases
                     });
                     loadedJsonSuites.add(test.path);
                 }