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

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

@@ -18,6 +18,7 @@ import type {
   CompoundConditional,
   DerivedVariableOperation,
   DerivedVariableInfo,
+  JsxRenderingUsage,
 } from './astScopes/types';
 import type { EnrichedConditionalUsage } from './worker/SerializableDataStructure';
 import resolvePathToControllable from './resolvePathToControllable';
@@ -32,7 +33,7 @@ export interface ChildComponentConditionalData {
   /** Child's conditional usages keyed by variable name (may include sourceDataPath from enrichment) */
   conditionalUsages: Record<string, ExtendedConditionalUsage[]>;
   /** Child's equivalent signature variables (maps internal paths to prop paths) */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Child's compound conditionals */
   compoundConditionals: CompoundConditional[];
   /**
@@ -41,6 +42,11 @@ export interface ChildComponentConditionalData {
    * then `hasAnalysis` is a gating condition for all of ChildComponent's flows.
    */
   gatingConditions?: ConditionalUsage[];
+  /**
+   * Child's JSX rendering usages (arrays rendered via .map(), text interpolation).
+   * These generate "variation flows" for different array lengths.
+   */
+  jsxRenderingUsages?: JsxRenderingUsage[];
 }
 
 export interface GenerateFlowsFromConditionalsArgs {
@@ -51,7 +57,7 @@ export interface GenerateFlowsFromConditionalsArgs {
   /** Map of controllable paths to their types */
   attributesMap: Record<string, string>;
   /** Map from local variable names to data sources */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Map from full paths to short paths */
   fullToShortPathMap: Record<string, string>;
   /**
@@ -73,6 +79,21 @@ export interface GenerateFlowsFromConditionalsArgs {
    * to `currentRun.entityShas` when `isInCurrentRun` isn't in conditionalUsages.
    */
   derivedVariables?: Record<string, DerivedVariableInfo>;
+  /**
+   * Optional map of child prop paths to their actual data sources.
+   * Used when child props flow through useState but ultimately come from
+   * mockable data sources (e.g., API calls, fetchers).
+   *
+   * Example:
+   * - "WorkoutsView().signature[0].workouts" → "createClient()...functionCallReturnValue.data"
+   *
+   * When a child path translates to a useState value, we check this map
+   * to find the real data source that can be mocked.
+   */
+  sourceEquivalencies?: Record<
+    string,
+    Array<{ scopeNodeName: string; schemaPath: string }>
+  >;
 }
 
 /**
@@ -117,7 +138,7 @@ function expandDerivedVariableToSources(
   path: string,
   conditionalUsages: Record<string, ConditionalUsage[]>,
   attributesMap: Record<string, string>,
-  equivalentSignatureVariables: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
   fullToShortPathMap: Record<string, string>,
   visited: Set<string> = new Set(),
   derivedVariables?: Record<string, DerivedVariableInfo>,
@@ -238,11 +259,15 @@ function cleanSourceDataPath(sourceDataPath: string): string | null {
     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
@@ -287,6 +312,85 @@ function stripLengthSuffix(path: string): string {
   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: ExecutionFlow['requiredValues'],
+): ExecutionFlow['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: ExecutionFlow['requiredValues'][0]): string {
+  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: string,
+  fullToShortPathMap: Record<string, string>,
+): boolean {
+  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.
  *
@@ -329,13 +433,16 @@ function extractControllableBase(path: string): string {
  * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
  * The fullToShortPathMap maps full paths to short paths
  */
-function findInAttributesMapForPath(
+export function findInAttributesMapForPath(
   path: string,
   attributesMap: Record<string, string>,
   fullToShortPathMap: Record<string, string>,
 ): string | null {
   // Direct match in attributesMap (already a short path)
   if (path in attributesMap) {
+    console.log(
+      `[findInAttributesMapForPath] "${path}" → DIRECT match in attributesMap`,
+    );
     return path;
   }
 
@@ -344,19 +451,31 @@ function findInAttributesMapForPath(
   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
       }
     }
@@ -368,25 +487,92 @@ function findInAttributesMapForPath(
   // 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: string): string {
+  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.
@@ -598,7 +784,15 @@ function generateFlowFromCompound(
         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({
@@ -609,21 +803,32 @@ function generateFlowFromCompound(
     });
   }
 
-  // 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,
@@ -732,8 +937,8 @@ function normalizePathForDeduplication(
  */
 function translateChildPathToParent(
   childPath: string,
-  childEquivalentSignatureVariables: Record<string, string>,
-  parentEquivalentSignatureVariables: Record<string, string>,
+  childEquivalentSignatureVariables: Record<string, string | string[]>,
+  parentEquivalentSignatureVariables: Record<string, string | string[]>,
   childName: string,
 ): string | null {
   // Extract the root variable from the child path
@@ -760,7 +965,11 @@ function translateChildPathToParent(
 
   // 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
@@ -773,7 +982,11 @@ function translateChildPathToParent(
 
   // 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
@@ -800,11 +1013,28 @@ export default function generateExecutionFlowsFromConditionals(
     fullToShortPathMap,
     childComponentData,
     derivedVariables,
+    sourceEquivalencies,
   } = args;
 
   const flows: ExecutionFlow[] = [];
   const seenFlowIds = new Set<string>();
 
+  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)
@@ -822,9 +1052,16 @@ export default function generateExecutionFlowsFromConditionals(
     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: string | null = null;
 
@@ -834,7 +1071,9 @@ export default function generateExecutionFlowsFromConditionals(
         // 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(
@@ -842,6 +1081,9 @@ export default function generateExecutionFlowsFromConditionals(
             attributesMap,
             fullToShortPathMap,
           );
+          console.log(
+            `[genFlowsFromConditionals] "${usage.path}" findInAttributesMapForPath("${cleanedPath}") → ${pathMatch ? `"${pathMatch}"` : 'null (not found)'}`,
+          );
           if (pathMatch) {
             resolvedPath = pathMatch;
           }
@@ -851,13 +1093,18 @@ export default function generateExecutionFlowsFromConditionals(
 
       // 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;
         }
@@ -869,7 +1116,9 @@ export default function generateExecutionFlowsFromConditionals(
       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(
@@ -878,7 +1127,6 @@ export default function generateExecutionFlowsFromConditionals(
             equivalentSignatureVariables,
             fullToShortPathMap,
           );
-
           if (resolution.isControllable && resolution.resolvedPath) {
             resolvedPath = resolution.resolvedPath;
           }
@@ -1174,6 +1422,9 @@ export default function generateExecutionFlowsFromConditionals(
 
       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;
       }
 
@@ -1188,10 +1439,33 @@ export default function generateExecutionFlowsFromConditionals(
       // 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);
 
@@ -1200,6 +1474,9 @@ export default function generateExecutionFlowsFromConditionals(
         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 })))}`,
+          );
         }
       }
     }
@@ -1253,25 +1530,85 @@ export default function generateExecutionFlowsFromConditionals(
             // 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;
+            // 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: string | null = 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,
-          );
+          // First try sourceDataPath from the usage (same as individual processing)
+          let compoundResolvedPath: string | null = null;
 
-          if (!resolution.isControllable || !resolution.resolvedPath) {
+          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);
         }
       }
 
@@ -1349,7 +1686,14 @@ export default function generateExecutionFlowsFromConditionals(
                     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({
@@ -1362,24 +1706,31 @@ export default function generateExecutionFlowsFromConditionals(
             }
           }
 
-          if (requiredValues.length > 0) {
+          // Remove contradictory "falsy" values where a child path requires data
+          const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+
+          if (cleanedValues.length > 0) {
             const impact: ExecutionFlow['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: ExecutionFlow = {
-              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,
             };
 
@@ -1596,9 +1947,6 @@ export default function generateExecutionFlowsFromConditionals(
         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)) {
@@ -1613,18 +1961,6 @@ export default function generateExecutionFlowsFromConditionals(
             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,
@@ -1633,12 +1969,6 @@ export default function generateExecutionFlowsFromConditionals(
             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) {
@@ -1647,21 +1977,11 @@ export default function generateExecutionFlowsFromConditionals(
             );
             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;
           }
 
@@ -1674,21 +1994,6 @@ export default function generateExecutionFlowsFromConditionals(
             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
@@ -1726,32 +2031,11 @@ export default function generateExecutionFlowsFromConditionals(
                 }
               }
 
-              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")
@@ -1762,10 +2046,62 @@ export default function generateExecutionFlowsFromConditionals(
                   // 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: string | null = 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;
                   }
                 }
               }
@@ -1773,11 +2109,6 @@ export default function generateExecutionFlowsFromConditionals(
 
             // If still not resolved after fallback, skip
             if (!resolvedPath) {
-              if (shouldDebugChild) {
-                console.log(
-                  `[DEBUG CHILD ${childName}]   SKIPPED - path not controllable`,
-                );
-              }
               continue;
             }
           }
@@ -1789,11 +2120,6 @@ export default function generateExecutionFlowsFromConditionals(
           );
 
           if (seenNormalizedPaths.has(normalizedPath)) {
-            if (shouldDebugChild) {
-              console.log(
-                `[DEBUG CHILD ${childName}]   SKIPPED - duplicate normalized path: ${normalizedPath}`,
-              );
-            }
             continue;
           }
           seenNormalizedPaths.add(normalizedPath);
@@ -1810,17 +2136,6 @@ export default function generateExecutionFlowsFromConditionals(
             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
@@ -1970,8 +2285,200 @@ export default function generateExecutionFlowsFromConditionals(
           }
         }
       }
+
+      // 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: string | null = 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: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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;
 }