@codeyam/codeyam-cli 0.1.0-staging.15d0f46 → 0.1.0-staging.1669d45

package/packages/ai/src/lib/promptGenerators/generateMissingKeysPrompt.js

@@ -0,0 +1,45 @@
+/**
+ * Generate a prompt for the follow-up LLM call to fill in missing mockData keys.
+ * This is used when the initial Default Scenario response is missing some keys.
+ */
+export default function generateMissingKeysPrompt({ scenario, executionFlows, generatedMockData, missingSchema, }) {
+    const coveredFlowIds = scenario.metadata?.coveredFlows || [];
+    const coveredFlowRequirements = coveredFlowIds
+        .map((flowId) => {
+        const flow = executionFlows?.find((f) => f.id === flowId);
+        if (!flow)
+            return null;
+        return {
+            flowId: flow.id,
+            flowName: flow.name,
+            requiredValues: flow.requiredValues,
+        };
+    })
+        .filter(Boolean);
+    return `The initial response was missing some keys. Generate mock data for ONLY the missing keys listed below.
+
+## Scenario Context
+\`\`\`json
+${JSON.stringify({ name: scenario.name, description: scenario.description, coveredFlows: coveredFlowRequirements }, null, 2)}
+\`\`\`
+
+## Already Generated Data
+\`\`\`json
+${JSON.stringify(generatedMockData, null, 2)}
+\`\`\`
+
+## Missing Keys to Generate
+\`\`\`json
+${JSON.stringify(missingSchema, null, 2)}
+\`\`\`
+
+Return ONLY a JSON object with this structure:
+\`\`\`json
+{
+  "mockData": {
+    // fill in ONLY the missing keys above
+  }
+}
+\`\`\``;
+}
+//# sourceMappingURL=generateMissingKeysPrompt.js.map

package/packages/ai/src/lib/promptGenerators/generateMissingKeysPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateMissingKeysPrompt.js","sourceRoot":"","sources":["../../../../../../../packages/ai/src/lib/promptGenerators/generateMissingKeysPrompt.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAAC,EAChD,QAAQ,EACR,cAAc,EACd,iBAAiB,EACjB,aAAa,GACiB;IAC9B,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,EAAE,YAAY,IAAI,EAAE,CAAC;IAC7D,MAAM,uBAAuB,GAAG,cAAc;SAC3C,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACd,MAAM,IAAI,GAAG,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,EAAE;YACf,QAAQ,EAAE,IAAI,CAAC,IAAI;YACnB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;IACJ,CAAC,CAAC;SACD,MAAM,CAAC,OAAO,CAAC,CAAC;IAEnB,OAAO;;;;EAIP,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,YAAY,EAAE,uBAAuB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;EAK1H,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;EAK1C,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;;;;;;OAUjC,CAAC;AACR,CAAC"}

package/packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.js

@@ -1,13 +1,26 @@
-export default function guessNewScenarioDataFromDescriptionGenerator({ description, existingScenarios, scenariosDataStructure, }) {
+export default function guessNewScenarioDataFromDescriptionGenerator({ description, existingScenarios, scenariosDataStructure, flowSelections, }) {
+    let flowSelectionsSection = '';
+    if (flowSelections && flowSelections.length > 0) {
+        flowSelectionsSection = `
+  User-selected Execution Flow Values:
+  The user has specifically requested these values be used in the scenario:
+  ${flowSelections
+            .map((sel) => `  - ${sel.path}: ${sel.value}${sel.isCustom ? ' (custom value)' : ''}`)
+            .join('\n')}
+
+  IMPORTANT: The mockData MUST include these specific values for the specified paths. Generate a scenario name and description that reflects these choices.
+  `;
+    }
     return `Mock Scenario Data Structure:
   \`\`\`
   ${JSON.stringify(scenariosDataStructure, null, 2)}
-  \`\`\
+  \`\`\`
   Existing Mock Scenario Data:
   \`\`\`
   ${JSON.stringify(existingScenarios, null, 2)}
   \`\`\`
-  New Scenario user-created prompt: "${description}"
+${flowSelectionsSection}
+  New Scenario user-created prompt: "${description || '(No additional description - generate based on selected execution flow values)'}"
   `;
 }
 //# sourceMappingURL=guessNewScenarioDataFromDescriptionGenerator.js.map

package/packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.js.map

@@ -1 +1 @@
-{"version":3,"file":"guessNewScenarioDataFromDescriptionGenerator.js","sourceRoot":"","sources":["../../../../../../../packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,UAAU,4CAA4C,CAAC,EACnE,WAAW,EACX,iBAAiB,EACjB,sBAAsB,GACe;IACrC,OAAO;;IAEL,IAAI,CAAC,SAAS,CAAC,sBAAsB,EAAE,IAAI,EAAE,CAAC,CAAC;;;;IAI/C,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;;uCAEP,WAAW;GAC/C,CAAC;AACJ,CAAC"}
+{"version":3,"file":"guessNewScenarioDataFromDescriptionGenerator.js","sourceRoot":"","sources":["../../../../../../../packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAC,OAAO,UAAU,4CAA4C,CAAC,EACnE,WAAW,EACX,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,GACuB;IACrC,IAAI,qBAAqB,GAAG,EAAE,CAAC;IAC/B,IAAI,cAAc,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChD,qBAAqB,GAAG;;;IAGxB,cAAc;aACb,GAAG,CACF,CAAC,GAAG,EAAE,EAAE,CACN,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAAE,CAC1E;aACA,IAAI,CAAC,IAAI,CAAC;;;GAGZ,CAAC;IACF,CAAC;IAED,OAAO;;IAEL,IAAI,CAAC,SAAS,CAAC,sBAAsB,EAAE,IAAI,EAAE,CAAC,CAAC;;;;IAI/C,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC;;EAE5C,qBAAqB;uCACgB,WAAW,IAAI,gFAAgF;GACnI,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,563 @@
+/**
+ * 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) {
+    // 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);
+    // If the path wasn't changed, there are no non-transforming functions to strip
+    if (cleanedPath === path) {
+        return null;
+    }
+    // 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;
+    };
+    // Check the cleaned path directly
+    const directResult = checkInAttributesMap(cleanedPath);
+    if (directResult) {
+        return directResult;
+    }
+    // Extract the short path (after functionCallReturnValue) for attributesMap lookup
+    const functionReturnMatch = cleanedPath.match(/\.functionCallReturnValue\.(.+)$/);
+    if (functionReturnMatch) {
+        const shortPath = functionReturnMatch[1];
+        const shortResult = checkInAttributesMap(shortPath);
+        if (shortResult) {
+            return shortResult;
+        }
+    }
+    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);
+    const dataSourceBase = equivalentSignatureVariables[localVarName];
+    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) {
+                const baseDataSource = equivalentSignatureVariables[baseVarName];
+                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: 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, the derived path should also be controllable.
+        const derivedBaseResult = findControllableBaseForDerivedPath(fullResolvedPath, attributesMap);
+        if (derivedBaseResult) {
+            chain.push(`derived from controllable base: ${derivedBaseResult}`);
+            return {
+                resolvedPath: fullResolvedPath,
+                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
+    const localPrefixResult = findControllablePrefix(localPath, attributesMap, fullToShortPathMap);
+    if (localPrefixResult) {
+        chain.push(`nested property of controllable prefix (direct)`);
+        return {
+            resolvedPath: localPath,
+            resolutionChain: chain,
+            isControllable: true,
+        };
+    }
+    // 5b. Fix 36: 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 {
+            resolvedPath: localPath,
+            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