@codeyam/codeyam-cli 0.0.0 → 0.1.0-staging.036391e

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

@@ -0,0 +1,2267 @@
+/**
+ * Generates execution flows from conditional usages using pure static analysis.
+ *
+ * This replaces LLM-driven flow generation with deterministic flow generation
+ * based on conditionalUsages extracted from the AST. Only paths that resolve
+ * to controllable data sources (exist in attributesMap) produce flows.
+ *
+ * Flow generation rules:
+ * - truthiness conditions → truthy flow + falsy flow
+ * - comparison conditions → one flow per compared value
+ * - switch conditions → one flow per case value
+ * - compound conditionals → one flow with all conditions (only if ALL paths controllable)
+ */
+
+import type { ExecutionFlow } from '~codeyam/types';
+import type {
+  ConditionalUsage,
+  CompoundConditional,
+  DerivedVariableOperation,
+  DerivedVariableInfo,
+  JsxRenderingUsage,
+} from './astScopes/types';
+import type { EnrichedConditionalUsage } from './worker/SerializableDataStructure';
+import resolvePathToControllable from './resolvePathToControllable';
+import cleanPathOfNonTransformingFunctions from './dataStructure/helpers/cleanPathOfNonTransformingFunctions';
+
+/** Extended conditional usage type that may include sourceDataPath from enrichment */
+type ExtendedConditionalUsage = ConditionalUsage &
+  Partial<EnrichedConditionalUsage>;
+
+/** Child component conditional data for merging child flows into parent */
+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 | string[]>;
+  /** Child's compound conditionals */
+  compoundConditionals: CompoundConditional[];
+  /**
+   * Gating conditions - the parent's conditions required to render this child component.
+   * For example, if the parent has `{hasAnalysis && <ChildComponent />}`,
+   * 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 {
+  /** Record of attribute paths to their conditional usages (may include sourceDataPath) */
+  conditionalUsages: Record<string, ExtendedConditionalUsage[]>;
+  /** Compound conditionals (&&-chained conditions) */
+  compoundConditionals: CompoundConditional[];
+  /** Map of controllable paths to their types */
+  attributesMap: Record<string, string>;
+  /** Map from local variable names to data sources */
+  equivalentSignatureVariables: Record<string, string | string[]>;
+  /** Map from full paths to short paths */
+  fullToShortPathMap: Record<string, string>;
+  /**
+   * Optional child component conditional data.
+   * Maps child component name to its conditional data.
+   * Used to merge child execution flows into parent.
+   */
+  childComponentData?: Record<string, ChildComponentConditionalData>;
+  /**
+   * Optional map of derived variables to their derivation info.
+   * Used to trace intermediate derived variables that aren't directly
+   * used in conditionals but are sources for other derived variables.
+   *
+   * Example:
+   * - `isInCurrentRun = currentRun.entityShas.includes(sha)` → { sourcePath: 'currentRun.entityShas', operation: 'arrayIncludes' }
+   * - `isAnalyzing = isInCurrentRun || isInQueue` → { sourcePaths: ['isInCurrentRun', 'isInQueue'], operation: 'or' }
+   *
+   * Without this map, we can't trace from `isAnalyzing` through `isInCurrentRun`
+   * 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 }>
+  >;
+}
+
+/**
+ * Resolved source info from expanding a derived variable.
+ * Contains the path and the operation that led to it.
+ */
+interface ResolvedSourceInfo {
+  path: string;
+  operation?:
+    | 'notNull'
+    | 'isNull'
+    | 'equals'
+    | 'notEquals'
+    | 'or'
+    | 'and'
+    | 'arrayIncludes'
+    | 'arraySome'
+    | 'arrayEvery'
+    | 'arrayLength';
+}
+
+/**
+ * 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: string,
+  conditionalUsages: Record<string, ConditionalUsage[]>,
+  attributesMap: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
+  fullToShortPathMap: Record<string, string>,
+  visited: Set<string> = new Set(),
+  derivedVariables?: Record<string, DerivedVariableInfo>,
+): ResolvedSourceInfo[] {
+  // 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: ResolvedSourceInfo[] = [];
+
+    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.
+ *
+ * This function ONLY handles the specific pattern where a scope name is
+ * duplicated before the hook call:
+ *
+ * Example:
+ * "useLoaderData<LoaderData>.useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
+ * → "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
+ *
+ * For paths with multiple function calls (like fetch().json()), or paths
+ * that don't match the expected pattern, returns null to indicate the
+ * fallback resolution should be used.
+ */
+function cleanSourceDataPath(sourceDataPath: string): string | null {
+  // Count function call patterns - both empty () and with content (...)
+  // We detect multiple function calls by counting:
+  // 1. Empty () patterns
+  // 2. Patterns like functionName(...) - closing paren followed by dot or end
+  const emptyFnCalls = (sourceDataPath.match(/\(\)/g) || []).length;
+  const fnCallReturnValues = (
+    sourceDataPath.match(/\.functionCallReturnValue/g) || []
+  ).length;
+
+  // If there are multiple functionCallReturnValue occurrences, this is a chained call
+  // (e.g., fetch(...).functionCallReturnValue.json().functionCallReturnValue.data)
+  if (fnCallReturnValues > 1 || emptyFnCalls !== 1) {
+    // Multiple function calls - return null to use fallback resolution
+    return null;
+  }
+
+  // Find the "()" which marks the function call
+  const fnCallIndex = sourceDataPath.indexOf('()');
+
+  // Find where the function name starts (go back to find the start of this segment)
+  const beforeFnCall = sourceDataPath.slice(0, fnCallIndex);
+  const lastDotBeforeFn = beforeFnCall.lastIndexOf('.');
+
+  if (lastDotBeforeFn === -1) {
+    return sourceDataPath;
+  }
+
+  // Extract the scope prefix and the actual path
+  const scopePrefix = sourceDataPath.slice(0, lastDotBeforeFn);
+  const actualPath = sourceDataPath.slice(lastDotBeforeFn + 1);
+
+  // Verify this is actually a redundant scope prefix pattern
+  // The actualPath should start with something that matches the scopePrefix
+  // e.g., scopePrefix="useLoaderData<LoaderData>" and actualPath starts with "useLoaderData<LoaderData>()..."
+  if (!actualPath.startsWith(scopePrefix.split('.').pop() || '')) {
+    // Not a redundant prefix pattern - return the original path
+    return 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: string): string {
+  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: string): string {
+  // 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.
+ *
+ * IMPORTANT: Returns the FULL path (preserving data source context) when possible.
+ * This ensures execution flows can be traced back to specific data sources,
+ * which is critical when multiple data sources have the same property names
+ * (e.g., multiple useFetcher hooks all having 'state' and 'data').
+ *
+ * The attributesMap contains short relative paths (e.g., "entity.sha")
+ * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
+ * The fullToShortPathMap maps full paths to short paths
+ */
+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) {
+    return path;
+  }
+
+  // Try looking up the path in fullToShortPathMap to verify it's controllable
+  // IMPORTANT: Return the FULL path, not the short path, to preserve data source context
+  if (path in fullToShortPathMap) {
+    const shortPath = fullToShortPathMap[path];
+    if (shortPath in attributesMap) {
+      return path; // Return FULL path to preserve data source context
+    }
+  }
+
+  // Normalized match (array indices [N] → [])
+  const normalizedPath = path.replace(/\[\d+\]/g, '[]');
+  if (normalizedPath !== path) {
+    if (normalizedPath in attributesMap) {
+      return normalizedPath;
+    }
+    if (normalizedPath in fullToShortPathMap) {
+      const shortPath = fullToShortPathMap[normalizedPath];
+      if (shortPath in attributesMap) {
+        return normalizedPath; // Return normalized FULL path
+      }
+    }
+  }
+
+  // Try prefix matching for child paths
+  // e.g., path is "entity.sha.something" and attributesMap has "entity.sha"
+  // OR path is a full path like "useLoaderData<...>().functionCallReturnValue.entity.sha"
+  // 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
+      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
+    }
+  }
+
+  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.
+ *
+ * Examples:
+ * - "useFetcher<...>().functionCallReturnValue.state" → "state"
+ * - "useLoaderData<...>().functionCallReturnValue.user.isActive" → "isActive"
+ */
+function generateNameFromPath(path: string): string {
+  // Remove function call markers and get the last meaningful segment
+  const cleanPath = path
+    .replace(/\(\)/g, '')
+    .replace(/\.functionCallReturnValue/g, '');
+  const parts = cleanPath.split('.');
+  const lastPart = parts[parts.length - 1];
+
+  // Convert camelCase to Title Case with spaces
+  return lastPart
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/^./, (str) => str.toUpperCase())
+    .trim();
+}
+
+/**
+ * Generate a flow ID from path and value.
+ * Creates a unique, URL-safe identifier.
+ */
+function generateFlowId(path: string, value: string): string {
+  // Clean the path for use in ID
+  const cleanPath = path
+    .replace(/\(\)/g, '')
+    .replace(/\.functionCallReturnValue/g, '')
+    .replace(/[<>]/g, '')
+    .replace(/\./g, '-');
+
+  // Clean the value
+  const cleanValue = value
+    .toString()
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  return `${cleanPath}-${cleanValue}`.toLowerCase();
+}
+
+/**
+ * Infer value type from a string value.
+ */
+function inferValueType(
+  value: string,
+): 'string' | 'number' | 'boolean' | 'null' {
+  if (value === 'true' || value === 'false') return 'boolean';
+  if (value === 'null' || value === 'undefined') return 'null';
+  if (!isNaN(Number(value)) && value !== '') return 'number';
+  return 'string';
+}
+
+/**
+ * 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: ConditionalUsage,
+  resolvedPath: string,
+): ExecutionFlow[] {
+  const flows: ExecutionFlow[] = [];
+  const baseName = generateNameFromPath(resolvedPath);
+
+  // Determine impact based on whether this conditional controls JSX rendering
+  // Conditionals that control visual output are high-impact
+  const impact: ExecutionFlow['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;
+
+    // Truthy flow (or falsy if negated)
+    flows.push({
+      id: generateFlowId(resolvedPath, isNegated ? 'falsy' : 'truthy'),
+      name: `${baseName} ${isNegated ? 'False' : 'True'}`,
+      description: `When ${baseName.toLowerCase()} is ${isNegated ? 'falsy' : 'truthy'}`,
+      requiredValues: [
+        {
+          attributePath,
+          value: isNegated ? 'falsy' : 'truthy',
+          comparison: isNegated ? 'falsy' : 'truthy',
+          valueType: 'boolean',
+          constraint,
+        },
+      ],
+      impact,
+      sourceLocation: usage.sourceLocation
+        ? {
+            lineNumber: usage.sourceLocation.lineNumber,
+            column: usage.sourceLocation.column,
+          }
+        : undefined,
+      codeSnippet: usage.sourceLocation?.codeSnippet,
+    });
+
+    // Falsy flow (or truthy if negated)
+    flows.push({
+      id: generateFlowId(resolvedPath, isNegated ? 'truthy' : 'falsy'),
+      name: `${baseName} ${isNegated ? 'True' : 'False'}`,
+      description: `When ${baseName.toLowerCase()} is ${isNegated ? 'truthy' : 'falsy'}`,
+      requiredValues: [
+        {
+          attributePath,
+          value: isNegated ? 'truthy' : 'falsy',
+          comparison: isNegated ? 'truthy' : 'falsy',
+          valueType: 'boolean',
+          constraint,
+        },
+      ],
+      impact,
+      sourceLocation: usage.sourceLocation
+        ? {
+            lineNumber: usage.sourceLocation.lineNumber,
+            column: usage.sourceLocation.column,
+          }
+        : undefined,
+      codeSnippet: usage.sourceLocation?.codeSnippet,
+    });
+  } else if (
+    usage.conditionType === 'comparison' ||
+    usage.conditionType === 'switch'
+  ) {
+    // Generate one flow per compared value
+    const values = usage.comparedValues ?? [];
+
+    for (const value of values) {
+      flows.push({
+        id: generateFlowId(resolvedPath, value),
+        name: `${baseName}: ${value}`,
+        description: `When ${baseName.toLowerCase()} equals "${value}"`,
+        requiredValues: [
+          {
+            attributePath,
+            value: value,
+            comparison: 'equals',
+            valueType: inferValueType(value),
+            constraint,
+          },
+        ],
+        impact,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+    }
+  }
+
+  return flows;
+}
+
+/**
+ * Generate a flow from a compound conditional (all conditions must be satisfied).
+ * Sets impact to 'high' if the compound conditional controls JSX rendering.
+ */
+function generateFlowFromCompound(
+  compound: CompoundConditional,
+  resolvedPaths: Map<string, string>,
+): ExecutionFlow | null {
+  // Determine impact based on whether this compound conditional controls JSX rendering
+  const impact: ExecutionFlow['impact'] = compound.controlsJsxRendering
+    ? 'high'
+    : 'medium';
+  const requiredValues: ExecutionFlow['requiredValues'] = [];
+
+  for (const condition of compound.conditions) {
+    const resolvedPath = resolvedPaths.get(condition.path);
+    if (!resolvedPath) {
+      // This shouldn't happen if we pre-filtered, but safety check
+      return null;
+    }
+
+    // Determine the required value based on condition type
+    let value: string;
+    let comparison: ExecutionFlow['requiredValues'][0]['comparison'];
+
+    if (condition.conditionType === 'truthiness') {
+      // If negated (!foo), we need falsy; otherwise truthy
+      value = condition.isNegated ? 'falsy' : 'truthy';
+      comparison = condition.isNegated ? 'falsy' : 'truthy';
+    } else {
+      // For comparison/switch, use the first compared value or required value
+      value =
+        condition.requiredValue?.toString() ??
+        condition.comparedValues?.[0] ??
+        'truthy';
+      comparison = 'equals';
+    }
+
+    requiredValues.push({
+      attributePath: stripLengthSuffix(resolvedPath),
+      value,
+      comparison,
+      valueType: inferValueType(value),
+    });
+  }
+
+  // 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-');
+
+  return {
+    id: `compound-${pathParts}`,
+    name: requiredValues
+      .map((rv) => generateNameFromPath(rv.attributePath))
+      .join(' + '),
+    description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
+    requiredValues,
+    impact,
+    sourceLocation: {
+      lineNumber: compound.sourceLocation.lineNumber,
+      column: compound.sourceLocation.column,
+    },
+    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: CompoundConditional['conditions'],
+): CompoundConditional['conditions'][] {
+  // Separate conditions into mandatory (no orGroupId) and OR groups
+  const mandatory = conditions.filter((c) => !c.orGroupId);
+  const orGroups = new Map<string, typeof conditions>();
+
+  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: CompoundConditional['conditions'][] = [];
+
+  function generateCombinations(
+    index: number,
+    current: typeof conditions,
+  ): void {
+    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.
+ *
+ * Only generates flows where all paths resolve to controllable data sources.
+ * This ensures we never produce flows with invalid paths like useState variables.
+ */
+/**
+ * Normalize a resolved path to a canonical form for deduplication.
+ * Uses fullToShortPathMap to convert full paths to short paths.
+ * This ensures that both "hasNewerVersion" and
+ * "useLoaderData<LoaderData>().functionCallReturnValue.hasNewerVersion"
+ * normalize to the same canonical path.
+ */
+function normalizePathForDeduplication(
+  resolvedPath: string,
+  fullToShortPathMap: Record<string, string>,
+): string {
+  // If the path is in fullToShortPathMap, use the short path as canonical
+  if (resolvedPath in fullToShortPathMap) {
+    return fullToShortPathMap[resolvedPath];
+  }
+  // Otherwise, the path itself is canonical
+  return resolvedPath;
+}
+
+/**
+ * Translate a child component path to a parent path using prop mappings.
+ *
+ * Given:
+ * - childPath: "selectedScenario.metadata.screenshotPaths[0]" (path in child's context)
+ * - childEquiv: { selectedScenario: "signature[0].selectedScenario" } (child's internal-to-prop mapping)
+ * - parentEquiv: { "ChildName().signature[0].selectedScenario": "selectedScenario" } (parent's prop assignments)
+ * - childName: "ChildName"
+ *
+ * Returns: "selectedScenario.metadata.screenshotPaths[0]" (path in parent's context)
+ *
+ * The translation works by:
+ * 1. Finding the root variable in the child path (e.g., "selectedScenario")
+ * 2. Looking up the child's equivalence to find the prop path (e.g., "signature[0].selectedScenario")
+ * 3. Building the full child prop path (e.g., "ChildName().signature[0].selectedScenario")
+ * 4. Looking up the parent's equivalence to find the parent path (e.g., "selectedScenario")
+ * 5. Replacing the root with the parent path and preserving the suffix
+ */
+function translateChildPathToParent(
+  childPath: string,
+  childEquivalentSignatureVariables: Record<string, string | string[]>,
+  parentEquivalentSignatureVariables: Record<string, string | string[]>,
+  childName: string,
+): string | null {
+  // Extract the root variable from the child path
+  // e.g., "selectedScenario.metadata.screenshotPaths[0]" → "selectedScenario"
+  const dotIndex = childPath.indexOf('.');
+  const bracketIndex = childPath.indexOf('[');
+  let rootVar: string;
+  let suffix: string;
+
+  if (dotIndex === -1 && bracketIndex === -1) {
+    rootVar = childPath;
+    suffix = '';
+  } else if (dotIndex === -1) {
+    rootVar = childPath.slice(0, bracketIndex);
+    suffix = childPath.slice(bracketIndex);
+  } else if (bracketIndex === -1) {
+    rootVar = childPath.slice(0, dotIndex);
+    suffix = childPath.slice(dotIndex);
+  } else {
+    const firstIndex = Math.min(dotIndex, bracketIndex);
+    rootVar = childPath.slice(0, firstIndex);
+    suffix = childPath.slice(firstIndex);
+  }
+
+  // Look up the child's equivalence for this root variable
+  // e.g., childEquiv[selectedScenario] = "signature[0].selectedScenario"
+  // 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;
+  }
+
+  // Build the full child prop path as seen from parent
+  // e.g., "ChildName().signature[0].selectedScenario"
+  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"
+  // 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));
+    return null;
+  }
+
+  // Build the translated path: parentValue + suffix
+  // e.g., "selectedScenario" + ".metadata.screenshotPaths[0]"
+  const result = parentValue + suffix;
+  return result;
+}
+
+export default function generateExecutionFlowsFromConditionals(
+  args: GenerateFlowsFromConditionalsArgs,
+): ExecutionFlow[] {
+  const {
+    conditionalUsages,
+    compoundConditionals,
+    attributesMap,
+    equivalentSignatureVariables,
+    fullToShortPathMap,
+    childComponentData,
+    derivedVariables,
+    sourceEquivalencies,
+  } = args;
+
+  const flows: ExecutionFlow[] = [];
+  const seenFlowIds = new Set<string>();
+
+  // Track normalized resolved paths to prevent duplicate flows
+  // This handles the case where we have usages for both:
+  // - "hasNewerVersion" (short path from destructured variable)
+  // - "useLoaderData<LoaderData>().functionCallReturnValue.hasNewerVersion" (full path)
+  // Both resolve to the same logical data source, so we only want ONE set of flows.
+  const seenNormalizedPaths = new Set<string>();
+
+  // Track which usages are part of compound conditionals (to avoid duplicates)
+  const compoundChainIds = new Set(
+    compoundConditionals.map((c) => c.chainId).filter(Boolean),
+  );
+
+  // Process individual conditional usages
+  for (const [_path, usages] of Object.entries(conditionalUsages)) {
+    for (const usage of usages) {
+      // Skip usages that are part of compound conditionals (handled separately)
+      if (usage.chainId && compoundChainIds.has(usage.chainId)) {
+        continue;
+      }
+
+      // First, try to use pre-computed sourceDataPath if available
+      let resolvedPath: string | null = null;
+
+      if (usage.sourceDataPath) {
+        // Clean up the sourceDataPath - it may have redundant scope prefixes
+        // e.g., "useLoaderData<LoaderData>.useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
+        // 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);
+
+        if (cleanedPath) {
+          // Verify the cleaned path exists in attributesMap
+          const pathMatch = findInAttributesMapForPath(
+            cleanedPath,
+            attributesMap,
+            fullToShortPathMap,
+          );
+          if (pathMatch) {
+            resolvedPath = pathMatch;
+          }
+        }
+        // If cleanedPath is null, fall through to use fallback resolution
+      }
+
+      // Fall back to resolution via equivalentSignatureVariables
+      if (!resolvedPath) {
+        const resolution = resolvePathToControllable(
+          usage.path,
+          attributesMap,
+          equivalentSignatureVariables,
+          fullToShortPathMap,
+        );
+
+        if (resolution.isControllable && resolution.resolvedPath) {
+          resolvedPath = resolution.resolvedPath;
+        }
+      }
+
+      // If still not resolved, try using derivedFrom info to find the source path
+      // This handles cases like: const hasAnalysis = analysis !== null
+      // where hasAnalysis is not in attributesMap but analysis is
+      if (!resolvedPath && 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,
+          );
+
+          if (resolution.isControllable && resolution.resolvedPath) {
+            resolvedPath = resolution.resolvedPath;
+          }
+        }
+
+        // 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: ExecutionFlow['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: ExecutionFlow = {
+            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: ExecutionFlow = {
+            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: ExecutionFlow['impact'] = usage.controlsJsxRendering
+              ? 'high'
+              : 'medium';
+
+            const requiredValues: ExecutionFlow['requiredValues'] =
+              allSources.map((source) => ({
+                attributePath: source.path,
+                value: 'falsy',
+                comparison: 'falsy' as const,
+                valueType: 'boolean' as const,
+              }));
+
+            // Create a single falsy flow with all sources
+            const falsyFlow: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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: ExecutionFlow['impact'] = usage.controlsJsxRendering
+              ? 'high'
+              : 'medium';
+
+            const requiredValues: ExecutionFlow['requiredValues'] =
+              allSources.map((source) => ({
+                attributePath: source.path,
+                value: 'truthy',
+                comparison: 'truthy' as const,
+                valueType: 'boolean' as const,
+              }));
+
+            // Create a truthy flow with all sources
+            const truthyFlow: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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,
+            );
+
+            if (resolution.isControllable && resolution.resolvedPath) {
+              resolvedPath = resolution.resolvedPath;
+              break;
+            }
+          }
+        }
+      }
+
+      if (!resolvedPath) {
+        // Path is not controllable - skip (no invalid flows possible)
+        continue;
+      }
+
+      // Normalize the resolved path to detect duplicates
+      // E.g., both "hasNewerVersion" and "useLoaderData<...>().hasNewerVersion"
+      // should normalize to the same canonical path
+      const normalizedPath = normalizePathForDeduplication(
+        resolvedPath,
+        fullToShortPathMap,
+      );
+
+      // 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)) {
+        continue;
+      }
+      seenNormalizedPaths.add(normalizedPath);
+
+      // Generate flows for this controllable usage
+      const usageFlows = generateFlowsFromUsage(usage, resolvedPath);
+
+      for (const flow of usageFlows) {
+        // Deduplicate by flow ID
+        if (!seenFlowIds.has(flow.id)) {
+          seenFlowIds.add(flow.id);
+          flows.push(flow);
+        }
+      }
+    }
+  }
+
+  // Process compound conditionals
+  for (const compound of compoundConditionals) {
+    // 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<string, string>();
+      // Track expanded sources for derived variables (path -> array of expanded sources)
+      const expandedSources = new Map<
+        string,
+        Array<{ path: string; operation?: DerivedVariableOperation }>
+      >();
+      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);
+        }
+      }
+
+      // 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: ExecutionFlow['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: string;
+                let comparison: ExecutionFlow['requiredValues'][0]['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' as const,
+                });
+              }
+            } else {
+              // This condition was resolved directly
+              const resolvedPath = resolvedPaths.get(condition.path);
+              if (resolvedPath) {
+                let value: string;
+                let comparison: ExecutionFlow['requiredValues'][0]['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: ExecutionFlow['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: 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 ')}`,
+              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);
+          }
+        }
+      }
+    }
+  }
+
+  // Process child component conditional usages
+  // Translate child paths to parent paths and merge flows
+  if (childComponentData) {
+    for (const [childName, childData] of Object.entries(childComponentData)) {
+      // First, resolve gating conditions to get required values that must be added to all child flows
+      const gatingRequiredValues: Array<{
+        attributePath: string;
+        value: string;
+        comparison:
+          | 'truthy'
+          | 'falsy'
+          | 'equals'
+          | 'length>'
+          | 'length<'
+          | 'exists'
+          | 'not-exists';
+      }> = [];
+
+      if (childData.gatingConditions) {
+        for (const gatingCondition of childData.gatingConditions) {
+          // Try to resolve via derivedFrom first
+          let gatingPath = gatingCondition.path;
+          if (gatingCondition.derivedFrom?.sourcePath) {
+            gatingPath = gatingCondition.derivedFrom.sourcePath;
+          }
+
+          // Fix 32: Handle comparison expressions like "activeTab === 'scenarios'"
+          // Extract the variable name and the compared value
+          const comparisonMatch = gatingPath.match(
+            /^([a-zA-Z_][a-zA-Z0-9_]*)\s*(===?|!==?)\s*['"]?([^'"]+)['"]?$/,
+          );
+          if (comparisonMatch) {
+            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: string | null = 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 as any).isNegated === true;
+              const isNotEquals = operator === '!=' || operator === '!==';
+              // Determine the effective value for this gating condition
+              // If condition is "activeTab === 'scenarios'" and NOT negated, flow needs activeTab = 'scenarios'
+              // If condition is "activeTab === 'scenarios'" and IS negated, flow needs activeTab != 'scenarios' (falsy/other value)
+              // If condition is "activeTab !== 'scenarios'" and NOT negated, flow needs activeTab != 'scenarios'
+              // XOR logic: isNegated XOR isNotEquals
+              const needsExactValue = isNegated !== isNotEquals;
+
+              gatingRequiredValues.push({
+                attributePath: resolvedVarPath,
+                value: needsExactValue ? 'falsy' : comparedValue,
+                comparison: needsExactValue ? 'falsy' : 'equals',
+              });
+              continue; // Skip to next gating condition
+            }
+          }
+
+          // Fix 31: Handle compound gating conditions (containing && or ||)
+          // e.g., "isEditMode && selectedScenario" should be parsed into individual paths
+          const isAndExpression = gatingPath.includes(' && ');
+          const isOrExpression = gatingPath.includes(' || ');
+          const isCompoundExpression = isAndExpression || isOrExpression;
+
+          if (isCompoundExpression) {
+            // Parse the compound expression into individual variable names
+            // Split on && and || (with optional spaces)
+            const parts = gatingPath.split(/\s*(?:&&|\|\|)\s*/);
+            const isNegated = (gatingCondition as any).isNegated === true;
+
+            // Fix 37: Apply DeMorgan's law correctly for compound conditions
+            // - !(A && B) = !A || !B: EITHER A is false OR B is false (can't know which)
+            // - !(A || B) = !A && !B: BOTH must be false
+            // - (A && B): BOTH must be true
+            // - (A || B): EITHER is true (can't know which)
+            //
+            // We should only add gating requirements when we can definitively say
+            // all parts must have the same value. This is true for:
+            // - Non-negated &&: all parts must be truthy
+            // - Negated ||: all parts must be falsy (DeMorgan: !(A || B) = !A && !B)
+            //
+            // We should NOT add gating requirements when either part could be true/false:
+            // - Negated && (DeMorgan: !(A && B) = !A || !B): can't constrain both to falsy
+            // - Non-negated ||: can't constrain both to truthy
+            const shouldSkipGating =
+              (isAndExpression && isNegated) || // !(A && B) - either could be falsy
+              (isOrExpression && !isNegated); // (A || B) - either could be truthy
+
+            if (shouldSkipGating) {
+              // Don't add gating requirements for this compound condition
+              // The child flow's own requirements will determine what values are needed
+            } else {
+              for (const part of parts) {
+                // Clean up the part (remove parentheses, negation, etc.)
+                const cleanPart = part
+                  .replace(/^\(+|\)+$/g, '') // Remove leading/trailing parens
+                  .replace(/^!+/, '') // Remove leading negation
+                  .trim();
+
+                if (!cleanPart) continue;
+
+                // Try to resolve this individual path
+                const partResolution = resolvePathToControllable(
+                  cleanPart,
+                  attributesMap,
+                  equivalentSignatureVariables,
+                  fullToShortPathMap,
+                );
+
+                if (
+                  partResolution.isControllable &&
+                  partResolution.resolvedPath
+                ) {
+                  // For non-negated &&: all parts must be truthy
+                  // For negated ||: all parts must be falsy (DeMorgan: !(A || B) = !A && !B)
+                  gatingRequiredValues.push({
+                    attributePath: stripLengthSuffix(
+                      partResolution.resolvedPath,
+                    ),
+                    value: isNegated ? 'falsy' : 'truthy',
+                    comparison: isNegated ? 'falsy' : 'truthy',
+                  });
+                }
+              }
+            }
+          } else {
+            // 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: string | null = 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 as any).isNegated === true;
+              gatingRequiredValues.push({
+                attributePath: resolvedGatingPath,
+                value: isNegated ? 'falsy' : 'truthy',
+                comparison: isNegated ? 'falsy' : 'truthy',
+              });
+            }
+          }
+        }
+      }
+
+      // Track which child usages are part of compound conditionals (to avoid duplicates)
+      // Fix 33: Only skip usages that are part of compound conditionals, not all usages with chainIds
+      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)) {
+            continue;
+          }
+
+          // Determine the child path to translate
+          let childPath = usage.path;
+
+          // If the usage has derivedFrom, use the source path instead
+          if (usage.derivedFrom?.sourcePath) {
+            childPath = usage.derivedFrom.sourcePath;
+          }
+
+          if (shouldDebugChild) {
+            console.log(
+              `[DEBUG CHILD ${childName}] Processing usage path: ${usage.path}`,
+            );
+            console.log(
+              `[DEBUG CHILD ${childName}]   childPath (after derivedFrom): ${childPath}`,
+            );
+            console.log(
+              `[DEBUG CHILD ${childName}]   sourceDataPath: ${usage.sourceDataPath}`,
+            );
+          }
+
+          // Translate the child path to a parent path
+          let translatedPath = translateChildPathToParent(
+            childPath,
+            childData.equivalentSignatureVariables,
+            equivalentSignatureVariables,
+            childName,
+          );
+
+          if (shouldDebugChild) {
+            console.log(
+              `[DEBUG CHILD ${childName}]   translatedPath (from translateChildPathToParent): ${translatedPath}`,
+            );
+          }
+
+          // If translation failed but we have sourceDataPath, try to extract the prop path from it
+          // sourceDataPath format: "ChildName.signature[n].propPath.rest" → extract "propPath.rest"
+          if (!translatedPath && usage.sourceDataPath) {
+            const signatureMatch = usage.sourceDataPath.match(
+              /\.signature\[\d+\]\.(.+)$/,
+            );
+            if (signatureMatch) {
+              translatedPath = signatureMatch[1];
+              if (shouldDebugChild) {
+                console.log(
+                  `[DEBUG CHILD ${childName}]   translatedPath (from sourceDataPath regex): ${translatedPath}`,
+                );
+              }
+            }
+          }
+
+          if (!translatedPath) {
+            // Could not translate - skip this usage
+            if (shouldDebugChild) {
+              console.log(
+                `[DEBUG CHILD ${childName}]   SKIPPED - no translation found`,
+              );
+            }
+            continue;
+          }
+
+          // Now resolve the translated path in the parent context
+          // First, try standard resolution
+          const resolution = resolvePathToControllable(
+            translatedPath,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          if (shouldDebugChild) {
+            console.log(
+              `[DEBUG CHILD ${childName}]   resolvePathToControllable result:`,
+            );
+            console.log(
+              `[DEBUG CHILD ${childName}]     isControllable: ${resolution.isControllable}`,
+            );
+            console.log(
+              `[DEBUG CHILD ${childName}]     resolvedPath: ${resolution.resolvedPath}`,
+            );
+            console.log(
+              `[DEBUG CHILD ${childName}]     chain: ${resolution.resolutionChain.join(' -> ')}`,
+            );
+          }
+
+          // Only create flows for controllable paths (whitelist approach).
+          // If the path doesn't resolve to something in attributesMap, skip it.
+          // This prevents creating flows for useState values which are not
+          // 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: string | null = 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: 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;
+
+                    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;
+            }
+          }
+
+          // 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);
+
+          // Generate flows for this translated usage
+          // Create a modified usage with the translated path for flow generation
+          const translatedUsage: ConditionalUsage = {
+            ...usage,
+            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
+            if (gatingRequiredValues.length > 0) {
+              // Filter out any gating values that are already in the flow
+              const existingPaths = new Set(
+                flow.requiredValues.map((rv) => rv.attributePath),
+              );
+              const newGatingValues = gatingRequiredValues.filter(
+                (gv) => !existingPaths.has(gv.attributePath),
+              );
+              flow.requiredValues = [
+                ...flow.requiredValues,
+                ...newGatingValues,
+              ];
+
+              // Update the flow ID to include gating conditions
+              if (newGatingValues.length > 0) {
+                const gatingIdPart = newGatingValues
+                  .map((gv) => `${gv.attributePath}-${gv.value}`)
+                  .join('-');
+                flow.id = `${flow.id}-gated-${gatingIdPart}`;
+              }
+            }
+
+            if (!seenFlowIds.has(flow.id)) {
+              seenFlowIds.add(flow.id);
+              flows.push(flow);
+            }
+          }
+        }
+      }
+
+      // Process child's compound conditionals
+      for (const compound of childData.compoundConditionals) {
+        const resolvedPaths = new Map<string, string>();
+        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) {
+            allResolvable = false;
+            break;
+          }
+
+          const resolution = resolvePathToControllable(
+            translatedPath,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          // 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: string | null = 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, resolvedPath);
+        }
+
+        if (allResolvable && resolvedPaths.size > 0) {
+          const compoundFlow = generateFlowFromCompound(
+            compound,
+            resolvedPaths,
+          );
+          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: 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);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return flows;
+}