@codeyam/codeyam-cli 0.1.0-staging.dd216e0 → 0.1.0-staging.e057775

package/packages/ai/src/lib/resolvePathToControllable.js

@@ -0,0 +1,677 @@
+/**
+ * Resolves a local variable path to a controllable data source path.
+ *
+ * This is used for deterministic execution flow generation from static analysis.
+ * A path is "controllable" if it maps to an entry in attributesMap, meaning
+ * we can mock that data during scenario simulation.
+ *
+ * Resolution strategy:
+ * 1. Direct match in attributesMap
+ * 2. Normalized match (array indices [N] → [])
+ * 3. Full-to-short map lookup
+ * 4. Equivalent variable resolution (trace local vars to data sources)
+ */
+import { splitOutsideParenthesesAndArrays, joinParenthesesAndArrays, } from "./splitOutsideParentheses.js";
+import cleanPathOfNonTransformingFunctions from "./dataStructure/helpers/cleanPathOfNonTransformingFunctions.js";
+/**
+ * Extract the local variable name from a path.
+ *
+ * Handles patterns like:
+ * - "debugFetcher.state" → "debugFetcher"
+ * - "EntityDetail.showModal" → "showModal" (strips component prefix)
+ * - "isLoading" → "isLoading"
+ */
+function extractLocalVariableName(path) {
+    const parts = path.split('.');
+    if (parts.length >= 2) {
+        // Check if first part looks like a component name (PascalCase)
+        const firstPart = parts[0];
+        if (/^[A-Z][a-zA-Z0-9]*$/.test(firstPart)) {
+            // Return the second part as the variable name
+            return parts[1];
+        }
+    }
+    // Otherwise return the first part
+    return parts[0];
+}
+/**
+ * Resolve a compound path by replacing the local variable with its data source.
+ *
+ * When the data source is a function call (ends with `()`), we insert
+ * `.functionCallReturnValue.` to match how paths are stored in the data structure.
+ *
+ * Examples:
+ * - ("debugFetcher.state", "debugFetcher", "useFetcher<...>()")
+ *   → "useFetcher<...>().functionCallReturnValue.state"
+ * - ("debugFetcher.data.success", "debugFetcher", "useFetcher<...>()")
+ *   → "useFetcher<...>().functionCallReturnValue.data.success"
+ */
+function resolveCompoundPath(originalPath, localVarName, dataSourceBase) {
+    // Find where the local variable appears in the path
+    const varIndex = originalPath.indexOf(localVarName);
+    if (varIndex === -1) {
+        // If the data source is a function call, we need .functionCallReturnValue
+        if (dataSourceBase.endsWith('()')) {
+            return dataSourceBase + '.functionCallReturnValue';
+        }
+        return dataSourceBase;
+    }
+    // Get the suffix after the local variable name
+    const afterVar = originalPath.slice(varIndex + localVarName.length);
+    // If the data source is a function call, insert .functionCallReturnValue
+    if (dataSourceBase.endsWith('()')) {
+        return dataSourceBase + '.functionCallReturnValue' + afterVar;
+    }
+    // If there's no suffix, just return the data source
+    if (!afterVar || afterVar === '') {
+        return dataSourceBase;
+    }
+    // Otherwise just combine them directly
+    return dataSourceBase + afterVar;
+}
+/**
+ * Check if a type indicates an array.
+ * Returns true for "array", "Array", or types ending with "[]" like "User[]"
+ */
+function isArrayType(type) {
+    return (type === 'array' ||
+        type === 'Array' ||
+        type.endsWith('[]') ||
+        type.startsWith('Array<'));
+}
+/**
+ * Check if a path is an array.length access and return the base array path if so.
+ * Returns null if not an array.length pattern.
+ *
+ * Fix 27: Also checks via fullToShortPathMap for translated child paths.
+ * Uses path splitting utilities instead of string matching for robustness.
+ */
+function getArrayBaseIfLengthAccess(path, attributesMap, fullToShortPathMap) {
+    // Use path splitting to detect .length access properly
+    const pathParts = splitOutsideParenthesesAndArrays(path);
+    if (pathParts.length === 0 || pathParts[pathParts.length - 1] !== 'length') {
+        return null;
+    }
+    // Get the base path (everything except the last 'length' part)
+    const basePath = joinParenthesesAndArrays(pathParts.slice(0, -1));
+    // Clean the base path of non-transforming functions (e.g., .filter())
+    // This handles cases like scenarios.filter(cyScope()).length
+    const cleanedBasePath = cleanPathOfNonTransformingFunctions(basePath);
+    // Helper to check if a path is in attributesMap with array type
+    const checkArrayInAttributesMap = (pathToCheck) => {
+        // Direct match
+        if (pathToCheck in attributesMap) {
+            const type = attributesMap[pathToCheck];
+            if (isArrayType(type)) {
+                return pathToCheck;
+            }
+        }
+        // Normalized match (array indices [N] → [])
+        const normalizedPath = pathToCheck.replace(/\[\d+\]/g, '[]');
+        if (normalizedPath !== pathToCheck && normalizedPath in attributesMap) {
+            const type = attributesMap[normalizedPath];
+            if (isArrayType(type)) {
+                return normalizedPath;
+            }
+        }
+        // Try with [] suffix (for filter/sort/etc methods that operate on arrays)
+        // cleanPathOfNonTransformingFunctions may strip the method but not add []
+        if (!pathToCheck.endsWith('[]')) {
+            const pathWithArray = pathToCheck + '[]';
+            if (pathWithArray in attributesMap) {
+                const type = attributesMap[pathWithArray];
+                if (isArrayType(type)) {
+                    return pathWithArray;
+                }
+            }
+        }
+        return null;
+    };
+    // Check base path directly
+    const directResult = checkArrayInAttributesMap(basePath);
+    if (directResult)
+        return directResult;
+    // Check cleaned path (with non-transforming functions removed)
+    if (cleanedBasePath !== basePath) {
+        const cleanedResult = checkArrayInAttributesMap(cleanedBasePath);
+        if (cleanedResult)
+            return cleanedResult;
+    }
+    // Fix 27: Check via fullToShortPathMap
+    if (fullToShortPathMap) {
+        // Try both basePath and cleanedBasePath
+        const pathsToTry = [basePath];
+        if (cleanedBasePath !== basePath) {
+            pathsToTry.push(cleanedBasePath);
+        }
+        for (const pathToCheck of pathsToTry) {
+            // Direct match in fullToShortPathMap
+            if (pathToCheck in fullToShortPathMap) {
+                const shortPath = fullToShortPathMap[pathToCheck];
+                const shortResult = checkArrayInAttributesMap(shortPath);
+                if (shortResult)
+                    return basePath; // Return original basePath for context
+            }
+            // Fix 30: Find prefix match in fullToShortPathMap
+            const fullPathKeys = Object.keys(fullToShortPathMap);
+            for (const fullPath of fullPathKeys) {
+                if (pathToCheck.startsWith(fullPath + '.')) {
+                    const suffix = pathToCheck.slice(fullPath.length);
+                    const shortBase = fullToShortPathMap[fullPath];
+                    const shortPath = shortBase + suffix;
+                    const shortResult = checkArrayInAttributesMap(shortPath);
+                    if (shortResult)
+                        return basePath; // Return original basePath for context
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if a path exists in the attributes map (directly or normalized).
+ */
+function findInAttributesMap(path, attributesMap) {
+    // Direct match
+    if (path in attributesMap) {
+        return path;
+    }
+    // Normalized match (array indices [N] → [])
+    const normalizedPath = path.replace(/\[\d+\]/g, '[]');
+    if (normalizedPath !== path && normalizedPath in attributesMap) {
+        return normalizedPath;
+    }
+    // Fix 33: If path ends with [] (array element access), check if base path is an array
+    // This handles cases like `segments[]` where `segments` is in attributesMap as an array
+    if (path.endsWith('[]')) {
+        const basePath = path.slice(0, -2); // Remove trailing []
+        if (basePath in attributesMap) {
+            const type = attributesMap[basePath];
+            // Check if the base is an array type
+            if (isArrayType(type) || type === 'unknown' || type === 'string') {
+                // For arrays/strings, element access is controllable
+                return path;
+            }
+        }
+    }
+    // Fix 33: If path ends with [N] (specific array index), check if base path is an array
+    // This handles cases like `segments[0]` where `segments` is in attributesMap as an array
+    const arrayIndexMatch = path.match(/^(.+)\[\d+\]$/);
+    if (arrayIndexMatch) {
+        const basePath = arrayIndexMatch[1];
+        if (basePath in attributesMap) {
+            const type = attributesMap[basePath];
+            // Check if the base is an array type
+            if (isArrayType(type) || type === 'unknown' || type === 'string') {
+                // For arrays/strings, element access is controllable
+                // Return the normalized path for consistency
+                return normalizedPath;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Fix 35: Check if a path is controllable because a PREFIX of it is controllable.
+ *
+ * When child components access nested properties on a prop passed from parent,
+ * the parent's attributesMap might only contain the base path (e.g., "scenarios[]")
+ * but the child uses a nested path (e.g., "scenarios[].metadata.screenshotPaths[]").
+ *
+ * Since nested properties of controllable objects are also controllable,
+ * we should recognize that "scenarios[].metadata.screenshotPaths[]" is controllable
+ * if "scenarios[]" is controllable with an object/array type.
+ *
+ * @param path - The full path to check (e.g., "scenarios[].metadata.screenshotPaths[]")
+ * @param attributesMap - Map of controllable paths to their types
+ * @param fullToShortPathMap - Map from full paths to short paths
+ * @returns The full path if controllable via prefix, null otherwise
+ */
+function findControllablePrefix(path, attributesMap, fullToShortPathMap) {
+    // Normalize array indices for matching
+    const normalizedPath = path.replace(/\[\d+\]/g, '[]');
+    // First, try to find a short version of the path using fullToShortPathMap
+    // The path might be "useLoaderData...scenarios[].metadata.screenshotPaths[]"
+    // We need to find "currentEntityAnalysis.scenarios[]" in attributesMap
+    // Try to find the longest matching prefix in fullToShortPathMap
+    let shortenedPath = normalizedPath;
+    if (fullToShortPathMap) {
+        for (const [fullPath, shortPath] of Object.entries(fullToShortPathMap)) {
+            // Check if normalizedPath starts with this fullPath
+            if (normalizedPath.startsWith(fullPath)) {
+                // Replace the prefix with the short version
+                const suffix = normalizedPath.slice(fullPath.length);
+                shortenedPath = shortPath + suffix;
+                break;
+            }
+        }
+    }
+    // Now check prefixes on the shortened path
+    const pathToCheck = shortenedPath;
+    // Split the path into parts by . and []
+    // e.g., "scenarios[].metadata.screenshotPaths[]" → ["scenarios[]", "metadata", "screenshotPaths[]"]
+    const parts = [];
+    let current = '';
+    for (let i = 0; i < pathToCheck.length; i++) {
+        const char = pathToCheck[i];
+        if (char === '.') {
+            if (current)
+                parts.push(current);
+            current = '';
+        }
+        else if (char === '[') {
+            // Include the bracket notation in the current part
+            const bracketEnd = pathToCheck.indexOf(']', i);
+            if (bracketEnd !== -1) {
+                current += pathToCheck.slice(i, bracketEnd + 1);
+                i = bracketEnd;
+            }
+            else {
+                current += char;
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        parts.push(current);
+    // Try progressively shorter prefixes
+    // e.g., "scenarios[].metadata.screenshotPaths[]" → "scenarios[].metadata" → "scenarios[]"
+    for (let i = parts.length - 1; i >= 1; i--) {
+        const prefix = parts.slice(0, i).join('.');
+        // Check direct match in attributesMap
+        if (prefix in attributesMap) {
+            const type = attributesMap[prefix];
+            // For objects, arrays, or unknown types, nested property access is controllable
+            if (isArrayType(type) ||
+                type === 'object' ||
+                type === 'unknown' ||
+                type.endsWith('[]') ||
+                type.includes('<') // Generic types like Scenario[] or Record<...>
+            ) {
+                return path; // Return the original path (not normalized) as controllable
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Fix 34: Find a controllable base path for derived paths.
+ *
+ * Paths like "useParams().functionCallReturnValue.*.split('/').filter(Boolean)[0]"
+ * are derived from "useParams().functionCallReturnValue.*" via string methods.
+ * This function strips string method calls to find the controllable base.
+ *
+ * String methods that create derived paths:
+ * - .split(...) → returns array of strings
+ * - .filter(...) → returns filtered array
+ * - .slice(...) → returns sliced array/string
+ * - .map(...) → returns transformed array
+ * - .find(...) → returns single element
+ * - .trim(), .toLowerCase(), .toUpperCase() → returns modified string
+ *
+ * @param path - The full derived path
+ * @param attributesMap - Map of controllable paths
+ * @returns The controllable base path if found, null otherwise
+ */
+function findControllableBaseForDerivedPath(path, attributesMap) {
+    // Helper to check if a path is in attributesMap
+    const checkInAttributesMap = (pathToCheck) => {
+        // Direct match
+        if (pathToCheck in attributesMap) {
+            return pathToCheck;
+        }
+        // Normalized match (array indices [N] → [])
+        const normalizedPath = pathToCheck.replace(/\[\d+\]/g, '[]');
+        if (normalizedPath !== pathToCheck && normalizedPath in attributesMap) {
+            return normalizedPath;
+        }
+        return null;
+    };
+    // Use cleanPathOfNonTransformingFunctions to strip non-transforming methods
+    // like .filter(), .sort(), .slice() etc. This handles all method calls generically
+    // without hardcoding specific method names.
+    const cleanedPath = cleanPathOfNonTransformingFunctions(path);
+    // Check the cleaned path directly (even if unchanged, later steps may find something)
+    const directResult = checkInAttributesMap(cleanedPath);
+    if (directResult) {
+        return directResult;
+    }
+    // Fix 38: For controllability purposes, strip ALL derivation operations
+    // including transforming methods like .split(...) and array indices.
+    // The key insight is: if we control the base, we control all derived values.
+    //
+    // Pattern: base.split('...').filter(...)[N] → find base
+    // We progressively strip: [N] → filter(...) → split(...) → until we find something controllable
+    // Methods that derive new values (should be stripped for controllability)
+    const derivingMethods = [
+        'split',
+        'match',
+        'filter',
+        'map',
+        'find',
+        'findIndex',
+        'slice',
+        'substring',
+        'substr',
+        'trim',
+        'trimStart',
+        'trimEnd',
+        'toLowerCase',
+        'toUpperCase',
+        'replace',
+        'replaceAll',
+        'sort',
+        'reverse',
+        'flat',
+        'flatMap',
+    ];
+    // Build regex to match method calls: .methodName(...)
+    // Use a simpler approach: progressively strip trailing derivations
+    let workingPath = cleanedPath;
+    // Keep stripping derivations until we find something controllable or can't strip anymore
+    // Max 20 iterations to prevent infinite loops
+    for (let iteration = 0; iteration < 20; iteration++) {
+        // Try current path
+        const result = checkInAttributesMap(workingPath);
+        if (result) {
+            return result;
+        }
+        // Also check via functionCallReturnValue extraction
+        // Note: We return workingPath (the FULL path) if the short path is found,
+        // because the full path is more meaningful for execution flows
+        const functionReturnMatch = workingPath.match(/\.functionCallReturnValue\.(.+)$/);
+        if (functionReturnMatch) {
+            const shortPath = functionReturnMatch[1];
+            const shortResult = checkInAttributesMap(shortPath);
+            if (shortResult) {
+                // Return the full path, not just the short result
+                // This ensures execution flows have meaningful paths like
+                // "useParams().functionCallReturnValue.*" instead of just "*"
+                return workingPath;
+            }
+        }
+        // Try to strip trailing array index: path[0] → path
+        const arrayIndexMatch = workingPath.match(/^(.+)\[\d+\]$/);
+        if (arrayIndexMatch) {
+            workingPath = arrayIndexMatch[1];
+            continue;
+        }
+        // Try to strip trailing method call: path.method(...) → path
+        let strippedMethod = false;
+        for (const method of derivingMethods) {
+            // Match .method(...) at the end, handling nested parentheses
+            const methodRegex = new RegExp(`\\.${method}\\([^()]*(?:\\([^()]*\\)[^()]*)*\\)$`);
+            if (methodRegex.test(workingPath)) {
+                workingPath = workingPath.replace(methodRegex, '');
+                strippedMethod = true;
+                break;
+            }
+        }
+        if (!strippedMethod) {
+            // Can't strip anymore
+            break;
+        }
+    }
+    // Final check after stripping
+    const finalResult = checkInAttributesMap(workingPath);
+    if (finalResult) {
+        return finalResult;
+    }
+    // Also check via functionCallReturnValue extraction for final path
+    const finalFunctionReturnMatch = workingPath.match(/\.functionCallReturnValue\.(.+)$/);
+    if (finalFunctionReturnMatch) {
+        const shortPath = finalFunctionReturnMatch[1];
+        const shortResult = checkInAttributesMap(shortPath);
+        if (shortResult) {
+            // Return the full path, not just the short result
+            return workingPath;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a local variable path to a controllable data source path.
+ *
+ * @param localPath - The path to resolve (e.g., "isLoading", "debugFetcher.state")
+ * @param attributesMap - Map of controllable paths to their types
+ * @param equivalentSignatureVariables - Map from local variable names to data sources
+ * @param fullToShortPathMap - Map from full paths to short paths (for hooks)
+ * @returns Resolution result with the controllable path or null
+ */
+export default function resolvePathToControllable(localPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap) {
+    const chain = [localPath];
+    // 1. Direct match in attributesMap
+    const directMatch = findInAttributesMap(localPath, attributesMap);
+    if (directMatch) {
+        chain.push(`direct match: ${directMatch}`);
+        return {
+            resolvedPath: directMatch,
+            resolutionChain: chain,
+            isControllable: true,
+        };
+    }
+    // 2. Array.length resolution (direct)
+    // If path ends with .length and base is an array, the .length is controllable
+    // Fix 27: Pass fullToShortPathMap for child path resolution
+    const arrayBase = getArrayBaseIfLengthAccess(localPath, attributesMap, fullToShortPathMap);
+    if (arrayBase) {
+        chain.push(`array.length: base ${arrayBase} is array type`);
+        return {
+            resolvedPath: localPath,
+            resolutionChain: chain,
+            isControllable: true,
+        };
+    }
+    // 3. Full-to-short map lookup
+    if (localPath in fullToShortPathMap) {
+        const shortPath = fullToShortPathMap[localPath];
+        chain.push(`fullToShort: ${shortPath}`);
+        const shortMatch = findInAttributesMap(shortPath, attributesMap);
+        if (shortMatch) {
+            chain.push(`short match: ${shortMatch}`);
+            return {
+                resolvedPath: localPath, // Return the full path since that's what we'll use
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+    }
+    // 3b. Array element notation resolution (Fix 29)
+    // When a path ends with [] (array element access), the fullToShortPathMap
+    // may only have the base path (without []). Check if the base is mapped
+    // and then verify the short path with [] is in attributesMap.
+    if (localPath.endsWith('[]')) {
+        const basePath = localPath.slice(0, -2); // Remove trailing []
+        if (basePath in fullToShortPathMap) {
+            const baseShortPath = fullToShortPathMap[basePath];
+            const shortPathWithBrackets = baseShortPath + '[]';
+            chain.push(`fullToShort (base): ${basePath} → ${baseShortPath}`);
+            const shortMatch = findInAttributesMap(shortPathWithBrackets, attributesMap);
+            if (shortMatch) {
+                chain.push(`short match with []: ${shortMatch}`);
+                return {
+                    resolvedPath: localPath,
+                    resolutionChain: chain,
+                    isControllable: true,
+                };
+            }
+        }
+    }
+    // 4. Equivalent variable resolution
+    const localVarName = extractLocalVariableName(localPath);
+    // Handle array case (OR expressions) - use first element if array
+    const rawDataSourceBase = equivalentSignatureVariables[localVarName];
+    const dataSourceBase = Array.isArray(rawDataSourceBase)
+        ? rawDataSourceBase[0]
+        : rawDataSourceBase;
+    if (dataSourceBase) {
+        chain.push(`equivalent var: ${localVarName} → ${dataSourceBase}`);
+        // Build the full resolved path
+        let fullResolvedPath = resolveCompoundPath(localPath, localVarName, dataSourceBase);
+        chain.push(`resolved: ${fullResolvedPath}`);
+        // Fix 33: Handle transitive resolution for array access patterns
+        // When dataSourceBase is like "segments[0]" or "segments[]", we need to resolve "segments" first
+        // Then combine with the array access: segments -> useParams()... + [0] or []
+        const arrayMatch = fullResolvedPath.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)(\[\d*\].*)$/);
+        if (arrayMatch) {
+            const baseVarName = arrayMatch[1]; // e.g., "segments"
+            const accessSuffix = arrayMatch[2]; // e.g., "[0]" or "[0].property"
+            if (baseVarName in equivalentSignatureVariables &&
+                baseVarName !== localVarName) {
+                // Handle array case (OR expressions) - use first element if array
+                const rawBaseDataSource = equivalentSignatureVariables[baseVarName];
+                const baseDataSource = Array.isArray(rawBaseDataSource)
+                    ? rawBaseDataSource[0]
+                    : rawBaseDataSource;
+                if (baseDataSource) {
+                    chain.push(`transitive resolution: ${baseVarName} → ${baseDataSource}`);
+                    // Append the array access suffix to the resolved base
+                    if (baseDataSource.endsWith('()')) {
+                        fullResolvedPath =
+                            baseDataSource + '.functionCallReturnValue' + accessSuffix;
+                    }
+                    else if (baseDataSource.endsWith('.functionCallReturnValue')) {
+                        fullResolvedPath = baseDataSource + accessSuffix;
+                    }
+                    else {
+                        fullResolvedPath = baseDataSource + accessSuffix;
+                    }
+                    chain.push(`transitively resolved: ${fullResolvedPath}`);
+                }
+            }
+        }
+        // Check if resolved path is controllable
+        const resolvedMatch = findInAttributesMap(fullResolvedPath, attributesMap);
+        if (resolvedMatch) {
+            chain.push(`resolved match: ${resolvedMatch}`);
+            return {
+                resolvedPath: fullResolvedPath,
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+        // Check via fullToShortMap
+        if (fullResolvedPath in fullToShortPathMap) {
+            const shortPath = fullToShortPathMap[fullResolvedPath];
+            chain.push(`resolved fullToShort: ${shortPath}`);
+            const shortMatch = findInAttributesMap(shortPath, attributesMap);
+            if (shortMatch) {
+                chain.push(`short resolved match: ${shortMatch}`);
+                return {
+                    resolvedPath: fullResolvedPath,
+                    resolutionChain: chain,
+                    isControllable: true,
+                };
+            }
+        }
+        // Array.length resolution (after equivalent variable resolution)
+        // If the resolved path ends with .length and base is an array, the .length is controllable
+        // Fix 27: Pass fullToShortPathMap for child path resolution
+        const resolvedArrayBase = getArrayBaseIfLengthAccess(fullResolvedPath, attributesMap, fullToShortPathMap);
+        if (resolvedArrayBase) {
+            chain.push(`array.length: base ${resolvedArrayBase} is array type`);
+            return {
+                resolvedPath: fullResolvedPath,
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+        // Fix 34/38: Handle derived paths from controllable bases
+        // Paths like "useParams().functionCallReturnValue.*.split('/').filter(Boolean)[0]"
+        // are derived from "useParams().functionCallReturnValue.*" via string methods.
+        // If the base path is controllable, return the BASE path (not the derived path)
+        // because that's what we need to mock in the data structure.
+        const derivedBaseResult = findControllableBaseForDerivedPath(fullResolvedPath, attributesMap);
+        if (derivedBaseResult) {
+            chain.push(`derived from controllable base: ${derivedBaseResult}`);
+            return {
+                // Return the controllable BASE path, not the derived path
+                // This ensures execution flows contain paths that exist in attributesMap
+                resolvedPath: derivedBaseResult,
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+        // Fix 35: Handle nested property access on controllable paths
+        // When child components access nested properties like "scenarios[].metadata.screenshotPaths[]"
+        // but parent only has "scenarios[]" in attributesMap, the nested path should still be
+        // controllable since nested properties of controllable objects are also controllable.
+        const prefixResult = findControllablePrefix(fullResolvedPath, attributesMap, fullToShortPathMap);
+        if (prefixResult) {
+            chain.push(`nested property of controllable prefix`);
+            return {
+                resolvedPath: fullResolvedPath,
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+    }
+    // 5. Fix 35: Check for controllable prefix on the local path directly
+    // This handles cases where the localPath itself (before any resolution)
+    // has a controllable prefix in attributesMap
+    //
+    // IMPORTANT: Only do prefix matching if:
+    // a) The root variable is known in equivalentSignatureVariables, OR
+    // b) The path looks like an already-translated path (contains .functionCallReturnValue.)
+    //
+    // If the root variable is NOT known AND it's not an already-translated path, it's likely
+    // from an internal scope (callback, async function) and shouldn't be matched
+    // against similarly-named variables from different scopes.
+    // For example, "data.status" from inside `await response.json()` should NOT
+    // match the "data" from a useFetcher hook.
+    const localVarNameForPrefix = extractLocalVariableName(localPath);
+    const isKnownVariable = localVarNameForPrefix in equivalentSignatureVariables;
+    // Fix 35b: Also allow prefix matching for already-translated paths from child components
+    // These paths start with hook patterns like useLoaderData<...>().functionCallReturnValue
+    // and should be checked for controllable prefixes even if the hook itself isn't
+    // in equivalentSignatureVariables (because it's a fully resolved path, not a local variable)
+    const isAlreadyTranslatedPath = localPath.includes('.functionCallReturnValue.');
+    if (isKnownVariable || isAlreadyTranslatedPath) {
+        const localPrefixResult = findControllablePrefix(localPath, attributesMap, fullToShortPathMap);
+        if (localPrefixResult) {
+            chain.push(`nested property of controllable prefix (direct)`);
+            return {
+                resolvedPath: localPath,
+                resolutionChain: chain,
+                isControllable: true,
+            };
+        }
+    }
+    else {
+        chain.push(`root variable '${localVarNameForPrefix}' not in equivalentSignatureVariables - skipping prefix match`);
+    }
+    // 5b. Fix 36/38: Check for derived paths on localPath directly
+    // When localPath contains derivation methods like .filter(cyScope()), check if
+    // the base path (before .filter()) is controllable
+    const localDerivedResult = findControllableBaseForDerivedPath(localPath, attributesMap);
+    if (localDerivedResult) {
+        chain.push(`derived from controllable base (direct): ${localDerivedResult}`);
+        return {
+            // Return the controllable BASE path, not the derived path
+            resolvedPath: localDerivedResult,
+            resolutionChain: chain,
+            isControllable: true,
+        };
+    }
+    // 5c. Fix 36: Also check .length on derived paths directly
+    // E.g., scenarios.filter(cyScope()).length where scenarios[] is controllable
+    const localArrayBase = getArrayBaseIfLengthAccess(localPath, attributesMap, fullToShortPathMap);
+    if (localArrayBase) {
+        chain.push(`array.length on derived path: base ${localArrayBase}`);
+        return {
+            resolvedPath: localPath,
+            resolutionChain: chain,
+            isControllable: true,
+        };
+    }
+    // 6. Not controllable
+    chain.push('not controllable');
+    return {
+        resolvedPath: null,
+        resolutionChain: chain,
+        isControllable: false,
+    };
+}
+//# sourceMappingURL=resolvePathToControllable.js.map