@codeyam/codeyam-cli 0.0.0 → 0.1.0-staging.032c089

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

@@ -0,0 +1,3769 @@
+import ts from 'typescript';
+import * as crypto from 'crypto';
+import {
+  AnalysisContext,
+  CompoundConditional,
+  ConditionalUsage,
+} from './types';
+import { StructuredPath } from './paths';
+import { nodeToSource } from './nodeToSource';
+import { methodRegistry, ArrayPushSemantics } from './methodSemantics';
+import {
+  getComparisonOperatorString,
+  isArithmeticOperator,
+  isAssignmentOperator,
+  isBitwiseCompoundOperator,
+  isComparisonOperator,
+  isDefinedType,
+  isNumericCompoundOperator,
+  leftOrRightType,
+  unwrapExpression,
+} from './sharedPatterns';
+import { processBindingPattern } from './processBindings';
+import {
+  extractConditionalEffectsFromTernary,
+  findUseStateSetters,
+} from './conditionalEffectsExtractor';
+import { detectArrayDerivedPattern } from './arrayDerivationDetector';
+
+/**
+ * Recursively extracts root variable names from an expression AST node.
+ * Used to identify which variables flow into JSX expression children,
+ * so we can link them to the return value schema.
+ *
+ * Examples:
+ * - `filteredTopPaths.map(...)` → ['filteredTopPaths']
+ * - `a && b` → ['a', 'b']
+ * - `condition ? x : y` → ['condition', 'x', 'y']
+ */
+function extractRootVariableNames(node: ts.Expression): string[] {
+  const ignoredIdentifiers = new Set([
+    'undefined',
+    'null',
+    'true',
+    'false',
+    'NaN',
+    'Infinity',
+  ]);
+
+  if (ts.isIdentifier(node)) {
+    const name = node.text;
+    return ignoredIdentifiers.has(name) ? [] : [name];
+  }
+
+  if (ts.isPropertyAccessExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  if (ts.isCallExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  if (ts.isBinaryExpression(node)) {
+    return [
+      ...extractRootVariableNames(node.left),
+      ...extractRootVariableNames(node.right),
+    ];
+  }
+
+  if (ts.isPrefixUnaryExpression(node)) {
+    return extractRootVariableNames(node.operand);
+  }
+
+  if (ts.isConditionalExpression(node)) {
+    return [
+      ...extractRootVariableNames(node.condition),
+      ...extractRootVariableNames(node.whenTrue),
+      ...extractRootVariableNames(node.whenFalse),
+    ];
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  // Stop recursion at JSX elements and other terminal nodes
+  if (
+    ts.isJsxElement(node) ||
+    ts.isJsxFragment(node) ||
+    ts.isJsxSelfClosingElement(node)
+  ) {
+    return [];
+  }
+
+  return [];
+}
+
+/**
+ * Checks if a JSX element has props that reference variables from the parent scope.
+ * This is used to detect unconditionally-rendered children that should have their
+ * execution flows merged into the parent.
+ *
+ * We want to track children where the parent controls data that affects the child's
+ * conditional rendering. Static props (like title="Dashboard") don't need tracking
+ * because they don't create variable execution flows.
+ *
+ * Examples:
+ * - <WorkoutsView workouts={workouts} /> → true (workouts is a variable)
+ * - <ItemList items={items} count={count} /> → true (items, count are variables)
+ * - <Header title="Dashboard" /> → false (static string)
+ * - <Footer /> → false (no props)
+ * - <Button onClick={handleClick} /> → false (only callback, no data props)
+ *
+ * @returns true if the component has at least one prop that references a variable
+ *          (excluding callbacks which typically start with 'on' or 'handle')
+ */
+function hasDataPropsFromParent(
+  node: ts.JsxElement | ts.JsxSelfClosingElement,
+  componentName: string,
+): { hasDataProps: boolean; dataProps: string[] } {
+  const attributes = ts.isJsxElement(node)
+    ? node.openingElement.attributes.properties
+    : node.attributes.properties;
+
+  const dataProps: string[] = [];
+
+  for (const attr of attributes) {
+    // Spread attributes always reference parent data: {...props}
+    if (ts.isJsxSpreadAttribute(attr)) {
+      const spreadText = attr.expression?.getText() || '...spread';
+      dataProps.push(`{...${spreadText}}`);
+      console.log(
+        `[UnconditionalChild] ${componentName}: Found spread attribute {${spreadText}}`,
+      );
+      continue;
+    }
+
+    if (ts.isJsxAttribute(attr)) {
+      const propName = attr.name.getText();
+
+      // Skip callback props - they don't create data-driven execution flows
+      // Callbacks typically start with 'on' (onClick, onChange) or 'handle' (handleSubmit)
+      if (
+        propName.startsWith('on') ||
+        propName.startsWith('handle') ||
+        propName === 'ref'
+      ) {
+        console.log(
+          `[UnconditionalChild] ${componentName}: Skipping callback prop '${propName}'`,
+        );
+        continue;
+      }
+
+      // Check if the prop value is a JSX expression (references a variable)
+      // vs a string literal which is static
+      if (attr.initializer) {
+        if (ts.isJsxExpression(attr.initializer)) {
+          // JSX expression like prop={value} - this references a variable
+          // Could be a simple identifier, property access, or more complex expression
+          const expression = attr.initializer.expression;
+          if (expression) {
+            // Skip if it's just a function/arrow function (callback)
+            if (
+              ts.isArrowFunction(expression) ||
+              ts.isFunctionExpression(expression)
+            ) {
+              console.log(
+                `[UnconditionalChild] ${componentName}: Skipping inline callback prop '${propName}'`,
+              );
+              continue;
+            }
+            // This is a data prop that references parent state/props
+            const exprText = expression.getText();
+            dataProps.push(`${propName}={${exprText}}`);
+            console.log(
+              `[UnconditionalChild] ${componentName}: Found data prop '${propName}' = {${exprText}}`,
+            );
+          }
+        } else {
+          // String literals like prop="value" are static
+          console.log(
+            `[UnconditionalChild] ${componentName}: Skipping static prop '${propName}'`,
+          );
+        }
+      }
+    }
+  }
+
+  const hasDataProps = dataProps.length > 0;
+  if (hasDataProps) {
+    console.log(
+      `[UnconditionalChild] ${componentName}: Has ${dataProps.length} data props: [${dataProps.join(', ')}]`,
+    );
+  } else {
+    console.log(
+      `[UnconditionalChild] ${componentName}: No data props found, will NOT track`,
+    );
+  }
+
+  return { hasDataProps, dataProps };
+}
+
+/**
+ * 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.
+ *
+ * IMPORTANT: We always use the original source text for callbacks, never cyScope names.
+ * cyScope names are internal identifiers for child scopes and should NEVER appear
+ * in schema paths or call signatures. Using cyScope names causes data merge conflicts
+ * because the same callback gets different identifiers in different contexts.
+ */
+function getArgPathForCallSignature(
+  arg: ts.Expression,
+  context: AnalysisContext,
+): StructuredPath {
+  // Always use the standard path conversion - never replace with cyScope names
+  return (
+    StructuredPath.fromNode(arg, context.sourceFile) ||
+    nodeToSource(arg, context.sourceFile)
+  );
+}
+
+/**
+ * Builds a StructuredPath for a call expression using the original source text.
+ *
+ * IMPORTANT: This function ensures consistent call signatures by always using
+ * the original callback text, never cyScope names. This prevents schema path
+ * conflicts where the same call would have different paths.
+ */
+function buildCallPathFromSource(
+  node: ts.CallExpression,
+  context: AnalysisContext,
+): StructuredPath | null {
+  const expression = node.expression;
+
+  // Convert arguments using original source text
+  const argPaths = node.arguments.map((arg) =>
+    getArgPathForCallSignature(arg, context),
+  );
+
+  // Handle type arguments if present
+  let typeArgs: string[] | undefined = undefined;
+  if (node.typeArguments && node.typeArguments.length > 0) {
+    typeArgs = node.typeArguments.map((typeArg) =>
+      typeArg.getText(context.sourceFile),
+    );
+  }
+
+  if (ts.isIdentifier(expression)) {
+    // Simple function call: func(arg1, arg2)
+    return StructuredPath.fromFunction(expression.text, argPaths, typeArgs);
+  } else if (ts.isPropertyAccessExpression(expression)) {
+    // Method call: obj.method(arg1, arg2)
+    const objPath = StructuredPath.fromNode(
+      expression.expression,
+      context.sourceFile,
+    );
+    if (!objPath) return null;
+    return objPath
+      .withProperty(expression.name.text)
+      .withFunctionCall(argPaths, typeArgs);
+  } else if (ts.isCallExpression(expression)) {
+    // Chained call: func(arg1)(arg2)
+    const funcPath = buildCallPathFromSource(expression, context);
+    if (!funcPath) return null;
+    return funcPath.withFunctionCall(argPaths, typeArgs);
+  } else if (ts.isElementAccessExpression(expression)) {
+    // Element access call: obj[key](args)
+    const basePath = StructuredPath.fromNode(expression, context.sourceFile);
+    if (!basePath) return null;
+    return basePath.withFunctionCall(argPaths, typeArgs);
+  } else {
+    // Complex call expression
+    const basePath = StructuredPath.fromNode(expression, context.sourceFile);
+    if (!basePath) return null;
+    return basePath.withFunctionCall(argPaths, typeArgs);
+  }
+}
+
+/**
+ * Checks if an expression is likely an array type.
+ * Uses TypeScript's type checker when available, falls back to heuristics.
+ */
+function isLikelyArrayType(
+  expr: ts.Expression,
+  typeChecker: ts.TypeChecker | undefined,
+): boolean {
+  if (typeChecker) {
+    try {
+      const type = typeChecker.getTypeAtLocation(expr);
+      const typeString = typeChecker.typeToString(type);
+      // Check for common array type patterns:
+      // - T[] syntax (includes any[], string[], etc.)
+      // - Array<T> syntax
+      // - ReadonlyArray<T> syntax
+      // - readonly T[] syntax (starts with "readonly " and ends with "[]")
+      if (
+        typeString.includes('[]') ||
+        typeString.startsWith('Array<') ||
+        typeString.startsWith('ReadonlyArray<')
+      ) {
+        return true;
+      }
+      // Check if it's a tuple or array literal type via TypeScript's type flags
+      if (type.getFlags() & ts.TypeFlags.Object) {
+        const objectType = type as ts.ObjectType;
+        if (
+          objectType.objectFlags & ts.ObjectFlags.Tuple ||
+          objectType.objectFlags & ts.ObjectFlags.ArrayLiteral
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      // Type checking can fail in some edge cases, fall through to false
+    }
+  }
+  return false;
+}
+
+/**
+ * Marks variables used in truthiness checks as potentially undefined.
+ * When code checks `if (x)` or `x && ...`, it indicates x might be falsy (null/undefined).
+ * This function walks through the condition and adds | undefined to such variables.
+ */
+export function markConditionVariablesAsNullable(
+  condition: ts.Expression,
+  context: AnalysisContext,
+): void {
+  const unwrapped = unwrapExpression(condition);
+
+  // For binary expressions with &&, mark both sides as nullable if they're truthiness checks
+  // Example: `diffView && <Component />` means diffView might be undefined
+  // Example: `a && b && <Component />` means both a and b might be undefined
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Recursively mark left side
+    markConditionVariablesAsNullable(unwrapped.left, context);
+
+    // Mark right side if it's also a truthiness check (not JSX or other consequences)
+    const rightUnwrapped = unwrapExpression(unwrapped.right);
+    // Check if right side is JSX or contains JSX
+    const isJsxConsequence =
+      ts.isJsxElement(rightUnwrapped) ||
+      ts.isJsxSelfClosingElement(rightUnwrapped) ||
+      ts.isJsxFragment(rightUnwrapped);
+
+    if (!isJsxConsequence) {
+      // This handles chains like `a && b && ...` where both a and b are checks
+      markConditionVariablesAsNullable(unwrapped.right, context);
+    }
+    return;
+  }
+
+  // Don't mark variables in comparison operators as nullable
+  // Example: `if (x === 5)` doesn't mean x might be undefined
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    isComparisonOperator(unwrapped.operatorToken.kind)
+  ) {
+    return;
+  }
+
+  // For simple identifiers or property accesses, mark as potentially undefined
+  const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+  if (path) {
+    const currentType = context.getTypeInfo(path) || 'unknown';
+
+    // Only add | undefined if it's not already there
+    if (!currentType.includes('undefined')) {
+      context.addType(path, `${currentType} | undefined`);
+    }
+  }
+}
+
+/**
+ * Helper to extract source location from an AST node
+ */
+function getSourceLocation(
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+): ConditionalUsage['sourceLocation'] {
+  const start = node.getStart(sourceFile);
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+  const codeSnippet = node.getText(sourceFile);
+
+  return {
+    lineNumber: line + 1, // Convert to 1-based
+    column: character,
+    codeSnippet:
+      codeSnippet.length > 100
+        ? codeSnippet.slice(0, 100) + '...'
+        : codeSnippet,
+  };
+}
+
+/**
+ * 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)
+ */
+function countConditionsInAndChain(expr: ts.Expression): number {
+  const unwrapped = unwrapExpression(expr);
+
+  if (
+    ts.isBinaryExpression(unwrapped) &&
+    unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    const leftCount = countConditionsInAndChain(unwrapped.left);
+    const rightUnwrapped = unwrapExpression(unwrapped.right);
+    const isJsxConsequence =
+      ts.isJsxElement(rightUnwrapped) ||
+      ts.isJsxSelfClosingElement(rightUnwrapped) ||
+      ts.isJsxFragment(rightUnwrapped);
+
+    if (isJsxConsequence) {
+      return leftCount;
+    }
+    return leftCount + countConditionsInAndChain(unwrapped.right);
+  }
+
+  // Single condition (not an && chain)
+  return 1;
+}
+
+/**
+ * Chain tracking info for compound conditionals
+ */
+interface ChainInfo {
+  chainId: string;
+  chainLength: number;
+  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)
+      const componentName = getComponentNameFromJsx(child);
+      if (componentName) {
+        if (parentConditions.length > 0) {
+          // If there are parent conditions, record them as gating conditions
+          console.log(
+            `[ChildBoundary] ${componentName}: Conditionally rendered with ${parentConditions.length} gating conditions`,
+          );
+          for (const condition of parentConditions) {
+            console.log(
+              `[ChildBoundary] ${componentName}: Adding gating condition path='${condition.path}' isNegated=${condition.isNegated}`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: condition.path,
+              conditionType: 'truthiness',
+              location: 'ternary',
+              sourceLocation: condition.sourceLocation,
+              controlsJsxRendering: true,
+              isNegated: condition.isNegated,
+            });
+          }
+        } else {
+          // No parent conditions - check if it has data props for unconditional tracking
+          console.log(
+            `[ChildBoundary] ${componentName}: Checking for unconditional rendering with data props...`,
+          );
+          const { hasDataProps, dataProps } = hasDataPropsFromParent(
+            child,
+            componentName,
+          );
+          if (hasDataProps) {
+            // Fix: Track unconditionally-rendered children that receive data props
+            // These need to be tracked for flow merging even without gating conditions
+            // Example: <WorkoutsView workouts={workouts} /> - parent controls workouts data
+            console.log(
+              `[ChildBoundary] ${componentName}: TRACKING as unconditionally-rendered with data props: [${dataProps.join(', ')}]`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: '__unconditional__',
+              conditionType: 'truthiness',
+              location: 'unconditional',
+              controlsJsxRendering: true,
+              isNegated: false,
+            });
+          }
+        }
+      }
+      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)
+      const componentName = getComponentNameFromJsx(child);
+      if (componentName) {
+        if (parentConditions.length > 0) {
+          // If there are parent conditions, record them as gating conditions
+          console.log(
+            `[ChildBoundary] ${componentName}: Conditionally rendered (self-closing) with ${parentConditions.length} gating conditions`,
+          );
+          for (const condition of parentConditions) {
+            console.log(
+              `[ChildBoundary] ${componentName}: Adding gating condition path='${condition.path}' isNegated=${condition.isNegated}`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: condition.path,
+              conditionType: 'truthiness',
+              location: 'ternary',
+              sourceLocation: condition.sourceLocation,
+              controlsJsxRendering: true,
+              isNegated: condition.isNegated,
+            });
+          }
+        } else {
+          // No parent conditions - check if it has data props for unconditional tracking
+          console.log(
+            `[ChildBoundary] ${componentName}: Checking for unconditional rendering (self-closing) with data props...`,
+          );
+          const { hasDataProps, dataProps } = hasDataPropsFromParent(
+            child,
+            componentName,
+          );
+          if (hasDataProps) {
+            // Fix: Track unconditionally-rendered children that receive data props
+            console.log(
+              `[ChildBoundary] ${componentName}: TRACKING as unconditionally-rendered (self-closing) with data props: [${dataProps.join(', ')}]`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: '__unconditional__',
+              conditionType: 'truthiness',
+              location: 'unconditional',
+              controlsJsxRendering: true,
+              isNegated: false,
+            });
+          }
+        }
+      }
+      // 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;
+}
+
+/**
+ * Extracts conditional usages from a condition expression for key attribute detection.
+ * This function identifies which attributes are used in conditionals and how they're used.
+ * It also tracks compound conditionals (&&-chains) where all conditions must be true together.
+ *
+ * @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,
+    chainInfo: ChainInfo | null,
+    isNegated: boolean,
+  ): void {
+    const unwrapped = unwrapExpression(expr);
+
+    // Handle binary expressions with && (logical AND chains)
+    // Example: `a && b && <Component />` - both a and b are conditional checks
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+    ) {
+      // Track if we're creating the chain at this level (root of the chain)
+      const isChainRoot = !chainInfo;
+
+      // If no chainInfo, this is the root of a new chain
+      if (isChainRoot) {
+        const chainLength = countConditionsInAndChain(unwrapped);
+        // Only create chain tracking for chains with 2+ conditions
+        if (chainLength >= 2) {
+          const chainId = `chain_${crypto.randomUUID().slice(0, 8)}`;
+          const chainExpression = unwrapped.getText(context.sourceFile);
+          const compound: CompoundConditional = {
+            chainId,
+            expression:
+              chainExpression.length > 200
+                ? chainExpression.slice(0, 200) + '...'
+                : chainExpression,
+            conditions: [],
+            location,
+            sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+            controlsJsxRendering,
+          };
+          chainInfo = {
+            chainId,
+            chainLength,
+            chainExpression: compound.expression,
+            currentPosition: 0,
+            compound,
+          };
+        }
+      }
+
+      // Recursively process left side
+      extractWithChainTracking(unwrapped.left, chainInfo, false);
+
+      // Process right side if it's not JSX (JSX is the consequence, not the condition)
+      const rightUnwrapped = unwrapExpression(unwrapped.right);
+      const isJsxConsequence =
+        ts.isJsxElement(rightUnwrapped) ||
+        ts.isJsxSelfClosingElement(rightUnwrapped) ||
+        ts.isJsxFragment(rightUnwrapped);
+
+      if (!isJsxConsequence) {
+        extractWithChainTracking(unwrapped.right, chainInfo, false);
+      }
+
+      // If this is the root of the chain, register the compound conditional
+      if (isChainRoot && chainInfo) {
+        context.addCompoundConditional(chainInfo.compound);
+      }
+      return;
+    }
+
+    // Handle binary expressions with || (logical OR)
+    // 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
+    ) {
+      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;
+    }
+
+    // Handle comparison operators (===, !==, <, >, <=, >=)
+    // Example: `if (status === 'active')` - status is compared against 'active'
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      isComparisonOperator(unwrapped.operatorToken.kind)
+    ) {
+      // Try to extract the variable and the compared value
+      const leftPath = StructuredPath.fromNode(
+        unwrapped.left,
+        context.sourceFile,
+      );
+      const rightPath = StructuredPath.fromNode(
+        unwrapped.right,
+        context.sourceFile,
+      );
+
+      // Determine the compared value for computing requiredValue
+      const getRequiredValue = (
+        literalValue: string | undefined,
+        isNegatedComparison: boolean,
+      ): string | boolean | undefined => {
+        if (literalValue === undefined) return undefined;
+        // For !== comparisons, the condition is true when NOT equal to the value
+        // For === comparisons, the condition is true when equal to the value
+        const isNotEqual =
+          unwrapped.operatorToken.kind ===
+            ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+          unwrapped.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken;
+        if (isNotEqual) {
+          // !== 'value' means requiredValue is NOT 'value', but we express this as "not 'value'"
+          return `not ${literalValue}`;
+        }
+        return literalValue;
+      };
+
+      // Get the comparison operator string for the compound condition
+      const comparisonOperator = getComparisonOperatorString(
+        unwrapped.operatorToken.kind,
+      );
+
+      // Helper to add a condition
+      const addCondition = (
+        path: string,
+        conditionType: 'comparison' | 'truthiness',
+        comparedValues?: string[],
+        requiredValue?: string | boolean,
+        sourceExpr?: ts.Expression,
+      ) => {
+        const usage: ConditionalUsage = {
+          path,
+          conditionType,
+          comparedValues,
+          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;
+          usage.chainPosition = chainInfo.currentPosition;
+          usage.chainLength = chainInfo.chainLength;
+          usage.chainExpression = chainInfo.chainExpression;
+          chainInfo.currentPosition++;
+
+          // Add to compound conditional conditions
+          chainInfo.compound.conditions.push({
+            path,
+            conditionType,
+            comparedValues,
+            isNegated,
+            requiredValue,
+            ...(comparisonOperator && { comparisonOperator }),
+            ...(chainInfo.currentOrGroupId && {
+              orGroupId: chainInfo.currentOrGroupId,
+            }),
+          });
+        }
+
+        context.addConditionalUsage(usage);
+      };
+
+      // Check if left is a variable and right is a literal
+      if (leftPath && isLiteralExpression(unwrapped.right)) {
+        const literalValue = getLiteralValue(unwrapped.right, context);
+        addCondition(
+          leftPath.toLeftHandSideString(),
+          'comparison',
+          literalValue !== undefined ? [literalValue] : undefined,
+          getRequiredValue(literalValue, isNegated),
+          unwrapped.left, // Pass source expression for array derivation detection
+        );
+        return;
+      }
+
+      // Check if right is a variable and left is a literal
+      if (rightPath && isLiteralExpression(unwrapped.left)) {
+        const literalValue = getLiteralValue(unwrapped.left, context);
+        addCondition(
+          rightPath.toLeftHandSideString(),
+          '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',
+          undefined,
+          undefined,
+          unwrapped.left,
+        );
+      }
+      if (rightPath) {
+        addCondition(
+          rightPath.toLeftHandSideString(),
+          'comparison',
+          undefined,
+          undefined,
+          unwrapped.right,
+        );
+      }
+      return;
+    }
+
+    // Handle prefix unary NOT expression: !variable
+    // Example: `if (!isVisible)` - isVisible is a truthiness check (negated)
+    if (
+      ts.isPrefixUnaryExpression(unwrapped) &&
+      unwrapped.operator === ts.SyntaxKind.ExclamationToken
+    ) {
+      extractWithChainTracking(unwrapped.operand, chainInfo, !isNegated);
+      return;
+    }
+
+    // Handle simple identifiers or property accesses (truthiness checks)
+    // Example: `if (x)` or `x && <JSX />` - x is checked for truthiness
+    const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+    if (path && !path.isLiteral()) {
+      const pathStr = path.toLeftHandSideString();
+      const usage: ConditionalUsage = {
+        path: pathStr,
+        conditionType: 'truthiness',
+        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;
+        usage.chainPosition = chainInfo.currentPosition;
+        usage.chainLength = chainInfo.chainLength;
+        usage.chainExpression = chainInfo.chainExpression;
+        chainInfo.currentPosition++;
+
+        // Add to compound conditional conditions
+        // For truthiness, requiredValue is true if not negated, false if negated
+        chainInfo.compound.conditions.push({
+          path: pathStr,
+          conditionType: 'truthiness',
+          isNegated,
+          requiredValue: !isNegated,
+          ...(chainInfo.currentOrGroupId && {
+            orGroupId: chainInfo.currentOrGroupId,
+          }),
+        });
+      }
+
+      context.addConditionalUsage(usage);
+    }
+  }
+
+  // Start extraction with no chain info
+  extractWithChainTracking(condition, null, false);
+}
+
+/**
+ * Helper to check if an expression is a literal value
+ */
+function isLiteralExpression(expr: ts.Expression): boolean {
+  const unwrapped = unwrapExpression(expr);
+  return (
+    ts.isStringLiteral(unwrapped) ||
+    ts.isNumericLiteral(unwrapped) ||
+    ts.isNoSubstitutionTemplateLiteral(unwrapped) ||
+    unwrapped.kind === ts.SyntaxKind.TrueKeyword ||
+    unwrapped.kind === ts.SyntaxKind.FalseKeyword ||
+    unwrapped.kind === ts.SyntaxKind.NullKeyword ||
+    unwrapped.kind === ts.SyntaxKind.UndefinedKeyword ||
+    unwrapped.kind === ts.SyntaxKind.ThisKeyword
+  );
+}
+
+/**
+ * Helper to get the string representation of a literal value
+ */
+function getLiteralValue(
+  expr: ts.Expression,
+  context: AnalysisContext,
+): string | undefined {
+  const unwrapped = unwrapExpression(expr);
+
+  if (
+    ts.isStringLiteral(unwrapped) ||
+    ts.isNoSubstitutionTemplateLiteral(unwrapped)
+  ) {
+    return unwrapped.text;
+  }
+  if (ts.isNumericLiteral(unwrapped)) {
+    return unwrapped.text;
+  }
+  if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) {
+    return 'true';
+  }
+  if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) {
+    return 'false';
+  }
+  if (unwrapped.kind === ts.SyntaxKind.NullKeyword) {
+    return 'null';
+  }
+  if (unwrapped.kind === ts.SyntaxKind.UndefinedKeyword) {
+    return 'undefined';
+  }
+  if (unwrapped.kind === ts.SyntaxKind.ThisKeyword) {
+    return 'this';
+  }
+
+  return undefined;
+}
+
+/**
+ * Processes an expression node recursively, establishing equivalences and types
+ * in the analysis context as side effects.
+ *
+ * This is the core function for centralized expression analysis, which handles all
+ * expression types and registers appropriate relationships and types in the context.
+ *
+ * @param node The expression node to process.
+ * @param context The analysis context.
+ * @param targetPath The base path to which this expression's value should be related.
+ *        For example, for a variable declaration `const x = y`, the targetPath would be
+ *        StructuredPath.fromBase('x'). For a return statement `return expr`, the targetPath
+ *        would be StructuredPath.fromBase('returnValue').
+ *
+ *        When targetPath is provided, this function will establish all appropriate equivalences
+ *        and register types for targetPath. When omitted (typically for sub-expressions in
+ *        recursive calls), the function will operate without establishing external relationships.
+ *
+ * @returns true if the expression was processed successfully, false otherwise.
+ */
+export function processExpression({
+  node,
+  context,
+  targetPath,
+  typeHint,
+}: {
+  node: ts.Expression;
+  context: AnalysisContext;
+  targetPath?: StructuredPath; // Base path for relationship establishment
+  typeHint?: string; // Optional type hint for the node
+}): boolean {
+  let inferredNodeType = context.inferTypeFromNode(node);
+  if (inferredNodeType === 'unknown' && typeHint) {
+    inferredNodeType = typeHint;
+  }
+  const unwrappedNode = unwrapExpression(node);
+
+  // IMPORTANT: Mark nullable variables BEFORE checking child boundaries
+  // JSX expressions like {showLogsForEntity && projectSlug && (<Component />)} are child boundaries,
+  // but we still need to mark the variables as potentially undefined
+  if (
+    ts.isBinaryExpression(unwrappedNode) &&
+    unwrappedNode.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    markConditionVariablesAsNullable(unwrappedNode, context);
+    // Extract conditional usages for key attribute detection
+    // Only call from the OUTERMOST && expression to avoid duplicates
+    // Check if parent is also a && (meaning we're nested)
+    const parent = unwrappedNode.parent;
+    const parentIsAndChain =
+      parent &&
+      ts.isBinaryExpression(parent) &&
+      parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken;
+    if (!parentIsAndChain) {
+      extractConditionalUsage(unwrappedNode, context, 'logical-and');
+    }
+  }
+
+  // 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;
+  }
+
+  // Create a path for this node
+  let nodePath: StructuredPath | null = null;
+
+  // if (unwrappedNode.kind === ts.SyntaxKind.Identifier) {
+  //   console.warn(
+  //     `Got IDENTIFIER and ts.isIdentifier = ${ts.isIdentifier(unwrappedNode)}`,
+  //     unwrappedNode.getText(context.sourceFile),
+  //   );
+  // }
+
+  // Handle simple cases directly
+  if (ts.isIdentifier(unwrappedNode)) {
+    nodePath = StructuredPath.fromBase(unwrappedNode.text);
+
+    // If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, inferredNodeType);
+
+      // Propagate sub-properties from the identifier to the targetPath
+      // This handles cases like: dataItem={{ structure: completeDataStructure }}
+      // where completeDataStructure was defined as { 'Function Arguments': dataStructure.arguments }
+      // We need to propagate completeDataStructure['Function Arguments'] to
+      // ChildComponent().signature[0].dataItem.structure['Function Arguments']
+      const nodePathStr = nodePath.toString();
+      const equivalentVariables = context.getEquivalentVariables();
+      const structure = context.getStructure();
+
+      // Propagate existing equivalencies for sub-properties
+      for (const [key, rawValue] of Object.entries(equivalentVariables)) {
+        // Check if this equivalency is for a sub-property of the identifier
+        // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
+        if (
+          key.startsWith(nodePathStr + '.') ||
+          key.startsWith(nodePathStr + '[')
+        ) {
+          const subPath = key.substring(nodePathStr.length);
+          const newTargetPath = StructuredPath.fromBase(
+            targetPath.toString() + subPath,
+          );
+          // Handle both string and string[] values
+          const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+          for (const value of values) {
+            if (typeof value === 'string') {
+              const valuePath = StructuredPath.fromBase(value);
+              context.addEquivalence(newTargetPath, valuePath);
+            }
+          }
+        }
+      }
+
+      // Propagate existing structure entries for sub-properties
+      for (const [key, value] of Object.entries(structure)) {
+        if (
+          key.startsWith(nodePathStr + '.') ||
+          key.startsWith(nodePathStr + '[')
+        ) {
+          const subPath = key.substring(nodePathStr.length);
+          const newTargetPath = StructuredPath.fromBase(
+            targetPath.toString() + subPath,
+          );
+          context.addType(newTargetPath, value);
+        }
+      }
+    }
+    context.addType(nodePath, inferredNodeType);
+    return true;
+  }
+
+  if (
+    ts.isStringLiteral(unwrappedNode) ||
+    ts.isNoSubstitutionTemplateLiteral(unwrappedNode)
+  ) {
+    nodePath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'string',
+    );
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'string');
+    }
+
+    return true;
+  }
+
+  if (ts.isNumericLiteral(unwrappedNode)) {
+    nodePath = StructuredPath.createLiteralPath(unwrappedNode.text, 'number');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'number');
+    }
+
+    return true;
+  }
+
+  if (
+    unwrappedNode.kind === ts.SyntaxKind.TrueKeyword ||
+    unwrappedNode.kind === ts.SyntaxKind.FalseKeyword
+  ) {
+    const value =
+      unwrappedNode.kind === ts.SyntaxKind.TrueKeyword ? 'true' : 'false';
+    nodePath = StructuredPath.createLiteralPath(value, 'boolean');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'boolean');
+    }
+
+    return true;
+  }
+
+  if (unwrappedNode.kind === ts.SyntaxKind.NullKeyword) {
+    nodePath = StructuredPath.createLiteralPath('null', 'null');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'null');
+    }
+
+    return true;
+  }
+
+  if (unwrappedNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+    nodePath = StructuredPath.createLiteralPath('undefined', 'undefined');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'undefined');
+    }
+
+    return true;
+  }
+
+  if (
+    ts.isThisTypeNode(unwrappedNode) ||
+    unwrappedNode.kind === ts.SyntaxKind.ThisKeyword
+  ) {
+    nodePath = StructuredPath.createLiteralPath('this', 'object');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'object');
+    }
+
+    return true;
+  }
+
+  // Handle Property Access: obj.prop
+  if (ts.isPropertyAccessExpression(unwrappedNode)) {
+    // Process the object part recursively (without targetPath)
+    const objectProcessed = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+
+    if (!objectProcessed) {
+      // If we couldn't process the object part, we can't process the property access
+      // console.warn(
+      //   `processExpression: Unsupported object part: ${unwrappedNode.expression.getText(context.sourceFile)}`,
+      //   ts.isIdentifier(unwrappedNode.expression),
+      // );
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported base expression for property access: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a proper path for the object
+    const objectPath = StructuredPath.fromNode(
+      unwrappedNode.expression,
+      context.sourceFile,
+    );
+
+    if (!objectPath) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Couldn't get path for property access base: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Create the property access path
+    const propertyPath = objectPath.withProperty(unwrappedNode.name.text);
+
+    // Check if this is an environment variable access
+    const fullText = unwrappedNode.getText(context.sourceFile);
+    if (
+      fullText.includes('.env.') || // process.env.X, window.env.X
+      isEnvStoreAccess(fullText) // env.X where env is likely an env config object
+    ) {
+      context.addEnvironmentVariable(fullText);
+    }
+
+    // Infer and register type for the property
+    context.addType(propertyPath, inferredNodeType);
+
+    // If targetPath is provided, establish equivalence and propagate type
+    if (targetPath) {
+      context.addEquivalence(targetPath, propertyPath);
+      context.addType(targetPath, inferredNodeType);
+    }
+
+    return true;
+  }
+
+  // Handle Binary Expressions: a + b, x === y, etc.
+  if (ts.isBinaryExpression(unwrappedNode)) {
+    // Check if it's an assignment first, as BinaryExpression includes assignments
+    if (isAssignmentOperator(unwrappedNode.operatorToken.kind)) {
+      // Check for destructuring assignment first
+      if (
+        (ts.isObjectBindingPattern(unwrappedNode.left) ||
+          ts.isArrayBindingPattern(unwrappedNode.left)) &&
+        unwrappedNode.operatorToken.kind === ts.SyntaxKind.EqualsToken
+      ) {
+        // For destructuring assignment, we first need to process the right side
+        const rightSideProcessed = processExpression({
+          node: unwrappedNode.right,
+          context,
+        });
+
+        if (!rightSideProcessed) {
+          context.markUnsupported(
+            unwrappedNode.right,
+            `processExpression: Unsupported right side of destructuring assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`,
+            false,
+          );
+          return false;
+        }
+
+        // Get the right side path
+        const rightSidePath = StructuredPath.fromNode(
+          unwrappedNode.right,
+          context.sourceFile,
+        );
+
+        if (!rightSidePath) {
+          context.markUnsupported(
+            unwrappedNode.right,
+            `processExpression: Couldn't get path for right side of destructuring assignment`,
+            false,
+          );
+          return false;
+        }
+
+        // Process the binding pattern with the right side as source
+        const success = processBindingPattern(
+          unwrappedNode.left as ts.BindingPattern,
+          rightSidePath,
+          context,
+        );
+
+        // If targetPath was provided, establish equivalence to the right side
+        // This is useful when the destructuring assignment is itself part of a larger expression
+        if (targetPath) {
+          context.addEquivalence(targetPath, rightSidePath);
+          context.inferAndAddType(targetPath, unwrappedNode.right);
+        }
+
+        return success;
+      }
+      // Regular non-destructuring assignment
+      else {
+        // Process the left side to ensure it's analyzed and to get its path
+        const leftSideProcessed = processExpression({
+          node: unwrappedNode.left,
+          context,
+        });
+
+        if (!leftSideProcessed) {
+          context.markUnsupported(
+            unwrappedNode.left,
+            `processExpression: Unsupported left side of assignment: ${ts.SyntaxKind[unwrappedNode.left.kind]}`,
+            false,
+          );
+          return false; // Cannot process assignment without successful LHS processing
+        }
+
+        // Get the structured path for the left side
+        const leftSidePath = StructuredPath.fromNode(
+          unwrappedNode.left,
+          context.sourceFile,
+        );
+
+        if (!leftSidePath) {
+          context.markUnsupported(
+            unwrappedNode.left,
+            `processExpression: Couldn't get path for left side of assignment: ${ts.SyntaxKind[unwrappedNode.left.kind]}`,
+            false,
+          );
+          return false;
+        }
+
+        // Handle simple assignment (=)
+        if (unwrappedNode.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+          // Process the right side
+          const rightSideProcessed = processExpression({
+            node: unwrappedNode.right,
+            context,
+            targetPath: leftSidePath, // Pass leftSidePath as targetPath
+          });
+
+          if (!rightSideProcessed) {
+            context.addType(leftSidePath, 'unknown');
+            context.markUnsupported(
+              unwrappedNode.right,
+              `processExpression: Unsupported right side of assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`,
+              false,
+            );
+            return false;
+          }
+          if (ts.isObjectLiteralExpression(unwrappedNode.right)) {
+            // Just add object type - property equivalences were set up during processing
+            context.addType(leftSidePath, 'object');
+          }
+          // If targetPath was provided to us, establish equivalence
+          if (targetPath) {
+            context.addEquivalence(targetPath, leftSidePath);
+            context.inferAndAddType(targetPath, unwrappedNode.right);
+          }
+
+          return true;
+        }
+        // Handle compound assignments (+=, -=, etc.)
+        else {
+          // For compound assignments, we process the right side without targetPath
+          const rightSideProcessed = processExpression({
+            node: unwrappedNode.right,
+            context,
+          });
+          if (!rightSideProcessed) {
+            context.markUnsupported(
+              unwrappedNode.right,
+              `processExpression: Unsupported right side of compound assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`,
+              false,
+            );
+            return false;
+          }
+
+          // Determine the result type based on operation
+          const operatorKind = unwrappedNode.operatorToken.kind;
+
+          let leftType = context.getTypeInfo(leftSidePath);
+          if (leftType === 'unknown') {
+            leftType = context.inferTypeFromNode(unwrappedNode.left);
+          }
+
+          const rightType = context.inferTypeFromNode(unwrappedNode.right);
+
+          let resultType = 'unknown';
+          if (operatorKind === ts.SyntaxKind.PlusEqualsToken) {
+            // plus operator is special - it can be string or number
+            resultType =
+              leftType === 'string' || rightType === 'string'
+                ? 'string'
+                : 'number';
+          } else if (isNumericCompoundOperator(operatorKind)) {
+            resultType = 'number';
+          } else if (isBitwiseCompoundOperator(operatorKind)) {
+            resultType = 'number';
+          } else if (
+            operatorKind === ts.SyntaxKind.AmpersandAmpersandEqualsToken
+          ) {
+            resultType = 'boolean';
+          } else if (
+            operatorKind === ts.SyntaxKind.BarBarEqualsToken ||
+            operatorKind === ts.SyntaxKind.QuestionQuestionEqualsToken
+          ) {
+            resultType = leftOrRightType(leftType, rightType) ?? 'unknown';
+          } else {
+            context.markUnsupported(
+              unwrappedNode,
+              `processExpression: Unsupported compound assignment operator: ${ts.SyntaxKind[operatorKind]}`,
+              false,
+            );
+          }
+
+          // Update the type of the left side
+          context.addType(leftSidePath, resultType);
+          context.addEquivalence(
+            leftSidePath,
+            StructuredPath.fromNode(unwrappedNode.right, context.sourceFile),
+          );
+
+          // If targetPath was provided, establish equivalence
+          if (targetPath) {
+            context.addEquivalence(targetPath, leftSidePath);
+            context.addType(targetPath, resultType);
+          }
+
+          return true;
+        }
+      }
+    }
+    // Non-assignment binary expressions (logical, arithmetic, comparison, etc.)
+    else {
+      // Process both sides for their side effects (without targetPath)
+      processExpression({ node: unwrappedNode.left, context });
+      processExpression({ node: unwrappedNode.right, context });
+
+      // Determine the type of the result
+      const operatorKind = unwrappedNode.operatorToken.kind;
+      let resultPath = null;
+      let resultType = 'unknown';
+
+      // Type Inference Logic
+      if (isComparisonOperator(operatorKind)) {
+        resultType = 'boolean';
+
+        // Type narrowing: if comparing a call expression with unknown return type
+        // to a value of known type, narrow the return type
+        const leftType = context.inferTypeFromNode(unwrappedNode.left);
+        const rightType = context.inferTypeFromNode(unwrappedNode.right);
+
+        // Check if left side is a call expression with unknown return type
+        if (
+          ts.isCallExpression(unwrappedNode.left) &&
+          leftType === 'unknown' &&
+          rightType !== 'unknown'
+        ) {
+          const leftPath = StructuredPath.fromNode(
+            unwrappedNode.left,
+            context.sourceFile,
+          );
+          if (leftPath) {
+            const returnValuePath = leftPath.withProperty(
+              'functionCallReturnValue',
+            );
+            context.addType(returnValuePath, `${rightType} | unknown`);
+          }
+        }
+        // Check if right side is a call expression with unknown return type
+        else if (
+          ts.isCallExpression(unwrappedNode.right) &&
+          rightType === 'unknown' &&
+          leftType !== 'unknown'
+        ) {
+          const rightPath = StructuredPath.fromNode(
+            unwrappedNode.right,
+            context.sourceFile,
+          );
+          if (rightPath) {
+            const returnValuePath = rightPath.withProperty(
+              'functionCallReturnValue',
+            );
+            context.addType(returnValuePath, `${leftType} | unknown`);
+          }
+        }
+      } else if (isArithmeticOperator(operatorKind)) {
+        // For plus operator, check if either operand is a string
+        if (operatorKind === ts.SyntaxKind.PlusToken) {
+          const leftType = context.inferTypeFromNode(unwrappedNode.left);
+          const rightType = context.inferTypeFromNode(unwrappedNode.right);
+
+          if (leftType === 'string' || rightType === 'string') {
+            resultType = 'string';
+          } else {
+            resultType = 'number';
+          }
+        } else {
+          // All other arithmetic operators result in numbers
+          resultType = 'number';
+        }
+      } else if (operatorKind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        // Logical AND typically results in a boolean
+        resultType = 'boolean';
+
+        // Mark the left operand as potentially undefined since it's being checked for truthiness
+        markConditionVariablesAsNullable(unwrappedNode.left, context);
+      } else if (
+        operatorKind === ts.SyntaxKind.BarBarToken || // Logical OR
+        operatorKind === ts.SyntaxKind.QuestionQuestionToken // Nullish Coalescing
+      ) {
+        // For || and ??, the result type depends on the operands
+        const leftType = context.inferTypeFromNode(unwrappedNode.left);
+        const rightType = context.inferTypeFromNode(unwrappedNode.right);
+
+        // For ||, if either side is boolean, result is boolean
+        if (
+          operatorKind === ts.SyntaxKind.BarBarToken &&
+          (leftType === 'boolean' || rightType === 'boolean')
+        ) {
+          resultType = 'boolean';
+        }
+        // Otherwise, for both || and ??, we use the first defined type
+        else if (isDefinedType(leftType)) {
+          resultType = leftType;
+        } else {
+          resultType = rightType || 'unknown';
+        }
+        // For || and ??, create an equivalence to the left side
+        // This ensures the equivalency chain is preserved through fallback expressions
+        // 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,
+              context.sourceFile,
+            );
+          } else {
+            // if the expression is the target capture that the two sides are equivalent (e.g. (x ?? y).map())
+            targetPath = StructuredPath.fromNode(
+              unwrappedNode,
+              context.sourceFile,
+            );
+            resultPath = StructuredPath.fromNode(
+              unwrappedNode.left,
+              context.sourceFile,
+            );
+          }
+        } else if (operatorKind === ts.SyntaxKind.BarBarToken) {
+          // 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) {
+            // Get paths for both sides
+            const leftPath = StructuredPath.fromNode(
+              unwrappedNode.left,
+              context.sourceFile,
+            );
+            const rightPath = StructuredPath.fromNode(
+              unwrappedNode.right,
+              context.sourceFile,
+            );
+
+            // Collect all valid paths
+            const allPaths: StructuredPath[] = [];
+            if (leftPath) allPaths.push(leftPath);
+            if (rightPath) allPaths.push(rightPath);
+
+            // Add multiple equivalencies to track both sources
+            if (allPaths.length > 0) {
+              context.addMultipleEquivalencies(targetPath, allPaths);
+            }
+
+            // Process both sides to capture their internal structures
+            processExpression({
+              node: unwrappedNode.left,
+              context,
+            });
+            processExpression({
+              node: unwrappedNode.right,
+              context,
+            });
+
+            // Register the type for the target path
+            const leftType = context.inferTypeFromNode(unwrappedNode.left);
+            const rightType = context.inferTypeFromNode(unwrappedNode.right);
+            const orResultType = isDefinedType(leftType)
+              ? leftType
+              : rightType || 'unknown';
+            context.addType(targetPath, orResultType);
+
+            // Return early - we've already handled equivalencies with addMultipleEquivalencies
+            // Don't fall through to the generic addEquivalence call below
+            return true;
+          }
+          // 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) {
+        resultType = 'boolean';
+      } else {
+        // Fallback for other operators
+        resultType = inferredNodeType;
+        context.markUnsupported(
+          unwrappedNode,
+          `processExpression: Unsupported binary operator: ${ts.SyntaxKind[operatorKind]}`,
+          false,
+        );
+      }
+
+      // Get a canonical representation for the entire binary expression
+      resultPath ??= nodeToSource(unwrappedNode, context.sourceFile);
+
+      // Register the type for the expression
+      context.addType(resultPath, resultType);
+
+      // If targetPath is provided, establish equivalence and register type
+      if (targetPath) {
+        context.addEquivalence(targetPath, resultPath);
+        context.addType(targetPath, resultType);
+      }
+
+      return true;
+    }
+  }
+
+  // Handle Call Expressions: func(), obj.method(), func()() etc.
+  if (ts.isCallExpression(unwrappedNode)) {
+    // 1. Process the expression being called (e.g., 'func', 'obj.method')
+    const calledExprProcessed = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+
+    if (!calledExprProcessed) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported expression being called: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a proper path for the called expression
+    const calledExprPath = StructuredPath.fromNode(
+      unwrappedNode.expression,
+      context.sourceFile,
+    );
+
+    if (!calledExprPath) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Couldn't get path for called expression: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Build call path using original source text for consistent schema paths.
+    // IMPORTANT: Never use cyScope names in call paths - they are internal identifiers
+    // that should not appear in schema paths or call signatures.
+    const callPath = buildCallPathFromSource(unwrappedNode, context);
+
+    // 2. Process all arguments recursively WITH targetPath for proper equivalence
+    for (let i = 0; i < unwrappedNode.arguments.length; i++) {
+      const arg = unwrappedNode.arguments[i];
+
+      const childBoundary = context.isChildBoundary(arg);
+      if (childBoundary) {
+        context.addChildBoundaryEquivalence(callPath.withParameter(i), arg);
+      }
+
+      // Process each argument with its parameter path as targetPath
+      // This automatically establishes all equivalences and types
+      processExpression({
+        node: arg,
+        context,
+        targetPath: callPath.withParameter(i), // Use parameter path as targetPath
+      });
+
+      // Special case for Object.keys, etc.
+      if (calledExprPath.base === 'Object' && i === 0) {
+        const argPath = StructuredPath.fromNode(arg, context.sourceFile);
+        if (argPath) {
+          context.addType(argPath, 'object');
+        }
+      }
+    }
+
+    // 5. Handle Method Semantics and determine return type
+    let returnType = 'unknown';
+    let handledBySemantics = false;
+
+    // Check if it's a method call (PropertyAccess)
+    if (ts.isPropertyAccessExpression(unwrappedNode.expression)) {
+      const methodName = unwrappedNode.expression.name.text;
+      const semanticsList = methodRegistry.getByMethodName(methodName);
+
+      if (semanticsList && semanticsList.length > 0) {
+        const semantics = semanticsList[0];
+
+        // Get the source expression path (e.g., the object for obj.method())
+        const sourceExpr = unwrappedNode.expression.expression;
+        const unwrappedSourceExpr = unwrapExpression(sourceExpr);
+
+        // When the source is a ternary expression like (cond ? arr : arr.slice()),
+        // apply method semantics to BOTH branches directly. The ternary itself isn't
+        // a variable - it's just a choice between two paths that both flow to the result.
+        if (ts.isConditionalExpression(unwrappedSourceExpr)) {
+          const branches = [
+            unwrappedSourceExpr.whenTrue,
+            unwrappedSourceExpr.whenFalse,
+          ];
+
+          for (const branch of branches) {
+            const branchPath = StructuredPath.fromNode(
+              branch,
+              context.sourceFile,
+            );
+            if (branchPath) {
+              const isArraySemantics = semantics instanceof ArrayPushSemantics;
+              const shouldApply =
+                !isArraySemantics ||
+                isLikelyArrayType(branch, context.typeChecker);
+
+              if (shouldApply) {
+                semantics.addEquivalences(callPath, branchPath, context);
+                returnType = semantics.getReturnType();
+                handledBySemantics = true;
+              }
+            }
+          }
+        } else {
+          // Regular (non-ternary) source expression
+          const sourcePath = StructuredPath.fromNode(
+            sourceExpr,
+            context.sourceFile,
+          );
+
+          if (sourcePath) {
+            // For array-specific semantics (like push), verify the source is actually an array
+            // This prevents router.push() from being mistakenly treated as Array.push()
+            const isArraySemantics = semantics instanceof ArrayPushSemantics;
+            const shouldApply =
+              !isArraySemantics ||
+              isLikelyArrayType(sourceExpr, context.typeChecker);
+
+            if (shouldApply) {
+              // Apply method semantics
+              semantics.addEquivalences(callPath, sourcePath, context);
+              returnType = semantics.getReturnType();
+              handledBySemantics = true;
+            }
+          }
+        }
+      }
+    }
+    // Check if it's a method call via element access (obj['method']())
+    else if (
+      ts.isElementAccessExpression(unwrappedNode.expression) &&
+      ts.isStringLiteral(unwrappedNode.expression.argumentExpression)
+    ) {
+      const methodName = unwrappedNode.expression.argumentExpression.text;
+      const semanticsList = methodRegistry.getByMethodName(methodName);
+
+      if (semanticsList && semanticsList.length > 0) {
+        const semantics = semanticsList[0];
+
+        // Get the source expression path
+        const sourceExpr = unwrappedNode.expression.expression;
+        const sourcePath = StructuredPath.fromNode(
+          sourceExpr,
+          context.sourceFile,
+        );
+
+        if (sourcePath) {
+          // For array-specific semantics (like push), verify the source is actually an array
+          const isArraySemantics = semantics instanceof ArrayPushSemantics;
+          const shouldApply =
+            !isArraySemantics ||
+            isLikelyArrayType(sourceExpr, context.typeChecker);
+
+          if (shouldApply) {
+            // Apply method semantics
+            semantics.addEquivalences(callPath, sourcePath, context);
+            returnType = semantics.getReturnType();
+            handledBySemantics = true;
+          }
+        }
+      }
+    }
+    // 7. Determine and Add Return Type
+    if (returnType === 'unknown') {
+      // If semantics didn't provide a type, try inferring
+      returnType = context.inferTypeFromNode(node);
+    }
+
+    // Register types
+    context.addType(callPath, 'function');
+    context.addType(calledExprPath, 'function');
+
+    // Only register the function call return value if:
+    // - It's not void, AND
+    // - Either the result is being used (targetPath exists) OR the return type is known (not 'unknown')
+    if (returnType !== 'void' && (targetPath || returnType !== 'unknown')) {
+      const returnValuePath = callPath.withProperty('functionCallReturnValue');
+      context.addType(returnValuePath, returnType);
+    }
+
+    // 8. If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, callPath);
+      context.addType(targetPath, returnType);
+    }
+
+    return true;
+  }
+
+  // Handle Object Literals: { a: 1, b: x, ...spread }
+  if (ts.isObjectLiteralExpression(unwrappedNode)) {
+    // Create a path for the object literal itself
+    const literalSourcePath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'object',
+    );
+
+    // If targetPath is provided, establish property relationships
+    // This is the main use case we're optimizing for
+    if (targetPath) {
+      // Process each property and establish relationships to the targetPath
+      for (const property of unwrappedNode.properties) {
+        if (ts.isPropertyAssignment(property)) {
+          // Get property name
+          let propName: string;
+          if (ts.isIdentifier(property.name)) {
+            propName = property.name.text;
+          } else if (ts.isStringLiteral(property.name)) {
+            propName = property.name.text;
+          } else if (ts.isNumericLiteral(property.name)) {
+            propName = property.name.text;
+          } else if (ts.isComputedPropertyName(property.name)) {
+            // Handle computed property names: { [x]: y }
+            processExpression({ node: property.name.expression, context });
+            const path = StructuredPath.fromNode(
+              property.name.expression,
+              context.sourceFile,
+            );
+            propName = `*${path}*`;
+          } else {
+            // For other property name types, use text representation
+            propName = property.name.getText(context.sourceFile);
+            context.markSemanticLimitation(
+              property.name,
+              'Complex property name might not be accurately represented.',
+            );
+          }
+
+          // Create a path for this property within the base
+          const propPath = targetPath.withProperty(propName);
+
+          // Handle child boundaries (callback functions) in object properties
+          // This establishes equivalency between the property path and the child scope
+          // e.g., columns[0].renderCell → cyScope1()
+          if (context.isChildBoundary(property.initializer)) {
+            context.addChildBoundaryEquivalence(propPath, property.initializer);
+          }
+
+          // Process the property value with propPath as targetPath
+          // This allows nested object literals to work correctly
+          processExpression({
+            node: property.initializer,
+            context,
+            targetPath: propPath,
+          });
+        } else if (ts.isShorthandPropertyAssignment(property)) {
+          // Handle shorthand form: { x } is equivalent to { x: x }
+          const propName = property.name.text;
+          const propPath = targetPath.withProperty(propName);
+
+          // Create a path for the identifier value
+          const valuePath = StructuredPath.fromBase(propName);
+
+          // Establish the equivalence and type
+          context.addEquivalence(propPath, valuePath);
+          const valueType = context.inferTypeFromNode(property.name);
+          context.addType(propPath, valueType);
+          context.addType(valuePath, valueType);
+        } else if (ts.isSpreadAssignment(property)) {
+          // Handle spread: { ...obj }
+          // Create a path for this spread source
+          let spreadSourcePath: StructuredPath | null = null;
+
+          // Handle simple identifier spread: { ...obj }
+          if (ts.isIdentifier(property.expression)) {
+            // Process the spread expression first
+            processExpression({ node: property.expression, context });
+
+            spreadSourcePath = StructuredPath.fromBase(
+              property.expression.text,
+            );
+            // Establish equivalence between the target and the spread source
+            context.addEquivalence(targetPath, spreadSourcePath);
+            // and we know obj is an object
+            context.addType(spreadSourcePath, 'object');
+          }
+          // Handle property access spread: { ...obj.prop }
+          else if (ts.isPropertyAccessExpression(property.expression)) {
+            // Process the spread expression first
+            processExpression({ node: property.expression, context });
+
+            spreadSourcePath = StructuredPath.fromNode(
+              property.expression,
+              context.sourceFile,
+            );
+            if (spreadSourcePath) {
+              context.addEquivalence(targetPath, spreadSourcePath);
+            }
+          }
+          // Handle object literal spread: { ...{ key: value } }
+          // This propagates sub-properties from the spread object to the target
+          else if (ts.isObjectLiteralExpression(property.expression)) {
+            // Recursively process the spread object literal WITH targetPath
+            // This ensures sub-properties like { args: x } become targetPath.args = x
+            processExpression({
+              node: property.expression,
+              context,
+              targetPath,
+            });
+          }
+          // Handle conditional spread: { ...(x ? {...} : {}) }
+          else if (ts.isParenthesizedExpression(property.expression)) {
+            // Unwrap parentheses and process
+            const unwrapped = property.expression.expression;
+
+            // Handle conditional expression inside parens: (x ? {...} : {})
+            if (ts.isConditionalExpression(unwrapped)) {
+              // Process both branches - whenTrue and whenFalse
+              // For tracing, we care about non-empty branches
+              if (ts.isObjectLiteralExpression(unwrapped.whenTrue)) {
+                processExpression({
+                  node: unwrapped.whenTrue,
+                  context,
+                  targetPath,
+                });
+              } else {
+                processExpression({ node: unwrapped.whenTrue, context });
+              }
+
+              if (ts.isObjectLiteralExpression(unwrapped.whenFalse)) {
+                processExpression({
+                  node: unwrapped.whenFalse,
+                  context,
+                  targetPath,
+                });
+              } else {
+                processExpression({ node: unwrapped.whenFalse, context });
+              }
+            } else {
+              // Other parenthesized expression - just process normally
+              processExpression({ node: property.expression, context });
+            }
+          }
+          // Handle other expression types
+          else {
+            // Process the spread expression
+            processExpression({ node: property.expression, context });
+
+            // For complex expressions, use their source representation
+            spreadSourcePath = nodeToSource(
+              property.expression,
+              context.sourceFile,
+            );
+            if (spreadSourcePath) {
+              context.addEquivalence(targetPath, spreadSourcePath);
+            }
+
+            // Mark semantic limitation only for complex spread expressions
+            context.markSemanticLimitation(
+              property,
+              'Complex spread assignment - individual properties not fully mapped.',
+            );
+          }
+        } else if (
+          ts.isMethodDeclaration(property) ||
+          ts.isGetAccessorDeclaration(property) ||
+          ts.isSetAccessorDeclaration(property)
+        ) {
+          // For methods and accessors, just mark the property as a function
+          if (ts.isIdentifier(property.name)) {
+            const propName = property.name.text;
+            const propPath = targetPath.withProperty(propName);
+            context.addType(propPath, 'function');
+          }
+
+          context.markUnsupported(
+            property,
+            `processExpression: Method/Accessor in object literal not fully processed: ${ts.SyntaxKind[property.kind]}`,
+            false,
+          );
+        }
+      }
+
+      // Mark the targetPath as an object type
+      context.addType(targetPath, 'object');
+      return true;
+    } else {
+      // No targetPath provided - just process each property for side effects
+      for (const property of unwrappedNode.properties) {
+        if (ts.isPropertyAssignment(property)) {
+          processExpression({ node: property.initializer, context });
+        } else if (ts.isShorthandPropertyAssignment(property)) {
+          // For shorthand, establish type for the identifier
+          const identPath = StructuredPath.fromBase(property.name.text);
+          const idType = context.inferTypeFromNode(property.name);
+          context.addType(identPath, idType);
+        } else if (ts.isSpreadAssignment(property)) {
+          // Still process the spread expression to ensure its contents are analyzed
+          processExpression({ node: property.expression, context });
+
+          // Even without a targetPath, we can still determine the type for the spread source
+          if (ts.isIdentifier(property.expression)) {
+            const spreadSource = StructuredPath.fromBase(
+              property.expression.text,
+            );
+            context.addType(spreadSource, 'object');
+          } else if (ts.isPropertyAccessExpression(property.expression)) {
+            const spreadSource = StructuredPath.fromNode(
+              property.expression,
+              context.sourceFile,
+            );
+            if (spreadSource) {
+              context.addType(spreadSource, 'object');
+            }
+          }
+        } else if (
+          ts.isMethodDeclaration(property) ||
+          ts.isGetAccessorDeclaration(property) ||
+          ts.isSetAccessorDeclaration(property)
+        ) {
+          context.markUnsupported(
+            property,
+            `processExpression: Method/Accessor in object literal not fully processed: ${ts.SyntaxKind[property.kind]}`,
+            false,
+          );
+        }
+      }
+
+      // If we have no targetPath but we're still analyzing an object literal,
+      // create a type registration for the literal itself
+      context.addType(literalSourcePath, 'object');
+      return true;
+    }
+  }
+
+  // Handle Array Literals: [1, x, func()]
+  if (ts.isArrayLiteralExpression(unwrappedNode)) {
+    // Create a path for the array literal
+    const arrayLiteralPath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'array',
+    );
+
+    // Process each element recursively
+    for (let i = 0; i < unwrappedNode.elements.length; i++) {
+      const element = unwrappedNode.elements[i];
+
+      // If targetPath is provided, create element paths
+      if (targetPath) {
+        // Create path for this element (e.g., targetPath[0], targetPath[1])
+        const elementPath = targetPath.withElement(i);
+
+        // Process the element with elementPath as targetPath
+        processExpression({ node: element, context, targetPath: elementPath });
+      } else {
+        // No targetPath, just process for side effects
+        processExpression({ node: element, context });
+      }
+    }
+
+    // Register type information
+    if (targetPath) {
+      context.addType(targetPath, 'array');
+    } else {
+      context.addType(arrayLiteralPath, 'array');
+    }
+
+    return true;
+  }
+
+  // Handle Element Access: arr[0], obj[key], obj['prop']
+  if (ts.isElementAccessExpression(unwrappedNode)) {
+    // Process the object expression
+    const objectProcessed = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+
+    if (!objectProcessed) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported base expression for element access: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the object
+    const objectPath = StructuredPath.fromNode(
+      unwrappedNode.expression,
+      context.sourceFile,
+    );
+
+    if (!objectPath) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Couldn't get path for element access base: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Process the argument expression
+    processExpression({ node: unwrappedNode.argumentExpression, context });
+
+    // Create the element access path based on argument type
+    let elementPath: StructuredPath;
+
+    if (ts.isNumericLiteral(unwrappedNode.argumentExpression)) {
+      // Array index: arr[0]
+      elementPath = objectPath.withElement(
+        parseInt(unwrappedNode.argumentExpression.text, 10),
+      );
+    } else if (ts.isStringLiteral(unwrappedNode.argumentExpression)) {
+      // String key: obj['prop']
+      elementPath = objectPath.withProperty(
+        unwrappedNode.argumentExpression.text,
+      );
+    } else {
+      // Dynamic access: obj[key]
+      // Use a representation of the argument or fallback to wildcard
+      const argText = unwrappedNode.argumentExpression.getText(
+        context.sourceFile,
+      );
+      elementPath = objectPath.withElement(argText || '*');
+    }
+
+    // Infer and register type
+    context.addType(elementPath, inferredNodeType);
+
+    // If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, elementPath);
+      context.addType(targetPath, inferredNodeType);
+    }
+
+    return true;
+  }
+
+  // Handle Conditional Expression (Ternary): cond ? trueVal : falseVal
+  if (ts.isConditionalExpression(unwrappedNode)) {
+    // Mark variables in the condition as potentially undefined
+    markConditionVariablesAsNullable(unwrappedNode.condition, context);
+
+    // 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,
+      context,
+      typeHint: 'boolean | unknown',
+    }); //TODO: could we capture that this is evidence of a boolean type?
+
+    // Process both branches WITH targetPath to establish equivalencies
+    // This is critical for tracing nested properties through ternary assignments
+    // e.g., const items = condition ? arr1 : arr2; items.map(i => i.prop)
+    // We need items to be equivalent to both arr1 AND arr2 for proper tracing
+    processExpression({ node: unwrappedNode.whenTrue, context, targetPath });
+    processExpression({ node: unwrappedNode.whenFalse, context, targetPath });
+
+    // Create a path for the whole expression
+    const expressionSourcePath = nodeToSource(
+      unwrappedNode,
+      context.sourceFile,
+    );
+
+    // Infer type based on branches
+    const trueType = context.inferTypeFromNode(unwrappedNode.whenTrue);
+    const falseType = context.inferTypeFromNode(unwrappedNode.whenFalse);
+
+    // Determine the result type
+    let resultType = leftOrRightType(falseType, trueType);
+    if (!resultType) {
+      // If we can't determine a specific type, use unknown without marking as semantic limitation
+      // This prevents conditional expressions from marking the analysis as incomplete
+      resultType = 'unknown';
+    }
+
+    // Register type for the expression
+    context.addType(expressionSourcePath, resultType);
+
+    // If targetPath is provided, only register type (don't overwrite branch equivalencies)
+    // The equivalencies to individual branches (set above) are more useful for tracing
+    // than an equivalency to the entire ternary expression text
+    if (targetPath) {
+      // NOTE: We intentionally do NOT add equivalence here.
+      // The branch processing above already added equivalencies:
+      //   targetPath -> whenTrue branch
+      //   targetPath -> whenFalse branch
+      // Adding an equivalence to expressionSourcePath would overwrite those
+      // with a useless equivalence to the ternary text itself.
+      //
+      // Use updateSchemaType instead of addType because:
+      // 1. Branch processing may have already set a type on targetPath
+      // 2. addType has a guard that prevents overwriting specific types with 'unknown'
+      // 3. updateSchemaType bypasses this guard, ensuring the ternary's computed type is used
+      context.updateSchemaType(targetPath, resultType);
+    }
+
+    return true;
+  }
+
+  // Handle New Expression: new Date(), new MyClass()
+  if (ts.isNewExpression(unwrappedNode)) {
+    // Process the constructor expression
+    const constructorProcessed = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+
+    if (!constructorProcessed) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported constructor expression: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the constructor
+    const constructorPath = StructuredPath.fromNode(
+      unwrappedNode.expression,
+      context.sourceFile,
+    );
+
+    if (!constructorPath) {
+      return false;
+    }
+
+    // Process any arguments
+    if (unwrappedNode.arguments) {
+      for (const arg of unwrappedNode.arguments) {
+        processExpression({ node: arg, context });
+      }
+    }
+
+    // Create argument paths for the function call
+    const validArgPaths: StructuredPath[] = unwrappedNode.arguments
+      ? unwrappedNode.arguments.map(
+          (arg) =>
+            StructuredPath.fromNode(arg, context.sourceFile) ??
+            nodeToSource(arg, context.sourceFile) ??
+            StructuredPath.literal('unknown'),
+        )
+      : [];
+
+    // Construct a path for the new expression
+    const newCallPath = constructorPath.withFunctionCall(validArgPaths);
+
+    // Infer result type
+    let resultType = 'object';
+    if (ts.isIdentifier(unwrappedNode.expression)) {
+      const constructorName = unwrappedNode.expression.text;
+      if (
+        ['String', 'Number', 'Boolean', 'Array', 'Date'].includes(
+          constructorName,
+        )
+      ) {
+        resultType = constructorName.toLowerCase();
+      }
+    } else {
+      resultType = inferredNodeType;
+    }
+
+    // Register types
+    context.addType(newCallPath, resultType);
+    context.addType(constructorPath, 'function');
+
+    // If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, newCallPath);
+      context.addType(targetPath, resultType);
+    }
+
+    return true;
+  }
+
+  // Handle Arrow Functions: (p) => p.prop, (a, b) => { ... }
+  if (ts.isArrowFunction(unwrappedNode)) {
+    // If this arrow function is a child boundary (e.g., a .map() callback),
+    // don't process its parameters here - they will be processed when the
+    // child scope is analyzed separately. This prevents parameter variables
+    // from leaking into the parent scope's equivalencies.
+    // Check if this arrow function is a child boundary (i.e., should be processed
+    // as a separate child scope, not here in the parent scope).
+    //
+    // We use two checks because childBoundary positions can be unreliable:
+    // 1. Position-based check (standard isChildBoundary)
+    // 2. Text-based check: if the arrow function text doesn't appear in the
+    //    statement text, it was replaced with a cyScope placeholder
+    const isChildBoundary = context.isChildBoundary(unwrappedNode);
+
+    // Text-based child scope detection for when positions are unreliable
+    const arrowFnText = unwrappedNode.getText(context.sourceFile);
+    const firstLine = arrowFnText.split('\n')[0].trim();
+    const searchText = firstLine.substring(0, Math.min(20, firstLine.length));
+    const isInStatementText = context.statementInfo.text.includes(searchText);
+    const isChildScope = !isInStatementText && arrowFnText.length > 10;
+
+    if (isChildBoundary || isChildScope) {
+      // The method semantics (e.g., ArrayMapSemantics) have already established
+      // the necessary equivalences between the child scope placeholder and array elements
+      if (targetPath) {
+        context.addType(targetPath, 'function');
+      }
+      return true;
+    }
+
+    // Create a path for the function
+    const functionPath = StructuredPath.empty();
+
+    // Process parameters
+    unwrappedNode.parameters.forEach((param, index) => {
+      const signaturePath = functionPath.withParameter(index);
+      if (ts.isIdentifier(param.name)) {
+        const paramNamePath = StructuredPath.fromBase(param.name.text);
+
+        // Establish equivalence between parameter name and signature path
+        context.addEquivalence(paramNamePath, signaturePath);
+
+        // Register types
+        const paramType = context.inferTypeFromNode(param) || 'unknown';
+        context.addType(paramNamePath, paramType);
+        context.addType(signaturePath, paramType);
+      } else if (
+        ts.isObjectBindingPattern(param.name) ||
+        ts.isArrayBindingPattern(param.name)
+      ) {
+        const success = processBindingPattern(
+          param.name,
+          signaturePath,
+          context,
+        );
+        if (!success) {
+          context.markUnsupported(
+            param,
+            `processExpression: Failed to process binding pattern: ${ts.SyntaxKind[param.kind]}`,
+            false,
+          );
+        }
+      } else {
+        context.markUnsupported(
+          param,
+          `processExpression: Unsupported parameter kind in ArrowFunction: ${ts.SyntaxKind[param.kind]}`,
+          false,
+        );
+      }
+    });
+
+    // Process function body
+    const body = unwrappedNode.body;
+    if (ts.isBlock(body)) {
+      // For block bodies, process the statements inside
+      context.processNode(body);
+    } else {
+      // For expression bodies, process as implicit return
+      const returnPath = functionPath.withProperty('returnValue');
+      processExpression({ node: body, context, targetPath: returnPath });
+    }
+
+    // If targetPath is provided, establish equivalence
+    if (targetPath) {
+      context.addEquivalence(targetPath, functionPath);
+      context.addType(targetPath, 'function');
+    }
+
+    return true;
+  }
+
+  // Handle Tagged Template Expressions: sql`SELECT * FROM ${table}`
+  if (ts.isTaggedTemplateExpression(unwrappedNode)) {
+    // Process the tag expression (e.g., 'sql', 'css', 'gql')
+    const tagProcessed = processExpression({
+      node: unwrappedNode.tag,
+      context,
+    });
+
+    if (!tagProcessed) {
+      context.markUnsupported(
+        unwrappedNode.tag,
+        `processExpression: Unsupported tag expression in tagged template: ${ts.SyntaxKind[unwrappedNode.tag.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the tag
+    const tagPath = StructuredPath.fromNode(
+      unwrappedNode.tag,
+      context.sourceFile,
+    );
+
+    if (tagPath) {
+      // Mark the tag as a function
+      context.addType(tagPath, 'function');
+    }
+
+    // Process the template part (reusing existing template processing logic)
+    const template = unwrappedNode.template;
+    let allSpansProcessed = true;
+
+    if (ts.isTemplateExpression(template)) {
+      // Process all template spans (interpolations)
+      for (const span of template.templateSpans) {
+        if (context.isChildBoundary(span.expression)) {
+          continue;
+        }
+
+        const spanProcessed = processExpression({
+          node: span.expression,
+          context,
+          targetPath: StructuredPath.empty(),
+        });
+
+        allSpansProcessed = allSpansProcessed && spanProcessed;
+      }
+    }
+    // If it's NoSubstitutionTemplateLiteral, nothing more to process
+
+    // Create a path for the entire tagged template expression
+    const taggedTemplatePath = StructuredPath.fromNode(
+      unwrappedNode,
+      context.sourceFile,
+    );
+
+    // The return type of a tagged template is unknown (depends on the tag function)
+    context.addType(taggedTemplatePath, 'unknown');
+
+    // If targetPath is provided, establish equivalence
+    if (targetPath) {
+      context.addEquivalence(targetPath, taggedTemplatePath);
+      context.addType(targetPath, 'unknown');
+    }
+
+    // If we didn't fully handle all spans, mark as semantic limitation
+    if (!allSpansProcessed && ts.isTemplateExpression(template)) {
+      context.markSemanticLimitation(
+        unwrappedNode,
+        'Tagged template contains complex expressions that may not be fully analyzed',
+      );
+    }
+
+    return true;
+  }
+
+  // Handle Template Literals: `Hello ${name}` or `Simple`
+  if (
+    ts.isTemplateExpression(unwrappedNode) ||
+    ts.isNoSubstitutionTemplateLiteral(unwrappedNode)
+  ) {
+    // Create a path for the template literal
+    const templatePath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'string',
+    );
+
+    // Track if we can fully handle all expressions in the template
+    let allSpansProcessed = true;
+
+    // Process template spans if any by recursing back into processExpression
+    if (ts.isTemplateExpression(unwrappedNode)) {
+      for (const span of unwrappedNode.templateSpans) {
+        if (context.isChildBoundary(span.expression)) {
+          continue;
+        }
+
+        // Process each span with StructuredPath.empty() as targetPath
+        // This ensures types and equivalences are established without imposing
+        // a prefix that wouldn't make sense in a template context
+        const spanProcessed = processExpression({
+          node: span.expression,
+          context,
+          targetPath: StructuredPath.empty(), // Use empty path to trigger equivalence and type registration
+        });
+
+        allSpansProcessed = allSpansProcessed && spanProcessed;
+      }
+    }
+
+    // Template expressions are always strings
+    context.addType(templatePath, 'string');
+
+    // Register the type with targetPath if provided
+    if (targetPath) {
+      context.addEquivalence(targetPath, templatePath);
+      context.addType(targetPath, 'string');
+    }
+
+    // If we didn't fully handle all spans, still return true but with limitations noted
+    if (!allSpansProcessed && ts.isTemplateExpression(unwrappedNode)) {
+      context.markSemanticLimitation(
+        unwrappedNode,
+        'Template literal contains complex expressions that may not be fully analyzed',
+      );
+    }
+
+    return true;
+  }
+
+  // Handle TypeOf Expression: typeof x
+  if (ts.isTypeOfExpression(unwrappedNode)) {
+    // Process the inner expression
+    processExpression({ node: unwrappedNode.expression, context });
+
+    // Create a path for the typeof expression
+    const typeofPath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'string',
+    );
+
+    // Register the type (always string)
+    if (targetPath) {
+      context.addEquivalence(targetPath, typeofPath);
+      context.addType(targetPath, 'string');
+    }
+
+    return true;
+  }
+
+  // Handle Void Expression: void x, void 0, void func()
+  if (ts.isVoidExpression(unwrappedNode)) {
+    // Process the inner expression for side effects
+    processExpression({ node: unwrappedNode.expression, context });
+
+    // void always returns undefined
+    if (targetPath) {
+      const voidPath = StructuredPath.createLiteralPath(
+        'undefined',
+        'undefined',
+      );
+      context.addEquivalence(targetPath, voidPath);
+      context.addType(targetPath, 'undefined');
+    }
+
+    return true;
+  }
+
+  // Handle Prefix Unary Expressions: ++x, --y, !z, -a
+  if (ts.isPrefixUnaryExpression(unwrappedNode)) {
+    // Process the operand
+    const operandProcessed = processExpression({
+      node: unwrappedNode.operand,
+      context,
+    });
+
+    if (!operandProcessed) {
+      context.markUnsupported(
+        unwrappedNode.operand,
+        `processExpression: Could not process operand of PrefixUnaryExpression: ${ts.SyntaxKind[unwrappedNode.operand.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the operand
+    const operandPath = StructuredPath.fromNode(
+      unwrappedNode.operand,
+      context.sourceFile,
+    );
+
+    if (!operandPath) {
+      return false;
+    }
+
+    // Determine the result type based on operator
+    const operatorKind = unwrappedNode.operator;
+    let resultType = 'unknown';
+
+    if (
+      operatorKind === ts.SyntaxKind.PlusPlusToken ||
+      operatorKind === ts.SyntaxKind.MinusMinusToken
+    ) {
+      resultType = 'number';
+    } else if (operatorKind === ts.SyntaxKind.ExclamationToken) {
+      resultType = 'boolean | unknown';
+    } else if (
+      operatorKind === ts.SyntaxKind.MinusToken ||
+      operatorKind === ts.SyntaxKind.PlusToken ||
+      operatorKind === ts.SyntaxKind.TildeToken
+    ) {
+      resultType = 'number';
+    } else {
+      context.markUnsupported(
+        unwrappedNode,
+        `processExpression: Unsupported prefix unary operator: ${ts.SyntaxKind[operatorKind]}`,
+        false,
+      );
+    }
+
+    // Register the operand's type (which is also the result)
+    context.addType(operandPath, resultType);
+
+    // If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, operandPath);
+      context.addType(targetPath, resultType);
+    }
+
+    return true;
+  }
+
+  // Handle Postfix Unary Expressions: x++, y--, etc.
+  if (ts.isPostfixUnaryExpression(unwrappedNode)) {
+    // Process the operand
+    const operandProcessed = processExpression({
+      node: unwrappedNode.operand,
+      context,
+    });
+
+    if (!operandProcessed) {
+      context.markUnsupported(
+        unwrappedNode.operand,
+        `processExpression: Could not process operand of PostfixUnaryExpression: ${ts.SyntaxKind[unwrappedNode.operand.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the operand
+    const operandPath = StructuredPath.fromNode(
+      unwrappedNode.operand,
+      context.sourceFile,
+    );
+
+    if (!operandPath) {
+      return false;
+    }
+
+    // Determine the result type based on operator
+    const operatorKind = unwrappedNode.operator;
+    let resultType = 'unknown';
+
+    // Currently postfix expressions only support ++ and -- operators
+    if (
+      operatorKind === ts.SyntaxKind.PlusPlusToken ||
+      operatorKind === ts.SyntaxKind.MinusMinusToken
+    ) {
+      resultType = 'number';
+
+      // Register the operand as a number
+      context.addType(operandPath, resultType);
+
+      // If it's a property access like user.age, add type for parent object
+      if (ts.isPropertyAccessExpression(unwrappedNode.operand)) {
+        const objectPath = StructuredPath.fromNode(
+          unwrappedNode.operand.expression,
+          context.sourceFile,
+        );
+        if (objectPath) {
+          context.addType(objectPath, 'object');
+        }
+      }
+    } else {
+      // Should never reach here (postfix only has ++ and --) but handle just in case
+      context.markUnsupported(
+        unwrappedNode,
+        `processExpression: Unsupported postfix unary operator: ${ts.SyntaxKind[operatorKind]}`,
+        false, // Non-blocking
+      );
+      return false;
+    }
+
+    // If targetPath is provided, establish equivalence and register type
+    if (targetPath) {
+      context.addEquivalence(targetPath, operandPath);
+      context.addType(targetPath, resultType);
+    }
+
+    return true;
+  }
+
+  // Handle JSX Elements (both normal and self-closing)
+  if (
+    ts.isJsxElement(unwrappedNode) ||
+    ts.isJsxSelfClosingElement(unwrappedNode)
+  ) {
+    let openingElement: ts.JsxOpeningElement | ts.JsxSelfClosingElement;
+
+    if (ts.isJsxElement(unwrappedNode)) {
+      openingElement = unwrappedNode.openingElement;
+    } else {
+      openingElement = unwrappedNode;
+    }
+
+    // Extract the component/tag name
+    const tagName = getJsxTagName(openingElement.tagName, context);
+    if (!tagName) {
+      context.markUnsupported(
+        unwrappedNode,
+        'Unable to determine JSX element name',
+        false,
+      );
+      return false;
+    }
+
+    // Create a path for the component as a function call
+    const componentPath = StructuredPath.fromFunction(tagName);
+
+    // Process each attribute
+    let allAttributesHandled = true;
+    for (const attr of openingElement.attributes.properties) {
+      if (ts.isJsxAttribute(attr)) {
+        // Process JSX attribute with component path as context
+        const attrHandled = processJsxAttribute(
+          attr,
+          context,
+          componentPath,
+          targetPath,
+        );
+        allAttributesHandled = allAttributesHandled && attrHandled;
+      } else if (ts.isJsxSpreadAttribute(attr)) {
+        // Process JSX spread attribute (e.g., <Comp {...props} />)
+        if (attr.expression) {
+          // Process the spread expression
+          const parameterPath = componentPath.withParameter(0);
+          const spreadProcessed = processExpression({
+            node: attr.expression,
+            context,
+            targetPath: parameterPath,
+          });
+          if (!spreadProcessed) {
+            context.markUnsupported(
+              attr.expression,
+              `processExpression: Unsupported spread expression: ${ts.SyntaxKind[attr.expression.kind]}`,
+              false,
+            );
+          }
+
+          allAttributesHandled = allAttributesHandled && spreadProcessed;
+        }
+      }
+    }
+
+    // Process children for JSX elements (not self-closing)
+    if (ts.isJsxElement(unwrappedNode)) {
+      for (const child of unwrappedNode.children) {
+        // Process expressions in JSX children: <div>{expr}</div>
+        if (ts.isJsxExpression(child) && child.expression) {
+          // When processing return value JSX, link root variables to return value schema
+          if (targetPath && targetPath.base !== '') {
+            const varNames = [
+              ...new Set(extractRootVariableNames(child.expression)),
+            ];
+            for (const varName of varNames) {
+              context.addEquivalence(
+                targetPath.withProperty(varName),
+                StructuredPath.fromBase(varName),
+              );
+            }
+          }
+
+          // Process the expression with StructuredPath.empty() as targetPath
+          // to trigger type registration without imposing prefix
+          processExpression({
+            node: child.expression,
+            context,
+            targetPath: StructuredPath.empty(),
+          });
+        }
+        // Process nested JSX elements recursively
+        else if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+          processExpression({ node: child, context });
+        }
+      }
+    }
+
+    // Register component as 'jsx-component' type to distinguish from regular function calls
+    // This allows downstream code to identify JSX components and not treat them as method chains
+    context.addType(componentPath, 'jsx-component');
+
+    // If targetPath is provided (e.g., in variable assignment), establish equivalence to hardcoded "JSX"
+    if (targetPath) {
+      context.addEquivalence(targetPath, StructuredPath.literal('JSX'));
+      // Don't register a type for targetPath
+    }
+
+    return allAttributesHandled;
+  }
+
+  // Handle JSX Fragments (<>...</>)
+  if (ts.isJsxFragment(unwrappedNode)) {
+    // Process children
+    for (const child of unwrappedNode.children) {
+      // Process expressions in JSX children: <>{expr}</>
+      if (ts.isJsxExpression(child) && child.expression) {
+        // When processing return value JSX, link root variables to return value schema
+        if (targetPath && targetPath.base !== '') {
+          const varNames = [
+            ...new Set(extractRootVariableNames(child.expression)),
+          ];
+          for (const varName of varNames) {
+            context.addEquivalence(
+              targetPath.withProperty(varName),
+              StructuredPath.fromBase(varName),
+            );
+          }
+        }
+
+        // Process the expression to extract structure
+        processExpression({
+          node: child.expression,
+          context,
+          targetPath: StructuredPath.empty(),
+        });
+      }
+      // Process nested JSX elements recursively
+      else if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+        processExpression({ node: child, context });
+      }
+      // Process nested fragments recursively
+      else if (ts.isJsxFragment(child)) {
+        processExpression({ node: child, context });
+      }
+      // Process JsxText (for completeness)
+      else if (ts.isJsxText(child)) {
+        // JsxText nodes are just string literals, no additional processing needed
+        // But we record them for completeness
+      }
+    }
+
+    // If targetPath is provided, establish equivalence to hardcoded "JSX"
+    if (targetPath) {
+      context.addEquivalence(targetPath, StructuredPath.literal('JSX'));
+      // Don't register a type for targetPath
+    }
+
+    return true;
+  }
+
+  if (
+    ts.isJsxOpeningElement(unwrappedNode) ||
+    ts.isJsxOpeningFragment(unwrappedNode)
+  ) {
+    if (unwrappedNode.parent) {
+      return processExpression({
+        node: unwrappedNode.parent,
+        context,
+        targetPath,
+      });
+    }
+    // Fallback: shouldn't normally happen, but handle gracefully
+    return true;
+  }
+
+  if (
+    ts.isJsxClosingElement(unwrappedNode) ||
+    ts.isJsxClosingFragment(unwrappedNode)
+  ) {
+    // Closing elements/fragments don't carry additional information
+    return true;
+  }
+
+  // Handle standalone JsxExpression (e.g., {expr} in JSX context)
+  if (ts.isJsxExpression(unwrappedNode)) {
+    if (unwrappedNode.expression) {
+      // Process the inner expression
+      return processExpression({
+        node: unwrappedNode.expression,
+        context,
+        targetPath,
+      });
+    }
+    // If there's no expression, we can just return true
+    return true;
+  }
+
+  // Handle JsxText (text content inside JSX elements)
+  if (ts.isJsxText(unwrappedNode)) {
+    // JsxText is just string content in JSX, typically doesn't need
+    // complex analysis, but we mark it as handled
+
+    // If the text is non-whitespace and targetPath is provided,
+    // we could establish a string literal equivalence
+    const text = unwrappedNode.getText(context.sourceFile).trim();
+    if (text && targetPath) {
+      const literalPath = StructuredPath.createLiteralPath(
+        `"${text}"`,
+        'string',
+      );
+      context.addEquivalence(targetPath, literalPath);
+      context.addType(targetPath, 'string');
+    }
+
+    return true;
+  }
+
+  // Handle Spread Element: ...obj, ...arr
+  if (ts.isSpreadElement(unwrappedNode)) {
+    // Process the expression being spread
+    const spreadExprProcessed = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+
+    if (!spreadExprProcessed) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported expression in spread element: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    // Get a path for the spread expression
+    const spreadExprPath = StructuredPath.fromNode(
+      unwrappedNode.expression,
+      context.sourceFile,
+    );
+
+    if (!spreadExprPath) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Couldn't get path for spread element expression`,
+        false,
+      );
+      return false;
+    }
+
+    // Create a path for the spread element itself
+    const spreadPath = StructuredPath.fromBase(
+      `...${unwrappedNode.expression.getText(context.sourceFile)}`,
+    );
+
+    // If targetPath is provided, establish equivalence
+    if (targetPath) {
+      context.addEquivalence(targetPath, spreadPath);
+
+      // We don't know the exact type of the spread result as it depends on context
+      // (object spread vs array spread), so we use the same type as the expression
+      const spreadType = context.getTypeInfo(spreadExprPath) || 'unknown';
+      context.addType(targetPath, spreadType);
+    }
+
+    return true;
+  }
+  if (ts.isDeleteExpression(unwrappedNode)) {
+    // first just process whatever is being deleted
+    const result = processExpression({
+      node: unwrappedNode.expression,
+      context,
+    });
+    if (!result) {
+      context.markUnsupported(
+        unwrappedNode.expression,
+        `processExpression: Unsupported expression in delete: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`,
+        false,
+      );
+      return false;
+    }
+
+    nodePath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+    // 'delete' is boolean typed
+    context.addType(nodePath, 'boolean');
+
+    if (targetPath) {
+      context.addEquivalence(targetPath, nodePath);
+      context.addType(targetPath, 'boolean');
+    }
+    return result;
+  }
+
+  // Handle yield expressions in generator functions
+  if (ts.isYieldExpression(unwrappedNode)) {
+    // yield returns whatever is yielded, or undefined if no expression
+    if (unwrappedNode.expression) {
+      // Process the yielded expression
+      const result = processExpression({
+        node: unwrappedNode.expression,
+        context,
+        targetPath,
+      });
+      return result;
+    }
+    // yield with no expression returns undefined
+    if (targetPath) {
+      context.addType(targetPath, 'undefined');
+    }
+    return true;
+  }
+
+  if (ts.isRegularExpressionLiteral(unwrappedNode)) {
+    // Regular expressions are treated as string literals
+    const regexPath = StructuredPath.createLiteralPath(
+      unwrappedNode.getText(context.sourceFile),
+      'string',
+    );
+    context.addType(regexPath, 'string');
+
+    // If targetPath is provided, establish equivalence
+    if (targetPath) {
+      context.addEquivalence(targetPath, regexPath);
+      context.addType(targetPath, 'string');
+    }
+
+    return true;
+  }
+
+  console.warn(
+    `processExpression: Unsupported expression kind: ${ts.SyntaxKind[unwrappedNode.kind]}`,
+    {
+      nodeText: node.getText(context.sourceFile),
+      statementName: context.statementInfo.name,
+      statementText: context.statementInfo.text,
+    },
+  );
+
+  // For now, mark other types as unsupported and return false
+  context.markUnsupported(
+    unwrappedNode,
+    `processExpression: Unsupported expression kind: ${ts.SyntaxKind[unwrappedNode.kind]}`,
+    false, // Non-blocking for now
+  );
+  return false;
+}
+
+/**
+ * Helper function to process a JSX attribute
+ */
+function processJsxAttribute(
+  attr: ts.JsxAttribute,
+  context: AnalysisContext,
+  componentPath: StructuredPath,
+  targetPath?: StructuredPath,
+): boolean {
+  // JSX attribute names can be either simple identifiers or namespace names
+  const attrName = ts.isIdentifier(attr.name)
+    ? attr.name.text
+    : attr.name.name.text;
+
+  // Skip attributes with no initializer (boolean props)
+  if (!attr.initializer) {
+    return true;
+  }
+
+  // Create path for this attribute: Component.signature[0].attributeName
+  const attributePath = componentPath.withParameter(0).withProperty(attrName);
+
+  // For string literals: <Component attr="value" />
+  if (ts.isStringLiteral(attr.initializer)) {
+    const literalPath = StructuredPath.createLiteralPath(
+      `"${attr.initializer.text}"`,
+      'string',
+    );
+    context.addEquivalence(attributePath, literalPath);
+    context.addType(attributePath, 'string');
+    return true;
+  }
+
+  // For expressions: <Component attr={value} />
+  if (ts.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    const expression = attr.initializer.expression;
+    if (context.isChildBoundary(expression)) {
+      // Create equivalency between attribute path and child scope
+      // e.g., Grid().signature[0].renderRow → cyScope1()
+      context.addChildBoundaryEquivalence(attributePath, expression);
+      return true;
+    }
+
+    // Process the expression with attributePath as targetPath
+    // This will establish all equivalences and types automatically
+    return processExpression({
+      node: expression,
+      context,
+      targetPath: attributePath,
+    });
+  }
+
+  // Mark as unsupported if we couldn't handle the attribute
+  context.markUnsupported(
+    attr,
+    `Unsupported JSX attribute initializer: ${attr.initializer?.kind ? ts.SyntaxKind[attr.initializer.kind] : 'undefined'}`,
+    false,
+  );
+  return false;
+}
+
+/**
+ * Helper function to get a string representation of a JSX tag name
+ */
+function getJsxTagName(
+  tagNameNode: ts.JsxTagNameExpression,
+  context: AnalysisContext,
+): string {
+  if (ts.isIdentifier(tagNameNode)) {
+    return tagNameNode.text;
+  } else if (ts.isPropertyAccessExpression(tagNameNode)) {
+    const objName = getJsxTagName(tagNameNode.expression, context);
+    return objName ? `${objName}.${tagNameNode.name.text}` : '';
+  } else if ((tagNameNode as any).namespace) {
+    // Handle namespaced names like <ns:elem />
+    const jsxNamespacedName = tagNameNode as any;
+    return `${jsxNamespacedName.namespace.text}:${jsxNamespacedName.name.text}`;
+  }
+
+  return '';
+}