@mnemonica/tactica 0.1.0 → 0.1.1

package/lib/analyzer.js

@@ -43,14 +43,33 @@ class MnemonicaAnalyzer {
     constructor(program) {
         this.errors = [];
         this.graph = new graph_1.TypeGraphImpl();
+        this.definitions = new Map();
+        this.usages = new Map();
+        this.edsUsages = new Map();
+        this.flowUsages = new Map();
+        this.typeAliases = new Map();
+        // Track variable assignments: variableName -> fullPath of the type it holds
+        this.variableToTypeMap = new Map();
         // Store program for future use (currently unused but kept for extensibility)
         void program;
     }
+    /**
+     * Reset usage-related state for a fresh pass.
+     * Call before the usage-collection pass to avoid duplicates from definition pass.
+     */
+    resetUsages() {
+        this.usages.clear();
+        this.edsUsages.clear();
+        this.flowUsages.clear();
+        this.variableToTypeMap.clear();
+    }
     /**
      * Analyze a source file for Mnemonica type definitions
      */
     analyzeFile(sourceFile) {
         this.errors = [];
+        // Ensure parent nodes are set for AST traversal
+        this.setParentNodesInSourceFile(sourceFile);
         this.visitNode(sourceFile, sourceFile);
         return {
             types: this.graph.getAllTypes(),
@@ -70,6 +89,71 @@ class MnemonicaAnalyzer {
     getGraph() {
         return this.graph;
     }
+    /**
+     * Get collected definitions
+     */
+    getDefinitions() {
+        return this.definitions;
+    }
+    /**
+     * Get collected usages
+     */
+    getUsages() {
+        return this.usages;
+    }
+    /**
+     * Get collected EDS usages
+     */
+    getEDSUsages() {
+        return this.edsUsages;
+    }
+    /**
+     * Get collected flow usages
+     */
+    getFlowUsages() {
+        return this.flowUsages;
+    }
+    /**
+     * Add a topologica type to the analyzer for usage tracking.
+     * This allows the analyzer to recognize topologica types when collecting usages.
+     */
+    addTopologicaType(fullPath, node) {
+        // Skip if already exists
+        if (this.graph.allTypes.has(fullPath)) {
+            return;
+        }
+        // Add to graph so it can be found during usage collection
+        if (node.parent) {
+            // Add as child of parent
+            this.graph.addChild(node.parent, node);
+        }
+        else {
+            // Add as root
+            this.graph.addRoot(node);
+        }
+        // Also add to definitions so it's recognized as a known type
+        const definition = {
+            name: node.name,
+            location: `${node.sourceFile}:${node.line}:${node.column}`,
+            kind: 'define',
+            parent: node.parent ? node.parent.fullPath : null,
+            strictChain: true,
+            blockErrors: false
+        };
+        this.definitions.set(fullPath, definition);
+    }
+    /**
+     * Set parent nodes in a source file to enable AST traversal up
+     */
+    setParentNodesInSourceFile(sourceFile) {
+        const setParent = (node, parent) => {
+            // TypeScript doesn't expose parent as writable, but we need it
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node.parent = parent;
+            ts.forEachChild(node, child => setParent(child, node));
+        };
+        setParent(sourceFile);
+    }
     /**
      * Visit a node in the AST
      */
@@ -82,6 +166,16 @@ class MnemonicaAnalyzer {
         if (this.isDecorateDecorator(node)) {
             this.processDecorateDecorator(node, sourceFile, currentClass);
         }
+        // Check for type usages (new Type(), type annotations, etc.)
+        this.collectUsage(node, sourceFile);
+        // Check for EDS patterns (wrap, link, getLastContext, etc.)
+        this.collectEDS(node, sourceFile);
+        // Check for native flow patterns (property access, method calls, etc.)
+        this.collectFlow(node, sourceFile);
+        // Collect type aliases for resolving type references
+        if (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name)) {
+            this.typeAliases.set(node.name.text, node.type);
+        }
         // Track class declarations for decorator parent lookup
         if (ts.isClassDeclaration(node)) {
             // Visit children with this class as the current context
@@ -111,8 +205,37 @@ class MnemonicaAnalyzer {
         return false;
     }
     /**
-     * Check if a node is a @decorate() decorator
-     */
+        * Extract config options from define() call
+        */
+    extractConfig(call) {
+        const config = {};
+        // Config is the third argument: define('Name', handler, config)
+        const configArg = call.arguments[2];
+        if (!configArg || !ts.isObjectLiteralExpression(configArg)) {
+            return config;
+        }
+        for (const prop of configArg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const propName = prop.name.text;
+                if (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                    config.strictChain = true;
+                }
+                else if (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                    config.strictChain = false;
+                }
+                else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                    config.blockErrors = true;
+                }
+                else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                    config.blockErrors = false;
+                }
+            }
+        }
+        return config;
+    }
+    /**
+        * Check if a node is a @decorate() decorator
+        */
     isDecorateDecorator(node) {
         if (!ts.isDecorator(node)) {
             return false;
@@ -135,9 +258,25 @@ class MnemonicaAnalyzer {
      * Process a define() call
      */
     processDefineCall(call, sourceFile) {
-        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, call.getStart(sourceFile));
+        // Check if this exact call has already been processed (prevents duplicates from chained calls)
+        if (call.__tactica_processed) {
+            return;
+        }
+        call.__tactica_processed = true;
         // Get the type name from arguments
         const typeName = this.extractTypeName(call);
+        // For chained calls like define('A').define('B'), we want the position of the .define('B') part
+        // not the start of the entire expression
+        let positionNode = call;
+        // If this is a chained call, get the position of the property access expression
+        // which is the .define part
+        if (ts.isPropertyAccessExpression(call.expression)) {
+            // The expression is the property access: (define('RootAsync', ...)).define
+            // We want the position of just the .define part
+            positionNode = call.expression.name; // This is the 'define' identifier
+        }
+        const startPos = positionNode.getStart(sourceFile);
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);
         if (!typeName) {
             this.errors.push({
                 message: 'Could not extract type name from define() call',
@@ -148,11 +287,27 @@ class MnemonicaAnalyzer {
             return;
         }
         // Determine parent type
-        const parentNode = this.findParentType(call);
+        const parentNode = this.findParentType(call, sourceFile);
+        // Build full path
+        const fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;
+        // Extract config options
+        const config = this.extractConfig(call);
+        // Create definition info
+        const definition = {
+            name: typeName,
+            location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+            kind: 'define',
+            parent: parentNode ? parentNode.fullPath : null,
+            strictChain: config.strictChain ?? true,
+            blockErrors: config.blockErrors ?? false,
+        };
+        this.definitions.set(fullPath, definition);
         // Create type node
         const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1);
         // Extract properties from constructor function
         node.properties = this.extractProperties(call);
+        // Extract constructor parameters for TypeRegistry signature
+        node.constructorParams = this.extractConstructorParams(call);
         // Add to graph
         if (parentNode) {
             this.graph.addChild(parentNode, node);
@@ -160,9 +315,76 @@ class MnemonicaAnalyzer {
         else {
             this.graph.addRoot(node);
         }
+        // Track variable assignment: const User = define('UserEntity', ...) -> map "User" to "UserEntity"
+        // For chained calls like const X = define('A').define('B'), we want to map X -> A (the root)
+        this.trackVariableAssignment(call, parentNode, fullPath);
+    }
+    /**
+        * Track variable assignments that capture define() results
+        * e.g., const User = define('UserEntity', ...) maps "User" -> "UserEntity"
+        * For chained calls like const X = define('A').define('B'), we map X -> A (the root type)
+        */
+    trackVariableAssignment(call, parentNode, fullPath) {
+        // Check if this call is the right-hand side of a variable declaration
+        // Walk up the tree to find VariableDeclaration
+        let current = call.parent;
+        while (current) {
+            if (ts.isVariableDeclaration(current)) {
+                // Found: const X = define(...)
+                if (ts.isIdentifier(current.name)) {
+                    const varName = current.name.text;
+                    // If this is a chained call (has parent), don't overwrite existing mapping
+                    // The first define in the chain sets the mapping to the root type
+                    if (parentNode && this.variableToTypeMap.has(varName)) {
+                        return;
+                    }
+                    this.variableToTypeMap.set(varName, fullPath);
+                }
+                return;
+            }
+            current = current.parent;
+        }
+    }
+    /**
+        * Track variable assignments from lookupTyped() calls
+        * e.g., const SentienceConstructor = lookupTyped('Sentience') maps "SentienceConstructor" -> "Sentience"
+        */
+    trackLookupTypedAssignment(call, typePath) {
+        // Walk up the tree to find VariableDeclaration
+        let current = call.parent;
+        while (current) {
+            if (ts.isVariableDeclaration(current)) {
+                // Found: const X = lookupTyped(...)
+                if (ts.isIdentifier(current.name)) {
+                    const varName = current.name.text;
+                    this.variableToTypeMap.set(varName, typePath);
+                }
+                return;
+            }
+            current = current.parent;
+        }
     }
     /**
-     * Process a @decorate() decorator
+        * Track variable assignments from new Type() calls
+        * e.g., const user = new UserType() maps "user" -> "UserType"
+        */
+    trackNewAssignment(newExpr, typePath) {
+        // Walk up the tree to find VariableDeclaration
+        let current = newExpr.parent;
+        while (current) {
+            if (ts.isVariableDeclaration(current)) {
+                // Found: const X = new Type(...)
+                if (ts.isIdentifier(current.name)) {
+                    const varName = current.name.text;
+                    this.variableToTypeMap.set(varName, typePath);
+                }
+                return;
+            }
+            current = current.parent;
+        }
+    }
+    /**
+        * Process a @decorate() decorator
      */
     processDecorateDecorator(decorator, sourceFile, classDeclParam) {
         const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, decorator.getStart(sourceFile));
@@ -189,6 +411,7 @@ class MnemonicaAnalyzer {
         }
         // Try to find parent type from decorator arguments
         let parentNode;
+        let parentFullPath = null;
         if (ts.isCallExpression(decorator.expression)) {
             const args = decorator.expression.arguments;
             if (args.length > 0 && ts.isIdentifier(args[0])) {
@@ -204,8 +427,23 @@ class MnemonicaAnalyzer {
                         }
                     }
                 }
+                if (parentNode) {
+                    parentFullPath = parentNode.fullPath;
+                }
             }
         }
+        // Build full path
+        const fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;
+        // Create definition info for decorate
+        const definition = {
+            name: typeName,
+            location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+            kind: 'decorate',
+            parent: parentFullPath,
+            strictChain: true, // decorate uses strict defaults
+            blockErrors: false,
+        };
+        this.definitions.set(fullPath, definition);
         // Create type node
         const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1);
         // Extract properties from class members
@@ -248,7 +486,7 @@ class MnemonicaAnalyzer {
     /**
      * Find parent type node for nested define calls
      */
-    findParentType(call) {
+    findParentType(call, _sourceFile) {
         const expression = call.expression;
         // Check for method call: SomeType.define('SubType', ...)
         if (!ts.isPropertyAccessExpression(expression)) {
@@ -259,6 +497,14 @@ class MnemonicaAnalyzer {
         if (ts.isIdentifier(obj)) {
             // Direct reference to parent type - search by simple name
             const name = obj.text;
+            // First check variable mapping: const User = define('UserEntity', ...)
+            // In this case, name is "User" but we need to find "UserEntity"
+            const mappedFullPath = this.variableToTypeMap.get(name);
+            if (mappedFullPath) {
+                const mappedNode = this.graph.findType(mappedFullPath);
+                if (mappedNode)
+                    return mappedNode;
+            }
             // First try exact match
             const exact = this.graph.findType(name);
             if (exact)
@@ -278,11 +524,42 @@ class MnemonicaAnalyzer {
                 return this.graph.findType(chain.join('.'));
             }
         }
+        // Handle chained define: define('UserEntity', ...).define('UserResponse', ...)
+        if (ts.isCallExpression(obj)) {
+            // This is a chained call - the object is itself a define() call
+            // Check if the parent call is a define() that hasn't been processed yet
+            if (this.isDefineCall(obj)) {
+                // Process the parent define() call first to create its type node
+                // Use the sourceFile from the current context
+                this.processDefineCall(obj, _sourceFile);
+                // Now find and return the newly created parent type
+                const parentTypeName = this.extractTypeName(obj);
+                if (parentTypeName) {
+                    return this.findParentTypeByName(parentTypeName);
+                }
+            }
+        }
         return undefined;
     }
     /**
-     * Get property chain from nested access
-     */
+        * Find a parent type by its name, searching in the graph
+        */
+    findParentTypeByName(name) {
+        // First try exact match
+        const exact = this.graph.findType(name);
+        if (exact)
+            return exact;
+        // Then search through all types for one with matching name
+        for (const type of this.graph.getAllTypes()) {
+            if (type.name === name) {
+                return type;
+            }
+        }
+        return undefined;
+    }
+    /**
+        * Get property chain from nested access
+        */
     getPropertyChain(expr) {
         const chain = [];
         let current = expr;
@@ -306,22 +583,41 @@ class MnemonicaAnalyzer {
         if (!handlerArg) {
             return properties;
         }
+        // Build type map from data parameter (for this.x = data.x patterns)
+        const dataTypeMap = this.buildDataTypeMap(handlerArg);
         // Handle function expression
         if (ts.isFunctionExpression(handlerArg) || ts.isArrowFunction(handlerArg)) {
             const body = handlerArg.body;
+            // First, extract properties from `this` parameter type annotation
+            // This handles patterns like: function(this: SomeType, data: SomeType) { }
+            const thisParamProperties = this.extractThisParamProperties(handlerArg);
+            for (const [name, propInfo] of thisParamProperties) {
+                properties.set(name, propInfo);
+            }
             // Function body with statements
             if (ts.isBlock(body)) {
                 for (const stmt of body.statements) {
                     if (ts.isExpressionStatement(stmt)) {
-                        this.extractPropertyFromStatement(stmt.expression, properties);
+                        this.extractPropertyFromStatement(stmt.expression, properties, dataTypeMap);
                     }
                 }
             }
         }
         // Handle class expression
         if (ts.isClassExpression(handlerArg)) {
+            // First pass: collect all property types for method inference
+            const classPropertyTypes = this.extractClassPropertyTypes(handlerArg);
             for (const member of handlerArg.members) {
+                // Handle property declarations
                 if (ts.isPropertyDeclaration(member) && member.name) {
+                    // Skip private and protected properties
+                    if (member.modifiers) {
+                        const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                            m.kind === ts.SyntaxKind.ProtectedKeyword);
+                        if (hasPrivateOrProtected) {
+                            continue;
+                        }
+                    }
                     const name = ts.isIdentifier(member.name) ? member.name.text : '';
                     if (name) {
                         properties.set(name, {
@@ -331,14 +627,120 @@ class MnemonicaAnalyzer {
                         });
                     }
                 }
+                // Handle method declarations
+                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                    // Skip private and protected methods
+                    if (member.modifiers) {
+                        const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                            m.kind === ts.SyntaxKind.ProtectedKeyword);
+                        if (hasPrivateOrProtected) {
+                            continue;
+                        }
+                    }
+                    const name = member.name.text;
+                    const type = this.inferMethodType(member, classPropertyTypes);
+                    properties.set(name, {
+                        name,
+                        type,
+                        optional: false,
+                    });
+                }
+                // Handle getter declarations
+                if (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {
+                    // Skip private and protected getters
+                    if (member.modifiers) {
+                        const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                            m.kind === ts.SyntaxKind.ProtectedKeyword);
+                        if (hasPrivateOrProtected) {
+                            continue;
+                        }
+                    }
+                    const name = member.name.text;
+                    // First try explicit type annotation, then infer from getter body
+                    let type = this.inferType(member.type);
+                    if (type === 'unknown' && member.body) {
+                        type = this.inferReturnTypeFromBody(member.body, classPropertyTypes);
+                    }
+                    properties.set(name, {
+                        name,
+                        type,
+                        optional: false,
+                        readonly: true,
+                    });
+                }
             }
         }
         return properties;
     }
+    /**
+     * Build a type map from all parameters with inline object type annotations
+     * Returns a map of "paramName.propertyName" -> type
+     */
+    buildDataTypeMap(handlerArg) {
+        const typeMap = new Map();
+        if (!ts.isFunctionExpression(handlerArg) && !ts.isArrowFunction(handlerArg)) {
+            return typeMap;
+        }
+        // Iterate over ALL parameters
+        for (const param of handlerArg.parameters) {
+            if (!param.name || !param.type)
+                continue;
+            // Get parameter name
+            let paramName = '';
+            if (ts.isIdentifier(param.name)) {
+                paramName = param.name.text;
+            }
+            else {
+                continue; // Skip destructured parameters for now
+            }
+            // Check if it's an inline object type literal
+            if (ts.isTypeLiteralNode(param.type)) {
+                for (const member of param.type.members) {
+                    if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                        const propName = member.name.text;
+                        const type = this.inferType(member.type);
+                        typeMap.set(`${paramName}.${propName}`, type);
+                    }
+                }
+            }
+            else {
+                // Store simple parameter types like `decorateValue: string`
+                const type = this.inferType(param.type);
+                if (type !== 'unknown') {
+                    typeMap.set(paramName, type);
+                }
+            }
+        }
+        return typeMap;
+    }
+    /**
+     * Extract property access chain (e.g., "dataRenamed.id" from dataRenamed.id)
+     * Handles fallbacks like: data.permissions || []
+     */
+    getPropertyAccessChain(expr) {
+        // Handle identifier: data
+        if (ts.isIdentifier(expr)) {
+            return expr.text;
+        }
+        // Handle property access: data.permissions
+        if (ts.isPropertyAccessExpression(expr)) {
+            const base = this.getPropertyAccessChain(expr.expression);
+            if (base) {
+                return `${base}.${expr.name.text}`;
+            }
+        }
+        // Handle fallback pattern: data.permissions || []
+        if (ts.isBinaryExpression(expr) &&
+            expr.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            // Return the left side of || operator
+            return this.getPropertyAccessChain(expr.left);
+        }
+        return undefined;
+    }
     /**
      * Extract property assignment from statement
      */
-    extractPropertyFromStatement(expr, properties) {
+    extractPropertyFromStatement(expr, properties, dataTypeMap = new Map()) {
         // Handle: this.property = value
         if (ts.isBinaryExpression(expr) &&
             expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
@@ -348,11 +750,28 @@ class MnemonicaAnalyzer {
                 if (left.expression.kind === ts.SyntaxKind.ThisKeyword) {
                     const name = left.name?.text;
                     if (name) {
-                        properties.set(name, {
-                            name,
-                            type: this.inferTypeFromInitializer(expr.right),
-                            optional: false,
-                        });
+                        // Try to get type from dataTypeMap using full access chain (e.g., "dataRenamed.id")
+                        const accessChain = this.getPropertyAccessChain(expr.right);
+                        let type = accessChain ? dataTypeMap.get(accessChain) : undefined;
+                        // If not found and RHS is a simple identifier, try looking it up directly
+                        if (!type && ts.isIdentifier(expr.right)) {
+                            type = dataTypeMap.get(expr.right.text);
+                        }
+                        if (!type) {
+                            type = this.inferTypeFromInitializer(expr.right, dataTypeMap);
+                        }
+                        // Don't overwrite a known type from `this` annotation with unknown
+                        const existing = properties.get(name);
+                        if (existing && existing.type !== 'unknown' && type === 'unknown') {
+                            // Keep the better type from explicit annotation
+                        }
+                        else {
+                            properties.set(name, {
+                                name,
+                                type,
+                                optional: false,
+                            });
+                        }
                     }
                 }
             }
@@ -385,12 +804,21 @@ class MnemonicaAnalyzer {
         }
     }
     /**
-     * Extract properties from class declaration
+     * Extract properties from class declaration (including methods and getters)
      */
     extractClassProperties(classDecl) {
         const properties = new Map();
         for (const member of classDecl.members) {
+            // Handle property declarations
             if (ts.isPropertyDeclaration(member) && member.name) {
+                // Skip private and protected properties
+                if (member.modifiers) {
+                    const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                        m.kind === ts.SyntaxKind.ProtectedKeyword);
+                    if (hasPrivateOrProtected) {
+                        continue;
+                    }
+                }
                 const name = ts.isIdentifier(member.name) ? member.name.text : '';
                 if (name) {
                     // If no explicit type but has initializer, infer from initializer
@@ -405,9 +833,137 @@ class MnemonicaAnalyzer {
                     });
                 }
             }
+            // Handle method declarations
+            if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                // Skip private and protected methods
+                if (member.modifiers) {
+                    const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                        m.kind === ts.SyntaxKind.ProtectedKeyword);
+                    if (hasPrivateOrProtected) {
+                        continue;
+                    }
+                }
+                const name = member.name.text;
+                const type = this.inferMethodType(member);
+                properties.set(name, {
+                    name,
+                    type,
+                    optional: false,
+                });
+            }
+            // Handle getter declarations
+            if (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {
+                // Skip private and protected getters
+                if (member.modifiers) {
+                    const hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||
+                        m.kind === ts.SyntaxKind.ProtectedKeyword);
+                    if (hasPrivateOrProtected) {
+                        continue;
+                    }
+                }
+                const name = member.name.text;
+                // First try explicit type annotation, then infer from getter body
+                let type = this.inferType(member.type);
+                if (type === 'unknown' && member.body) {
+                    type = this.inferReturnTypeFromBody(member.body);
+                }
+                properties.set(name, {
+                    name,
+                    type,
+                    optional: false,
+                    readonly: true,
+                });
+            }
+        }
+        return properties;
+    }
+    /**
+     * Extract class property types for method return type inference
+     * Maps property names to their TypeScript type strings
+     * Note: Includes private/protected properties for method inference
+     */
+    extractClassPropertyTypes(classDecl) {
+        const propertyTypes = new Map();
+        for (const member of classDecl.members) {
+            if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                // Include ALL properties (even private) for method return type inference
+                // The visibility check is done when adding to output properties
+                const name = member.name.text;
+                if (member.type) {
+                    propertyTypes.set(name, this.inferType(member.type));
+                }
+            }
+        }
+        return propertyTypes;
+    }
+    /**
+     * Infer method type from method declaration
+     */
+    inferMethodType(method, classPropertyTypes) {
+        const params = method.parameters.map(param => {
+            const paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';
+            const paramType = this.inferType(param.type);
+            return `${paramName}: ${paramType}`;
+        }).join(', ');
+        const returnType = this.inferReturnType(method, classPropertyTypes);
+        if (params) {
+            return `(${params}) => ${returnType}`;
+        }
+        return `() => ${returnType}`;
+    }
+    /**
+        * Extract properties from `this` parameter type annotation
+        * Handles patterns like: function(this: SomeType, data: SomeType) { }
+        */
+    extractThisParamProperties(handlerArg) {
+        const properties = new Map();
+        // Find the `this` parameter (if any)
+        for (const param of handlerArg.parameters) {
+            if (param.name && ts.isIdentifier(param.name) && param.name.text === 'this' && param.type) {
+                // Check if it's a type reference (e.g., `this: usage`)
+                if (ts.isTypeReferenceNode(param.type)) {
+                    const typeName = ts.isIdentifier(param.type.typeName)
+                        ? param.type.typeName.text
+                        : '';
+                    // Look up the type alias in our collected type aliases
+                    const aliasedType = this.typeAliases.get(typeName);
+                    if (aliasedType && ts.isTypeLiteralNode(aliasedType)) {
+                        // Extract properties from the type literal
+                        for (const member of aliasedType.members) {
+                            if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                                const propName = member.name.text;
+                                const type = this.inferType(member.type);
+                                properties.set(propName, {
+                                    name: propName,
+                                    type,
+                                    optional: !!member.questionToken,
+                                });
+                            }
+                        }
+                    }
+                }
+                // Check if it's directly an inline type literal (e.g., `this: { id: string }`)
+                else if (ts.isTypeLiteralNode(param.type)) {
+                    for (const member of param.type.members) {
+                        if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                            const propName = member.name.text;
+                            const type = this.inferType(member.type);
+                            properties.set(propName, {
+                                name: propName,
+                                type,
+                                optional: !!member.questionToken,
+                            });
+                        }
+                    }
+                }
+                break; // Found the `this` parameter, no need to continue
+            }
         }
         return properties;
     }
+    /**
+        * Infer TypeScript type from type node
+        */
     /**
      * Infer TypeScript type from type node
      */
@@ -434,17 +990,207 @@ class MnemonicaAnalyzer {
                 return 'void';
             case ts.SyntaxKind.ArrayType:
                 return 'Array<' + this.inferType(typeNode.elementType) + '>';
-            case ts.SyntaxKind.TypeLiteral:
-                return 'object';
+            case ts.SyntaxKind.TypeLiteral: {
+                // Inline-expand type literals instead of collapsing to 'object'
+                const typeLit = typeNode;
+                const props = [];
+                for (const member of typeLit.members) {
+                    if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                        const propName = member.name.text;
+                        const optional = member.questionToken ? '?' : '';
+                        const type = this.inferType(member.type);
+                        props.push(`${propName}${optional}: ${type}`);
+                    }
+                }
+                return `{ ${props.join('; ')} }`;
+            }
+            case ts.SyntaxKind.LiteralType: {
+                // Handle string literal types like 'user', 'admin', etc.
+                const literal = typeNode.literal;
+                if (ts.isStringLiteral(literal)) {
+                    // Return the actual literal value (e.g., 'user' instead of string)
+                    return `'${literal.text}'`;
+                }
+                if (ts.isNumericLiteral(literal)) {
+                    return literal.text;
+                }
+                if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+                    return 'true';
+                }
+                if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+                    return 'false';
+                }
+                if (literal.kind === ts.SyntaxKind.NullKeyword) {
+                    return 'null';
+                }
+                return 'unknown';
+            }
+            case ts.SyntaxKind.TypeReference: {
+                // Handle type references like Map<string, number>, PropertyInfo, etc.
+                const typeRef = typeNode;
+                const typeName = ts.isIdentifier(typeRef.typeName)
+                    ? typeRef.typeName.text
+                    : ts.isQualifiedName(typeRef.typeName)
+                        ? this.getQualifiedNameText(typeRef.typeName)
+                        : 'unknown';
+                // Check if this is a type alias we can resolve
+                const aliasedType = this.typeAliases.get(typeName);
+                if (aliasedType) {
+                    // Resolve the type alias
+                    return this.inferType(aliasedType);
+                }
+                // Handle InstanceType<typeof X> pattern -> convert to Parent_X
+                if (typeName === 'InstanceType' && typeRef.typeArguments && typeRef.typeArguments.length === 1) {
+                    const arg = typeRef.typeArguments[0];
+                    if (arg.kind === ts.SyntaxKind.TypeQuery) {
+                        const typeQuery = arg;
+                        if (ts.isIdentifier(typeQuery.exprName)) {
+                            const typeName = typeQuery.exprName.text;
+                            // Look up the type in the graph to get full path
+                            const typeNode = this.graph.findTypeByName(typeName);
+                            if (typeNode) {
+                                // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
+                                return typeNode.fullPath.replace(/\./g, '_');
+                            }
+                            // Fallback: just use the type name if not found in graph
+                            return typeName;
+                        }
+                    }
+                }
+                if (!typeRef.typeArguments || typeRef.typeArguments.length === 0) {
+                    // Check if this type exists in our graph - convert to full path format
+                    const typeNode = this.graph.findTypeByName(typeName);
+                    if (typeNode) {
+                        // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
+                        return typeNode.fullPath.replace(/\./g, "_");
+                    }
+                    return typeName;
+                }
+                // Build generic type arguments
+                const args = typeRef.typeArguments.map(arg => this.inferType(arg));
+                return `${typeName}<${args.join(', ')}>`;
+            }
+            case ts.SyntaxKind.UnionType: {
+                // Handle union types like 'a' | 'b' | 'c'
+                const unionType = typeNode;
+                const types = unionType.types.map(t => this.inferType(t));
+                return types.join(' | ');
+            }
+            case ts.SyntaxKind.IntersectionType: {
+                // Handle intersection types like TypeA & TypeB
+                const intersectionType = typeNode;
+                const types = intersectionType.types.map(t => this.inferType(t));
+                return types.join(' & ');
+            }
+            case ts.SyntaxKind.TupleType: {
+                // Handle tuple types like [string, number]
+                const tupleType = typeNode;
+                const elements = tupleType.elements.map(elem => this.inferType(elem));
+                return `[${elements.join(', ')}]`;
+            }
+            case ts.SyntaxKind.OptionalType: {
+                // Handle optional element in tuple: string?
+                const optionalType = typeNode;
+                return this.inferType(optionalType.type) + '?';
+            }
+            case ts.SyntaxKind.RestType: {
+                // Handle rest element: ...T
+                const restType = typeNode;
+                return '...' + this.inferType(restType.type);
+            }
+            case ts.SyntaxKind.ParenthesizedType: {
+                // Handle parenthesized types: (A | B)
+                return this.inferType(typeNode.type);
+            }
+            case ts.SyntaxKind.IndexedAccessType: {
+                // Handle indexed access: T[K]
+                const indexed = typeNode;
+                let objectType = this.inferType(indexed.objectType);
+                const indexType = this.inferType(indexed.indexType);
+                // If objectType is 'object', try to resolve the underlying type alias
+                if (objectType === 'object' && ts.isTypeReferenceNode(indexed.objectType)) {
+                    const refName = ts.isIdentifier(indexed.objectType.typeName) ? indexed.objectType.typeName.text : '';
+                    const aliased = this.typeAliases.get(refName);
+                    if (aliased) {
+                        objectType = this.inferType(aliased);
+                    }
+                }
+                return `${objectType}[${indexType}]`;
+            }
+            case ts.SyntaxKind.TypeOperator: {
+                // Handle keyof, readonly, unique operators
+                const typeOp = typeNode;
+                const operator = ts.SyntaxKind[typeOp.operator];
+                return `${operator} ${this.inferType(typeOp.type)}`;
+            }
+            case ts.SyntaxKind.TypeQuery: {
+                // Handle typeof expressions like `typeof UsageEntry`
+                const typeQuery = typeNode;
+                if (ts.isIdentifier(typeQuery.exprName)) {
+                    return `typeof ${typeQuery.exprName.text}`;
+                }
+                return 'unknown';
+            }
             default:
                 // For complex types, return the text representation
                 return 'unknown';
         }
     }
+    /**
+        * Infer return type from a method declaration
+        * Uses explicit return type annotation or infers from return statements
+        */
+    inferReturnType(method, classPropertyTypes) {
+        // If method has explicit return type annotation, use it
+        if (method.type) {
+            return this.inferType(method.type);
+        }
+        // Otherwise, try to infer from return statements in the method body
+        if (method.body) {
+            return this.inferReturnTypeFromBody(method.body, classPropertyTypes);
+        }
+        return 'unknown';
+    }
+    /**
+        * Infer return type by analyzing return statements in the method body
+        */
+    inferReturnTypeFromBody(body, classPropertyTypes) {
+        const returnTypes = new Set();
+        const visit = (node) => {
+            if (ts.isReturnStatement(node) && node.expression) {
+                const type = this.inferTypeFromInitializer(node.expression, undefined, classPropertyTypes);
+                if (type !== 'unknown') {
+                    returnTypes.add(type);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(body);
+        if (returnTypes.size === 0) {
+            return 'void';
+        }
+        if (returnTypes.size === 1) {
+            return Array.from(returnTypes)[0];
+        }
+        return Array.from(returnTypes).join(' | ');
+    }
+    /**
+        * Get full text from a qualified name (e.g., Namespace.Type)
+        */
+    getQualifiedNameText(qualifiedName) {
+        const parts = [];
+        let current = qualifiedName;
+        while (ts.isQualifiedName(current)) {
+            parts.unshift(current.right.text);
+            current = current.left;
+        }
+        parts.unshift(current.text);
+        return parts.join('.');
+    }
     /**
      * Infer type from initializer
      */
-    inferTypeFromInitializer(initializer) {
+    inferTypeFromInitializer(initializer, dataTypeMap, classPropertyTypes) {
         switch (initializer.kind) {
             case ts.SyntaxKind.StringLiteral:
                 return 'string';
@@ -469,10 +1215,829 @@ class MnemonicaAnalyzer {
                 }
                 return 'object';
             }
+            case ts.SyntaxKind.BinaryExpression: {
+                // Handle arithmetic operations: a * b, a + b, a - b, a / b
+                const binaryExpr = initializer;
+                const leftType = this.inferTypeFromInitializer(binaryExpr.left, dataTypeMap, classPropertyTypes);
+                const rightType = this.inferTypeFromInitializer(binaryExpr.right, dataTypeMap, classPropertyTypes);
+                // Check if it's an arithmetic operator
+                const operator = binaryExpr.operatorToken.kind;
+                if (operator === ts.SyntaxKind.AsteriskToken ||
+                    operator === ts.SyntaxKind.SlashToken ||
+                    operator === ts.SyntaxKind.MinusToken ||
+                    operator === ts.SyntaxKind.PercentToken) {
+                    // Arithmetic operations on numbers produce numbers
+                    if ((leftType === 'number' || leftType === 'unknown') &&
+                        (rightType === 'number' || rightType === 'unknown')) {
+                        return 'number';
+                    }
+                }
+                if (operator === ts.SyntaxKind.PlusToken) {
+                    // Plus can be addition or string concatenation
+                    if (leftType === 'string' || rightType === 'string') {
+                        return 'string';
+                    }
+                    if (leftType === 'number' && rightType === 'number') {
+                        return 'number';
+                    }
+                }
+                return 'unknown';
+            }
+            case ts.SyntaxKind.PropertyAccessExpression: {
+                // Handle property access like data.value, data.id
+                if (dataTypeMap) {
+                    const accessChain = this.getPropertyAccessChain(initializer);
+                    if (accessChain) {
+                        const type = dataTypeMap.get(accessChain);
+                        if (type) {
+                            return type;
+                        }
+                    }
+                }
+                // Handle this.map.size pattern (Map.size returns number)
+                const propAccess = initializer;
+                if (ts.isPropertyAccessExpression(propAccess.expression)) {
+                    const outerProp = propAccess.expression;
+                    // Check for this.map pattern
+                    let innerName = '';
+                    if (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                        innerName = 'this';
+                    }
+                    else if (ts.isIdentifier(outerProp.expression)) {
+                        innerName = outerProp.expression.text;
+                    }
+                    const mapProp = outerProp.name.text;
+                    const finalProp = propAccess.name.text;
+                    // this.map.size -> number
+                    if (innerName === 'this' && mapProp === 'map' && finalProp === 'size') {
+                        return 'number';
+                    }
+                }
+                return 'unknown';
+            }
+            case ts.SyntaxKind.Identifier: {
+                // Handle identifier references if in dataTypeMap
+                if (dataTypeMap) {
+                    const name = initializer.text;
+                    const type = dataTypeMap.get(name);
+                    if (type) {
+                        return type;
+                    }
+                }
+                return 'unknown';
+            }
+            case ts.SyntaxKind.CallExpression: {
+                // Handle function calls like Date.now(), parseInt(), etc.
+                const callExpr = initializer;
+                if (ts.isPropertyAccessExpression(callExpr.expression)) {
+                    const methodName = callExpr.expression.name.text;
+                    const objName = ts.isIdentifier(callExpr.expression.expression)
+                        ? callExpr.expression.expression.text
+                        : '';
+                    // Date.now() -> number
+                    if (objName === 'Date' && methodName === 'now') {
+                        return 'number';
+                    }
+                    // String methods that return string
+                    if (methodName === 'toString' || methodName === 'valueOf') {
+                        return 'string';
+                    }
+                    // Handle Map property access on class instances (this.map.*)
+                    if (ts.isPropertyAccessExpression(callExpr.expression.expression)) {
+                        const outerProp = callExpr.expression.expression;
+                        // Handle both 'this' keyword and identifier patterns
+                        let innerName = '';
+                        if (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                            innerName = 'this';
+                        }
+                        else if (ts.isIdentifier(outerProp.expression)) {
+                            innerName = outerProp.expression.text;
+                        }
+                        const mapProp = outerProp.name.text;
+                        // this.map.X() patterns
+                        if (innerName === 'this' && mapProp === 'map') {
+                            // Try to get the Map's value type from class properties
+                            let mapValueType = 'unknown';
+                            if (classPropertyTypes) {
+                                const mapType = classPropertyTypes.get('map');
+                                if (mapType && mapType.startsWith('Map<')) {
+                                    // Parse Map<K, V> to get V
+                                    const match = mapType.match(/Map<[^,]+,\s*(.+)>$/);
+                                    if (match) {
+                                        mapValueType = match[1];
+                                    }
+                                }
+                            }
+                            if (methodName === 'has')
+                                return 'boolean';
+                            if (methodName === 'set')
+                                return 'this';
+                            if (methodName === 'get')
+                                return mapValueType;
+                            if (methodName === 'delete')
+                                return 'boolean';
+                            if (methodName === 'clear')
+                                return 'void';
+                            if (methodName === 'values')
+                                return `IterableIterator<${mapValueType}>`;
+                            if (methodName === 'keys')
+                                return 'IterableIterator<string>';
+                            if (methodName === 'entries')
+                                return `IterableIterator<[string, ${mapValueType}]>`;
+                        }
+                    }
+                    // Direct map.X() calls
+                    if (objName === 'map' || objName === 'obj') {
+                        if (methodName === 'has')
+                            return 'boolean';
+                        if (methodName === 'set')
+                            return 'this';
+                        if (methodName === 'get')
+                            return 'unknown';
+                        if (methodName === 'delete')
+                            return 'boolean';
+                        if (methodName === 'clear')
+                            return 'void';
+                        if (methodName === 'values')
+                            return 'IterableIterator<unknown>';
+                        if (methodName === 'keys')
+                            return 'IterableIterator<string>';
+                        if (methodName === 'entries')
+                            return 'IterableIterator<[string, unknown]>';
+                    }
+                }
+                // parseInt, parseFloat -> number
+                if (ts.isIdentifier(callExpr.expression)) {
+                    const fnName = callExpr.expression.text;
+                    if (fnName === 'parseInt' || fnName === 'parseFloat') {
+                        return 'number';
+                    }
+                    if (fnName === 'String') {
+                        return 'string';
+                    }
+                    if (fnName === 'Number') {
+                        return 'number';
+                    }
+                    if (fnName === 'Boolean') {
+                        return 'boolean';
+                    }
+                }
+                return 'unknown';
+            }
+            case ts.SyntaxKind.TemplateExpression:
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral: {
+                // Template literals like `${baseValue}-${extra}` always produce strings
+                return 'string';
+            }
             default:
                 return 'unknown';
         }
     }
+    /**
+        * Collect usage information for type references
+        */
+    collectUsage(node, sourceFile) {
+        // Check for new Type() instantiation
+        if (ts.isNewExpression(node) && node.expression) {
+            let typeName;
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                typeName = this.resolveTypePath(node.expression);
+            }
+            else {
+                typeName = this.getTypeNameFromExpression(node.expression);
+            }
+            if (typeName) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+                this.addUsage(typeName, {
+                    location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+                    kind: 'instantiation',
+                    code: node.getText(sourceFile).slice(0, 100),
+                });
+                // Track variable assignment from new Type() for flow analysis
+                this.trackNewAssignment(node, typeName);
+                // Also record as flow event
+                this.addFlow(typeName, {
+                    location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+                    kind: 'instantiation',
+                    code: node.getText(sourceFile).slice(0, 100),
+                    context: 'new expression',
+                });
+            }
+        }
+        // Check for property access on instances (user.AdminType)
+        if (ts.isPropertyAccessExpression(node)) {
+            const propName = node.name.text;
+            // Check if this looks like a type access pattern
+            if (propName && this.isLikelyTypeName(propName)) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+                // Try to resolve full path
+                const fullPath = this.resolveTypePath(node);
+                if (fullPath) {
+                    this.addUsage(fullPath, {
+                        location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+                        kind: 'propertyAccess',
+                        code: node.getText(sourceFile).slice(0, 100),
+                    });
+                }
+            }
+        }
+        // Check for lookupTyped('TypeName') calls
+        if (ts.isCallExpression(node) && node.expression) {
+            const funcName = this.getFunctionName(node.expression);
+            if (funcName === 'lookupTyped' && node.arguments.length > 0) {
+                const firstArg = node.arguments[0];
+                if (ts.isStringLiteral(firstArg) || ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                    const typePath = firstArg.text;
+                    const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+                    this.addUsage(typePath, {
+                        location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+                        kind: 'lookup',
+                        code: node.getText(sourceFile).slice(0, 100),
+                    });
+                    // Track variable assignment from lookupTyped for instantiation tracking
+                    this.trackLookupTypedAssignment(node, typePath);
+                }
+            }
+        }
+    }
+    /**
+        * Get function name from expression (identifier or property access)
+        */
+    getFunctionName(expr) {
+        if (ts.isIdentifier(expr)) {
+            return expr.text;
+        }
+        if (ts.isPropertyAccessExpression(expr)) {
+            return expr.name.text;
+        }
+        return undefined;
+    }
+    /**
+        * Add a usage to the collection
+        */
+    addUsage(typePath, usage) {
+        // Only track usages of mnemonica-defined types
+        if (!this.definitions.has(typePath)) {
+            return;
+        }
+        if (!this.usages.has(typePath)) {
+            this.usages.set(typePath, []);
+        }
+        // Check for duplicates based on location, code, and kind
+        const existingUsages = this.usages.get(typePath);
+        const isDuplicate = existingUsages.some(existing => existing.location === usage.location &&
+            existing.code === usage.code &&
+            existing.kind === usage.kind);
+        if (!isDuplicate) {
+            existingUsages.push(usage);
+        }
+    }
+    /**
+     * Collect EDS (Execution Data Storage) usage information
+     */
+    collectEDS(node, sourceFile) {
+        if (!ts.isCallExpression(node) || !node.expression) {
+            return;
+        }
+        const funcName = this.getFunctionName(node.expression);
+        if (!funcName) {
+            return;
+        }
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        // wrap(fn), wrapArgs(fn), wrapInstanceMethods(obj)
+        if (funcName === 'wrap' || funcName === 'wrapArgs' || funcName === 'wrapInstanceMethods') {
+            const targetType = this.resolveEDSArgumentType(node.arguments[0]);
+            this.addEDS(targetType || 'unknown', {
+                location,
+                kind: 'wrap',
+                code,
+                targetType: targetType || undefined,
+            });
+            return;
+        }
+        // link(parent, child), runWithInstance(instance, fn)
+        if (funcName === 'link' || funcName === 'runWithInstance') {
+            const targetType = this.resolveEDSArgumentType(node.arguments[0]);
+            this.addEDS(targetType || 'unknown', {
+                location,
+                kind: 'link',
+                code,
+                targetType: targetType || undefined,
+            });
+            return;
+        }
+        // getLastContext(), getErrorInstance(err)
+        if (funcName === 'getLastContext' || funcName === 'getErrorInstance') {
+            this.addEDS('unknown', {
+                location,
+                kind: 'contextConsume',
+                code,
+            });
+            return;
+        }
+        // enrichError(err, instance)
+        if (funcName === 'enrichError') {
+            const targetType = node.arguments.length > 1
+                ? this.resolveEDSArgumentType(node.arguments[1])
+                : undefined;
+            this.addEDS(targetType || 'unknown', {
+                location,
+                kind: 'errorEnrich',
+                code,
+                targetType: targetType || undefined,
+            });
+            return;
+        }
+        // attachHooks(types), attachHooks([A, B])
+        if (funcName === 'attachHooks' && node.arguments.length > 0) {
+            const arg = node.arguments[0];
+            if (ts.isArrayLiteralExpression(arg)) {
+                for (const element of arg.elements) {
+                    const targetType = this.resolveEDSArgumentType(element);
+                    this.addEDS(targetType || 'unknown', {
+                        location,
+                        kind: 'hookAttach',
+                        code,
+                        targetType: targetType || undefined,
+                    });
+                }
+            }
+            else {
+                const targetType = this.resolveEDSArgumentType(arg);
+                this.addEDS(targetType || 'unknown', {
+                    location,
+                    kind: 'hookAttach',
+                    code,
+                    targetType: targetType || undefined,
+                });
+            }
+            return;
+        }
+        // Adapters: createDiveInterceptor, createDivePlugin, createDiveMiddleware
+        if (funcName === 'createDiveInterceptor' || funcName === 'createDivePlugin' || funcName === 'createDiveMiddleware') {
+            this.addEDS('unknown', {
+                location,
+                kind: 'adapterUse',
+                code,
+            });
+            return;
+        }
+    }
+    /**
+     * Resolve type from EDS call argument (best effort)
+     */
+    resolveEDSArgumentType(arg) {
+        if (!arg) {
+            return undefined;
+        }
+        // Identifier: variable name
+        if (ts.isIdentifier(arg)) {
+            const mapped = this.variableToTypeMap.get(arg.text);
+            if (mapped) {
+                return mapped;
+            }
+            // Maybe it's a type name directly
+            if (this.definitions.has(arg.text)) {
+                return arg.text;
+            }
+            return undefined;
+        }
+        // Property access: obj.prop
+        if (ts.isPropertyAccessExpression(arg)) {
+            return this.resolveTypePath(arg);
+        }
+        // This expression: this.something
+        if (ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.expression) && arg.expression.text === 'this') {
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Add an EDS usage to the collection
+     */
+    addEDS(typePath, info) {
+        if (!this.edsUsages.has(typePath)) {
+            this.edsUsages.set(typePath, []);
+        }
+        const existing = this.edsUsages.get(typePath);
+        const isDuplicate = existing.some(e => e.location === info.location && e.kind === info.kind && e.code === info.code);
+        if (!isDuplicate) {
+            existing.push(info);
+        }
+    }
+    /**
+     * Collect native flow patterns (instance usage after creation)
+     * Phase 1: property access, method calls, arguments, return, destructuring, etc.
+     */
+    collectFlow(node, sourceFile) {
+        // Property read: user.name or user?.name
+        if (ts.isPropertyAccessExpression(node)) {
+            this.collectFlowPropertyAccess(node, sourceFile);
+            return;
+        }
+        // Element access: user['name']
+        if (ts.isElementAccessExpression(node)) {
+            this.collectFlowElementAccess(node, sourceFile);
+            return;
+        }
+        // Property write: user.name = value
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            this.collectFlowAssignment(node, sourceFile);
+            return;
+        }
+        // Method call: user.validate()  AND  argument passing: processUser(user)
+        if (ts.isCallExpression(node) && node.expression) {
+            this.collectFlowMethodCall(node, sourceFile);
+            this.collectFlowArgumentPass(node, sourceFile);
+            return;
+        }
+        // Destructure read: const { name } = user
+        if (ts.isVariableDeclaration(node) && node.initializer) {
+            this.collectFlowDestructure(node, sourceFile);
+            return;
+        }
+        // Return instance: return user
+        if (ts.isReturnStatement(node) && node.expression) {
+            this.collectFlowReturn(node, sourceFile);
+            return;
+        }
+        // Spread: { ...user }
+        if (ts.isSpreadElement(node)) {
+            this.collectFlowSpread(node, sourceFile);
+            return;
+        }
+    }
+    /**
+     * Collect property access flow (read or conditional)
+     */
+    collectFlowPropertyAccess(node, sourceFile) {
+        const objectType = this.resolveExpressionType(node.expression);
+        if (!objectType) {
+            return;
+        }
+        const propName = node.name.text;
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        // Skip if this is a type constructor access (e.g., UserType.define)
+        if (propName === 'define') {
+            return;
+        }
+        this.addFlow(objectType, {
+            location,
+            kind: 'propertyRead',
+            code,
+            propertyName: propName,
+            targetType: objectType
+        });
+    }
+    /**
+     * Collect element access flow: user['name']
+     */
+    collectFlowElementAccess(node, sourceFile) {
+        const objectType = this.resolveExpressionType(node.expression);
+        if (!objectType) {
+            return;
+        }
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        this.addFlow(objectType, {
+            location,
+            kind: 'elementAccess',
+            code,
+            targetType: objectType
+        });
+    }
+    /**
+     * Collect assignment flow: user.name = value or user = other
+     */
+    collectFlowAssignment(node, sourceFile) {
+        // Property write: user.name = value
+        if (ts.isPropertyAccessExpression(node.left)) {
+            const objectType = this.resolveExpressionType(node.left.expression);
+            if (!objectType) {
+                return;
+            }
+            const propName = node.left.name.text;
+            const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+            const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+            const code = node.getText(sourceFile).slice(0, 100);
+            this.addFlow(objectType, {
+                location,
+                kind: 'propertyWrite',
+                code,
+                propertyName: propName,
+                targetType: objectType
+            });
+            return;
+        }
+        // Variable reassignment: user = other
+        if (ts.isIdentifier(node.left)) {
+            const varName = node.left.text;
+            const mappedType = this.variableToTypeMap.get(varName);
+            if (!mappedType) {
+                return;
+            }
+            const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+            const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+            const code = node.getText(sourceFile).slice(0, 100);
+            this.addFlow(mappedType, {
+                location,
+                kind: 'reassignment',
+                code,
+                targetType: mappedType
+            });
+        }
+    }
+    /**
+     * Collect method call flow: user.validate()
+     */
+    collectFlowMethodCall(node, sourceFile) {
+        if (!ts.isPropertyAccessExpression(node.expression)) {
+            return;
+        }
+        const objectType = this.resolveExpressionType(node.expression.expression);
+        if (!objectType) {
+            return;
+        }
+        const methodName = node.expression.name.text;
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        // Skip if this is a type constructor call (e.g., new UserType())
+        if (methodName === 'define') {
+            return;
+        }
+        this.addFlow(objectType, {
+            location,
+            kind: 'methodCall',
+            code,
+            propertyName: methodName,
+            targetType: objectType
+        });
+    }
+    /**
+     * Collect argument passing flow: processUser(user)
+     */
+    collectFlowArgumentPass(node, sourceFile) {
+        for (let i = 0; i < node.arguments.length; i++) {
+            const arg = node.arguments[i];
+            const argType = this.resolveExpressionType(arg);
+            if (!argType) {
+                continue;
+            }
+            const funcName = this.getFunctionName(node.expression) || 'anonymous';
+            const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+            const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+            const code = node.getText(sourceFile).slice(0, 100);
+            this.addFlow(argType, {
+                location,
+                kind: 'passAsArg',
+                code,
+                targetType: argType,
+                context: `arg ${i} to ${funcName}`
+            });
+        }
+    }
+    /**
+     * Collect destructuring flow: const { name } = user
+     */
+    collectFlowDestructure(node, sourceFile) {
+        if (!ts.isObjectBindingPattern(node.name)) {
+            return;
+        }
+        const sourceType = this.resolveExpressionType(node.initializer);
+        if (!sourceType) {
+            return;
+        }
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        // Extract destructured property names
+        const props = [];
+        for (const element of node.name.elements) {
+            if (ts.isIdentifier(element.name)) {
+                props.push(element.name.text);
+            }
+        }
+        this.addFlow(sourceType, {
+            location,
+            kind: 'destructureRead',
+            code,
+            targetType: sourceType,
+            context: props.join(', ')
+        });
+    }
+    /**
+     * Collect return flow: return user
+     */
+    collectFlowReturn(node, sourceFile) {
+        const returnType = this.resolveExpressionType(node.expression);
+        if (!returnType) {
+            return;
+        }
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        this.addFlow(returnType, {
+            location,
+            kind: 'return',
+            code,
+            targetType: returnType
+        });
+    }
+    /**
+     * Collect spread flow: { ...user }
+     */
+    collectFlowSpread(node, sourceFile) {
+        const spreadType = this.resolveExpressionType(node.expression);
+        if (!spreadType) {
+            return;
+        }
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
+        const code = node.getText(sourceFile).slice(0, 100);
+        this.addFlow(spreadType, {
+            location,
+            kind: 'spread',
+            code,
+            targetType: spreadType
+        });
+    }
+    /**
+     * Resolve type from an expression (identifier, property access, etc.)
+     */
+    resolveExpressionType(expr) {
+        // Identifier: user
+        if (ts.isIdentifier(expr)) {
+            return this.variableToTypeMap.get(expr.text);
+        }
+        // Property access: user.name (return object type, not property type)
+        if (ts.isPropertyAccessExpression(expr)) {
+            return this.resolveExpressionType(expr.expression);
+        }
+        // Element access: user['name']
+        if (ts.isElementAccessExpression(expr)) {
+            return this.resolveExpressionType(expr.expression);
+        }
+        // This expression: this (if in a method, we can't resolve without more context)
+        if (expr.kind === ts.SyntaxKind.ThisKeyword) {
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Add a flow usage to the collection
+     */
+    addFlow(typePath, info) {
+        if (!this.flowUsages.has(typePath)) {
+            this.flowUsages.set(typePath, []);
+        }
+        const existing = this.flowUsages.get(typePath);
+        const isDuplicate = existing.some(e => e.location === info.location && e.kind === info.kind && e.code === info.code);
+        if (!isDuplicate) {
+            existing.push(info);
+        }
+    }
+    /**
+            * Get type name from expression (identifier or property access)
+            */
+    getTypeNameFromExpression(expr) {
+        if (ts.isIdentifier(expr)) {
+            const name = expr.text;
+            // Check if this identifier is a variable mapped to a type (e.g., from lookupTyped)
+            const mappedType = this.variableToTypeMap.get(name);
+            if (mappedType) {
+                return mappedType;
+            }
+            return name;
+        }
+        if (ts.isPropertyAccessExpression(expr)) {
+            const chain = this.getPropertyChain(expr);
+            return chain.join('.');
+        }
+        return undefined;
+    }
+    /**
+        * Resolve full type path from property access
+        */
+    resolveTypePath(expr) {
+        const chain = this.getPropertyChain(expr);
+        if (chain.length === 0)
+            return undefined;
+        // Check if this chain matches a known type
+        const fullPath = chain.join('.');
+        if (this.definitions.has(fullPath)) {
+            return fullPath;
+        }
+        // Try just the property name
+        const propName = chain[chain.length - 1];
+        for (const [path] of this.definitions) {
+            if (path.endsWith(`.${propName}`) || path === propName) {
+                return path;
+            }
+        }
+        return fullPath;
+    }
+    /**
+         * Check if a name looks like a type (starts with uppercase)
+         */
+    isLikelyTypeName(name) {
+        return name[0] >= 'A' && name[0] <= 'Z';
+    }
+    /**
+         * Extract constructor parameters from define() call
+         * This is used for TypeRegistry constructor signatures
+         * Preserves parameter names and expands object types to their structure
+         */
+    extractConstructorParams(call) {
+        const params = [];
+        const handlerArg = call.arguments[1];
+        if (!handlerArg)
+            return params;
+        // Helper to resolve type alias and extract properties
+        const resolveTypeAndExtract = (typeNode) => {
+            if (!typeNode)
+                return undefined;
+            // Direct inline type literal: { prop: type }
+            if (ts.isTypeLiteralNode(typeNode)) {
+                const props = [];
+                for (const member of typeNode.members) {
+                    if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                        const propName = member.name.text;
+                        const optional = member.questionToken ? '?' : '';
+                        const type = this.inferType(member.type);
+                        props.push(`${propName}${optional}: ${type}`);
+                    }
+                }
+                return `{ ${props.join('; ')} }`;
+            }
+            // Type reference: usage, UserData, etc. - recursively expand
+            if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+                const typeName = typeNode.typeName.text;
+                const aliasedType = this.typeAliases.get(typeName);
+                if (aliasedType) {
+                    const expanded = resolveTypeAndExtract(aliasedType);
+                    if (expanded)
+                        return expanded;
+                }
+                // If not an object type alias, return the type name with args
+                if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+                    const args = typeNode.typeArguments.map(arg => this.inferType(arg));
+                    return typeName + '<' + args.join(', ') + '>';
+                }
+                return typeName;
+            }
+            return undefined;
+        };
+        // Handle function expression or arrow function
+        if (ts.isFunctionExpression(handlerArg) || ts.isArrowFunction(handlerArg)) {
+            // Look for constructor parameters (second param after `this`)
+            // Patterns: function(this: Type, data: { ... }) or (this: Type, data: { ... }) =>
+            for (let i = 0; i < handlerArg.parameters.length; i++) {
+                const param = handlerArg.parameters[i];
+                if (!param.type)
+                    continue;
+                // Skip `this` parameter (first param)
+                if (i === 0 && param.name.kind === ts.SyntaxKind.Identifier && param.name.text === 'this') {
+                    continue;
+                }
+                // Get parameter name and expand its type
+                const paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';
+                const expandedType = resolveTypeAndExtract(param.type) || this.inferType(param.type);
+                params.push({
+                    name: paramName,
+                    type: expandedType,
+                    optional: !!param.questionToken || !!param.initializer
+                });
+            }
+        }
+        // Handle class expression - check constructor method
+        if (ts.isClassExpression(handlerArg)) {
+            for (const member of handlerArg.members) {
+                if (ts.isConstructorDeclaration(member)) {
+                    for (const param of member.parameters) {
+                        if (!param.name || !ts.isIdentifier(param.name))
+                            continue;
+                        if (param.type) {
+                            const paramName = param.name.text;
+                            const expandedType = resolveTypeAndExtract(param.type) || this.inferType(param.type);
+                            params.push({
+                                name: paramName,
+                                type: expandedType,
+                                optional: !!param.questionToken || !!param.initializer
+                            });
+                        }
+                    }
+                    break; // Only process first constructor
+                }
+            }
+        }
+        return params;
+    }
 }
 exports.MnemonicaAnalyzer = MnemonicaAnalyzer;
 //# sourceMappingURL=analyzer.js.map