@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9

package/analyzer-template/packages/ai/src/lib/astScopes/processExpression.ts

@@ -19,6 +19,160 @@ import {
   unwrapExpression,
 } from './sharedPatterns';
 import { processBindingPattern } from './processBindings';
+import {
+  extractConditionalEffectsFromTernary,
+  findUseStateSetters,
+} from './conditionalEffectsExtractor';
+import { detectArrayDerivedPattern } from './arrayDerivationDetector';
+
+/**
+ * Extracts the component name from a JSX element.
+ * Returns null for intrinsic elements (div, span, etc.) since we only care about
+ * custom components for gating condition tracking.
+ *
+ * Examples:
+ * - <ChildViewer /> → "ChildViewer"
+ * - <ScenarioViewer scenario={...} /> → "ScenarioViewer"
+ * - <div> → null (intrinsic element)
+ */
+function getComponentNameFromJsx(
+  node: ts.JsxElement | ts.JsxSelfClosingElement,
+): string | null {
+  let tagName: ts.JsxTagNameExpression;
+
+  if (ts.isJsxElement(node)) {
+    tagName = node.openingElement.tagName;
+  } else {
+    tagName = node.tagName;
+  }
+
+  // Get the text of the tag name
+  const name = tagName.getText();
+
+  // Check if it's a custom component (starts with uppercase) vs intrinsic element
+  // Custom components start with uppercase: <MyComponent />
+  // Intrinsic elements start with lowercase: <div />
+  if (
+    name &&
+    name[0] === name[0].toUpperCase() &&
+    name[0] !== name[0].toLowerCase()
+  ) {
+    return name;
+  }
+
+  return null;
+}
+
+/**
+ * Extracts condition paths from a logical AND chain expression.
+ * Used for creating gating conditions for child components.
+ *
+ * Example: `hasData && isReady && <Component />` returns ['hasData', 'isReady']
+ */
+function extractConditionPathsFromAndChain(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+): string[] {
+  const paths: string[] = [];
+  const unwrapped = unwrapExpression(expr);
+
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Recursively get conditions from left side
+    paths.push(
+      ...extractConditionPathsFromAndChain(unwrapped.left, sourceFile),
+    );
+
+    // Process right side if it's not JSX (JSX is the consequence, not a condition)
+    const rightUnwrapped = unwrapExpression(unwrapped.right);
+    if (
+      !ts.isJsxElement(rightUnwrapped) &&
+      !ts.isJsxSelfClosingElement(rightUnwrapped) &&
+      !ts.isJsxFragment(rightUnwrapped)
+    ) {
+      paths.push(
+        ...extractConditionPathsFromAndChain(unwrapped.right, sourceFile),
+      );
+    }
+  } else {
+    // Base case: extract path from this expression
+    const path = StructuredPath.fromNode(unwrapped, sourceFile);
+    if (path) {
+      paths.push(path.toString());
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Finds the rightmost JSX element in an && chain.
+ * Example: `a && b && <Component />` returns <Component />
+ */
+function findJsxInAndChain(
+  expr: ts.Expression,
+): ts.JsxElement | ts.JsxSelfClosingElement | null {
+  const unwrapped = unwrapExpression(expr);
+
+  if (ts.isJsxElement(unwrapped) || ts.isJsxSelfClosingElement(unwrapped)) {
+    return unwrapped;
+  }
+
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Check right side first (most common case: condition && <Jsx />)
+    const rightResult = findJsxInAndChain(unwrapped.right);
+    if (rightResult) return rightResult;
+
+    // Also check left side for rare cases
+    return findJsxInAndChain(unwrapped.left);
+  }
+
+  return null;
+}
+
+/**
+ * Fix 32: Finds a JSX fragment in an && chain.
+ * Example: `activeTab && <><ChildA /><ChildB /></>` returns the fragment
+ * This is needed to propagate parent conditions through fragments.
+ */
+function findJsxFragmentInAndChain(expr: ts.Expression): ts.JsxFragment | null {
+  const unwrapped = unwrapExpression(expr);
+
+  if (ts.isJsxFragment(unwrapped)) {
+    return unwrapped;
+  }
+
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Check right side first (most common case: condition && <></>)
+    const rightResult = findJsxFragmentInAndChain(unwrapped.right);
+    if (rightResult) return rightResult;
+
+    // Also check left side for rare cases
+    return findJsxFragmentInAndChain(unwrapped.left);
+  }
+
+  return null;
+}
+
+/**
+ * Detects if a property access looks like an environment variable store access.
+ * Matches patterns like `env.DATABASE_URL`, `env.IS_FORMBRICKS_CLOUD`, etc.
+ * where the object is named "env" and the property looks like an env var name.
+ */
+function isEnvStoreAccess(fullText: string): boolean {
+  // Match: env.SOME_VAR or env.someVar (but object must be exactly "env")
+  // This catches patterns from @t3-oss/env-nextjs and similar packages
+  const envStorePattern = /^env\.[A-Z_][A-Z0-9_]*$/;
+  return envStorePattern.test(fullText);
+}
 
 /**
  * Converts a call expression argument to a StructuredPath.
@@ -215,6 +369,149 @@ function getSourceLocation(
   };
 }
 
+/**
+ * Extracts the root array path from an expression that ends with .map().
+ * Handles chained methods like .filter().map(), .slice().map(), etc.
+ *
+ * Examples:
+ * - items.map(...) → "items"
+ * - data.users.map(...) → "data.users"
+ * - items.filter(...).map(...) → "items"
+ * - items.slice(0, 5).map(...) → "items"
+ */
+function extractArrayPathFromMapCall(
+  expr: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+): string | null {
+  // Walk up the chain to find the root array
+  let current: ts.Expression = expr.expression;
+
+  while (ts.isPropertyAccessExpression(current)) {
+    const methodName = current.name.getText(sourceFile);
+
+    // Common array methods that return arrays (so we keep going up)
+    const arrayReturningMethods = [
+      'map',
+      'filter',
+      'slice',
+      'concat',
+      'flat',
+      'flatMap',
+      'reverse',
+      'sort',
+      'toReversed',
+      'toSorted',
+      'toSpliced',
+    ];
+
+    if (arrayReturningMethods.includes(methodName)) {
+      const objectExpr = current.expression;
+
+      // If the object is a call expression (chained method), keep going
+      if (ts.isCallExpression(objectExpr)) {
+        current = objectExpr.expression;
+      } else {
+        // Found the root - it's an identifier or property access
+        const path = StructuredPath.fromNode(objectExpr, sourceFile);
+        return path ? path.toString() : null;
+      }
+    } else {
+      // Not an array method we recognize
+      break;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extracts JSX rendering usages from a JSX expression.
+ * Detects:
+ * - array.map() calls → 'array-map' type
+ * - string interpolations (identifiers/property access) → 'text-interpolation' type
+ *
+ * Recursively searches inside && chains and ternary expressions.
+ *
+ * @param expr The expression inside {expr}
+ * @param context The analysis context
+ */
+function extractJsxRenderingUsage(
+  expr: ts.Expression,
+  context: AnalysisContext,
+): void {
+  const unwrapped = unwrapExpression(expr);
+  const sourceLocation = getSourceLocation(expr, context.sourceFile);
+
+  // Detect array.map() calls
+  if (ts.isCallExpression(unwrapped)) {
+    const calleeExpr = unwrapped.expression;
+
+    if (ts.isPropertyAccessExpression(calleeExpr)) {
+      const methodName = calleeExpr.name.getText(context.sourceFile);
+
+      if (methodName === 'map') {
+        const arrayPath = extractArrayPathFromMapCall(
+          unwrapped,
+          context.sourceFile,
+        );
+
+        if (arrayPath) {
+          context.addJsxRenderingUsage({
+            path: arrayPath,
+            renderingType: 'array-map',
+            valueType: 'array',
+            sourceLocation,
+          });
+        }
+      }
+    }
+  }
+  // Detect simple string interpolations: {title} or {user.name}
+  else if (
+    ts.isIdentifier(unwrapped) ||
+    ts.isPropertyAccessExpression(unwrapped)
+  ) {
+    const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+
+    if (path) {
+      const pathStr = path.toString();
+      const typeInfo = context.getTypeInfo(path);
+
+      // Only track as text interpolation if it's a string type
+      // Check for 'string' type, or types that contain 'string' (but not 'string[]')
+      if (
+        typeInfo === 'string' ||
+        (typeInfo &&
+          typeInfo.includes('string') &&
+          !typeInfo.includes('string[]'))
+      ) {
+        context.addJsxRenderingUsage({
+          path: pathStr,
+          renderingType: 'text-interpolation',
+          valueType: 'string',
+          sourceLocation,
+        });
+      }
+    }
+  }
+  // Recursively search inside && chains: {showList && items.map(...)}
+  else if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Check the right side of the && chain (where .map() typically appears)
+    const rightSide = unwrapExpression(unwrapped.right);
+    extractJsxRenderingUsage(rightSide, context);
+    // Also check nested && chains on the left
+    extractJsxRenderingUsage(unwrapped.left, context);
+  }
+  // Recursively search inside ternaries: {isEmpty ? null : items.map(...)}
+  else if (ts.isConditionalExpression(unwrapped)) {
+    extractJsxRenderingUsage(unwrapped.whenTrue, context);
+    extractJsxRenderingUsage(unwrapped.whenFalse, context);
+  }
+}
+
 /**
  * Counts the number of conditions in an && chain (excluding JSX consequence)
  */
@@ -251,6 +548,430 @@ interface ChainInfo {
   chainExpression: string;
   currentPosition: number;
   compound: CompoundConditional;
+  /**
+   * When processing OR expressions within an && chain, this tracks the
+   * current OR group ID. Conditions added while this is set will be marked
+   * as OR alternatives (only one needs to be true).
+   */
+  currentOrGroupId?: string;
+}
+
+/**
+ * Parent gating condition accumulated during JSX traversal.
+ * Used to track conditions from parent && chains that gate child components.
+ */
+interface ParentGatingCondition {
+  path: string;
+  sourceLocation: { lineNumber: number; column: number; codeSnippet: string };
+  isNegated?: boolean;
+}
+
+/**
+ * Extracts conditionals from JSX elements by recursively traversing children.
+ *
+ * This is CRITICAL for extracting compound conditionals from JSX expressions
+ * like `{hasNewerVersion && !isActive && <Banner />}`.
+ *
+ * This function is called BEFORE the child boundary check in processExpression
+ * because JSX elements are NOT scopes - their expressions use variables from
+ * the parent scope and should have their conditionals extracted regardless of
+ * whether the JSX is within a child boundary.
+ *
+ * Fix 32: Added parentConditions parameter to track gating conditions from
+ * parent && chains. When we find a component nested inside multiple conditionals
+ * like `{activeTab && <>{ternary ? ... : <Component />}</>}`, ALL parent
+ * conditions should be added as gating conditions for the component.
+ *
+ * @param node The JSX element, self-closing element, or fragment to traverse
+ * @param context The analysis context
+ * @param parentConditions Accumulated gating conditions from parent && chains
+ */
+function extractConditionalsFromJsx(
+  node: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment,
+  context: AnalysisContext,
+  parentConditions: ParentGatingCondition[] = [],
+): void {
+  // Get children to process
+  let children: ts.NodeArray<ts.JsxChild> | undefined;
+
+  if (ts.isJsxElement(node)) {
+    children = node.children;
+  } else if (ts.isJsxFragment(node)) {
+    children = node.children;
+  }
+  // JsxSelfClosingElement has no children
+
+  if (!children) {
+    return;
+  }
+
+  for (const child of children) {
+    // Process JSX expressions: {expr}
+    if (ts.isJsxExpression(child) && child.expression) {
+      const expr = unwrapExpression(child.expression);
+
+      // Extract JSX rendering usages (array.map, text interpolation)
+      // This handles direct usages like {items.map(...)} or {user.name}
+      extractJsxRenderingUsage(expr, context);
+
+      // If the expression is an && chain, extract its conditional usages
+      if (
+        ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+      ) {
+        // Mark nullable variables
+        markConditionVariablesAsNullable(expr, context);
+        // Extract conditional usage (this handles compound conditionals)
+        // Pass controlsJsxRendering: true since this conditional controls JSX rendering
+        extractConditionalUsage(expr, context, 'logical-and', {
+          controlsJsxRendering: true,
+        });
+
+        // Extract all condition paths from the && chain for gating tracking
+        const conditionPaths = extractConditionPathsFromAndChain(
+          expr,
+          context.sourceFile,
+        );
+        const sourceLocation = getSourceLocation(expr, context.sourceFile);
+
+        // Fix 32: Build accumulated conditions including parent conditions
+        const accumulatedConditions: ParentGatingCondition[] = [
+          ...parentConditions,
+          ...conditionPaths.map((path) => ({
+            path,
+            sourceLocation,
+            isNegated: false,
+          })),
+        ];
+
+        // Track gating conditions for child components
+        // Example: {hasAnalysis && <ScenarioViewer />}
+        const jsxElement = findJsxInAndChain(expr);
+        if (jsxElement) {
+          const componentName = getComponentNameFromJsx(jsxElement);
+          if (componentName) {
+            // Fix 32: Add ALL accumulated conditions (parent + current) as gating conditions
+            for (const condition of accumulatedConditions) {
+              context.addChildBoundaryGatingCondition(componentName, {
+                path: condition.path,
+                conditionType: 'truthiness',
+                location: 'logical-and',
+                sourceLocation: condition.sourceLocation,
+                controlsJsxRendering: true,
+                isNegated: condition.isNegated,
+              });
+            }
+          }
+
+          // Fix 32: Recursively process nested JSX with accumulated conditions
+          if (
+            ts.isJsxElement(jsxElement) ||
+            ts.isJsxSelfClosingElement(jsxElement)
+          ) {
+            extractConditionalsFromJsx(
+              jsxElement,
+              context,
+              accumulatedConditions,
+            );
+          }
+        }
+
+        // Fix 32: Also check for nested JSX fragments
+        const jsxFragment = findJsxFragmentInAndChain(expr);
+        if (jsxFragment) {
+          extractConditionalsFromJsx(
+            jsxFragment,
+            context,
+            accumulatedConditions,
+          );
+        }
+      }
+      // If the expression is a ternary, extract its conditional
+      else if (ts.isConditionalExpression(expr)) {
+        // Pass controlsJsxRendering: true since this conditional controls JSX rendering
+        extractConditionalUsage(expr.condition, context, 'ternary', {
+          controlsJsxRendering: true,
+        });
+
+        // Track gating conditions for components in both branches of the ternary
+        // Example: {isError ? <ErrorView /> : <SuccessView />}
+        const conditionPath = StructuredPath.fromNode(
+          unwrapExpression(expr.condition),
+          context.sourceFile,
+        );
+        const sourceLocation = getSourceLocation(expr, context.sourceFile);
+
+        // Recursively process the whenTrue and whenFalse branches for JSX
+        const whenTrue = unwrapExpression(expr.whenTrue);
+        const whenFalse = unwrapExpression(expr.whenFalse);
+
+        // Fix 32: Build conditions for whenTrue branch (parent conditions + ternary condition truthy)
+        const whenTrueConditions: ParentGatingCondition[] = [
+          ...parentConditions,
+          ...(conditionPath
+            ? [
+                {
+                  path: conditionPath.toString(),
+                  sourceLocation,
+                  isNegated: false,
+                },
+              ]
+            : []),
+        ];
+
+        // Fix 32: Build conditions for whenFalse branch (parent conditions + ternary condition falsy)
+        const whenFalseConditions: ParentGatingCondition[] = [
+          ...parentConditions,
+          ...(conditionPath
+            ? [
+                {
+                  path: conditionPath.toString(),
+                  sourceLocation,
+                  isNegated: true,
+                },
+              ]
+            : []),
+        ];
+
+        // Handle whenTrue branch (condition is truthy)
+        if (ts.isJsxElement(whenTrue) || ts.isJsxSelfClosingElement(whenTrue)) {
+          const componentName = getComponentNameFromJsx(whenTrue);
+          if (componentName) {
+            // Fix 32: Add ALL conditions (parent + ternary) as gating conditions
+            for (const condition of whenTrueConditions) {
+              context.addChildBoundaryGatingCondition(componentName, {
+                path: condition.path,
+                conditionType: 'truthiness',
+                location: 'ternary',
+                sourceLocation: condition.sourceLocation,
+                controlsJsxRendering: true,
+                isNegated: condition.isNegated,
+              });
+            }
+          }
+        }
+        if (
+          ts.isJsxElement(whenTrue) ||
+          ts.isJsxSelfClosingElement(whenTrue) ||
+          ts.isJsxFragment(whenTrue)
+        ) {
+          extractConditionalsFromJsx(whenTrue, context, whenTrueConditions);
+        }
+
+        // Handle whenFalse branch (condition is falsy/negated)
+        if (
+          ts.isJsxElement(whenFalse) ||
+          ts.isJsxSelfClosingElement(whenFalse)
+        ) {
+          const componentName = getComponentNameFromJsx(whenFalse);
+          if (componentName) {
+            // Fix 32: Add ALL conditions (parent + ternary) as gating conditions
+            for (const condition of whenFalseConditions) {
+              context.addChildBoundaryGatingCondition(componentName, {
+                path: condition.path,
+                conditionType: 'truthiness',
+                location: 'ternary',
+                sourceLocation: condition.sourceLocation,
+                controlsJsxRendering: true,
+                isNegated: condition.isNegated,
+              });
+            }
+          }
+        }
+        if (
+          ts.isJsxElement(whenFalse) ||
+          ts.isJsxSelfClosingElement(whenFalse) ||
+          ts.isJsxFragment(whenFalse)
+        ) {
+          extractConditionalsFromJsx(whenFalse, context, whenFalseConditions);
+        }
+        // Handle chained ternaries: a ? <A/> : b ? <B/> : <C/>
+        // When whenFalse is another ConditionalExpression, recursively process it
+        else if (ts.isConditionalExpression(whenFalse)) {
+          // Extract conditional usage for the nested ternary's condition
+          extractConditionalUsage(whenFalse.condition, context, 'ternary', {
+            controlsJsxRendering: true,
+          });
+
+          // Get the nested condition path
+          const nestedConditionPath = StructuredPath.fromNode(
+            unwrapExpression(whenFalse.condition),
+            context.sourceFile,
+          );
+          const nestedSourceLocation = getSourceLocation(
+            whenFalse,
+            context.sourceFile,
+          );
+
+          const nestedWhenTrue = unwrapExpression(whenFalse.whenTrue);
+          const nestedWhenFalse = unwrapExpression(whenFalse.whenFalse);
+
+          // Fix 32: Build conditions for nested whenTrue (parent falsy + nested truthy)
+          const nestedWhenTrueConditions: ParentGatingCondition[] = [
+            ...whenFalseConditions, // Parent ternary was falsy to get here
+            ...(nestedConditionPath
+              ? [
+                  {
+                    path: nestedConditionPath.toString(),
+                    sourceLocation: nestedSourceLocation,
+                    isNegated: false,
+                  },
+                ]
+              : []),
+          ];
+
+          // Fix 32: Build conditions for nested whenFalse (parent falsy + nested falsy)
+          const nestedWhenFalseConditions: ParentGatingCondition[] = [
+            ...whenFalseConditions, // Parent ternary was falsy to get here
+            ...(nestedConditionPath
+              ? [
+                  {
+                    path: nestedConditionPath.toString(),
+                    sourceLocation: nestedSourceLocation,
+                    isNegated: true,
+                  },
+                ]
+              : []),
+          ];
+
+          // Handle nested whenTrue branch
+          if (
+            ts.isJsxElement(nestedWhenTrue) ||
+            ts.isJsxSelfClosingElement(nestedWhenTrue)
+          ) {
+            const componentName = getComponentNameFromJsx(nestedWhenTrue);
+            if (componentName) {
+              // Fix 32: Add ALL accumulated conditions
+              for (const condition of nestedWhenTrueConditions) {
+                context.addChildBoundaryGatingCondition(componentName, {
+                  path: condition.path,
+                  conditionType: 'truthiness',
+                  location: 'ternary',
+                  sourceLocation: condition.sourceLocation,
+                  controlsJsxRendering: true,
+                  isNegated: condition.isNegated,
+                });
+              }
+            }
+          }
+          if (
+            ts.isJsxElement(nestedWhenTrue) ||
+            ts.isJsxSelfClosingElement(nestedWhenTrue) ||
+            ts.isJsxFragment(nestedWhenTrue)
+          ) {
+            extractConditionalsFromJsx(
+              nestedWhenTrue,
+              context,
+              nestedWhenTrueConditions,
+            );
+          }
+
+          // Handle nested whenFalse branch (this could be another chained ternary or JSX)
+          if (
+            ts.isJsxElement(nestedWhenFalse) ||
+            ts.isJsxSelfClosingElement(nestedWhenFalse)
+          ) {
+            const componentName = getComponentNameFromJsx(nestedWhenFalse);
+            if (componentName) {
+              // Fix 32: Add ALL accumulated conditions
+              for (const condition of nestedWhenFalseConditions) {
+                context.addChildBoundaryGatingCondition(componentName, {
+                  path: condition.path,
+                  conditionType: 'truthiness',
+                  location: 'ternary',
+                  sourceLocation: condition.sourceLocation,
+                  controlsJsxRendering: true,
+                  isNegated: condition.isNegated,
+                });
+              }
+            }
+          }
+          if (
+            ts.isJsxElement(nestedWhenFalse) ||
+            ts.isJsxSelfClosingElement(nestedWhenFalse) ||
+            ts.isJsxFragment(nestedWhenFalse)
+          ) {
+            extractConditionalsFromJsx(
+              nestedWhenFalse,
+              context,
+              nestedWhenFalseConditions,
+            );
+          }
+          // If nestedWhenFalse is yet another ConditionalExpression, the recursion
+          // will handle it on the next iteration when this function processes it
+          else if (ts.isConditionalExpression(nestedWhenFalse)) {
+            // Recursively handle deeper nesting by wrapping in a synthetic process
+            // We create a fake JsxExpression context to reuse the same logic
+            const syntheticChild = {
+              kind: ts.SyntaxKind.JsxExpression,
+              expression: nestedWhenFalse,
+            } as unknown as ts.JsxExpression;
+            // Process via the main JSX expression handler by recursing
+            // For now, just extract conditionals directly
+            extractConditionalUsage(
+              nestedWhenFalse.condition,
+              context,
+              'ternary',
+              { controlsJsxRendering: true },
+            );
+          }
+        }
+      }
+    }
+    // Recursively process nested JSX elements - Fix 32: pass parent conditions
+    else if (ts.isJsxElement(child)) {
+      // Check if this is a user-defined component (vs intrinsic element like div)
+      // If it's a component AND there are parent conditions, record the gating conditions
+      const componentName = getComponentNameFromJsx(child);
+      if (componentName && parentConditions.length > 0) {
+        for (const condition of parentConditions) {
+          context.addChildBoundaryGatingCondition(componentName, {
+            path: condition.path,
+            conditionType: 'truthiness',
+            location: 'ternary',
+            sourceLocation: condition.sourceLocation,
+            controlsJsxRendering: true,
+            isNegated: condition.isNegated,
+          });
+        }
+      }
+      extractConditionalsFromJsx(child, context, parentConditions);
+    }
+    // Handle self-closing JSX elements (e.g., <ScenarioViewer />)
+    else if (ts.isJsxSelfClosingElement(child)) {
+      // Check if this is a user-defined component (vs intrinsic element like div)
+      // If it's a component AND there are parent conditions, record the gating conditions
+      const componentName = getComponentNameFromJsx(child);
+      if (componentName && parentConditions.length > 0) {
+        for (const condition of parentConditions) {
+          context.addChildBoundaryGatingCondition(componentName, {
+            path: condition.path,
+            conditionType: 'truthiness',
+            location: 'ternary',
+            sourceLocation: condition.sourceLocation,
+            controlsJsxRendering: true,
+            isNegated: condition.isNegated,
+          });
+        }
+      }
+      // Self-closing elements have no children, so no recursion needed
+    }
+    // Recursively process nested JSX fragments - Fix 32: pass parent conditions
+    else if (ts.isJsxFragment(child)) {
+      extractConditionalsFromJsx(child, context, parentConditions);
+    }
+  }
+}
+
+/**
+ * Options for extractConditionalUsage
+ */
+interface ExtractConditionalOptions {
+  /**
+   * Whether this conditional controls JSX rendering.
+   * Set to true when the conditional appears in a JSX expression like {cond && <Component />}
+   */
+  controlsJsxRendering?: boolean;
 }
 
 /**
@@ -261,12 +982,15 @@ interface ChainInfo {
  * @param condition The condition expression to analyze
  * @param context The analysis context
  * @param location Where this condition appears (if, ternary, logical-and, switch)
+ * @param options Additional options including controlsJsxRendering flag
  */
 export function extractConditionalUsage(
   condition: ts.Expression,
   context: AnalysisContext,
   location: ConditionalUsage['location'],
+  options: ExtractConditionalOptions = {},
 ): void {
+  const { controlsJsxRendering } = options;
   // Internal recursive function with chain tracking
   function extractWithChainTracking(
     expr: ts.Expression,
@@ -300,6 +1024,7 @@ export function extractConditionalUsage(
             conditions: [],
             location,
             sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+            controlsJsxRendering,
           };
           chainInfo = {
             chainId,
@@ -333,14 +1058,37 @@ export function extractConditionalUsage(
     }
 
     // Handle binary expressions with || (logical OR)
-    // OR breaks the chain - each side is independent
+    // When OR is inside an && chain, we need to continue chain tracking
+    // and mark conditions as OR alternatives
     if (
       ts.isBinaryExpression(unwrapped) &&
       unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken
     ) {
-      // Both sides of || are independent conditional checks (no chain tracking)
-      extractWithChainTracking(unwrapped.left, null, false);
-      extractWithChainTracking(unwrapped.right, null, false);
+      if (chainInfo) {
+        // We're inside an && chain - continue tracking but mark as OR alternatives
+        // Generate an orGroupId so conditions from both sides can be grouped
+        const orGroupId =
+          chainInfo.currentOrGroupId ?? `or_${crypto.randomUUID().slice(0, 8)}`;
+
+        // Process left side with OR group tracking
+        const leftChainInfo = {
+          ...chainInfo,
+          currentOrGroupId: orGroupId,
+        };
+        extractWithChainTracking(unwrapped.left, leftChainInfo, false);
+
+        // Process right side with same OR group
+        // Note: we use leftChainInfo's currentPosition which may have been updated
+        const rightChainInfo = {
+          ...leftChainInfo,
+          currentPosition: chainInfo.currentPosition,
+        };
+        extractWithChainTracking(unwrapped.right, rightChainInfo, false);
+      } else {
+        // Not inside a chain - OR breaks into independent conditional checks
+        extractWithChainTracking(unwrapped.left, null, false);
+        extractWithChainTracking(unwrapped.right, null, false);
+      }
       return;
     }
 
@@ -385,6 +1133,7 @@ export function extractConditionalUsage(
         conditionType: 'comparison' | 'truthiness',
         comparedValues?: string[],
         requiredValue?: string | boolean,
+        sourceExpr?: ts.Expression,
       ) => {
         const usage: ConditionalUsage = {
           path,
@@ -393,8 +1142,20 @@ export function extractConditionalUsage(
           location,
           sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
           isNegated,
+          controlsJsxRendering,
         };
 
+        // Check for inline array-derived patterns (.length) on the source expression
+        if (sourceExpr) {
+          const arrayDerived = detectArrayDerivedPattern(sourceExpr);
+          if (arrayDerived) {
+            usage.derivedFrom = {
+              operation: arrayDerived.operation,
+              sourcePath: arrayDerived.sourcePath,
+            };
+          }
+        }
+
         // Add chain info if part of a compound conditional
         if (chainInfo) {
           usage.chainId = chainInfo.chainId;
@@ -410,6 +1171,9 @@ export function extractConditionalUsage(
             comparedValues,
             isNegated,
             requiredValue,
+            ...(chainInfo.currentOrGroupId && {
+              orGroupId: chainInfo.currentOrGroupId,
+            }),
           });
         }
 
@@ -424,6 +1188,7 @@ export function extractConditionalUsage(
           'comparison',
           literalValue !== undefined ? [literalValue] : undefined,
           getRequiredValue(literalValue, isNegated),
+          unwrapped.left, // Pass source expression for array derivation detection
         );
         return;
       }
@@ -436,16 +1201,29 @@ export function extractConditionalUsage(
           'comparison',
           literalValue !== undefined ? [literalValue] : undefined,
           getRequiredValue(literalValue, isNegated),
+          unwrapped.right, // Pass source expression for array derivation detection
         );
         return;
       }
 
       // Both sides are variables - record both as comparisons without specific values
       if (leftPath) {
-        addCondition(leftPath.toLeftHandSideString(), 'comparison');
+        addCondition(
+          leftPath.toLeftHandSideString(),
+          'comparison',
+          undefined,
+          undefined,
+          unwrapped.left,
+        );
       }
       if (rightPath) {
-        addCondition(rightPath.toLeftHandSideString(), 'comparison');
+        addCondition(
+          rightPath.toLeftHandSideString(),
+          'comparison',
+          undefined,
+          undefined,
+          unwrapped.right,
+        );
       }
       return;
     }
@@ -471,8 +1249,19 @@ export function extractConditionalUsage(
         location,
         sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
         isNegated,
+        controlsJsxRendering,
       };
 
+      // Check for inline array-derived patterns (.some(), .every(), .includes(), .length)
+      // This populates derivedFrom so downstream code can resolve to the base array path
+      const arrayDerived = detectArrayDerivedPattern(unwrapped);
+      if (arrayDerived) {
+        usage.derivedFrom = {
+          operation: arrayDerived.operation,
+          sourcePath: arrayDerived.sourcePath,
+        };
+      }
+
       // Add chain info if part of a compound conditional
       if (chainInfo) {
         usage.chainId = chainInfo.chainId;
@@ -488,6 +1277,9 @@ export function extractConditionalUsage(
           conditionType: 'truthiness',
           isNegated,
           requiredValue: !isNegated,
+          ...(chainInfo.currentOrGroupId && {
+            orGroupId: chainInfo.currentOrGroupId,
+          }),
         });
       }
 
@@ -611,6 +1403,18 @@ export function processExpression({
     }
   }
 
+  // CRITICAL: Extract conditionals from JSX BEFORE checking child boundaries
+  // JSX elements are NOT scopes - their expressions use variables from the parent scope.
+  // Even if the JSX element is within a child boundary (e.g., because it contains callbacks),
+  // we must still extract conditionals from JSX expression children like {x && <div>...</div>}
+  if (
+    ts.isJsxElement(unwrappedNode) ||
+    ts.isJsxSelfClosingElement(unwrappedNode) ||
+    ts.isJsxFragment(unwrappedNode)
+  ) {
+    extractConditionalsFromJsx(unwrappedNode, context);
+  }
+
   // If the node falls within an excluded child scope, stop processing it.
   if (context.isChildBoundary(node)) {
     return true;
@@ -802,7 +1606,8 @@ export function processExpression({
     // Check if this is an environment variable access
     const fullText = unwrappedNode.getText(context.sourceFile);
     if (
-      fullText.includes('.env.') // simple heuristic for env var access but not great
+      fullText.includes('.env.') || // process.env.X, window.env.X
+      isEnvStoreAccess(fullText) // env.X where env is likely an env config object
     ) {
       context.addEnvironmentVariable(fullText);
     }
@@ -1109,6 +1914,14 @@ export function processExpression({
         // e.g., `const tab = segments[0] || 'default'` should trace tab back to segments[0]
         if (operatorKind === ts.SyntaxKind.QuestionQuestionToken) {
           // specifically for ?? we create an equivalence to the left side
+          // IMPORTANT: Also process the left side recursively to apply method semantics
+          // (e.g., for `const segments = splat?.split('/') ?? []`, we need split semantics)
+          processExpression({
+            node: unwrappedNode.left,
+            context,
+            // Don't pass targetPath here - we'll establish equivalence separately below
+          });
+
           if (targetPath) {
             resultPath = StructuredPath.fromNode(
               unwrappedNode.left,
@@ -1126,15 +1939,31 @@ export function processExpression({
             );
           }
         } else if (operatorKind === ts.SyntaxKind.BarBarToken) {
-          // For ||, also create an equivalence to the left side
+          // For ||, create equivalences to BOTH sides
           // This enables data flow tracing through fallback expressions
+          // e.g., `const item = items.find(...) || null` should trace to both:
+          //   - items[] (from the find result)
+          //   - null (from the fallback)
           if (targetPath) {
+            // Process left side recursively to capture its full equivalency chain
+            processExpression({
+              node: unwrappedNode.left,
+              context,
+              targetPath,
+            });
+            // Process right side recursively for completeness
+            processExpression({
+              node: unwrappedNode.right,
+              context,
+              targetPath,
+            });
+            // Set resultPath to left side for type inference
             resultPath = StructuredPath.fromNode(
               unwrappedNode.left,
               context.sourceFile,
             );
           }
-          // Note: Unlike ??, we don't set targetPath when there's no target
+          // Note: When there's no targetPath, we don't recursively process
           // because || is often used in boolean contexts where the full expression matters
         }
       } else if (operatorKind === ts.SyntaxKind.InstanceOfKeyword) {
@@ -1673,6 +2502,17 @@ export function processExpression({
     // Extract conditional usages for key attribute detection
     extractConditionalUsage(unwrappedNode.condition, context, 'ternary');
 
+    // Extract conditional effects (setter calls in ternary branches)
+    const knownSetters = findUseStateSetters(context.sourceFile);
+    const effects = extractConditionalEffectsFromTernary(
+      unwrappedNode,
+      context,
+      knownSetters,
+    );
+    for (const effect of effects) {
+      context.addConditionalEffect(effect);
+    }
+
     // Process all parts recursively
     processExpression({
       node: unwrappedNode.condition,