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

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

@@ -0,0 +1,1019 @@
+/**
+ * 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 } from './astScopes/types';
+import type { EnrichedConditionalUsage } from './worker/SerializableDataStructure';
+import resolvePathToControllable from './resolvePathToControllable';
+
+/** 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>;
+  /** 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[];
+}
+
+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>;
+  /** 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>;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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 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.
+ */
+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';
+
+  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: resolvedPath,
+          value: isNegated ? 'falsy' : 'truthy',
+          comparison: isNegated ? 'falsy' : 'truthy',
+          valueType: 'boolean',
+        },
+      ],
+      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: resolvedPath,
+          value: isNegated ? 'truthy' : 'falsy',
+          comparison: isNegated ? 'truthy' : 'falsy',
+          valueType: 'boolean',
+        },
+      ],
+      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: resolvedPath,
+            value: value,
+            comparison: 'equals',
+            valueType: inferValueType(value),
+          },
+        ],
+        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: 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,
+  };
+}
+
+/**
+ * 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>,
+  parentEquivalentSignatureVariables: Record<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"
+  const childPropPath = childEquivalentSignatureVariables[rootVar];
+
+  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"
+  const parentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+
+  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,
+  } = 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 { sourcePath, sourcePaths } = 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 multi-source derivations (or, and), try the first resolvable path
+        // This is a simplification - ideally we'd generate flows for each source
+        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) {
+    // First, check if ALL paths in this compound are controllable
+    const resolvedPaths = new Map<string, string>();
+    let allControllable = true;
+
+    for (const condition of compound.conditions) {
+      const resolution = resolvePathToControllable(
+        condition.path,
+        attributesMap,
+        equivalentSignatureVariables,
+        fullToShortPathMap,
+      );
+
+      if (!resolution.isControllable || !resolution.resolvedPath) {
+        allControllable = false;
+        break;
+      }
+
+      resolvedPaths.set(condition.path, resolution.resolvedPath);
+    }
+
+    // Only create a flow if ALL paths are controllable
+    if (allControllable && resolvedPaths.size > 0) {
+      const compoundFlow = generateFlowFromCompound(compound, resolvedPaths);
+      if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
+        seenFlowIds.add(compoundFlow.id);
+        flows.push(compoundFlow);
+      }
+    }
+  }
+
+  // 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,
+            );
+
+            if (varResolution.isControllable && varResolution.resolvedPath) {
+              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: varResolution.resolvedPath,
+                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: 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,
+            );
+
+            if (
+              gatingResolution.isControllable &&
+              gatingResolution.resolvedPath
+            ) {
+              // 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: gatingResolution.resolvedPath,
+                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) {
+          // 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;
+          }
+
+          // Translate the child path to a parent path
+          let translatedPath = translateChildPathToParent(
+            childPath,
+            childData.equivalentSignatureVariables,
+            equivalentSignatureVariables,
+            childName,
+          );
+
+          // 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 (!translatedPath) {
+            // Could not translate - skip this usage
+            continue;
+          }
+
+          // Now resolve the translated path in the parent context
+          const resolution = resolvePathToControllable(
+            translatedPath,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          if (!resolution.isControllable || !resolution.resolvedPath) {
+            // Path is not controllable in parent context
+            continue;
+          }
+
+          const resolvedPath = resolution.resolvedPath;
+
+          // Check for duplicates
+          const normalizedPath = normalizePathForDeduplication(
+            resolvedPath,
+            fullToShortPathMap,
+          );
+
+          if (seenNormalizedPaths.has(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,
+          );
+
+          // 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 allControllable = true;
+
+        for (const condition of compound.conditions) {
+          // Determine the child path to translate
+          const childPath = condition.path;
+
+          // Translate the child path to a parent path
+          const translatedPath = translateChildPathToParent(
+            childPath,
+            childData.equivalentSignatureVariables,
+            equivalentSignatureVariables,
+            childName,
+          );
+
+          if (!translatedPath) {
+            allControllable = false;
+            break;
+          }
+
+          const resolution = resolvePathToControllable(
+            translatedPath,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          if (!resolution.isControllable || !resolution.resolvedPath) {
+            allControllable = false;
+            break;
+          }
+
+          resolvedPaths.set(condition.path, resolution.resolvedPath);
+        }
+
+        if (allControllable && resolvedPaths.size > 0) {
+          const compoundFlow = generateFlowFromCompound(
+            compound,
+            resolvedPaths,
+          );
+          if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
+            seenFlowIds.add(compoundFlow.id);
+            flows.push(compoundFlow);
+          }
+        }
+      }
+    }
+  }
+
+  return flows;
+}