@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.d0ad4ae

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

@@ -1,8 +1,13 @@
 import ts from 'typescript';
-import { AnalysisContext, ConditionalUsage } from './types';
+import * as crypto from 'crypto';
+import {
+  AnalysisContext,
+  CompoundConditional,
+  ConditionalUsage,
+} from './types';
 import { StructuredPath } from './paths';
 import { nodeToSource } from './nodeToSource';
-import { methodRegistry } from './methodSemantics';
+import { methodRegistry, ArrayPushSemantics } from './methodSemantics';
 import {
   isArithmeticOperator,
   isAssignmentOperator,
@@ -15,6 +20,135 @@ import {
 } from './sharedPatterns';
 import { processBindingPattern } from './processBindings';
 
+/**
+ * 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).
@@ -72,9 +206,69 @@ export function markConditionVariablesAsNullable(
   }
 }
 
+/**
+ * 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,
+  };
+}
+
+/**
+ * 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;
+}
+
 /**
  * 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
@@ -85,119 +279,236 @@ export function extractConditionalUsage(
   context: AnalysisContext,
   location: ConditionalUsage['location'],
 ): void {
-  const unwrapped = unwrapExpression(condition);
+  // 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),
+          };
+          chainInfo = {
+            chainId,
+            chainLength,
+            chainExpression: compound.expression,
+            currentPosition: 0,
+            compound,
+          };
+        }
+      }
 
-  // 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
-  ) {
-    // Recursively process left side
-    extractConditionalUsage(unwrapped.left, context, location);
+      // 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);
+      // 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) {
-      extractConditionalUsage(unwrapped.right, context, location);
+      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;
     }
-    return;
-  }
 
-  // Handle binary expressions with || (logical OR)
-  if (
-    ts.isBinaryExpression(unwrapped) &&
-    unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken
-  ) {
-    // Both sides of || are conditional checks
-    extractConditionalUsage(unwrapped.left, context, location);
-    extractConditionalUsage(unwrapped.right, context, location);
-    return;
-  }
+    // Handle binary expressions with || (logical OR)
+    // OR breaks the chain - each side is independent
+    if (
+      ts.isBinaryExpression(unwrapped) &&
+      unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken
+    ) {
+      // Both sides of || are independent conditional checks (no chain tracking)
+      extractWithChainTracking(unwrapped.left, null, false);
+      extractWithChainTracking(unwrapped.right, null, false);
+      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,
-    );
+    // 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,
+      );
 
-    // Check if left is a variable and right is a literal
-    if (leftPath && isLiteralExpression(unwrapped.right)) {
-      const literalValue = getLiteralValue(unwrapped.right, context);
-      context.addConditionalUsage({
-        path: leftPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        comparedValues: literalValue !== undefined ? [literalValue] : undefined,
-        location,
-      });
+      // 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;
+      };
+
+      // Helper to add a condition
+      const addCondition = (
+        path: string,
+        conditionType: 'comparison' | 'truthiness',
+        comparedValues?: string[],
+        requiredValue?: string | boolean,
+      ) => {
+        const usage: ConditionalUsage = {
+          path,
+          conditionType,
+          comparedValues,
+          location,
+          sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+          isNegated,
+        };
+
+        // 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,
+          });
+        }
+
+        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),
+        );
+        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),
+        );
+        return;
+      }
+
+      // Both sides are variables - record both as comparisons without specific values
+      if (leftPath) {
+        addCondition(leftPath.toLeftHandSideString(), 'comparison');
+      }
+      if (rightPath) {
+        addCondition(rightPath.toLeftHandSideString(), 'comparison');
+      }
       return;
     }
 
-    // Check if right is a variable and left is a literal
-    if (rightPath && isLiteralExpression(unwrapped.left)) {
-      const literalValue = getLiteralValue(unwrapped.left, context);
-      context.addConditionalUsage({
-        path: rightPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        comparedValues: literalValue !== undefined ? [literalValue] : undefined,
-        location,
-      });
+    // 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;
     }
 
-    // Both sides are variables - record both as comparisons without specific values
-    if (leftPath) {
-      context.addConditionalUsage({
-        path: leftPath.toLeftHandSideString(),
-        conditionType: 'comparison',
+    // 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,
-      });
-    }
-    if (rightPath) {
-      context.addConditionalUsage({
-        path: rightPath.toLeftHandSideString(),
-        conditionType: 'comparison',
-        location,
-      });
-    }
-    return;
-  }
+        sourceLocation: getSourceLocation(unwrapped, context.sourceFile),
+        isNegated,
+      };
+
+      // 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,
+        });
+      }
 
-  // Handle prefix unary NOT expression: !variable
-  // Example: `if (!isVisible)` - isVisible is a truthiness check
-  if (
-    ts.isPrefixUnaryExpression(unwrapped) &&
-    unwrapped.operator === ts.SyntaxKind.ExclamationToken
-  ) {
-    extractConditionalUsage(unwrapped.operand, context, location);
-    return;
+      context.addConditionalUsage(usage);
+    }
   }
 
-  // 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()) {
-    context.addConditionalUsage({
-      path: path.toLeftHandSideString(),
-      conditionType: 'truthiness',
-      location,
-    });
-  }
+  // Start extraction with no chain info
+  extractWithChainTracking(condition, null, false);
 }
 
 /**
@@ -300,7 +611,16 @@ export function processExpression({
   ) {
     markConditionVariablesAsNullable(unwrappedNode, context);
     // Extract conditional usages for key attribute detection
-    extractConditionalUsage(unwrappedNode, context, 'logical-and');
+    // 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');
+    }
   }
 
   // If the node falls within an excluded child scope, stop processing it.
@@ -494,7 +814,8 @@ export function processExpression({
     // Check if this is an environment variable access
     const fullText = unwrappedNode.getText(context.sourceFile);
     if (
-      fullText.includes('.env.') // simple heuristic for env var access but not great
+      fullText.includes('.env.') || // process.env.X, window.env.X
+      isEnvStoreAccess(fullText) // env.X where env is likely an env config object
     ) {
       context.addEnvironmentVariable(fullText);
     }
@@ -889,9 +1210,10 @@ export function processExpression({
       return false;
     }
 
-    // Construct empty arguments list just to get the call path
-    // We'll process each argument with its parameter path as targetPath
-    const callPath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+    // 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++) {
@@ -939,10 +1261,19 @@ export function processExpression({
         );
 
         if (sourcePath) {
-          // Apply method semantics
-          semantics.addEquivalences(callPath, sourcePath, context);
-          returnType = semantics.getReturnType();
-          handledBySemantics = true;
+          // 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;
+          }
         }
       }
     }
@@ -965,10 +1296,18 @@ export function processExpression({
         );
 
         if (sourcePath) {
-          // Apply method semantics
-          semantics.addEquivalences(callPath, sourcePath, context);
-          returnType = semantics.getReturnType();
-          handledBySemantics = true;
+          // 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;
+          }
         }
       }
     }
@@ -1041,6 +1380,13 @@ export function processExpression({
           // 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({
@@ -1346,8 +1692,13 @@ export function processExpression({
       context,
       typeHint: 'boolean | unknown',
     }); //TODO: could we capture that this is evidence of a boolean type?
-    processExpression({ node: unwrappedNode.whenTrue, context });
-    processExpression({ node: unwrappedNode.whenFalse, context });
+
+    // 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(
@@ -1370,10 +1721,22 @@ export function processExpression({
     // Register type for the expression
     context.addType(expressionSourcePath, resultType);
 
-    // If targetPath is provided, establish equivalence and register type
+    // 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) {
-      context.addEquivalence(targetPath, expressionSourcePath);
-      context.addType(targetPath, resultType);
+      // 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;
@@ -1901,8 +2264,9 @@ export function processExpression({
       }
     }
 
-    // Register component as 'function' type (not 'JSX')
-    context.addType(componentPath, 'function');
+    // 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) {
@@ -2173,6 +2537,9 @@ function processJsxAttribute(
   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;
     }