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

package/packages/ai/src/lib/astScopes/patterns/switchStatementHandler.js

@@ -1,5 +1,20 @@
 import ts from 'typescript';
 import { StructuredPath } from "../paths.js";
+/**
+ * Helper to extract source location from an AST node
+ */
+function getSourceLocation(node, sourceFile) {
+    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,
+    };
+}
 /**
  * Handler for switch statements
  *
@@ -30,13 +45,21 @@ export class SwitchStatementHandler {
                     }
                 }
             }
+            const discriminantPathStr = discriminantPath.toLeftHandSideString();
             // Record the conditional usage
             context.addConditionalUsage({
-                path: discriminantPath.toLeftHandSideString(),
+                path: discriminantPathStr,
                 conditionType: 'switch',
                 comparedValues: caseValues.length > 0 ? caseValues : undefined,
                 location: 'switch',
+                sourceLocation: getSourceLocation(node, context.sourceFile),
             });
+            // Update the schema type to be a union of the case values
+            // This ensures the LLM knows the valid values for this field
+            if (caseValues.length > 0) {
+                const unionType = caseValues.map((v) => `'${v}'`).join(' | ');
+                context.updateSchemaType(discriminantPathStr, unionType);
+            }
         }
         // Process each clause in the switch statement
         for (const clause of node.caseBlock.clauses) {

package/packages/ai/src/lib/astScopes/patterns/switchStatementHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"switchStatementHandler.js","sourceRoot":"","sources":["../../../../../../../../packages/ai/src/lib/astScopes/patterns/switchStatementHandler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"switchStatementHandler.js","sourceRoot":"","sources":["../../../../../../../../packages/ai/src/lib/astScopes/patterns/switchStatementHandler.ts"],"names":[],"mappings":"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"}

package/packages/ai/src/lib/astScopes/processExpression.js

@@ -1,9 +1,108 @@
 import ts from 'typescript';
+import * as crypto from 'crypto';
 import { StructuredPath } from "./paths.js";
 import { nodeToSource } from "./nodeToSource.js";
-import { methodRegistry } from "./methodSemantics.js";
+import { methodRegistry, ArrayPushSemantics } from "./methodSemantics.js";
 import { isArithmeticOperator, isAssignmentOperator, isBitwiseCompoundOperator, isComparisonOperator, isDefinedType, isNumericCompoundOperator, leftOrRightType, unwrapExpression, } from "./sharedPatterns.js";
 import { processBindingPattern } from "./processBindings.js";
+/**
+ * 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, context) {
+    // 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, context) {
+    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 = 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, typeChecker) {
+    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;
+                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).
@@ -47,102 +146,220 @@ export function markConditionVariablesAsNullable(condition, context) {
     }
 }
 /**
- * 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.
- *
- * @param condition The condition expression to analyze
- * @param context The analysis context
- * @param location Where this condition appears (if, ternary, logical-and, switch)
+ * Helper to extract source location from an AST node
  */
-export function extractConditionalUsage(condition, context, location) {
-    const unwrapped = unwrapExpression(condition);
-    // Handle binary expressions with && (logical AND chains)
-    // Example: `a && b && <Component />` - both a and b are conditional checks
+function getSourceLocation(node, sourceFile) {
+    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) {
+    const unwrapped = unwrapExpression(expr);
     if (ts.isBinaryExpression(unwrapped) &&
         unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-        // Recursively process left side
-        extractConditionalUsage(unwrapped.left, context, location);
-        // Process right side if it's not JSX (JSX is the consequence, not the condition)
+        const leftCount = countConditionsInAndChain(unwrapped.left);
         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) {
+            return leftCount;
         }
-        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;
+        return leftCount + countConditionsInAndChain(unwrapped.right);
     }
-    // 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,
-            });
+    // Single condition (not an && chain)
+    return 1;
+}
+/**
+ * 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)
+ */
+export function extractConditionalUsage(condition, context, location) {
+    // Internal recursive function with chain tracking
+    function extractWithChainTracking(expr, chainInfo, isNegated) {
+        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 = {
+                        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,
+                    };
+                }
+            }
+            // 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;
         }
-        // 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 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;
         }
-        // Both sides are variables - record both as comparisons without specific values
-        if (leftPath) {
-            context.addConditionalUsage({
-                path: leftPath.toLeftHandSideString(),
-                conditionType: 'comparison',
-                location,
-            });
+        // 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, isNegatedComparison) => {
+                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, conditionType, comparedValues, requiredValue) => {
+                const usage = {
+                    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;
         }
-        if (rightPath) {
-            context.addConditionalUsage({
-                path: rightPath.toLeftHandSideString(),
-                conditionType: 'comparison',
+        // 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 = {
+                path: pathStr,
+                conditionType: 'truthiness',
                 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
+                // For truthiness, requiredValue is true if not negated, false if negated
+                chainInfo.compound.conditions.push({
+                    path: pathStr,
+                    conditionType: 'truthiness',
+                    isNegated,
+                    requiredValue: !isNegated,
+                });
+            }
+            context.addConditionalUsage(usage);
         }
-        return;
-    }
-    // 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;
-    }
-    // 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);
 }
 /**
  * Helper to check if an expression is a literal value
@@ -220,7 +437,15 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
         unwrappedNode.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
         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.
     if (context.isChildBoundary(node)) {
@@ -632,9 +857,10 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
             context.markUnsupported(unwrappedNode.expression, `processExpression: Couldn't get path for called expression: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
             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++) {
             const arg = unwrappedNode.arguments[i];
@@ -670,10 +896,17 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
                 const sourceExpr = unwrappedNode.expression.expression;
                 const sourcePath = StructuredPath.fromNode(sourceExpr, context.sourceFile);
                 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;
+                    }
                 }
             }
         }
@@ -688,10 +921,16 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
                 const sourceExpr = unwrappedNode.expression.expression;
                 const sourcePath = StructuredPath.fromNode(sourceExpr, context.sourceFile);
                 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;
+                    }
                 }
             }
         }
@@ -751,6 +990,12 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
                     }
                     // 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({
@@ -991,8 +1236,12 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
             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(unwrappedNode, context.sourceFile);
         // Infer type based on branches
@@ -1007,10 +1256,22 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
         }
         // 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;
     }
@@ -1210,6 +1471,18 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
         }
         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
@@ -1360,8 +1633,9 @@ export function processExpression({ node, context, targetPath, typeHint, }) {
                 }
             }
         }
-        // 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) {
             context.addEquivalence(targetPath, StructuredPath.literal('JSX'));
@@ -1558,6 +1832,9 @@ function processJsxAttribute(attr, context, componentPath, targetPath) {
     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