recon-generate 0.0.38 → 0.0.39

package/dist/db.js

@@ -100,10 +100,19 @@ async function ensureBuild(foundryRoot, forceBuild) {
     await runCmd(cmd, foundryRoot);
 }
 /**
- * Load the latest build-info JSON file from .recon/out/build-info.
+ * Load the latest build-info cluster from .recon/out/build-info.
+ *
+ * A single `forge build` run may emit multiple build-info files (one per compiler
+ * config). Files are clustered by mtime proximity and their outputs are merged:
+ * output.contracts + output.sources + input.sources. First-encountered (newest)
+ * file wins on key collisions.
  */
 function loadBuildInfoRaw(foundryRoot) {
+    var _a;
     const buildInfoDir = path.join(foundryRoot, '.recon', 'out', 'build-info');
+    // Reuse the shared helper synchronously via readdirSync/statSync so we don't
+    // change this function's signature. findLatestBuildInfoCluster is async; the
+    // logic is simple enough to inline here for the sync path.
     let files = [];
     try {
         const entries = fs.readdirSync(buildInfoDir);
@@ -119,28 +128,66 @@ function loadBuildInfoRaw(foundryRoot) {
     if (files.length === 0) {
         throw new Error(`No build-info JSON files found in ${buildInfoDir}. Run: forge build --build-info`);
     }
-    const latestFile = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0];
-    console.log(`[recon-generate] Using build-info: ${latestFile.name}`);
-    const stat = fs.statSync(latestFile.fullPath);
-    console.log(`[recon-generate] Reading build-info (${(stat.size / 1024 / 1024).toFixed(1)} MB)...`);
-    const rawContent = fs.readFileSync(latestFile.fullPath, 'utf-8');
-    console.log(`[recon-generate] Parsing JSON...`);
-    const parsed = JSON.parse(rawContent);
-    const { output, compilerVersion: detectedVersion } = normalizeCompilerOutput(parsed);
-    const compilerVersion = detectedVersion || '0.8.0';
-    return { raw: parsed, output, compilerVersion };
+    // Cluster by mtime proximity (10s window) — see utils.findLatestBuildInfoCluster.
+    const CLUSTER_WINDOW_MS = 10000;
+    const sorted = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const anchorTime = sorted[0].mtime.getTime();
+    const cluster = sorted.filter((f) => anchorTime - f.mtime.getTime() <= CLUSTER_WINDOW_MS);
+    if (cluster.length > 1) {
+        console.log(`[recon-generate] Detected ${cluster.length} build-info files from latest run; merging.`);
+    }
+    const mergedOutput = { contracts: {}, sources: {} };
+    const mergedInputSources = {};
+    let compilerVersion = null;
+    for (const file of cluster) {
+        console.log(`[recon-generate] Using build-info: ${file.name}`);
+        const stat = fs.statSync(file.fullPath);
+        console.log(`[recon-generate] Reading build-info (${(stat.size / 1024 / 1024).toFixed(1)} MB)...`);
+        const rawContent = fs.readFileSync(file.fullPath, 'utf-8');
+        console.log(`[recon-generate] Parsing JSON...`);
+        const parsed = JSON.parse(rawContent);
+        const { output, compilerVersion: detectedVersion } = normalizeCompilerOutput(parsed);
+        // First file (newest) wins on per-key collisions.
+        if (output === null || output === void 0 ? void 0 : output.contracts) {
+            for (const [filePath, contracts] of Object.entries(output.contracts)) {
+                mergedOutput.contracts[filePath] = {
+                    ...contracts,
+                    ...(mergedOutput.contracts[filePath] || {}),
+                };
+            }
+        }
+        if (output === null || output === void 0 ? void 0 : output.sources) {
+            for (const [filePath, src] of Object.entries(output.sources)) {
+                if (!mergedOutput.sources[filePath]) {
+                    mergedOutput.sources[filePath] = src;
+                }
+            }
+        }
+        if ((_a = parsed.input) === null || _a === void 0 ? void 0 : _a.sources) {
+            for (const [filePath, entry] of Object.entries(parsed.input.sources)) {
+                if (!mergedInputSources[filePath]) {
+                    mergedInputSources[filePath] = entry;
+                }
+            }
+        }
+        if (!compilerVersion && detectedVersion) {
+            compilerVersion = detectedVersion;
+        }
+    }
+    return {
+        output: mergedOutput,
+        inputSources: mergedInputSources,
+        compilerVersion: compilerVersion || '0.8.0',
+    };
 }
 /**
  * Extract source contents from build-info input.sources
  */
-function extractSourceContents(raw) {
-    var _a;
+function extractSourceContents(inputSources) {
     const sourceContents = new Map();
-    if ((_a = raw.input) === null || _a === void 0 ? void 0 : _a.sources) {
-        for (const [filePath, entry] of Object.entries(raw.input.sources)) {
-            if (entry === null || entry === void 0 ? void 0 : entry.content) {
-                sourceContents.set(filePath, entry.content);
-            }
+    for (const [filePath, entry] of Object.entries(inputSources)) {
+        if (entry === null || entry === void 0 ? void 0 : entry.content) {
+            sourceContents.set(filePath, entry.content);
         }
     }
     return sourceContents;
@@ -148,9 +195,9 @@ function extractSourceContents(raw) {
 const runDb = async (foundryRoot, options = {}) => {
     // Build into .recon/out (skipping test/script), reuse if already present
     await ensureBuild(foundryRoot, !!options.forceBuild);
-    // Load latest build-info from .recon/out
-    const { raw, output, compilerVersion } = loadBuildInfoRaw(foundryRoot);
-    const sourceContents = extractSourceContents(raw);
+    // Load latest build-info cluster from .recon/out
+    const { output, inputSources, compilerVersion } = loadBuildInfoRaw(foundryRoot);
+    const sourceContents = extractSourceContents(inputSources);
     console.log(`[recon-generate] Compiler version: ${compilerVersion}`);
     if (sourceContents.size > 0) {
         console.log(`[recon-generate] Found ${sourceContents.size} source content entries`);

package/dist/link2.js

@@ -121,40 +121,34 @@ const runForgeBuildAndGetLibraries = async (cwd, verbose = false) => {
             resolve();
         });
     });
-    // Find the most recent build-info JSON file
+    // Find the latest build-info cluster — a single `forge build` run can emit
+    // multiple files (one per compiler config), so we stream libraries from all
+    // of them and union the results.
     const foundryConfig = await (0, utils_1.getFoundryConfig)(cwd);
     const buildInfoDir = path.join(cwd, foundryConfig.out, 'build-info');
     if (verbose) {
         console.log(`[VERBOSE] Looking for build-info files in: ${buildInfoDir}`);
     }
-    let files;
+    let cluster;
     try {
-        files = await fs.readdir(buildInfoDir);
-    }
-    catch {
-        throw new Error(`Build info directory not found: ${buildInfoDir}. Make sure forge build --build-info completed successfully.`);
-    }
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
-    if (jsonFiles.length === 0) {
-        throw new Error(`No build-info JSON files found in ${buildInfoDir}`);
-    }
-    // Get the most recent file by modification time
-    let mostRecentFile = jsonFiles[0];
-    let mostRecentTime = 0;
-    for (const file of jsonFiles) {
-        const filePath = path.join(buildInfoDir, file);
-        const stats = await fs.stat(filePath);
-        if (stats.mtimeMs > mostRecentTime) {
-            mostRecentTime = stats.mtimeMs;
-            mostRecentFile = file;
-        }
+        cluster = await (0, utils_1.findLatestBuildInfoCluster)(buildInfoDir);
     }
-    const buildInfoPath = path.join(buildInfoDir, mostRecentFile);
-    if (verbose) {
-        console.log(`[VERBOSE] Streaming build-info from: ${buildInfoPath}`);
+    catch (e) {
+        throw new Error(`${e.message} Make sure forge build --build-info completed successfully.`);
+    }
+    if (verbose && cluster.length > 1) {
+        console.log(`[VERBOSE] Detected ${cluster.length} build-info files from latest run; streaming each.`);
+    }
+    const allLibraries = new Set();
+    for (const file of cluster) {
+        if (verbose) {
+            console.log(`[VERBOSE] Streaming build-info from: ${file.path}`);
+        }
+        const libs = await streamLibrariesFromBuildInfo(file.path, verbose);
+        for (const lib of libs)
+            allLibraries.add(lib);
     }
-    // Stream-parse instead of loading entire file into memory
-    return streamLibrariesFromBuildInfo(buildInfoPath, verbose);
+    return Array.from(allLibraries);
 };
 const formatEchidnaYaml = (config, libraries) => {
     const cfg = { ...config };

package/dist/sourcemap.js

@@ -70,26 +70,63 @@ function findFoundryProject(startDir = process.cwd()) {
     }
     return null;
 }
-function findBuildInfo(projectDir, outDir = 'out') {
+async function findBuildInfoCluster(projectDir, outDir = 'out') {
     const buildInfoDir = path.join(projectDir, outDir, 'build-info');
     if (!fs.existsSync(buildInfoDir))
         return null;
-    const files = fs.readdirSync(buildInfoDir).filter(f => f.endsWith('.json'));
-    if (files.length === 0)
+    try {
+        return await (0, utils_1.findLatestBuildInfoCluster)(buildInfoDir);
+    }
+    catch {
         return null;
-    // Return the most recent build-info file
-    const sorted = files.sort((a, b) => {
-        const statA = fs.statSync(path.join(buildInfoDir, a));
-        const statB = fs.statSync(path.join(buildInfoDir, b));
-        return statB.mtimeMs - statA.mtimeMs;
-    });
-    return path.join(buildInfoDir, sorted[0]);
+    }
 }
 function loadBuildInfo(buildInfoPath) {
     const content = fs.readFileSync(buildInfoPath, 'utf-8');
     const buildInfo = JSON.parse(content);
     return buildInfo.output || buildInfo;
 }
+/**
+ * Load and merge build-info output from every file in the cluster.
+ * First-encountered (newest) file wins on per-key collisions in sources/contracts.
+ */
+function loadAndMergeBuildInfoCluster(cluster) {
+    const mergedSources = {};
+    const mergedContracts = {};
+    const sourceListSet = new Set();
+    const paths = [];
+    for (const file of cluster) {
+        const output = loadBuildInfo(file.path);
+        paths.push(file.path);
+        if (output === null || output === void 0 ? void 0 : output.sources) {
+            for (const [filePath, src] of Object.entries(output.sources)) {
+                if (!mergedSources[filePath]) {
+                    mergedSources[filePath] = src;
+                }
+            }
+        }
+        if (output === null || output === void 0 ? void 0 : output.contracts) {
+            for (const [filePath, contracts] of Object.entries(output.contracts)) {
+                mergedContracts[filePath] = {
+                    ...contracts,
+                    ...(mergedContracts[filePath] || {}),
+                };
+            }
+        }
+        if (Array.isArray(output === null || output === void 0 ? void 0 : output.sourceList)) {
+            for (const s of output.sourceList)
+                sourceListSet.add(s);
+        }
+    }
+    return {
+        astData: {
+            sources: mergedSources,
+            contracts: mergedContracts,
+            sourceList: Array.from(sourceListSet),
+        },
+        paths,
+    };
+}
 function getAllSourceContracts(sourceUnits, astData) {
     const results = [];
     const sources = astData.sources || {};
@@ -158,14 +195,19 @@ async function runSourcemap(foundryRoot, options = {}) {
     console.log(`📁 Project: ${projectDir}`);
     console.log(`📂 Output:  ${outputDir}`);
     const startTime = Date.now();
-    // Find build info
-    const buildInfoPath = findBuildInfo(projectDir, forgeOutDir);
-    if (!buildInfoPath) {
+    // Find build-info cluster (handles multi-config runs emitting >1 file).
+    const cluster = await findBuildInfoCluster(projectDir, forgeOutDir);
+    if (!cluster || cluster.length === 0) {
         throw new Error(`No build-info found in ${projectDir}/${forgeOutDir}/build-info/. Run "forge build" first to generate build artifacts.`);
     }
-    console.log(`📂 Found build-info: ${path.basename(buildInfoPath)}`);
-    // Load AST
-    const astData = loadBuildInfo(buildInfoPath);
+    if (cluster.length > 1) {
+        console.log(`📂 Found ${cluster.length} build-info files (latest run): ${cluster.map(f => f.name).join(', ')}`);
+    }
+    else {
+        console.log(`📂 Found build-info: ${cluster[0].name}`);
+    }
+    // Load and merge AST + contracts across the cluster.
+    const { astData, paths: buildInfoPaths } = loadAndMergeBuildInfoCluster(cluster);
     const reader = new solc_typed_ast_1.ASTReader();
     const skipPatterns = ['forge-std/', 'lib/forge-std/'];
     const filteredSources = {};
@@ -228,7 +270,15 @@ async function runSourcemap(foundryRoot, options = {}) {
     console.log(`🗺️  Step 2/3: Generating Branch Mappings...`);
     console.log(`${'─'.repeat(60)}`);
     const { loadBuildInfoSourceMaps, generateBranchMapping } = await Promise.resolve().then(() => __importStar(require('./cfg/sourcemap')));
-    const sourceMaps = loadBuildInfoSourceMaps(buildInfoPath);
+    // Merge source maps from every cluster file. First-encountered (newest) wins.
+    const sourceMaps = new Map();
+    for (const p of buildInfoPaths) {
+        const perFileMaps = loadBuildInfoSourceMaps(p);
+        for (const [name, data] of perFileMaps) {
+            if (!sourceMaps.has(name))
+                sourceMaps.set(name, data);
+        }
+    }
     const contractsToProcess = Array.from(sourceMaps.keys()).filter(name => {
         const mapData = sourceMaps.get(name);
         return mapData && mapData.sourceFile.startsWith('src/');

package/dist/utils.d.ts

@@ -65,15 +65,38 @@ export declare const parseBuildOutput: (buildOutput: any, skipPatterns?: string[
  * @returns Object containing sourceUnits and raw buildOutput
  */
 export declare const loadBuildInfoFromFile: (buildInfoPath: string, skipPatterns?: string[]) => Promise<BuildInfoResult>;
+/**
+ * A single build-info file on disk.
+ */
+export interface BuildInfoFile {
+    name: string;
+    path: string;
+    mtime: Date;
+}
+/**
+ * Find the cluster of build-info files produced by the latest `forge build` run.
+ *
+ * Foundry emits one build-info per unique compiler config (e.g. mixed solc
+ * versions), so a single run can produce multiple files. We anchor on the
+ * newest file's mtime and include any file within `clusterWindowMs`. Older
+ * files (from prior runs) are excluded. Returns newest-first ordering.
+ */
+export declare const findLatestBuildInfoCluster: (buildInfoDir: string, clusterWindowMs?: number) => Promise<BuildInfoFile[]>;
 /**
  * Load the latest build info from a Foundry project.
  *
+ * A single `forge build` run may emit multiple build-info files (one per compiler
+ * config — e.g. mixed solc versions). We cluster files by mtime proximity: the
+ * newest file anchors a window, and any file with an mtime within `clusterWindowMs`
+ * is considered part of the same run. Older files (from prior runs) are ignored.
+ *
  * @param foundryRoot - The root directory of the Foundry project
  * @param outputDir - The output directory relative to foundryRoot (default: 'out')
  * @param skipPatterns - Optional array of patterns to skip (e.g., ['test/', 'script/'])
- * @returns Object containing sourceUnits and raw buildOutput
+ * @param clusterWindowMs - Time window (ms) for grouping build-infos from the same run (default: 10000)
+ * @returns Object containing merged sourceUnits and raw buildOutput
  */
-export declare const loadLatestBuildInfo: (foundryRoot: string, outputDir?: string, skipPatterns?: string[]) => Promise<BuildInfoResult>;
+export declare const loadLatestBuildInfo: (foundryRoot: string, outputDir?: string, skipPatterns?: string[], clusterWindowMs?: number) => Promise<BuildInfoResult>;
 /**
  * Recursively walks parameter internalType fields and extracts referenced type names.
  * For dotted types like "struct ISpoke.DynamicReserveConfig" → extracts "ISpoke"

package/dist/utils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadLatestBuildInfo = exports.loadBuildInfoFromFile = exports.parseBuildOutput = exports.signatureEquals = exports.getFunctionName = exports.getIndex = exports.getSource = exports.getLines = exports.FOUNDRY_CONFIG_DEFAULTS = void 0;
+exports.loadLatestBuildInfo = exports.findLatestBuildInfoCluster = exports.loadBuildInfoFromFile = exports.parseBuildOutput = exports.signatureEquals = exports.getFunctionName = exports.getIndex = exports.getSource = exports.getLines = exports.FOUNDRY_CONFIG_DEFAULTS = void 0;
 exports.fileExists = fileExists;
 exports.getFoundryConfigPath = getFoundryConfigPath;
 exports.findOutputDirectory = findOutputDirectory;
@@ -527,16 +527,14 @@ const loadBuildInfoFromFile = async (buildInfoPath, skipPatterns = []) => {
 };
 exports.loadBuildInfoFromFile = loadBuildInfoFromFile;
 /**
- * Load the latest build info from a Foundry project.
+ * Find the cluster of build-info files produced by the latest `forge build` run.
  *
- * @param foundryRoot - The root directory of the Foundry project
- * @param outputDir - The output directory relative to foundryRoot (default: 'out')
- * @param skipPatterns - Optional array of patterns to skip (e.g., ['test/', 'script/'])
- * @returns Object containing sourceUnits and raw buildOutput
+ * Foundry emits one build-info per unique compiler config (e.g. mixed solc
+ * versions), so a single run can produce multiple files. We anchor on the
+ * newest file's mtime and include any file within `clusterWindowMs`. Older
+ * files (from prior runs) are excluded. Returns newest-first ordering.
  */
-const loadLatestBuildInfo = async (foundryRoot, outputDir = 'out', skipPatterns = []) => {
-    const outDir = path.join(foundryRoot, outputDir);
-    const buildInfoDir = path.join(outDir, 'build-info');
+const findLatestBuildInfoCluster = async (buildInfoDir, clusterWindowMs = 10000) => {
     let files = [];
     try {
         const entries = await fs.readdir(buildInfoDir);
@@ -553,8 +551,74 @@ const loadLatestBuildInfo = async (foundryRoot, outputDir = 'out', skipPatterns
     if (files.length === 0) {
         throw new Error(`No build-info JSON files found in ${buildInfoDir}.`);
     }
-    const latestFile = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0].path;
-    return (0, exports.loadBuildInfoFromFile)(latestFile, skipPatterns);
+    const sorted = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    const anchorTime = sorted[0].mtime.getTime();
+    return sorted.filter((f) => anchorTime - f.mtime.getTime() <= clusterWindowMs);
+};
+exports.findLatestBuildInfoCluster = findLatestBuildInfoCluster;
+/**
+ * Merge two build outputs by shallow-combining their `contracts` and `sources` maps.
+ * Keys present in `base` are preserved (base wins on collision).
+ */
+const mergeBuildOutputs = (base, next) => {
+    const merged = { ...base };
+    if (next === null || next === void 0 ? void 0 : next.contracts) {
+        merged.contracts = { ...((base === null || base === void 0 ? void 0 : base.contracts) || {}) };
+        for (const [filePath, contracts] of Object.entries(next.contracts)) {
+            merged.contracts[filePath] = {
+                ...contracts,
+                ...(merged.contracts[filePath] || {}),
+            };
+        }
+    }
+    if (next === null || next === void 0 ? void 0 : next.sources) {
+        merged.sources = { ...((base === null || base === void 0 ? void 0 : base.sources) || {}) };
+        for (const [filePath, src] of Object.entries(next.sources)) {
+            if (!merged.sources[filePath]) {
+                merged.sources[filePath] = src;
+            }
+        }
+    }
+    return merged;
+};
+/**
+ * Load the latest build info from a Foundry project.
+ *
+ * A single `forge build` run may emit multiple build-info files (one per compiler
+ * config — e.g. mixed solc versions). We cluster files by mtime proximity: the
+ * newest file anchors a window, and any file with an mtime within `clusterWindowMs`
+ * is considered part of the same run. Older files (from prior runs) are ignored.
+ *
+ * @param foundryRoot - The root directory of the Foundry project
+ * @param outputDir - The output directory relative to foundryRoot (default: 'out')
+ * @param skipPatterns - Optional array of patterns to skip (e.g., ['test/', 'script/'])
+ * @param clusterWindowMs - Time window (ms) for grouping build-infos from the same run (default: 10000)
+ * @returns Object containing merged sourceUnits and raw buildOutput
+ */
+const loadLatestBuildInfo = async (foundryRoot, outputDir = 'out', skipPatterns = [], clusterWindowMs = 10000) => {
+    const outDir = path.join(foundryRoot, outputDir);
+    const buildInfoDir = path.join(outDir, 'build-info');
+    const cluster = await (0, exports.findLatestBuildInfoCluster)(buildInfoDir, clusterWindowMs);
+    if (cluster.length === 1) {
+        return (0, exports.loadBuildInfoFromFile)(cluster[0].path, skipPatterns);
+    }
+    // Parse each build-info independently (each has its own AST ID space; feeding
+    // merged sources into a single ASTReader would collide on duplicate IDs).
+    // Then concat sourceUnits (deduped by absolutePath) and merge buildOutput maps.
+    const seenSourcePaths = new Set();
+    const mergedSourceUnits = [];
+    let mergedBuildOutput = {};
+    for (const f of cluster) {
+        const { sourceUnits, buildOutput } = await (0, exports.loadBuildInfoFromFile)(f.path, skipPatterns);
+        for (const unit of sourceUnits) {
+            if (!seenSourcePaths.has(unit.absolutePath)) {
+                seenSourcePaths.add(unit.absolutePath);
+                mergedSourceUnits.push(unit);
+            }
+        }
+        mergedBuildOutput = mergeBuildOutputs(mergedBuildOutput, buildOutput);
+    }
+    return { sourceUnits: mergedSourceUnits, buildOutput: mergedBuildOutput };
 };
 exports.loadLatestBuildInfo = loadLatestBuildInfo;
 // --- Extra import resolution utilities ---

package/dist/z3Solver.js

@@ -125,18 +125,17 @@ const getExpressionName = (expr) => {
 };
 const expressionToZ3 = (ctx, expr, varMap, bitSize, signed) => {
     if (expr instanceof solc_typed_ast_1.Literal) {
-        let value = expr.value || '0';
-        // Handle hex values
-        if (value.startsWith('0x')) {
-            value = BigInt(value).toString();
-        }
-        // Handle negative values for signed types
+        // Only numeric literals can be solved as BitVecs. Bool/string/hexString
+        // literals have no BitVec form — skip them instead of letting BigInt throw.
+        if (expr.kind !== 'number')
+            return null;
+        const value = (expr.value || '').trim();
+        if (!/^-?(0x[0-9a-fA-F]+|[0-9]+)$/.test(value))
+            return null;
         if (value.startsWith('-')) {
             const absVal = BigInt(value.slice(1));
-            // Two's complement
             const maxVal = BigInt(1) << BigInt(bitSize);
-            const signedVal = maxVal - absVal;
-            return ctx.BitVec.val(signedVal, bitSize);
+            return ctx.BitVec.val(maxVal - absVal, bitSize);
         }
         return ctx.BitVec.val(BigInt(value), bitSize);
     }
@@ -252,19 +251,26 @@ const createZ3Constraint = (ctx, expr, varMap, bitSize, signed) => {
     }
 };
 /**
- * Parse Z3 value string to BigInt
- * Z3 returns hex values in format like #xFFFF... or decimal strings
+ * Parse Z3 value string to BigInt.
+ * Z3 returns hex values in format like #xFFFF... or decimal strings.
+ * Returns null for unparseable values (e.g., uninterpreted-function expressions
+ * like `keccak256` or `unknown_length` that Z3 couldn't reduce to a literal).
  */
 const parseZ3Value = (valueStr) => {
-    // Handle Z3 hex format: #xFFFF... -> 0xFFFF...
     if (valueStr.startsWith('#x')) {
-        return BigInt('0x' + valueStr.slice(2));
+        const hex = valueStr.slice(2);
+        if (!/^[0-9a-fA-F]+$/.test(hex))
+            return null;
+        return BigInt('0x' + hex);
     }
-    // Handle Z3 binary format: #b0101... -> 0b0101...
     if (valueStr.startsWith('#b')) {
-        return BigInt('0b' + valueStr.slice(2));
+        const bin = valueStr.slice(2);
+        if (!/^[01]+$/.test(bin))
+            return null;
+        return BigInt('0b' + bin);
     }
-    // Handle regular decimal or hex
+    if (!/^-?(0x[0-9a-fA-F]+|[0-9]+)$/.test(valueStr))
+        return null;
     return BigInt(valueStr);
 };
 const solveConstraint = async (ctx, constraint, varMap, bitSize, signed) => {
@@ -279,6 +285,9 @@ const solveConstraint = async (ctx, constraint, varMap, bitSize, signed) => {
         const value = model.eval(z3Var);
         const valueStr = value.toString();
         let numValue = parseZ3Value(valueStr);
+        // Skip uninterpreted/non-numeric model values (keccak256(...), etc.)
+        if (numValue === null)
+            continue;
         // Convert to signed if needed
         if (signed && numValue >= BigInt(1) << BigInt(bitSize - 1)) {
             numValue = numValue - (BigInt(1) << BigInt(bitSize));
@@ -295,11 +304,19 @@ const setZ3Silent = (silent) => {
 exports.setZ3Silent = setZ3Silent;
 const findZ3Solutions = async (fnDef) => {
     const solutions = [];
+    let ctx;
     try {
-        const { ctx } = await initZ3();
-        // Find all comparison operations
-        const binOps = fnDef.getChildrenByType(solc_typed_ast_1.BinaryOperation);
-        for (const binOp of binOps) {
+        ({ ctx } = await initZ3());
+    }
+    catch (e) {
+        if (!silentMode) {
+            console.warn(`[z3] Warning: init failed: ${e}`);
+        }
+        return solutions;
+    }
+    const binOps = fnDef.getChildrenByType(solc_typed_ast_1.BinaryOperation);
+    for (const binOp of binOps) {
+        try {
             // Only handle equality operator
             if (binOp.operator !== '==') {
                 continue;
@@ -363,11 +380,11 @@ const findZ3Solutions = async (fnDef) => {
                 });
             }
         }
-    }
-    catch (e) {
-        // Z3 errors are non-fatal
-        if (!silentMode) {
-            console.warn(`[z3] Warning: ${e}`);
+        catch (e) {
+            // Per-constraint errors are non-fatal — skip this binOp and continue.
+            if (!silentMode) {
+                console.warn(`[z3] Warning: ${e}`);
+            }
         }
     }
     return solutions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
@@ -26,15 +26,15 @@
     "commander": "^14.0.3",
     "ethers": "^6.16.0",
     "handlebars": "^4.7.8",
-    "solc-typed-ast": "^20.0.2",
+    "solc-typed-ast": "^20.0.5",
     "src-location": "^1.1.0",
     "stream-json": "^1.9.1",
-    "better-sqlite3": "^12.6.2",
-    "yaml": "^2.8.2",
-    "z3-solver": "^4.15.4"
+    "better-sqlite3": "^12.9.0",
+    "yaml": "^2.8.3",
+    "z3-solver": "^4.16.0"
   },
   "devDependencies": {
-    "@types/node": "^25.2.0",
+    "@types/node": "^25.6.0",
     "@types/stream-json": "^1.7.8",
     "typescript": "^5.8.3"
   }