@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.1669d45

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

@@ -0,0 +1,742 @@
+/**
+ * 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";
+/**
+ * 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;
+}
+/**
+ * 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.
+ */
+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';
+    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, 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: 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, 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, } = 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 { 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();
+        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 = [];
+            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.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.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.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 = {
+                        ...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();
+                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;
+}
+//# sourceMappingURL=generateExecutionFlowsFromConditionals.js.map