@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.4813bf3

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

@@ -105,11 +105,13 @@ function cleanSourceDataPath(sourceDataPath) {
     // 2. Patterns like functionName(...) - closing paren followed by dot or end
     const emptyFnCalls = (sourceDataPath.match(/\(\)/g) || []).length;
     const fnCallReturnValues = (sourceDataPath.match(/\.functionCallReturnValue/g) || []).length;
-    // If there are multiple functionCallReturnValue occurrences, this is a chained call
-    // (e.g., fetch(...).functionCallReturnValue.json().functionCallReturnValue.data)
+    // For chained function calls (e.g., fetch().json()) or paths with non-standard
+    // fn call patterns, return the original path so findInAttributesMapForPath can
+    // try to look it up in fullToShortPathMap. If it doesn't match, the caller
+    // falls through to fallback resolution anyway.
     if (fnCallReturnValues > 1 || emptyFnCalls !== 1) {
-        // Multiple function calls - return null to use fallback resolution
-        return null;
+        console.log(`[cleanSourceDataPath] chained/non-standard path (fnCallRVs=${fnCallReturnValues}, emptyFnCalls=${emptyFnCalls}), returning original: "${sourceDataPath}"`);
+        return sourceDataPath;
     }
     // Find the "()" which marks the function call
     const fnCallIndex = sourceDataPath.indexOf('()');
@@ -146,6 +148,71 @@ function stripLengthSuffix(path) {
     }
     return path;
 }
+/**
+ * Remove contradictory required values from a compound flow.
+ *
+ * When a lifecycle boolean (like isLoadingAuditData) is traced to a fetch call's
+ * return value, a negated condition (!isLoadingAuditData) produces "falsy" on
+ * the fetch path. But if another condition in the same compound requires data
+ * from a sub-path of that fetch (e.g., topPaths length > 0), the "falsy" on the
+ * parent path contradicts it — a null/falsy response has no .json() to call.
+ *
+ * This function removes "falsy" required values whose attributePath is a prefix
+ * of another required value's attributePath. The child data requirement already
+ * implies the parent (fetch) succeeded.
+ */
+function removeContradictoryFalsyValues(requiredValues) {
+    return requiredValues.filter((rv) => {
+        if (rv.comparison === 'falsy') {
+            const hasChildRequirement = requiredValues.some((other) => other !== rv &&
+                other.attributePath.startsWith(rv.attributePath + '.'));
+            if (hasChildRequirement) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Generate a human-readable description snippet for a required value,
+ * incorporating the comparison type so the LLM understands the intent.
+ */
+function describeRequiredValue(rv) {
+    const name = generateNameFromPath(rv.attributePath).toLowerCase();
+    switch (rv.comparison) {
+        case 'truthy':
+            return `${name} is present`;
+        case 'falsy':
+            return `${name} is absent`;
+        case 'length>':
+            return rv.value === '0'
+                ? `${name} has items`
+                : `${name} has more than ${rv.value} items`;
+        case 'length<':
+            return `${name} has fewer than ${rv.value} items`;
+        case 'equals':
+            return `${name} is ${rv.value}`;
+        case 'exists':
+            return `${name} exists`;
+        case 'not-exists':
+            return `${name} does not exist`;
+        default:
+            return `${name} is ${rv.value}`;
+    }
+}
+/**
+ * Check whether a resolved path has child entries in the fullToShortPathMap.
+ *
+ * When a lifecycle boolean (e.g., isLoadingAuditData) resolves to a parent path
+ * like fetch(...).functionCallReturnValue, and that path has children (like
+ * .json().functionCallReturnValue.topPaths), individual truthy/falsy flows on
+ * the parent are misleading. Compound flows with specific child requirements
+ * provide better guidance for mock data generation.
+ */
+function hasChildPathsInMap(resolvedPath, fullToShortPathMap) {
+    return Object.keys(fullToShortPathMap).some((fullPath) => fullPath.startsWith(resolvedPath + '.') ||
+        fullPath.startsWith(resolvedPath + '['));
+}
 /**
  * Extract the controllable base path from a path that may contain method calls.
  *
@@ -184,9 +251,10 @@ function extractControllableBase(path) {
  * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
  * The fullToShortPathMap maps full paths to short paths
  */
-function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
+export function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // Direct match in attributesMap (already a short path)
     if (path in attributesMap) {
+        console.log(`[findInAttributesMapForPath] "${path}" → DIRECT match in attributesMap`);
         return path;
     }
     // Try looking up the path in fullToShortPathMap to verify it's controllable
@@ -194,18 +262,22 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     if (path in fullToShortPathMap) {
         const shortPath = fullToShortPathMap[path];
         if (shortPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match: shortPath="${shortPath}" found in attributesMap`);
             return path; // Return FULL path to preserve data source context
         }
+        console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match shortPath="${shortPath}" but NOT in attributesMap`);
     }
     // Normalized match (array indices [N] → [])
     const normalizedPath = path.replace(/\[\d+\]/g, '[]');
     if (normalizedPath !== path) {
         if (normalizedPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" DIRECT match in attributesMap`);
             return normalizedPath;
         }
         if (normalizedPath in fullToShortPathMap) {
             const shortPath = fullToShortPathMap[normalizedPath];
             if (shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" fullToShortPathMap match: shortPath="${shortPath}"`);
                 return normalizedPath; // Return normalized FULL path
             }
         }
@@ -216,20 +288,70 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // and we need to find matching short path prefix
     for (const attrPath of Object.keys(attributesMap)) {
         if (path.startsWith(attrPath + '.') || path.startsWith(attrPath + '[')) {
-            // The path is a child of a known attribute path
+            console.log(`[findInAttributesMapForPath] "${path}" → PREFIX match: starts with attributesMap key "${attrPath}"`);
             return path;
         }
     }
     // Try suffix matching: if the path ends with ".X.Y.Z" and attributesMap has "X.Y.Z"
     // Return the FULL input path to preserve data source context
-    for (const attrPath of Object.keys(attributesMap)) {
-        if (path.endsWith('.' + attrPath) ||
-            path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
-            return path; // Return FULL path, not short attrPath
+    // Skip suffix matching for chained function calls (multiple .functionCallReturnValue segments)
+    // to avoid false matches: e.g., fetch(...).json().functionCallReturnValue.data falsely matching
+    // "data" from a completely different data source like useFetcher
+    const fnCallReturnValueCount = (path.match(/\.functionCallReturnValue/g) || []).length;
+    if (fnCallReturnValueCount <= 1) {
+        for (const attrPath of Object.keys(attributesMap)) {
+            if (path.endsWith('.' + attrPath) ||
+                path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
+                console.log(`[findInAttributesMapForPath] "${path}" → SUFFIX match: ends with attributesMap key "${attrPath}"`);
+                return path; // Return FULL path, not short attrPath
+            }
+        }
+    }
+    // Try child path matching against fullToShortPathMap keys
+    // If the path starts with a known full path + '.' or '[', it's a child
+    // of a controllable path. Build the equivalent short child path.
+    // e.g., path = "fetch(...).fCRV.json().fCRV.topPaths.length"
+    //   fullToShortPathMap has "fetch(...).fCRV.json().fCRV.topPaths" → "json().fCRV.topPaths"
+    //   → check if "json().fCRV.topPaths.length" is in attributesMap
+    for (const [fullPath, shortPath] of Object.entries(fullToShortPathMap)) {
+        if (path.startsWith(fullPath + '.') || path.startsWith(fullPath + '[')) {
+            const suffix = path.slice(fullPath.length); // e.g., ".length"
+            const shortChildPath = shortPath + suffix;
+            if (shortChildPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD of fullToShortPathMap key "${fullPath}": shortChildPath="${shortChildPath}" found in attributesMap`);
+                return path; // Return full path to preserve data source context
+            }
+            // Also check if the base short path is an array and suffix is .length
+            if (suffix === '.length' && shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD .length of fullToShortPathMap key "${fullPath}": base shortPath="${shortPath}" is in attributesMap (array .length)`);
+                return path; // Array .length is controllable via the array
+            }
+        }
+    }
+    // Try parent matching: if the path is a prefix of any fullToShortPathMap key,
+    // it's a parent of controllable data and therefore controllable itself
+    for (const fullPath of Object.keys(fullToShortPathMap)) {
+        if (fullPath.startsWith(path + '.') || fullPath.startsWith(path + '[')) {
+            console.log(`[findInAttributesMapForPath] "${path}" → PARENT match: fullToShortPathMap key "${fullPath}" starts with this path`);
+            return path;
         }
     }
+    console.log(`[findInAttributesMapForPath] "${path}" → NO MATCH (checked ${Object.keys(attributesMap).length} attributesMap keys, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap keys)`);
     return null;
 }
+/**
+ * Generate a slug from a path for use in flow IDs and exclusive groups.
+ */
+function pathToSlug(path) {
+    return path
+        .replace(/\[\d+\]/g, '')
+        .replace(/\[\]/g, '')
+        .replace(/\(\)/g, '')
+        .replace(/\.functionCallReturnValue/g, '')
+        .replace(/[<>]/g, '')
+        .replace(/\./g, '-')
+        .toLowerCase();
+}
 /**
  * Generate a human-readable name from a path.
  * Extracts the last meaningful part of the path.
@@ -419,7 +541,17 @@ function generateFlowFromCompound(compound, resolvedPaths) {
                 condition.requiredValue?.toString() ??
                     condition.comparedValues?.[0] ??
                     'truthy';
-            comparison = 'equals';
+            // Map comparison operator to flow comparison type
+            const op = condition.comparisonOperator;
+            if (op === '>' || op === '>=') {
+                comparison = 'length>';
+            }
+            else if (op === '<' || op === '<=') {
+                comparison = 'length<';
+            }
+            else {
+                comparison = 'equals';
+            }
         }
         requiredValues.push({
             attributePath: stripLengthSuffix(resolvedPath),
@@ -428,20 +560,28 @@ function generateFlowFromCompound(compound, resolvedPaths) {
             valueType: inferValueType(value),
         });
     }
-    // Generate a combined ID from all paths
-    const pathParts = requiredValues
+    // Remove contradictory "falsy" values where a child path requires data
+    const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+    if (cleanedValues.length === 0) {
+        return null;
+    }
+    // Generate a combined ID from all paths + values to distinguish different comparisons
+    const pathParts = cleanedValues
         .map((rv) => {
         const name = generateNameFromPath(rv.attributePath);
-        return name.toLowerCase().replace(/\s+/g, '-');
+        const suffix = rv.comparison === 'truthy' || rv.comparison === 'falsy'
+            ? `-${rv.comparison}`
+            : `-${rv.comparison}-${rv.value}`;
+        return name.toLowerCase().replace(/\s+/g, '-') + suffix;
     })
         .join('-and-');
     return {
         id: `compound-${pathParts}`,
-        name: requiredValues
+        name: cleanedValues
             .map((rv) => generateNameFromPath(rv.attributePath))
             .join(' + '),
-        description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
-        requiredValues,
+        description: `When ${cleanedValues.map((rv) => describeRequiredValue(rv)).join(' and ')}`,
+        requiredValues: cleanedValues,
         impact,
         sourceLocation: {
             lineNumber: compound.sourceLocation.lineNumber,
@@ -557,7 +697,11 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     }
     // Look up the child's equivalence for this root variable
     // e.g., childEquiv[selectedScenario] = "signature[0].selectedScenario"
-    const childPropPath = childEquivalentSignatureVariables[rootVar];
+    // Handle array case (OR expressions) - use first element if array
+    const rawChildPropPath = childEquivalentSignatureVariables[rootVar];
+    const childPropPath = Array.isArray(rawChildPropPath)
+        ? rawChildPropPath[0]
+        : rawChildPropPath;
     if (!childPropPath) {
         // No mapping found - this might be internal state, not a prop
         return null;
@@ -567,7 +711,11 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     const fullChildPropPath = `${childName}().${childPropPath}`;
     // Look up parent's equivalence to find what value was passed to this prop
     // e.g., parentEquiv["ChildName().signature[0].selectedScenario"] = "selectedScenario"
-    const parentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+    // Handle array case (OR expressions) - use first element if array
+    const rawParentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+    const parentValue = Array.isArray(rawParentValue)
+        ? rawParentValue[0]
+        : rawParentValue;
     if (!parentValue) {
         // No parent mapping found - log ALL parent keys that contain the childName
         const relevantParentKeys = Object.keys(parentEquivalentSignatureVariables).filter((k) => k.includes(childName));
@@ -579,9 +727,14 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     return result;
 }
 export default function generateExecutionFlowsFromConditionals(args) {
-    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, } = args;
+    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, sourceEquivalencies, } = args;
     const flows = [];
     const seenFlowIds = new Set();
+    console.log(`[genFlowsFromConditionals] INPUT: ${Object.keys(conditionalUsages).length} conditional paths, ${Object.keys(attributesMap).length} attributesMap entries, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap entries, ${Object.keys(equivalentSignatureVariables).length} equivSigVars, ${compoundConditionals.length} compound conditionals`);
+    console.log(`[genFlowsFromConditionals] conditionalUsages keys: [${Object.keys(conditionalUsages).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] attributesMap keys: [${Object.keys(attributesMap).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] fullToShortPathMap: ${JSON.stringify(fullToShortPathMap)}`);
+    console.log(`[genFlowsFromConditionals] equivalentSignatureVariables: ${JSON.stringify(equivalentSignatureVariables)}`);
     // Track normalized resolved paths to prevent duplicate flows
     // This handles the case where we have usages for both:
     // - "hasNewerVersion" (short path from destructured variable)
@@ -595,8 +748,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
         for (const usage of usages) {
             // Skip usages that are part of compound conditionals (handled separately)
             if (usage.chainId && compoundChainIds.has(usage.chainId)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: part of compound conditional chain=${usage.chainId}`);
                 continue;
             }
+            console.log(`[genFlowsFromConditionals] --- Processing "${usage.path}" (type=${usage.conditionType}, negated=${usage.isNegated}, sourceDataPath="${usage.sourceDataPath ?? '(none)'}", derivedFrom=${usage.derivedFrom ? JSON.stringify(usage.derivedFrom) : 'none'})`);
             // First, try to use pre-computed sourceDataPath if available
             let resolvedPath = null;
             if (usage.sourceDataPath) {
@@ -605,9 +760,11 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 // should become "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
                 // Returns null for malformed paths (e.g., chained function calls like fetch().json())
                 const cleanedPath = cleanSourceDataPath(usage.sourceDataPath);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" cleanSourceDataPath("${usage.sourceDataPath}") → "${cleanedPath}"`);
                 if (cleanedPath) {
                     // Verify the cleaned path exists in attributesMap
                     const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" findInAttributesMapForPath("${cleanedPath}") → ${pathMatch ? `"${pathMatch}"` : 'null (not found)'}`);
                     if (pathMatch) {
                         resolvedPath = pathMatch;
                     }
@@ -616,7 +773,9 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             // Fall back to resolution via equivalentSignatureVariables
             if (!resolvedPath) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" sourceDataPath resolution failed, trying resolvePathToControllable("${usage.path}")...`);
                 const resolution = resolvePathToControllable(usage.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" resolvePathToControllable → isControllable=${resolution.isControllable}, resolvedPath="${resolution.resolvedPath ?? '(none)'}"`);
                 if (resolution.isControllable && resolution.resolvedPath) {
                     resolvedPath = resolution.resolvedPath;
                 }
@@ -626,6 +785,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // where hasAnalysis is not in attributesMap but analysis is
             if (!resolvedPath && usage.derivedFrom) {
                 const { operation, sourcePath, sourcePaths, comparedValue } = usage.derivedFrom;
+                console.log(`[genFlowsFromConditionals] "${usage.path}" trying derivedFrom: operation=${operation}, sourcePath="${sourcePath ?? '(none)'}", sourcePaths=${sourcePaths ? JSON.stringify(sourcePaths) : '(none)'}, comparedValue="${comparedValue ?? '(none)'}"`);
                 // For single-source derivations (notNull, equals, etc.)
                 if (sourcePath) {
                     const resolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -871,6 +1031,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             if (!resolvedPath) {
                 // Path is not controllable - skip (no invalid flows possible)
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: not controllable (no resolvedPath after all attempts)`);
                 continue;
             }
             // Normalize the resolved path to detect duplicates
@@ -880,9 +1041,22 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // Skip if we've already generated flows for this normalized path
             // This prevents duplicate flows when we have usages for both short and full paths
             if (seenNormalizedPaths.has(normalizedPath)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: duplicate normalizedPath="${normalizedPath}" (resolvedPath="${resolvedPath}")`);
                 continue;
             }
             seenNormalizedPaths.add(normalizedPath);
+            // Skip individual truthy/falsy flows on parent paths that have child data entries.
+            // Lifecycle booleans (like isLoadingAuditData) traced to fetch(...).functionCallReturnValue
+            // produce misleading truthy/falsy flows: "truthy" can't show loading (mock resolves instantly),
+            // "falsy" tells the LLM to return null (breaking .json()). Compound flows with specific child
+            // data requirements provide the correct mock guidance.
+            if (usage.conditionType === 'truthiness' &&
+                resolvedPath &&
+                hasChildPathsInMap(resolvedPath, fullToShortPathMap)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: parent path "${resolvedPath}" has child data paths — compound flows will handle this`);
+                continue;
+            }
+            console.log(`[genFlowsFromConditionals] "${usage.path}" RESOLVED → resolvedPath="${resolvedPath}", normalizedPath="${normalizedPath}" — generating flows`);
             // Generate flows for this controllable usage
             const usageFlows = generateFlowsFromUsage(usage, resolvedPath);
             for (const flow of usageFlows) {
@@ -890,6 +1064,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 if (!seenFlowIds.has(flow.id)) {
                     seenFlowIds.add(flow.id);
                     flows.push(flow);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" FLOW ADDED: id="${flow.id}", requiredValues=${JSON.stringify(flow.requiredValues.map((rv) => ({ attr: rv.attributePath, val: rv.value })))}`);
                 }
             }
         }
@@ -925,19 +1100,57 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         resolvedPaths.set(condition.path, sources[0].path);
                     }
                     else {
-                        // Derived variable but no controllable sources found
-                        allControllable = false;
-                        break;
+                        // Derived variable expansion failed — try sourceDataPath fallback
+                        // This handles cases where the derivation chain goes through useMemo/useState
+                        // but the enriched sourceDataPath already traced to the actual data source
+                        const usageWithSource = usagesForPath?.find((u) => u.sourceDataPath);
+                        let derivedFallbackPath = null;
+                        if (usageWithSource?.sourceDataPath) {
+                            const cleanedPath = cleanSourceDataPath(usageWithSource.sourceDataPath);
+                            if (cleanedPath) {
+                                const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                                if (pathMatch) {
+                                    derivedFallbackPath = pathMatch;
+                                }
+                            }
+                        }
+                        if (derivedFallbackPath) {
+                            resolvedPaths.set(condition.path, derivedFallbackPath);
+                            console.log(`[genFlowsFromConditionals] COMPOUND "${condition.path}" derived expansion failed but sourceDataPath fallback resolved → "${derivedFallbackPath}"`);
+                        }
+                        else {
+                            // Truly not controllable
+                            console.log(`[genFlowsFromConditionals] COMPOUND "${condition.path}" derived but no controllable sources and no sourceDataPath fallback → NOT controllable`);
+                            allControllable = false;
+                            break;
+                        }
                     }
                 }
                 else {
                     // Not a derived variable - resolve directly
-                    const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-                    if (!resolution.isControllable || !resolution.resolvedPath) {
+                    // First try sourceDataPath from the usage (same as individual processing)
+                    let compoundResolvedPath = null;
+                    const usageWithSource = usagesForPath?.find((u) => u.sourceDataPath);
+                    if (usageWithSource?.sourceDataPath) {
+                        const cleanedPath = cleanSourceDataPath(usageWithSource.sourceDataPath);
+                        if (cleanedPath) {
+                            const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                            if (pathMatch) {
+                                compoundResolvedPath = pathMatch;
+                            }
+                        }
+                    }
+                    if (!compoundResolvedPath) {
+                        const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        if (resolution.isControllable && resolution.resolvedPath) {
+                            compoundResolvedPath = resolution.resolvedPath;
+                        }
+                    }
+                    if (!compoundResolvedPath) {
                         allControllable = false;
                         break;
                     }
-                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                    resolvedPaths.set(condition.path, compoundResolvedPath);
                 }
             }
             // Only create a flow if ALL paths are controllable
@@ -1010,7 +1223,16 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                         condition.requiredValue?.toString() ??
                                             condition.comparedValues?.[0] ??
                                             'truthy';
-                                    comparison = 'equals';
+                                    const op = condition.comparisonOperator;
+                                    if (op === '>' || op === '>=') {
+                                        comparison = 'length>';
+                                    }
+                                    else if (op === '<' || op === '<=') {
+                                        comparison = 'length<';
+                                    }
+                                    else {
+                                        comparison = 'equals';
+                                    }
                                 }
                                 requiredValues.push({
                                     attributePath: stripLengthSuffix(resolvedPath),
@@ -1021,21 +1243,26 @@ export default function generateExecutionFlowsFromConditionals(args) {
                             }
                         }
                     }
-                    if (requiredValues.length > 0) {
+                    // Remove contradictory "falsy" values where a child path requires data
+                    const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+                    if (cleanedValues.length > 0) {
                         const impact = compound.controlsJsxRendering ? 'high' : 'medium';
-                        // Generate a combined ID from all paths
-                        const pathParts = requiredValues
+                        // Generate a combined ID from all paths + values
+                        const pathParts = cleanedValues
                             .map((rv) => {
                             const name = generateNameFromPath(rv.attributePath);
-                            return name.toLowerCase().replace(/\s+/g, '-');
+                            const suffix = rv.comparison === 'truthy' || rv.comparison === 'falsy'
+                                ? `-${rv.comparison}`
+                                : `-${rv.comparison}-${rv.value}`;
+                            return name.toLowerCase().replace(/\s+/g, '-') + suffix;
                         })
                             .join('-and-');
                         const compoundFlow = {
-                            id: `${pathParts}-${requiredValues.map((rv) => rv.value).join('-')}`,
-                            name: generateNameFromPath(requiredValues[0].attributePath),
-                            description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
+                            id: `${pathParts}`,
+                            name: generateNameFromPath(cleanedValues[0].attributePath),
+                            description: `When ${cleanedValues.map((rv) => describeRequiredValue(rv)).join(' and ')}`,
                             impact,
-                            requiredValues,
+                            requiredValues: cleanedValues,
                             sourceLocation: compound.sourceLocation,
                         };
                         if (!seenFlowIds.has(compoundFlow.id)) {
@@ -1195,8 +1422,6 @@ export default function generateExecutionFlowsFromConditionals(args) {
             const childCompoundChainIds = new Set(childData.compoundConditionals.map((c) => c.chainId).filter(Boolean));
             for (const [_path, usages] of Object.entries(childData.conditionalUsages)) {
                 for (const usage of usages) {
-                    // Debug logging (disabled - set to true for troubleshooting child flow resolution)
-                    const shouldDebugChild = false;
                     // Skip usages that are part of compound conditionals (handled separately)
                     // Fix 33: Only skip if the chainId is in the child's compound conditionals
                     if (usage.chainId && childCompoundChainIds.has(usage.chainId)) {
@@ -1208,43 +1433,23 @@ export default function generateExecutionFlowsFromConditionals(args) {
                     if (usage.derivedFrom?.sourcePath) {
                         childPath = usage.derivedFrom.sourcePath;
                     }
-                    if (shouldDebugChild) {
-                        console.log(`[DEBUG CHILD ${childName}] Processing usage path: ${usage.path}`);
-                        console.log(`[DEBUG CHILD ${childName}]   childPath (after derivedFrom): ${childPath}`);
-                        console.log(`[DEBUG CHILD ${childName}]   sourceDataPath: ${usage.sourceDataPath}`);
-                    }
                     // Translate the child path to a parent path
                     let translatedPath = translateChildPathToParent(childPath, childData.equivalentSignatureVariables, equivalentSignatureVariables, childName);
-                    if (shouldDebugChild) {
-                        console.log(`[DEBUG CHILD ${childName}]   translatedPath (from translateChildPathToParent): ${translatedPath}`);
-                    }
                     // If translation failed but we have sourceDataPath, try to extract the prop path from it
                     // sourceDataPath format: "ChildName.signature[n].propPath.rest" → extract "propPath.rest"
                     if (!translatedPath && usage.sourceDataPath) {
                         const signatureMatch = usage.sourceDataPath.match(/\.signature\[\d+\]\.(.+)$/);
                         if (signatureMatch) {
                             translatedPath = signatureMatch[1];
-                            if (shouldDebugChild) {
-                                console.log(`[DEBUG CHILD ${childName}]   translatedPath (from sourceDataPath regex): ${translatedPath}`);
-                            }
                         }
                     }
                     if (!translatedPath) {
                         // Could not translate - skip this usage
-                        if (shouldDebugChild) {
-                            console.log(`[DEBUG CHILD ${childName}]   SKIPPED - no translation found`);
-                        }
                         continue;
                     }
                     // Now resolve the translated path in the parent context
                     // First, try standard resolution
                     const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-                    if (shouldDebugChild) {
-                        console.log(`[DEBUG CHILD ${childName}]   resolvePathToControllable result:`);
-                        console.log(`[DEBUG CHILD ${childName}]     isControllable: ${resolution.isControllable}`);
-                        console.log(`[DEBUG CHILD ${childName}]     resolvedPath: ${resolution.resolvedPath}`);
-                        console.log(`[DEBUG CHILD ${childName}]     chain: ${resolution.resolutionChain.join(' -> ')}`);
-                    }
                     // Only create flows for controllable paths (whitelist approach).
                     // If the path doesn't resolve to something in attributesMap, skip it.
                     // This prevents creating flows for useState values which are not
@@ -1271,19 +1476,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     break;
                                 }
                             }
-                            if (shouldDebugChild) {
-                                console.log(`[DEBUG CHILD ${childName}]   useState fallback: looking for URL param`);
-                                console.log(`[DEBUG CHILD ${childName}]     useStatePattern: ${useStatePattern}`);
-                                console.log(`[DEBUG CHILD ${childName}]     useStateVarName: ${useStateVarName}`);
-                            }
                             if (useStateVarName) {
                                 // Look for a related URL param like "varNameFromUrl"
                                 const urlParamName = `${useStateVarName}FromUrl`;
                                 const urlParamPath = equivalentSignatureVariables[urlParamName];
-                                if (shouldDebugChild) {
-                                    console.log(`[DEBUG CHILD ${childName}]     urlParamName: ${urlParamName}`);
-                                    console.log(`[DEBUG CHILD ${childName}]     urlParamPath: ${urlParamPath}`);
-                                }
                                 if (urlParamPath) {
                                     // For useState values initialized from URL params, use the
                                     // URL param variable name directly (e.g., "viewModeFromUrl")
@@ -1294,26 +1490,58 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     // The flow will use the URL param name as the attributePath,
                                     // which gets properly resolved when generating mock data.
                                     resolvedPath = urlParamName;
-                                    if (shouldDebugChild) {
-                                        console.log(`[DEBUG CHILD ${childName}]   useState fallback SUCCESS: using URL param name ${resolvedPath}`);
+                                }
+                            }
+                        }
+                        // Fallback 2: Try sourceEquivalencies to find the actual data source
+                        // This handles the case where props flow through useState but originate
+                        // from a mockable data source (e.g., API call, fetcher).
+                        //
+                        // Example: WorkoutsView receives `workouts` prop which in parent is stored
+                        // in useState, but ultimately comes from a Supabase query.
+                        // sourceEquivalencies tells us: "WorkoutsView().signature[0].workouts" → "createClient()...data"
+                        if (!resolvedPath && sourceEquivalencies) {
+                            // Build the child prop path to look up in sourceEquivalencies
+                            // Format: "ChildName().signature[0].propName"
+                            // First, find what prop this child path maps to
+                            let childPropName = null;
+                            for (const [varName, varPath] of Object.entries(childData.equivalentSignatureVariables)) {
+                                // Check if childPath starts with this variable name
+                                // e.g., childPath = "workouts.length", varName = "workouts", varPath = "signature[0].workouts"
+                                if (childPath === varName ||
+                                    childPath.startsWith(`${varName}.`)) {
+                                    childPropName = varName;
+                                    break;
+                                }
+                            }
+                            if (childPropName) {
+                                // Build the full sourceEquivalencies key
+                                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+                                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+                                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                                    const dataSourcePath = sourceEquivEntry[0].schemaPath;
+                                    // Check if this data source path is controllable
+                                    const dataSourceResolution = resolvePathToControllable(dataSourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                                    if (dataSourceResolution.isControllable &&
+                                        dataSourceResolution.resolvedPath) {
+                                        // Preserve any suffix from the child path
+                                        // e.g., childPath = "workouts.length" → suffix = ".length"
+                                        const suffix = childPath.startsWith(`${childPropName}.`)
+                                            ? childPath.slice(childPropName.length)
+                                            : '';
+                                        resolvedPath = dataSourceResolution.resolvedPath + suffix;
                                     }
                                 }
                             }
                         }
                         // If still not resolved after fallback, skip
                         if (!resolvedPath) {
-                            if (shouldDebugChild) {
-                                console.log(`[DEBUG CHILD ${childName}]   SKIPPED - path not controllable`);
-                            }
                             continue;
                         }
                     }
                     // Check for duplicates
                     const normalizedPath = normalizePathForDeduplication(resolvedPath, fullToShortPathMap);
                     if (seenNormalizedPaths.has(normalizedPath)) {
-                        if (shouldDebugChild) {
-                            console.log(`[DEBUG CHILD ${childName}]   SKIPPED - duplicate normalized path: ${normalizedPath}`);
-                        }
                         continue;
                     }
                     seenNormalizedPaths.add(normalizedPath);
@@ -1324,12 +1552,6 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         path: resolvedPath,
                     };
                     const usageFlows = generateFlowsFromUsage(translatedUsage, resolvedPath);
-                    if (shouldDebugChild) {
-                        console.log(`[DEBUG CHILD ${childName}]   GENERATING ${usageFlows.length} flows with resolvedPath: ${resolvedPath}`);
-                        for (const f of usageFlows) {
-                            console.log(`[DEBUG CHILD ${childName}]     - Flow ID: ${f.id}, path: ${f.requiredValues[0]?.attributePath}`);
-                        }
-                    }
                     // Add gating conditions to each flow
                     for (const flow of usageFlows) {
                         // Add gating required values to the flow
@@ -1433,8 +1655,153 @@ export default function generateExecutionFlowsFromConditionals(args) {
                     }
                 }
             }
+            // Process child's jsxRenderingUsages (array.map flows)
+            // This generates array variation flows (empty, few, many) for arrays rendered in child
+            if (childData.jsxRenderingUsages) {
+                for (const jsxUsage of childData.jsxRenderingUsages) {
+                    // Translate the child path to a parent path
+                    const translatedPath = translateChildPathToParent(jsxUsage.path, childData.equivalentSignatureVariables, equivalentSignatureVariables, childName);
+                    if (!translatedPath) {
+                        continue;
+                    }
+                    // Resolve to controllable path in parent context
+                    const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                    let resolvedPath = resolution.resolvedPath;
+                    // Try sourceEquivalencies fallback if not controllable
+                    if (!resolution.isControllable || !resolvedPath) {
+                        if (sourceEquivalencies) {
+                            // Build the sourceEquivalencies key
+                            // The child path (e.g., "workouts") maps to a prop path (e.g., "signature[0].workouts")
+                            let childPropName = null;
+                            for (const [varName, varPath] of Object.entries(childData.equivalentSignatureVariables)) {
+                                if (jsxUsage.path === varName ||
+                                    jsxUsage.path.startsWith(`${varName}.`)) {
+                                    childPropName = varName;
+                                    break;
+                                }
+                            }
+                            if (childPropName) {
+                                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+                                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+                                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                                    const dataSourcePath = sourceEquivEntry[0].schemaPath;
+                                    const dataSourceResolution = resolvePathToControllable(dataSourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                                    if (dataSourceResolution.isControllable &&
+                                        dataSourceResolution.resolvedPath) {
+                                        resolvedPath = dataSourceResolution.resolvedPath;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (!resolvedPath) {
+                        continue;
+                    }
+                    // Check for duplicates
+                    const normalizedPath = normalizePathForDeduplication(resolvedPath, fullToShortPathMap);
+                    const dedupeKey = `${normalizedPath}:${jsxUsage.renderingType}`;
+                    if (seenNormalizedPaths.has(dedupeKey)) {
+                        continue;
+                    }
+                    seenNormalizedPaths.add(dedupeKey);
+                    // Generate array variation flows for array-map rendering
+                    if (jsxUsage.renderingType === 'array-map') {
+                        const baseName = generateNameFromPath(resolvedPath);
+                        const pathSlug = pathToSlug(resolvedPath);
+                        const exclusiveGroup = `array-length-${pathSlug}`;
+                        // Empty array flow
+                        const emptyFlow = {
+                            id: `${pathSlug}-empty-array`,
+                            name: `${baseName} Empty`,
+                            description: `When ${baseName.toLowerCase()} array is empty`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '0',
+                                    comparison: 'length<',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'medium',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(emptyFlow.id)) {
+                            seenFlowIds.add(emptyFlow.id);
+                            flows.push(emptyFlow);
+                        }
+                        // Few items flow (1-3)
+                        const fewFlow = {
+                            id: `${pathSlug}-few-items`,
+                            name: `${baseName} Few Items`,
+                            description: `When ${baseName.toLowerCase()} array has 1-3 items`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '3',
+                                    comparison: 'length<',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'low',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(fewFlow.id)) {
+                            seenFlowIds.add(fewFlow.id);
+                            flows.push(fewFlow);
+                        }
+                        // Many items flow (10+)
+                        const manyFlow = {
+                            id: `${pathSlug}-many-items`,
+                            name: `${baseName} Many Items`,
+                            description: `When ${baseName.toLowerCase()} array has many items`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '10',
+                                    comparison: 'length>',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'low',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(manyFlow.id)) {
+                            seenFlowIds.add(manyFlow.id);
+                            flows.push(manyFlow);
+                        }
+                    }
+                }
+            }
         }
     }
+    console.log(`[genFlowsFromConditionals] RESULT: ${flows.length} total flows generated`);
+    for (const flow of flows) {
+        console.log(`[genFlowsFromConditionals] FLOW: id="${flow.id}" requiredValues=[${flow.requiredValues.map((rv) => `${rv.attributePath}=${rv.value}`).join(', ')}]`);
+    }
     return flows;
 }
 //# sourceMappingURL=generateExecutionFlowsFromConditionals.js.map