@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/ast/visitors/ClassVisitor.ts

@@ -26,12 +26,13 @@ import type {
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
 import type { AnalyzeFunctionBodyCallback } from './FunctionVisitor.js';
-import type { DecoratorInfo, ParameterInfo, VariableDeclarationInfo } from '../types.js';
+import type { DecoratorInfo, ParameterInfo, VariableDeclarationInfo, TypeParameterInfo } from '../types.js';
+import { extractTypeParameters } from './TypeScriptVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
 import { createParameterNodes } from '../utils/createParameterNodes.js';
 import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
 import { ClassNode, type ClassNodeRecord } from '../../../../core/nodes/ClassNode.js';
-import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { computeSemanticIdV2 } from '../../../../core/SemanticId.js';
 import { getLine, getColumn } from '../utils/location.js';
 
 /**
@@ -204,6 +205,21 @@ export class ClassVisitor extends ASTVisitor {
           }
         }
 
+        // Extract type parameters (REG-303)
+        if (collections.typeParameters && (classNode as any).typeParameters) {
+          const typeParamInfos = extractTypeParameters(
+            (classNode as any).typeParameters,
+            classRecord.id,
+            'CLASS',
+            module.file,
+            classLine,
+            classColumn
+          );
+          for (const tp of typeParamInfos) {
+            (collections.typeParameters as TypeParameterInfo[]).push(tp);
+          }
+        }
+
         // Store ClassNodeRecord + TypeScript metadata
         (classDeclarations as ClassInfo[]).push({
           ...classRecord,
@@ -267,7 +283,7 @@ export class ClassVisitor extends ASTVisitor {
 
               // Use semantic ID as primary ID (matching FunctionVisitor pattern)
               const legacyId = `FUNCTION#${className}.${propName}#${module.file}#${propLine}:${propColumn}`;
-              const functionId = computeSemanticId('FUNCTION', propName, scopeTracker.getContext());
+              const functionId = computeSemanticIdV2('FUNCTION', propName, module.file, scopeTracker.getNamedParent());
 
               // Add method to class methods list for CONTAINS edges
               currentClass.methods.push(functionId);
@@ -297,7 +313,7 @@ export class ClassVisitor extends ASTVisitor {
 
               // Create SCOPE for property function body
               const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propLine}`;
-              const propBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
+              const propBodySemanticId = computeSemanticIdV2('SCOPE', 'body', module.file, scopeTracker.getNamedParent());
               (scopes as ScopeInfo[]).push({
                 id: propBodyScopeId,
                 semanticId: propBodySemanticId,
@@ -334,7 +350,7 @@ export class ClassVisitor extends ASTVisitor {
 
             // Use semantic ID as primary ID (matching FunctionVisitor pattern)
             const legacyId = `FUNCTION#${className}.${methodName}#${module.file}#${methodLine}:${methodColumn}`;
-            const functionId = computeSemanticId('FUNCTION', methodName, scopeTracker.getContext());
+            const functionId = computeSemanticIdV2('FUNCTION', methodName, module.file, scopeTracker.getNamedParent());
 
             // Add method to class methods list for CONTAINS edges
             currentClass.methods.push(functionId);
@@ -355,6 +371,21 @@ export class ClassVisitor extends ASTVisitor {
             };
             (functions as ClassFunctionInfo[]).push(funcData);
 
+            // Extract type parameters for methods (REG-303)
+            if (collections.typeParameters && (methodNode as any).typeParameters) {
+              const typeParamInfos = extractTypeParameters(
+                (methodNode as any).typeParameters,
+                functionId,
+                'FUNCTION',
+                module.file,
+                methodLine,
+                methodColumn
+              );
+              for (const tp of typeParamInfos) {
+                (collections.typeParameters as TypeParameterInfo[]).push(tp);
+              }
+            }
+
             // Extract method decorators
             const methodNodeWithDecorators = methodNode as ClassMethod & { decorators?: Decorator[] };
             if (methodNodeWithDecorators.decorators && methodNodeWithDecorators.decorators.length > 0 && decorators) {
@@ -376,7 +407,7 @@ export class ClassVisitor extends ASTVisitor {
 
             // Create SCOPE for method body
             const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodLine}`;
-            const methodBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
+            const methodBodySemanticId = computeSemanticIdV2('SCOPE', 'body', module.file, scopeTracker.getNamedParent());
             (scopes as ScopeInfo[]).push({
               id: methodBodyScopeId,
               semanticId: methodBodySemanticId,
@@ -410,7 +441,7 @@ export class ClassVisitor extends ASTVisitor {
             const { discriminator } = scopeTracker.enterCountedScope('static_block');
 
             // Generate semantic ID for static block scope
-            const staticBlockScopeId = computeSemanticId('SCOPE', `static_block#${discriminator}`, scopeTracker.getContext());
+            const staticBlockScopeId = computeSemanticIdV2('SCOPE', `static_block#${discriminator}`, module.file, scopeTracker.getNamedParent());
 
             // Add to class staticBlocks array for CONTAINS edge
             if (!currentClass.staticBlocks) {
@@ -462,7 +493,7 @@ export class ClassVisitor extends ASTVisitor {
               // Handle as private method (function-valued property)
               const funcNode = propNode.value as ArrowFunctionExpression | FunctionExpression;
 
-              const functionId = computeSemanticId('FUNCTION', displayName, scopeTracker.getContext());
+              const functionId = computeSemanticIdV2('FUNCTION', displayName, module.file, scopeTracker.getNamedParent());
 
               // Add to class methods list for CONTAINS edges
               currentClass.methods.push(functionId);
@@ -492,7 +523,7 @@ export class ClassVisitor extends ASTVisitor {
               }
 
               // Create SCOPE for property function body
-              const propBodyScopeId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
+              const propBodyScopeId = computeSemanticIdV2('SCOPE', 'body', module.file, scopeTracker.getNamedParent());
               (scopes as ScopeInfo[]).push({
                 id: propBodyScopeId,
                 semanticId: propBodyScopeId,
@@ -512,7 +543,7 @@ export class ClassVisitor extends ASTVisitor {
               scopeTracker.exitScope();
             } else {
               // Handle as private field (non-function property)
-              const variableId = computeSemanticId('VARIABLE', displayName, scopeTracker.getContext());
+              const variableId = computeSemanticIdV2('VARIABLE', displayName, module.file, scopeTracker.getNamedParent());
 
               // Add to class properties list for HAS_PROPERTY edges
               if (!currentClass.properties) {
@@ -568,7 +599,7 @@ export class ClassVisitor extends ASTVisitor {
             // For getter/setter, include kind in name for unique ID (e.g., "get:#prop", "set:#prop")
             const kind = methodNode.kind as 'get' | 'set' | 'method';
             const semanticName = (kind === 'get' || kind === 'set') ? `${kind}:${displayName}` : displayName;
-            const functionId = computeSemanticId('FUNCTION', semanticName, scopeTracker.getContext());
+            const functionId = computeSemanticIdV2('FUNCTION', semanticName, module.file, scopeTracker.getNamedParent());
 
             // Add method to class methods list for CONTAINS edges
             currentClass.methods.push(functionId);
@@ -610,7 +641,7 @@ export class ClassVisitor extends ASTVisitor {
             }
 
             // Create SCOPE for method body
-            const methodBodyScopeId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
+            const methodBodyScopeId = computeSemanticIdV2('SCOPE', 'body', module.file, scopeTracker.getNamedParent());
             (scopes as ScopeInfo[]).push({
               id: methodBodyScopeId,
               semanticId: methodBodyScopeId,

package/src/plugins/analysis/ast/visitors/FunctionVisitor.ts

@@ -21,13 +21,13 @@ import type {
   NewExpression
 } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
-import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
-import { typeNodeToString } from './TypeScriptVisitor.js';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import { typeNodeToString, extractTypeParameters } from './TypeScriptVisitor.js';
 import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
 import { IdGenerator } from '../IdGenerator.js';
 import { createParameterNodes } from '../utils/createParameterNodes.js';
 import { getLine, getColumn } from '../utils/location.js';
-import type { ParameterInfo, PromiseExecutorContext } from '../types.js';
+import type { ParameterInfo, PromiseExecutorContext, TypeParameterInfo } from '../types.js';
 import { ConstructorCallNode } from '../../../../core/nodes/ConstructorCallNode.js';
 
 /**
@@ -102,7 +102,6 @@ export class FunctionVisitor extends ASTVisitor {
     const functions = this.collections.functions ?? [];
     const parameters = this.collections.parameters ?? [];
     const scopes = this.collections.scopes ?? [];
-    const functionCounterRef = (this.collections.functionCounterRef ?? { value: 0 }) as CounterRef;
     const scopeTracker = this.scopeTracker;
 
     const analyzeFunctionBody = this.analyzeFunctionBody;
@@ -220,7 +219,7 @@ export class FunctionVisitor extends ASTVisitor {
 
         // Generate ID using centralized IdGenerator
         const idGenerator = new IdGenerator(scopeTracker);
-        const functionId = idGenerator.generateSimple('FUNCTION', node.id.name, module.file, line);
+        const functionId = idGenerator.generateV2Simple('FUNCTION', node.id.name, module.file);
 
         // Extract type info
         const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
@@ -244,6 +243,22 @@ export class FunctionVisitor extends ASTVisitor {
           start: node.start ?? undefined
         });
 
+        // Extract type parameters (REG-303)
+        const typeParametersCollection = collections.typeParameters;
+        if (typeParametersCollection && (node as any).typeParameters) {
+          const typeParamInfos = extractTypeParameters(
+            (node as any).typeParameters,
+            functionId,
+            'FUNCTION',
+            module.file,
+            line,
+            getColumn(node)
+          );
+          for (const tp of typeParamInfos) {
+            (typeParametersCollection as TypeParameterInfo[]).push(tp);
+          }
+        }
+
         // Enter function scope BEFORE creating parameters (semantic IDs need function context)
         scopeTracker.enterScope(node.id.name, 'FUNCTION');
 
@@ -251,7 +266,7 @@ export class FunctionVisitor extends ASTVisitor {
         createParameterNodes(node.params, functionId, module.file, getLine(node), parameters as ParameterInfo[], scopeTracker);
 
         // Create SCOPE for function body
-        const functionBodyScopeId = idGenerator.generateScope('body', `${node.id.name}:body`, module.file, line);
+        const functionBodyScopeId = idGenerator.generateV2Simple('SCOPE', 'body', module.file);
         (scopes as ScopeInfo[]).push({
           id: functionBodyScopeId,
           type: 'SCOPE',
@@ -294,7 +309,7 @@ export class FunctionVisitor extends ASTVisitor {
 
         // Generate ID using centralized IdGenerator
         const idGenerator = new IdGenerator(scopeTracker);
-        const functionId = idGenerator.generate('FUNCTION', functionName, module.file, line, column, functionCounterRef);
+        const functionId = idGenerator.generateV2Simple('FUNCTION', functionName, module.file);
 
         // Extract type info
         const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
@@ -319,6 +334,22 @@ export class FunctionVisitor extends ASTVisitor {
           start: node.start ?? undefined
         });
 
+        // Extract type parameters (REG-303)
+        const arrowTypeParamsCollection = collections.typeParameters;
+        if (arrowTypeParamsCollection && (node as any).typeParameters) {
+          const typeParamInfos = extractTypeParameters(
+            (node as any).typeParameters,
+            functionId,
+            'FUNCTION',
+            module.file,
+            line,
+            column
+          );
+          for (const tp of typeParamInfos) {
+            (arrowTypeParamsCollection as TypeParameterInfo[]).push(tp);
+          }
+        }
+
         // Enter function scope BEFORE creating parameters (semantic IDs need function context)
         scopeTracker.enterScope(functionName, 'FUNCTION');
 
@@ -326,7 +357,7 @@ export class FunctionVisitor extends ASTVisitor {
         createParameterNodes(node.params, functionId, module.file, line, parameters as ParameterInfo[], scopeTracker);
 
         // Create SCOPE for arrow function body
-        const bodyScope = idGenerator.generateScope('body', `${functionName}:body`, module.file, line, column);
+        const bodyScope = idGenerator.generateV2Simple('SCOPE', 'body', module.file);
         (scopes as ScopeInfo[]).push({
           id: bodyScope,
           type: 'SCOPE',

package/src/plugins/analysis/ast/visitors/MutationDetector.ts

@@ -0,0 +1,211 @@
+/**
+ * MutationDetector — detects array mutations (push/unshift/splice) and Object.assign calls.
+ *
+ * Creates ArrayMutationInfo and ObjectMutationInfo records for FLOWS_INTO edge
+ * generation in GraphBuilder.
+ * Extracted from CallExpressionVisitor.ts (REG-424).
+ */
+
+import type { CallExpression } from '@babel/types';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import type { ArrayMutationInfo, ArrayMutationArgument, ObjectMutationInfo, ObjectMutationValue } from '../types.js';
+import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import type { VisitorModule, VisitorCollections } from './ASTVisitor.js';
+
+export class MutationDetector {
+  /**
+   * Detect array mutation calls (push, unshift, splice) and collect mutation info
+   * for later FLOWS_INTO edge creation in GraphBuilder.
+   *
+   * REG-117: Added isNested, baseObjectName, propertyName for nested mutations.
+   */
+  static detectArrayMutation(
+    callNode: CallExpression,
+    arrayName: string,
+    method: 'push' | 'unshift' | 'splice',
+    module: VisitorModule,
+    collections: VisitorCollections,
+    scopeTracker?: ScopeTracker,
+    isNested?: boolean,
+    baseObjectName?: string,
+    propertyName?: string
+  ): void {
+    // Initialize collection if not exists
+    if (!collections.arrayMutations) {
+      collections.arrayMutations = [];
+    }
+    const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
+
+    const mutationArgs: ArrayMutationArgument[] = [];
+
+    // For splice, only arguments from index 2 onwards are insertions
+    // splice(start, deleteCount, item1, item2, ...)
+    callNode.arguments.forEach((arg, index) => {
+      // Skip start and deleteCount for splice
+      if (method === 'splice' && index < 2) return;
+
+      const argInfo: ArrayMutationArgument = {
+        argIndex: method === 'splice' ? index - 2 : index,
+        isSpread: arg.type === 'SpreadElement',
+        valueType: 'EXPRESSION'  // Default
+      };
+
+      let actualArg = arg;
+      if (arg.type === 'SpreadElement') {
+        actualArg = arg.argument;
+      }
+
+      // Determine value type and store coordinates for node lookup in GraphBuilder.
+      // IMPORTANT: Check ObjectExpression/ArrayExpression BEFORE extractLiteralValue
+      // to match the order in extractArguments (which creates the actual nodes).
+      // extractLiteralValue returns objects/arrays with all-literal properties as
+      // literal values, but extractArguments creates OBJECT_LITERAL/ARRAY_LITERAL nodes.
+      if (actualArg.type === 'ObjectExpression') {
+        argInfo.valueType = 'OBJECT_LITERAL';
+        argInfo.valueLine = actualArg.loc?.start.line;
+        argInfo.valueColumn = actualArg.loc?.start.column;
+      } else if (actualArg.type === 'ArrayExpression') {
+        argInfo.valueType = 'ARRAY_LITERAL';
+        argInfo.valueLine = actualArg.loc?.start.line;
+        argInfo.valueColumn = actualArg.loc?.start.column;
+      } else if (actualArg.type === 'Identifier') {
+        argInfo.valueType = 'VARIABLE';
+        argInfo.valueName = actualArg.name;
+      } else if (actualArg.type === 'CallExpression') {
+        argInfo.valueType = 'CALL';
+        argInfo.callLine = actualArg.loc?.start.line;
+        argInfo.callColumn = actualArg.loc?.start.column;
+      } else {
+        const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+        if (literalValue !== null) {
+          argInfo.valueType = 'LITERAL';
+          argInfo.literalValue = literalValue;
+          argInfo.valueLine = actualArg.loc?.start.line;
+          argInfo.valueColumn = actualArg.loc?.start.column;
+        }
+      }
+
+      mutationArgs.push(argInfo);
+    });
+
+    // Only record if there are actual insertions
+    if (mutationArgs.length > 0) {
+      const line = callNode.loc?.start.line ?? 0;
+      const column = callNode.loc?.start.column ?? 0;
+
+      let mutationId: string | undefined;
+      // Capture scope path for scope-aware lookup (REG-309)
+      const scopePath = scopeTracker?.getContext().scopePath ?? [];
+
+      if (scopeTracker) {
+        const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
+        mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
+      }
+
+      arrayMutations.push({
+        id: mutationId,
+        arrayName,
+        mutationScopePath: scopePath,
+        mutationMethod: method,
+        file: module.file,
+        line,
+        column,
+        insertedValues: mutationArgs,
+        // REG-117: Nested mutation fields
+        isNested,
+        baseObjectName,
+        propertyName
+      });
+    }
+  }
+
+  /**
+   * Detect Object.assign(target, source1, source2, ...) calls.
+   * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder.
+   */
+  static detectObjectAssign(
+    callNode: CallExpression,
+    module: VisitorModule,
+    collections: VisitorCollections,
+    scopeTracker?: ScopeTracker
+  ): void {
+    // Need at least 2 arguments: target and at least one source
+    if (callNode.arguments.length < 2) return;
+
+    // Initialize object mutations collection if not exists
+    if (!collections.objectMutations) {
+      collections.objectMutations = [];
+    }
+    const objectMutations = collections.objectMutations as ObjectMutationInfo[];
+
+    // First argument is target
+    const targetArg = callNode.arguments[0];
+    let targetName: string;
+
+    if (targetArg.type === 'Identifier') {
+      targetName = targetArg.name;
+    } else if (targetArg.type === 'ObjectExpression') {
+      targetName = '<anonymous>';
+    } else {
+      return;
+    }
+
+    const line = callNode.loc?.start.line ?? 0;
+    const column = callNode.loc?.start.column ?? 0;
+
+    for (let i = 1; i < callNode.arguments.length; i++) {
+      let arg = callNode.arguments[i];
+      let isSpread = false;
+
+      if (arg.type === 'SpreadElement') {
+        isSpread = true;
+        arg = arg.argument;
+      }
+
+      const valueInfo: ObjectMutationValue = {
+        valueType: 'EXPRESSION',
+        argIndex: i - 1,
+        isSpread
+      };
+
+      const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+      if (literalValue !== null) {
+        valueInfo.valueType = 'LITERAL';
+        valueInfo.literalValue = literalValue;
+      } else if (arg.type === 'Identifier') {
+        valueInfo.valueType = 'VARIABLE';
+        valueInfo.valueName = arg.name;
+      } else if (arg.type === 'ObjectExpression') {
+        valueInfo.valueType = 'OBJECT_LITERAL';
+      } else if (arg.type === 'ArrayExpression') {
+        valueInfo.valueType = 'ARRAY_LITERAL';
+      } else if (arg.type === 'CallExpression') {
+        valueInfo.valueType = 'CALL';
+        valueInfo.callLine = arg.loc?.start.line;
+        valueInfo.callColumn = arg.loc?.start.column;
+      }
+
+      // Capture scope path for scope-aware lookup (REG-309)
+      const scopePath = scopeTracker?.getContext().scopePath ?? [];
+
+      let mutationId: string | undefined;
+      if (scopeTracker) {
+        const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:Object.assign:${targetName}`);
+        mutationId = computeSemanticId('OBJECT_MUTATION', `Object.assign:${targetName}`, scopeTracker.getContext(), { discriminator });
+      }
+
+      objectMutations.push({
+        id: mutationId,
+        objectName: targetName,
+        mutationScopePath: scopePath,
+        propertyName: '<assign>',
+        mutationType: 'assign',
+        file: module.file,
+        line,
+        column,
+        value: valueInfo
+      });
+    }
+  }
+}

package/src/plugins/analysis/ast/visitors/ObjectPropertyExtractor.ts

@@ -0,0 +1,217 @@
+/**
+ * ObjectPropertyExtractor — extracts object properties for HAS_PROPERTY edges.
+ *
+ * Handles nested objects, arrays, literals, variables, calls, and spread properties.
+ * Extracted from CallExpressionVisitor.ts (REG-424).
+ */
+
+import type { ObjectExpression, ObjectProperty } from '@babel/types';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { ObjectLiteralNode } from '../../../../core/nodes/ObjectLiteralNode.js';
+import { ArrayLiteralNode } from '../../../../core/nodes/ArrayLiteralNode.js';
+import type { VisitorModule, VisitorCollections, CounterRef } from './ASTVisitor.js';
+import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import type { ObjectLiteralInfo, ObjectPropertyInfo, ArrayLiteralInfo, ArrayElementInfo, LiteralInfo } from './call-expression-types.js';
+import { ArrayElementExtractor } from './ArrayElementExtractor.js';
+
+export class ObjectPropertyExtractor {
+  /**
+   * Extract object properties and create ObjectPropertyInfo records.
+   *
+   * Handles nested objects (recursive), nested arrays (delegates to ArrayElementExtractor),
+   * literal values, variable references, call expressions, and spread properties.
+   */
+  static extract(
+    objectExpr: ObjectExpression,
+    objectId: string,
+    module: VisitorModule,
+    objectProperties: ObjectPropertyInfo[],
+    objectLiterals: ObjectLiteralInfo[],
+    objectLiteralCounterRef: CounterRef,
+    literals: LiteralInfo[],
+    literalCounterRef: CounterRef,
+    collections: VisitorCollections,
+    scopeTracker?: ScopeTracker
+  ): void {
+    for (const prop of objectExpr.properties) {
+      const propLine = prop.loc?.start.line || 0;
+      const propColumn = prop.loc?.start.column || 0;
+
+      // Handle spread properties: { ...other }
+      if (prop.type === 'SpreadElement') {
+        const spreadArg = prop.argument;
+        const propertyInfo: ObjectPropertyInfo = {
+          objectId,
+          propertyName: '<spread>',
+          valueType: 'SPREAD',
+          file: module.file,
+          line: propLine,
+          column: propColumn
+        };
+
+        if (spreadArg.type === 'Identifier') {
+          propertyInfo.valueName = spreadArg.name;
+          propertyInfo.valueType = 'VARIABLE';
+          // REG-329: Capture scope path for spread variable resolution
+          propertyInfo.valueScopePath = scopeTracker?.getContext().scopePath ?? [];
+        }
+
+        objectProperties.push(propertyInfo);
+        continue;
+      }
+
+      // Handle regular properties
+      if (prop.type === 'ObjectProperty') {
+        const objProp = prop as ObjectProperty;
+        let propertyName: string;
+
+        // Get property name
+        if (objProp.key.type === 'Identifier') {
+          propertyName = objProp.key.name;
+        } else if (objProp.key.type === 'StringLiteral') {
+          propertyName = objProp.key.value;
+        } else if (objProp.key.type === 'NumericLiteral') {
+          propertyName = String(objProp.key.value);
+        } else {
+          propertyName = '<computed>';
+        }
+
+        const propertyInfo: ObjectPropertyInfo = {
+          objectId,
+          propertyName,
+          file: module.file,
+          line: propLine,
+          column: propColumn,
+          valueType: 'EXPRESSION'
+        };
+
+        const value = objProp.value;
+
+        // Nested object literal - check BEFORE extractLiteralValue
+        if (value.type === 'ObjectExpression') {
+          // Use factory - do NOT pass argIndex for nested literals (uses 'obj' suffix)
+          const nestedObjectNode = ObjectLiteralNode.create(
+            module.file,
+            value.loc?.start.line || 0,
+            value.loc?.start.column || 0,
+            {
+              counter: objectLiteralCounterRef.value++
+            }
+          );
+          objectLiterals.push(nestedObjectNode as unknown as ObjectLiteralInfo);
+          const nestedObjectId = nestedObjectNode.id;
+
+          // Recursively extract nested properties
+          ObjectPropertyExtractor.extract(
+            value,
+            nestedObjectId,
+            module,
+            objectProperties,
+            objectLiterals,
+            objectLiteralCounterRef,
+            literals,
+            literalCounterRef,
+            collections,
+            scopeTracker
+          );
+
+          propertyInfo.valueType = 'OBJECT_LITERAL';
+          propertyInfo.nestedObjectId = nestedObjectId;
+          propertyInfo.valueNodeId = nestedObjectId;
+        }
+        // Nested array literal - check BEFORE extractLiteralValue
+        else if (value.type === 'ArrayExpression') {
+          const arrayLiteralCounterRef = (collections.arrayLiteralCounterRef ?? { value: 0 }) as CounterRef;
+          const arrayLiterals = collections.arrayLiterals ?? [];
+          const arrayElements = collections.arrayElements ?? [];
+
+          // Use factory - do NOT pass argIndex for nested literals (uses 'arr' suffix)
+          const nestedArrayNode = ArrayLiteralNode.create(
+            module.file,
+            value.loc?.start.line || 0,
+            value.loc?.start.column || 0,
+            {
+              counter: arrayLiteralCounterRef.value++
+            }
+          );
+          (arrayLiterals as ArrayLiteralInfo[]).push(nestedArrayNode as unknown as ArrayLiteralInfo);
+          const nestedArrayId = nestedArrayNode.id;
+
+          // Recursively extract array elements
+          ArrayElementExtractor.extract(
+            value,
+            nestedArrayId,
+            module,
+            arrayElements as ArrayElementInfo[],
+            arrayLiterals as ArrayLiteralInfo[],
+            arrayLiteralCounterRef,
+            objectLiterals,
+            objectLiteralCounterRef,
+            objectProperties,
+            literals,
+            literalCounterRef,
+            collections,
+            scopeTracker
+          );
+
+          propertyInfo.valueType = 'ARRAY_LITERAL';
+          propertyInfo.nestedArrayId = nestedArrayId;
+          propertyInfo.valueNodeId = nestedArrayId;
+        }
+        // Literal value (primitives only - objects/arrays handled above)
+        else {
+          const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+          // Handle both non-null literals AND explicit null literals (NullLiteral)
+          if (literalValue !== null || value.type === 'NullLiteral') {
+            const literalId = `LITERAL#${propertyName}#${module.file}#${propLine}:${propColumn}:${literalCounterRef.value++}`;
+            literals.push({
+              id: literalId,
+              type: 'LITERAL',
+              value: literalValue,
+              valueType: typeof literalValue,
+              file: module.file,
+              line: propLine,
+              column: propColumn,
+              parentCallId: objectId,
+              argIndex: 0
+            });
+            propertyInfo.valueType = 'LITERAL';
+            propertyInfo.valueNodeId = literalId;
+            propertyInfo.literalValue = literalValue;
+          }
+          // Variable reference
+          else if (value.type === 'Identifier') {
+            propertyInfo.valueType = 'VARIABLE';
+            propertyInfo.valueName = value.name;
+            // REG-329: Capture scope path for scope-aware variable resolution
+            propertyInfo.valueScopePath = scopeTracker?.getContext().scopePath ?? [];
+          }
+          // Call expression
+          else if (value.type === 'CallExpression') {
+            propertyInfo.valueType = 'CALL';
+            propertyInfo.callLine = value.loc?.start.line;
+            propertyInfo.callColumn = value.loc?.start.column;
+          }
+          // Other expressions
+          else {
+            propertyInfo.valueType = 'EXPRESSION';
+          }
+        }
+
+        objectProperties.push(propertyInfo);
+      }
+      // Handle object methods: { foo() {} }
+      else if (prop.type === 'ObjectMethod') {
+        const propertyName = prop.key.type === 'Identifier' ? prop.key.name : '<computed>';
+        objectProperties.push({
+          objectId,
+          propertyName,
+          valueType: 'EXPRESSION',
+          file: module.file,
+          line: propLine,
+          column: propColumn
+        });
+      }
+    }
+  }
+}