@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.6e699e5

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

@@ -0,0 +1,1440 @@
+/**
+ * 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 resolvePathToControllable from "./resolvePathToControllable.js";
+import cleanPathOfNonTransformingFunctions from "./dataStructure/helpers/cleanPathOfNonTransformingFunctions.js";
+/**
+ * Recursively expands a derived variable to its leaf data sources.
+ *
+ * For OR expressions like `isAnalyzing = a || b || c`:
+ * - Returns all source paths [a, b, c] so they can all be set appropriately
+ *
+ * For nested derivations like `isAnalyzing = isInCurrentRun || isInQueue`:
+ * - Where `isInCurrentRun` is derived from `currentRun.entityShas.includes(x)`
+ * - Returns the final data sources: [currentRun.entityShas, queueState.jobs]
+ *
+ * @param path The variable path to expand
+ * @param conditionalUsages All conditional usages (to look up derivedFrom info)
+ * @param attributesMap Map of controllable paths
+ * @param equivalentSignatureVariables Variable-to-path mappings
+ * @param fullToShortPathMap Full-to-short path mappings
+ * @param visited Set of already-visited paths (prevents infinite recursion)
+ * @param derivedVariables Optional map of all derived variables (for intermediate tracing)
+ * @returns Array of resolved source paths that are controllable
+ */
+function expandDerivedVariableToSources(path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited = new Set(), derivedVariables) {
+    // Prevent infinite recursion
+    if (visited.has(path)) {
+        return [];
+    }
+    visited.add(path);
+    // First, check if this path is directly controllable
+    const directResolution = resolvePathToControllable(path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+    if (directResolution.isControllable && directResolution.resolvedPath) {
+        return [{ path: directResolution.resolvedPath }];
+    }
+    // Look up derivedFrom info for this path
+    // First check conditionalUsages, then fall back to derivedVariables
+    const usage = conditionalUsages[path]?.[0];
+    let derivedFrom = usage?.derivedFrom;
+    // CRITICAL: If not found in conditionalUsages, check derivedVariables
+    // This handles intermediate derived variables like `isInCurrentRun` that aren't
+    // directly used in conditionals but ARE derived from data sources
+    if (!derivedFrom && derivedVariables?.[path]) {
+        derivedFrom = derivedVariables[path];
+    }
+    if (!derivedFrom) {
+        return [];
+    }
+    const { operation, sourcePath, sourcePaths } = derivedFrom;
+    // For OR/AND operations, recursively expand all source paths
+    if ((operation === 'or' || operation === 'and') && sourcePaths) {
+        const allSources = [];
+        for (const sp of sourcePaths) {
+            const expanded = expandDerivedVariableToSources(sp, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+            // Add all expanded sources
+            for (const source of expanded) {
+                // Avoid duplicates
+                if (!allSources.some((s) => s.path === source.path)) {
+                    allSources.push(source);
+                }
+            }
+        }
+        return allSources;
+    }
+    // For single-source operations (arrayIncludes, arraySome, notNull, etc.)
+    if (sourcePath) {
+        // Try to resolve the source path directly
+        const sourceResolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+        if (sourceResolution.isControllable && sourceResolution.resolvedPath) {
+            return [{ path: sourceResolution.resolvedPath, operation }];
+        }
+        // If not directly resolvable, recursively expand
+        return expandDerivedVariableToSources(sourcePath, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+    }
+    return [];
+}
+/**
+ * Clean up sourceDataPath by removing redundant scope prefixes.
+ *
+ * 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) {
+    // 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) {
+    if (path.endsWith('.length')) {
+        return path.slice(0, -7); // Remove ".length" (7 characters)
+    }
+    return path;
+}
+/**
+ * Extract the controllable base path from a path that may contain method calls.
+ *
+ * This handles complex expressions like:
+ * - `scenarios.filter((s) => s.active).length` → `scenarios`
+ * - `users.some((u) => u.role === 'admin')` → `users`
+ * - `items.map(x => x.name).join(', ')` → `items`
+ *
+ * The controllable base is the path that can be mocked - we can control
+ * what `scenarios` contains, but we can't control what `.filter()` returns.
+ *
+ * @param path - The path that may contain method calls
+ * @returns The controllable base path with method calls stripped
+ */
+function extractControllableBase(path) {
+    // First strip .length suffix if present
+    const pathWithoutLength = stripLengthSuffix(path);
+    // Use cleanPathOfNonTransformingFunctions to strip method calls like .filter(), .some()
+    const cleanedPath = cleanPathOfNonTransformingFunctions(pathWithoutLength);
+    // If the cleaned path is different, return it
+    if (cleanedPath !== pathWithoutLength) {
+        return cleanedPath;
+    }
+    // Otherwise, return the path with just .length stripped
+    return pathWithoutLength;
+}
+/**
+ * Find a path in attributesMap, using fullToShortPathMap to verify the path is controllable.
+ *
+ * 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, attributesMap, fullToShortPathMap) {
+    // 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) {
+    // 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, value) {
+    // 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) {
+    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, resolvedPath) {
+    const flows = [];
+    const baseName = generateNameFromPath(resolvedPath);
+    // Determine impact based on whether this conditional controls JSX rendering
+    // Conditionals that control visual output are high-impact
+    const impact = usage.controlsJsxRendering
+        ? 'high'
+        : 'medium';
+    // When there's a constraintExpression, use the controllable base for attributePath
+    // and pass through the constraint for LLM reasoning
+    const hasConstraint = !!usage.constraintExpression;
+    const attributePath = hasConstraint
+        ? extractControllableBase(resolvedPath)
+        : stripLengthSuffix(resolvedPath);
+    const constraint = usage.constraintExpression;
+    if (usage.conditionType === 'truthiness') {
+        // Generate both truthy and falsy flows
+        const isNegated = usage.isNegated ?? false;
+        // 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, resolvedPaths) {
+    // Determine impact based on whether this compound conditional controls JSX rendering
+    const impact = compound.controlsJsxRendering
+        ? 'high'
+        : 'medium';
+    const 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;
+        let 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) {
+    // Separate conditions into mandatory (no orGroupId) and OR groups
+    const mandatory = conditions.filter((c) => !c.orGroupId);
+    const orGroups = new Map();
+    for (const condition of conditions) {
+        if (condition.orGroupId) {
+            const group = orGroups.get(condition.orGroupId) ?? [];
+            group.push(condition);
+            orGroups.set(condition.orGroupId, group);
+        }
+    }
+    // If no OR groups, return the original conditions
+    if (orGroups.size === 0) {
+        return [conditions];
+    }
+    // Generate all combinations by picking one condition from each OR group
+    const groupArrays = Array.from(orGroups.values());
+    const combinations = [];
+    function generateCombinations(index, current) {
+        if (index === groupArrays.length) {
+            // We've picked one from each OR group - combine with mandatory conditions
+            combinations.push([...mandatory, ...current]);
+            return;
+        }
+        // Pick each option from the current OR group
+        for (const option of groupArrays[index]) {
+            generateCombinations(index + 1, [...current, option]);
+        }
+    }
+    generateCombinations(0, []);
+    return combinations;
+}
+/**
+ * Generate execution flows from conditional usages using pure static analysis.
+ *
+ * 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, fullToShortPathMap) {
+    // 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, childEquivalentSignatureVariables, parentEquivalentSignatureVariables, childName) {
+    // 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;
+    let suffix;
+    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) {
+    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, } = args;
+    const flows = [];
+    const seenFlowIds = new Set();
+    // 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();
+    // 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 = 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 = usage.controlsJsxRendering
+                        ? 'high'
+                        : 'medium';
+                    const isNegated = usage.isNegated ?? false;
+                    // For equals derivation:
+                    // - Truthy check (!negated): needs value = comparedValue (equals)
+                    // - Falsy check (negated): needs value != comparedValue (notEquals)
+                    // For notEquals derivation: inverse of above
+                    const isEqualsDerivation = operation === 'equals';
+                    const truthyNeedsEquals = isEqualsDerivation !== isNegated;
+                    // Generate truthy flow
+                    const truthyFlow = {
+                        id: generateFlowId(usage.path, 'truthy'),
+                        name: `${baseName} True`,
+                        description: `When ${baseName.toLowerCase()} is truthy (${resolvedPath} ${truthyNeedsEquals ? '=' : '!='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'equals' : 'notEquals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Generate falsy flow
+                    const falsyFlow = {
+                        id: generateFlowId(usage.path, 'falsy'),
+                        name: `${baseName} False`,
+                        description: `When ${baseName.toLowerCase()} is falsy (${resolvedPath} ${truthyNeedsEquals ? '!=' : '='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'notEquals' : 'equals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Add flows and skip normal flow generation
+                    if (!seenFlowIds.has(truthyFlow.id)) {
+                        seenFlowIds.add(truthyFlow.id);
+                        flows.push(truthyFlow);
+                    }
+                    if (!seenFlowIds.has(falsyFlow.id)) {
+                        seenFlowIds.add(falsyFlow.id);
+                        flows.push(falsyFlow);
+                    }
+                    continue;
+                }
+                // For OR derivations with negation, we need ALL sources to be falsy
+                // e.g., !isBusy where isBusy = isRunning || isQueued || isPending
+                // For the falsy flow, ALL sources must be falsy
+                if (operation === 'or' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated === true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to falsy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'falsy',
+                            comparison: 'falsy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a single falsy flow with all sources
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy (all sources are falsy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a truthy flow - for OR, ANY source being truthy is sufficient
+                        // We use the first resolvable source for the truthy flow
+                        const firstSource = allSources[0];
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'truthy',
+                                    comparison: 'truthy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (falsy needs all sources, truthy needs one)
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For AND derivations without negation, we need ALL sources to be truthy
+                // e.g., isReady where isReady = hasData && isLoaded && isValid
+                // For the truthy flow, ALL sources must be truthy
+                // For negated AND (!isReady), ANY source being falsy is sufficient (fallback behavior)
+                if (operation === 'and' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated !== true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to truthy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'truthy',
+                            comparison: 'truthy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a truthy flow with all sources
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy (all sources are truthy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a falsy flow - for AND, ANY source being falsy is sufficient
+                        // We use the first resolvable source for the falsy flow
+                        const firstSource = allSources[0];
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'falsy',
+                                    comparison: 'falsy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (truthy needs all sources, falsy needs one)
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For multi-source derivations (or, and) without special handling,
+                // try the first resolvable path as a fallback
+                if (!resolvedPath && sourcePaths && sourcePaths.length > 0) {
+                    for (const sp of sourcePaths) {
+                        const resolution = resolvePathToControllable(sp, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        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();
+            // Track expanded sources for derived variables (path -> array of expanded sources)
+            const expandedSources = new Map();
+            let allControllable = true;
+            for (const condition of conditionSet) {
+                // Check if this condition path has derivation info
+                // First check conditionalUsages, then fall back to derivedVariables
+                const usagesForPath = conditionalUsages[condition.path];
+                let derivedFromInfo = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                // CRITICAL: Also check derivedVariables for intermediate derived variables
+                if (!derivedFromInfo && derivedVariables?.[condition.path]) {
+                    derivedFromInfo = derivedVariables[condition.path];
+                }
+                if (derivedFromInfo) {
+                    // This is a derived variable - expand to its sources
+                    const sources = expandDerivedVariableToSources(condition.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (sources.length > 0) {
+                        // Store the expanded sources for this condition
+                        expandedSources.set(condition.path, sources);
+                        // Use the first source's path for the resolvedPaths map (for ID generation)
+                        resolvedPaths.set(condition.path, sources[0].path);
+                    }
+                    else {
+                        // Derived variable but no controllable sources found
+                        allControllable = false;
+                        break;
+                    }
+                }
+                else {
+                    // Not a derived variable - resolve directly
+                    const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                    if (!resolution.isControllable || !resolution.resolvedPath) {
+                        allControllable = false;
+                        break;
+                    }
+                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                }
+            }
+            // Only create a flow if ALL paths are controllable
+            if (allControllable && resolvedPaths.size > 0) {
+                // If any conditions were expanded from derived variables, we need to build a custom flow
+                if (expandedSources.size > 0) {
+                    const requiredValues = [];
+                    for (const condition of conditionSet) {
+                        const sources = expandedSources.get(condition.path);
+                        if (sources) {
+                            // This condition was expanded - add all its sources
+                            // Determine the required value based on condition type and derivation operation
+                            const usagesForPath = conditionalUsages[condition.path];
+                            let expandedDerivedFrom = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                            // Also check derivedVariables for intermediate derived variables
+                            if (!expandedDerivedFrom && derivedVariables?.[condition.path]) {
+                                expandedDerivedFrom = derivedVariables[condition.path];
+                            }
+                            const operation = expandedDerivedFrom?.operation;
+                            for (const source of sources) {
+                                // For OR-derived truthy: ANY source truthy
+                                // For AND-derived truthy: ALL sources truthy
+                                // For negated: inverse
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    const isNegated = condition.isNegated === true;
+                                    // For OR: truthy needs ANY source truthy, falsy needs ALL sources falsy
+                                    // For AND: truthy needs ALL sources truthy, falsy needs ANY source falsy
+                                    // In compound conditionals, we generate the truthy path by default
+                                    // (the compound expression must be truthy)
+                                    if (operation === 'or') {
+                                        // For OR-derived, truthy means we need at least one source truthy
+                                        // We'll use the first source as truthy (simplification)
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else if (operation === 'and') {
+                                        // For AND-derived, truthy means ALL sources truthy
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else {
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    comparison = isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value = 'truthy';
+                                    comparison = 'truthy';
+                                }
+                                requiredValues.push({
+                                    attributePath: source.path,
+                                    value,
+                                    comparison,
+                                    valueType: 'boolean',
+                                });
+                            }
+                        }
+                        else {
+                            // This condition was resolved directly
+                            const resolvedPath = resolvedPaths.get(condition.path);
+                            if (resolvedPath) {
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    value = condition.isNegated ? 'falsy' : 'truthy';
+                                    comparison = condition.isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value =
+                                        condition.requiredValue?.toString() ??
+                                            condition.comparedValues?.[0] ??
+                                            'truthy';
+                                    comparison = 'equals';
+                                }
+                                requiredValues.push({
+                                    attributePath: stripLengthSuffix(resolvedPath),
+                                    value,
+                                    comparison,
+                                    valueType: inferValueType(value),
+                                });
+                            }
+                        }
+                    }
+                    if (requiredValues.length > 0) {
+                        const impact = compound.controlsJsxRendering ? 'high' : 'medium';
+                        // Generate a combined ID from all paths
+                        const pathParts = requiredValues
+                            .map((rv) => {
+                            const name = generateNameFromPath(rv.attributePath);
+                            return name.toLowerCase().replace(/\s+/g, '-');
+                        })
+                            .join('-and-');
+                        const compoundFlow = {
+                            id: `${pathParts}-${requiredValues.map((rv) => rv.value).join('-')}`,
+                            name: generateNameFromPath(requiredValues[0].attributePath),
+                            description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
+                            impact,
+                            requiredValues,
+                            sourceLocation: compound.sourceLocation,
+                        };
+                        if (!seenFlowIds.has(compoundFlow.id)) {
+                            seenFlowIds.add(compoundFlow.id);
+                            flows.push(compoundFlow);
+                        }
+                    }
+                }
+                else {
+                    // No derived variables - use the original generateFlowFromCompound
+                    // Create a modified compound with just this condition set
+                    const modifiedCompound = {
+                        ...compound,
+                        conditions: conditionSet,
+                    };
+                    const compoundFlow = generateFlowFromCompound(modifiedCompound, resolvedPaths);
+                    if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
+                        seenFlowIds.add(compoundFlow.id);
+                        flows.push(compoundFlow);
+                    }
+                }
+            }
+        }
+    }
+    // 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 = [];
+            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 = null;
+                        if (varResolution.isControllable && varResolution.resolvedPath) {
+                            resolvedVarPath = varResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedVarPath) {
+                            const isNegated = gatingCondition.isNegated === true;
+                            const isNotEquals = operator === '!=' || operator === '!==';
+                            // Determine the effective value for this gating condition
+                            // 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.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 = null;
+                        if (gatingResolution.isControllable &&
+                            gatingResolution.resolvedPath) {
+                            resolvedGatingPath = gatingResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedGatingPath) {
+                            // For truthiness conditions on gating, check if the condition is negated
+                            // e.g., ternary else branch: isError ? <ErrorView /> : <SuccessView />
+                            // SuccessView has isNegated: true, meaning it renders when isError is falsy
+                            const isNegated = gatingCondition.isNegated === true;
+                            gatingRequiredValues.push({
+                                attributePath: 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 = 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}`);
+                                    }
+                                }
+                            }
+                        }
+                        // 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 = {
+                        ...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();
+                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 = 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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return flows;
+}
+//# sourceMappingURL=generateExecutionFlowsFromConditionals.js.map