@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.e090cb3

package/packages/ai/src/lib/dataStructure/ScopeDataStructure.js

@@ -79,15 +79,29 @@
  * - `helpers/README.md` - Overview of the helper module architecture
  */
 import fillInSchemaGapsAndUnknowns from "./helpers/fillInSchemaGapsAndUnknowns.js";
+import { clearCleanKnownObjectFunctionsCache } from "./helpers/cleanKnownObjectFunctions.js";
+import { clearCleanNonObjectFunctionsCache } from "./helpers/cleanNonObjectFunctions.js";
+/**
+ * Patterns that indicate recursive type structures in schema paths.
+ * Used by hasExcessivePatternRepetition() to detect exponential path blowup.
+ */
+const RECURSIVE_PATH_PATTERNS = [
+    /\.attributes\.properties\[\]/g, // TypeScript AST JSX nodes
+    /\.children\[\]/g, // Tree structures
+    /\.elements\[\]/g, // Array-like structures
+    /\.members\[\]/g, // Class/interface members
+    /\.properties\[\]/g, // Object properties
+    /\.items\[\]/g, // Generic items arrays
+];
 import ensureSchemaConsistency from "./helpers/ensureSchemaConsistency.js";
 import cleanPath from "./helpers/cleanPath.js";
 import { PathManager } from "./helpers/PathManager.js";
-import { uniqueId, uniqueScopeVariables, uniqueScopeAndPaths, } from "./helpers/uniqueIdUtils.js";
+import { uniqueId, uniqueScopeAndPaths, uniqueScopeVariables, } from "./helpers/uniqueIdUtils.js";
 import selectBestValue from "./helpers/selectBestValue.js";
 import { VisitedTracker } from "./helpers/VisitedTracker.js";
 import { DebugTracer } from "./helpers/DebugTracer.js";
 import { BatchSchemaProcessor } from "./helpers/BatchSchemaProcessor.js";
-import { ScopeTreeManager, ROOT_SCOPE_NAME, } from "./helpers/ScopeTreeManager.js";
+import { ROOT_SCOPE_NAME, ScopeTreeManager, } from "./helpers/ScopeTreeManager.js";
 import cleanScopeNodeName from "./helpers/cleanScopeNodeName.js";
 import getFunctionCallRoot from "./helpers/getFunctionCallRoot.js";
 import cleanPathOfNonTransformingFunctions from "./helpers/cleanPathOfNonTransformingFunctions.js";
@@ -108,6 +122,17 @@ export function resetScopeDataStructureMetrics() {
     followEquivalenciesEarlyExitPhase1Count = 0;
     followEquivalenciesWithWorkCount = 0;
     addEquivalencyCallCount = 0;
+    // Clear module-level caches to prevent unbounded memory growth across entities
+    const knownObjectCache = clearCleanKnownObjectFunctionsCache();
+    const nonObjectCache = clearCleanNonObjectFunctionsCache();
+    if (knownObjectCache.count > 0 || nonObjectCache.count > 0) {
+        const totalBytes = knownObjectCache.estimatedBytes + nonObjectCache.estimatedBytes;
+        console.log('CodeYam: Cleared analysis caches', {
+            knownObjectCache: `${knownObjectCache.count} entries, ${(knownObjectCache.estimatedBytes / 1024).toFixed(1)}KB`,
+            nonObjectCache: `${nonObjectCache.count} entries, ${(nonObjectCache.estimatedBytes / 1024).toFixed(1)}KB`,
+            totalKB: `${(totalBytes / 1024).toFixed(1)}KB`,
+        });
+    }
 }
 // Performance: Pre-computed Sets for equivalency reason filtering (O(1) vs O(n))
 const ALLOWED_EQUIVALENCY_REASONS = new Set([
@@ -138,7 +163,12 @@ const ALLOWED_EQUIVALENCY_REASONS = new Set([
     'Array.from() equivalency',
     'propagated sub-property equivalency',
     'propagated function call return sub-property equivalency',
+    'propagated parent-variable equivalency', // Added: propagate child scope equivalencies to parent scope when variable is defined in parent
     'where was this function called from', // Added: tracks which scope called an external function
+    'MUI DataGrid renderCell params.row equivalency', // Added: links DataGrid renderCell params.row to rows array elements
+    'MUI Autocomplete getOptionLabel option equivalency', // Added: links Autocomplete getOptionLabel callback param to options array
+    'MUI Autocomplete renderOption option equivalency', // Added: links Autocomplete renderOption callback param to options array
+    'MUI Autocomplete option property equivalency', // Added: propagates property accesses from Autocomplete callbacks
 ]);
 const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
     'signature of functionCall',
@@ -151,6 +181,7 @@ const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
     'transformed non-object function equivalency - implicit parent equivalency - rerouted via useCallback',
     'transformed non-object function equivalency - Array.from() equivalency',
     'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
+    // 'transformed non-object function equivalency - Explicit array deconstruction equivalency value',
 ]);
 export class ScopeDataStructure {
     // Getter for backward compatibility - returns the tree structure
@@ -171,6 +202,26 @@ export class ScopeDataStructure {
          * Maps local variable path to array of usages.
          */
         this.rawConditionalUsages = {};
+        /**
+         * Conditional effects collected during AST analysis.
+         * Tracks what setter calls happen inside conditionals (if, switch, ternary).
+         */
+        this.rawConditionalEffects = [];
+        /**
+         * Compound conditionals collected during AST analysis.
+         * Groups conditions that must all be true together (e.g., a && b && c).
+         */
+        this.rawCompoundConditionals = [];
+        /**
+         * Gating conditions for child component boundaries.
+         * Maps child component name to the conditions that must be true for it to render.
+         */
+        this.rawChildBoundaryGatingConditions = {};
+        /**
+         * JSX rendering usages collected during AST analysis.
+         * Tracks arrays rendered via .map() and strings interpolated in JSX.
+         */
+        this.rawJsxRenderingUsages = [];
         this.lastAddToSchemaId = 0;
         this.lastEquivalencyId = 0;
         this.lastEquivalencyDatabaseId = 0;
@@ -182,6 +233,9 @@ export class ScopeDataStructure {
         // Index for O(1) lookup of external function calls by name
         // Invalidated by setting to null; rebuilt lazily on next access
         this.externalFunctionCallsIndex = null;
+        // Tracks internal functions that have been filtered out during captureCompleteSchema
+        // Prevents re-adding them via subsequent equivalency propagation (e.g., from getReturnValue)
+        this.filteredInternalFunctions = new Set();
         // Debug tracer for selective path/scope tracing
         // Enable via: CODEYAM_DEBUG=true CODEYAM_DEBUG_PATHS="user.*,signature" npm test
         this.tracer = new DebugTracer({
@@ -300,6 +354,8 @@ export class ScopeDataStructure {
             const efcName = this.pathManager.stripGenerics(efc.name);
             for (const manager of this.equivalencyManagers) {
                 if (manager.internalFunctions.has(efcName)) {
+                    // Track this so we don't re-add it via subsequent finalize calls
+                    this.filteredInternalFunctions.add(efcName);
                     return false;
                 }
             }
@@ -320,11 +376,42 @@ export class ScopeDataStructure {
             });
             entry.sourceCandidates = entry.sourceCandidates.filter((candidate) => {
                 const baseName = this.pathManager.stripGenerics(candidate.scopeNodeName);
+                // Check if this is a local variable path (doesn't contain function call pattern)
+                // Local variables like "surveys[]" or "items[]" are important for tracing data flow
+                // from parent to child components (e.g., surveys[] -> SurveyCard().signature[0].survey)
+                const isLocalVariablePath = !candidate.schemaPath.includes('()') &&
+                    !candidate.schemaPath.startsWith('signature[') &&
+                    !candidate.schemaPath.startsWith('returnValue');
                 return (validExternalFacingScopeNames.has(baseName) &&
                     (candidate.schemaPath.startsWith('signature[') ||
-                        candidate.schemaPath.startsWith(baseName)) &&
+                        candidate.schemaPath.startsWith(baseName) ||
+                        isLocalVariablePath) &&
                     !containsArrayMethod(candidate.schemaPath));
             });
+            // If all sourceCandidates were filtered out (e.g., because they belonged to
+            // internal functions like useState), look for the highest-order intermediate
+            // that belongs to a valid external-facing scope
+            if (entry.sourceCandidates.length === 0 &&
+                Object.keys(entry.intermediatesOrder).length > 0) {
+                // Find intermediates that belong to valid external-facing scopes
+                const validIntermediates = Object.entries(entry.intermediatesOrder)
+                    .filter(([pathId]) => {
+                    const [scopeNodeName, schemaPath] = pathId.split('::');
+                    if (!scopeNodeName || !schemaPath)
+                        return false;
+                    const baseName = this.pathManager.stripGenerics(scopeNodeName);
+                    return (validExternalFacingScopeNames.has(baseName) &&
+                        !containsArrayMethod(schemaPath));
+                })
+                    .sort((a, b) => b[1] - a[1]); // Sort by order descending (highest first)
+                if (validIntermediates.length > 0) {
+                    const [pathId] = validIntermediates[0];
+                    const [scopeNodeName, schemaPath] = pathId.split('::');
+                    if (scopeNodeName && schemaPath) {
+                        entry.sourceCandidates.push({ scopeNodeName, schemaPath });
+                    }
+                }
+            }
         }
         this.propagateSourceAndUsageEquivalencies(this.scopeNodes[this.scopeTreeManager.getRootName()]);
         for (const externalFunctionCall of this.externalFunctionCalls) {
@@ -389,6 +476,10 @@ export class ScopeDataStructure {
             }
             return;
         }
+        // PERF: Early exit for paths with repeated function-call signature patterns
+        if (this.hasExcessivePatternRepetition(path)) {
+            return;
+        }
         // Update chain metadata for database tracking
         if (equivalencyValueChain.length > 0) {
             equivalencyValueChain[equivalencyValueChain.length - 1].addToSchemaId =
@@ -558,7 +649,6 @@ export class ScopeDataStructure {
     }
     addEquivalency(path, equivalentPath, equivalentScopeName, scopeNode, equivalencyReason, equivalencyValueChain, traceId) {
         var _a;
-        // DEBUG: Detect infinite loops
         addEquivalencyCallCount++;
         if (addEquivalencyCallCount > 50000) {
             console.error('INFINITE LOOP DETECTED in addEquivalency', {
@@ -583,13 +673,54 @@ export class ScopeDataStructure {
                 return;
             }
         }
+        // Skip self-referential equivalencies that would create infinite loops.
+        // Case 1: Direct self-reference (path === equivalentPath)
+        // FunctionCallManager adds equivalency(subPath, subPath, externalFunctionName, ...)
+        // For simple calls like buildBranchFileMap(), this is fine.
+        // But for chained calls like query.where().where().where(), each method call adds
+        // a .functionCallReturnValue segment, and the equivalency processing creates an infinite loop.
+        // We detect chained calls by counting .functionCallReturnValue occurrences in the path.
+        if (path === equivalentPath &&
+            equivalencyReason === 'equivalency to external function call') {
+            // Count how many .functionCallReturnValue segments are in the path
+            const functionCallReturnValueCount = (path.match(/\.functionCallReturnValue/g) || []).length;
+            // Skip if there are multiple chained calls (2+ .functionCallReturnValue segments)
+            if (functionCallReturnValueCount >= 2) {
+                return;
+            }
+        }
+        // Case 2: Circular reference where equivalentPath contains path as a prefix
+        // e.g., path="query" and equivalentPath="query.where(...).functionCallReturnValue"
+        // This happens with method chaining patterns where a variable is reassigned to
+        // the result of a method call on itself: query = query.where(...)
+        // Resolving this equivalency would require resolving query first, creating infinite recursion.
+        if (equivalentPath.startsWith(path + '.') ||
+            equivalentPath.startsWith(path + '(')) {
+            return;
+        }
         if (!equivalentScopeName) {
-            console.warn('Debug Propagation: missing equivalent scope name', {
+            console.error('CodeYam Error: Missing equivalent scope name - FULL CONTEXT:', JSON.stringify({
                 path,
                 equivalentPath,
                 equivalentScopeName,
                 scopeNodeName: scopeNode.name,
-            });
+                equivalencyReason,
+                tree: scopeNode.tree,
+                equivalencyValueChain: equivalencyValueChain?.map((ev) => ({
+                    id: ev.id,
+                    source: ev.source,
+                    reason: ev.reason,
+                    currentPath: ev.currentPath,
+                    previousPath: ev.previousPath,
+                })),
+                scopeNodeFunctionCalls: scopeNode.functionCalls?.map((fc) => ({
+                    name: fc.name,
+                    callSignature: fc.callSignature,
+                    callScope: fc.callScope,
+                })),
+                instantiatedVariables: scopeNode.instantiatedVariables,
+                parentInstantiatedVariables: scopeNode.parentInstantiatedVariables,
+            }, null, 2));
             throw new Error('CodeYam Error: Missing equivalent scope name');
         }
         (_a = scopeNode.equivalencies)[path] || (_a[path] = []);
@@ -712,22 +843,57 @@ export class ScopeDataStructure {
             const searchKey = getFunctionCallRoot(functionCallInfo.callSignature);
             const existingFunctionCall = this.getExternalFunctionCallsIndex().get(searchKey);
             if (existingFunctionCall) {
-                existingFunctionCall.schema = {
+                // Preserve per-call schemas BEFORE merging to enable per-variable mock data.
+                // This is critical for hooks like useFetcher<UserData>() vs useFetcher<ReportData>()
+                // where each call returns different typed data.
+                if (!existingFunctionCall.perCallSignatureSchemas) {
+                    // First merge - save the existing call's schema
+                    existingFunctionCall.perCallSignatureSchemas = {
+                        [existingFunctionCall.callSignature]: {
+                            ...existingFunctionCall.schema,
+                        },
+                    };
+                }
+                // Save the new call's schema before it gets merged
+                existingFunctionCall.perCallSignatureSchemas[functionCallInfo.callSignature] = { ...functionCallInfo.schema };
+                // Merge schemas using selectBestValue to preserve specific types like 'null'
+                // over generic types like 'unknown'. This ensures ref variables detected
+                // earlier (marked as 'null') aren't overwritten by later 'unknown' values.
+                const mergedSchema = {
                     ...existingFunctionCall.schema,
-                    ...functionCallInfo.schema,
                 };
+                for (const key in functionCallInfo.schema) {
+                    const existingValue = existingFunctionCall.schema[key];
+                    const newValue = functionCallInfo.schema[key];
+                    mergedSchema[key] = selectBestValue(existingValue, newValue, newValue);
+                }
+                existingFunctionCall.schema = mergedSchema;
                 existingFunctionCall.equivalencies = {
                     ...existingFunctionCall.equivalencies,
                     ...functionCallInfo.equivalencies,
                 };
+                // Track all call signatures that get merged (e.g., logger.info, logger.debug, etc.)
+                if (!existingFunctionCall.allCallSignatures) {
+                    existingFunctionCall.allCallSignatures = [
+                        existingFunctionCall.callSignature,
+                    ];
+                }
+                if (!existingFunctionCall.allCallSignatures.includes(functionCallInfo.callSignature)) {
+                    existingFunctionCall.allCallSignatures.push(functionCallInfo.callSignature);
+                }
             }
             else {
                 const functionCallInfoNameParts = this.splitPath(functionCallInfo.name);
                 const isExternal = !callingScopeNode.instantiatedVariables?.includes(functionCallInfoNameParts[0]) &&
                     !callingScopeNode.parentInstantiatedVariables?.includes(functionCallInfoNameParts[0]);
                 if (isExternal) {
-                    this.externalFunctionCalls.push(functionCallInfo);
-                    this.invalidateExternalFunctionCallsIndex();
+                    // Check if this function was already filtered out as an internal function
+                    // (e.g., useState was filtered in captureCompleteSchema but finalize is trying to re-add it)
+                    const strippedName = this.pathManager.stripGenerics(functionCallInfo.name);
+                    if (!this.filteredInternalFunctions.has(strippedName)) {
+                        this.externalFunctionCalls.push(functionCallInfo);
+                        this.invalidateExternalFunctionCallsIndex();
+                    }
                 }
             }
         }
@@ -796,9 +962,26 @@ export class ScopeDataStructure {
                 const remainingKey = remainingSchemaPathParts.join('|');
                 const equivalentSchemaPath = equivalentSchemaPathMap.get(remainingKey);
                 if (equivalentSchemaPath) {
+                    // Skip propagation when there's a structural mismatch:
+                    // - schemaPath ends with [] (array element, represents an object)
+                    // - equivalentSchemaPath doesn't end with [] (non-array prop, usually a scalar)
+                    // This prevents incorrectly typing array elements as strings when they're
+                    // equivalent to scalar props like JSX keys (e.g., workouts[] ↔ Card().key)
+                    const schemaPathEndsWithArray = schemaPath.endsWith('[]');
+                    const equivalentEndsWithArray = equivalentSchemaPath.endsWith('[]');
+                    if (schemaPathEndsWithArray !== equivalentEndsWithArray) {
+                        // Don't propagate between array element paths and non-array paths
+                        continue;
+                    }
                     const value1 = scopeNode.schema[schemaPath];
                     const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
                     const bestValue = selectBestValue(value1, value2);
+                    // PERF: Skip paths with repeated function-call signature patterns
+                    // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+                    if (this.hasExcessivePatternRepetition(schemaPath) ||
+                        this.hasExcessivePatternRepetition(equivalentSchemaPath)) {
+                        continue;
+                    }
                     scopeNode.schema[schemaPath] = bestValue;
                     equivalentScopeNode.schema[equivalentSchemaPath] = bestValue;
                 }
@@ -810,6 +993,10 @@ export class ScopeDataStructure {
                         equivalentPath,
                         ...remainingSchemaPathParts,
                     ]);
+                    // PERF: Skip paths with repeated function-call signature patterns
+                    if (this.hasExcessivePatternRepetition(newEquivalentPath)) {
+                        continue;
+                    }
                     equivalentScopeNode.schema[newEquivalentPath] =
                         scopeNode.schema[schemaPath];
                 }
@@ -837,6 +1024,22 @@ export class ScopeDataStructure {
     joinPathParts(pathParts) {
         return this.pathManager.joinPathParts(pathParts);
     }
+    /**
+     * Extracts the root variable name from a path.
+     * E.g., "collected[]" -> "collected", "foo.bar" -> "foo", "collected[0]" -> "collected"
+     */
+    extractRootVariable(path) {
+        const parts = this.splitPath(path);
+        if (parts.length === 0)
+            return null;
+        const firstPart = parts[0];
+        // Strip array notation: "collected[]" -> "collected", "collected[0]" -> "collected"
+        const bracketIndex = firstPart.indexOf('[');
+        if (bracketIndex > 0) {
+            return firstPart.substring(0, bracketIndex);
+        }
+        return firstPart;
+    }
     // PRIVATE METHODS //
     uniqueId(params) {
         return uniqueId(params);
@@ -850,26 +1053,103 @@ export class ScopeDataStructure {
     isValidPath(path) {
         return this.pathManager.isValidPath(path);
     }
+    /**
+     * Detects if a path contains excessive repetition of the same pattern.
+     *
+     * This prevents exponential blowup when analyzing recursive type structures.
+     * For example, TypeScript AST nodes have `.attributes.properties[]` where each
+     * property is also a node with `.attributes.properties[]`. Without this check,
+     * paths like `signature[0].attributes.properties[].attributes.properties[].attributes.properties[]...`
+     * would be generated exponentially.
+     *
+     * Two detection strategies:
+     * 1. Known patterns: Check RECURSIVE_PATH_PATTERNS for common recursive structures
+     * 2. Generic detection: For longer paths, detect any 2-3 part segment that repeats
+     *
+     * @param path - The schema path to check
+     * @param maxRepetitions - Maximum allowed repetitions of any pattern (default: 2)
+     * @returns true if the path has excessive repetition
+     */
+    hasExcessivePatternRepetition(path, maxRepetitions = 2) {
+        // Check known recursive patterns
+        for (const pattern of RECURSIVE_PATH_PATTERNS) {
+            const matches = path.match(pattern);
+            if (matches && matches.length > maxRepetitions) {
+                return true;
+            }
+        }
+        // Check for repeated function calls that indicate recursive type expansion.
+        // E.g., localeCompare(b[])...localeCompare(b[]) means string.localeCompare
+        // returns a type that again has localeCompare, causing infinite expansion.
+        // We extract all function call patterns like "funcName(args)" and check if
+        // the same normalized call appears more than once.
+        const funcCallPattern = /(?:^|\.)[^.([]+\([^)]*\)/g;
+        const funcCallMatches = path.match(funcCallPattern);
+        if (funcCallMatches && funcCallMatches.length > 1) {
+            const seen = new Set();
+            for (const match of funcCallMatches) {
+                // Strip leading dot and normalize array indices
+                const normalized = match.replace(/^\./, '').replace(/\[\d+\]/g, '[]');
+                if (seen.has(normalized))
+                    return true;
+                seen.add(normalized);
+            }
+        }
+        // For longer paths, detect any repeated multi-part segments we haven't explicitly listed
+        const pathParts = this.splitPath(path);
+        if (pathParts.length <= 6) {
+            return false;
+        }
+        // Check for repeated sequences of 2-3 consecutive parts
+        for (let segmentLength = 2; segmentLength <= 3; segmentLength++) {
+            const seen = new Map();
+            for (let i = 0; i <= pathParts.length - segmentLength; i++) {
+                const segment = pathParts.slice(i, i + segmentLength).join('.');
+                const normalizedSegment = segment.replace(/\[\d+\]/g, '[]');
+                const count = (seen.get(normalizedSegment) || 0) + 1;
+                seen.set(normalizedSegment, count);
+                if (count > maxRepetitions) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     addToTree(pathParts) {
         this.scopeTreeManager.addPath(pathParts);
     }
     setInstantiatedVariables(scopeNode) {
         let instantiatedVariables = scopeNode.analysis?.instantiatedVariables ?? [];
-        for (const [path, equivalentPath] of Object.entries(scopeNode.analysis.isolatedEquivalentVariables ?? {})) {
-            if (typeof equivalentPath !== 'string') {
-                continue;
-            }
-            if (equivalentPath.startsWith('signature[')) {
-                const equivalentPathParts = this.splitPath(equivalentPath);
-                instantiatedVariables.push(equivalentPathParts[0]);
-                instantiatedVariables.push(path);
+        for (const [path, rawEquivalentPath] of Object.entries(scopeNode.analysis.isolatedEquivalentVariables ?? {})) {
+            // Normalize to array for consistent handling (supports both string and string[])
+            const equivalentPaths = Array.isArray(rawEquivalentPath)
+                ? rawEquivalentPath
+                : rawEquivalentPath
+                    ? [rawEquivalentPath]
+                    : [];
+            for (const equivalentPath of equivalentPaths) {
+                if (typeof equivalentPath !== 'string') {
+                    continue;
+                }
+                if (equivalentPath.startsWith('signature[')) {
+                    const equivalentPathParts = this.splitPath(equivalentPath);
+                    instantiatedVariables.push(equivalentPathParts[0]);
+                    instantiatedVariables.push(path);
+                }
             }
             const duplicateInstantiated = instantiatedVariables.find((v) => path.split('::cyDuplicateKey')[0] === v.split('::cyDuplicateKey')[0]);
             if (duplicateInstantiated) {
                 instantiatedVariables.push(path);
             }
         }
-        instantiatedVariables = instantiatedVariables.filter((varName, index, self) => self.indexOf(varName) === index);
+        const instantiatedSeen = new Set();
+        instantiatedVariables = instantiatedVariables.filter((varName) => {
+            if (instantiatedSeen.has(varName)) {
+                return false;
+            }
+            instantiatedSeen.add(varName);
+            return true;
+        });
         scopeNode.instantiatedVariables = instantiatedVariables;
         if (!scopeNode.tree || scopeNode.tree.length === 0) {
             return;
@@ -881,72 +1161,156 @@ export class ScopeDataStructure {
         const parentInstantiatedVariables = [
             ...(parentScopeNode.parentInstantiatedVariables ?? []),
             ...parentScopeNode.instantiatedVariables.filter((v) => !v.startsWith('signature[') && !v.startsWith('returnValue')),
-        ].filter((varName, index, self) => !instantiatedVariables.includes(varName) &&
-            self.indexOf(varName) === index);
-        scopeNode.parentInstantiatedVariables = parentInstantiatedVariables;
+        ].filter((varName) => !instantiatedSeen.has(varName));
+        const parentInstantiatedSeen = new Set();
+        const dedupedParentInstantiatedVariables = parentInstantiatedVariables.filter((varName) => {
+            if (parentInstantiatedSeen.has(varName)) {
+                return false;
+            }
+            parentInstantiatedSeen.add(varName);
+            return true;
+        });
+        scopeNode.parentInstantiatedVariables = dedupedParentInstantiatedVariables;
     }
     trackFunctionCalls(scopeNode) {
         this.captureFunctionCalls(scopeNode);
         this.checkExternalFunctionCalls();
     }
     determineEquivalenciesAndBuildSchema(scopeNode) {
+        if (!scopeNode.analysis) {
+            return;
+        }
         const { isolatedStructure, isolatedEquivalentVariables } = scopeNode.analysis;
+        // Flatten isolatedEquivalentVariables values for allPaths (handles both string and string[])
+        const flattenedEquivValues = Object.values(isolatedEquivalentVariables || {}).flatMap((v) => (Array.isArray(v) ? v : [v]));
         const allPaths = Array.from(new Set([
             ...Object.keys(isolatedStructure || {}),
             ...Object.keys(isolatedEquivalentVariables || {}),
-            ...Object.values(isolatedEquivalentVariables || {}),
+            ...flattenedEquivValues,
         ]));
         for (let path in isolatedEquivalentVariables) {
-            let equivalentValue = isolatedEquivalentVariables?.[path];
-            if (equivalentValue && this.isValidPath(equivalentValue)) {
-                path = cleanPath(path.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
-                equivalentValue = cleanPath(equivalentValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
-                this.addEquivalency(path, equivalentValue, scopeNode.name, scopeNode, 'original equivalency');
-                // Propagate sub-property equivalencies when the equivalentValue is a simple variable
-                // that has sub-properties defined in the isolatedEquivalentVariables.
-                // This handles cases like: dataItem={{ structure: completeDataStructure }}
-                // where completeDataStructure has sub-properties like completeDataStructure['Function Arguments']
-                // We need to propagate these to create: dataItem.structure['Function Arguments'] equivalencies
-                const isSimpleVariable = !equivalentValue.startsWith('signature[') &&
-                    !equivalentValue.includes('functionCallReturnValue') &&
-                    !equivalentValue.includes('.') &&
-                    !equivalentValue.includes('[');
-                if (isSimpleVariable) {
-                    // Look in current scope and all parent scopes for sub-properties
-                    const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
-                    for (const scopeName of scopesToCheck) {
-                        const checkScope = this.scopeNodes[scopeName];
-                        if (!checkScope?.analysis?.isolatedEquivalentVariables)
-                            continue;
-                        for (const [subPath, subValue] of Object.entries(checkScope.analysis.isolatedEquivalentVariables)) {
-                            // Check if this is a sub-property of the equivalentValue variable
-                            // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
-                            const matchesDot = subPath.startsWith(equivalentValue + '.');
-                            const matchesBracket = subPath.startsWith(equivalentValue + '[');
-                            if (matchesDot || matchesBracket) {
-                                const subPropertyPath = subPath.substring(equivalentValue.length);
-                                const newPath = cleanPath(path + subPropertyPath, allPaths);
-                                const newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
-                                if (newEquivalentValue &&
-                                    this.isValidPath(newEquivalentValue)) {
-                                    this.addEquivalency(newPath, newEquivalentValue, checkScope.name, // Use the scope where the sub-property was found
-                                    scopeNode, 'propagated sub-property equivalency');
-                                }
+            const rawEquivalentValue = isolatedEquivalentVariables?.[path];
+            // Normalize to array for consistent handling
+            const equivalentValues = Array.isArray(rawEquivalentValue)
+                ? rawEquivalentValue
+                : [rawEquivalentValue];
+            for (let equivalentValue of equivalentValues) {
+                if (equivalentValue && this.isValidPath(equivalentValue)) {
+                    // IMPORTANT: DO NOT strip ::cyDuplicateKey:: markers from equivalencies.
+                    // These markers are critical for distinguishing variable reassignments.
+                    // For example, with:
+                    //   let fetcher = useFetcher<ConfigData>();
+                    //   const configData = fetcher.data?.data;
+                    //   fetcher = useFetcher<SettingsData>();
+                    //   const settingsData = fetcher.data?.data;
+                    //
+                    // mergeStatements creates:
+                    //   fetcher → useFetcher<ConfigData>()...
+                    //   fetcher::cyDuplicateKey1:: → useFetcher<SettingsData>()...
+                    //   configData → fetcher.data.data
+                    //   settingsData → fetcher::cyDuplicateKey1::.data.data
+                    //
+                    // If we strip ::cyDuplicateKey::, settingsData would incorrectly trace
+                    // to useFetcher<ConfigData>() instead of useFetcher<SettingsData>().
+                    path = cleanPath(path, allPaths);
+                    equivalentValue = cleanPath(equivalentValue, allPaths);
+                    this.addEquivalency(path, equivalentValue, scopeNode.name, scopeNode, 'original equivalency');
+                    // Propagate equivalencies involving parent-scope variables to those parent scopes.
+                    // This handles patterns like: collected.push({...entity}) where 'collected' is defined
+                    // in a parent scope. The equivalency collected[] -> push().signature[0] needs to be
+                    // visible when tracing from the parent scope.
+                    const rootVariable = this.extractRootVariable(path);
+                    const equivalentRootVariable = this.extractRootVariable(equivalentValue);
+                    // Skip propagation for self-referential reassignment patterns like:
+                    //   x = x.method().functionCallReturnValue
+                    // where the path IS the variable itself (not a sub-path like x[] or x.prop).
+                    // These create circular references since both sides reference the same variable.
+                    //
+                    // But DO propagate for patterns like collected[] -> collected.push(...).signature[0]
+                    // where the path has additional segments beyond the root variable.
+                    const pathIsJustRootVariable = path === rootVariable;
+                    const isSelfReferentialReassignment = pathIsJustRootVariable && rootVariable === equivalentRootVariable;
+                    if (rootVariable &&
+                        !isSelfReferentialReassignment &&
+                        scopeNode.parentInstantiatedVariables?.includes(rootVariable)) {
+                        // Find the parent scope where this variable is defined
+                        for (const parentScopeName of scopeNode.tree || []) {
+                            const parentScope = this.scopeNodes[parentScopeName];
+                            if (parentScope?.instantiatedVariables?.includes(rootVariable)) {
+                                // Add the equivalency to the parent scope as well
+                                this.addEquivalency(path, equivalentValue, scopeNode.name, // The equivalent path's scope remains the child scope
+                                parentScope, // But store it in the parent scope's equivalencies
+                                'propagated parent-variable equivalency');
+                                break;
                             }
-                            // Also check if equivalentValue itself maps to a functionCallReturnValue
-                            // e.g., result = useMemo(...).functionCallReturnValue
-                            if (subPath === equivalentValue &&
-                                typeof subValue === 'string' &&
-                                subValue.endsWith('.functionCallReturnValue')) {
-                                this.propagateFunctionCallReturnSubProperties(path, subValue, scopeNode, allPaths);
+                        }
+                    }
+                    // Propagate sub-property equivalencies when the equivalentValue is a simple variable
+                    // that has sub-properties defined in the isolatedEquivalentVariables.
+                    // This handles cases like: dataItem={{ structure: completeDataStructure }}
+                    // where completeDataStructure has sub-properties like completeDataStructure['Function Arguments']
+                    // We need to propagate these to create: dataItem.structure['Function Arguments'] equivalencies
+                    const isSimpleVariable = !equivalentValue.startsWith('signature[') &&
+                        !equivalentValue.includes('functionCallReturnValue') &&
+                        !equivalentValue.includes('.') &&
+                        !equivalentValue.includes('[');
+                    if (isSimpleVariable) {
+                        // Look in current scope and all parent scopes for sub-properties
+                        const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
+                        for (const scopeName of scopesToCheck) {
+                            const checkScope = this.scopeNodes[scopeName];
+                            if (!checkScope?.analysis?.isolatedEquivalentVariables)
+                                continue;
+                            for (const [subPath, rawSubValue] of Object.entries(checkScope.analysis.isolatedEquivalentVariables)) {
+                                // Normalize to array for consistent handling
+                                const subValues = Array.isArray(rawSubValue)
+                                    ? rawSubValue
+                                    : rawSubValue
+                                        ? [rawSubValue]
+                                        : [];
+                                // Check if this is a sub-property of the equivalentValue variable
+                                // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
+                                const matchesDot = subPath.startsWith(equivalentValue + '.');
+                                const matchesBracket = subPath.startsWith(equivalentValue + '[');
+                                if (matchesDot || matchesBracket) {
+                                    const subPropertyPath = subPath.substring(equivalentValue.length);
+                                    const newPath = cleanPath(path + subPropertyPath, allPaths);
+                                    for (const subValue of subValues) {
+                                        if (typeof subValue !== 'string')
+                                            continue;
+                                        const newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
+                                        if (newEquivalentValue &&
+                                            this.isValidPath(newEquivalentValue)) {
+                                            this.addEquivalency(newPath, newEquivalentValue, checkScope.name, // Use the scope where the sub-property was found
+                                            scopeNode, 'propagated sub-property equivalency');
+                                        }
+                                    }
+                                }
+                                // Also check if equivalentValue itself maps to a functionCallReturnValue
+                                // e.g., result = useMemo(...).functionCallReturnValue
+                                for (const subValue of subValues) {
+                                    if (subPath === equivalentValue &&
+                                        typeof subValue === 'string' &&
+                                        subValue.endsWith('.functionCallReturnValue')) {
+                                        this.propagateFunctionCallReturnSubProperties(path, subValue, scopeNode, allPaths);
+                                    }
+                                }
                             }
                         }
                     }
-                }
-                // Handle function call return values by propagating returnValue.* sub-properties
-                // from the callback scope to the usage path
-                if (equivalentValue.endsWith('.functionCallReturnValue')) {
-                    this.propagateFunctionCallReturnSubProperties(path, equivalentValue, scopeNode, allPaths);
+                    // Handle function call return values by propagating returnValue.* sub-properties
+                    // from the callback scope to the usage path
+                    if (equivalentValue.endsWith('.functionCallReturnValue')) {
+                        this.propagateFunctionCallReturnSubProperties(path, equivalentValue, scopeNode, allPaths);
+                        // Track which variable receives the return value of each function call
+                        // This enables generating separate mock data for each call site
+                        this.trackReceivingVariable(path, equivalentValue);
+                    }
+                    // Also track variables that receive destructured properties from function call return values
+                    // e.g., "userData" -> "db.query('users').functionCallReturnValue.data"
+                    if (equivalentValue.includes('.functionCallReturnValue.')) {
+                        this.trackReceivingVariable(path, equivalentValue);
+                    }
                 }
             }
         }
@@ -954,7 +1318,7 @@ export class ScopeDataStructure {
         // This eliminates deep call stacks and improves deduplication
         this.batchProcessor = new BatchSchemaProcessor();
         this.batchQueuedSet = new Set();
-        for (const key of Array.from(allPaths)) {
+        for (const key of allPaths) {
             let value = isolatedStructure[key] ?? 'unknown';
             if (['null', 'undefined'].includes(value)) {
                 value = 'unknown';
@@ -988,7 +1352,14 @@ export class ScopeDataStructure {
     processBatchQueue() {
         if (!this.batchProcessor)
             return;
+        let iterations = 0;
         while (this.batchProcessor.hasWork()) {
+            iterations++;
+            // Safety: detect potential infinite loops
+            if (iterations > 100000) {
+                console.error(`[ScopeDataStructure] processBatchQueue exceeded 100k iterations, possible infinite loop!`);
+                break;
+            }
             const item = this.batchProcessor.getNextWork();
             if (!item)
                 break;
@@ -1004,6 +1375,55 @@ export class ScopeDataStructure {
             });
         }
     }
+    /**
+     * Tracks which variable receives the return value of a function call.
+     *
+     * When we encounter an equivalency like:
+     *   result1 -> db.select(query1).functionCallReturnValue
+     *
+     * This method extracts the call signature (db.select(query1)) and maps it
+     * to the receiving variable (result1) on the corresponding FunctionCallInfo.
+     *
+     * This enables generating separate mock data for each call site when the same
+     * function is called multiple times with different arguments.
+     */
+    trackReceivingVariable(receivingVariable, equivalentValue) {
+        // Extract the call signature by finding the .functionCallReturnValue part
+        // and taking everything before it
+        // Handles both:
+        //   "db.select(query1).functionCallReturnValue" -> "db.select(query1)"
+        //   "db.query('users').functionCallReturnValue.data" -> "db.query('users')"
+        const funcReturnIdx = equivalentValue.indexOf('.functionCallReturnValue');
+        if (funcReturnIdx === -1) {
+            return;
+        }
+        const callSignature = equivalentValue.substring(0, funcReturnIdx);
+        // Skip if the receiving variable is not a simple identifier
+        // (e.g., skip if it's a path like "obj.property" or contains array access)
+        if (receivingVariable.includes('.') || receivingVariable.includes('[')) {
+            return;
+        }
+        // Find the FunctionCallInfo that matches this call signature
+        const searchKey = getFunctionCallRoot(callSignature);
+        const functionCallInfo = this.getExternalFunctionCallsIndex().get(searchKey);
+        if (!functionCallInfo) {
+            return;
+        }
+        // Initialize arrays if needed
+        if (!functionCallInfo.receivingVariableNames) {
+            functionCallInfo.receivingVariableNames = [];
+        }
+        if (!functionCallInfo.callSignatureToVariable) {
+            functionCallInfo.callSignatureToVariable = {};
+        }
+        // Add the receiving variable to the list (if not already present)
+        if (!functionCallInfo.receivingVariableNames.includes(receivingVariable)) {
+            functionCallInfo.receivingVariableNames.push(receivingVariable);
+        }
+        // Map the call signature to its receiving variable
+        // Use the full call signature (not the search key) for precise mapping
+        functionCallInfo.callSignatureToVariable[callSignature] = receivingVariable;
+    }
     /**
      * Propagates returnValue.* sub-properties from a callback scope to the usage path.
      *
@@ -1034,8 +1454,15 @@ export class ScopeDataStructure {
                 const checkScope = this.scopeNodes[scopeName];
                 if (!checkScope?.analysis?.isolatedEquivalentVariables)
                     continue;
-                const functionRef = checkScope.analysis.isolatedEquivalentVariables[functionName];
-                if (typeof functionRef === 'string' && functionRef.endsWith('F')) {
+                const rawFunctionRef = checkScope.analysis.isolatedEquivalentVariables[functionName];
+                // Normalize to array and find first string ending with 'F'
+                const functionRefs = Array.isArray(rawFunctionRef)
+                    ? rawFunctionRef
+                    : rawFunctionRef
+                        ? [rawFunctionRef]
+                        : [];
+                const functionRef = functionRefs.find((r) => typeof r === 'string' && r.endsWith('F'));
+                if (typeof functionRef === 'string') {
                     callbackScopeName = functionRef.slice(0, -1);
                     break;
                 }
@@ -1058,22 +1485,32 @@ export class ScopeDataStructure {
         if (!callbackScope.analysis?.isolatedEquivalentVariables)
             return;
         const isolatedVars = callbackScope.analysis.isolatedEquivalentVariables;
+        // Get the first returnValue equivalency (normalize array to single value for these checks)
+        const rawReturnValue = isolatedVars.returnValue;
+        const firstReturnValue = Array.isArray(rawReturnValue)
+            ? rawReturnValue[0]
+            : rawReturnValue;
         // First, check if returnValue is an alias to another variable (e.g., returnValue = intermediate)
         // If so, we need to look for that variable's sub-properties too
-        const returnValueAlias = typeof isolatedVars.returnValue === 'string' &&
-            !isolatedVars.returnValue.includes('.')
-            ? isolatedVars.returnValue
+        const returnValueAlias = typeof firstReturnValue === 'string' && !firstReturnValue.includes('.')
+            ? firstReturnValue
             : undefined;
         // Pattern 3: Object.keys(X).reduce() - the reduce result has the same sub-properties as X
         // When returnValue = "Object.keys(source).reduce(...).functionCallReturnValue", look for source.* sub-properties
         let reduceSourceVar;
-        if (typeof isolatedVars.returnValue === 'string') {
-            const reduceMatch = isolatedVars.returnValue.match(/^Object\.keys\((\w+)\)\.reduce\(.*\)\.functionCallReturnValue$/);
+        if (typeof firstReturnValue === 'string') {
+            const reduceMatch = firstReturnValue.match(/^Object\.keys\((\w+)\)\.reduce\(.*\)\.functionCallReturnValue$/);
             if (reduceMatch) {
                 reduceSourceVar = reduceMatch[1];
             }
         }
-        for (const [subPath, subValue] of Object.entries(isolatedVars)) {
+        for (const [subPath, rawSubValue] of Object.entries(isolatedVars)) {
+            // Normalize to array for consistent handling
+            const subValues = Array.isArray(rawSubValue)
+                ? rawSubValue
+                : rawSubValue
+                    ? [rawSubValue]
+                    : [];
             // Check for direct returnValue.* sub-properties
             const isReturnValueSub = subPath.startsWith('returnValue.') ||
                 subPath.startsWith('returnValue[');
@@ -1085,33 +1522,36 @@ export class ScopeDataStructure {
             const isReduceSourceSub = reduceSourceVar &&
                 (subPath.startsWith(reduceSourceVar + '.') ||
                     subPath.startsWith(reduceSourceVar + '['));
-            if (typeof subValue !== 'string' ||
-                (!isReturnValueSub && !isAliasSub && !isReduceSourceSub))
-                continue;
-            // Convert alias/reduceSource paths to returnValue paths
-            let effectiveSubPath = subPath;
-            if (isAliasSub && !isReturnValueSub) {
-                // Replace the alias prefix with returnValue
-                effectiveSubPath =
-                    'returnValue' + subPath.substring(returnValueAlias.length);
-            }
-            else if (isReduceSourceSub && !isReturnValueSub && !isAliasSub) {
-                // Replace the reduce source prefix with returnValue
-                effectiveSubPath =
-                    'returnValue' + subPath.substring(reduceSourceVar.length);
-            }
-            const subPropertyPath = effectiveSubPath.substring('returnValue'.length);
-            const newPath = cleanPath(path + subPropertyPath, allPaths);
-            let newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
-            // Resolve variable references through parent scope equivalencies
-            const resolved = this.resolveVariableThroughParentScopes(newEquivalentValue, callbackScope, allPaths);
-            newEquivalentValue = resolved.resolvedPath;
-            const equivalentScopeName = resolved.scopeName;
-            if (!newEquivalentValue || !this.isValidPath(newEquivalentValue))
+            if (!isReturnValueSub && !isAliasSub && !isReduceSourceSub)
                 continue;
-            this.addEquivalency(newPath, newEquivalentValue, equivalentScopeName, scopeNode, 'propagated function call return sub-property equivalency');
-            // Ensure the database entry has the usage path
-            this.addUsageToEquivalencyDatabaseEntry(newPath, newEquivalentValue, equivalentScopeName, scopeNode.name);
+            for (const subValue of subValues) {
+                if (typeof subValue !== 'string')
+                    continue;
+                // Convert alias/reduceSource paths to returnValue paths
+                let effectiveSubPath = subPath;
+                if (isAliasSub && !isReturnValueSub) {
+                    // Replace the alias prefix with returnValue
+                    effectiveSubPath =
+                        'returnValue' + subPath.substring(returnValueAlias.length);
+                }
+                else if (isReduceSourceSub && !isReturnValueSub && !isAliasSub) {
+                    // Replace the reduce source prefix with returnValue
+                    effectiveSubPath =
+                        'returnValue' + subPath.substring(reduceSourceVar.length);
+                }
+                const subPropertyPath = effectiveSubPath.substring('returnValue'.length);
+                const newPath = cleanPath(path + subPropertyPath, allPaths);
+                let newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
+                // Resolve variable references through parent scope equivalencies
+                const resolved = this.resolveVariableThroughParentScopes(newEquivalentValue, callbackScope, allPaths);
+                newEquivalentValue = resolved.resolvedPath;
+                const equivalentScopeName = resolved.scopeName;
+                if (!newEquivalentValue || !this.isValidPath(newEquivalentValue))
+                    continue;
+                this.addEquivalency(newPath, newEquivalentValue, equivalentScopeName, scopeNode, 'propagated function call return sub-property equivalency');
+                // Ensure the database entry has the usage path
+                this.addUsageToEquivalencyDatabaseEntry(newPath, newEquivalentValue, equivalentScopeName, scopeNode.name);
+            }
         }
     }
     /**
@@ -1143,7 +1583,14 @@ export class ScopeDataStructure {
             const parentScope = this.scopeNodes[parentScopeName];
             if (!parentScope?.analysis?.isolatedEquivalentVariables)
                 continue;
-            const rootEquiv = parentScope.analysis.isolatedEquivalentVariables[rootVar];
+            const rawRootEquiv = parentScope.analysis.isolatedEquivalentVariables[rootVar];
+            // Normalize to array and use first string value
+            const rootEquivs = Array.isArray(rawRootEquiv)
+                ? rawRootEquiv
+                : rawRootEquiv
+                    ? [rawRootEquiv]
+                    : [];
+            const rootEquiv = rootEquivs.find((r) => typeof r === 'string');
             if (typeof rootEquiv === 'string') {
                 return {
                     resolvedPath: cleanPath(rootEquiv + restOfPath, allPaths),
@@ -1337,9 +1784,21 @@ export class ScopeDataStructure {
             const remainingPath = this.joinPathParts(remainingPathParts);
             if (relevantSubPathParts.every((part, i) => part === schemaPathParts[i]) &&
                 equivalentValue.scopeNodeName === scopeNode.name) {
+                // DEBUG
                 continue;
             }
             const newEquivalentPath = this.joinPathParts([schemaPath, remainingPath]);
+            // PERF: Detect repeated patterns in paths to prevent exponential blowup
+            // Paths like `signature[0].attributes.properties[].attributes.properties[]...`
+            // indicate recursive type structures that cause exponential schema explosion
+            if (this.hasExcessivePatternRepetition(newEquivalentPath)) {
+                if (traceId && debugLevel > 0) {
+                    console.info('Debug: skipping path with excessive pattern repetition', {
+                        path: newEquivalentPath,
+                    });
+                }
+                continue;
+            }
             if (!equivalentScopeNode) {
                 if (traceId) {
                     console.info('Debug Propagation: missing equivalent scope info', {
@@ -1467,6 +1926,8 @@ export class ScopeDataStructure {
                         return;
                     }
                     const usageScopeNode = this.getScopeOrFunctionCallInfo(usageEquivalency.scopeNodeName);
+                    if (!usageScopeNode)
+                        continue;
                     // Guard against infinite recursion by tracking which paths we've already
                     // added from addComplexSourcePathVariables
                     if (this.visitedTracker.checkAndMarkComplexSourceVisited(usageScopeNode.name, newUsageEquivalentPath)) {
@@ -1515,6 +1976,8 @@ export class ScopeDataStructure {
                         continue;
                     }
                     const usageScopeNode = this.getScopeOrFunctionCallInfo(usageEquivalency.scopeNodeName);
+                    if (!usageScopeNode)
+                        continue;
                     // This is put in place to avoid propagating array functions like 'filter' through complex equivalencies
                     // but may cause problems if the funtion call is not on a known object (e.g. string or array)
                     if (newUsageEquivalentPath.endsWith(')') ||
@@ -1611,9 +2074,70 @@ export class ScopeDataStructure {
             // Update inverted index
             this.intermediatesOrderIndex.set(pathId, databaseEntry);
             if (intermediateIndex === 0) {
-                const isValidSourceCandidate = pathInfo.schemaPath.startsWith('signature[') ||
+                let isValidSourceCandidate = pathInfo.schemaPath.startsWith('signature[') ||
                     pathInfo.schemaPath.includes('functionCallReturnValue');
-                if (isValidSourceCandidate) {
+                // Check if path STARTS with a spread pattern like [...var]
+                // This handles cases like [...files][][0] or [...files].sort(...).functionCallReturnValue[][0]
+                // where the spread source variable needs to be resolved to a signature path.
+                // We do this REGARDLESS of isValidSourceCandidate because even paths containing
+                // functionCallReturnValue may need spread resolution to trace back to the signature.
+                const spreadMatch = pathInfo.schemaPath.match(/^\[\.\.\.(\w+)\]/);
+                if (spreadMatch) {
+                    const spreadVar = spreadMatch[1];
+                    const spreadPattern = spreadMatch[0]; // The full [...var] match
+                    const scopeNode = this.scopeNodes[pathInfo.scopeNodeName];
+                    if (scopeNode?.equivalencies) {
+                        // Follow the equivalency chain to find a signature path
+                        // e.g., files (cyScope1) → files (root) → signature[0].files
+                        const resolveToSignature = (varName, currentScopeName, visited) => {
+                            const visitKey = `${currentScopeName}::${varName}`;
+                            if (visited.has(visitKey))
+                                return null;
+                            visited.add(visitKey);
+                            const currentScope = this.scopeNodes[currentScopeName];
+                            if (!currentScope?.equivalencies)
+                                return null;
+                            const varEquivs = currentScope.equivalencies[varName];
+                            if (!varEquivs)
+                                return null;
+                            // First check if any equivalency directly points to a signature path
+                            const signatureEquiv = varEquivs.find((eq) => eq.schemaPath.startsWith('signature['));
+                            if (signatureEquiv) {
+                                return signatureEquiv;
+                            }
+                            // Otherwise, follow the chain to other scopes
+                            for (const equiv of varEquivs) {
+                                // If the equivalency points to the same variable in a different scope,
+                                // follow the chain
+                                if (equiv.schemaPath === varName &&
+                                    equiv.scopeNodeName !== currentScopeName) {
+                                    const result = resolveToSignature(varName, equiv.scopeNodeName, visited);
+                                    if (result)
+                                        return result;
+                                }
+                            }
+                            return null;
+                        };
+                        const signatureEquiv = resolveToSignature(spreadVar, pathInfo.scopeNodeName, new Set());
+                        if (signatureEquiv) {
+                            // Replace ONLY the [...var] part with the resolved signature path
+                            // This preserves any suffix like .sort(...).functionCallReturnValue[][0]
+                            const resolvedPath = pathInfo.schemaPath.replace(spreadPattern, signatureEquiv.schemaPath);
+                            // Add the resolved path as a source candidate
+                            if (!databaseEntry.sourceCandidates.some((sc) => sc.schemaPath === resolvedPath &&
+                                sc.scopeNodeName === pathInfo.scopeNodeName)) {
+                                databaseEntry.sourceCandidates.push({
+                                    scopeNodeName: pathInfo.scopeNodeName,
+                                    schemaPath: resolvedPath,
+                                });
+                            }
+                            isValidSourceCandidate = true;
+                        }
+                    }
+                }
+                if (isValidSourceCandidate &&
+                    !databaseEntry.sourceCandidates.some((sc) => sc.schemaPath === pathInfo.schemaPath &&
+                        sc.scopeNodeName === pathInfo.scopeNodeName)) {
                     databaseEntry.sourceCandidates.push(pathInfo);
                 }
             }
@@ -1759,6 +2283,13 @@ export class ScopeDataStructure {
                 delete scopeNode.schema[key];
             }
         }
+        // Ensure parameter-to-signature equivalencies are fully propagated.
+        // When a parameter variable (e.g., `node`) is equivalenced to `signature[N]`,
+        // all sub-paths of that variable should also appear under `signature[N]`.
+        // This handles cases where the sub-path was added to the schema via a propagation
+        // chain that already included the variable↔signature equivalency, causing the
+        // cycle detection to prevent the reverse mapping.
+        this.propagateParameterToSignaturePaths(scopeNode);
         fillInSchemaGapsAndUnknowns(scopeNode, fillInUnknowns);
         if (final) {
             for (const manager of this.equivalencyManagers) {
@@ -1770,6 +2301,40 @@ export class ScopeDataStructure {
             ensureSchemaConsistency(scopeNode.schema);
         }
     }
+    /**
+     * For each equivalency where a simple variable maps to signature[N],
+     * ensure all sub-paths of that variable are reflected under signature[N].
+     */
+    propagateParameterToSignaturePaths(scopeNode) {
+        // Find variable → signature[N] equivalencies
+        for (const [varName, equivalencies] of Object.entries(scopeNode.equivalencies)) {
+            // Only process simple variable names (no dots, brackets, or parens)
+            if (varName.includes('.') ||
+                varName.includes('[') ||
+                varName.includes('(')) {
+                continue;
+            }
+            for (const equiv of equivalencies) {
+                if (equiv.scopeNodeName === scopeNode.name &&
+                    equiv.schemaPath.startsWith('signature[')) {
+                    const signaturePath = equiv.schemaPath;
+                    const varPrefix = varName + '.';
+                    const varBracketPrefix = varName + '[';
+                    // Find all schema keys starting with the variable
+                    for (const key in scopeNode.schema) {
+                        if (key.startsWith(varPrefix) || key.startsWith(varBracketPrefix)) {
+                            const suffix = key.slice(varName.length);
+                            const sigKey = signaturePath + suffix;
+                            // Only add if the signature path doesn't already exist
+                            if (!scopeNode.schema[sigKey]) {
+                                scopeNode.schema[sigKey] = scopeNode.schema[key];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     filterAndConvertSchema({ filterPath, newPath, schema, }) {
         const filterPathParts = this.splitPath(filterPath);
         return Object.keys(schema).reduce((acc, key) => {
@@ -1829,6 +2394,10 @@ export class ScopeDataStructure {
                             path,
                             ...this.splitPath(key).slice(equivalentValueSchemaPathParts.length),
                         ]);
+                        // PERF: Skip keys with repeated function-call signature patterns
+                        // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+                        if (this.hasExcessivePatternRepetition(newKey))
+                            continue;
                         resolvedSchema[newKey] = value;
                     }
                 }
@@ -1850,6 +2419,9 @@ export class ScopeDataStructure {
                 if (!subSchema)
                     continue;
                 for (const resolvedKey in subSchema) {
+                    // PERF: Skip keys with repeated function-call signature patterns
+                    if (this.hasExcessivePatternRepetition(resolvedKey))
+                        continue;
                     if (!resolvedSchema[resolvedKey] ||
                         subSchema[resolvedKey] === 'unknown') {
                         resolvedSchema[resolvedKey] = subSchema[resolvedKey];
@@ -1952,9 +2524,56 @@ export class ScopeDataStructure {
                 return acc;
             }, {});
         }
+        // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+        // during this "getter" method. See comment in getFunctionSignature.
+        const wasOnlyEquivalencies = this.onlyEquivalencies;
+        this.onlyEquivalencies = true;
         this.validateSchema(scopeNode, true, fillInUnknowns);
+        this.onlyEquivalencies = wasOnlyEquivalencies;
         const { schema } = scopeNode;
-        return schema;
+        // For root scope, merge in external function call schemas
+        // This ensures that imported objects used as method call targets (like logger.error())
+        // appear in the schema as objects with function properties
+        if (scopeName === undefined ||
+            scopeName === this.scopeTreeManager.getRootName()) {
+            const mergedSchema = { ...schema };
+            for (const efc of this.externalFunctionCalls) {
+                // Add the base object name (e.g., "logger") as an object
+                const baseName = this.splitPath(efc.name)[0];
+                if (!mergedSchema[baseName]) {
+                    mergedSchema[baseName] = 'object';
+                }
+                // Get all call signatures (use allCallSignatures if available, otherwise just the single callSignature)
+                const signatures = efc.allCallSignatures ?? [efc.callSignature];
+                for (const signature of signatures) {
+                    // Add the method as a function (e.g., "logger.error")
+                    // Extract method name from callSignature like "logger.error(args...)"
+                    // Get everything before the first '(' to get "logger.error"
+                    const parenIndex = signature.indexOf('(');
+                    if (parenIndex > 0) {
+                        const methodPath = signature.substring(0, parenIndex);
+                        if (methodPath.includes('.') && !mergedSchema[methodPath]) {
+                            mergedSchema[methodPath] = 'function';
+                        }
+                    }
+                }
+            }
+            return this.filterDuplicateKeys(mergedSchema);
+        }
+        return this.filterDuplicateKeys(schema);
+    }
+    /**
+     * Filter out ::cyDuplicateKey:: entries from a schema.
+     * These are internal markers for tracking variable reassignments
+     * and should not appear in output schemas or LLM prompts.
+     */
+    filterDuplicateKeys(schema) {
+        return Object.entries(schema).reduce((acc, [key, value]) => {
+            if (!key.includes('::cyDuplicateKey')) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
     }
     getEquivalencies(scopeName) {
         const scopeNode = this.getScopeOrFunctionCallInfo(scopeName);
@@ -1976,18 +2595,204 @@ export class ScopeDataStructure {
         if (!scopeNode) {
             return {};
         }
-        const entries = this.equivalencyDatabase.filter((entry) => entry.usages.some((usage) => usage.scopeNodeName === scopeNode.name));
-        return entries.reduce((acc, entry) => {
+        // Collect all descendant scope names (including the scope itself)
+        // This ensures we include external calls from nested scopes like cyScope2
+        const getAllDescendantScopeNames = (node) => {
+            const names = new Set([node.name]);
+            for (const child of node.children) {
+                for (const name of getAllDescendantScopeNames(child)) {
+                    names.add(name);
+                }
+            }
+            return names;
+        };
+        const treeNode = this.scopeTreeManager.findNode(scopeNode.name);
+        const descendantScopeNames = treeNode
+            ? getAllDescendantScopeNames(treeNode)
+            : new Set([scopeNode.name]);
+        // Get all external function calls made from this scope or any descendant scope
+        // This allows us to include prop equivalencies from JSX components
+        // that were rendered in nested scopes (e.g., FileTableRow called from cyScope2)
+        const externalCallsFromScope = this.externalFunctionCalls.filter((efc) => descendantScopeNames.has(efc.callScope));
+        const externalCallNames = new Set(externalCallsFromScope.map((efc) => efc.name));
+        // Helper to check if a usage belongs to this scope (directly, via descendant, or via external call)
+        const usageMatchesScope = (usage) => descendantScopeNames.has(usage.scopeNodeName) ||
+            externalCallNames.has(usage.scopeNodeName);
+        const entries = this.equivalencyDatabase.filter((entry) => entry.usages.some(usageMatchesScope));
+        // Helper to resolve a source candidate through equivalency chains to find signature paths
+        const resolveToSignature = (source, visited) => {
+            const visitKey = `${source.scopeNodeName}::${source.schemaPath}`;
+            if (visited.has(visitKey))
+                return [];
+            visited.add(visitKey);
+            // If already a signature path, return as-is
+            if (source.schemaPath.startsWith('signature[')) {
+                return [source];
+            }
+            const currentScope = this.scopeNodes[source.scopeNodeName];
+            if (!currentScope?.equivalencies)
+                return [source];
+            // Check for direct equivalencies FIRST (full path match)
+            // This ensures paths like "useMemo(...).functionCallReturnValue" follow to "cyScope1::returnValue"
+            // before prefix matching tries "useMemo(...)" which goes to the useMemo scope
+            const directEquivs = currentScope.equivalencies[source.schemaPath];
+            if (directEquivs?.length > 0) {
+                const results = [];
+                for (const equiv of directEquivs) {
+                    const resolved = resolveToSignature({
+                        scopeNodeName: equiv.scopeNodeName,
+                        schemaPath: equiv.schemaPath,
+                    }, visited);
+                    results.push(...resolved);
+                }
+                if (results.length > 0)
+                    return results;
+            }
+            // Handle spread patterns like [...items].sort().functionCallReturnValue
+            // Extract the spread variable and resolve it through the equivalency chain
+            const spreadMatch = source.schemaPath.match(/^\[\.\.\.(\w+)\]/);
+            if (spreadMatch) {
+                const spreadVar = spreadMatch[1];
+                const spreadPattern = spreadMatch[0];
+                const varEquivs = currentScope.equivalencies[spreadVar];
+                if (varEquivs?.length > 0) {
+                    const results = [];
+                    for (const equiv of varEquivs) {
+                        // Follow the variable equivalency and then resolve from there
+                        const resolvedVar = resolveToSignature({
+                            scopeNodeName: equiv.scopeNodeName,
+                            schemaPath: equiv.schemaPath,
+                        }, visited);
+                        // For each resolved variable path, create the full path with array element suffix
+                        for (const rv of resolvedVar) {
+                            if (rv.schemaPath.startsWith('signature[')) {
+                                // Get the suffix after the spread pattern
+                                let suffix = source.schemaPath.slice(spreadPattern.length);
+                                // Clean the suffix: strip array method chains like .sort(...).functionCallReturnValue[]
+                                // These don't change the data identity, just transform it.
+                                // Keep only the final element access parts like [0], [1], etc.
+                                // Pattern: strip everything from a method call up through functionCallReturnValue[]
+                                suffix = suffix.replace(/\.\w+\([^)]*\)\.functionCallReturnValue\[\]/g, '');
+                                // Also handle simpler case without nested parens
+                                suffix = suffix.replace(/\.sort\(\w*\(\)\)\.functionCallReturnValue\[\]/g, '');
+                                // Add [] to indicate array element access from the spread
+                                const resolvedPath = rv.schemaPath + '[]' + suffix;
+                                results.push({
+                                    scopeNodeName: rv.scopeNodeName,
+                                    schemaPath: resolvedPath,
+                                });
+                            }
+                        }
+                    }
+                    if (results.length > 0)
+                        return results;
+                }
+            }
+            // Try to find prefix equivalencies that can resolve this path
+            // For path like "cyScope3().signature[0][0]", check "cyScope3().signature[0]", etc.
+            const pathParts = this.splitPath(source.schemaPath);
+            for (let i = pathParts.length - 1; i > 0; i--) {
+                const prefix = this.joinPathParts(pathParts.slice(0, i));
+                const suffix = this.joinPathParts(pathParts.slice(i));
+                const prefixEquivs = currentScope.equivalencies[prefix];
+                if (prefixEquivs?.length > 0) {
+                    const results = [];
+                    for (const equiv of prefixEquivs) {
+                        const newPath = this.joinPathParts([equiv.schemaPath, suffix]);
+                        const resolved = resolveToSignature({ scopeNodeName: equiv.scopeNodeName, schemaPath: newPath }, visited);
+                        results.push(...resolved);
+                    }
+                    if (results.length > 0)
+                        return results;
+                }
+            }
+            return [source];
+        };
+        const acc = entries.reduce((result, entry) => {
             var _a;
             if (entry.sourceCandidates.length === 0)
-                return acc;
-            const usages = entry.usages.filter((u) => u.scopeNodeName === scopeNode.name);
+                return result;
+            const usages = entry.usages.filter(usageMatchesScope);
             for (const usage of usages) {
-                acc[_a = usage.schemaPath] || (acc[_a] = []);
-                acc[usage.schemaPath].push(...entry.sourceCandidates);
+                result[_a = usage.schemaPath] || (result[_a] = []);
+                // Resolve each source candidate through the equivalency chain
+                for (const source of entry.sourceCandidates) {
+                    const resolvedSources = resolveToSignature(source, new Set());
+                    result[usage.schemaPath].push(...resolvedSources);
+                }
             }
-            return acc;
+            return result;
         }, {});
+        // Post-processing: enrich useState-backed sources with co-located external
+        // function calls. When a useState value resolves to a setter variable that
+        // lives in the same scope as a fetch/API call, that fetch is a data source.
+        this.enrichUseStateSourcesWithCoLocatedCalls(acc);
+        return acc;
+    }
+    /**
+     * For each source that ends at a useState path, check if the setter was called
+     * from a scope that also contains external function calls (like fetch).
+     * If so, add those external calls as additional source candidates.
+     */
+    enrichUseStateSourcesWithCoLocatedCalls(acc) {
+        const rootScopeName = this.scopeTreeManager.getRootName();
+        const rootScope = this.scopeNodes[rootScopeName];
+        if (!rootScope)
+            return;
+        // Collect all descendants for each scope node
+        const getAllDescendants = (node) => {
+            const names = new Set([node.name]);
+            for (const child of node.children) {
+                for (const name of getAllDescendants(child)) {
+                    names.add(name);
+                }
+            }
+            return names;
+        };
+        for (const [usagePath, sources] of Object.entries(acc)) {
+            const additionalSources = [];
+            for (const source of sources) {
+                // Check if this source is a useState-related terminal path
+                // (e.g., useState(X).functionCallReturnValue[1] or useState(X).signature[0])
+                if (!source.schemaPath.match(/^useState\([^)]*\)\./))
+                    continue;
+                // Find the useState call from the source path
+                const useStateCallMatch = source.schemaPath.match(/^(useState\([^)]*\))\./);
+                if (!useStateCallMatch)
+                    continue;
+                const useStateCall = useStateCallMatch[1];
+                // Look in the root scope for the useState value equivalency
+                // which tells us where the setter was called from
+                const valuePath = `${useStateCall}.functionCallReturnValue[0]`;
+                const valueEquivs = rootScope.equivalencies[valuePath];
+                if (!valueEquivs)
+                    continue;
+                for (const equiv of valueEquivs) {
+                    // Find the scope where the setter was called
+                    const setterScopeName = equiv.scopeNodeName;
+                    const setterScopeTree = this.scopeTreeManager.findNode(setterScopeName);
+                    if (!setterScopeTree)
+                        continue;
+                    // Get all descendant scope names from the setter scope
+                    const relatedScopes = getAllDescendants(setterScopeTree);
+                    // Find external function calls in those scopes whose return values
+                    // are actually consumed (assigned to a variable). This excludes
+                    // fire-and-forget calls like analytics.track() or console.log().
+                    const coLocatedCalls = this.externalFunctionCalls.filter((efc) => relatedScopes.has(efc.callScope) &&
+                        efc.receivingVariableNames &&
+                        efc.receivingVariableNames.length > 0);
+                    for (const call of coLocatedCalls) {
+                        additionalSources.push({
+                            scopeNodeName: call.callScope,
+                            schemaPath: `${call.callSignature}.functionCallReturnValue`,
+                        });
+                    }
+                }
+            }
+            if (additionalSources.length > 0) {
+                acc[usagePath].push(...additionalSources);
+            }
+        }
     }
     getUsageEquivalencies(functionName) {
         const scopeNode = this.getScopeOrFunctionCallInfo(functionName);
@@ -2020,11 +2825,12 @@ export class ScopeDataStructure {
             return acc;
         }, {});
         const equivalencies = this.getEquivalencies(functionName);
+        const scopeName = functionName ?? this.scopeTreeManager.getRootName();
         for (const equivalenceKey in equivalencies ?? {}) {
             for (const equivalenceValue of equivalencies[equivalenceKey]) {
                 const schemaPath = equivalenceValue.schemaPath;
                 if (schemaPath.startsWith('signature[') &&
-                    equivalenceValue.scopeNodeName === functionName &&
+                    equivalenceValue.scopeNodeName === scopeName &&
                     !signatureInSchema[schemaPath]) {
                     signatureInSchema[schemaPath] = 'unknown';
                 }
@@ -2032,9 +2838,103 @@ export class ScopeDataStructure {
         }
         const tempScopeNode = this.createTempScopeNode(functionName ?? this.scopeTreeManager.getRootName(), signatureInSchema, equivalencies);
         this.validateSchema(tempScopeNode, true, fillInUnknowns);
-        return tempScopeNode.schema;
+        // After validateSchema has filled in types, propagate nested paths from
+        // variables to their signature equivalents.
+        // e.g., workouts[].activity_type -> signature[0].workouts[].activity_type
+        //
+        // Build a map of variable names that are equivalent to signature paths
+        // e.g., { 'workouts': 'signature[0].workouts' }
+        const variableToSignatureMap = {};
+        for (const equivalenceKey in equivalencies ?? {}) {
+            for (const equivalenceValue of equivalencies[equivalenceKey]) {
+                const schemaPath = equivalenceValue.schemaPath;
+                // Track which variables map to signature paths
+                // equivalenceKey is the variable name (e.g., 'workouts')
+                // schemaPath is where it comes from (e.g., 'signature[0].workouts')
+                if (schemaPath.startsWith('signature[') &&
+                    equivalenceValue.scopeNodeName === scopeName) {
+                    variableToSignatureMap[equivalenceKey] = schemaPath;
+                }
+            }
+        }
+        // Enrich schema with deeply nested paths from internal function call scopes.
+        // When a function call like traverse(tree) exists, and traverse's scope has
+        // signature[0].children[path][entityName] (from propagateParameterToSignaturePaths),
+        // we need to map those paths back to the argument variable (tree) in this scope.
+        // This handles cases where cycle detection prevented the equivalency chain from
+        // propagating deep paths during Phase 2 batch queue processing.
+        for (const equivalenceKey in equivalencies ?? {}) {
+            // Look for keys matching function call pattern: funcName(...).signature[N]
+            const funcCallMatch = equivalenceKey.match(/^([^(]+)\(.*?\)\.(signature\[\d+\])$/);
+            if (!funcCallMatch)
+                continue;
+            const calledFunctionName = funcCallMatch[1];
+            const signatureParam = funcCallMatch[2]; // e.g., "signature[0]"
+            for (const equivalenceValue of equivalencies[equivalenceKey]) {
+                if (equivalenceValue.scopeNodeName !== scopeName)
+                    continue;
+                const targetVariable = equivalenceValue.schemaPath;
+                // Get the called function's schema (includes propagated parameter paths)
+                const childSchema = this.getSchema({
+                    scopeName: calledFunctionName,
+                });
+                if (!childSchema)
+                    continue;
+                // Map child function's signature paths to parent variable paths
+                const sigPrefix = signatureParam + '.';
+                const sigBracketPrefix = signatureParam + '[';
+                for (const childKey in childSchema) {
+                    let suffix = null;
+                    if (childKey.startsWith(sigPrefix)) {
+                        suffix = childKey.slice(signatureParam.length);
+                    }
+                    else if (childKey.startsWith(sigBracketPrefix)) {
+                        suffix = childKey.slice(signatureParam.length);
+                    }
+                    if (suffix !== null) {
+                        const parentKey = targetVariable + suffix;
+                        if (!schema[parentKey]) {
+                            schema[parentKey] = childSchema[childKey];
+                        }
+                    }
+                }
+            }
+        }
+        // Propagate nested paths from variables to their signature equivalents
+        // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
+        // signature[0].workouts[].title
+        for (const schemaKey in schema) {
+            // Skip keys that already start with signature[
+            if (schemaKey.startsWith('signature['))
+                continue;
+            // Check if this key starts with a variable that maps to a signature path
+            for (const [variableName, signaturePath] of Object.entries(variableToSignatureMap)) {
+                // Check if schemaKey starts with variableName followed by a property accessor
+                // e.g., 'workouts[]' starts with 'workouts'
+                if (schemaKey === variableName ||
+                    schemaKey.startsWith(variableName + '.') ||
+                    schemaKey.startsWith(variableName + '[')) {
+                    // Transform the path: replace the variable prefix with the signature path
+                    const suffix = schemaKey.slice(variableName.length);
+                    const signatureKey = signaturePath + suffix;
+                    // Add to schema if not already present
+                    if (!tempScopeNode.schema[signatureKey]) {
+                        tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                    }
+                }
+            }
+        }
+        return this.filterDuplicateKeys(tempScopeNode.schema);
     }
     getReturnValue({ functionName, fillInUnknowns, }) {
+        // Trigger finalization on all managers to apply any pending updates
+        // (e.g., ref type propagation to external function call schemas)
+        const rootScope = this.scopeNodes[this.scopeTreeManager.getRootName()];
+        if (rootScope) {
+            for (const manager of this.equivalencyManagers) {
+                manager.finalize(rootScope, this);
+            }
+        }
         const scopeName = functionName ?? this.scopeTreeManager.getRootName();
         const scopeNode = this.scopeNodes[scopeName];
         let schema = {};
@@ -2045,7 +2945,8 @@ export class ScopeDataStructure {
             });
         }
         else {
-            for (const externalFunctionCall of this.externalFunctionCalls) {
+            // Use getExternalFunctionCalls() which cleans cyScope from schemas
+            for (const externalFunctionCall of this.getExternalFunctionCalls()) {
                 const functionNameParts = this.splitPath(functionName).map((p) => this.functionOrScopeName(p));
                 const nameParts = this.splitPath(externalFunctionCall.name).map((p) => this.functionOrScopeName(p));
                 if (functionNameParts.every((part, index) => part === nameParts[index])) {
@@ -2066,14 +2967,27 @@ export class ScopeDataStructure {
             // Include function paths even if their return value wasn't captured
             // This ensures methods like onAuthStateChange are included in the schema
             // But exclude signature entries (they should only be included via functionCallReturnValue paths)
-            (schema[key] === 'function' && key.indexOf('signature[') === -1))
+            // Also exclude bare function call signatures - paths that are JUST a call like
+            // "useCustomSizes(projectSlug)" should not be included as return values.
+            // These represent "the function exists" not actual return data, and including
+            // them causes nested path bugs in dependencySchemas.
+            (schema[key] === 'function' &&
+                key.indexOf('signature[') === -1 &&
+                // Exclude bare call signatures: function calls with no dots OUTSIDE parentheses
+                // e.g., "useCustomSizes(projectSlug)" is bare (exclude)
+                // e.g., "loadProject({nested.property})" is bare - dots are inside args (exclude)
+                // e.g., "getSupabase().auth.method()" has dots outside - method chain (include)
+                !this.isBareCallSignature(key)))
             .reduce((acc, key) => {
             acc[key] = schema[key];
             const keyParts = this.splitPath(key);
             for (const path in schema) {
                 const pathParts = this.splitPath(path);
                 if (pathParts.every((p, i) => keyParts[i] === p)) {
-                    acc[path] = schema[path];
+                    // Also exclude bare call signatures from prefix paths
+                    if (!this.isBareCallSignature(path)) {
+                        acc[path] = schema[path];
+                    }
                 }
             }
             return acc;
@@ -2081,12 +2995,68 @@ export class ScopeDataStructure {
         // Replace cyScope placeholders with actual callback text
         const resolvedSchema = this.replaceCyScopePlaceholders(returnValueSchema);
         const tempScopeNode = this.createTempScopeNode(scopeName, resolvedSchema);
+        // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+        // during this "getter" method. See comment in getFunctionSignature.
+        const wasOnlyEquivalencies = this.onlyEquivalencies;
+        this.onlyEquivalencies = true;
         this.validateSchema(tempScopeNode, true, fillInUnknowns);
-        return tempScopeNode.schema;
+        this.onlyEquivalencies = wasOnlyEquivalencies;
+        // Remove bare call signatures from the return value schema.
+        // fillInSchemaGapsAndUnknowns may add parent paths like "useCustomSizes(projectSlug)"
+        // when it sees "useCustomSizes(projectSlug).functionCallReturnValue". These bare
+        // call signatures represent "the function exists" not actual return data, and
+        // including them causes nested path bugs in dependencySchemas.
+        const resultSchema = tempScopeNode.schema;
+        for (const key of Object.keys(resultSchema)) {
+            if (this.isBareCallSignature(key)) {
+                delete resultSchema[key];
+            }
+        }
+        return resultSchema;
+    }
+    /**
+     * Checks if a schema key is a "bare call signature" - a function call with no
+     * method chain before it and no path segments after it.
+     *
+     * A bare call signature represents "this function exists" rather than actual
+     * return data, and including them causes nested path bugs in dependencySchemas.
+     *
+     * Examples:
+     * - "useCustomSizes(projectSlug)" -> bare (true)
+     * - "loadProject({nested.property})" -> bare (dots are inside args, true)
+     * - "getSupabase().auth.method()" -> not bare (has dots outside parens, false)
+     * - "useProject().functionCallReturnValue" -> not bare (has path after, false)
+     */
+    isBareCallSignature(key) {
+        // Must end with ) and contain ( to be a call
+        if (!key.endsWith(')') || key.indexOf('(') === -1) {
+            return false;
+        }
+        // Check if there are any dots OUTSIDE of parentheses
+        // Strip out content inside balanced parentheses, then check for dots
+        let depth = 0;
+        let hasDotsOutsideParens = false;
+        for (let i = 0; i < key.length; i++) {
+            const char = key[i];
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+            }
+            else if (char === '.' && depth === 0) {
+                hasDotsOutsideParens = true;
+                break;
+            }
+        }
+        // It's a bare call signature if there are no dots outside parentheses
+        return !hasDotsOutsideParens;
     }
     /**
      * Replaces cyScope placeholder references (e.g., cyScope10()) in schema keys
      * with the actual callback function text from the corresponding scope node.
+     * If the scope text can't be found, uses a generic fallback to avoid leaking
+     * internal cyScope names into stored data.
      */
     replaceCyScopePlaceholders(schema) {
         const cyScopePattern = /cyScope(\d+)\(\)/g;
@@ -2098,10 +3068,10 @@ export class ScopeDataStructure {
             for (const match of matches) {
                 const cyScopeName = `cyScope${match[1]}`;
                 const scopeText = this.findCyScopeText(cyScopeName);
-                if (scopeText) {
-                    // Replace cyScope10() with the actual callback text
-                    newKey = newKey.replace(match[0], scopeText);
-                }
+                // Always replace cyScope references - use actual text if available,
+                // otherwise use a generic callback placeholder
+                const replacement = scopeText || '() => {}';
+                newKey = newKey.replace(match[0], replacement);
             }
             result[newKey] = value;
         }
@@ -2151,12 +3121,371 @@ export class ScopeDataStructure {
     getEquivalentSignatureVariables() {
         const scopeNode = this.scopeNodes[this.scopeTreeManager.getRootName()];
         const equivalentSignatureVariables = {};
+        // Helper to add equivalencies - accumulates into array if multiple values for same key
+        // This is critical for OR expressions like `x = a || b` where x should map to both a and b
+        const addEquivalency = (key, value) => {
+            const existing = equivalentSignatureVariables[key];
+            if (existing === undefined) {
+                // First value - store as string
+                equivalentSignatureVariables[key] = value;
+            }
+            else if (typeof existing === 'string') {
+                if (existing !== value) {
+                    // Second different value - convert to array
+                    equivalentSignatureVariables[key] = [existing, value];
+                }
+                // Same value - no change needed
+            }
+            else {
+                // Already an array - add if not already present
+                if (!existing.includes(value)) {
+                    existing.push(value);
+                }
+            }
+        };
         for (const [path, equivalentValues] of Object.entries(scopeNode.equivalencies)) {
             for (const equivalentValue of equivalentValues) {
+                // Case 1: Props/signature equivalencies (existing behavior)
+                // Maps local variable names to their signature paths
+                // e.g., "propValue" -> "signature[0].prop"
                 if (path.startsWith('signature[')) {
-                    equivalentSignatureVariables[equivalentValue.schemaPath] = path;
+                    addEquivalency(equivalentValue.schemaPath, path);
+                }
+                // Case 2: Hook variable equivalencies (new behavior)
+                // The equivalencies are stored as: path = variable name, schemaPath = data source
+                // e.g., path = "debugFetcher", schemaPath = "useFetcher<...>().functionCallReturnValue"
+                // We need to map: "debugFetcher" -> "useFetcher<...>()"
+                // This enables resolving paths like "debugFetcher.state" to
+                // "useFetcher<...>().state" for execution flow validation
+                if (equivalentValue.schemaPath.endsWith('.functionCallReturnValue')) {
+                    // Extract the hook call path (everything before .functionCallReturnValue)
+                    let hookCallPath = equivalentValue.schemaPath.slice(0, -'.functionCallReturnValue'.length);
+                    // Only include if it looks like a hook call (contains parentheses)
+                    // and the variable name (path) is a simple identifier (no dots)
+                    if (hookCallPath.includes('(') && !path.includes('.')) {
+                        // Special case: If hookCallPath is a callback scope (cyScope pattern),
+                        // trace through it to find what the callback actually returns.
+                        // This handles useState(() => { return prop; }) patterns.
+                        const cyScopeMatch = hookCallPath.match(/^(cyScope\d+)\(\)$/);
+                        if (cyScopeMatch) {
+                            // Use the equivalency database to trace the callback's return value
+                            // to its actual source (e.g., viewModeFromUrl -> segments -> params -> useParams)
+                            const dbEntry = this.getEquivalenciesDatabaseEntry(scopeNode.name, // Component scope
+                            path);
+                            if (dbEntry?.sourceCandidates?.length > 0) {
+                                // Use the traced source instead of the callback scope
+                                hookCallPath = dbEntry.sourceCandidates[0].schemaPath;
+                            }
+                        }
+                        addEquivalency(path, hookCallPath);
+                    }
+                }
+                // Case 3: Destructured variables from local variables
+                // e.g., const { scenarios } = currentEntityAnalysis;
+                // This creates: path = "scenarios", schemaPath = "currentEntityAnalysis.scenarios"
+                // We need to map: "scenarios" -> "currentEntityAnalysis.scenarios"
+                // AND resolve transitively if currentEntityAnalysis is itself equivalent to a hook call
+                if (!path.includes('.') && // path is a simple identifier
+                    !equivalentValue.schemaPath.startsWith('signature[') && // not a signature path
+                    !equivalentValue.schemaPath.endsWith('.functionCallReturnValue') // not already handled above
+                ) {
+                    // Skip bare "returnValue" from child scopes — this is the child's return value,
+                    // not a meaningful data source path in the parent scope
+                    if (equivalentValue.schemaPath === 'returnValue' &&
+                        equivalentValue.scopeNodeName !==
+                            this.scopeTreeManager.getRootName()) {
+                        continue;
+                    }
+                    // Add equivalency (will accumulate if multiple values for OR expressions)
+                    addEquivalency(path, equivalentValue.schemaPath);
+                }
+                // Case 4: Child component prop mappings (Fix 22)
+                // When parent renders <ChildComponent prop={value} />, we get equivalencies like:
+                //   path = "ChildComponent().signature[0].prop"
+                //   schemaPath = "value" (the variable passed as the prop)
+                // We need to include these so translateChildPathToParent can work.
+                // Pattern: ComponentName().signature[N] or ComponentName().signature[N].propName
+                if (path.includes('().signature[') &&
+                    !equivalentValue.schemaPath.includes('()') // schemaPath is a simple variable, not a function call
+                ) {
+                    addEquivalency(path, equivalentValue.schemaPath);
+                }
+                // Case 5: Destructured function parameters (Fix 25)
+                // When a function has destructured props: function Comp({ propA, propB }: Props)
+                // We get equivalencies like:
+                //   path = "propA" (the destructured variable name)
+                //   schemaPath = "signature[0].propA" (the signature path)
+                // We need to map: "propA" -> "signature[0].propA"
+                // This enables translateChildPathToParent to resolve child variable paths
+                // to their signature paths when merging execution flows.
+                if (!path.includes('.') && // path is a simple identifier (destructured prop name)
+                    equivalentValue.schemaPath.startsWith('signature[') // schemaPath IS a signature path
+                ) {
+                    addEquivalency(path, equivalentValue.schemaPath);
+                }
+                // Case 7: Method calls on variables that result in .functionCallReturnValue (Fix 33)
+                // When we have patterns like:
+                //   path = "segments" (simple identifier)
+                //   schemaPath = "splat.split('/').functionCallReturnValue"
+                // This is a method call on a variable (not a hook call), but we still need to
+                // track it so transitive resolution can resolve `splat` to its actual source.
+                // E.g., if splat -> useParams().functionCallReturnValue['*'], then
+                // segments -> useParams().functionCallReturnValue['*'].split('/').functionCallReturnValue
+                if (!path.includes('.') && // path is a simple identifier
+                    equivalentValue.schemaPath.endsWith('.functionCallReturnValue') && // ends with function return
+                    equivalentValue.schemaPath.includes('.') // has property access (method call)
+                ) {
+                    // Check if this looks like a method call on a variable (not a hook call)
+                    // Hook calls look like: hookName() or hookName<T>()
+                    // Method calls look like: variable.method() or variable.method<T>()
+                    const hookCallPath = equivalentValue.schemaPath.slice(0, -'.functionCallReturnValue'.length);
+                    // If it's a method call (contains a dot before the parenthesis), include it
+                    const dotBeforeParen = hookCallPath.indexOf('.');
+                    const parenPos = hookCallPath.indexOf('(');
+                    if (dotBeforeParen !== -1 && dotBeforeParen < parenPos) {
+                        // This is a method call like "splat.split('/')", not a hook call
+                        addEquivalency(path, equivalentValue.schemaPath);
+                    }
+                }
+            }
+        }
+        // Case 6: Collect JSX child prop equivalencies from child scopes (Fix 26)
+        // When a parent component renders <ChildComponent prop={value} />, the JSX
+        // return statement may be in a child scope (e.g., cyScope2). The equivalencies
+        // like ChildComponent().signature[0].prop -> value get stored in that child scope.
+        // But translateChildPathToParent needs to find them from the parent scope's context.
+        // So we collect Case 4 patterns from ALL child scopes that belong to this root scope.
+        const rootName = this.scopeTreeManager.getRootName();
+        for (const [scopeName, childScopeNode] of Object.entries(this.scopeNodes)) {
+            // Skip the root scope (already processed above)
+            if (scopeName === rootName)
+                continue;
+            // Only include scopes that are children of the root (their tree includes root)
+            if (!childScopeNode.tree?.includes(rootName))
+                continue;
+            // Look for Case 4 patterns in the child scope
+            for (const [path, equivalentValues] of Object.entries(childScopeNode.equivalencies || {})) {
+                for (const equivalentValue of equivalentValues) {
+                    // Case 4 pattern: ChildComponent().signature[0].propName -> parentVariable
+                    if (path.includes('().signature[') &&
+                        !equivalentValue.schemaPath.includes('()') // schemaPath is a simple variable
+                    ) {
+                        // Only add if not already present from the root scope
+                        // Root scope values take precedence over child scope values
+                        if (!(path in equivalentSignatureVariables)) {
+                            addEquivalency(path, equivalentValue.schemaPath);
+                        }
+                    }
+                }
+            }
+        }
+        // Transitive resolution: Resolve variable chains through multiple levels
+        // E.g., analysis → currentEntityAnalysis → useLoaderData().functionCallReturnValue.currentEntityAnalysis
+        // We need multiple passes because resolutions can depend on each other
+        const maxIterations = 5; // Prevent infinite loops
+        // Helper function to resolve a single source path using equivalencies
+        const resolveSourcePath = (sourcePath, equivMap) => {
+            // Extract base variable from the path
+            const dotIndex = sourcePath.indexOf('.');
+            const bracketIndex = sourcePath.indexOf('[');
+            let baseVar;
+            let rest;
+            if (dotIndex === -1 && bracketIndex === -1) {
+                baseVar = sourcePath;
+                rest = '';
+            }
+            else if (dotIndex === -1) {
+                baseVar = sourcePath.slice(0, bracketIndex);
+                rest = sourcePath.slice(bracketIndex);
+            }
+            else if (bracketIndex === -1) {
+                baseVar = sourcePath.slice(0, dotIndex);
+                rest = sourcePath.slice(dotIndex);
+            }
+            else {
+                const firstIndex = Math.min(dotIndex, bracketIndex);
+                baseVar = sourcePath.slice(0, firstIndex);
+                rest = sourcePath.slice(firstIndex);
+            }
+            // Look up the base variable in equivalencies
+            if (baseVar in equivMap && equivMap[baseVar] !== sourcePath) {
+                const baseResolved = equivMap[baseVar];
+                // Skip if baseResolved is an array (handle later)
+                if (Array.isArray(baseResolved))
+                    return null;
+                // If it resolves to a signature path, build the full resolved path
+                if (baseResolved.startsWith('signature[') ||
+                    baseResolved.includes('()')) {
+                    if (baseResolved.endsWith('()')) {
+                        return baseResolved + '.functionCallReturnValue' + rest;
+                    }
+                    return baseResolved + rest;
+                }
+            }
+            return null;
+        };
+        for (let iteration = 0; iteration < maxIterations; iteration++) {
+            let changed = false;
+            for (const [varName, sourcePathOrArray] of Object.entries(equivalentSignatureVariables)) {
+                // Handle arrays (OR expressions) by resolving each element
+                if (Array.isArray(sourcePathOrArray)) {
+                    const resolvedArray = [];
+                    let arrayChanged = false;
+                    for (const sourcePath of sourcePathOrArray) {
+                        // Try to resolve this path using transitive resolution
+                        const resolved = resolveSourcePath(sourcePath, equivalentSignatureVariables);
+                        if (resolved && resolved !== sourcePath) {
+                            resolvedArray.push(resolved);
+                            arrayChanged = true;
+                        }
+                        else {
+                            resolvedArray.push(sourcePath);
+                        }
+                    }
+                    if (arrayChanged) {
+                        equivalentSignatureVariables[varName] = resolvedArray;
+                        changed = true;
+                    }
+                    continue;
+                }
+                const sourcePath = sourcePathOrArray;
+                // Skip if already fully resolved (contains function call syntax)
+                // BUT first check for computed value patterns that need resolution (Fix 28)
+                // AND method call patterns that need base variable resolution (Fix 33)
+                if (sourcePath.includes('()')) {
+                    // Fix 28: Handle computed value patterns with dependency arrays
+                    // Patterns like `functionName(arg, [dep1, dep2, ...])` are NOT controllable
+                    // data sources. We trace through the dependencies to find controllable sources.
+                    const bracketStart = sourcePath.indexOf('[');
+                    const bracketEnd = sourcePath.lastIndexOf(']');
+                    if (bracketStart !== -1 && bracketEnd > bracketStart) {
+                        const arrayContent = sourcePath.slice(bracketStart + 1, bracketEnd);
+                        const items = arrayContent.split(',').map((s) => s.trim());
+                        // Only process if this looks like a dependency array:
+                        // multiple items that are all simple identifiers (not numbers or expressions)
+                        const isIdentifier = (s) => /^\w+$/.test(s) && !/^\d+$/.test(s);
+                        if (items.length > 1 && items.every(isIdentifier)) {
+                            // Look for a dependency that's already resolved to a controllable source
+                            for (const dep of items) {
+                                if (dep in equivalentSignatureVariables) {
+                                    const resolvedDep = equivalentSignatureVariables[dep];
+                                    // Use if it's a controllable path (contains hook call)
+                                    // and is NOT another unresolved computed pattern (has comma-separated deps)
+                                    const hasCommaInBrackets = resolvedDep.includes('[') &&
+                                        resolvedDep.includes(',') &&
+                                        resolvedDep.indexOf(',') > resolvedDep.indexOf('[');
+                                    if (resolvedDep.includes('()') && !hasCommaInBrackets) {
+                                        // Computed value is typically an element from an array
+                                        equivalentSignatureVariables[varName] = resolvedDep + '[]';
+                                        changed = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Fix 33: Handle method call patterns on variables
+                    // Patterns like: "splat.split('/').functionCallReturnValue"
+                    // We need to resolve the base variable (splat) to its actual source
+                    // Check if this is a method call on a variable (dot before first parenthesis)
+                    const dotIndex = sourcePath.indexOf('.');
+                    const parenIndex = sourcePath.indexOf('(');
+                    if (dotIndex !== -1 &&
+                        dotIndex < parenIndex &&
+                        !sourcePath.startsWith('use') // Not a hook call like useState()
+                    ) {
+                        // Extract the base variable (before the first dot)
+                        const baseVar = sourcePath.slice(0, dotIndex);
+                        const rest = sourcePath.slice(dotIndex); // includes ".method(...).functionCallReturnValue"
+                        // Check if the base variable can be resolved
+                        if (baseVar in equivalentSignatureVariables &&
+                            baseVar !== varName) {
+                            const baseResolved = equivalentSignatureVariables[baseVar];
+                            // Skip if baseResolved is an array (OR expression)
+                            if (Array.isArray(baseResolved))
+                                continue;
+                            // Only resolve if the base resolved to something useful (contains () or .)
+                            if (baseResolved.includes('()') || baseResolved.includes('.')) {
+                                const newPath = baseResolved + rest;
+                                if (newPath !== equivalentSignatureVariables[varName]) {
+                                    equivalentSignatureVariables[varName] = newPath;
+                                    changed = true;
+                                }
+                            }
+                        }
+                    }
+                    // Fix 38: Handle cyScope lazy initializer return values
+                    // When we have viewMode -> cyScope20(), trace through to find what cyScope20 returns.
+                    // The lazy initializer's return value should be the controllable data source.
+                    // Pattern: cyScopeN() where N is a number
+                    const cyScopeMatch = sourcePath.match(/^(cyScope\d+)\(\)$/);
+                    if (cyScopeMatch) {
+                        const cyScopeName = cyScopeMatch[1];
+                        const cyScopeNode = this.scopeNodes[cyScopeName];
+                        if (cyScopeNode?.equivalencies) {
+                            // Look for returnValue equivalency in the cyScope
+                            const returnValueEquivs = cyScopeNode.equivalencies['returnValue'];
+                            if (returnValueEquivs && returnValueEquivs.length > 0) {
+                                // Get the first return value source
+                                const returnSource = returnValueEquivs[0].schemaPath;
+                                // If the return source is a simple variable (not a complex path),
+                                // resolve varName directly to that variable
+                                if (returnSource &&
+                                    !returnSource.includes('(') &&
+                                    !returnSource.includes('[')) {
+                                    // Update varName to point to the return source
+                                    if (equivalentSignatureVariables[varName] !== returnSource) {
+                                        equivalentSignatureVariables[varName] = returnSource;
+                                        changed = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // Check if the source path starts with a variable that's also in the map
+                const dotIndex = sourcePath.indexOf('.');
+                let baseVar;
+                let rest;
+                if (dotIndex > 0) {
+                    // Path has a dot: "a.b.c" -> baseVar="a", rest=".b.c"
+                    baseVar = sourcePath.slice(0, dotIndex);
+                    rest = sourcePath.slice(dotIndex); // includes the leading dot
+                }
+                else {
+                    // Path is a simple identifier: "currentEntityAnalysis" -> baseVar="currentEntityAnalysis", rest=""
+                    baseVar = sourcePath;
+                    rest = '';
+                }
+                if (baseVar in equivalentSignatureVariables && baseVar !== varName) {
+                    // Handle array case (OR expressions) - use first element
+                    const rawBaseResolved = equivalentSignatureVariables[baseVar];
+                    const baseResolved = Array.isArray(rawBaseResolved)
+                        ? rawBaseResolved[0]
+                        : rawBaseResolved;
+                    if (!baseResolved)
+                        continue;
+                    // If the base resolves to a hook call, add .functionCallReturnValue
+                    if (baseResolved.endsWith('()')) {
+                        const newPath = baseResolved + '.functionCallReturnValue' + rest;
+                        if (newPath !== equivalentSignatureVariables[varName]) {
+                            equivalentSignatureVariables[varName] = newPath;
+                            changed = true;
+                        }
+                    }
+                    else if (baseResolved !== sourcePath) {
+                        const newPath = baseResolved + rest;
+                        if (newPath !== equivalentSignatureVariables[varName]) {
+                            equivalentSignatureVariables[varName] = newPath;
+                            changed = true;
+                        }
+                    }
                 }
             }
+            // Stop if no changes were made in this iteration
+            if (!changed)
+                break;
         }
         return equivalentSignatureVariables;
     }
@@ -2189,7 +3518,12 @@ export class ScopeDataStructure {
             return { ...acc, ...filterdSchema };
         }, {});
         const tempScopeNode = this.createTempScopeNode(scopeName ?? this.scopeTreeManager.getRootName(), relevantSchema);
+        // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+        // during this "getter" method. See comment in getFunctionSignature.
+        const wasOnlyEquivalencies = this.onlyEquivalencies;
+        this.onlyEquivalencies = true;
         this.validateSchema(tempScopeNode, true, final);
+        this.onlyEquivalencies = wasOnlyEquivalencies;
         return {
             name: variableName,
             equivalentTo: equivalents,
@@ -2197,7 +3531,96 @@ export class ScopeDataStructure {
         };
     }
     getExternalFunctionCalls() {
-        return this.externalFunctionCalls;
+        // Replace cyScope placeholders in all external function call data
+        // This ensures call signatures and schema paths use actual callback text
+        // instead of internal cyScope names, preventing mock data merge conflicts.
+        return this.externalFunctionCalls.map((efc) => this.cleanCyScopeFromFunctionCallInfo(efc));
+    }
+    /**
+     * Cleans cyScope placeholder references from a FunctionCallInfo.
+     * Replaces cyScopeN() with the actual callback text in:
+     * - callSignature
+     * - allCallSignatures
+     * - schema keys
+     */
+    cleanCyScopeFromFunctionCallInfo(efc) {
+        const cyScopePattern = /cyScope\d+\(\)/g;
+        // Check if any cleaning is needed
+        const hasCyScope = cyScopePattern.test(efc.callSignature) ||
+            (efc.allCallSignatures &&
+                efc.allCallSignatures.some((sig) => /cyScope\d+\(\)/.test(sig))) ||
+            (efc.schema &&
+                Object.keys(efc.schema).some((key) => /cyScope\d+\(\)/.test(key)));
+        if (!hasCyScope) {
+            return efc;
+        }
+        // Create cleaned copy
+        const cleaned = { ...efc };
+        // Clean callSignature
+        cleaned.callSignature = this.replaceCyScopeInString(efc.callSignature);
+        // Clean allCallSignatures
+        if (efc.allCallSignatures) {
+            cleaned.allCallSignatures = efc.allCallSignatures.map((sig) => this.replaceCyScopeInString(sig));
+        }
+        // Clean schema keys
+        if (efc.schema) {
+            cleaned.schema = this.replaceCyScopePlaceholders(efc.schema);
+        }
+        // Clean callSignatureToVariable keys
+        if (efc.callSignatureToVariable) {
+            cleaned.callSignatureToVariable = Object.entries(efc.callSignatureToVariable).reduce((acc, [key, value]) => {
+                acc[this.replaceCyScopeInString(key)] = value;
+                return acc;
+            }, {});
+        }
+        return cleaned;
+    }
+    /**
+     * Replaces cyScope placeholder references in a single string.
+     * If the scope text can't be found, uses a generic fallback to avoid leaking
+     * internal cyScope names into stored data.
+     *
+     * Handles two patterns:
+     * 1. Function call style: cyScope7() - matched by cyScope(\d+)\(\)
+     * 2. Scope name style: parentName____cyScopeXX or cyScopeXX - matched by (\w+____)?cyScope([0-9A-Fa-f]+)
+     */
+    replaceCyScopeInString(str) {
+        let result = str;
+        // Pattern 1: Function call style - cyScope7()
+        const functionCallPattern = /cyScope(\d+)\(\)/g;
+        const functionCallMatches = [...str.matchAll(functionCallPattern)];
+        for (const match of functionCallMatches) {
+            const cyScopeName = `cyScope${match[1]}`;
+            const scopeText = this.findCyScopeText(cyScopeName);
+            // Always replace cyScope references - use actual text if available,
+            // otherwise use a generic callback placeholder
+            const replacement = scopeText || '() => {}';
+            result = result.replace(match[0], replacement);
+        }
+        // Pattern 2: Scope name style - parentName____cyScopeXX or just cyScopeXX
+        // This handles hex-encoded scope IDs like cyScope1F
+        const scopeNamePattern = /(\w+____)?cyScope([0-9A-Fa-f]+)/g;
+        const scopeNameMatches = [...result.matchAll(scopeNamePattern)];
+        for (const match of scopeNameMatches) {
+            const fullMatch = match[0];
+            const prefix = match[1] || ''; // e.g., "getTitleColor____"
+            const cyScopeId = match[2]; // e.g., "1F"
+            const cyScopeName = `cyScope${cyScopeId}`;
+            // Try to find the scope text, checking both with and without prefix
+            let scopeText = this.findCyScopeText(cyScopeName);
+            if (!scopeText && prefix) {
+                // Try looking up with the full prefixed name
+                scopeText = this.findCyScopeText(`${prefix}${cyScopeName}`);
+            }
+            if (scopeText) {
+                result = result.replace(fullMatch, scopeText);
+            }
+            else {
+                // Replace with a generic identifier to avoid leaking internal names
+                result = result.replace(fullMatch, 'callback');
+            }
+        }
+        return result;
     }
     getEnvironmentVariables() {
         return this.environmentVariables;
@@ -2223,12 +3646,116 @@ export class ScopeDataStructure {
             }
         }
     }
+    /**
+     * Add conditional effects from AST analysis.
+     * Called during scope analysis to collect all setter calls inside conditionals.
+     */
+    addConditionalEffects(effects) {
+        // Add effects, avoiding duplicates based on effect stateVariable and condition paths
+        for (const effect of effects) {
+            const exists = this.rawConditionalEffects.some((existing) => {
+                // Same effect target (stateVariable + value)
+                const sameEffect = existing.effect.stateVariable === effect.effect.stateVariable &&
+                    existing.effect.value === effect.effect.value;
+                if (!sameEffect)
+                    return false;
+                // Same condition(s)
+                if (existing.condition && effect.condition) {
+                    return (existing.condition.path === effect.condition.path &&
+                        existing.condition.requiredValue === effect.condition.requiredValue);
+                }
+                if (existing.conditions && effect.conditions) {
+                    if (existing.conditions.length !== effect.conditions.length)
+                        return false;
+                    return existing.conditions.every((ec, i) => {
+                        const newCond = effect.conditions[i];
+                        return (ec.path === newCond.path &&
+                            ec.requiredValue === newCond.requiredValue);
+                    });
+                }
+                return false;
+            });
+            if (!exists) {
+                this.rawConditionalEffects.push(effect);
+            }
+        }
+    }
+    /**
+     * Get conditional effects collected during analysis.
+     */
+    getConditionalEffects() {
+        return this.rawConditionalEffects;
+    }
+    /**
+     * Add compound conditionals from AST analysis.
+     * Called during scope analysis to collect grouped conditions (e.g., a && b && c).
+     */
+    addCompoundConditionals(compounds) {
+        // Add compounds, avoiding duplicates based on chainId
+        for (const compound of compounds) {
+            const exists = this.rawCompoundConditionals.some((existing) => existing.chainId === compound.chainId);
+            if (!exists) {
+                this.rawCompoundConditionals.push(compound);
+            }
+        }
+    }
+    /**
+     * Get compound conditionals collected during analysis.
+     */
+    getCompoundConditionals() {
+        return this.rawCompoundConditionals;
+    }
+    /**
+     * Add child boundary gating conditions from AST analysis.
+     * These track which conditions must be true for a child component to render.
+     */
+    addChildBoundaryGatingConditions(conditions) {
+        for (const [childName, usages] of Object.entries(conditions)) {
+            if (!this.rawChildBoundaryGatingConditions[childName]) {
+                this.rawChildBoundaryGatingConditions[childName] = [];
+            }
+            // Add usages, avoiding duplicates
+            for (const usage of usages) {
+                const exists = this.rawChildBoundaryGatingConditions[childName].some((existing) => existing.path === usage.path &&
+                    existing.conditionType === usage.conditionType &&
+                    existing.isNegated === usage.isNegated);
+                if (!exists) {
+                    this.rawChildBoundaryGatingConditions[childName].push(usage);
+                }
+            }
+        }
+    }
+    /**
+     * Get enriched child boundary gating conditions with source tracing.
+     * Similar to getEnrichedConditionalUsages but for gating conditions.
+     */
+    getEnrichedChildBoundaryGatingConditions() {
+        const enriched = {};
+        const rootScopeName = this.scopeTreeManager.getTree().name;
+        for (const [childName, usages] of Object.entries(this.rawChildBoundaryGatingConditions)) {
+            enriched[childName] = usages.map((usage) => {
+                // Try to trace this path back to a data source
+                const explanation = this.explainPath(rootScopeName, usage.path);
+                let sourceDataPath;
+                if (explanation.source) {
+                    sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+                }
+                return {
+                    ...usage,
+                    sourceDataPath,
+                };
+            });
+        }
+        return enriched;
+    }
     /**
      * Get enriched conditional usages with source tracing.
      * Uses explainPath to trace each local variable back to its data source.
+     * Preserves all fields from the raw conditional usages including derivedFrom.
      */
     getEnrichedConditionalUsages() {
         const enriched = {};
+        console.log(`[getEnrichedConditionalUsages] Processing ${Object.keys(this.rawConditionalUsages).length} conditional paths: [${Object.keys(this.rawConditionalUsages).join(', ')}]`);
         for (const [path, usages] of Object.entries(this.rawConditionalUsages)) {
             // Try to trace this path back to a data source
             // First, try the root scope
@@ -2236,9 +3763,47 @@ export class ScopeDataStructure {
             const explanation = this.explainPath(rootScopeName, path);
             let sourceDataPath;
             if (explanation.source) {
-                // Build the full data path: scopeName.path
-                sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+                const { scope, path: sourcePath } = explanation.source;
+                // Build initial path — avoid redundant prefix when path already contains the scope call
+                let fullPath;
+                if (sourcePath.startsWith(`${scope}(`)) {
+                    fullPath = sourcePath;
+                }
+                else {
+                    fullPath = `${scope}.${sourcePath}`;
+                }
+                sourceDataPath = fullPath;
+                console.log(`[getEnrichedConditionalUsages] "${path}" explainPath → scope="${scope}", sourcePath="${sourcePath}" → sourceDataPath="${sourceDataPath}"`);
+            }
+            else {
+                console.log(`[getEnrichedConditionalUsages] "${path}" explainPath → no source found`);
+            }
+            // If explainPath didn't find a useful external source (e.g., it traced to
+            // useState or just to the component scope itself), check sourceEquivalencies
+            // for an external function call source like a fetch call
+            const hasExternalSource = sourceDataPath?.includes('.functionCallReturnValue');
+            if (!hasExternalSource) {
+                console.log(`[getEnrichedConditionalUsages] "${path}" no external source (sourceDataPath="${sourceDataPath}"), checking sourceEquivalencies fallback...`);
+                const sourceEquiv = this.getSourceEquivalencies();
+                const returnValueKey = `returnValue.${path}`;
+                const sources = sourceEquiv[returnValueKey];
+                if (sources) {
+                    console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] has ${sources.length} sources: [${sources.map((s) => s.schemaPath).join(', ')}]`);
+                    const externalSource = sources.find((s) => s.schemaPath.includes('.functionCallReturnValue') &&
+                        !s.schemaPath.startsWith('useState('));
+                    if (externalSource) {
+                        console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found external source: "${externalSource.schemaPath}"`);
+                        sourceDataPath = externalSource.schemaPath;
+                    }
+                    else {
+                        console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found no external function call source`);
+                    }
+                }
+                else {
+                    console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] not found`);
+                }
             }
+            console.log(`[getEnrichedConditionalUsages] "${path}" FINAL sourceDataPath="${sourceDataPath ?? '(none)'}" (${usages.length} usages)`);
             enriched[path] = usages.map((usage) => ({
                 ...usage,
                 sourceDataPath,
@@ -2246,66 +3811,435 @@ export class ScopeDataStructure {
         }
         return enriched;
     }
+    /**
+     * Add JSX rendering usages from AST analysis.
+     * These track arrays rendered via .map() and strings interpolated in JSX.
+     */
+    addJsxRenderingUsages(usages) {
+        // Add usages, avoiding duplicates based on path and renderingType
+        for (const usage of usages) {
+            const exists = this.rawJsxRenderingUsages.some((existing) => existing.path === usage.path &&
+                existing.renderingType === usage.renderingType);
+            if (!exists) {
+                this.rawJsxRenderingUsages.push(usage);
+            }
+        }
+    }
+    /**
+     * Get JSX rendering usages collected during analysis.
+     */
+    getJsxRenderingUsages() {
+        return this.rawJsxRenderingUsages;
+    }
     toSerializable() {
-        // Helper to convert ScopeVariable to SerializableScopeVariable
+        // Helper to clean cyScope and cyDuplicateKey from a string for output
+        const cleanCyScope = (str) => this.replaceCyScopeInString(str).replace(/::cyDuplicateKey\d+::/g, '');
+        // Helper to convert ScopeVariable to SerializableScopeVariable (with cyScope cleaned)
         const toSerializableVariable = (vars) => vars.map((v) => ({
-            scopeNodeName: v.scopeNodeName,
-            schemaPath: v.schemaPath,
+            scopeNodeName: cleanCyScope(v.scopeNodeName),
+            schemaPath: cleanCyScope(v.schemaPath),
         }));
+        // Helper to clean cyScope from all keys in a schema
+        const cleanSchemaKeys = (schema) => {
+            return Object.entries(schema).reduce((acc, [key, value]) => {
+                acc[cleanCyScope(key)] = value;
+                return acc;
+            }, {});
+        };
         // Helper to get function result for a given function name
         const getFunctionResult = (functionName) => {
             return {
-                signature: this.getFunctionSignature({ functionName }) ?? {},
-                signatureWithUnknowns: this.getFunctionSignature({ functionName, fillInUnknowns: true }) ??
-                    {},
-                returnValue: this.getReturnValue({ functionName }) ?? {},
-                returnValueWithUnknowns: this.getReturnValue({ functionName, fillInUnknowns: true }) ?? {},
+                signature: cleanSchemaKeys(this.getFunctionSignature({ functionName }) ?? {}),
+                signatureWithUnknowns: cleanSchemaKeys(this.getFunctionSignature({ functionName, fillInUnknowns: true }) ??
+                    {}),
+                returnValue: cleanSchemaKeys(this.getReturnValue({ functionName }) ?? {}),
+                returnValueWithUnknowns: cleanSchemaKeys(this.getReturnValue({ functionName, fillInUnknowns: true }) ?? {}),
                 usageEquivalencies: Object.entries(this.getUsageEquivalencies(functionName) ?? {}).reduce((acc, [key, vars]) => {
-                    acc[key] = toSerializableVariable(vars);
+                    // Clean cyScope from the key as well as variable properties
+                    acc[cleanCyScope(key)] = toSerializableVariable(vars);
                     return acc;
                 }, {}),
                 sourceEquivalencies: Object.entries(this.getSourceEquivalencies(functionName) ?? {}).reduce((acc, [key, vars]) => {
-                    acc[key] = toSerializableVariable(vars);
+                    // Clean cyScope from the key as well as variable properties
+                    acc[cleanCyScope(key)] = toSerializableVariable(vars);
                     return acc;
                 }, {}),
                 environmentVariables: this.getEnvironmentVariables(),
             };
         };
-        // Convert external function calls
-        const externalFunctionCalls = this.externalFunctionCalls.map((efc) => ({
-            name: efc.name,
-            callSignature: efc.callSignature,
-            callScope: efc.callScope,
-            schema: efc.schema,
-            equivalencies: efc.equivalencies
-                ? Object.entries(efc.equivalencies).reduce((acc, [key, vars]) => {
-                    acc[key] = toSerializableVariable(vars);
-                    return acc;
-                }, {})
-                : undefined,
-        }));
+        // Convert external function calls - use getExternalFunctionCalls() which cleans cyScope
+        const cleanedExternalCalls = this.getExternalFunctionCalls();
+        // Get root scope schema for building per-variable return value schemas
+        const rootScopeName = this.scopeTreeManager.getRootName();
+        const rootScope = this.scopeNodes[rootScopeName];
+        const rootSchema = rootScope?.schema ?? {};
+        const externalFunctionCalls = cleanedExternalCalls.map((efc) => {
+            // Build perVariableSchemas from perCallSignatureSchemas when available.
+            // This preserves distinct schemas per variable when the same function is called
+            // multiple times with DIFFERENT call signatures (e.g., different type parameters).
+            //
+            // When field accesses happen in child scopes (like JSX expressions), the
+            // rootSchema doesn't contain the detailed paths - they end up in child scope
+            // schemas. Using perCallSignatureSchemas ensures we get the correct schema
+            // for each call, regardless of where field accesses occur.
+            let perVariableSchemas;
+            // Use perCallSignatureSchemas only when:
+            // 1. It exists and has distinct entries for different call signatures
+            // 2. The number of distinct call signatures >= number of receiving variables
+            //
+            // This prevents using it when all calls have the same signature (e.g., useFetcher() x 2)
+            // because in that case, perCallSignatureSchemas only has one entry.
+            const numCallSignatures = efc.perCallSignatureSchemas
+                ? Object.keys(efc.perCallSignatureSchemas).length
+                : 0;
+            const numReceivingVars = efc.receivingVariableNames?.length ?? 0;
+            const hasDistinctSchemas = numCallSignatures >= numReceivingVars && numCallSignatures > 1;
+            // CASE 1: Multiple call signatures with distinct schemas - use indexed variable names
+            if (hasDistinctSchemas &&
+                efc.perCallSignatureSchemas &&
+                efc.callSignatureToVariable) {
+                perVariableSchemas = {};
+                // Build a reverse map: variable -> array of call signatures (in order)
+                // This handles the case where the same variable name is reused for different calls
+                const varToCallSigs = {};
+                for (const [callSig, varName] of Object.entries(efc.callSignatureToVariable)) {
+                    if (!varToCallSigs[varName]) {
+                        varToCallSigs[varName] = [];
+                    }
+                    varToCallSigs[varName].push(callSig);
+                }
+                // Track how many times each variable name has been seen
+                const varNameCounts = {};
+                // For each receiving variable, get its original schema from perCallSignatureSchemas
+                for (const varName of efc.receivingVariableNames ?? []) {
+                    const occurrence = varNameCounts[varName] ?? 0;
+                    varNameCounts[varName] = occurrence + 1;
+                    const callSigs = varToCallSigs[varName];
+                    // Use the nth call signature for the nth occurrence of this variable
+                    const callSig = callSigs?.[occurrence];
+                    if (callSig && efc.perCallSignatureSchemas[callSig]) {
+                        // Use indexed key if this variable name is reused (e.g., fetcher, fetcher[1])
+                        const key = occurrence === 0 ? varName : `${varName}[${occurrence}]`;
+                        // Clone the schema to avoid shared references
+                        perVariableSchemas[key] = {
+                            ...efc.perCallSignatureSchemas[callSig],
+                        };
+                    }
+                }
+                // Only include if we have entries for ALL receiving variables
+                if (Object.keys(perVariableSchemas).length < numReceivingVars) {
+                    // Not all variables have schemas - fall back to rootSchema extraction
+                    perVariableSchemas = undefined;
+                }
+                else {
+                    // Also check that at least one schema is non-empty
+                    // Bug fix: perCallSignatureSchemas may have entries but with empty schemas {}
+                    // In this case, we should fall through to Fallback which uses rootSchema
+                    const hasNonEmptySchema = Object.values(perVariableSchemas).some((schema) => Object.keys(schema).length > 0);
+                    if (!hasNonEmptySchema) {
+                        perVariableSchemas = undefined;
+                    }
+                }
+            }
+            // CASE 2: Single call signature with single variable - use perCallSignatureSchemas directly
+            // This handles parameterized calls like useFetcher<ConfigData>() where each is a separate efc entry
+            if (!perVariableSchemas &&
+                efc.perCallSignatureSchemas &&
+                numCallSignatures === 1 &&
+                numReceivingVars === 1) {
+                const varName = efc.receivingVariableNames[0];
+                const callSig = Object.keys(efc.perCallSignatureSchemas)[0];
+                const schema = efc.perCallSignatureSchemas[callSig];
+                if (schema && Object.keys(schema).length > 0) {
+                    perVariableSchemas = { [varName]: { ...schema } };
+                }
+            }
+            // CASE 3: Extract from efc.schema when perCallSignatureSchemas is missing or empty
+            // This handles two scenarios:
+            // 1. Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+            // 2. Destructuring where perCallSignatureSchemas exists but has EMPTY schemas
+            //
+            // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create separate
+            // efc entries because getFunctionCallRoot preserves type parameters. Each entry has its own
+            // `schema` field, but due to variable reassignment, the schema may be contaminated with paths
+            // from other calls (the tracer attributes field accesses to ALL equivalencies).
+            //
+            // Solution: Filter efc.schema to only include paths that match THIS entry's call signature.
+            // The schema paths include the full call signature prefix, so we can filter by it.
+            //
+            // Example: ConfigData entry has paths like:
+            //   "useFetcher<{ data: ConfigData | null }>().functionCallReturnValue.data.data.theme"
+            // But also (contaminated):
+            //   "useFetcher<{ data: ConfigData | null }>().functionCallReturnValue.data.data.notifications"
+            //
+            // We filter to only keep paths that should belong to THIS call by checking if the
+            // receiving variable's equivalency points to this call's return value.
+            //
+            // BUG FIX: The old condition `!efc.perCallSignatureSchemas` was FALSE when the object
+            // existed (even with empty schemas), causing this case to be skipped. We now also check
+            // if all schemas in perCallSignatureSchemas are empty.
+            const hasNonEmptyPerCallSignatureSchemas = efc.perCallSignatureSchemas &&
+                Object.values(efc.perCallSignatureSchemas).some((schema) => Object.keys(schema).length > 0);
+            // Build the call signature prefix that paths should start with
+            const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+            // Check if efc.schema has variable-specific paths (indicating destructuring).
+            // Destructuring: const { entities, gitStatus } = useLoaderData()
+            // - efc.schema has paths like: useLoaderData().functionCallReturnValue.entities...
+            // Multiple calls: const x = useFetcher(); const y = useFetcher();
+            // - efc.schema has paths like: useFetcher().functionCallReturnValue.data...
+            // CASE 3 should only run for destructuring (variable-specific paths exist).
+            const hasVariableSpecificPaths = (efc.receivingVariableNames ?? []).some((varName) => Object.keys(efc.schema).some((path) => path.startsWith(`${callSigPrefix}.${varName}`)));
+            if (!perVariableSchemas &&
+                !hasNonEmptyPerCallSignatureSchemas &&
+                numReceivingVars >= 1 &&
+                hasVariableSpecificPaths) {
+                // Filter efc.schema to only include paths matching this call signature
+                const filteredSchema = {};
+                for (const [path, type] of Object.entries(efc.schema)) {
+                    if (path.startsWith(callSigPrefix) || path === efc.callSignature) {
+                        filteredSchema[path] = type;
+                    }
+                }
+                // Build perVariableSchemas from the filtered schema
+                // For destructuring, filter paths by variable name
+                if (Object.keys(filteredSchema).length > 0) {
+                    perVariableSchemas = {};
+                    for (const varName of efc.receivingVariableNames ?? []) {
+                        // For destructuring, extract only paths specific to this variable
+                        const varSpecificPrefix = `${callSigPrefix}.${varName}`;
+                        const varSchema = {};
+                        for (const [path, type] of Object.entries(filteredSchema)) {
+                            if (path.startsWith(varSpecificPrefix)) {
+                                // Transform: useLoaderData().functionCallReturnValue.entities.sha
+                                //         -> functionCallReturnValue.entities.sha (keep the variable name)
+                                const suffix = path.slice(callSigPrefix.length);
+                                const returnValuePath = `functionCallReturnValue${suffix}`;
+                                varSchema[returnValuePath] = type;
+                            }
+                            else if (path === efc.callSignature) {
+                                // Include the function call type itself
+                                varSchema[path] = type;
+                            }
+                        }
+                        if (Object.keys(varSchema).length > 0) {
+                            perVariableSchemas[varName] = varSchema;
+                        }
+                    }
+                    // Only include if we have entries
+                    if (Object.keys(perVariableSchemas).length === 0) {
+                        perVariableSchemas = undefined;
+                    }
+                }
+            }
+            // Fallback: extract from root scope schema when perCallSignatureSchemas is not available
+            // or doesn't have distinct entries for each variable.
+            // This works when field accesses are in the root scope.
+            if (!perVariableSchemas &&
+                efc.receivingVariableNames &&
+                efc.receivingVariableNames.length > 0) {
+                perVariableSchemas = {};
+                for (const varName of efc.receivingVariableNames) {
+                    const varSchema = {};
+                    for (const [path, type] of Object.entries(rootSchema)) {
+                        // Check if path starts with this variable name
+                        if (path === varName ||
+                            path.startsWith(varName + '.') ||
+                            path.startsWith(varName + '[')) {
+                            // Transform to functionCallReturnValue format
+                            // e.g., userFetcher.data.id -> functionCallReturnValue.data.id
+                            const suffix = path.slice(varName.length);
+                            const returnValuePath = `functionCallReturnValue${suffix}`;
+                            varSchema[returnValuePath] = type;
+                        }
+                    }
+                    if (Object.keys(varSchema).length > 0) {
+                        // Clean the variable name when using as key in output
+                        perVariableSchemas[cleanCyScope(varName)] = varSchema;
+                    }
+                }
+                // Only include if we have any entries
+                if (Object.keys(perVariableSchemas).length === 0) {
+                    perVariableSchemas = undefined;
+                }
+            }
+            // Enrich the schema with inferred types by applying fillInSchemaGapsAndUnknowns.
+            // This ensures the serialized schema has the same type inference as getReturnValue().
+            // Without this, evidence like "entities[].analyses: array" becomes "unknown".
+            const enrichedSchema = { ...efc.schema };
+            const tempScopeNode = {
+                name: efc.name,
+                schema: enrichedSchema,
+                equivalencies: efc.equivalencies ?? {},
+            };
+            fillInSchemaGapsAndUnknowns(tempScopeNode, true);
+            return {
+                name: efc.name,
+                callSignature: efc.callSignature,
+                callScope: efc.callScope,
+                schema: enrichedSchema,
+                equivalencies: efc.equivalencies
+                    ? Object.entries(efc.equivalencies).reduce((acc, [key, vars]) => {
+                        // Clean cyScope from the key as well as variable properties
+                        acc[cleanCyScope(key)] = toSerializableVariable(vars);
+                        return acc;
+                    }, {})
+                    : undefined,
+                allCallSignatures: efc.allCallSignatures,
+                receivingVariableNames: efc.receivingVariableNames?.map(cleanCyScope),
+                callSignatureToVariable: efc.callSignatureToVariable
+                    ? Object.fromEntries(Object.entries(efc.callSignatureToVariable).map(([k, v]) => [
+                        k,
+                        cleanCyScope(v),
+                    ]))
+                    : undefined,
+                perVariableSchemas,
+            };
+        });
+        // POST-PROCESSING: Deduplicate schemas across parameterized calls to same base function
+        // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create
+        // separate entries. Due to variable reassignment, BOTH entries may have ALL fields.
+        // We deduplicate by assigning each field to ONLY ONE entry based on order of appearance.
+        //
+        // Strategy: Fields that appear first in order belong to the first entry,
+        // fields that appear later belong to later entries (split evenly).
+        const deduplicateParameterizedEntries = (entries) => {
+            // Group entries by base function name (without type parameters)
+            const groups = new Map();
+            for (const entry of entries) {
+                // Extract base function name by stripping type parameters
+                // e.g., "useFetcher<{ data: ConfigData | null }>" -> "useFetcher"
+                const baseName = entry.name.replace(/<.*>$/, '');
+                const group = groups.get(baseName) || [];
+                group.push(entry);
+                groups.set(baseName, group);
+            }
+            // Process groups with multiple parameterized entries
+            for (const [, group] of groups) {
+                if (group.length <= 1)
+                    continue;
+                // Check if these are parameterized calls (have type parameters in name)
+                const hasTypeParams = group.every((e) => e.name.includes('<'));
+                if (!hasTypeParams)
+                    continue;
+                // Collect ALL unique field suffixes across all entries (in order of first appearance)
+                // Field suffix is the path after functionCallReturnValue, e.g., ".data.data.theme"
+                const allFieldSuffixes = [];
+                for (const entry of group) {
+                    if (!entry.perVariableSchemas)
+                        continue;
+                    for (const varSchema of Object.values(entry.perVariableSchemas)) {
+                        for (const path of Object.keys(varSchema)) {
+                            // Skip the base "functionCallReturnValue" entry
+                            if (path === 'functionCallReturnValue')
+                                continue;
+                            // Extract field suffix
+                            const match = path.match(/functionCallReturnValue(.+)/);
+                            if (!match)
+                                continue;
+                            const fieldSuffix = match[1];
+                            if (!allFieldSuffixes.includes(fieldSuffix)) {
+                                allFieldSuffixes.push(fieldSuffix);
+                            }
+                        }
+                    }
+                }
+                // Assign fields to entries: split evenly based on order
+                // First N/2 fields go to first entry, remaining go to second entry
+                const fieldToEntryMap = new Map();
+                const fieldsPerEntry = Math.ceil(allFieldSuffixes.length / group.length);
+                for (let i = 0; i < allFieldSuffixes.length; i++) {
+                    const fieldSuffix = allFieldSuffixes[i];
+                    const entryIdx = Math.min(Math.floor(i / fieldsPerEntry), group.length - 1);
+                    fieldToEntryMap.set(fieldSuffix, entryIdx);
+                }
+                // Filter each entry's perVariableSchemas to only include its assigned fields
+                for (let i = 0; i < group.length; i++) {
+                    const entry = group[i];
+                    if (!entry.perVariableSchemas)
+                        continue;
+                    const filteredPerVarSchemas = {};
+                    for (const [varName, varSchema] of Object.entries(entry.perVariableSchemas)) {
+                        const filteredVarSchema = {};
+                        for (const [path, type] of Object.entries(varSchema)) {
+                            // Always keep the base functionCallReturnValue
+                            if (path === 'functionCallReturnValue') {
+                                filteredVarSchema[path] = type;
+                                continue;
+                            }
+                            // Extract field suffix
+                            const match = path.match(/functionCallReturnValue(.+)/);
+                            if (!match) {
+                                // Keep non-field paths
+                                filteredVarSchema[path] = type;
+                                continue;
+                            }
+                            const fieldSuffix = match[1];
+                            // Only include if this entry owns this field
+                            if (fieldToEntryMap.get(fieldSuffix) === i) {
+                                filteredVarSchema[path] = type;
+                            }
+                        }
+                        if (Object.keys(filteredVarSchema).length > 0) {
+                            filteredPerVarSchemas[varName] = filteredVarSchema;
+                        }
+                    }
+                    entry.perVariableSchemas =
+                        Object.keys(filteredPerVarSchemas).length > 0
+                            ? filteredPerVarSchemas
+                            : undefined;
+                }
+            }
+            return entries;
+        };
+        // Apply deduplication
+        const deduplicatedExternalFunctionCalls = deduplicateParameterizedEntries(externalFunctionCalls);
+        // IMPORTANT: Get equivalent signature variables BEFORE calling getFunctionResult
+        // because getFunctionResult calls validateSchema which may remove equivalencies
+        // during the finalize step (e.g., cleanNonObjectFunctions removes method call
+        // equivalencies like `segments -> splat.split('/').functionCallReturnValue`).
+        // Fix 33: Move this call before any schema validation to preserve method call chains.
+        const equivalentSignatureVariables = this.getEquivalentSignatureVariables();
         // Get root function result
         const rootFunction = getFunctionResult();
-        // Get results for each external function
+        // Get results for each external function (use cleaned calls for consistency)
         const functionResults = {};
-        for (const efc of this.externalFunctionCalls) {
+        for (const efc of cleanedExternalCalls) {
             functionResults[efc.name] = getFunctionResult(efc.name);
         }
-        // Get equivalent signature variables
-        const equivalentSignatureVariables = this.getEquivalentSignatureVariables();
         const environmentVariables = this.getEnvironmentVariables();
         // Get enriched conditional usages with source tracing
         const enrichedConditionalUsages = this.getEnrichedConditionalUsages();
         const conditionalUsages = Object.keys(enrichedConditionalUsages).length > 0
             ? enrichedConditionalUsages
             : undefined;
+        // Get conditional effects (setter calls inside conditionals)
+        const conditionalEffects = this.rawConditionalEffects.length > 0
+            ? this.rawConditionalEffects
+            : undefined;
+        // Get compound conditionals (grouped conditions that must all be true)
+        const compoundConditionals = this.rawCompoundConditionals.length > 0
+            ? this.rawCompoundConditionals
+            : undefined;
+        // Get child boundary gating conditions
+        const enrichedGatingConditions = this.getEnrichedChildBoundaryGatingConditions();
+        const childBoundaryGatingConditions = Object.keys(enrichedGatingConditions).length > 0
+            ? enrichedGatingConditions
+            : undefined;
+        // Get JSX rendering usages (arrays via .map(), strings via interpolation)
+        const jsxRenderingUsages = this.rawJsxRenderingUsages.length > 0
+            ? this.rawJsxRenderingUsages
+            : undefined;
         return {
-            externalFunctionCalls,
+            externalFunctionCalls: deduplicatedExternalFunctionCalls,
             rootFunction,
             functionResults,
             equivalentSignatureVariables,
             environmentVariables,
             conditionalUsages,
+            conditionalEffects,
+            compoundConditionals,
+            childBoundaryGatingConditions,
+            jsxRenderingUsages,
         };
     }
     // ═══════════════════════════════════════════════════════════════════════════