@mnemonica/tactica 0.1.4 → 0.1.7

package/lib/analyzer.js

@@ -50,6 +50,15 @@ class MnemonicaAnalyzer {
         this.typeAliases = new Map();
         // Track variable assignments: variableName -> fullPath of the type it holds
         this.variableToTypeMap = new Map();
+        // Track mnemonica module-object variables (e.g., import { mnemonica } from 'mnemonica'; const m = mnemonica)
+        this.moduleObjectVariables = new Set();
+        // Track imported aliases of createTypesCollection (e.g., import { createTypesCollection as ctc })
+        this.createTypesCollectionVariables = new Set();
+        // Track custom collection variables: variableName -> collectionId
+        this.collectionVariables = new Map();
+        // Track custom collection metadata for Option B registry emission
+        this.collectionInfo = new Map();
+        this.collectionCounter = 0;
         // Store program for future use (currently unused but kept for extensibility)
         void program;
     }
@@ -62,6 +71,8 @@ class MnemonicaAnalyzer {
         this.edsUsages.clear();
         this.flowUsages.clear();
         this.variableToTypeMap.clear();
+        // Note: moduleObjectVariables and collectionVariables intentionally persist
+        // across definition and usage passes.
     }
     /**
      * Analyze a source file for Mnemonica type definitions
@@ -158,10 +169,19 @@ class MnemonicaAnalyzer {
      * Visit a node in the AST
      */
     visitNode(node, sourceFile, currentClass) {
+        // Track mnemonica module-object aliases and custom collection variables
+        // before processing define()/lookup() calls so source resolution works.
+        this.trackImports(node);
+        this.trackModuleObjectAliases(node);
+        this.trackCollectionAliases(node, sourceFile);
         // Check for define() calls
         if (this.isDefineCall(node)) {
             this.processDefineCall(node, sourceFile);
         }
+        // Check for lazy() calls
+        if (this.isLazyCall(node)) {
+            this.processLazyCall(node, sourceFile);
+        }
         // Check for decorate() decorator
         if (this.isDecorateDecorator(node)) {
             this.processDecorateDecorator(node, sourceFile, currentClass);
@@ -186,6 +206,167 @@ class MnemonicaAnalyzer {
             ts.forEachChild(node, child => this.visitNode(child, sourceFile, currentClass));
         }
     }
+    /**
+     * Track imports from 'mnemonica' so aliases of the module object and
+     * createTypesCollection are recognized without relying on the type checker.
+     */
+    trackImports(node) {
+        if (!ts.isImportDeclaration(node)) {
+            return;
+        }
+        const { moduleSpecifier } = node;
+        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== 'mnemonica') {
+            return;
+        }
+        const clause = node.importClause;
+        if (!clause) {
+            return;
+        }
+        // import { mnemonica, createTypesCollection } from 'mnemonica'
+        if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            for (const element of clause.namedBindings.elements) {
+                const localName = element.name.text;
+                const importedName = element.propertyName
+                    ? element.propertyName.text
+                    : localName;
+                if (importedName === 'mnemonica') {
+                    this.moduleObjectVariables.add(localName);
+                }
+                if (importedName === 'createTypesCollection') {
+                    this.createTypesCollectionVariables.add(localName);
+                }
+            }
+        }
+        // import * as mnemonica from 'mnemonica'
+        if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+            this.moduleObjectVariables.add(clause.namedBindings.name.text);
+        }
+        // import mnemonica from 'mnemonica' (default import) — treat as module object too
+        if (clause.name) {
+            this.moduleObjectVariables.add(clause.name.text);
+        }
+    }
+    /**
+     * Track aliases of the mnemonica module object, e.g.:
+     *   const m = mnemonica;
+     *   const App = m;
+     */
+    trackModuleObjectAliases(node) {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {
+            return;
+        }
+        const { initializer } = node;
+        if (!initializer) {
+            return;
+        }
+        if (ts.isIdentifier(initializer) && this.moduleObjectVariables.has(initializer.text)) {
+            this.moduleObjectVariables.add(node.name.text);
+        }
+    }
+    /**
+     * Track custom collection variables, e.g.:
+     *   const MyCollection = createTypesCollection();
+     *   const Other = MyCollection;
+     *
+     * Also detects Option B user-provided registry interfaces:
+     *   export interface MyCollectionRegistry {}
+     *   const MyCollection = createTypesCollection<MyCollectionRegistry>();
+     */
+    trackCollectionAliases(node, sourceFile) {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {
+            return;
+        }
+        const { initializer } = node;
+        if (!initializer) {
+            return;
+        }
+        // Direct createTypesCollection() call
+        if (this.isCreateTypesCollectionCall(initializer)) {
+            const collectionId = this.nextCollectionId();
+            this.collectionVariables.set(node.name.text, collectionId);
+            const registryInterfaceName = this.extractRegistryInterfaceName(initializer, sourceFile);
+            this.collectionInfo.set(collectionId, {
+                variableName: node.name.text,
+                sourceFile: sourceFile.fileName,
+                registryInterfaceName: registryInterfaceName
+            });
+            return;
+        }
+        // Alias of another collection variable
+        if (ts.isIdentifier(initializer)) {
+            const existing = this.collectionVariables.get(initializer.text);
+            if (existing) {
+                this.collectionVariables.set(node.name.text, existing);
+            }
+        }
+    }
+    /**
+     * Extract the registry interface name from createTypesCollection<Registry>()
+     * when the interface is declared in the same source file.
+     */
+    extractRegistryInterfaceName(call, sourceFile) {
+        const typeArgs = call.typeArguments;
+        if (!typeArgs || typeArgs.length === 0) {
+            return undefined;
+        }
+        const firstTypeArg = typeArgs[0];
+        if (!ts.isTypeReferenceNode(firstTypeArg) || !ts.isIdentifier(firstTypeArg.typeName)) {
+            return undefined;
+        }
+        const name = firstTypeArg.typeName.text;
+        // Confirm the interface exists in the same source file.
+        for (const statement of sourceFile.statements) {
+            if (ts.isInterfaceDeclaration(statement) &&
+                statement.name.text === name) {
+                return name;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get the registry interface name for a collection id.
+     */
+    getRegistryInterfaceName(collectionId) {
+        if (!collectionId) {
+            return undefined;
+        }
+        return this.collectionInfo.get(collectionId)?.registryInterfaceName;
+    }
+    /**
+     * Check if an expression is a createTypesCollection() call.
+     * Handles:
+     *   createTypesCollection()
+     *   ctc() // aliased import
+     *   mnemonica.createTypesCollection() // module object method
+     *   m.createTypesCollection() // aliased module object
+     */
+    isCreateTypesCollectionCall(node) {
+        if (!ts.isCallExpression(node)) {
+            return false;
+        }
+        const expr = node.expression;
+        // Direct call or aliased import: createTypesCollection() / ctc()
+        if (ts.isIdentifier(expr)) {
+            return expr.text === 'createTypesCollection' ||
+                this.createTypesCollectionVariables.has(expr.text);
+        }
+        // Module object method: mnemonica.createTypesCollection()
+        if (ts.isPropertyAccessExpression(expr) &&
+            expr.name.text === 'createTypesCollection' &&
+            ts.isIdentifier(expr.expression) &&
+            this.moduleObjectVariables.has(expr.expression.text)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Generate a unique collection identifier.
+     */
+    nextCollectionId() {
+        this.collectionCounter++;
+        const result = `collection_${this.collectionCounter}`;
+        return result;
+    }
     /**
      * Check if a node is a define() call
      */
@@ -193,7 +374,7 @@ class MnemonicaAnalyzer {
         if (!ts.isCallExpression(node)) {
             return false;
         }
-        const expression = node.expression;
+        const { expression } = node;
         // Check for direct call: define('TypeName', ...)
         if (ts.isIdentifier(expression) && expression.text === 'define') {
             return true;
@@ -204,6 +385,24 @@ class MnemonicaAnalyzer {
         }
         return false;
     }
+    /**
+     * Check if a node is a lazy() call
+     */
+    isLazyCall(node) {
+        if (!ts.isCallExpression(node)) {
+            return false;
+        }
+        const { expression } = node;
+        // Check for direct call: lazy('TypeName', getter, ...)
+        if (ts.isIdentifier(expression) && expression.text === 'lazy') {
+            return true;
+        }
+        // Check for method call: SomeType.lazy('SubType', getter, ...)
+        if (ts.isPropertyAccessExpression(expression)) {
+            return expression.name?.text === 'lazy';
+        }
+        return false;
+    }
     /**
         * Extract config options from an object literal
         */
@@ -247,7 +446,7 @@ class MnemonicaAnalyzer {
         if (!ts.isDecorator(node)) {
             return false;
         }
-        const expression = node.expression;
+        const { expression } = node;
         // Check for @decorate
         if (ts.isIdentifier(expression) && expression.text === 'decorate') {
             return true;
@@ -258,20 +457,37 @@ class MnemonicaAnalyzer {
             if (ts.isIdentifier(fnName) && fnName.text === 'decorate') {
                 return true;
             }
+            // Check for @MyCollection.decorate() where MyCollection is a custom collection
+            if (ts.isPropertyAccessExpression(fnName) &&
+                fnName.name.text === 'decorate' &&
+                ts.isIdentifier(fnName.expression) &&
+                this.collectionVariables.has(fnName.expression.text)) {
+                return true;
+            }
         }
         return false;
     }
+    /**
+     * Mark a call expression as processed and return whether it already was.
+     */
+    markProcessed(call) {
+        const marked = call;
+        if (marked.__tactica_processed) {
+            return true;
+        }
+        marked.__tactica_processed = true;
+        return false;
+    }
     /**
      * Process a define() call
      */
     processDefineCall(call, sourceFile) {
         // Check if this exact call has already been processed (prevents duplicates from chained calls)
-        if (call.__tactica_processed) {
+        if (this.markProcessed(call)) {
             return;
         }
-        call.__tactica_processed = true;
-        // Get the type name from arguments
-        const typeName = this.extractTypeName(call);
+        // Get the type name and source context from arguments
+        const defineContext = this.extractDefineContext(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;
@@ -284,7 +500,7 @@ class MnemonicaAnalyzer {
         }
         const startPos = positionNode.getStart(sourceFile);
         const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);
-        if (!typeName) {
+        if (!defineContext.typeName) {
             this.errors.push({
                 message: 'Could not extract type name from define() call',
                 file: sourceFile.fileName,
@@ -293,13 +509,27 @@ class MnemonicaAnalyzer {
             });
             return;
         }
-        // Determine parent type
-        const parentNode = this.findParentType(call, sourceFile);
-        // Build full path
-        const fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;
+        const { typeName } = defineContext;
+        // Determine parent type and collection based on the call source.
+        const parentNode = defineContext.parentType;
+        const { collectionId } = defineContext;
         // Extract config options
         const config = this.extractConfig(call);
-        // Create definition info
+        // Create type node first so its internal fullPath (including any collection prefix) is resolved.
+        const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1, collectionId);
+        node.registryInterfaceName = this.getRegistryInterfaceName(collectionId);
+        // 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);
+        }
+        else {
+            this.graph.addRoot(node);
+        }
+        // Create definition info using the node's resolved fullPath
         const definition = {
             name: typeName,
             location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
@@ -308,10 +538,52 @@ class MnemonicaAnalyzer {
             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
+        this.definitions.set(node.fullPath, definition);
+        // 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, node.fullPath);
+    }
+    /**
+     * Process a lazy() call
+     */
+    processLazyCall(call, sourceFile) {
+        // Check if this exact call has already been processed (prevents duplicates from chained calls)
+        if (this.markProcessed(call)) {
+            return;
+        }
+        // Get the type name and source context from arguments
+        const lazyContext = this.extractLazyContext(call, sourceFile);
+        // For chained calls like define('A').lazy('B'), we want the position of the .lazy('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 .lazy part
+        if (ts.isPropertyAccessExpression(call.expression)) {
+            // The expression is the property access: (define('RootAsync', ...)).lazy
+            // We want the position of just the .lazy part
+            positionNode = call.expression.name; // This is the 'lazy' identifier
+        }
+        const startPos = positionNode.getStart(sourceFile);
+        const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);
+        if (!lazyContext.typeName) {
+            this.errors.push({
+                message: 'Could not extract type name from lazy() call',
+                file: sourceFile.fileName,
+                line: line + 1,
+                column: character + 1,
+            });
+            return;
+        }
+        const { typeName } = lazyContext;
+        // Determine parent type and collection based on the call source.
+        const parentNode = lazyContext.parentType;
+        const { collectionId } = lazyContext;
+        // Extract config options
+        const config = this.extractLazyConfig(call);
+        // Create type node first so its internal fullPath (including any collection prefix) is resolved.
+        const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1, collectionId);
+        node.registryInterfaceName = this.getRegistryInterfaceName(collectionId);
+        // Extract properties from the constructor returned by the lazy getter
         node.properties = this.extractProperties(call);
         // Extract constructor parameters for TypeRegistry signature
         node.constructorParams = this.extractConstructorParams(call);
@@ -322,9 +594,271 @@ 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);
+        // Create definition info using the node's resolved fullPath
+        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(node.fullPath, definition);
+        // Track variable assignment: const LazyType = lazy('LazyType', ...) -> map "LazyType" -> "LazyType"
+        // For chained calls like const X = lazy('A').define('B'), we want to map X -> A (the root)
+        this.trackVariableAssignment(call, parentNode, node.fullPath);
+    }
+    /**
+     * Extract lazy() call arguments into a normalized shape.
+     * Handles named/unnamed and explicit-source forms, both as free calls
+     * and as method calls.
+     */
+    extractLazyCallArgs(call) {
+        const args = call.arguments;
+        const isMethodCall = ts.isPropertyAccessExpression(call.expression);
+        if (isMethodCall) {
+            // Source is the object of the property access: Type.lazy(...)
+            const source = call.expression.expression;
+            if (args.length === 0) {
+                return undefined;
+            }
+            const methodFirstArg = args[0];
+            if (ts.isStringLiteral(methodFirstArg)) {
+                // Type.lazy('Name', getter, config?)
+                if (args.length < 2) {
+                    return undefined;
+                }
+                return {
+                    source,
+                    name: methodFirstArg.text,
+                    getter: args[1],
+                    config: args[2],
+                };
+            }
+            // Type.lazy(getter, config?)
+            return {
+                source,
+                getter: methodFirstArg,
+                config: args[1],
+            };
+        }
+        // Free call: lazy(...)
+        if (args.length === 0) {
+            return undefined;
+        }
+        const firstArg = args[0];
+        // Explicit-source form: lazy(source, 'Name', getter, config?)
+        // or lazy(source, getter, config?)
+        if (args.length >= 2 && ts.isIdentifier(firstArg)) {
+            const secondArg = args[1];
+            if (ts.isStringLiteral(secondArg)) {
+                // lazy(source, 'Name', getter, config?)
+                if (args.length < 3) {
+                    return undefined;
+                }
+                return {
+                    source: firstArg,
+                    name: secondArg.text,
+                    getter: args[2],
+                    config: args[3],
+                };
+            }
+            // lazy(source, getter, config?)
+            return {
+                source: firstArg,
+                getter: secondArg,
+                config: args[2],
+            };
+        }
+        // Named root form: lazy('Name', getter, config?)
+        if (ts.isStringLiteral(firstArg)) {
+            if (args.length < 2) {
+                return undefined;
+            }
+            return {
+                name: firstArg.text,
+                getter: args[1],
+                config: args[2],
+            };
+        }
+        // Unnamed root form: lazy(getter, config?)
+        return {
+            getter: firstArg,
+            config: args[1],
+        };
+    }
+    /**
+     * Unwrap the constructor returned by a lazy getter.
+     * Supports:
+     *   () => class Name {}
+     *   () => function Name() {}
+     *   () => { return class Name {}; }
+     *   function () { return function Name() {}; }
+     */
+    unwrapLazyGetter(getterExpr) {
+        if (ts.isArrowFunction(getterExpr)) {
+            const { body } = getterExpr;
+            if (!ts.isBlock(body)) {
+                return body;
+            }
+            for (const stmt of body.statements) {
+                if (ts.isReturnStatement(stmt) && stmt.expression) {
+                    return stmt.expression;
+                }
+            }
+            return undefined;
+        }
+        if (ts.isFunctionExpression(getterExpr)) {
+            const { body } = getterExpr;
+            for (const stmt of body.statements) {
+                if (ts.isReturnStatement(stmt) && stmt.expression) {
+                    return stmt.expression;
+                }
+            }
+            return undefined;
+        }
+        // Not a recognized getter pattern
+        return undefined;
+    }
+    /**
+     * Extract a constructor name from a class expression, class declaration,
+     * or named function expression.
+     */
+    extractConstructorName(constructorExpr) {
+        if (ts.isClassExpression(constructorExpr) && constructorExpr.name) {
+            return constructorExpr.name.text;
+        }
+        if (ts.isClassDeclaration(constructorExpr) && constructorExpr.name) {
+            return constructorExpr.name.text;
+        }
+        if (ts.isFunctionExpression(constructorExpr) && constructorExpr.name) {
+            return constructorExpr.name.text;
+        }
+        return undefined;
+    }
+    /**
+     * Extract the type name from either a define() or lazy() call.
+     */
+    extractMnemonicaTypeName(call) {
+        if (this.isDefineCall(call)) {
+            return this.extractTypeName(call);
+        }
+        if (this.isLazyCall(call)) {
+            const args = this.extractLazyCallArgs(call);
+            if (!args) {
+                return undefined;
+            }
+            if (args.name) {
+                return args.name;
+            }
+            const constructorExpr = this.unwrapLazyGetter(args.getter);
+            if (constructorExpr) {
+                return this.extractConstructorName(constructorExpr);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract the full lazy() call context: type name, parent type, and collection.
+     * Handles direct calls, property-access calls, chained calls, and the
+     * explicit-source form `lazy(source, 'TypeName', getter)`.
+     */
+    extractLazyContext(call, sourceFile) {
+        const args = this.extractLazyCallArgs(call);
+        if (!args) {
+            return {};
+        }
+        let typeName = args.name;
+        if (!typeName) {
+            const constructorExpr = this.unwrapLazyGetter(args.getter);
+            if (constructorExpr) {
+                typeName = this.extractConstructorName(constructorExpr);
+            }
+        }
+        if (!typeName) {
+            return {};
+        }
+        const { expression } = call;
+        // Direct call: lazy('TypeName', ...) or lazy(source, 'TypeName', getter)
+        if (ts.isIdentifier(expression) && expression.text === 'lazy') {
+            if (args.source && ts.isIdentifier(args.source)) {
+                const sourceContext = this.resolveDefineSource(args.source.text);
+                return {
+                    typeName,
+                    parentType: sourceContext.parentType,
+                    collectionId: sourceContext.collectionId,
+                };
+            }
+            // Plain root lazy in default collection
+            return { typeName };
+        }
+        // Property access: X.lazy('TypeName', ...)
+        if (ts.isPropertyAccessExpression(expression) && expression.name.text === 'lazy') {
+            const obj = expression.expression;
+            if (ts.isIdentifier(obj)) {
+                const sourceContext = this.resolveDefineSource(obj.text);
+                return {
+                    typeName,
+                    parentType: sourceContext.parentType,
+                    collectionId: sourceContext.collectionId,
+                };
+            }
+            if (ts.isPropertyAccessExpression(obj)) {
+                // Nested access: instance.Type.lazy - try to resolve
+                const chain = this.getPropertyChain(obj);
+                if (chain.length > 0) {
+                    const parentNode = this.graph.findType(chain.join('.'));
+                    return { typeName, parentType: parentNode };
+                }
+            }
+            if (ts.isCallExpression(obj)) {
+                // Determine the collection context from the root of the chain so that
+                // custom-collection types do not get confused with default-collection types.
+                const rootId = this.getRootIdentifier(obj.expression);
+                const expectedCollectionId = rootId
+                    ? this.resolveDefineSource(rootId.text).collectionId
+                    : undefined;
+                // Chained call: define('A').lazy('B') or lazy('A').lazy('B')
+                if (this.isDefineCall(obj)) {
+                    this.processDefineCall(obj, sourceFile);
+                    const parentTypeName = this.extractMnemonicaTypeName(obj);
+                    if (parentTypeName) {
+                        const parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);
+                        return { typeName, parentType: parentNode, collectionId: parentNode?.collectionId };
+                    }
+                }
+                if (this.isLazyCall(obj)) {
+                    this.processLazyCall(obj, sourceFile);
+                    const parentTypeName = this.extractMnemonicaTypeName(obj);
+                    if (parentTypeName) {
+                        const parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);
+                        return { typeName, parentType: parentNode, collectionId: parentNode?.collectionId };
+                    }
+                }
+                // Builder lookup chain: App.lookup('User').lazy('Admin')
+                if (this.isLookupCall(obj)) {
+                    const lookedUpPath = this.resolveLookupPath(obj);
+                    if (lookedUpPath) {
+                        const parentNode = this.graph.findType(lookedUpPath);
+                        if (parentNode) {
+                            return { typeName, parentType: parentNode, collectionId: parentNode.collectionId };
+                        }
+                    }
+                }
+            }
+        }
+        return { typeName };
+    }
+    /**
+     * Extract config options from lazy() call
+     */
+    extractLazyConfig(call) {
+        const args = this.extractLazyCallArgs(call);
+        if (!args || !args.config || !ts.isObjectLiteralExpression(args.config)) {
+            return {};
+        }
+        const configResult = this.extractConfigFromObjectLiteral(args.config);
+        return configResult;
     }
     /**
         * Track variable assignments that capture define() results
@@ -417,51 +951,68 @@ class MnemonicaAnalyzer {
             return;
         }
         // Parse decorator arguments: @decorate(), @decorate(Parent),
-        // @decorate({ ... }), @decorate(Parent, { ... })
+        // @decorate({ ... }), @decorate(Parent, { ... }),
+        // @MyCollection.decorate(), @MyCollection.decorate({ ... })
         let parentNode;
         let parentFullPath = null;
+        let collectionId;
         let decoratorConfig = {};
         if (ts.isCallExpression(decorator.expression)) {
-            const args = decorator.expression.arguments;
-            let parentArg;
-            let configArg;
-            for (const arg of args) {
-                if (ts.isIdentifier(arg)) {
-                    if (parentArg) {
-                        this.errors.push({
-                            message: '@decorate() accepts only one parent reference',
-                            file: sourceFile.fileName,
-                            line: line + 1,
-                            column: character + 1,
-                        });
+            const callExpr = decorator.expression;
+            const callee = callExpr.expression;
+            // Check for @MyCollection.decorate() where MyCollection is a custom collection.
+            // The decorated class becomes a root type in that collection.
+            if (ts.isPropertyAccessExpression(callee) &&
+                callee.name.text === 'decorate' &&
+                ts.isIdentifier(callee.expression) &&
+                this.collectionVariables.has(callee.expression.text)) {
+                collectionId = this.collectionVariables.get(callee.expression.text);
+                if (callExpr.arguments.length === 1 && ts.isObjectLiteralExpression(callExpr.arguments[0])) {
+                    decoratorConfig = this.extractConfigFromObjectLiteral(callExpr.arguments[0]);
+                }
+            }
+            else {
+                const args = callExpr.arguments;
+                let parentArg;
+                let configArg;
+                for (const arg of args) {
+                    if (ts.isIdentifier(arg)) {
+                        if (parentArg) {
+                            this.errors.push({
+                                message: '@decorate() accepts only one parent reference',
+                                file: sourceFile.fileName,
+                                line: line + 1,
+                                column: character + 1,
+                            });
+                        }
+                        else {
+                            parentArg = arg;
+                        }
                     }
-                    else {
-                        parentArg = arg;
+                    else if (ts.isObjectLiteralExpression(arg)) {
+                        if (configArg) {
+                            this.errors.push({
+                                message: '@decorate() accepts only one config object',
+                                file: sourceFile.fileName,
+                                line: line + 1,
+                                column: character + 1,
+                            });
+                        }
+                        else {
+                            configArg = arg;
+                        }
                     }
                 }
-                else if (ts.isObjectLiteralExpression(arg)) {
-                    if (configArg) {
-                        this.errors.push({
-                            message: '@decorate() accepts only one config object',
-                            file: sourceFile.fileName,
-                            line: line + 1,
-                            column: character + 1,
-                        });
-                    }
-                    else {
-                        configArg = arg;
+                if (parentArg) {
+                    parentNode = this.findParentTypeByIdentifier(parentArg.text);
+                    if (parentNode) {
+                        parentFullPath = parentNode.fullPath;
                     }
                 }
-            }
-            if (parentArg) {
-                parentNode = this.findParentTypeByIdentifier(parentArg.text);
-                if (parentNode) {
-                    parentFullPath = parentNode.fullPath;
+                if (configArg) {
+                    decoratorConfig = this.extractConfigFromObjectLiteral(configArg);
                 }
             }
-            if (configArg) {
-                decoratorConfig = this.extractConfigFromObjectLiteral(configArg);
-            }
         }
         // Build full path
         const fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;
@@ -476,7 +1027,8 @@ class MnemonicaAnalyzer {
         };
         this.definitions.set(fullPath, definition);
         // Create type node
-        const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1);
+        const node = graph_1.TypeGraphImpl.createNode(typeName, parentNode, sourceFile.fileName, line + 1, character + 1, collectionId);
+        node.registryInterfaceName = this.getRegistryInterfaceName(node.collectionId);
         // Extract properties and constructor parameters from class members
         node.properties = this.extractClassProperties(classDecl);
         node.constructorParams = this.extractClassConstructorParams(classDecl);
@@ -489,15 +1041,23 @@ class MnemonicaAnalyzer {
         }
     }
     /**
-     * Extract type name from define() call arguments
+     * Extract type name from define() call arguments.
+     * Handles:
+     *   define('TypeName', handler)
+     *   define(source, 'TypeName', handler)   // explicit-source form
+     *   define(function TypeName() {})
+     *   define(() => class TypeName {})
      */
     extractTypeName(call) {
         const args = call.arguments;
-        // define('TypeName', handler) or define(() => class)
         if (args.length === 0) {
             return undefined;
         }
         const firstArg = args[0];
+        // Explicit-source form: define(source, 'TypeName', handler)
+        if (args.length >= 2 && ts.isIdentifier(firstArg) && ts.isStringLiteral(args[1])) {
+            return args[1].text;
+        }
         // String literal: define('TypeName', ...)
         if (ts.isStringLiteral(firstArg)) {
             return firstArg.text;
@@ -508,7 +1068,7 @@ class MnemonicaAnalyzer {
         }
         // Arrow function returning class: define(() => class TypeName {})
         if (ts.isArrowFunction(firstArg)) {
-            const body = firstArg.body;
+            const { body } = firstArg;
             if (ts.isClassExpression(body) && body.name) {
                 return body.name.text;
             }
@@ -516,74 +1076,213 @@ class MnemonicaAnalyzer {
         return undefined;
     }
     /**
-     * Find parent type node for nested define calls
+     * Extract the full define() call context: type name, parent type, and collection.
+     * Handles direct calls, property-access calls, chained calls, and the
+     * explicit-source form `define(source, 'TypeName', handler)`.
      */
-    findParentType(call, _sourceFile) {
-        const expression = call.expression;
-        // Check for method call: SomeType.define('SubType', ...)
-        if (!ts.isPropertyAccessExpression(expression)) {
-            return undefined;
+    extractDefineContext(call) {
+        const typeName = this.extractTypeName(call);
+        if (!typeName) {
+            return {};
         }
-        // Get the object being called on (SomeType in SomeType.define)
-        const obj = expression.expression;
-        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)
-                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;
+        const { expression } = call;
+        // Direct call: define('TypeName', ...) or define(source, 'TypeName', handler)
+        if (ts.isIdentifier(expression) && expression.text === 'define') {
+            // Explicit-source form: define(source, 'TypeName', handler)
+            if (call.arguments.length >= 2 && ts.isIdentifier(call.arguments[0])) {
+                const sourceName = call.arguments[0].text;
+                const sourceContext = this.resolveDefineSource(sourceName);
+                return {
+                    typeName,
+                    parentType: sourceContext.parentType,
+                    collectionId: sourceContext.collectionId,
+                };
+            }
+            // Plain root define in default collection
+            return { typeName };
+        }
+        // Property access: X.define('TypeName', ...)
+        if (ts.isPropertyAccessExpression(expression) && expression.name.text === 'define') {
+            const obj = expression.expression;
+            if (ts.isIdentifier(obj)) {
+                const sourceContext = this.resolveDefineSource(obj.text);
+                return {
+                    typeName,
+                    parentType: sourceContext.parentType,
+                    collectionId: sourceContext.collectionId,
+                };
+            }
+            if (ts.isPropertyAccessExpression(obj)) {
+                // Nested access: instance.Type.define - try to resolve
+                const chain = this.getPropertyChain(obj);
+                if (chain.length > 0) {
+                    const parentNode = this.graph.findType(chain.join('.'));
+                    return { typeName, parentType: parentNode };
                 }
             }
+            if (ts.isCallExpression(obj)) {
+                // Determine the collection context from the root of the chain so that
+                // custom-collection types do not get confused with default-collection types.
+                const rootId = this.getRootIdentifier(obj.expression);
+                const expectedCollectionId = rootId
+                    ? this.resolveDefineSource(rootId.text).collectionId
+                    : undefined;
+                // Chained call: define('A').define('B') or mnemonica.define('A').define('B')
+                if (this.isDefineCall(obj)) {
+                    this.processDefineCall(obj, call.getSourceFile());
+                    const parentTypeName = this.extractTypeName(obj);
+                    if (parentTypeName) {
+                        const parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);
+                        // Inherit collection from the parent type (if any)
+                        return { typeName, parentType: parentNode, collectionId: parentNode?.collectionId };
+                    }
+                }
+                // Chained lazy call: lazy('A').define('B') or Type.lazy('A').define('B')
+                if (this.isLazyCall(obj)) {
+                    this.processLazyCall(obj, call.getSourceFile());
+                    const parentTypeName = this.extractMnemonicaTypeName(obj);
+                    if (parentTypeName) {
+                        const parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);
+                        return { typeName, parentType: parentNode, collectionId: parentNode?.collectionId };
+                    }
+                }
+                // Builder lookup chain: App.lookup('User').define('Admin')
+                if (this.isLookupCall(obj)) {
+                    const lookedUpPath = this.resolveLookupPath(obj);
+                    if (lookedUpPath) {
+                        const parentNode = this.graph.findType(lookedUpPath);
+                        if (parentNode) {
+                            return { typeName, parentType: parentNode, collectionId: parentNode.collectionId };
+                        }
+                    }
+                }
+            }
+        }
+        return { typeName };
+    }
+    /**
+     * Prefix a dotted type path with a collection identifier so custom-collection
+     * types do not collide with default-collection types in the graph.
+     */
+    prefixCollectionPath(path, collectionId) {
+        return `${collectionId}::${path}`;
+    }
+    /**
+     * Resolve a define() source identifier to either a parent type, a collection,
+     * or the default (module object) collection.
+     */
+    resolveDefineSource(sourceName) {
+        // Module object aliases -> root in default collection
+        if (this.moduleObjectVariables.has(sourceName)) {
+            return {};
+        }
+        // Collection variables -> root in that collection
+        const collectionId = this.collectionVariables.get(sourceName);
+        if (collectionId) {
+            return { collectionId };
+        }
+        // Otherwise treat as a type variable reference
+        const parentNode = this.findParentTypeByIdentifier(sourceName);
+        return { parentType: parentNode, collectionId: parentNode?.collectionId };
+    }
+    /**
+     * Check if a call expression is a lookup() call.
+     */
+    isLookupCall(node) {
+        const expr = node.expression;
+        if (ts.isIdentifier(expr) && expr.text === 'lookup') {
+            return true;
+        }
+        if (ts.isPropertyAccessExpression(expr) && expr.name.text === 'lookup') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Resolve a lookup() call to a dotted type path (best effort).
+     * Handles:
+     *   lookup('User')
+     *   lookup(source, 'User')
+     *   App.lookup('User')
+     *   collection.lookup('User.Admin')
+     */
+    resolveLookupPath(call) {
+        const args = call.arguments;
+        if (args.length === 0) {
             return undefined;
         }
-        if (ts.isPropertyAccessExpression(obj)) {
-            // Nested access: instance.Type.define - try to resolve
-            const chain = this.getPropertyChain(obj);
-            if (chain.length > 0) {
-                return this.graph.findType(chain.join('.'));
+        // Single-arg lookup: lookup('User') or App.lookup('User')
+        if (args.length === 1) {
+            const arg = args[0];
+            if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+                const path = arg.text;
+                // If this is a method call on a source, resolve relative to that source.
+                if (ts.isPropertyAccessExpression(call.expression)) {
+                    const sourceExpr = call.expression.expression;
+                    if (ts.isIdentifier(sourceExpr)) {
+                        const sourceName = sourceExpr.text;
+                        const sourceContext = this.resolveDefineSource(sourceName);
+                        if (sourceContext.collectionId) {
+                            // Collection lookup: prefix path with the collection id
+                            return this.prefixCollectionPath(path, sourceContext.collectionId);
+                        }
+                        if (sourceContext.parentType) {
+                            // Type lookup: relative first, then root fallback
+                            const relativePath = `${sourceContext.parentType.fullPath}.${path}`;
+                            if (this.graph.findType(relativePath)) {
+                                return relativePath;
+                            }
+                            return path;
+                        }
+                    }
+                }
+                return path;
             }
+            return undefined;
         }
-        // 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);
+        // Two-arg lookup: lookup(source, 'User')
+        if (args.length >= 2) {
+            const sourceArg = args[0];
+            const pathArg = args[1];
+            if (!ts.isIdentifier(sourceArg) || !ts.isStringLiteral(pathArg)) {
+                return undefined;
+            }
+            const sourceName = sourceArg.text;
+            const path = pathArg.text;
+            const sourceContext = this.resolveDefineSource(sourceName);
+            if (sourceContext.collectionId) {
+                return this.prefixCollectionPath(path, sourceContext.collectionId);
+            }
+            if (sourceContext.parentType) {
+                const relativePath = `${sourceContext.parentType.fullPath}.${path}`;
+                if (this.graph.findType(relativePath)) {
+                    return relativePath;
                 }
+                return path;
             }
+            return path;
         }
         return undefined;
     }
     /**
-        * Find a parent type by its name, searching in the graph
+        * Find a parent type by its name, searching in the graph.
+        * When collectionId is provided, only types from that collection are considered.
         */
-    findParentTypeByName(name) {
-        // First try exact match
+    findParentTypeByName(name, collectionId) {
+        const matchesCollection = (type) => {
+            if (collectionId === undefined) {
+                return type.collectionId === undefined;
+            }
+            return type.collectionId === collectionId;
+        };
+        // First try exact match (default-collection types use the plain dotted path)
         const exact = this.graph.findType(name);
-        if (exact)
+        if (exact && matchesCollection(exact)) {
             return exact;
-        // Then search through all types for one with matching name
+        }
+        // Then search through all types for one with matching name and collection
         for (const type of this.graph.getAllTypes()) {
-            if (type.name === name) {
+            if (type.name === name && matchesCollection(type)) {
                 return type;
             }
         }
@@ -605,6 +1304,20 @@ class MnemonicaAnalyzer {
         const parentNode = this.findParentTypeByName(name);
         return parentNode;
     }
+    /**
+     * Get the leftmost identifier of a property-access chain.
+     * For `App.define('User').define('Admin')` this returns the `App` identifier.
+     */
+    getRootIdentifier(expr) {
+        let current = expr;
+        while (ts.isPropertyAccessExpression(current)) {
+            current = current.expression;
+        }
+        if (ts.isIdentifier(current)) {
+            return current;
+        }
+        return undefined;
+    }
     /**
         * Get property chain from nested access
         */
@@ -622,23 +1335,61 @@ class MnemonicaAnalyzer {
         }
         return chain;
     }
+    /**
+     * Determine the constructor expression for either a define() or lazy() call.
+     * For define() this is the construct handler; for lazy() it is the value
+     * returned by the lazy getter.
+     */
+    extractConstructorExpression(call) {
+        const expr = call.expression;
+        const name = ts.isIdentifier(expr)
+            ? expr.text
+            : ts.isPropertyAccessExpression(expr)
+                ? expr.name.text
+                : '';
+        if (name === 'lazy') {
+            const lazyArgs = this.extractLazyCallArgs(call);
+            if (!lazyArgs) {
+                return undefined;
+            }
+            return this.unwrapLazyGetter(lazyArgs.getter);
+        }
+        // define() call
+        const args = call.arguments;
+        if (args.length === 0) {
+            return undefined;
+        }
+        // Modern form: define('Name', handler, config?)
+        if (ts.isStringLiteral(args[0])) {
+            return args[1];
+        }
+        // Legacy form: define(function Name() {}) or define(() => class Name {})
+        return args[0];
+    }
     /**
      * Extract properties from constructor function
      */
     extractProperties(call) {
-        const properties = new Map();
-        const handlerArg = call.arguments[1];
-        if (!handlerArg) {
-            return properties;
+        const constructorExpr = this.extractConstructorExpression(call);
+        if (!constructorExpr) {
+            return new Map();
         }
+        const result = this.extractPropertiesFromConstructor(constructorExpr);
+        return result;
+    }
+    /**
+     * Extract properties from a constructor expression (function, arrow, or class).
+     */
+    extractPropertiesFromConstructor(constructorExpr) {
+        const properties = new Map();
         // Build type map from data parameter (for this.x = data.x patterns)
-        const dataTypeMap = this.buildDataTypeMap(handlerArg);
+        const dataTypeMap = this.buildDataTypeMap(constructorExpr);
         // Handle function expression
-        if (ts.isFunctionExpression(handlerArg) || ts.isArrowFunction(handlerArg)) {
-            const body = handlerArg.body;
+        if (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {
+            const { body } = constructorExpr;
             // First, extract properties from `this` parameter type annotation
             // This handles patterns like: function(this: SomeType, data: SomeType) { }
-            const thisParamProperties = this.extractThisParamProperties(handlerArg);
+            const thisParamProperties = this.extractThisParamProperties(constructorExpr);
             for (const [name, propInfo] of thisParamProperties) {
                 properties.set(name, propInfo);
             }
@@ -652,16 +1403,18 @@ class MnemonicaAnalyzer {
             }
         }
         // Handle class expression
-        if (ts.isClassExpression(handlerArg)) {
+        if (ts.isClassExpression(constructorExpr)) {
             // First pass: collect all property types for method inference
-            const classPropertyTypes = this.extractClassPropertyTypes(handlerArg);
-            for (const member of handlerArg.members) {
+            const classPropertyTypes = this.extractClassPropertyTypes(constructorExpr);
+            for (const member of constructorExpr.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);
+                        const hasPrivateOrProtected = member.modifiers.some(m => {
+                            return m.kind === ts.SyntaxKind.PrivateKeyword ||
+                                m.kind === ts.SyntaxKind.ProtectedKeyword;
+                        });
                         if (hasPrivateOrProtected) {
                             continue;
                         }
@@ -679,8 +1432,10 @@ class MnemonicaAnalyzer {
                 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);
+                        const hasPrivateOrProtected = member.modifiers.some(m => {
+                            return m.kind === ts.SyntaxKind.PrivateKeyword ||
+                                m.kind === ts.SyntaxKind.ProtectedKeyword;
+                        });
                         if (hasPrivateOrProtected) {
                             continue;
                         }
@@ -697,8 +1452,10 @@ class MnemonicaAnalyzer {
                 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);
+                        const hasPrivateOrProtected = member.modifiers.some(m => {
+                            return m.kind === ts.SyntaxKind.PrivateKeyword ||
+                                m.kind === ts.SyntaxKind.ProtectedKeyword;
+                        });
                         if (hasPrivateOrProtected) {
                             continue;
                         }
@@ -792,7 +1549,7 @@ class MnemonicaAnalyzer {
         // Handle: this.property = value
         if (ts.isBinaryExpression(expr) &&
             expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-            const left = expr.left;
+            const { left } = expr;
             if (ts.isPropertyAccessExpression(left)) {
                 // Check if accessing 'this' (ThisKeyword)
                 if (left.expression.kind === ts.SyntaxKind.ThisKeyword) {
@@ -1037,7 +1794,7 @@ class MnemonicaAnalyzer {
             case ts.SyntaxKind.VoidKeyword:
                 return 'void';
             case ts.SyntaxKind.ArrayType:
-                return 'Array<' + this.inferType(typeNode.elementType) + '>';
+                return `Array<${this.inferType(typeNode.elementType)}>`;
             case ts.SyntaxKind.TypeLiteral: {
                 // Inline-expand type literals instead of collapsing to 'object'
                 const typeLit = typeNode;
@@ -1054,7 +1811,7 @@ class MnemonicaAnalyzer {
             }
             case ts.SyntaxKind.LiteralType: {
                 // Handle string literal types like 'user', 'admin', etc.
-                const literal = typeNode.literal;
+                const { literal } = typeNode;
                 if (ts.isStringLiteral(literal)) {
                     // Return the actual literal value (e.g., 'user' instead of string)
                     return `'${literal.text}'`;
@@ -1093,30 +1850,30 @@ class MnemonicaAnalyzer {
                     if (arg.kind === ts.SyntaxKind.TypeQuery) {
                         const typeQuery = arg;
                         if (ts.isIdentifier(typeQuery.exprName)) {
-                            const typeName = typeQuery.exprName.text;
+                            const queryTypeName = typeQuery.exprName.text;
                             // Look up the type in the graph to get full path
-                            const typeNode = this.graph.findTypeByName(typeName);
-                            if (typeNode) {
+                            const matchedType = this.graph.findTypeByName(queryTypeName);
+                            if (matchedType) {
                                 // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
-                                return typeNode.fullPath.replace(/\./g, '_');
+                                return matchedType.fullPath.replace(/\./g, '_');
                             }
                             // Fallback: just use the type name if not found in graph
-                            return typeName;
+                            return queryTypeName;
                         }
                     }
                 }
                 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) {
+                    const matchedType = this.graph.findTypeByName(typeName);
+                    if (matchedType) {
                         // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
-                        return typeNode.fullPath.replace(/\./g, "_");
+                        return matchedType.fullPath.replace(/\./g, '_');
                     }
                     return typeName;
                 }
                 // Build generic type arguments
-                const args = typeRef.typeArguments.map(arg => this.inferType(arg));
-                return `${typeName}<${args.join(', ')}>`;
+                const typeArgs = typeRef.typeArguments.map(arg => this.inferType(arg));
+                return `${typeName}<${typeArgs.join(', ')}>`;
             }
             case ts.SyntaxKind.UnionType: {
                 // Handle union types like 'a' | 'b' | 'c'
@@ -1139,12 +1896,12 @@ class MnemonicaAnalyzer {
             case ts.SyntaxKind.OptionalType: {
                 // Handle optional element in tuple: string?
                 const optionalType = typeNode;
-                return this.inferType(optionalType.type) + '?';
+                return `${this.inferType(optionalType.type)}?`;
             }
             case ts.SyntaxKind.RestType: {
                 // Handle rest element: ...T
                 const restType = typeNode;
-                return '...' + this.inferType(restType.type);
+                return `...${this.inferType(restType.type)}`;
             }
             case ts.SyntaxKind.ParenthesizedType: {
                 // Handle parenthesized types: (A | B)
@@ -1442,8 +2199,8 @@ class MnemonicaAnalyzer {
         }
     }
     /**
-        * Collect usage information for type references
-        */
+            * Collect usage information for type references
+            */
     collectUsage(node, sourceFile) {
         // Check for new Type() instantiation
         if (ts.isNewExpression(node) && node.expression) {
@@ -1489,13 +2246,12 @@ class MnemonicaAnalyzer {
                 }
             }
         }
-        // Check for lookup('TypeName') calls
+        // Check for lookup('TypeName') or lookup(source, 'TypeName') calls
         if (ts.isCallExpression(node) && node.expression) {
             const funcName = this.getFunctionName(node.expression);
             if (funcName === 'lookup' && node.arguments.length > 0) {
-                const firstArg = node.arguments[0];
-                if (ts.isStringLiteral(firstArg) || ts.isNoSubstitutionTemplateLiteral(firstArg)) {
-                    const typePath = firstArg.text;
+                const typePath = this.resolveLookupPath(node);
+                if (typePath) {
                     const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
                     this.addUsage(typePath, {
                         location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
@@ -1509,8 +2265,8 @@ class MnemonicaAnalyzer {
         }
     }
     /**
-        * Get function name from expression (identifier or property access)
-        */
+            * Get function name from expression (identifier or property access)
+            */
     getFunctionName(expr) {
         if (ts.isIdentifier(expr)) {
             return expr.text;
@@ -1521,8 +2277,8 @@ class MnemonicaAnalyzer {
         return undefined;
     }
     /**
-        * Add a usage to the collection
-        */
+            * Add a usage to the collection
+            */
     addUsage(typePath, usage) {
         // Only track usages of mnemonica-defined types
         if (!this.definitions.has(typePath)) {
@@ -1624,7 +2380,9 @@ class MnemonicaAnalyzer {
             return;
         }
         // Adapters: createDiveInterceptor, createDivePlugin, createDiveMiddleware
-        if (funcName === 'createDiveInterceptor' || funcName === 'createDivePlugin' || funcName === 'createDiveMiddleware') {
+        if (funcName === 'createDiveInterceptor' ||
+            funcName === 'createDivePlugin' ||
+            funcName === 'createDiveMiddleware') {
             this.addEDS('unknown', {
                 location,
                 kind: 'adapterUse',
@@ -1670,7 +2428,11 @@ class MnemonicaAnalyzer {
             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);
+        const isDuplicate = existing.some(e => {
+            return e.location === info.location &&
+                e.kind === info.kind &&
+                e.code === info.code;
+        });
         if (!isDuplicate) {
             existing.push(info);
         }
@@ -1730,7 +2492,7 @@ class MnemonicaAnalyzer {
         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') {
+        if (propName === 'define' || propName === 'lazy') {
             return;
         }
         this.addFlow(objectType, {
@@ -1816,7 +2578,7 @@ class MnemonicaAnalyzer {
         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') {
+        if (methodName === 'define' || methodName === 'lazy') {
             return;
         }
         this.addFlow(objectType, {
@@ -1945,7 +2707,11 @@ class MnemonicaAnalyzer {
             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);
+        const isDuplicate = existing.some(e => {
+            return e.location === info.location &&
+                e.kind === info.kind &&
+                e.code === info.code;
+        });
         if (!isDuplicate) {
             existing.push(info);
         }
@@ -1970,8 +2736,8 @@ class MnemonicaAnalyzer {
         return undefined;
     }
     /**
-        * Resolve full type path from property access
-        */
+            * Resolve full type path from property access
+            */
     resolveTypePath(expr) {
         const chain = this.getPropertyChain(expr);
         if (chain.length === 0)
@@ -1991,15 +2757,15 @@ class MnemonicaAnalyzer {
         return fullPath;
     }
     /**
-         * Check if a name looks like a type (starts with uppercase)
-         */
+             * Check if a name looks like a type (starts with uppercase)
+             */
     isLikelyTypeName(name) {
         return name[0] >= 'A' && name[0] <= 'Z';
     }
     /**
-         * Resolve a constructor parameter type, expanding inline object literals
-         * and type aliases where possible.
-         */
+             * Resolve a constructor parameter type, expanding inline object literals
+             * and type aliases where possible.
+             */
     resolveConstructorParamType(typeNode) {
         if (!typeNode)
             return undefined;
@@ -2028,15 +2794,15 @@ class MnemonicaAnalyzer {
             // 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}<${args.join(', ')}>`;
             }
             return typeName;
         }
         return undefined;
     }
     /**
-         * Extract constructor parameters from a class-like node.
-         */
+             * Extract constructor parameters from a class-like node.
+             */
     extractClassConstructorParams(classLike) {
         const params = [];
         for (const member of classLike.members) {
@@ -2061,25 +2827,35 @@ class MnemonicaAnalyzer {
         return params;
     }
     /**
-         * Extract constructor parameters from define() call
-         * This is used for TypeRegistry constructor signatures
-         * Preserves parameter names and expands object types to their structure
-         */
+             * 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 constructorExpr = this.extractConstructorExpression(call);
+        if (!constructorExpr) {
+            return [];
+        }
+        const result = this.extractConstructorParamsFromConstructor(constructorExpr);
+        return result;
+    }
+    /**
+             * Extract constructor parameters from a constructor expression.
+             */
+    extractConstructorParamsFromConstructor(constructorExpr) {
         const params = [];
-        const handlerArg = call.arguments[1];
-        if (!handlerArg)
-            return params;
         // Handle function expression or arrow function
-        if (ts.isFunctionExpression(handlerArg) || ts.isArrowFunction(handlerArg)) {
+        if (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {
             // 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];
+            for (let i = 0; i < constructorExpr.parameters.length; i++) {
+                const param = constructorExpr.parameters[i];
                 if (!param.type)
                     continue;
                 // Skip `this` parameter (first param)
-                if (i === 0 && param.name.kind === ts.SyntaxKind.Identifier && param.name.text === 'this') {
+                if (i === 0 &&
+                    param.name.kind === ts.SyntaxKind.Identifier &&
+                    param.name.text === 'this') {
                     continue;
                 }
                 // Get parameter name and expand its type
@@ -2093,8 +2869,8 @@ class MnemonicaAnalyzer {
             }
         }
         // Handle class expression - check constructor method
-        if (ts.isClassExpression(handlerArg)) {
-            const classParams = this.extractClassConstructorParams(handlerArg);
+        if (ts.isClassExpression(constructorExpr)) {
+            const classParams = this.extractClassConstructorParams(constructorExpr);
             for (const param of classParams) {
                 params.push(param);
             }