@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.2a88920

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

@@ -12,6 +12,78 @@
  * - compound conditionals → one flow with all conditions (only if ALL paths controllable)
  */
 import resolvePathToControllable from "./resolvePathToControllable.js";
+import cleanPathOfNonTransformingFunctions from "./dataStructure/helpers/cleanPathOfNonTransformingFunctions.js";
+/**
+ * Recursively expands a derived variable to its leaf data sources.
+ *
+ * For OR expressions like `isAnalyzing = a || b || c`:
+ * - Returns all source paths [a, b, c] so they can all be set appropriately
+ *
+ * For nested derivations like `isAnalyzing = isInCurrentRun || isInQueue`:
+ * - Where `isInCurrentRun` is derived from `currentRun.entityShas.includes(x)`
+ * - Returns the final data sources: [currentRun.entityShas, queueState.jobs]
+ *
+ * @param path The variable path to expand
+ * @param conditionalUsages All conditional usages (to look up derivedFrom info)
+ * @param attributesMap Map of controllable paths
+ * @param equivalentSignatureVariables Variable-to-path mappings
+ * @param fullToShortPathMap Full-to-short path mappings
+ * @param visited Set of already-visited paths (prevents infinite recursion)
+ * @param derivedVariables Optional map of all derived variables (for intermediate tracing)
+ * @returns Array of resolved source paths that are controllable
+ */
+function expandDerivedVariableToSources(path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited = new Set(), derivedVariables) {
+    // Prevent infinite recursion
+    if (visited.has(path)) {
+        return [];
+    }
+    visited.add(path);
+    // First, check if this path is directly controllable
+    const directResolution = resolvePathToControllable(path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+    if (directResolution.isControllable && directResolution.resolvedPath) {
+        return [{ path: directResolution.resolvedPath }];
+    }
+    // Look up derivedFrom info for this path
+    // First check conditionalUsages, then fall back to derivedVariables
+    const usage = conditionalUsages[path]?.[0];
+    let derivedFrom = usage?.derivedFrom;
+    // CRITICAL: If not found in conditionalUsages, check derivedVariables
+    // This handles intermediate derived variables like `isInCurrentRun` that aren't
+    // directly used in conditionals but ARE derived from data sources
+    if (!derivedFrom && derivedVariables?.[path]) {
+        derivedFrom = derivedVariables[path];
+    }
+    if (!derivedFrom) {
+        return [];
+    }
+    const { operation, sourcePath, sourcePaths } = derivedFrom;
+    // For OR/AND operations, recursively expand all source paths
+    if ((operation === 'or' || operation === 'and') && sourcePaths) {
+        const allSources = [];
+        for (const sp of sourcePaths) {
+            const expanded = expandDerivedVariableToSources(sp, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+            // Add all expanded sources
+            for (const source of expanded) {
+                // Avoid duplicates
+                if (!allSources.some((s) => s.path === source.path)) {
+                    allSources.push(source);
+                }
+            }
+        }
+        return allSources;
+    }
+    // For single-source operations (arrayIncludes, arraySome, notNull, etc.)
+    if (sourcePath) {
+        // Try to resolve the source path directly
+        const sourceResolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+        if (sourceResolution.isControllable && sourceResolution.resolvedPath) {
+            return [{ path: sourceResolution.resolvedPath, operation }];
+        }
+        // If not directly resolvable, recursively expand
+        return expandDerivedVariableToSources(sourcePath, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+    }
+    return [];
+}
 /**
  * Clean up sourceDataPath by removing redundant scope prefixes.
  *
@@ -59,6 +131,47 @@ function cleanSourceDataPath(sourceDataPath) {
     }
     return actualPath;
 }
+/**
+ * Strip .length suffix from a path if present.
+ *
+ * When we have a path like "items.length", the controllable attribute is "items"
+ * (the array), not "items.length". The length is derived from the array contents.
+ *
+ * This ensures that execution flows reference the actual controllable attribute
+ * rather than the derived .length property.
+ */
+function stripLengthSuffix(path) {
+    if (path.endsWith('.length')) {
+        return path.slice(0, -7); // Remove ".length" (7 characters)
+    }
+    return path;
+}
+/**
+ * Extract the controllable base path from a path that may contain method calls.
+ *
+ * This handles complex expressions like:
+ * - `scenarios.filter((s) => s.active).length` → `scenarios`
+ * - `users.some((u) => u.role === 'admin')` → `users`
+ * - `items.map(x => x.name).join(', ')` → `items`
+ *
+ * The controllable base is the path that can be mocked - we can control
+ * what `scenarios` contains, but we can't control what `.filter()` returns.
+ *
+ * @param path - The path that may contain method calls
+ * @returns The controllable base path with method calls stripped
+ */
+function extractControllableBase(path) {
+    // First strip .length suffix if present
+    const pathWithoutLength = stripLengthSuffix(path);
+    // Use cleanPathOfNonTransformingFunctions to strip method calls like .filter(), .some()
+    const cleanedPath = cleanPathOfNonTransformingFunctions(pathWithoutLength);
+    // If the cleaned path is different, return it
+    if (cleanedPath !== pathWithoutLength) {
+        return cleanedPath;
+    }
+    // Otherwise, return the path with just .length stripped
+    return pathWithoutLength;
+}
 /**
  * Find a path in attributesMap, using fullToShortPathMap to verify the path is controllable.
  *
@@ -117,6 +230,19 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     }
     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.
@@ -173,6 +299,12 @@ function inferValueType(value) {
 /**
  * Generate flows from a single conditional usage.
  * Sets impact to 'high' if the conditional controls JSX rendering.
+ *
+ * When the usage has a `constraintExpression`, it represents a complex expression
+ * that can't be simply resolved (e.g., `scenarios.filter(x => x.active).length > 1`).
+ * In this case:
+ * - `attributePath` is set to the controllable base (e.g., `scenarios`)
+ * - `constraint` is set to the full expression for LLM reasoning
  */
 function generateFlowsFromUsage(usage, resolvedPath) {
     const flows = [];
@@ -182,6 +314,13 @@ function generateFlowsFromUsage(usage, resolvedPath) {
     const impact = usage.controlsJsxRendering
         ? 'high'
         : 'medium';
+    // When there's a constraintExpression, use the controllable base for attributePath
+    // and pass through the constraint for LLM reasoning
+    const hasConstraint = !!usage.constraintExpression;
+    const attributePath = hasConstraint
+        ? extractControllableBase(resolvedPath)
+        : stripLengthSuffix(resolvedPath);
+    const constraint = usage.constraintExpression;
     if (usage.conditionType === 'truthiness') {
         // Generate both truthy and falsy flows
         const isNegated = usage.isNegated ?? false;
@@ -192,10 +331,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
             description: `When ${baseName.toLowerCase()} is ${isNegated ? 'falsy' : 'truthy'}`,
             requiredValues: [
                 {
-                    attributePath: resolvedPath,
+                    attributePath,
                     value: isNegated ? 'falsy' : 'truthy',
                     comparison: isNegated ? 'falsy' : 'truthy',
                     valueType: 'boolean',
+                    constraint,
                 },
             ],
             impact,
@@ -214,10 +354,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
             description: `When ${baseName.toLowerCase()} is ${isNegated ? 'truthy' : 'falsy'}`,
             requiredValues: [
                 {
-                    attributePath: resolvedPath,
+                    attributePath,
                     value: isNegated ? 'truthy' : 'falsy',
                     comparison: isNegated ? 'truthy' : 'falsy',
                     valueType: 'boolean',
+                    constraint,
                 },
             ],
             impact,
@@ -241,10 +382,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
                 description: `When ${baseName.toLowerCase()} equals "${value}"`,
                 requiredValues: [
                     {
-                        attributePath: resolvedPath,
+                        attributePath,
                         value: value,
                         comparison: 'equals',
                         valueType: inferValueType(value),
+                        constraint,
                     },
                 ],
                 impact,
@@ -293,7 +435,7 @@ function generateFlowFromCompound(compound, resolvedPaths) {
             comparison = 'equals';
         }
         requiredValues.push({
-            attributePath: resolvedPath,
+            attributePath: stripLengthSuffix(resolvedPath),
             value,
             comparison,
             valueType: inferValueType(value),
@@ -321,6 +463,48 @@ function generateFlowFromCompound(compound, resolvedPaths) {
         codeSnippet: compound.sourceLocation.codeSnippet,
     };
 }
+/**
+ * Expand a compound conditional with OR groups into multiple condition sets.
+ *
+ * For a compound like `A && (B || C)`:
+ * - Conditions: [{ path: 'A' }, { path: 'B', orGroupId: 'or_xxx' }, { path: 'C', orGroupId: 'or_xxx' }]
+ * - Returns: [[A, B], [A, C]] - two sets of conditions
+ *
+ * For multiple OR groups like `A && (B || C) && (D || E)`:
+ * - Returns: [[A, B, D], [A, B, E], [A, C, D], [A, C, E]]
+ */
+function expandOrGroups(conditions) {
+    // Separate conditions into mandatory (no orGroupId) and OR groups
+    const mandatory = conditions.filter((c) => !c.orGroupId);
+    const orGroups = new Map();
+    for (const condition of conditions) {
+        if (condition.orGroupId) {
+            const group = orGroups.get(condition.orGroupId) ?? [];
+            group.push(condition);
+            orGroups.set(condition.orGroupId, group);
+        }
+    }
+    // If no OR groups, return the original conditions
+    if (orGroups.size === 0) {
+        return [conditions];
+    }
+    // Generate all combinations by picking one condition from each OR group
+    const groupArrays = Array.from(orGroups.values());
+    const combinations = [];
+    function generateCombinations(index, current) {
+        if (index === groupArrays.length) {
+            // We've picked one from each OR group - combine with mandatory conditions
+            combinations.push([...mandatory, ...current]);
+            return;
+        }
+        // Pick each option from the current OR group
+        for (const option of groupArrays[index]) {
+            generateCombinations(index + 1, [...current, option]);
+        }
+    }
+    generateCombinations(0, []);
+    return combinations;
+}
 /**
  * Generate execution flows from conditional usages using pure static analysis.
  *
@@ -386,7 +570,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;
@@ -396,7 +584,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));
@@ -408,7 +600,7 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     return result;
 }
 export default function generateExecutionFlowsFromConditionals(args) {
-    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, } = args;
+    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, sourceEquivalencies, } = args;
     const flows = [];
     const seenFlowIds = new Set();
     // Track normalized resolved paths to prevent duplicate flows
@@ -454,7 +646,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // This handles cases like: const hasAnalysis = analysis !== null
             // where hasAnalysis is not in attributesMap but analysis is
             if (!resolvedPath && usage.derivedFrom) {
-                const { sourcePath, sourcePaths } = usage.derivedFrom;
+                const { operation, sourcePath, sourcePaths, comparedValue } = usage.derivedFrom;
                 // For single-source derivations (notNull, equals, etc.)
                 if (sourcePath) {
                     const resolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -462,8 +654,232 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         resolvedPath = resolution.resolvedPath;
                     }
                 }
-                // For multi-source derivations (or, and), try the first resolvable path
-                // This is a simplification - ideally we'd generate flows for each source
+                // For equals/notEquals derivations with comparedValue, generate comparison flows
+                // e.g., canEdit derived from user.role === 'admin'
+                // When canEdit is used in truthiness check, we need:
+                // - Truthy flow: user.role = 'admin' (comparison: 'equals')
+                // - Falsy flow: user.role != 'admin' (comparison: 'notEquals')
+                if ((operation === 'equals' || operation === 'notEquals') &&
+                    comparedValue !== undefined &&
+                    resolvedPath &&
+                    usage.conditionType === 'truthiness') {
+                    const baseName = generateNameFromPath(usage.path);
+                    const impact = usage.controlsJsxRendering
+                        ? 'high'
+                        : 'medium';
+                    const isNegated = usage.isNegated ?? false;
+                    // For equals derivation:
+                    // - Truthy check (!negated): needs value = comparedValue (equals)
+                    // - Falsy check (negated): needs value != comparedValue (notEquals)
+                    // For notEquals derivation: inverse of above
+                    const isEqualsDerivation = operation === 'equals';
+                    const truthyNeedsEquals = isEqualsDerivation !== isNegated;
+                    // Generate truthy flow
+                    const truthyFlow = {
+                        id: generateFlowId(usage.path, 'truthy'),
+                        name: `${baseName} True`,
+                        description: `When ${baseName.toLowerCase()} is truthy (${resolvedPath} ${truthyNeedsEquals ? '=' : '!='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'equals' : 'notEquals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Generate falsy flow
+                    const falsyFlow = {
+                        id: generateFlowId(usage.path, 'falsy'),
+                        name: `${baseName} False`,
+                        description: `When ${baseName.toLowerCase()} is falsy (${resolvedPath} ${truthyNeedsEquals ? '!=' : '='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'notEquals' : 'equals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Add flows and skip normal flow generation
+                    if (!seenFlowIds.has(truthyFlow.id)) {
+                        seenFlowIds.add(truthyFlow.id);
+                        flows.push(truthyFlow);
+                    }
+                    if (!seenFlowIds.has(falsyFlow.id)) {
+                        seenFlowIds.add(falsyFlow.id);
+                        flows.push(falsyFlow);
+                    }
+                    continue;
+                }
+                // For OR derivations with negation, we need ALL sources to be falsy
+                // e.g., !isBusy where isBusy = isRunning || isQueued || isPending
+                // For the falsy flow, ALL sources must be falsy
+                if (operation === 'or' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated === true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to falsy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'falsy',
+                            comparison: 'falsy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a single falsy flow with all sources
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy (all sources are falsy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a truthy flow - for OR, ANY source being truthy is sufficient
+                        // We use the first resolvable source for the truthy flow
+                        const firstSource = allSources[0];
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'truthy',
+                                    comparison: 'truthy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (falsy needs all sources, truthy needs one)
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For AND derivations without negation, we need ALL sources to be truthy
+                // e.g., isReady where isReady = hasData && isLoaded && isValid
+                // For the truthy flow, ALL sources must be truthy
+                // For negated AND (!isReady), ANY source being falsy is sufficient (fallback behavior)
+                if (operation === 'and' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated !== true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to truthy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'truthy',
+                            comparison: 'truthy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a truthy flow with all sources
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy (all sources are truthy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a falsy flow - for AND, ANY source being falsy is sufficient
+                        // We use the first resolvable source for the falsy flow
+                        const firstSource = allSources[0];
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'falsy',
+                                    comparison: 'falsy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (truthy needs all sources, falsy needs one)
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For multi-source derivations (or, and) without special handling,
+                // try the first resolvable path as a fallback
                 if (!resolvedPath && sourcePaths && sourcePaths.length > 0) {
                     for (const sp of sourcePaths) {
                         const resolution = resolvePathToControllable(sp, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -501,23 +917,167 @@ export default function generateExecutionFlowsFromConditionals(args) {
     }
     // Process compound conditionals
     for (const compound of compoundConditionals) {
-        // First, check if ALL paths in this compound are controllable
-        const resolvedPaths = new Map();
-        let allControllable = true;
-        for (const condition of compound.conditions) {
-            const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-            if (!resolution.isControllable || !resolution.resolvedPath) {
-                allControllable = false;
-                break;
+        // Expand OR groups into separate condition sets
+        // For example, `A && (B || C)` becomes [[A, B], [A, C]]
+        const expandedConditionSets = expandOrGroups(compound.conditions);
+        // Process each expanded condition set as a separate potential flow
+        for (const conditionSet of expandedConditionSets) {
+            // First, check if ALL paths in this condition set are controllable (or can be expanded to controllable sources)
+            const resolvedPaths = new Map();
+            // Track expanded sources for derived variables (path -> array of expanded sources)
+            const expandedSources = new Map();
+            let allControllable = true;
+            for (const condition of conditionSet) {
+                // Check if this condition path has derivation info
+                // First check conditionalUsages, then fall back to derivedVariables
+                const usagesForPath = conditionalUsages[condition.path];
+                let derivedFromInfo = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                // CRITICAL: Also check derivedVariables for intermediate derived variables
+                if (!derivedFromInfo && derivedVariables?.[condition.path]) {
+                    derivedFromInfo = derivedVariables[condition.path];
+                }
+                if (derivedFromInfo) {
+                    // This is a derived variable - expand to its sources
+                    const sources = expandDerivedVariableToSources(condition.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (sources.length > 0) {
+                        // Store the expanded sources for this condition
+                        expandedSources.set(condition.path, sources);
+                        // Use the first source's path for the resolvedPaths map (for ID generation)
+                        resolvedPaths.set(condition.path, sources[0].path);
+                    }
+                    else {
+                        // Derived variable but no controllable sources found
+                        allControllable = false;
+                        break;
+                    }
+                }
+                else {
+                    // Not a derived variable - resolve directly
+                    const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                    if (!resolution.isControllable || !resolution.resolvedPath) {
+                        allControllable = false;
+                        break;
+                    }
+                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                }
             }
-            resolvedPaths.set(condition.path, resolution.resolvedPath);
-        }
-        // Only create a flow if ALL paths are controllable
-        if (allControllable && resolvedPaths.size > 0) {
-            const compoundFlow = generateFlowFromCompound(compound, resolvedPaths);
-            if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
-                seenFlowIds.add(compoundFlow.id);
-                flows.push(compoundFlow);
+            // Only create a flow if ALL paths are controllable
+            if (allControllable && resolvedPaths.size > 0) {
+                // If any conditions were expanded from derived variables, we need to build a custom flow
+                if (expandedSources.size > 0) {
+                    const requiredValues = [];
+                    for (const condition of conditionSet) {
+                        const sources = expandedSources.get(condition.path);
+                        if (sources) {
+                            // This condition was expanded - add all its sources
+                            // Determine the required value based on condition type and derivation operation
+                            const usagesForPath = conditionalUsages[condition.path];
+                            let expandedDerivedFrom = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                            // Also check derivedVariables for intermediate derived variables
+                            if (!expandedDerivedFrom && derivedVariables?.[condition.path]) {
+                                expandedDerivedFrom = derivedVariables[condition.path];
+                            }
+                            const operation = expandedDerivedFrom?.operation;
+                            for (const source of sources) {
+                                // For OR-derived truthy: ANY source truthy
+                                // For AND-derived truthy: ALL sources truthy
+                                // For negated: inverse
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    const isNegated = condition.isNegated === true;
+                                    // For OR: truthy needs ANY source truthy, falsy needs ALL sources falsy
+                                    // For AND: truthy needs ALL sources truthy, falsy needs ANY source falsy
+                                    // In compound conditionals, we generate the truthy path by default
+                                    // (the compound expression must be truthy)
+                                    if (operation === 'or') {
+                                        // For OR-derived, truthy means we need at least one source truthy
+                                        // We'll use the first source as truthy (simplification)
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else if (operation === 'and') {
+                                        // For AND-derived, truthy means ALL sources truthy
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else {
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    comparison = isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value = 'truthy';
+                                    comparison = 'truthy';
+                                }
+                                requiredValues.push({
+                                    attributePath: source.path,
+                                    value,
+                                    comparison,
+                                    valueType: 'boolean',
+                                });
+                            }
+                        }
+                        else {
+                            // This condition was resolved directly
+                            const resolvedPath = resolvedPaths.get(condition.path);
+                            if (resolvedPath) {
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    value = condition.isNegated ? 'falsy' : 'truthy';
+                                    comparison = condition.isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value =
+                                        condition.requiredValue?.toString() ??
+                                            condition.comparedValues?.[0] ??
+                                            'truthy';
+                                    comparison = 'equals';
+                                }
+                                requiredValues.push({
+                                    attributePath: stripLengthSuffix(resolvedPath),
+                                    value,
+                                    comparison,
+                                    valueType: inferValueType(value),
+                                });
+                            }
+                        }
+                    }
+                    if (requiredValues.length > 0) {
+                        const impact = compound.controlsJsxRendering ? 'high' : 'medium';
+                        // Generate a combined ID from all paths
+                        const pathParts = requiredValues
+                            .map((rv) => {
+                            const name = generateNameFromPath(rv.attributePath);
+                            return name.toLowerCase().replace(/\s+/g, '-');
+                        })
+                            .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 ')}`,
+                            impact,
+                            requiredValues,
+                            sourceLocation: compound.sourceLocation,
+                        };
+                        if (!seenFlowIds.has(compoundFlow.id)) {
+                            seenFlowIds.add(compoundFlow.id);
+                            flows.push(compoundFlow);
+                        }
+                    }
+                }
+                else {
+                    // No derived variables - use the original generateFlowFromCompound
+                    // Create a modified compound with just this condition set
+                    const modifiedCompound = {
+                        ...compound,
+                        conditions: conditionSet,
+                    };
+                    const compoundFlow = generateFlowFromCompound(modifiedCompound, resolvedPaths);
+                    if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
+                        seenFlowIds.add(compoundFlow.id);
+                        flows.push(compoundFlow);
+                    }
+                }
             }
         }
     }
@@ -541,7 +1101,17 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         const [, varName, operator, comparedValue] = comparisonMatch;
                         // Try to resolve the variable name
                         const varResolution = resolvePathToControllable(varName, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        // Only use controllable paths for gating conditions (whitelist approach).
+                        // Do NOT fall back to equivalentSignatureVariables because those may contain
+                        // uncontrollable paths like useState that cannot be mocked.
+                        let resolvedVarPath = null;
                         if (varResolution.isControllable && varResolution.resolvedPath) {
+                            resolvedVarPath = varResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedVarPath) {
                             const isNegated = gatingCondition.isNegated === true;
                             const isNotEquals = operator === '!=' || operator === '!==';
                             // Determine the effective value for this gating condition
@@ -551,7 +1121,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                             // XOR logic: isNegated XOR isNotEquals
                             const needsExactValue = isNegated !== isNotEquals;
                             gatingRequiredValues.push({
-                                attributePath: varResolution.resolvedPath,
+                                attributePath: resolvedVarPath,
                                 value: needsExactValue ? 'falsy' : comparedValue,
                                 comparison: needsExactValue ? 'falsy' : 'equals',
                             });
@@ -604,7 +1174,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     // For non-negated &&: all parts must be truthy
                                     // For negated ||: all parts must be falsy (DeMorgan: !(A || B) = !A && !B)
                                     gatingRequiredValues.push({
-                                        attributePath: partResolution.resolvedPath,
+                                        attributePath: stripLengthSuffix(partResolution.resolvedPath),
                                         value: isNegated ? 'falsy' : 'truthy',
                                         comparison: isNegated ? 'falsy' : 'truthy',
                                     });
@@ -616,14 +1186,24 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         // Simple gating condition (single path)
                         // Resolve the gating path in parent context
                         const gatingResolution = resolvePathToControllable(gatingPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        // Only use controllable paths for gating conditions (whitelist approach).
+                        // Do NOT fall back to equivalentSignatureVariables because those may contain
+                        // uncontrollable paths like useState that cannot be mocked.
+                        let resolvedGatingPath = null;
                         if (gatingResolution.isControllable &&
                             gatingResolution.resolvedPath) {
+                            resolvedGatingPath = gatingResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedGatingPath) {
                             // For truthiness conditions on gating, check if the condition is negated
                             // e.g., ternary else branch: isError ? <ErrorView /> : <SuccessView />
                             // SuccessView has isNegated: true, meaning it renders when isError is falsy
                             const isNegated = gatingCondition.isNegated === true;
                             gatingRequiredValues.push({
-                                attributePath: gatingResolution.resolvedPath,
+                                attributePath: resolvedGatingPath,
                                 value: isNegated ? 'falsy' : 'truthy',
                                 comparison: isNegated ? 'falsy' : 'truthy',
                             });
@@ -636,6 +1216,8 @@ 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)) {
@@ -647,30 +1229,156 @@ 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 (!resolution.isControllable || !resolution.resolvedPath) {
-                        // Path is not controllable in parent context
-                        continue;
+                    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
+                    // controllable via mock data injection.
+                    let resolvedPath = resolution.resolvedPath;
+                    if (!resolution.isControllable || !resolvedPath) {
+                        // Path is not controllable via standard resolution.
+                        // Try fallback: For useState values (cyScope*().functionCallReturnValue),
+                        // look for a related URL parameter like "varNameFromUrl" that might
+                        // control the initial state.
+                        //
+                        // Example: viewMode → cyScope20().functionCallReturnValue (useState value)
+                        // Fallback: viewModeFromUrl → segments[2] (URL param that initializes the useState)
+                        const useStateMatch = translatedPath.match(/^cyScope\d+\(\)\.functionCallReturnValue$/);
+                        if (useStateMatch) {
+                            // Find what variable this useState value corresponds to by looking
+                            // for entries like "varName": "cyScope20()" in equivalentSignatureVariables
+                            const useStatePattern = translatedPath.replace(/\.functionCallReturnValue$/, ''); // e.g., "cyScope20()"
+                            // Find the variable name that maps to this useState
+                            let useStateVarName = null;
+                            for (const [varName, varPath] of Object.entries(equivalentSignatureVariables)) {
+                                if (varPath === useStatePattern) {
+                                    useStateVarName = varName;
+                                    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")
+                                    // rather than fully resolving it. This keeps the path meaningful
+                                    // for scenario generation and avoids overly generic paths like
+                                    // "useParams().functionCallReturnValue.*".
+                                    //
+                                    // 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 (shouldDebugChild) {
+                                            console.log(`[DEBUG CHILD ${childName}]   sourceEquivalencies fallback SUCCESS: using data source ${resolvedPath}`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // If still not resolved after fallback, skip
+                        if (!resolvedPath) {
+                            if (shouldDebugChild) {
+                                console.log(`[DEBUG CHILD ${childName}]   SKIPPED - path not controllable`);
+                            }
+                            continue;
+                        }
                     }
-                    const resolvedPath = resolution.resolvedPath;
                     // 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);
@@ -681,6 +1389,12 @@ 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
@@ -710,28 +1424,218 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // Process child's compound conditionals
             for (const compound of childData.compoundConditionals) {
                 const resolvedPaths = new Map();
-                let allControllable = true;
+                let allResolvable = true;
                 for (const condition of compound.conditions) {
                     // Determine the child path to translate
                     const childPath = condition.path;
                     // Translate the child path to a parent path
                     const translatedPath = translateChildPathToParent(childPath, childData.equivalentSignatureVariables, equivalentSignatureVariables, childName);
                     if (!translatedPath) {
-                        allControllable = false;
+                        allResolvable = false;
                         break;
                     }
                     const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-                    if (!resolution.isControllable || !resolution.resolvedPath) {
-                        allControllable = false;
+                    // 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
+                    // controllable via mock data injection.
+                    let resolvedPath = resolution.resolvedPath;
+                    if (!resolution.isControllable || !resolvedPath) {
+                        // Path is not controllable via standard resolution.
+                        // Try fallback: For useState values (cyScope*().functionCallReturnValue),
+                        // look for a related URL parameter like "varNameFromUrl" that might
+                        // control the initial state.
+                        const useStateMatch = translatedPath.match(/^cyScope\d+\(\)\.functionCallReturnValue$/);
+                        if (useStateMatch) {
+                            const useStatePattern = translatedPath.replace(/\.functionCallReturnValue$/, '');
+                            // Find the variable name that maps to this useState
+                            let useStateVarName = null;
+                            for (const [varName, varPath] of Object.entries(equivalentSignatureVariables)) {
+                                if (varPath === useStatePattern) {
+                                    useStateVarName = varName;
+                                    break;
+                                }
+                            }
+                            if (useStateVarName) {
+                                const urlParamName = `${useStateVarName}FromUrl`;
+                                const urlParamPath = equivalentSignatureVariables[urlParamName];
+                                if (urlParamPath) {
+                                    resolvedPath = urlParamName;
+                                }
+                            }
+                        }
+                    }
+                    if (!resolvedPath) {
+                        allResolvable = false;
                         break;
                     }
-                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                    resolvedPaths.set(condition.path, resolvedPath);
                 }
-                if (allControllable && resolvedPaths.size > 0) {
+                if (allResolvable && resolvedPaths.size > 0) {
                     const compoundFlow = generateFlowFromCompound(compound, resolvedPaths);
-                    if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
-                        seenFlowIds.add(compoundFlow.id);
-                        flows.push(compoundFlow);
+                    if (compoundFlow) {
+                        // Add gating conditions to compound flow (same as regular usage flows)
+                        if (gatingRequiredValues.length > 0) {
+                            // Filter out any gating values that are already in the flow
+                            const existingPaths = new Set(compoundFlow.requiredValues.map((rv) => rv.attributePath));
+                            const newGatingValues = gatingRequiredValues.filter((gv) => !existingPaths.has(gv.attributePath));
+                            compoundFlow.requiredValues = [
+                                ...compoundFlow.requiredValues,
+                                ...newGatingValues,
+                            ];
+                            // Update the flow ID to include gating conditions
+                            if (newGatingValues.length > 0) {
+                                const gatingIdPart = newGatingValues
+                                    .map((gv) => `${gv.attributePath}-${gv.value}`)
+                                    .join('-');
+                                compoundFlow.id = `${compoundFlow.id}-gated-${gatingIdPart}`;
+                            }
+                        }
+                        if (!seenFlowIds.has(compoundFlow.id)) {
+                            seenFlowIds.add(compoundFlow.id);
+                            flows.push(compoundFlow);
+                        }
+                    }
+                }
+            }
+            // 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);
+                        }
                     }
                 }
             }