@codeyam/codeyam-cli 0.1.0-staging.e38f7bd → 0.1.0-staging.f777668

package/analyzer-template/packages/ai/src/lib/resolvePathToControllable.ts

@@ -0,0 +1,824 @@
+/**
+ * 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';
+import cleanPathOfNonTransformingFunctions from './dataStructure/helpers/cleanPathOfNonTransformingFunctions';
+
+export interface PathResolutionResult {
+  /** The resolved controllable path, or null if not controllable */
+  resolvedPath: string | null;
+  /** Chain showing how the path was resolved (for debugging) */
+  resolutionChain: string[];
+  /** Whether this path is controllable (can be mocked) */
+  isControllable: boolean;
+}
+
+/**
+ * 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: string): string {
+  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: string,
+  localVarName: string,
+  dataSourceBase: string,
+): string {
+  // 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: string): boolean {
+  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: string,
+  attributesMap: Record<string, string>,
+  fullToShortPathMap?: Record<string, string>,
+): string | null {
+  // 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: string): string | null => {
+    // 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: string,
+  attributesMap: Record<string, string>,
+): string | null {
+  // 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: string,
+  attributesMap: Record<string, string>,
+  fullToShortPathMap?: Record<string, string>,
+): string | null {
+  // 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: string[] = [];
+  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: string,
+  attributesMap: Record<string, string>,
+): string | null {
+  // Helper to check if a path is in attributesMap
+  const checkInAttributesMap = (pathToCheck: string): string | null => {
+    // 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: string,
+  attributesMap: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
+  fullToShortPathMap: Record<string, string>,
+): PathResolutionResult {
+  const chain: string[] = [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,
+  };
+}