@mnemonica/tactica 0.3.0 → 0.3.7

package/lib/analyzer.js

@@ -38,6 +38,32 @@ const nodePath = __importStar(require("path"));
 const ts = __importStar(require("typescript"));
 const graph_1 = require("./graph");
 const plugins_1 = require("./plugins");
+/**
+ * Global/builtin type names that are safe to emit bare into generated files
+ * — they resolve in any TypeScript compilation without an import.
+ */
+const KNOWN_GLOBAL_TYPES = new Set([
+    'Date', 'RegExp', 'Error', 'EvalError', 'RangeError', 'ReferenceError',
+    'SyntaxError', 'TypeError', 'URIError', 'AggregateError',
+    'Map', 'Set', 'WeakMap', 'WeakSet', 'WeakRef', 'FinalizationRegistry',
+    'Promise', 'Array', 'ReadonlyArray', 'Record', 'Partial', 'Required',
+    'Readonly', 'Pick', 'Omit', 'Exclude', 'Extract', 'NonNullable',
+    'ReturnType', 'InstanceType', 'Parameters', 'ConstructorParameters',
+    'ThisType', 'ThisParameterType', 'OmitThisParameter',
+    'Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize',
+    'String', 'Number', 'Boolean', 'Symbol', 'BigInt', 'Object', 'Function',
+    'Iterable', 'Iterator', 'Generator', 'AsyncIterable', 'AsyncIterator',
+    'AsyncGenerator', 'IterableIterator', 'AsyncIterableIterator',
+    'PropertyKey', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView',
+    'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array',
+    'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array',
+    'Float64Array', 'BigInt64Array', 'BigUint64Array', 'Intl'
+]);
+// Bound for chasing re-export barrels (export { X } from '…', export * from '…')
+const MAX_REEXPORT_CHASE_DEPTH = 5;
+// Bound for walking class/interface extends chains during referenced-type
+// expansion (inherited members merge into the expanded fields)
+const MAX_HERITAGE_DEPTH = 8;
 /**
  * AST Analyzer for finding Mnemonica define() and decorate() calls
  *
@@ -61,14 +87,15 @@ class MnemonicaAnalyzer {
         // Same-file function bindings (`fileName#name` -> function node) for
         // resolving wrap(fn) arguments syntactically — the checker stays unused
         this.functionBindings = new Map();
-        // wrap call node -> location of the enclosing wrap site, so nested
-        // wrap() calls inside a wrapped body carry the `via` link
+        // wrap call node -> location of the enclosing wrap site (plus that
+        // site's scope attribution), so nested wrap() calls inside a wrapped
+        // body carry the `via` link — and inherit the scope when they have
+        // none of their own
         this.nestedWrapVia = new Map();
         // wrap call node -> its collected entry, so a lexically nested wrap
         // (visited BEFORE the outer wrap call, per source order) gets its
         // `via` back-patched when the outer body is analysed
         this.wrapEntryByNode = new Map();
-        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)
@@ -87,8 +114,88 @@ class MnemonicaAnalyzer {
         // Registration sites: decorator applications, provider-token object
         // literals, consumer.apply() middleware wiring
         this.instrumentationSites = [];
-        // Store program for future use (currently unused but kept for extensibility)
-        void program;
+        // Referenced-type resolution (F10): per-file declarations and imports.
+        // A type name used in file X resolves through X's own import statements
+        // first (relative + tsconfig-paths, via ts.resolveModuleName), then
+        // X's local declarations, then — only when nothing imports or declares
+        // the name — the unique same-named declaration across scanned files.
+        // Genuine ambiguity or an unresolvable reference yields `unknown`, never
+        // a bare emitted name: generated types.ts carries no imports of its own.
+        this.referencedTypeDecls = new Map();
+        this.referencedTypeImports = new Map();
+        // file -> (exported name -> re-export specifier) for `export { X } from '…'`
+        this.referencedTypeReExports = new Map();
+        // file -> specifiers of `export * from '…'`
+        this.referencedTypeExportStars = new Map();
+        // file -> (exported name -> local name) for `export { X as Y }`
+        this.referencedTypeExportAliases = new Map();
+        // file -> (namespace name -> namespace declaration) — middle segments
+        // of qualified references (models.Inner.Crate) descend through these
+        this.referencedTypeNamespaces = new Map();
+        // file -> (namespace name -> specifier) for `export * as ns from '…'`
+        // barrels — a nested module namespace one segment deep
+        this.referencedTypeNamespaceStars = new Map();
+        // `${containingFile}::${specifier}` -> resolution (undefined = failed)
+        this.referencedTypeResolutionCache = new Map();
+        // file -> (const name -> array literal) for consts with array-literal
+        // initializers (`as const` / `satisfies` unwrapped), so a
+        // `typeof statusList[number]` field type expands to the element literal
+        // union instead of leaking a bare unresolvable `typeof` query into the
+        // generated file. Declarations persist across passes — entries stay
+        // valid after resetUsages(), same as referencedTypeDecls
+        this.referencedTypeConstArrays = new Map();
+        // File whose AST is currently being visited; references resolve against it
+        this.currentReferencedTypeFile = '';
+        // Alias names currently being expanded (cycle guard)
+        this.expandingReferencedAliases = new Set();
+        // Mnemonica-graph identity law (hard fail): every define()/lazy()/
+        // @decorate() site keyed by its runtime namespace (collection roots:
+        // `<collection>::<name>`; subtypes: `<parentFullPath>.<name>`). Two
+        // sites in one namespace are a same-namespace duplicate — the runtime
+        // throws ALREADY_DECLARED — and must abort generation.
+        this.defineSites = new Map();
+        // Mnemonica-graph references that stayed ambiguous after path-aware
+        // resolution or resolved to nothing (hard-fail class 2)
+        this.graphReferenceErrors = [];
+        // Guards lookup()-path validation so it runs once per usages pass
+        // (getResolutionErrors may be called repeatedly); resetUsages re-arms it
+        this.lookupReferencesValidated = false;
+        // Literal lookup() call sites with their resolved paths. Kept apart from
+        // the usages map on purpose: addUsage drops paths the graph does not
+        // know (usages.json indexes references to KNOWN types), but an unknown
+        // lookup path is exactly the hard-fail case — the runtime returns
+        // undefined there and the TypeError arrives one line later
+        this.lookupReferences = [];
+        // Guards plain-TS reference validation so it runs once per usages pass
+        // (getResolutionErrors may be called repeatedly); resetUsages re-arms it
+        this.plainTypeReferencesValidated = false;
+        // Plain-TS type reference sites whose resolution fell through imports,
+        // locals, the program-wide scan, and the graph to a soft `unknown`.
+        // Validated lazily from getResolutionErrors against the complete
+        // declaration map: a name several project-source files declare — with
+        // no import in the referencing file to anchor it — is the plain-TS
+        // ambiguity hard-fail class (one tier below the graph identity law);
+        // absence (ghost names) stays soft. Recording happens on every pass,
+        // the verdict only here — pass 1 sees an incomplete declaration map,
+        // so only the usages pass is authoritative (mirrors lookup references)
+        this.plainTypeReferences = [];
+        // Per-file top-level variable -> mnemonica fullPath bindings (value
+        // scope): `const Address = User.define('Address', …)` makes `Address`
+        // denote User.Address wherever that file's references are resolved
+        this.fileGraphBindings = new Map();
+        // define()/lazy() calls already extracted this pass. The CLI re-analyzes
+        // every file after resetUsages(); clearing the set lets the second pass
+        // re-extract every constructor against the COMPLETE graph — pass 1 sees
+        // forward references as `none` (soft unknown) because later files have
+        // not been visited yet, so only pass-2 resolution is authoritative for
+        // the hard-fail identity law. The stamp lives here rather than on the
+        // AST node so it can actually be cleared. (Chained calls visit the same
+        // node twice within one pass; the in-pass dedup below stays.)
+        this.processedCalls = new Set();
+        // Compiler options drive ts.resolveModuleName for import-aware
+        // referenced-type resolution (tsconfig `paths`, extensionless
+        // imports); the type checker itself stays unused.
+        this.referencedTypeCompilerOptions = program?.getCompilerOptions() ?? {};
         this.instrumentationVocabulary = (0, plugins_1.mergeTacticaPlugins)(plugins);
     }
     /**
@@ -106,12 +213,25 @@ class MnemonicaAnalyzer {
         this.nestedWrapVia.clear();
         // Note: moduleObjectVariables and collectionVariables intentionally persist
         // across definition and usage passes.
+        // Re-extraction in the usages pass is what makes graph reference
+        // resolution authoritative: pass 1 resolves against an incomplete
+        // graph (forward references read as `none`), pass 2 against all of it.
+        this.processedCalls.clear();
+        // lookup()-path validation runs against the recorded sites; a fresh
+        // pass must re-record and re-validate (pass-1 results would be
+        // premature — the graph is still incomplete)
+        this.lookupReferencesValidated = false;
+        this.lookupReferences = [];
+        this.plainTypeReferencesValidated = false;
+        this.plainTypeReferences = [];
     }
     /**
      * Analyze a source file for Mnemonica type definitions
      */
     analyzeFile(sourceFile) {
         this.errors = [];
+        // Referenced-type names in this file resolve against its own imports
+        this.currentReferencedTypeFile = nodePath.resolve(sourceFile.fileName);
         // Ensure parent nodes are set for AST traversal
         this.setParentNodesInSourceFile(sourceFile);
         this.visitNode(sourceFile, sourceFile);
@@ -282,10 +402,12 @@ class MnemonicaAnalyzer {
         // Check for framework instrumentation points (vocabulary supplied
         // by plugins; syntactic only — no type checker)
         this.collectInstrumentation(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);
-        }
+        // Collect referenced-type declarations (aliases, classes, interfaces)
+        // per file, and the file's import wiring, for import-aware resolution
+        this.trackReferencedTypeDeclaration(node);
+        this.trackReferencedTypeImport(node);
+        this.trackReferencedTypeReExport(node);
+        this.trackReferencedTypeConstArray(node);
         // Track same-file function bindings so EDS can resolve wrap(fn)
         // arguments without the type checker (best effort, last wins)
         if (ts.isFunctionDeclaration(node) && node.name) {
@@ -349,6 +471,1104 @@ class MnemonicaAnalyzer {
             this.moduleObjectVariables.add(clause.name.text);
         }
     }
+    /**
+     * Record a named referenced-type declaration (type alias, class, or
+     * interface) for the file currently being visited.
+     */
+    trackReferencedTypeDeclaration(node) {
+        // Namespaces are the middle segments of qualified references
+        // (models.Inner.Crate) — recorded separately from the plain-name
+        // declaration table (string-named `module '…'` declarations are
+        // ambient externals and stay out)
+        if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name) &&
+            node.body && ts.isModuleBlock(node.body)) {
+            const namespaceFilePath = this.currentReferencedTypeFile;
+            let namespaces = this.referencedTypeNamespaces.get(namespaceFilePath);
+            if (!namespaces) {
+                namespaces = new Map();
+                this.referencedTypeNamespaces.set(namespaceFilePath, namespaces);
+            }
+            namespaces.set(node.name.text, node);
+            return;
+        }
+        let name = '';
+        let kind;
+        let declNode;
+        if (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name)) {
+            name = node.name.text;
+            kind = 'alias';
+            declNode = node;
+        }
+        else if (ts.isClassDeclaration(node) && node.name) {
+            name = node.name.text;
+            kind = 'class';
+            declNode = node;
+        }
+        else if (ts.isInterfaceDeclaration(node) && ts.isIdentifier(node.name)) {
+            name = node.name.text;
+            kind = 'interface';
+            declNode = node;
+        }
+        if (!kind || !declNode || !name) {
+            return;
+        }
+        const filePath = this.currentReferencedTypeFile;
+        let decls = this.referencedTypeDecls.get(filePath);
+        if (!decls) {
+            decls = new Map();
+            this.referencedTypeDecls.set(filePath, decls);
+        }
+        const entry = { kind, node: declNode, file: filePath };
+        decls.set(name, entry);
+        // `export default class Foo {}` is also reachable under the 'default'
+        // binding for default importers
+        if (kind === 'class') {
+            const classNode = declNode;
+            const isExported = classNode.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+            const isDefault = classNode.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+            if (isExported && isDefault) {
+                decls.set('default', entry);
+            }
+        }
+    }
+    /**
+     * Record consts initialized with an array literal (optionally wrapped in
+     * `as const` / `satisfies`), so a `typeof statusList[number]` field type
+     * expands to the element literal union — the generated file carries no
+     * imports, so emitting the bare `typeof statusList` query would be an
+     * unresolvable name downstream. First binding wins: a nested shadow
+     * must not replace the module-level const the typeof refers to.
+     */
+    trackReferencedTypeConstArray(node) {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer) {
+            return;
+        }
+        const { initializer: rawInitializer } = node;
+        let initializer = rawInitializer;
+        while (ts.isAsExpression(initializer) || ts.isSatisfiesExpression(initializer)) {
+            initializer = initializer.expression;
+        }
+        if (!ts.isArrayLiteralExpression(initializer)) {
+            return;
+        }
+        const filePath = this.currentReferencedTypeFile;
+        let consts = this.referencedTypeConstArrays.get(filePath);
+        if (!consts) {
+            consts = new Map();
+            this.referencedTypeConstArrays.set(filePath, consts);
+        }
+        if (!consts.has(node.name.text)) {
+            consts.set(node.name.text, initializer);
+        }
+    }
+    /**
+     * Find the array literal behind a module const referenced through
+     * `typeof`: the declaring file's own consts first (the F13 case is a
+     * NON-exported const in the same module as the expanded class), then —
+     * when the file imports the name — the imported module's consts.
+     * External modules are never analyzed, so those yield nothing.
+     */
+    findReferencedConstArray(name, fromFile) {
+        const local = this.referencedTypeConstArrays.get(fromFile)?.get(name);
+        if (local) {
+            return local;
+        }
+        const imported = this.referencedTypeImports.get(fromFile)?.get(name);
+        if (!imported || imported.isNamespace) {
+            return undefined;
+        }
+        const resolution = this.resolveReferencedTypeModule(imported.specifier, fromFile);
+        if (!resolution || resolution.isExternal) {
+            return undefined;
+        }
+        const found = this.referencedTypeConstArrays.get(resolution.resolvedPath)?.get(imported.originalName);
+        return found;
+    }
+    /**
+     * Element literal types of a tracked const array: every element must be
+     * a plain literal (optionally wrapped in `as const` / `satisfies`) —
+     * string, numeric, boolean, or null. Spreads, identifiers, and nested
+     * arrays mean the union is not statically visible and yield undefined,
+     * so the caller degrades the field to `unknown` rather than guessing.
+     */
+    literalTypesOfArray(arrayLiteral) {
+        const literals = [];
+        for (const element of arrayLiteral.elements) {
+            if (ts.isSpreadElement(element)) {
+                return undefined;
+            }
+            let expr = element;
+            while (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) {
+                expr = expr.expression;
+            }
+            if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+                literals.push(`'${expr.text}'`);
+            }
+            else if (ts.isNumericLiteral(expr)) {
+                literals.push(expr.text);
+            }
+            else if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+                literals.push('true');
+            }
+            else if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+                literals.push('false');
+            }
+            else if (expr.kind === ts.SyntaxKind.NullKeyword) {
+                literals.push('null');
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (literals.length === 0) {
+            return undefined;
+        }
+        const result = literals;
+        return result;
+    }
+    /**
+     * Emit-type for `typeof name` when `name` is a tracked const array: the
+     * union of its element literal types (`'active' | 'closed'`). Every
+     * other typeof source — non-array consts, functions, classes, names not
+     * tracked at all — yields undefined, so the caller degrades the field
+     * to `unknown`: a bare `typeof name` emitted into types.ts has no
+     * import to resolve against downstream.
+     */
+    typeOfConstArrayUnion(name, fromFile) {
+        const arrayLiteral = this.findReferencedConstArray(name, fromFile);
+        if (!arrayLiteral) {
+            return undefined;
+        }
+        const literals = this.literalTypesOfArray(arrayLiteral);
+        if (!literals) {
+            return undefined;
+        }
+        const union = literals.join(' | ');
+        return union;
+    }
+    /**
+     * Record the importing file's named/namespace/default import bindings so
+     * referenced-type names resolve through the file's own import statements
+     * (F10) rather than a program-wide name map.
+     */
+    trackReferencedTypeImport(node) {
+        if (!ts.isImportDeclaration(node)) {
+            return;
+        }
+        const { moduleSpecifier } = node;
+        if (!ts.isStringLiteral(moduleSpecifier)) {
+            return;
+        }
+        const clause = node.importClause;
+        if (!clause) {
+            return;
+        }
+        const filePath = this.currentReferencedTypeFile;
+        let imports = this.referencedTypeImports.get(filePath);
+        if (!imports) {
+            imports = new Map();
+            this.referencedTypeImports.set(filePath, imports);
+        }
+        // import { SharedShape } from '…' / import { SharedShape as S } from '…'
+        if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            for (const element of clause.namedBindings.elements) {
+                const localName = element.name.text;
+                const originalName = element.propertyName ? element.propertyName.text : localName;
+                imports.set(localName, {
+                    originalName,
+                    specifier: moduleSpecifier.text,
+                    isNamespace: false
+                });
+            }
+        }
+        // import * as models from '…' — resolved when a qualified name
+        // (models.SharedShape) is encountered
+        if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+            imports.set(clause.namedBindings.name.text, {
+                originalName: '',
+                specifier: moduleSpecifier.text,
+                isNamespace: true
+            });
+        }
+        // import SharedShape from '…' (default import)
+        if (clause.name) {
+            imports.set(clause.name.text, {
+                originalName: 'default',
+                specifier: moduleSpecifier.text,
+                isNamespace: false
+            });
+        }
+    }
+    /**
+     * Record re-export wiring (`export { X } from '…'`, `export * from '…'`,
+     * `export { X as Y }`) so resolution can chase barrels to the origin
+     * module. Mirrors ModuleGraphBuilder.resolveOrigin, name-based only.
+     */
+    trackReferencedTypeReExport(node) {
+        if (!ts.isExportDeclaration(node)) {
+            return;
+        }
+        const filePath = this.currentReferencedTypeFile;
+        const { moduleSpecifier } = node;
+        const specifierText = moduleSpecifier && ts.isStringLiteral(moduleSpecifier)
+            ? moduleSpecifier.text
+            : undefined;
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+            for (const element of node.exportClause.elements) {
+                const exportedName = element.name.text;
+                const localName = element.propertyName ? element.propertyName.text : exportedName;
+                if (specifierText) {
+                    // export { X } from '…' / export { X as Y } from '…'
+                    let reExports = this.referencedTypeReExports.get(filePath);
+                    if (!reExports) {
+                        reExports = new Map();
+                        this.referencedTypeReExports.set(filePath, reExports);
+                    }
+                    reExports.set(exportedName, specifierText);
+                }
+                else if (localName !== exportedName) {
+                    // export { X as Y } — same-file alias of a local declaration
+                    let aliases = this.referencedTypeExportAliases.get(filePath);
+                    if (!aliases) {
+                        aliases = new Map();
+                        this.referencedTypeExportAliases.set(filePath, aliases);
+                    }
+                    aliases.set(exportedName, localName);
+                }
+            }
+            return;
+        }
+        if (node.exportClause && ts.isNamespaceExport(node.exportClause)) {
+            // `export * as ns from '…'` — a nested module namespace; middle
+            // segments of qualified references (barrel.Deep.Gadget) chase it
+            if (specifierText) {
+                let stars = this.referencedTypeNamespaceStars.get(filePath);
+                if (!stars) {
+                    stars = new Map();
+                    this.referencedTypeNamespaceStars.set(filePath, stars);
+                }
+                stars.set(node.exportClause.name.text, specifierText);
+            }
+            return;
+        }
+        if (!node.exportClause && specifierText) {
+            // export * from '…'
+            let stars = this.referencedTypeExportStars.get(filePath);
+            if (!stars) {
+                stars = [];
+                this.referencedTypeExportStars.set(filePath, stars);
+            }
+            stars.push(specifierText);
+        }
+    }
+    /**
+     * Resolve a module specifier from a containing file with the program's
+     * compilerOptions (tsconfig `paths`, extensionless imports, index files).
+     * Module resolution only — the no-getTypeChecker() precedent stays.
+     */
+    resolveReferencedTypeModule(specifier, containingFile) {
+        const cacheKey = `${containingFile}::${specifier}`;
+        if (this.referencedTypeResolutionCache.has(cacheKey)) {
+            const cached = this.referencedTypeResolutionCache.get(cacheKey);
+            return cached === undefined ? undefined : cached;
+        }
+        const resolution = ts.resolveModuleName(specifier, containingFile, this.referencedTypeCompilerOptions, ts.sys).resolvedModule;
+        const result = resolution
+            ? {
+                resolvedPath: nodePath.resolve(resolution.resolvedFileName),
+                isExternal: !!resolution.isExternalLibraryImport
+            }
+            : undefined;
+        this.referencedTypeResolutionCache.set(cacheKey, result);
+        const finalResult = result;
+        return finalResult;
+    }
+    /**
+     * Look up a name in one resolved module, chasing re-export barrels with a
+     * bounded depth. External (node_modules) modules hold no in-project
+     * declarations and stop the chase.
+     */
+    findReferencedTypeInModule(modulePath, name, depth) {
+        if (depth > MAX_REEXPORT_CHASE_DEPTH) {
+            return undefined;
+        }
+        const decls = this.referencedTypeDecls.get(modulePath);
+        const direct = decls?.get(name);
+        if (direct) {
+            return direct;
+        }
+        // export { X as Y } — resolve through the local name
+        const localAlias = this.referencedTypeExportAliases.get(modulePath)?.get(name);
+        if (localAlias) {
+            const aliased = decls?.get(localAlias);
+            if (aliased) {
+                return aliased;
+            }
+        }
+        const reExports = this.referencedTypeReExports.get(modulePath);
+        const reExportSpecifier = reExports?.get(name);
+        if (reExportSpecifier) {
+            const nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, modulePath);
+            if (nextResolution && !nextResolution.isExternal) {
+                const found = this.findReferencedTypeInModule(nextResolution.resolvedPath, name, depth + 1);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        const stars = this.referencedTypeExportStars.get(modulePath);
+        if (stars) {
+            for (const starSpecifier of stars) {
+                const nextResolution = this.resolveReferencedTypeModule(starSpecifier, modulePath);
+                if (!nextResolution || nextResolution.isExternal) {
+                    continue;
+                }
+                const found = this.findReferencedTypeInModule(nextResolution.resolvedPath, name, depth + 1);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Resolve a referenced type name as used in fromFile, import-aware:
+     *   1. the file's own import statements (relative + tsconfig paths,
+     *      chased through re-export barrels),
+     *   2. the file's local declarations,
+     *   3. the unique same-named declaration across scanned files.
+     * Returns undefined when nothing matches (or the match is ambiguous),
+     * in which case the caller falls back to `unknown`.
+     */
+    resolveReferencedTypeDeclaration(name, fromFile) {
+        // 1. the file's own imports win — an import is never shadowed by a
+        // same-named local declaration elsewhere in the program (F10)
+        const imported = this.referencedTypeImports.get(fromFile)?.get(name);
+        if (imported && !imported.isNamespace) {
+            const resolution = this.resolveReferencedTypeModule(imported.specifier, fromFile);
+            if (resolution && !resolution.isExternal) {
+                const found = this.findReferencedTypeInModule(resolution.resolvedPath, imported.originalName, 0);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        // 2. local declaration in the referencing file itself
+        const local = this.referencedTypeDecls.get(fromFile)?.get(name);
+        if (local) {
+            return local;
+        }
+        // 3. program-wide fallback, unique declaration only — ambiguity and
+        // absence both yield undefined (the caller emits `unknown`).
+        // External/ambient declarations (.d.ts, node_modules) do not
+        // participate: a user-local declaration always wins over a
+        // package-declared same-named type (the plain-TS tier of the
+        // identity law; ambiguity among the remaining declarations is
+        // validated separately as a hard fail)
+        let unique;
+        let count = 0;
+        for (const [filePath, decls] of this.referencedTypeDecls) {
+            if (this.isExternalDeclFile(filePath)) {
+                continue;
+            }
+            const candidate = decls.get(name);
+            if (candidate) {
+                count++;
+                unique = candidate;
+                if (count > 1) {
+                    return undefined;
+                }
+            }
+        }
+        const result = count === 1 ? unique : undefined;
+        return result;
+    }
+    /**
+     * External/ambient declaration files (.d.ts, anything under
+     * node_modules) never participate in plain-TS referenced-type
+     * resolution or the ambiguity law: they are not project source, the
+     * CLI never analyzes them, and a user-local declaration always wins
+     * over a package-declared same-named type.
+     */
+    isExternalDeclFile(file) {
+        const external = file.endsWith('.d.ts') ||
+            file.includes(`${nodePath.sep}node_modules${nodePath.sep}`);
+        return external;
+    }
+    /**
+     * Properties of a referenced class/interface/alias-of-literal declaration,
+     * shared by `this:`-parameter expansion and inline type emission.
+     * Inherited members are included: the extends chain is walked
+     * (depth-capped, cycle-guarded) and parent fields merge first, the
+     * declaration's own fields overriding on name clash.
+     */
+    referencedDeclarationProperties(decl) {
+        const visited = new Set();
+        const properties = this.referencedDeclarationPropertiesInner(decl, visited, 0);
+        return properties;
+    }
+    referencedDeclarationPropertiesInner(decl, visited, depth) {
+        const ownProperties = new Map();
+        const declNode = decl.node;
+        const declName = declNode.name && ts.isIdentifier(declNode.name) ? declNode.name.text : '';
+        const visitKey = `${decl.kind}:${decl.file}:${declName}`;
+        if (depth > MAX_HERITAGE_DEPTH || visited.has(visitKey)) {
+            return ownProperties;
+        }
+        visited.add(visitKey);
+        if (decl.kind === 'class') {
+            const classProps = this.extractClassProperties(decl.node);
+            for (const [name, info] of classProps) {
+                ownProperties.set(name, info);
+            }
+        }
+        else if (decl.kind === 'interface') {
+            const iface = decl.node;
+            this.collectTypeElementProperties([...iface.members], ownProperties);
+        }
+        else {
+            const aliasType = decl.node.type;
+            if (ts.isTypeLiteralNode(aliasType)) {
+                this.collectTypeElementProperties([...aliasType.members], ownProperties);
+            }
+            else {
+                return ownProperties;
+            }
+        }
+        // heritage merges parent fields first; the declaration's own fields
+        // override on name clash (later bases override earlier ones)
+        const merged = new Map();
+        for (const baseDecl of this.resolveHeritageDeclarations(decl)) {
+            const baseProps = this.referencedDeclarationPropertiesInner(baseDecl, visited, depth + 1);
+            for (const [name, info] of baseProps) {
+                merged.set(name, info);
+            }
+        }
+        for (const [name, info] of ownProperties) {
+            merged.set(name, info);
+        }
+        return merged;
+    }
+    /**
+     * Property signatures of interface/alias type-literal members, into
+     * the given map.
+     */
+    collectTypeElementProperties(members, properties) {
+        for (const member of 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,
+                });
+            }
+        }
+    }
+    /**
+     * Resolve the heritage clause of a class (`extends Base`) or interface
+     * (`extends A, B`) to referenced-type declarations through the SAME
+     * import-aware machinery as plain references (the declaring file's own
+     * imports first, then its locals, then the unique program-wide
+     * declaration). Unresolvable or external bases yield nothing — their
+     * inherited fields simply stay absent, same as before this walk
+     * existed. Mixin calls (`extends mixin(X)`) and namespace access are
+     * not followed.
+     */
+    resolveHeritageDeclarations(decl) {
+        const { heritageClauses } = decl.node;
+        if (!heritageClauses) {
+            return [];
+        }
+        const bases = [];
+        for (const clause of heritageClauses) {
+            if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
+                continue;
+            }
+            for (const heritageType of clause.types) {
+                if (!ts.isIdentifier(heritageType.expression)) {
+                    continue;
+                }
+                const baseName = heritageType.expression.text;
+                const baseDecl = this.resolveReferencedTypeDeclaration(baseName, decl.file);
+                if (baseDecl) {
+                    bases.push(baseDecl);
+                }
+            }
+        }
+        const result = bases;
+        return result;
+    }
+    /**
+     * Expand a referenced-type declaration to a self-contained type string
+     * for emission into generated files: type aliases through inferType,
+     * classes and interfaces through their (public, non-method) fields.
+     * Nested references resolve against the declaring file while expanding.
+     */
+    expandReferencedTypeDeclaration(decl) {
+        const referencingFile = this.currentReferencedTypeFile;
+        this.currentReferencedTypeFile = decl.file;
+        try {
+            const result = this.expandReferencedTypeDeclarationInner(decl);
+            return result;
+        }
+        finally {
+            this.currentReferencedTypeFile = referencingFile;
+        }
+    }
+    expandReferencedTypeDeclarationInner(decl) {
+        if (decl.kind === 'alias') {
+            const aliasNode = decl.node;
+            const aliasName = ts.isIdentifier(aliasNode.name) ? aliasNode.name.text : '';
+            if (aliasName && this.expandingReferencedAliases.has(aliasName)) {
+                // Self-referential alias chain — bail out
+                return 'unknown';
+            }
+            if (aliasName) {
+                this.expandingReferencedAliases.add(aliasName);
+            }
+            const expanded = this.inferType(aliasNode.type);
+            if (aliasName) {
+                this.expandingReferencedAliases.delete(aliasName);
+            }
+            return expanded;
+        }
+        const declProperties = this.referencedDeclarationProperties(decl);
+        const props = Array.from(declProperties.entries()).map(([propName, info]) => {
+            const optional = info.optional ? '?' : '';
+            return `${propName}${optional}: ${info.type}`;
+        });
+        const result = `{ ${props.join('; ')} }`;
+        return result;
+    }
+    /**
+     * Resolve a simple (non-qualified) type reference: import-aware
+     * declaration expansion first, then the InstanceType<typeof X> pattern,
+     * then mnemonica graph types; known globals keep their bare name and
+     * anything else falls back to `unknown` so generated files never carry
+     * an unresolvable bare name. Returns undefined when the caller should
+     * keep the generic spelling (handled separately).
+     */
+    resolveSimpleTypeReference(typeName, typeArgs, refNode) {
+        // Import-aware referenced-type declaration (F10)
+        const decl = this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile);
+        if (decl) {
+            const expanded = this.expandReferencedTypeDeclaration(decl);
+            if (expanded !== undefined) {
+                return expanded;
+            }
+            const unknownResult = 'unknown';
+            return unknownResult;
+        }
+        // Mnemonica-graph identity law: path-aware resolution (value scope,
+        // imports, nearest-chain, root, program-wide). Ambiguity between
+        // real graph types is a hard failure; a name no graph type carries
+        // stays in the plain-TS soft scope and falls to `unknown`.
+        const graphResult = this.resolveGraphTypeName(typeName);
+        if (graphResult.status === 'unique') {
+            // Handle InstanceType<typeof X> pattern -> convert to Parent_X
+            if (typeName === 'InstanceType' && typeArgs && typeArgs.length === 1) {
+                const [arg] = typeArgs;
+                if (arg.kind === ts.SyntaxKind.TypeQuery) {
+                    const typeQuery = arg;
+                    if (ts.isIdentifier(typeQuery.exprName)) {
+                        const queryResult = this.resolveGraphTypeName(typeQuery.exprName.text);
+                        if (queryResult.status === 'unique') {
+                            // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
+                            return queryResult.node.fullPath.replace(/\./g, '_');
+                        }
+                        if (queryResult.status === 'ambiguous') {
+                            this.recordGraphReferenceError(typeQuery.exprName.text, typeQuery, queryResult);
+                        }
+                        // Not a known mnemonica type — no bare emission
+                        return 'unknown';
+                    }
+                }
+            }
+            if (!typeArgs || typeArgs.length === 0) {
+                // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
+                return graphResult.node.fullPath.replace(/\./g, '_');
+            }
+            // Generic use of a graph type keeps its simple name; the
+            // generator upgrades it to the full-path instance type name
+            return `${typeName}<${typeArgs.map(a => this.inferType(a)).join(', ')}>`;
+        }
+        if (graphResult.status === 'ambiguous') {
+            this.recordGraphReferenceError(typeName, refNode ?? this.currentReferencedTypeFile, graphResult);
+        }
+        if (typeArgs && typeArgs.length > 0) {
+            if (KNOWN_GLOBAL_TYPES.has(typeName)) {
+                const genericResult = `${typeName}<${typeArgs.map(a => this.inferType(a)).join(', ')}>`;
+                return genericResult;
+            }
+            // Generic reference to a non-global, non-graph type cannot be
+            // emitted bare into the generated file
+            if (refNode) {
+                this.recordPlainTypeReferenceSite(typeName, refNode);
+            }
+            return 'unknown';
+        }
+        const fallbackResult = this.unresolvedTypeReferenceFallback(typeName, refNode);
+        return fallbackResult;
+    }
+    /**
+     * Resolve a qualified type reference (models.Inner.Crate) through the
+     * current file's namespace imports. The chain's head must be a namespace
+     * import; middle segments descend through namespace declarations, named
+     * re-exports of namespaces, and `export * as ns from '…'` barrels (each
+     * segment consumed exactly once, so the walk cannot cycle); the final
+     * segment resolves to a declaration which is expanded inline. When the
+     * precise walk finds nothing, the legacy rightmost-name lookup in the
+     * head module keeps one-level forms (models.Type) working — nested
+     * declarations are recorded by plain name there too. Returns undefined
+     * when the head is not a namespace import or nothing resolves.
+     */
+    inferQualifiedTypeReference(typeRef) {
+        if (!ts.isQualifiedName(typeRef.typeName)) {
+            return undefined;
+        }
+        // flatten the qualified name chain: models.Inner.Crate → ['models', 'Inner', 'Crate']
+        const segments = [];
+        let chain = typeRef.typeName;
+        while (ts.isQualifiedName(chain)) {
+            segments.unshift(chain.right.text);
+            chain = chain.left;
+        }
+        segments.unshift(chain.text);
+        const namespaceImport = this.referencedTypeImports.get(this.currentReferencedTypeFile)?.get(segments[0]);
+        if (!namespaceImport || !namespaceImport.isNamespace) {
+            return undefined;
+        }
+        const resolution = this.resolveReferencedTypeModule(namespaceImport.specifier, this.currentReferencedTypeFile);
+        if (!resolution || resolution.isExternal) {
+            return undefined;
+        }
+        // descend the middle segments: a module context resolves the segment
+        // as a namespace declaration / namespace re-export; a namespace-block
+        // context resolves it as a nested namespace declaration
+        let qualifier = {
+            modulePath: resolution.resolvedPath
+        };
+        for (let i = 1; i < segments.length - 1 && qualifier; i++) {
+            const segment = segments[i];
+            if (qualifier.block) {
+                const nested = this.findNamespaceInBlock(qualifier.block, segment);
+                if (nested?.body && ts.isModuleBlock(nested.body)) {
+                    qualifier = { modulePath: qualifier.modulePath, block: nested.body };
+                    continue;
+                }
+                qualifier = undefined;
+                break;
+            }
+            const namespaceDecl = this.referencedTypeNamespaces.get(qualifier.modulePath)?.get(segment);
+            if (namespaceDecl?.body && ts.isModuleBlock(namespaceDecl.body)) {
+                qualifier = { modulePath: qualifier.modulePath, block: namespaceDecl.body };
+                continue;
+            }
+            const starSpecifier = this.referencedTypeNamespaceStars.get(qualifier.modulePath)?.get(segment);
+            if (starSpecifier) {
+                const nextResolution = this.resolveReferencedTypeModule(starSpecifier, qualifier.modulePath);
+                if (nextResolution && !nextResolution.isExternal) {
+                    qualifier = { modulePath: nextResolution.resolvedPath };
+                    continue;
+                }
+            }
+            const reExportSpecifier = this.referencedTypeReExports.get(qualifier.modulePath)?.get(segment);
+            if (reExportSpecifier) {
+                const nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, qualifier.modulePath);
+                const reExported = nextResolution && !nextResolution.isExternal
+                    ? this.referencedTypeNamespaces.get(nextResolution.resolvedPath)?.get(segment)
+                    : undefined;
+                if (reExported?.body && ts.isModuleBlock(reExported.body)) {
+                    qualifier = { modulePath: nextResolution.resolvedPath, block: reExported.body };
+                    continue;
+                }
+            }
+            qualifier = undefined;
+        }
+        const finalName = segments[segments.length - 1];
+        let decl;
+        if (qualifier?.block) {
+            decl = this.findReferencedTypeInBlock(qualifier.block, qualifier.modulePath, finalName);
+        }
+        else if (qualifier) {
+            decl = this.findReferencedTypeInModule(qualifier.modulePath, finalName, 0);
+        }
+        // legacy fallback: rightmost name anywhere in the head module
+        // (namespace-nested declarations are also recorded by plain name)
+        if (!decl) {
+            decl = this.findReferencedTypeInModule(resolution.resolvedPath, finalName, 0);
+        }
+        if (!decl) {
+            return undefined;
+        }
+        const expanded = this.expandReferencedTypeDeclaration(decl);
+        return expanded;
+    }
+    /**
+     * Find a namespace declaration by name directly inside a module block.
+     */
+    findNamespaceInBlock(block, name) {
+        for (const statement of block.statements) {
+            if (ts.isModuleDeclaration(statement) && ts.isIdentifier(statement.name) &&
+                statement.name.text === name) {
+                const result = statement;
+                return result;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find a named type declaration (alias, class, interface) directly inside
+     * a namespace block — the final segment of a descended qualified chain.
+     */
+    findReferencedTypeInBlock(block, filePath, name) {
+        for (const statement of block.statements) {
+            if (ts.isTypeAliasDeclaration(statement) && ts.isIdentifier(statement.name) &&
+                statement.name.text === name) {
+                const result = { kind: 'alias', node: statement, file: filePath };
+                return result;
+            }
+            if (ts.isClassDeclaration(statement) && statement.name && statement.name.text === name) {
+                const result = { kind: 'class', node: statement, file: filePath };
+                return result;
+            }
+            if (ts.isInterfaceDeclaration(statement) && ts.isIdentifier(statement.name) &&
+                statement.name.text === name) {
+                const result = { kind: 'interface', node: statement, file: filePath };
+                return result;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Fallback for a type-reference name that resolves to no declaration and
+     * no graph type: known globals keep their bare name (they resolve without
+     * an import); everything else becomes `unknown` so generated types.ts
+     * never carries an unresolvable bare name (README's documented behavior)
+     * and the site is recorded for the plain-TS ambiguity validation.
+     */
+    unresolvedTypeReferenceFallback(typeName, refNode) {
+        if (KNOWN_GLOBAL_TYPES.has(typeName)) {
+            return typeName;
+        }
+        if (refNode) {
+            this.recordPlainTypeReferenceSite(typeName, refNode);
+        }
+        const result = 'unknown';
+        return result;
+    }
+    /**
+     * Record one define()/lazy()/@decorate() site under its runtime
+     * namespace key. Two sites in one namespace are a same-namespace
+     * duplicate (the runtime throws ALREADY_DECLARED); every site is kept
+     * so the failure can report all locations.
+     */
+    recordDefineSite(namespaceKey, location) {
+        let sites = this.defineSites.get(namespaceKey);
+        if (!sites) {
+            sites = [];
+            this.defineSites.set(namespaceKey, sites);
+        }
+        if (!sites.includes(location)) {
+            sites.push(location);
+        }
+    }
+    /**
+     * Fatal resolution failures (hard-fail law): same-namespace duplicate
+     * mnemonica definitions plus ambiguous/unresolved mnemonica-graph
+     * references. The CLI prints every location and writes no output.
+     */
+    getResolutionErrors() {
+        this.validateLookupReferences();
+        this.validatePlainTypeReferences();
+        const errors = [];
+        for (const [namespaceKey, sites] of this.defineSites) {
+            if (sites.length < 2) {
+                continue;
+            }
+            const displayName = namespaceKey.replace(/^[^:]+::/, '');
+            const message = `Duplicate definition of '${displayName}' in one namespace — ` +
+                'the mnemonica runtime would throw ALREADY_DECLARED';
+            errors.push({ message, locations: [...sites] });
+        }
+        for (const error of this.graphReferenceErrors) {
+            errors.push(error);
+        }
+        const result = errors;
+        return result;
+    }
+    /**
+     * Resolve a reference to a mnemonica graph type name, import-aware and
+     * path-aware (the hard-fail identity law, mirroring the runtime):
+     *   1. value scope — a tracked top-level binding in the referencing file
+     *      (`const Address = User.define('Address', …)`),
+     *   2. import scope — a binding exported from a module this file imports
+     *      (barrels chased),
+     *   3. nearest-chain — the anchor type's own subtypes first, then each
+     *      ancestor level (relative-first),
+     *   4. root — roots of the anchor's collection,
+     *   5. program-wide — only when exactly one type carries the name.
+     * Ambiguity (several candidates and nothing disambiguates) and absence
+     * are both returned as such — the caller records a hard failure; a bare
+     * first-match name is never emitted.
+     */
+    resolveGraphTypeName(name) {
+        // 1. value scope in the referencing file itself
+        const localBinding = this.fileGraphBindings.get(this.currentReferencedTypeFile)?.get(name);
+        if (localBinding) {
+            const node = this.graph.findType(localBinding);
+            if (node) {
+                const valueResult = { status: 'unique', node };
+                return valueResult;
+            }
+        }
+        // 2. import scope — the imported module's exported binding
+        const imported = this.referencedTypeImports.get(this.currentReferencedTypeFile)?.get(name);
+        if (imported && !imported.isNamespace) {
+            const resolution = this.resolveReferencedTypeModule(imported.specifier, this.currentReferencedTypeFile);
+            if (resolution && !resolution.isExternal) {
+                const fullPath = this.findGraphBindingInModule(resolution.resolvedPath, imported.originalName, 0);
+                if (fullPath) {
+                    const node = this.graph.findType(fullPath);
+                    if (node) {
+                        const importResult = { status: 'unique', node };
+                        return importResult;
+                    }
+                }
+            }
+        }
+        // 3-5. chain / root / program-wide tiers
+        const result = (0, graph_1.resolveGraphTypeReference)(this.graph, name, this.currentGraphAnchor);
+        return result;
+    }
+    /**
+     * Find a graph constructor binding exported by a resolved module,
+     * chasing re-export barrels with a bounded depth.
+     */
+    findGraphBindingInModule(modulePath, name, depth) {
+        if (depth > MAX_REEXPORT_CHASE_DEPTH) {
+            return undefined;
+        }
+        const direct = this.fileGraphBindings.get(modulePath)?.get(name);
+        if (direct) {
+            return direct;
+        }
+        const reExports = this.referencedTypeReExports.get(modulePath);
+        const reExportSpecifier = reExports?.get(name);
+        if (reExportSpecifier) {
+            const nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, modulePath);
+            if (nextResolution && !nextResolution.isExternal) {
+                const found = this.findGraphBindingInModule(nextResolution.resolvedPath, name, depth + 1);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        const stars = this.referencedTypeExportStars.get(modulePath);
+        if (stars) {
+            for (const starSpecifier of stars) {
+                const nextResolution = this.resolveReferencedTypeModule(starSpecifier, modulePath);
+                if (!nextResolution || nextResolution.isExternal) {
+                    continue;
+                }
+                const found = this.findGraphBindingInModule(nextResolution.resolvedPath, name, depth + 1);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Validate literal lookup() paths recorded during the usages pass
+     * against the complete graph. A lookup path matching no type is what the
+     * runtime answers with `undefined` — the TypeError arrives one line
+     * later at the `new` — so it joins the hard-fail law. The relative-first
+     * step already ran inside resolveLookupPath; whatever was recorded is
+     * the root-resolution result, so a plain findType check is the exact
+     * runtime law. Same-named types elsewhere in the graph are listed as
+     * did-you-mean candidates. Runs once per usages pass (re-armed by
+     * resetUsages); non-literal lookup arguments are never recorded and
+     * stay best-effort.
+     */
+    validateLookupReferences() {
+        if (this.lookupReferencesValidated) {
+            return;
+        }
+        this.lookupReferencesValidated = true;
+        // group sites by path: every failing site of the same path is listed
+        const sitesByPath = new Map();
+        for (const ref of this.lookupReferences) {
+            const sites = sitesByPath.get(ref.path) ?? [];
+            sites.push(ref.location);
+            sitesByPath.set(ref.path, sites);
+        }
+        for (const [typePath, sites] of sitesByPath) {
+            if (this.graph.findType(typePath)) {
+                continue;
+            }
+            // did-you-mean: types carrying the same name anywhere in the
+            // graph (never a first-match pick — the full list only)
+            const unprefixed = typePath.replace(/^[^:]+::/, '');
+            const lastSegment = unprefixed.split('.').pop() ?? unprefixed;
+            const candidates = this.graph.getAllTypes().filter(t => t.name === lastSegment);
+            if (candidates.length === 0) {
+                const noneError = {
+                    message: `Unresolved lookup of mnemonica type '${typePath}': no type at that path — ` +
+                        'the runtime would return undefined',
+                    locations: sites,
+                };
+                this.graphReferenceErrors.push(noneError);
+                continue;
+            }
+            const candidateLocations = candidates.map(n => `${n.sourceFile}:${n.line}:${n.column}`);
+            const candidatePaths = candidates.map(n => n.fullPath).join(', ');
+            const ambiguousError = {
+                message: `Unresolved lookup of mnemonica type '${typePath}': the runtime would return ` +
+                    `undefined — ${candidates.length} graph type(s) carry the name ` +
+                    `off-root (${candidatePaths}); use the full dotted path`,
+                locations: [...sites, ...candidateLocations],
+            };
+            this.graphReferenceErrors.push(ambiguousError);
+        }
+    }
+    /**
+     * Record a plain-TS type reference site that resolved to nothing and
+     * fell back to `unknown`, for the lazily-run ambiguity validation.
+     * Deduped by (name, location): inferType can visit the same node more
+     * than once per pass (constructor params + property inference).
+     */
+    recordPlainTypeReferenceSite(name, refNode) {
+        const location = this.nodeLocation(refNode);
+        const file = this.currentReferencedTypeFile;
+        const already = this.plainTypeReferences.some((ref) => ref.name === name && ref.location === location);
+        if (already) {
+            return;
+        }
+        this.plainTypeReferences.push({ name, location, file });
+    }
+    /**
+     * Project-source declaration files carrying `name` — one entry per
+     * file, so same-file interface merging counts once (not ambiguous).
+     * External/ambient declarations (.d.ts, anything under node_modules)
+     * never count: a user-local declaration always wins over a package-
+     * declared same-named type, so an external collision stays soft.
+     */
+    plainTypeDeclarationFiles(name) {
+        const files = [];
+        for (const [file, decls] of this.referencedTypeDecls) {
+            if (!this.isExternalDeclFile(file) && decls.has(name)) {
+                files.push(file);
+            }
+        }
+        return files;
+    }
+    /**
+     * Validate plain-TS type reference sites recorded during the usages
+     * pass against the complete declaration map. A name declared in
+     * several project-source files — with no import in the referencing
+     * file to anchor it — is ambiguous: silently emitting `unknown` would
+     * hide a real type the author meant, so it joins the hard-fail law
+     * (the plain-TS tier of the same identity law as graph references).
+     * Absence (ghost names) and external collisions stay soft `unknown`.
+     * Runs once per usages pass (re-armed by resetUsages), mirroring
+     * validateLookupReferences: recording happens on every pass, but only
+     * the usages pass sees the complete declaration map.
+     */
+    validatePlainTypeReferences() {
+        if (this.plainTypeReferencesValidated) {
+            return;
+        }
+        this.plainTypeReferencesValidated = true;
+        const sitesByName = new Map();
+        for (const ref of this.plainTypeReferences) {
+            const sites = sitesByName.get(ref.name) ?? [];
+            sites.push(ref);
+            sitesByName.set(ref.name, sites);
+        }
+        for (const [name, sites] of sitesByName) {
+            // an import binding in the referencing file anchors the name —
+            // the author already disambiguated (the import may just point
+            // at an unanalyzable external module, which stays soft)
+            const unanchored = sites.filter((site) => !this.referencedTypeImports.get(site.file)?.has(name));
+            if (unanchored.length === 0) {
+                continue;
+            }
+            const declFiles = this.plainTypeDeclarationFiles(name);
+            if (declFiles.length < 2) {
+                continue;
+            }
+            const message = `Ambiguous reference to type '${name}': ${declFiles.length} declarations ` +
+                'share the name and no import disambiguates — import the one you mean';
+            const declLocations = declFiles.map((file) => this.plainDeclLocation(file, name));
+            const error = {
+                message,
+                locations: [...unanchored.map((site) => site.location), ...declLocations]
+            };
+            this.graphReferenceErrors.push(error);
+        }
+    }
+    /**
+     * `file:line:column` of a recorded declaration, for the ambiguity
+     * report. Nodes recorded during traversal keep their positions; a
+     * synthetic/unpositioned node falls back to the file itself.
+     */
+    plainDeclLocation(file, name) {
+        const decl = this.referencedTypeDecls.get(file)?.get(name);
+        const node = decl?.node;
+        let location = `${file}:1:1`;
+        if (node && node.pos >= 0) {
+            const sourceFile = node.getSourceFile();
+            const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+            const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
+            location = `${file}:${line}:${column}`;
+        }
+        const result = location;
+        return result;
+    }
+    /**
+     * Record a hard-fail graph reference error with the reference site and
+     * every candidate location.
+     */
+    recordGraphReferenceError(name, refNode, result) {
+        const location = typeof refNode === 'string' ? refNode : this.nodeLocation(refNode);
+        if (result.status === 'ambiguous') {
+            const candidateLocations = result.candidates.map(n => `${n.sourceFile}:${n.line}:${n.column}`);
+            const ambiguousMessage = `Ambiguous reference to mnemonica type '${name}': ` +
+                `${result.candidates.length} types share the name and neither the parent chain ` +
+                'nor the imports disambiguate';
+            const ambiguousError = {
+                message: ambiguousMessage,
+                locations: [location, ...candidateLocations],
+            };
+            this.graphReferenceErrors.push(ambiguousError);
+            return;
+        }
+        const unresolvedMessage = `Unresolved reference to mnemonica type '${name}': no type matches ` +
+            'by value scope, imports, parent chain, or root path';
+        const unresolvedError = { message: unresolvedMessage, locations: [location] };
+        this.graphReferenceErrors.push(unresolvedError);
+    }
+    /**
+     * Location (`file:line:column`) of an AST node, derived without parent
+     * pointers when necessary.
+     */
+    nodeLocation(node) {
+        let current = node;
+        while (current && !ts.isSourceFile(current)) {
+            current = current.parent;
+        }
+        if (!current) {
+            const fallback = this.currentReferencedTypeFile;
+            return fallback;
+        }
+        const start = node.getStart(current);
+        const { line, character } = ts.getLineAndCharacterOfPosition(current, start);
+        const location = `${current.fileName}:${line + 1}:${character + 1}`;
+        return location;
+    }
     /**
      * Track aliases of the mnemonica module object, e.g.:
      *   const m = mnemonica;
@@ -574,11 +1794,10 @@ class MnemonicaAnalyzer {
      * Mark a call expression as processed and return whether it already was.
      */
     markProcessed(call) {
-        const marked = call;
-        if (marked.__tactica_processed) {
+        if (this.processedCalls.has(call)) {
             return true;
         }
-        marked.__tactica_processed = true;
+        this.processedCalls.add(call);
         return false;
     }
     /**
@@ -622,10 +1841,23 @@ class MnemonicaAnalyzer {
         // 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);
+        // Same-namespace duplicate detection (hard-fail law): key by the
+        // runtime namespace — collection roots `<collection>::<name>`, or
+        // `<parentFullPath>.<name>` for subtypes
+        this.recordDefineSite(parentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`, `${sourceFile.fileName}:${line + 1}:${character + 1}`);
+        // Extract properties from constructor function — the new node anchors
+        // relative-first graph reference resolution while its own signature
+        // is being read
+        const previousAnchor = this.currentGraphAnchor;
+        this.currentGraphAnchor = node;
+        try {
+            node.properties = this.extractProperties(call);
+            // Extract constructor parameters for TypeRegistry signature
+            node.constructorParams = this.extractConstructorParams(call);
+        }
+        finally {
+            this.currentGraphAnchor = previousAnchor;
+        }
         // Add to graph
         if (parentNode) {
             this.graph.addChild(parentNode, node);
@@ -689,10 +1921,20 @@ class MnemonicaAnalyzer {
         // 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);
+        // Same-namespace duplicate detection (hard-fail law)
+        this.recordDefineSite(parentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`, `${sourceFile.fileName}:${line + 1}:${character + 1}`);
         // 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);
+        // — the new node anchors relative-first graph reference resolution
+        const previousAnchor = this.currentGraphAnchor;
+        this.currentGraphAnchor = node;
+        try {
+            node.properties = this.extractProperties(call);
+            // Extract constructor parameters for TypeRegistry signature
+            node.constructorParams = this.extractConstructorParams(call);
+        }
+        finally {
+            this.currentGraphAnchor = previousAnchor;
+        }
         // Add to graph
         if (parentNode) {
             this.graph.addChild(parentNode, node);
@@ -987,12 +2229,27 @@ class MnemonicaAnalyzer {
                         return;
                     }
                     this.variableToTypeMap.set(varName, fullPath);
+                    this.trackFileGraphBinding(varName, fullPath);
                 }
                 return;
             }
             current = current.parent;
         }
     }
+    /**
+     * Mirror a variable -> mnemonica fullPath binding into the per-file
+     * value-scope map (graph identity law: `typeof X` and bare references
+     * resolve through the file's own bindings first).
+     */
+    trackFileGraphBinding(varName, fullPath) {
+        const filePath = this.currentReferencedTypeFile;
+        let bindings = this.fileGraphBindings.get(filePath);
+        if (!bindings) {
+            bindings = new Map();
+            this.fileGraphBindings.set(filePath, bindings);
+        }
+        bindings.set(varName, fullPath);
+    }
     /**
         * Track variable assignments from lookup() calls
         * e.g., const SentienceConstructor = lookup('Sentience') maps "SentienceConstructor" -> "Sentience"
@@ -1006,6 +2263,7 @@ class MnemonicaAnalyzer {
                 if (ts.isIdentifier(current.name)) {
                     const varName = current.name.text;
                     this.variableToTypeMap.set(varName, typePath);
+                    this.trackFileGraphBinding(varName, typePath);
                 }
                 return;
             }
@@ -1025,6 +2283,7 @@ class MnemonicaAnalyzer {
                 if (ts.isIdentifier(current.name)) {
                     const varName = current.name.text;
                     this.variableToTypeMap.set(varName, typePath);
+                    this.trackFileGraphBinding(varName, typePath);
                 }
                 return;
             }
@@ -1137,9 +2396,19 @@ class MnemonicaAnalyzer {
         // Create type node
         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);
+        // Same-namespace duplicate detection (hard-fail law)
+        this.recordDefineSite(parentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`, `${sourceFile.fileName}:${line + 1}:${character + 1}`);
+        // Extract properties and constructor parameters from class members —
+        // the new node anchors relative-first graph reference resolution
+        const previousAnchor = this.currentGraphAnchor;
+        this.currentGraphAnchor = node;
+        try {
+            node.properties = this.extractClassProperties(classDecl);
+            node.constructorParams = this.extractClassConstructorParams(classDecl);
+        }
+        finally {
+            this.currentGraphAnchor = previousAnchor;
+        }
         // Add to graph
         if (parentNode) {
             this.graph.addChild(parentNode, node);
@@ -1371,6 +2640,18 @@ class MnemonicaAnalyzer {
         }
         return undefined;
     }
+    /**
+     * Lookup-law delegate for the local-scope walker (scopes.json typePath
+     * metadata): resolve a lookup() initializer call through exactly the
+     * tiers the usages pass resolved it against (same source resolution,
+     * same complete graph). The walker runs its own scope-chain value-scope
+     * tier before delegating; everything above value scope lands here, so
+     * scopes.json never disagrees with the hard-fail-law verdicts.
+     */
+    resolveLookupCallPath(call) {
+        const result = this.resolveLookupPath(call);
+        return result;
+    }
     /**
         * Find a parent type by its name, searching in the graph.
         * When collectionId is provided, only types from that collection are considered.
@@ -1843,20 +3124,14 @@ class MnemonicaAnalyzer {
                     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,
-                                });
-                            }
+                    // Resolve through the referencing file's own imports first (F10)
+                    const decl = typeName
+                        ? this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile)
+                        : undefined;
+                    if (decl) {
+                        const declProperties = this.referencedDeclarationProperties(decl);
+                        for (const [propName, info] of declProperties) {
+                            properties.set(propName, info);
                         }
                     }
                 }
@@ -1947,46 +3222,25 @@ class MnemonicaAnalyzer {
             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;
-                    if (arg.kind === ts.SyntaxKind.TypeQuery) {
-                        const typeQuery = arg;
-                        if (ts.isIdentifier(typeQuery.exprName)) {
-                            const queryTypeName = typeQuery.exprName.text;
-                            // Look up the type in the graph to get full path
-                            const matchedType = this.graph.findTypeByName(queryTypeName);
-                            if (matchedType) {
-                                // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
-                                return matchedType.fullPath.replace(/\./g, '_');
-                            }
-                            // Fallback: just use the type name if not found in graph
-                            return queryTypeName;
-                        }
+                // Qualified names (Namespace.Type): resolve through namespace imports
+                if (ts.isQualifiedName(typeRef.typeName)) {
+                    const resolvedQualified = this.inferQualifiedTypeReference(typeRef);
+                    if (resolvedQualified !== undefined) {
+                        return resolvedQualified;
                     }
+                    // unresolved qualified references must not leak a bare name
+                    return 'unknown';
                 }
-                if (!typeRef.typeArguments || typeRef.typeArguments.length === 0) {
-                    // Check if this type exists in our graph - convert to full path format
-                    const matchedType = this.graph.findTypeByName(typeName);
-                    if (matchedType) {
-                        // Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry
-                        return matchedType.fullPath.replace(/\./g, '_');
-                    }
-                    return typeName;
+                const typeName = ts.isIdentifier(typeRef.typeName) ? typeRef.typeName.text : 'unknown';
+                // Import-aware referenced-type resolution (F10): a declaration
+                // reached through the current file's own imports (or its locals,
+                // or a unique program-wide declaration) expands inline
+                const simpleRef = this.resolveSimpleTypeReference(typeName, typeRef.typeArguments, typeRef);
+                if (simpleRef !== undefined) {
+                    return simpleRef;
                 }
                 // Build generic type arguments
-                const typeArgs = typeRef.typeArguments.map(arg => this.inferType(arg));
+                const typeArgs = (typeRef.typeArguments ?? []).map(arg => this.inferType(arg));
                 return `${typeName}<${typeArgs.join(', ')}>`;
             }
             case ts.SyntaxKind.UnionType: {
@@ -2024,14 +3278,40 @@ class MnemonicaAnalyzer {
             case ts.SyntaxKind.IndexedAccessType: {
                 // Handle indexed access: T[K]
                 const indexed = typeNode;
+                // `typeof constArray[K]` — element type of a tracked const array:
+                // emit the element literal union directly (assembling
+                // `union[K]` text would misread precedence, and when the const
+                // is not statically visible the honest answer is `unknown`,
+                // never a bare `typeof name` query)
+                if (ts.isTypeQueryNode(indexed.objectType) && ts.isIdentifier(indexed.objectType.exprName)) {
+                    const queryName = indexed.objectType.exprName.text;
+                    const arrayLiteral = this.findReferencedConstArray(queryName, this.currentReferencedTypeFile);
+                    const literals = arrayLiteral ? this.literalTypesOfArray(arrayLiteral) : undefined;
+                    if (!literals) {
+                        return 'unknown';
+                    }
+                    if (ts.isLiteralTypeNode(indexed.indexType) && ts.isNumericLiteral(indexed.indexType.literal)) {
+                        const elementIndex = parseInt(indexed.indexType.literal.text, 10);
+                        const element = literals[elementIndex];
+                        const elementResult = element === undefined ? 'unknown' : element;
+                        return elementResult;
+                    }
+                    const unionResult = literals.join(' | ');
+                    return unionResult;
+                }
                 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 is 'object', try to resolve the underlying referenced type
                 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);
+                    if (refName) {
+                        const decl = this.resolveReferencedTypeDeclaration(refName, this.currentReferencedTypeFile);
+                        if (decl) {
+                            const expanded = this.expandReferencedTypeDeclaration(decl);
+                            if (expanded) {
+                                objectType = expanded;
+                            }
+                        }
                     }
                 }
                 return `${objectType}[${indexType}]`;
@@ -2043,10 +3323,18 @@ class MnemonicaAnalyzer {
                 return `${operator} ${this.inferType(typeOp.type)}`;
             }
             case ts.SyntaxKind.TypeQuery: {
-                // Handle typeof expressions like `typeof UsageEntry`
+                // `typeof x` as a FIELD TYPE: the generated file has no imports,
+                // so a bare `typeof x` would be an unresolvable name downstream.
+                // When x is a tracked const array, emit its element literal
+                // union; otherwise degrade to `unknown`. (InstanceType<typeof X>
+                // graph types are handled in resolveSimpleTypeReference before
+                // inferType runs.)
                 const typeQuery = typeNode;
                 if (ts.isIdentifier(typeQuery.exprName)) {
-                    return `typeof ${typeQuery.exprName.text}`;
+                    const union = this.typeOfConstArrayUnion(typeQuery.exprName.text, this.currentReferencedTypeFile);
+                    if (union) {
+                        return union;
+                    }
                 }
                 return 'unknown';
             }
@@ -2093,19 +3381,6 @@ class MnemonicaAnalyzer {
         }
         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
      */
@@ -2370,13 +3645,17 @@ class MnemonicaAnalyzer {
                 const typePath = this.resolveLookupPath(node);
                 if (typePath) {
                     const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+                    const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
                     this.addUsage(typePath, {
-                        location: `${sourceFile.fileName}:${line + 1}:${character + 1}`,
+                        location,
                         kind: 'lookup',
                         code: node.getText(sourceFile).slice(0, 100),
                     });
                     // Track variable assignment from lookup for instantiation tracking
                     this.trackLookupAssignment(node, typePath);
+                    // Record for the hard-fail law even when addUsage dropped
+                    // the path (unknown paths are exactly the failure class)
+                    this.lookupReferences.push({ path: typePath, location });
                 }
             }
         }
@@ -2437,14 +3716,6 @@ class MnemonicaAnalyzer {
             funcName === 'upgradeConstructorArg' ||
             funcName === 'wrapInstanceMethods') {
             const targetType = this.resolveEDSArgumentType(node.arguments[0]);
-            const info = {
-                location,
-                kind: 'wrap',
-                code,
-                targetType: targetType || undefined,
-                scope,
-                fn: funcName,
-            };
             // dive's wrap-family signatures (dive/src/index.ts):
             //   wrap(fn, label?) | wrap(fn, context?, label?)
             //   wrapConstructorArg(fn, context)
@@ -2455,6 +3726,23 @@ class MnemonicaAnalyzer {
             const instanceArgNode = funcName === 'wrapInstanceMethods'
                 ? node.arguments[0]
                 : node.arguments[1];
+            // Fire-and-forget wrappers (wire-up helpers, registration
+            // functions) sit outside any define()/lazy() handler, so the
+            // lexical scope is absent — attribute through the instance/context
+            // argument instead: a tracked assignment, else the enclosing
+            // function's parameter annotation resolved through the graph law
+            const instanceTypePath = instanceArgNode
+                ? this.resolveWrapInstanceTypePath(instanceArgNode)
+                : undefined;
+            const effectiveScope = scope ?? instanceTypePath;
+            const info = {
+                location,
+                kind: 'wrap',
+                code,
+                targetType: targetType || undefined,
+                scope: effectiveScope,
+                fn: funcName,
+            };
             if (instanceArgNode && ts.isIdentifier(instanceArgNode)) {
                 info.instanceArg = instanceArgNode.text;
             }
@@ -2465,10 +3753,15 @@ class MnemonicaAnalyzer {
                 }
             }
             // A wrap() call nested inside another wrapped body carries the
-            // link to the site whose runtime wrapping caused it
-            const via = this.nestedWrapVia.get(node);
-            if (via) {
-                info.via = via;
+            // link to the site whose runtime wrapping caused it — and, when
+            // the nested site has no scope of its own, the causing site's
+            // scope attribution travels with the link
+            const viaLink = this.nestedWrapVia.get(node);
+            if (viaLink) {
+                info.via = viaLink.via;
+                if (info.scope === undefined) {
+                    info.scope = viaLink.scope;
+                }
             }
             // dive wraps returned functions too, and any mnemonica instance
             // created inside the wrapped body is a guaranteed path hit —
@@ -2482,12 +3775,12 @@ class MnemonicaAnalyzer {
                 const callbackFile = nodePath.resolve(sourceFile.fileName);
                 info.callbackScopeId = `${callbackFile}:${callbackPos.line + 1}:${callbackPos.character + 1}`;
                 const createsTypes = new Set();
-                this.analyzeWrappedBody(wrapped, location, sourceFile, 0, new Set(), createsTypes);
+                this.analyzeWrappedBody(wrapped, location, sourceFile, 0, new Set(), createsTypes, effectiveScope);
                 if (createsTypes.size > 0) {
                     info.createsTypes = Array.from(createsTypes);
                 }
             }
-            const stored = this.addEDS(targetType || scope || 'unknown', info);
+            const stored = this.addEDS(targetType || effectiveScope || 'unknown', info);
             this.wrapEntryByNode.set(node, stored);
             return;
         }
@@ -2576,6 +3869,67 @@ class MnemonicaAnalyzer {
         }
         return undefined;
     }
+    /**
+     * Resolve a wrap site's instance/context argument to a mnemonica type
+     * path — the fire-and-forget-wrapper attribution fallback when the call
+     * sits outside any define()/lazy() handler: a tracked assignment
+     * (`const holder = new Holder(...)`), else the root identifier's
+     * (property-access roots included) parameter annotation resolved
+     * through the graph law. Ambiguity or absence stays silent — this is a
+     * metadata heuristic, not the identity-law surface.
+     */
+    resolveWrapInstanceTypePath(arg) {
+        const fromBinding = (name, from) => {
+            const mapped = this.variableToTypeMap.get(name);
+            if (mapped) {
+                return mapped;
+            }
+            const annotationType = this.resolveParameterAnnotationTypePath(name, from);
+            return annotationType;
+        };
+        if (ts.isIdentifier(arg)) {
+            const result = fromBinding(arg.text, arg);
+            return result;
+        }
+        if (ts.isPropertyAccessExpression(arg)) {
+            const root = this.getRootIdentifier(arg);
+            if (root) {
+                const result = fromBinding(root.text, arg);
+                return result;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Resolve a bare-identifier type annotation of the nearest enclosing
+     * function's parameter through the mnemonica-graph tiers (value scope,
+     * imports, roots, program-wide-unique). Non-identifier and generic
+     * annotations are not graph references; ambiguity and absence yield
+     * undefined.
+     */
+    resolveParameterAnnotationTypePath(name, from) {
+        let current = from.parent;
+        while (current) {
+            if (ts.isFunctionLike(current)) {
+                for (const param of current.parameters ?? []) {
+                    if (!ts.isIdentifier(param.name) || param.name.text !== name || !param.type ||
+                        !ts.isTypeReferenceNode(param.type) ||
+                        !ts.isIdentifier(param.type.typeName) ||
+                        (param.type.typeArguments?.length ?? 0) > 0) {
+                        continue;
+                    }
+                    const graphResult = this.resolveGraphTypeName(param.type.typeName.text);
+                    if (graphResult.status === 'unique') {
+                        const result = graphResult.node.fullPath;
+                        return result;
+                    }
+                }
+                return undefined;
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
     /**
      * Resolve a wrap() argument to its function node without the type
      * checker: direct function expressions/arrows, or same-file bindings
@@ -2609,14 +3963,14 @@ class MnemonicaAnalyzer {
      * belong to their own wrap analysis, reached via the return chain.
      * Depth-capped and cycle-guarded.
      */
-    analyzeWrappedBody(fn, viaLocation, sourceFile, depth, visited, createsTypes) {
+    analyzeWrappedBody(fn, viaLocation, sourceFile, depth, visited, createsTypes, fallbackScope) {
         if (depth > 5 || visited.has(fn) || !fn.body) {
             return;
         }
         visited.add(fn);
         // Arrow with expression body: implicit return
         if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) {
-            this.recordWrappedReturn(fn.body, viaLocation, sourceFile, depth, visited);
+            this.recordWrappedReturn(fn.body, viaLocation, sourceFile, depth, visited, fallbackScope);
             return;
         }
         const walk = (node) => {
@@ -2628,7 +3982,7 @@ class MnemonicaAnalyzer {
                 return;
             }
             if (ts.isReturnStatement(node) && node.expression) {
-                this.recordWrappedReturn(node.expression, viaLocation, sourceFile, depth, visited);
+                this.recordWrappedReturn(node.expression, viaLocation, sourceFile, depth, visited, fallbackScope);
             }
             if (ts.isNewExpression(node)) {
                 const created = this.resolveExpressionType(node.expression) ||
@@ -2647,13 +4001,17 @@ class MnemonicaAnalyzer {
                     nestedName === 'wrapInstanceMethods') {
                     // the nested call may already be collected (visited
                     // before this outer wrap site) — back-patch its entry,
-                    // otherwise leave the link for collectEDS to pick up
+                    // otherwise leave the link (with this site's scope) for
+                    // collectEDS to pick up
                     const nestedEntry = this.wrapEntryByNode.get(node);
                     if (nestedEntry) {
                         nestedEntry.via = viaLocation;
+                        if (nestedEntry.scope === undefined) {
+                            nestedEntry.scope = fallbackScope;
+                        }
                     }
                     else {
-                        this.nestedWrapVia.set(node, viaLocation);
+                        this.nestedWrapVia.set(node, { via: viaLocation, scope: fallbackScope });
                     }
                 }
             }
@@ -2666,8 +4024,10 @@ class MnemonicaAnalyzer {
      * site (`via` = the site whose wrapping caused it) and recurse into
      * its own returns. Returns through identifiers resolve through the
      * same-file bindings table; unresolvable returns are simply skipped.
+     * A return declared outside any type scope inherits the causing wrap
+     * site's scope attribution (the generation chain is the only holder).
      */
-    recordWrappedReturn(expr, viaLocation, sourceFile, depth, visited) {
+    recordWrappedReturn(expr, viaLocation, sourceFile, depth, visited, fallbackScope) {
         const returned = this.resolveFunctionArgument(expr, sourceFile);
         if (!returned) {
             return;
@@ -2675,7 +4035,7 @@ class MnemonicaAnalyzer {
         const { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, returned.getStart(sourceFile));
         const location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;
         const code = returned.getText(sourceFile).slice(0, 100);
-        const scope = this.resolveEDSScope(returned);
+        const scope = this.resolveEDSScope(returned) ?? fallbackScope;
         const entry = this.addEDS(scope || 'unknown', {
             location,
             kind: 'wrap',
@@ -2688,7 +4048,7 @@ class MnemonicaAnalyzer {
         // the returned function's own returns are wrapped in turn; `via`
         // chains to this nested entry's location
         const nestedCreates = new Set();
-        this.analyzeWrappedBody(returned, location, sourceFile, depth + 1, visited, nestedCreates);
+        this.analyzeWrappedBody(returned, location, sourceFile, depth + 1, visited, nestedCreates, scope);
         if (nestedCreates.size > 0) {
             entry.createsTypes = Array.from(nestedCreates);
         }
@@ -3059,21 +4419,44 @@ class MnemonicaAnalyzer {
             }
             return `{ ${props.join('; ')} }`;
         }
-        // Type reference: usage, UserData, etc. - recursively expand
+        // Type reference: usage, UserData, etc. - resolve import-aware and
+        // expand the referenced declaration where possible (F10)
         if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
             const typeName = typeNode.typeName.text;
-            const aliasedType = this.typeAliases.get(typeName);
-            if (aliasedType) {
-                const expanded = this.resolveConstructorParamType(aliasedType);
+            const decl = this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile);
+            if (decl) {
+                const expanded = this.expandReferencedTypeDeclaration(decl);
                 if (expanded)
                     return expanded;
             }
+            // mnemonica graph types keep their simple name — the generator
+            // upgrades them to full-path instance type names. Resolution is
+            // path-aware (hard-fail law): ambiguity between real graph types
+            // records a fatal error instead of silently picking one.
+            const graphResult = this.resolveGraphTypeName(typeName);
+            if (graphResult.status === 'unique') {
+                const simpleResult = typeName;
+                return simpleResult;
+            }
+            if (graphResult.status === 'ambiguous') {
+                this.recordGraphReferenceError(typeName, typeNode, graphResult);
+                const unknownGraphResult = 'unknown';
+                return unknownGraphResult;
+            }
             // 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(', ')}>`;
+                if (KNOWN_GLOBAL_TYPES.has(typeName)) {
+                    const args = typeNode.typeArguments.map(arg => this.inferType(arg));
+                    return `${typeName}<${args.join(', ')}>`;
+                }
+                // generic reference to a non-global, non-graph type cannot be
+                // emitted bare into the generated file
+                this.recordPlainTypeReferenceSite(typeName, typeNode);
+                const unknownGenericResult = 'unknown';
+                return unknownGenericResult;
             }
-            return typeName;
+            const fallbackResult = this.unresolvedTypeReferenceFallback(typeName, typeNode);
+            return fallbackResult;
         }
         return undefined;
     }
@@ -3229,8 +4612,9 @@ class MnemonicaAnalyzer {
         if (!kind) {
             return;
         }
-        // The decorator's parent is the decorated node: a controller class
-        // or one of its methods
+        // The decorator's parent is the decorated node: a controller class,
+        // one of its methods, or one of its method parameters
+        // (@Body(mvp.forType(Dto)) on a handler argument)
         const decorated = node.parent;
         let scope;
         let targets;
@@ -3246,6 +4630,26 @@ class MnemonicaAnalyzer {
             scope = `method:${className}.${decorated.name.text}`;
             targets = [className];
         }
+        else if (ts.isParameter(decorated)) {
+            // Parameter decorators take the enclosing method's scope — the
+            // attachment point is the handler, not the argument name; the
+            // same method:Class.method form as method-level sites. Params of
+            // constructors, functions, and unnameable hosts stay silent, the
+            // same convention as other unresolvable decorator parents
+            const host = decorated.parent;
+            if (host &&
+                ts.isMethodDeclaration(host) &&
+                ts.isIdentifier(host.name) &&
+                ts.isClassDeclaration(host.parent) &&
+                host.parent.name) {
+                const className = host.parent.name.text;
+                scope = `method:${className}.${host.name.text}`;
+                targets = [className];
+            }
+            else {
+                return;
+            }
+        }
         else {
             return;
         }
@@ -3256,17 +4660,33 @@ class MnemonicaAnalyzer {
             // Class reference: @Register(Impl) or an inline instance:
             // @Register(new Impl({ ...options }))
             let className;
+            // per-arg kind: factory-call args carry their own configured
+            // kind, everything else takes the decorator's
+            let argKind = kind;
             if (ts.isIdentifier(arg)) {
                 className = arg.text;
             }
             else if (ts.isNewExpression(arg) && ts.isIdentifier(arg.expression)) {
                 className = arg.expression.text;
             }
+            else if (ts.isCallExpression(arg) && ts.isPropertyAccessExpression(arg.expression)) {
+                // Pipe-factory shape: @UsePipes(mvp.forType(Dto)) — the
+                // call's method name is plugin-listed, the target class sits
+                // in the configured argument position (default 0)
+                const factory = this.instrumentationVocabulary.decoratorArgFactories[arg.expression.name.text];
+                if (factory) {
+                    const targetArg = arg.arguments[factory.targetArg ?? 0];
+                    if (targetArg && ts.isIdentifier(targetArg)) {
+                        className = targetArg.text;
+                        argKind = factory.kind;
+                    }
+                }
+            }
             if (!className) {
                 continue;
             }
             this.instrumentationSites.push({
-                kind,
+                kind: argKind,
                 className,
                 location,
                 code,
@@ -3376,4 +4796,4 @@ class MnemonicaAnalyzer {
     }
 }
 exports.MnemonicaAnalyzer = MnemonicaAnalyzer;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport * as nodePath from 'path';\nimport * as ts from 'typescript';\nimport {\n\tTypeNode, PropertyInfo, AnalyzeResult, AnalyzeError,\n\tDefinitionInfo, UsageInfo, ConstructorParamInfo,\n\tEDSInfo, FlowInfo, InstrumentationKind, InstrumentationPoint,\n\tInstrumentationScope\n} from './types';\nimport { TypeGraphImpl } from './graph';\nimport {\n\tInstrumentationVocabulary, TacticaPlugin, mergeTacticaPlugins\n} from './plugins';\n\ninterface CollectionInfo {\n\tvariableName: string;\n\tsourceFile: string;\n\tregistryInterfaceName?: string;\n}\n\n/**\n * Location/code captured at a class declaration, used to resolve\n * instrumentation registration sites to the declared class\n */\ninterface InstrumentationClassDecl {\n\tkind?: InstrumentationKind;\n\tlocation: string;\n\tcode: string;\n}\n\n/**\n * Raw registration site (decorator, APP_* provider, consumer.apply).\n * Location/code are the site's own; getInstrumentationPoints() rewrites\n * them to the class declaration when the class is declared in-project.\n */\ninterface InstrumentationSite {\n\tkind: InstrumentationKind;\n\tclassName: string;\n\tlocation: string;\n\tcode: string;\n\tscope: InstrumentationScope;\n\ttargets: string[];\n}\n\n/**\n * AST Analyzer for finding Mnemonica define() and decorate() calls\n *\n * Framework-blind by construction: instrumentation detection vocabulary\n * (interface names, decorator names, provider tokens, middleware wiring)\n * comes entirely from plugins — with none loaded, zero points are collected.\n */\nexport class MnemonicaAnalyzer {\n\tprivate errors: AnalyzeError[] = [];\n\tprivate graph = new TypeGraphImpl();\n\tprivate definitions = new Map<string, DefinitionInfo>();\n\tprivate usages = new Map<string, UsageInfo[]>();\n\tprivate edsUsages = new Map<string, EDSInfo[]>();\n\tprivate flowUsages = new Map<string, FlowInfo[]>();\n\t// Enclosing mnemonica scope for EDS keying: define()/lazy() call node\n\t// or @decorate()-ed class declaration -> fullPath of the type it owns.\n\t// Populated on the definitions pass; AST nodes persist across passes,\n\t// so entries stay valid after resetUsages().\n\tprivate edsScopeByNode = new Map<ts.Node, string>();\n\t// Same-file function bindings (`fileName#name` -> function node) for\n\t// resolving wrap(fn) arguments syntactically — the checker stays unused\n\tprivate functionBindings = new Map<string, ts.FunctionLikeDeclaration>();\n\t// wrap call node -> location of the enclosing wrap site, so nested\n\t// wrap() calls inside a wrapped body carry the `via` link\n\tprivate nestedWrapVia = new Map<ts.Node, string>();\n\t// wrap call node -> its collected entry, so a lexically nested wrap\n\t// (visited BEFORE the outer wrap call, per source order) gets its\n\t// `via` back-patched when the outer body is analysed\n\tprivate wrapEntryByNode = new Map<ts.Node, EDSInfo>();\n\tprivate typeAliases = new Map<string, ts.TypeNode>();\n\t// Track variable assignments: variableName -> fullPath of the type it holds\n\tprivate variableToTypeMap = new Map<string, string>();\n\t// Track mnemonica module-object variables (e.g., import { mnemonica } from 'mnemonica'; const m = mnemonica)\n\tprivate moduleObjectVariables = new Set<string>();\n\t// Track imported aliases of createTypesCollection (e.g., import { createTypesCollection as ctc })\n\tprivate createTypesCollectionVariables = new Set<string>();\n\t// Track custom collection variables: variableName -> collectionId\n\tprivate collectionVariables = new Map<string, string>();\n\t// Track custom collection metadata for Option B registry emission\n\tprivate collectionInfo = new Map<string, CollectionInfo>();\n\tprivate collectionCounter = 0;\n\t// Instrumentation collection (syntactic only — no type checker):\n\t// every named class declaration by simple name, for resolving\n\t// registration sites to declaration locations (best effort, last wins)\n\tprivate instrumentationClassDecls = new Map<string, InstrumentationClassDecl>();\n\t// Registration sites: decorator applications, provider-token object\n\t// literals, consumer.apply() middleware wiring\n\tprivate instrumentationSites: InstrumentationSite[] = [];\n\t// Merged plugin vocabulary for instrumentation detection (empty when\n\t// no plugins were passed — the analyzer then collects no points)\n\tprivate instrumentationVocabulary: InstrumentationVocabulary;\n\n\tconstructor (program?: ts.Program, plugins: TacticaPlugin[] = []) {\n\t\t// Store program for future use (currently unused but kept for extensibility)\n\t\tvoid program;\n\t\tthis.instrumentationVocabulary = mergeTacticaPlugins(plugins);\n\t}\n\n\t/**\n\t * Reset usage-related state for a fresh pass.\n\t * Call before the usage-collection pass to avoid duplicates from definition pass.\n\t */\n\tresetUsages (): void {\n\t\tthis.usages.clear();\n\t\tthis.edsUsages.clear();\n\t\tthis.flowUsages.clear();\n\t\tthis.variableToTypeMap.clear();\n\t\t// EDS entry references go stale with edsUsages; via links are\n\t\t// re-derived on the next pass\n\t\tthis.wrapEntryByNode.clear();\n\t\tthis.nestedWrapVia.clear();\n\t\t// Note: moduleObjectVariables and collectionVariables intentionally persist\n\t\t// across definition and usage passes.\n\t}\n\n\t/**\n\t * Analyze a source file for Mnemonica type definitions\n\t */\n\tanalyzeFile (sourceFile: ts.SourceFile): AnalyzeResult {\n\t\tthis.errors = [];\n\t\t// Ensure parent nodes are set for AST traversal\n\t\tthis.setParentNodesInSourceFile(sourceFile);\n\t\tthis.visitNode(sourceFile, sourceFile);\n\n\t\treturn {\n\t\t\ttypes  : this.graph.getAllTypes(),\n\t\t\terrors : this.errors,\n\t\t};\n\t}\n\n\t/**\n\t * Analyze source code string\n\t */\n\tanalyzeSource (sourceCode: string, fileName = 'temp.ts'): AnalyzeResult {\n\t\tconst sourceFile = ts.createSourceFile(\n\t\t\tfileName,\n\t\t\tsourceCode,\n\t\t\tts.ScriptTarget.Latest,\n\t\t\ttrue\n\t\t);\n\t\treturn this.analyzeFile(sourceFile);\n\t}\n\n\t/**\n\t * Get the type graph\n\t */\n\tgetGraph (): TypeGraphImpl {\n\t\treturn this.graph;\n\t}\n\n\t/**\n\t * Get collected definitions\n\t */\n\tgetDefinitions (): Map<string, DefinitionInfo> {\n\t\treturn this.definitions;\n\t}\n\n\t/**\n\t * Get collected usages\n\t */\n\tgetUsages (): Map<string, UsageInfo[]> {\n\t\treturn this.usages;\n\t}\n\n\t/**\n\t * Get collected EDS usages\n\t */\n\tgetEDSUsages (): Map<string, EDSInfo[]> {\n\t\treturn this.edsUsages;\n\t}\n\n\t/**\n\t * Get collected flow usages\n\t */\n\tgetFlowUsages (): Map<string, FlowInfo[]> {\n\t\treturn this.flowUsages;\n\t}\n\n\t/**\n\t * Get collected instrumentation points.\n\t * Registration sites referencing a class declared in the same project\n\t * resolve to the class declaration's location/code; external classes\n\t * (e.g., a framework-builtin implementation from node_modules) keep\n\t * the registration site.\n\t * Deduped by kind+className+location+scope with targets merged — a\n\t * class detected by heritage AND by a decorator site yields separate\n\t * entries with distinct scopes (see InstrumentationPoint in types.ts).\n\t */\n\tgetInstrumentationPoints (): InstrumentationPoint[] {\n\t\tconst points = new Map<string, InstrumentationPoint>();\n\n\t\tconst addPoint = (point: InstrumentationPoint): void => {\n\t\t\tconst key = `${point.kind}|${point.className}|${point.location}|${point.scope}`;\n\t\t\tconst existing = points.get(key);\n\t\t\tif (existing) {\n\t\t\t\tconst merged = new Set([ ...existing.targets, ...point.targets ]);\n\t\t\t\texisting.targets = Array.from(merged);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tpoints.set(key, point);\n\t\t};\n\n\t\tfor (const site of this.instrumentationSites) {\n\t\t\tconst decl = this.instrumentationClassDecls.get(site.className);\n\t\t\tconst point: InstrumentationPoint = {\n\t\t\t\tkind      : site.kind,\n\t\t\t\tclassName : site.className,\n\t\t\t\tlocation  : decl ? decl.location : site.location,\n\t\t\t\tcode      : decl ? decl.code : site.code,\n\t\t\t\tscope     : site.scope,\n\t\t\t\ttargets   : site.targets,\n\t\t\t};\n\t\t\taddPoint(point);\n\t\t}\n\n\t\t// Heritage-declared classes always emit a declaration point with\n\t\t// scope 'module' (attachment statically unknown); registration\n\t\t// sites above carry the narrower scopes as separate entries\n\t\tfor (const [ className, decl ] of this.instrumentationClassDecls) {\n\t\t\tif (!decl.kind) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst point: InstrumentationPoint = {\n\t\t\t\tkind      : decl.kind,\n\t\t\t\tclassName : className,\n\t\t\t\tlocation  : decl.location,\n\t\t\t\tcode      : decl.code,\n\t\t\t\tscope     : 'module',\n\t\t\t\ttargets   : [],\n\t\t\t};\n\t\t\taddPoint(point);\n\t\t}\n\n\t\tconst result = Array.from(points.values());\n\t\treturn result;\n\t}\n\n\t/**\n\t * Add a topologica type to the analyzer for usage tracking.\n\t * This allows the analyzer to recognize topologica types when collecting usages.\n\t */\n\taddTopologicaType (fullPath: string, node: import('./types').TypeNode): void {\n\t\t// Skip if already exists\n\t\tif (this.graph.allTypes.has(fullPath)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Add to graph so it can be found during usage collection\n\t\tif (node.parent) {\n\t\t\t// Add as child of parent\n\t\t\tthis.graph.addChild(node.parent, node);\n\t\t} else {\n\t\t\t// Add as root\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Also add to definitions so it's recognized as a known type\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : node.name,\n\t\t\tlocation    : `${node.sourceFile}:${node.line}:${node.column}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : node.parent ? node.parent.fullPath : null,\n\t\t\tstrictChain : true,\n\t\t\tblockErrors : false\n\t\t};\n\t\tthis.definitions.set(fullPath, definition);\n\t}\n\n\t/**\n\t * Set parent nodes in a source file to enable AST traversal up\n\t */\n\tprivate setParentNodesInSourceFile (sourceFile: ts.SourceFile): void {\n\t\tconst setParent = (node: ts.Node, parent?: ts.Node) => {\n\t\t\t// TypeScript doesn't expose parent as writable, but we need it\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t(node as any).parent = parent;\n\t\t\tts.forEachChild(node, child => setParent(child, node));\n\t\t};\n\t\tsetParent(sourceFile);\n\t}\n\n\t/**\n\t * Visit a node in the AST\n\t */\n\tprivate visitNode (node: ts.Node, sourceFile: ts.SourceFile, currentClass?: ts.ClassDeclaration): void {\n\t\t// Track mnemonica module-object aliases and custom collection variables\n\t\t// before processing define()/lookup() calls so source resolution works.\n\t\tthis.trackImports(node);\n\t\tthis.trackModuleObjectAliases(node);\n\t\tthis.trackCollectionAliases(node, sourceFile);\n\n\t\t// Check for define() calls\n\t\tif (this.isDefineCall(node)) {\n\t\t\tthis.processDefineCall(node as ts.CallExpression, sourceFile);\n\t\t}\n\n\t\t// Check for lazy() calls\n\t\tif (this.isLazyCall(node)) {\n\t\t\tthis.processLazyCall(node as ts.CallExpression, sourceFile);\n\t\t}\n\n\t\t// Check for decorate() decorator\n\t\tif (this.isDecorateDecorator(node)) {\n\t\t\tthis.processDecorateDecorator(node as ts.Decorator, sourceFile, currentClass);\n\t\t}\n\n\t\t// Check for type usages (new Type(), type annotations, etc.)\n\t\tthis.collectUsage(node, sourceFile);\n\n\t\t// Check for EDS patterns (wrap, current, getFlow, etc.)\n\t\tthis.collectEDS(node, sourceFile);\n\n\t\t// Check for native flow patterns (property access, method calls, etc.)\n\t\tthis.collectFlow(node, sourceFile);\n\n\t\t// Check for framework instrumentation points (vocabulary supplied\n\t\t// by plugins; syntactic only — no type checker)\n\t\tthis.collectInstrumentation(node, sourceFile);\n\n\t\t// Collect type aliases for resolving type references\n\t\tif (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name)) {\n\t\t\tthis.typeAliases.set(node.name.text, node.type);\n\t\t}\n\n\t\t// Track same-file function bindings so EDS can resolve wrap(fn)\n\t\t// arguments without the type checker (best effort, last wins)\n\t\tif (ts.isFunctionDeclaration(node) && node.name) {\n\t\t\tconst key = `${sourceFile.fileName}#${node.name.text}`;\n\t\t\tthis.functionBindings.set(key, node);\n\t\t}\n\t\tif (\n\t\t\tts.isVariableDeclaration(node) &&\n\t\t\tts.isIdentifier(node.name) &&\n\t\t\tnode.initializer &&\n\t\t\t(ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))\n\t\t) {\n\t\t\tconst key = `${sourceFile.fileName}#${node.name.text}`;\n\t\t\tthis.functionBindings.set(key, node.initializer);\n\t\t}\n\n\t\t// Track class declarations for decorator parent lookup\n\t\tif (ts.isClassDeclaration(node)) {\n\t\t\t// Visit children with this class as the current context\n\t\t\tts.forEachChild(node, child => this.visitNode(child, sourceFile, node));\n\t\t} else {\n\t\t\t// Recursively visit children\n\t\t\tts.forEachChild(node, child => this.visitNode(child, sourceFile, currentClass));\n\t\t}\n\t}\n\n\t/**\n\t * Track imports from 'mnemonica' so aliases of the module object and\n\t * createTypesCollection are recognized without relying on the type checker.\n\t */\n\tprivate trackImports (node: ts.Node): void {\n\t\tif (!ts.isImportDeclaration(node)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { moduleSpecifier } = node;\n\t\tif (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== 'mnemonica') {\n\t\t\treturn;\n\t\t}\n\n\t\tconst clause = node.importClause;\n\t\tif (!clause) {\n\t\t\treturn;\n\t\t}\n\n\t\t// import { mnemonica, createTypesCollection } from 'mnemonica'\n\t\tif (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {\n\t\t\tfor (const element of clause.namedBindings.elements) {\n\t\t\t\tconst localName = element.name.text;\n\t\t\t\tconst importedName = element.propertyName\n\t\t\t\t\t? element.propertyName.text\n\t\t\t\t\t: localName;\n\t\t\t\tif (importedName === 'mnemonica') {\n\t\t\t\t\tthis.moduleObjectVariables.add(localName);\n\t\t\t\t}\n\t\t\t\tif (importedName === 'createTypesCollection') {\n\t\t\t\t\tthis.createTypesCollectionVariables.add(localName);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// import * as mnemonica from 'mnemonica'\n\t\tif (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {\n\t\t\tthis.moduleObjectVariables.add(clause.namedBindings.name.text);\n\t\t}\n\n\t\t// import mnemonica from 'mnemonica' (default import) — treat as module object too\n\t\tif (clause.name) {\n\t\t\tthis.moduleObjectVariables.add(clause.name.text);\n\t\t}\n\t}\n\n\t/**\n\t * Track aliases of the mnemonica module object, e.g.:\n\t *   const m = mnemonica;\n\t *   const App = m;\n\t */\n\tprivate trackModuleObjectAliases (node: ts.Node): void {\n\t\tif (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { initializer } = node;\n\t\tif (!initializer) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (ts.isIdentifier(initializer) && this.moduleObjectVariables.has(initializer.text)) {\n\t\t\tthis.moduleObjectVariables.add(node.name.text);\n\t\t}\n\t}\n\n\t/**\n\t * Track custom collection variables, e.g.:\n\t *   const MyCollection = createTypesCollection();\n\t *   const Other = MyCollection;\n\t *\n\t * Also detects Option B user-provided registry interfaces:\n\t *   export interface MyCollectionRegistry {}\n\t *   const MyCollection = createTypesCollection<MyCollectionRegistry>();\n\t */\n\tprivate trackCollectionAliases (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { initializer } = node;\n\t\tif (!initializer) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Direct createTypesCollection() call\n\t\tif (this.isCreateTypesCollectionCall(initializer)) {\n\t\t\tconst collectionId = this.nextCollectionId();\n\t\t\tthis.collectionVariables.set(node.name.text, collectionId);\n\n\t\t\tconst registryInterfaceName = this.extractRegistryInterfaceName(\n\t\t\t\tinitializer as ts.CallExpression,\n\t\t\t\tsourceFile\n\t\t\t);\n\t\t\tthis.collectionInfo.set(collectionId, {\n\t\t\t\tvariableName          : node.name.text,\n\t\t\t\tsourceFile            : sourceFile.fileName,\n\t\t\t\tregistryInterfaceName : registryInterfaceName\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Alias of another collection variable\n\t\tif (ts.isIdentifier(initializer)) {\n\t\t\tconst existing = this.collectionVariables.get(initializer.text);\n\t\t\tif (existing) {\n\t\t\t\tthis.collectionVariables.set(node.name.text, existing);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Extract the registry interface name from createTypesCollection<Registry>()\n\t * when the interface is declared in the same source file.\n\t */\n\tprivate extractRegistryInterfaceName (\n\t\tcall: ts.CallExpression,\n\t\tsourceFile: ts.SourceFile\n\t): string | undefined {\n\t\tconst typeArgs = call.typeArguments;\n\t\tif (!typeArgs || typeArgs.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstTypeArg ] = typeArgs;\n\t\tif (!ts.isTypeReferenceNode(firstTypeArg) || !ts.isIdentifier(firstTypeArg.typeName)) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst name = firstTypeArg.typeName.text;\n\n\t\t// Confirm the interface exists in the same source file.\n\t\tfor (const statement of sourceFile.statements) {\n\t\t\tif (\n\t\t\t\tts.isInterfaceDeclaration(statement) &&\n\t\t\t\tstatement.name.text === name\n\t\t\t) {\n\t\t\t\treturn name;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Get the registry interface name for a collection id.\n\t */\n\tprivate getRegistryInterfaceName (collectionId?: string): string | undefined {\n\t\tif (!collectionId) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.collectionInfo.get(collectionId)?.registryInterfaceName;\n\t}\n\n\t/**\n\t * Check if an expression is a createTypesCollection() call.\n\t * Handles:\n\t *   createTypesCollection()\n\t *   ctc() // aliased import\n\t *   mnemonica.createTypesCollection() // module object method\n\t *   m.createTypesCollection() // aliased module object\n\t */\n\tprivate isCreateTypesCollectionCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\t\tconst expr = node.expression;\n\n\t\t// Direct call or aliased import: createTypesCollection() / ctc()\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text === 'createTypesCollection' ||\n\t\t\t\tthis.createTypesCollectionVariables.has(expr.text);\n\t\t}\n\n\t\t// Module object method: mnemonica.createTypesCollection()\n\t\tif (\n\t\t\tts.isPropertyAccessExpression(expr) &&\n\t\t\texpr.name.text === 'createTypesCollection' &&\n\t\t\tts.isIdentifier(expr.expression) &&\n\t\t\tthis.moduleObjectVariables.has(expr.expression.text)\n\t\t) {\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Generate a unique collection identifier.\n\t */\n\tprivate nextCollectionId (): string {\n\t\tthis.collectionCounter++;\n\t\tconst result = `collection_${this.collectionCounter}`;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a node is a define() call\n\t */\n\tprivate isDefineCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for direct call: define('TypeName', ...)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'define') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for method call: SomeType.define('SubType', ...)\n\t\tif (ts.isPropertyAccessExpression(expression)) {\n\t\t\treturn expression.name?.text === 'define';\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Check if a node is a lazy() call\n\t */\n\tprivate isLazyCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for direct call: lazy('TypeName', getter, ...)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'lazy') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for method call: SomeType.lazy('SubType', getter, ...)\n\t\tif (ts.isPropertyAccessExpression(expression)) {\n\t\t\treturn expression.name?.text === 'lazy';\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t\t* Extract config options from an object literal\n\t\t*/\n\tprivate extractConfigFromObjectLiteral (configArg: ts.ObjectLiteralExpression):\n\t\t{ strictChain?: boolean; blockErrors?: boolean } {\n\t\tconst config: { strictChain?: boolean; blockErrors?: boolean } = {};\n\n\t\tfor (const prop of configArg.properties) {\n\t\t\tif (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {\n\t\t\t\tconst propName = prop.name.text;\n\t\t\t\tif (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\t\tconfig.strictChain = true;\n\t\t\t\t} else if (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\t\tconfig.strictChain = false;\n\t\t\t\t} else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\t\tconfig.blockErrors = true;\n\t\t\t\t} else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\t\tconfig.blockErrors = false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn config;\n\t}\n\n\t/**\n\t\t* Extract config options from define() call\n\t\t*/\n\tprivate extractConfig (call: ts.CallExpression): { strictChain?: boolean; blockErrors?: boolean } {\n\t\t// Config is the third argument: define('Name', handler, config)\n\t\tconst [ , , configArg ] = call.arguments;\n\t\tif (!configArg || !ts.isObjectLiteralExpression(configArg)) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst configResult = this.extractConfigFromObjectLiteral(configArg);\n\t\treturn configResult;\n\t}\n\n\t/**\n\t\t* Check if a node is a @decorate() decorator\n\t\t*/\n\tprivate isDecorateDecorator (node: ts.Node): node is ts.Decorator {\n\t\tif (!ts.isDecorator(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for @decorate\n\t\tif (ts.isIdentifier(expression) && expression.text === 'decorate') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for @decorate() or @decorate(ParentType)\n\t\tif (ts.isCallExpression(expression)) {\n\t\t\tconst fnName = expression.expression;\n\t\t\tif (ts.isIdentifier(fnName) && fnName.text === 'decorate') {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\t// Check for @MyCollection.decorate() where MyCollection is a custom collection\n\t\t\tif (\n\t\t\t\tts.isPropertyAccessExpression(fnName) &&\n\t\t\t\tfnName.name.text === 'decorate' &&\n\t\t\t\tts.isIdentifier(fnName.expression) &&\n\t\t\t\tthis.collectionVariables.has(fnName.expression.text)\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Mark a call expression as processed and return whether it already was.\n\t */\n\tprivate markProcessed (call: ts.CallExpression): boolean {\n\t\tconst marked = call as unknown as { __tactica_processed?: boolean };\n\t\tif (marked.__tactica_processed) {\n\t\t\treturn true;\n\t\t}\n\t\tmarked.__tactica_processed = true;\n\t\treturn false;\n\t}\n\n\t/**\n\t * Process a define() call\n\t */\n\tprivate processDefineCall (call: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\t// Check if this exact call has already been processed (prevents duplicates from chained calls)\n\t\tif (this.markProcessed(call)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Get the type name and source context from arguments\n\t\tconst defineContext = this.extractDefineContext(call);\n\n\t\t// For chained calls like define('A').define('B'), we want the position of the .define('B') part\n\t\t// not the start of the entire expression\n\t\tlet positionNode: ts.Node = call;\n\n\t\t// If this is a chained call, get the position of the property access expression\n\t\t// which is the .define part\n\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t// The expression is the property access: (define('RootAsync', ...)).define\n\t\t\t// We want the position of just the .define part\n\t\t\t// This is the 'define' identifier\n\t\t\tpositionNode = call.expression.name;\n\t\t}\n\n\t\tconst startPos = positionNode.getStart(sourceFile);\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);\n\n\t\tif (!defineContext.typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Could not extract type name from define() call',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst { typeName } = defineContext;\n\n\t\t// Determine parent type and collection based on the call source.\n\t\tconst parentNode = defineContext.parentType;\n\t\tconst { collectionId } = defineContext;\n\n\t\t// Extract config options\n\t\tconst config = this.extractConfig(call);\n\n\t\t// Create type node first so its internal fullPath (including any collection prefix) is resolved.\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(collectionId);\n\n\t\t// Extract properties from constructor function\n\t\tnode.properties = this.extractProperties(call);\n\n\t\t// Extract constructor parameters for TypeRegistry signature\n\t\tnode.constructorParams = this.extractConstructorParams(call);\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Create definition info using the node's resolved fullPath\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : parentNode ? parentNode.fullPath : null,\n\t\t\tstrictChain : config.strictChain ?? true,\n\t\t\tblockErrors : config.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(node.fullPath, definition);\n\t\tthis.edsScopeByNode.set(call, node.fullPath);\n\n\t\t// Track variable assignment: const User = define('UserEntity', ...) -> map \"User\" to \"UserEntity\"\n\t\t// For chained calls like const X = define('A').define('B'), we want to map X -> A (the root)\n\t\tthis.trackVariableAssignment(call, parentNode, node.fullPath);\n\t}\n\n\t/**\n\t * Process a lazy() call\n\t */\n\tprivate processLazyCall (call: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\t// Check if this exact call has already been processed (prevents duplicates from chained calls)\n\t\tif (this.markProcessed(call)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Get the type name and source context from arguments\n\t\tconst lazyContext = this.extractLazyContext(call, sourceFile);\n\n\t\t// For chained calls like define('A').lazy('B'), we want the position of the .lazy('B') part\n\t\t// not the start of the entire expression\n\t\tlet positionNode: ts.Node = call;\n\n\t\t// If this is a chained call, get the position of the property access expression\n\t\t// which is the .lazy part\n\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t// The expression is the property access: (define('RootAsync', ...)).lazy\n\t\t\t// We want the position of just the .lazy part\n\t\t\t// This is the 'lazy' identifier\n\t\t\tpositionNode = call.expression.name;\n\t\t}\n\n\t\tconst startPos = positionNode.getStart(sourceFile);\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);\n\n\t\tif (!lazyContext.typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Could not extract type name from lazy() call',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst { typeName } = lazyContext;\n\n\t\t// Determine parent type and collection based on the call source.\n\t\tconst parentNode = lazyContext.parentType;\n\t\tconst { collectionId } = lazyContext;\n\n\t\t// Extract config options\n\t\tconst config = this.extractLazyConfig(call);\n\n\t\t// Create type node first so its internal fullPath (including any collection prefix) is resolved.\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(collectionId);\n\n\t\t// Extract properties from the constructor returned by the lazy getter\n\t\tnode.properties = this.extractProperties(call);\n\n\t\t// Extract constructor parameters for TypeRegistry signature\n\t\tnode.constructorParams = this.extractConstructorParams(call);\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Create definition info using the node's resolved fullPath\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : parentNode ? parentNode.fullPath : null,\n\t\t\tstrictChain : config.strictChain ?? true,\n\t\t\tblockErrors : config.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(node.fullPath, definition);\n\t\tthis.edsScopeByNode.set(call, node.fullPath);\n\n\t\t// Track variable assignment: const LazyType = lazy('LazyType', ...) -> map \"LazyType\" -> \"LazyType\"\n\t\t// For chained calls like const X = lazy('A').define('B'), we want to map X -> A (the root)\n\t\tthis.trackVariableAssignment(call, parentNode, node.fullPath);\n\t}\n\n\t/**\n\t * Extract lazy() call arguments into a normalized shape.\n\t * Handles named/unnamed and explicit-source forms, both as free calls\n\t * and as method calls.\n\t */\n\tprivate extractLazyCallArgs (call: ts.CallExpression): {\n\t\tsource?: ts.Expression;\n\t\tname?: string;\n\t\tgetter: ts.Expression;\n\t\tconfig?: ts.Expression;\n\t} | undefined {\n\t\tconst args = call.arguments;\n\t\tconst isMethodCall = ts.isPropertyAccessExpression(call.expression);\n\n\t\tif (isMethodCall) {\n\t\t\t// Source is the object of the property access: Type.lazy(...)\n\t\t\tconst source = call.expression.expression;\n\t\t\tif (args.length === 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst [ methodFirstArg ] = args;\n\t\t\tif (ts.isStringLiteral(methodFirstArg)) {\n\t\t\t\t// Type.lazy('Name', getter, config?)\n\t\t\t\tif (args.length < 2) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tsource,\n\t\t\t\t\tname   : methodFirstArg.text,\n\t\t\t\t\tgetter : args[ 1 ],\n\t\t\t\t\tconfig : args[ 2 ],\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Type.lazy(getter, config?)\n\t\t\treturn {\n\t\t\t\tsource,\n\t\t\t\tgetter : methodFirstArg,\n\t\t\t\tconfig : args[ 1 ],\n\t\t\t};\n\t\t}\n\n\t\t// Free call: lazy(...)\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstArg ] = args;\n\n\t\t// Explicit-source form: lazy(source, 'Name', getter, config?)\n\t\t// or lazy(source, getter, config?)\n\t\tif (args.length >= 2 && ts.isIdentifier(firstArg)) {\n\t\t\tconst [ , secondArg ] = args;\n\t\t\tif (ts.isStringLiteral(secondArg)) {\n\t\t\t\t// lazy(source, 'Name', getter, config?)\n\t\t\t\tif (args.length < 3) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tsource : firstArg,\n\t\t\t\t\tname   : secondArg.text,\n\t\t\t\t\tgetter : args[ 2 ],\n\t\t\t\t\tconfig : args[ 3 ],\n\t\t\t\t};\n\t\t\t}\n\t\t\t// lazy(source, getter, config?)\n\t\t\treturn {\n\t\t\t\tsource : firstArg,\n\t\t\t\tgetter : secondArg,\n\t\t\t\tconfig : args[ 2 ],\n\t\t\t};\n\t\t}\n\n\t\t// Named root form: lazy('Name', getter, config?)\n\t\tif (ts.isStringLiteral(firstArg)) {\n\t\t\tif (args.length < 2) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tname   : firstArg.text,\n\t\t\t\tgetter : args[ 1 ],\n\t\t\t\tconfig : args[ 2 ],\n\t\t\t};\n\t\t}\n\n\t\t// Unnamed root form: lazy(getter, config?)\n\t\treturn {\n\t\t\tgetter : firstArg,\n\t\t\tconfig : args[ 1 ],\n\t\t};\n\t}\n\n\t/**\n\t * Unwrap the constructor returned by a lazy getter.\n\t * Supports:\n\t *   () => class Name {}\n\t *   () => function Name() {}\n\t *   () => { return class Name {}; }\n\t *   function () { return function Name() {}; }\n\t */\n\tprivate unwrapLazyGetter (getterExpr: ts.Expression): ts.Expression | undefined {\n\t\tif (ts.isArrowFunction(getterExpr)) {\n\t\t\tconst { body } = getterExpr;\n\t\t\tif (!ts.isBlock(body)) {\n\t\t\t\treturn body;\n\t\t\t}\n\t\t\tfor (const stmt of body.statements) {\n\t\t\t\tif (ts.isReturnStatement(stmt) && stmt.expression) {\n\t\t\t\t\treturn stmt.expression;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif (ts.isFunctionExpression(getterExpr)) {\n\t\t\tconst { body } = getterExpr;\n\t\t\tfor (const stmt of body.statements) {\n\t\t\t\tif (ts.isReturnStatement(stmt) && stmt.expression) {\n\t\t\t\t\treturn stmt.expression;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Not a recognized getter pattern\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract a constructor name from a class expression, class declaration,\n\t * or named function expression.\n\t */\n\tprivate extractConstructorName (constructorExpr: ts.Expression): string | undefined {\n\t\tif (ts.isClassExpression(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\tif (ts.isClassDeclaration(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\tif (ts.isFunctionExpression(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the type name from either a define() or lazy() call.\n\t */\n\tprivate extractMnemonicaTypeName (call: ts.CallExpression): string | undefined {\n\t\tif (this.isDefineCall(call)) {\n\t\t\treturn this.extractTypeName(call);\n\t\t}\n\t\tif (this.isLazyCall(call)) {\n\t\t\tconst args = this.extractLazyCallArgs(call);\n\t\t\tif (!args) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tif (args.name) {\n\t\t\t\treturn args.name;\n\t\t\t}\n\t\t\tconst constructorExpr = this.unwrapLazyGetter(args.getter);\n\t\t\tif (constructorExpr) {\n\t\t\t\treturn this.extractConstructorName(constructorExpr);\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the full lazy() call context: type name, parent type, and collection.\n\t * Handles direct calls, property-access calls, chained calls, and the\n\t * explicit-source form `lazy(source, 'TypeName', getter)`.\n\t */\n\tprivate extractLazyContext (call: ts.CallExpression, sourceFile: ts.SourceFile): {\n\t\ttypeName?: string;\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\tconst args = this.extractLazyCallArgs(call);\n\t\tif (!args) {\n\t\t\treturn {};\n\t\t}\n\n\t\tlet typeName: string | undefined = args.name;\n\t\tif (!typeName) {\n\t\t\tconst constructorExpr = this.unwrapLazyGetter(args.getter);\n\t\t\tif (constructorExpr) {\n\t\t\t\ttypeName = this.extractConstructorName(constructorExpr);\n\t\t\t}\n\t\t}\n\t\tif (!typeName) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst { expression } = call;\n\n\t\t// Direct call: lazy('TypeName', ...) or lazy(source, 'TypeName', getter)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'lazy') {\n\t\t\tif (args.source && ts.isIdentifier(args.source)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(args.source.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Plain root lazy in default collection\n\t\t\treturn { typeName };\n\t\t}\n\n\t\t// Property access: X.lazy('TypeName', ...)\n\t\tif (ts.isPropertyAccessExpression(expression) && expression.name.text === 'lazy') {\n\t\t\tconst obj = expression.expression;\n\n\t\t\tif (ts.isIdentifier(obj)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(obj.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (ts.isPropertyAccessExpression(obj)) {\n\t\t\t\t// Nested access: instance.Type.lazy - try to resolve\n\t\t\t\tconst chain = this.getPropertyChain(obj);\n\t\t\t\tif (chain.length > 0) {\n\t\t\t\t\tconst parentNode = this.graph.findType(chain.join('.'));\n\t\t\t\t\treturn { typeName, parentType : parentNode };\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (ts.isCallExpression(obj)) {\n\t\t\t\t// Determine the collection context from the root of the chain so that\n\t\t\t\t// custom-collection types do not get confused with default-collection types.\n\t\t\t\tconst rootId = this.getRootIdentifier(obj.expression);\n\t\t\t\tconst expectedCollectionId = rootId\n\t\t\t\t\t? this.resolveDefineSource(rootId.text).collectionId\n\t\t\t\t\t: undefined;\n\n\t\t\t\t// Chained call: define('A').lazy('B') or lazy('A').lazy('B')\n\t\t\t\tif (this.isDefineCall(obj)) {\n\t\t\t\t\tthis.processDefineCall(obj, sourceFile);\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (this.isLazyCall(obj)) {\n\t\t\t\t\tthis.processLazyCall(obj, sourceFile);\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Builder lookup chain: App.lookup('User').lazy('Admin')\n\t\t\t\tif (this.isLookupCall(obj)) {\n\t\t\t\t\tconst lookedUpPath = this.resolveLookupPath(obj);\n\t\t\t\t\tif (lookedUpPath) {\n\t\t\t\t\t\tconst parentNode = this.graph.findType(lookedUpPath);\n\t\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode.collectionId };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn { typeName };\n\t}\n\n\t/**\n\t * Extract config options from lazy() call\n\t */\n\tprivate extractLazyConfig (call: ts.CallExpression): { strictChain?: boolean; blockErrors?: boolean } {\n\t\tconst args = this.extractLazyCallArgs(call);\n\t\tif (!args || !args.config || !ts.isObjectLiteralExpression(args.config)) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst configResult = this.extractConfigFromObjectLiteral(args.config);\n\t\treturn configResult;\n\t}\n\n\t/**\n\t\t* Track variable assignments that capture define() results\n\t\t* e.g., const User = define('UserEntity', ...) maps \"User\" -> \"UserEntity\"\n\t\t* For chained calls like const X = define('A').define('B'), we map X -> A (the root type)\n\t\t*/\n\tprivate trackVariableAssignment (\n\t\tcall: ts.CallExpression,\n\t\tparentNode: TypeNode | undefined,\n\t\tfullPath: string\n\t): void {\n\t\t// Check if this call is the right-hand side of a variable declaration\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = call.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = define(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\t// If this is a chained call (has parent), don't overwrite existing mapping\n\t\t\t\t\t// The first define in the chain sets the mapping to the root type\n\t\t\t\t\tif (parentNode && this.variableToTypeMap.has(varName)) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tthis.variableToTypeMap.set(varName, fullPath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\t\n\t/**\n\t\t* Track variable assignments from lookup() calls\n\t\t* e.g., const SentienceConstructor = lookup('Sentience') maps \"SentienceConstructor\" -> \"Sentience\"\n\t\t*/\n\tprivate trackLookupAssignment (call: ts.CallExpression, typePath: string): void {\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = call.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = lookup(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\tthis.variableToTypeMap.set(varName, typePath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\n\t/**\n\t\t* Track variable assignments from new Type() calls\n\t\t* e.g., const user = new UserType() maps \"user\" -> \"UserType\"\n\t\t*/\n\tprivate trackNewAssignment (newExpr: ts.NewExpression, typePath: string): void {\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = newExpr.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = new Type(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\tthis.variableToTypeMap.set(varName, typePath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\n\t/**\n\t\t* Process a @decorate() decorator\n\t */\n\tprivate processDecorateDecorator (\n\t\tdecorator: ts.Decorator,\n\t\tsourceFile: ts.SourceFile,\n\t\tclassDeclParam?: ts.ClassDeclaration\n\t): void {\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tdecorator.getStart(sourceFile)\n\t\t);\n\n\t\t// Get the class declaration - use the passed context if parent is not set\n\t\tconst classDecl = decorator.parent as ts.ClassDeclaration | undefined || classDeclParam;\n\t\tif (!classDecl || !classDecl.name) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Decorated class has no name',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst typeName = classDecl.name.text;\n\t\tif (!typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Decorated class has no name',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Parse decorator arguments: @decorate(), @decorate(Parent),\n\t\t// @decorate({ ... }), @decorate(Parent, { ... }),\n\t\t// @MyCollection.decorate(), @MyCollection.decorate({ ... })\n\t\tlet parentNode: TypeNode | undefined;\n\t\tlet parentFullPath: string | null = null;\n\t\tlet collectionId: string | undefined;\n\t\tlet decoratorConfig: { strictChain?: boolean; blockErrors?: boolean } = {};\n\n\t\tif (ts.isCallExpression(decorator.expression)) {\n\t\t\tconst callExpr = decorator.expression;\n\t\t\tconst callee = callExpr.expression;\n\n\t\t\t// Check for @MyCollection.decorate() where MyCollection is a custom collection.\n\t\t\t// The decorated class becomes a root type in that collection.\n\t\t\tif (\n\t\t\t\tts.isPropertyAccessExpression(callee) &&\n\t\t\t\tcallee.name.text === 'decorate' &&\n\t\t\t\tts.isIdentifier(callee.expression) &&\n\t\t\t\tthis.collectionVariables.has(callee.expression.text)\n\t\t\t) {\n\t\t\t\tcollectionId = this.collectionVariables.get(callee.expression.text);\n\t\t\t\tif (callExpr.arguments.length === 1 && ts.isObjectLiteralExpression(callExpr.arguments[ 0 ])) {\n\t\t\t\t\tdecoratorConfig = this.extractConfigFromObjectLiteral(callExpr.arguments[ 0 ]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst args = callExpr.arguments;\n\t\t\t\tlet parentArg: ts.Identifier | undefined;\n\t\t\t\tlet configArg: ts.ObjectLiteralExpression | undefined;\n\n\t\t\t\tfor (const arg of args) {\n\t\t\t\t\tif (ts.isIdentifier(arg)) {\n\t\t\t\t\t\tif (parentArg) {\n\t\t\t\t\t\t\tthis.errors.push({\n\t\t\t\t\t\t\t\tmessage : '@decorate() accepts only one parent reference',\n\t\t\t\t\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\t\t\t\t\tline    : line + 1,\n\t\t\t\t\t\t\t\tcolumn  : character + 1,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tparentArg = arg;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (ts.isObjectLiteralExpression(arg)) {\n\t\t\t\t\t\tif (configArg) {\n\t\t\t\t\t\t\tthis.errors.push({\n\t\t\t\t\t\t\t\tmessage : '@decorate() accepts only one config object',\n\t\t\t\t\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\t\t\t\t\tline    : line + 1,\n\t\t\t\t\t\t\t\tcolumn  : character + 1,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconfigArg = arg;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (parentArg) {\n\t\t\t\t\tparentNode = this.findParentTypeByIdentifier(parentArg.text);\n\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\tparentFullPath = parentNode.fullPath;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (configArg) {\n\t\t\t\t\tdecoratorConfig = this.extractConfigFromObjectLiteral(configArg);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Build full path\n\t\tconst fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;\n\n\t\t// Create definition info for decorate\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'decorate',\n\t\t\tparent      : parentFullPath,\n\t\t\tstrictChain : decoratorConfig.strictChain ?? true,\n\t\t\tblockErrors : decoratorConfig.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(fullPath, definition);\n\t\tthis.edsScopeByNode.set(classDecl, fullPath);\n\n\t\t// Create type node\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(node.collectionId);\n\n\t\t// Extract properties and constructor parameters from class members\n\t\tnode.properties = this.extractClassProperties(classDecl);\n\t\tnode.constructorParams = this.extractClassConstructorParams(classDecl);\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\t}\n\n\t/**\n\t * Extract type name from define() call arguments.\n\t * Handles:\n\t *   define('TypeName', handler)\n\t *   define(source, 'TypeName', handler)   // explicit-source form\n\t *   define(function TypeName() {})\n\t *   define(() => class TypeName {})\n\t */\n\tprivate extractTypeName (call: ts.CallExpression): string | undefined {\n\t\tconst args = call.arguments;\n\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstArg ] = args;\n\n\t\t// Explicit-source form: define(source, 'TypeName', handler)\n\t\tif (args.length >= 2 && ts.isIdentifier(firstArg) && ts.isStringLiteral(args[ 1 ])) {\n\t\t\treturn args[ 1 ].text;\n\t\t}\n\n\t\t// String literal: define('TypeName', ...)\n\t\tif (ts.isStringLiteral(firstArg)) {\n\t\t\treturn firstArg.text;\n\t\t}\n\n\t\t// Function with name: define(function TypeName() {})\n\t\tif (ts.isFunctionExpression(firstArg) && firstArg.name) {\n\t\t\treturn firstArg.name.text;\n\t\t}\n\n\t\t// Arrow function returning class: define(() => class TypeName {})\n\t\tif (ts.isArrowFunction(firstArg)) {\n\t\t\tconst { body } = firstArg;\n\t\t\tif (ts.isClassExpression(body) && body.name) {\n\t\t\t\treturn body.name.text;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the full define() call context: type name, parent type, and collection.\n\t * Handles direct calls, property-access calls, chained calls, and the\n\t * explicit-source form `define(source, 'TypeName', handler)`.\n\t */\n\tprivate extractDefineContext (call: ts.CallExpression): {\n\t\ttypeName?: string;\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\tconst typeName = this.extractTypeName(call);\n\t\tif (!typeName) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst { expression } = call;\n\n\t\t// Direct call: define('TypeName', ...) or define(source, 'TypeName', handler)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'define') {\n\t\t\t// Explicit-source form: define(source, 'TypeName', handler)\n\t\t\tif (call.arguments.length >= 2 && ts.isIdentifier(call.arguments[ 0 ])) {\n\t\t\t\tconst sourceName = call.arguments[ 0 ].text;\n\t\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Plain root define in default collection\n\t\t\treturn { typeName };\n\t\t}\n\n\t\t// Property access: X.define('TypeName', ...)\n\t\tif (ts.isPropertyAccessExpression(expression) && expression.name.text === 'define') {\n\t\t\tconst obj = expression.expression;\n\n\t\t\tif (ts.isIdentifier(obj)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(obj.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (ts.isPropertyAccessExpression(obj)) {\n\t\t\t\t// Nested access: instance.Type.define - try to resolve\n\t\t\t\tconst chain = this.getPropertyChain(obj);\n\t\t\t\tif (chain.length > 0) {\n\t\t\t\t\tconst parentNode = this.graph.findType(chain.join('.'));\n\t\t\t\t\treturn { typeName, parentType : parentNode };\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (ts.isCallExpression(obj)) {\n\t\t\t\t// Determine the collection context from the root of the chain so that\n\t\t\t\t// custom-collection types do not get confused with default-collection types.\n\t\t\t\tconst rootId = this.getRootIdentifier(obj.expression);\n\t\t\t\tconst expectedCollectionId = rootId\n\t\t\t\t\t? this.resolveDefineSource(rootId.text).collectionId\n\t\t\t\t\t: undefined;\n\n\t\t\t\t// Chained call: define('A').define('B') or mnemonica.define('A').define('B')\n\t\t\t\tif (this.isDefineCall(obj)) {\n\t\t\t\t\tthis.processDefineCall(obj, call.getSourceFile());\n\t\t\t\t\tconst parentTypeName = this.extractTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\t// Inherit collection from the parent type (if any)\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Chained lazy call: lazy('A').define('B') or Type.lazy('A').define('B')\n\t\t\t\tif (this.isLazyCall(obj)) {\n\t\t\t\t\tthis.processLazyCall(obj, call.getSourceFile());\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Builder lookup chain: App.lookup('User').define('Admin')\n\t\t\t\tif (this.isLookupCall(obj)) {\n\t\t\t\t\tconst lookedUpPath = this.resolveLookupPath(obj);\n\t\t\t\t\tif (lookedUpPath) {\n\t\t\t\t\t\tconst parentNode = this.graph.findType(lookedUpPath);\n\t\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode.collectionId };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn { typeName };\n\t}\n\n\t/**\n\t * Prefix a dotted type path with a collection identifier so custom-collection\n\t * types do not collide with default-collection types in the graph.\n\t */\n\tprivate prefixCollectionPath (path: string, collectionId: string): string {\n\t\treturn `${collectionId}::${path}`;\n\t}\n\n\t/**\n\t * Resolve a define() source identifier to either a parent type, a collection,\n\t * or the default (module object) collection.\n\t */\n\tprivate resolveDefineSource (sourceName: string): {\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\t// Module object aliases -> root in default collection\n\t\tif (this.moduleObjectVariables.has(sourceName)) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// Collection variables -> root in that collection\n\t\tconst collectionId = this.collectionVariables.get(sourceName);\n\t\tif (collectionId) {\n\t\t\treturn { collectionId };\n\t\t}\n\n\t\t// Otherwise treat as a type variable reference\n\t\tconst parentNode = this.findParentTypeByIdentifier(sourceName);\n\t\treturn { parentType : parentNode, collectionId : parentNode?.collectionId };\n\t}\n\n\t/**\n\t * Check if a call expression is a lookup() call.\n\t */\n\tprivate isLookupCall (node: ts.CallExpression): boolean {\n\t\tconst expr = node.expression;\n\t\tif (ts.isIdentifier(expr) && expr.text === 'lookup') {\n\t\t\treturn true;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr) && expr.name.text === 'lookup') {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Resolve a lookup() call to a dotted type path (best effort).\n\t * Handles:\n\t *   lookup('User')\n\t *   lookup(source, 'User')\n\t *   App.lookup('User')\n\t *   collection.lookup('User.Admin')\n\t */\n\tprivate resolveLookupPath (call: ts.CallExpression): string | undefined {\n\t\tconst args = call.arguments;\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Single-arg lookup: lookup('User') or App.lookup('User')\n\t\tif (args.length === 1) {\n\t\t\tconst [ arg ] = args;\n\t\t\tif (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {\n\t\t\t\tconst path = arg.text;\n\t\t\t\t// If this is a method call on a source, resolve relative to that source.\n\t\t\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t\t\tconst sourceExpr = call.expression.expression;\n\t\t\t\t\tif (ts.isIdentifier(sourceExpr)) {\n\t\t\t\t\t\tconst sourceName = sourceExpr.text;\n\t\t\t\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\t\t\t\tif (sourceContext.collectionId) {\n\t\t\t\t\t\t\t// Collection lookup: prefix path with the collection id\n\t\t\t\t\t\t\treturn this.prefixCollectionPath(path, sourceContext.collectionId);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (sourceContext.parentType) {\n\t\t\t\t\t\t\t// Type lookup: relative first, then root fallback\n\t\t\t\t\t\t\tconst relativePath = `${sourceContext.parentType.fullPath}.${path}`;\n\t\t\t\t\t\t\tif (this.graph.findType(relativePath)) {\n\t\t\t\t\t\t\t\treturn relativePath;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn path;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn path;\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Two-arg lookup: lookup(source, 'User')\n\t\tif (args.length >= 2) {\n\t\t\tconst [ sourceArg, pathArg ] = args;\n\t\t\tif (!ts.isIdentifier(sourceArg) || !ts.isStringLiteral(pathArg)) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst sourceName = sourceArg.text;\n\t\t\tconst path = pathArg.text;\n\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\tif (sourceContext.collectionId) {\n\t\t\t\treturn this.prefixCollectionPath(path, sourceContext.collectionId);\n\t\t\t}\n\t\t\tif (sourceContext.parentType) {\n\t\t\t\tconst relativePath = `${sourceContext.parentType.fullPath}.${path}`;\n\t\t\t\tif (this.graph.findType(relativePath)) {\n\t\t\t\t\treturn relativePath;\n\t\t\t\t}\n\t\t\t\treturn path;\n\t\t\t}\n\t\t\treturn path;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t* Find a parent type by its name, searching in the graph.\n\t\t* When collectionId is provided, only types from that collection are considered.\n\t\t*/\n\tprivate findParentTypeByName (\n\t\tname: string,\n\t\tcollectionId?: string\n\t): TypeNode | undefined {\n\t\tconst matchesCollection = (type: TypeNode): boolean => {\n\t\t\tif (collectionId === undefined) {\n\t\t\t\treturn type.collectionId === undefined;\n\t\t\t}\n\t\t\treturn type.collectionId === collectionId;\n\t\t};\n\n\t\t// First try exact match (default-collection types use the plain dotted path)\n\t\tconst exact = this.graph.findType(name);\n\t\tif (exact && matchesCollection(exact)) {\n\t\t\treturn exact;\n\t\t}\n\n\t\t// Then search through all types for one with matching name and collection\n\t\tfor (const type of this.graph.getAllTypes()) {\n\t\t\tif (type.name === name && matchesCollection(type)) {\n\t\t\t\treturn type;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t* Find a parent type from an identifier reference.\n\t\t* Handles both aliased variables (const User = define('UserEntity', ...))\n\t\t* and direct class/type names.\n\t\t*/\n\tprivate findParentTypeByIdentifier (name: string): TypeNode | undefined {\n\t\t// First check variable mapping: const User = define('UserEntity', ...)\n\t\tconst mappedFullPath = this.variableToTypeMap.get(name);\n\t\tif (mappedFullPath) {\n\t\t\tconst mappedNode = this.graph.findType(mappedFullPath);\n\t\t\tif (mappedNode) return mappedNode;\n\t\t}\n\n\t\tconst parentNode = this.findParentTypeByName(name);\n\t\treturn parentNode;\n\t}\n\n\t/**\n\t * Get the leftmost identifier of a property-access chain.\n\t * For `App.define('User').define('Admin')` this returns the `App` identifier.\n\t */\n\tprivate getRootIdentifier (expr: ts.Expression): ts.Identifier | undefined {\n\t\tlet current: ts.Expression = expr;\n\t\twhile (ts.isPropertyAccessExpression(current)) {\n\t\t\tcurrent = current.expression;\n\t\t}\n\t\tif (ts.isIdentifier(current)) {\n\t\t\treturn current;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t* Get property chain from nested access\n\t\t*/\n\tprivate getPropertyChain (expr: ts.PropertyAccessExpression | ts.Identifier): string[] {\n\t\tconst chain: string[] = [];\n\n\t\tlet current: ts.Expression = expr;\n\t\twhile (ts.isPropertyAccessExpression(current)) {\n\t\t\tif (current.name) {\n\t\t\t\tchain.unshift(current.name.text);\n\t\t\t}\n\t\t\tcurrent = current.expression;\n\t\t}\n\n\t\tif (ts.isIdentifier(current)) {\n\t\t\tchain.unshift(current.text);\n\t\t}\n\n\t\treturn chain;\n\t}\n\n\t/**\n\t * Determine the constructor expression for either a define() or lazy() call.\n\t * For define() this is the construct handler; for lazy() it is the value\n\t * returned by the lazy getter.\n\t */\n\tprivate extractConstructorExpression (call: ts.CallExpression): ts.Expression | undefined {\n\t\tconst expr = call.expression;\n\t\tconst name = ts.isIdentifier(expr)\n\t\t\t? expr.text\n\t\t\t: ts.isPropertyAccessExpression(expr)\n\t\t\t\t? expr.name.text\n\t\t\t\t: '';\n\n\t\tif (name === 'lazy') {\n\t\t\tconst lazyArgs = this.extractLazyCallArgs(call);\n\t\t\tif (!lazyArgs) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\treturn this.unwrapLazyGetter(lazyArgs.getter);\n\t\t}\n\n\t\t// define() call\n\t\tconst args = call.arguments;\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Modern form: define('Name', handler, config?)\n\t\tif (ts.isStringLiteral(args[ 0 ])) {\n\t\t\treturn args[ 1 ];\n\t\t}\n\n\t\t// Legacy form: define(function Name() {}) or define(() => class Name {})\n\t\treturn args[ 0 ];\n\t}\n\n\t/**\n\t * Extract properties from constructor function\n\t */\n\tprivate extractProperties (call: ts.CallExpression): Map<string, PropertyInfo> {\n\t\tconst constructorExpr = this.extractConstructorExpression(call);\n\t\tif (!constructorExpr) {\n\t\t\treturn new Map<string, PropertyInfo>();\n\t\t}\n\t\tconst result = this.extractPropertiesFromConstructor(constructorExpr);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Extract properties from a constructor expression (function, arrow, or class).\n\t */\n\tprivate extractPropertiesFromConstructor (constructorExpr: ts.Expression): Map<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\t// Build type map from data parameter (for this.x = data.x patterns)\n\t\tconst dataTypeMap = this.buildDataTypeMap(constructorExpr);\n\n\t\t// Handle function expression\n\t\tif (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {\n\t\t\tconst { body } = constructorExpr;\n\n\t\t\t// First, extract properties from `this` parameter type annotation\n\t\t\t// This handles patterns like: function(this: SomeType, data: SomeType) { }\n\t\t\tconst thisParamProperties = this.extractThisParamProperties(constructorExpr);\n\t\t\tfor (const [ name, propInfo ] of thisParamProperties) {\n\t\t\t\tproperties.set(name, propInfo);\n\t\t\t}\n\n\t\t\t// Function body with statements\n\t\t\tif (ts.isBlock(body)) {\n\t\t\t\tfor (const stmt of body.statements) {\n\t\t\t\t\tif (ts.isExpressionStatement(stmt)) {\n\t\t\t\t\t\tthis.extractPropertyFromStatement(stmt.expression, properties, dataTypeMap);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Handle class expression\n\t\tif (ts.isClassExpression(constructorExpr)) {\n\t\t\t// First pass: collect all property types for method inference\n\t\t\tconst classPropertyTypes = this.extractClassPropertyTypes(constructorExpr);\n\n\t\t\tfor (const member of constructorExpr.members) {\n\t\t\t\t// Handle property declarations\n\t\t\t\tif (ts.isPropertyDeclaration(member) && member.name) {\n\t\t\t\t\t// Skip private and protected properties\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = ts.isIdentifier(member.name) ? member.name.text : '';\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\ttype     : this.inferType(member.type),\n\t\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Handle method declarations\n\t\t\t\tif (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t\t// Skip private and protected methods\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = member.name.text;\n\t\t\t\t\tconst type = this.inferMethodType(member, classPropertyTypes);\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : false,\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\t// Handle getter declarations\n\t\t\t\tif (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t\t// Skip private and protected getters\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = member.name.text;\n\t\t\t\t\t// First try explicit type annotation, then infer from getter body\n\t\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\t\tif (type === 'unknown' && member.body) {\n\t\t\t\t\t\ttype = this.inferReturnTypeFromBody(member.body, classPropertyTypes);\n\t\t\t\t\t}\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\treadonly : true,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t * Build a type map from all parameters with inline object type annotations\n\t * Returns a map of \"paramName.propertyName\" -> type\n\t */\n\tprivate buildDataTypeMap (handlerArg: ts.Expression): Map<string, string> {\n\t\tconst typeMap = new Map<string, string>();\n\n\t\tif (!ts.isFunctionExpression(handlerArg) && !ts.isArrowFunction(handlerArg)) {\n\t\t\treturn typeMap;\n\t\t}\n\n\t\t// Iterate over ALL parameters\n\t\tfor (const param of handlerArg.parameters) {\n\t\t\tif (!param.name || !param.type) continue;\n\n\t\t\t// Get parameter name\n\t\t\tlet paramName = '';\n\t\t\tif (ts.isIdentifier(param.name)) {\n\t\t\t\tparamName = param.name.text;\n\t\t\t} else {\n\t\t\t\t// Skip destructured parameters for now\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Check if it's an inline object type literal\n\t\t\tif (ts.isTypeLiteralNode(param.type)) {\n\t\t\t\tfor (const member of param.type.members) {\n\t\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\t\ttypeMap.set(`${paramName}.${propName}`, type);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Store simple parameter types like `decorateValue: string`\n\t\t\t\tconst type = this.inferType(param.type);\n\t\t\t\tif (type !== 'unknown') {\n\t\t\t\t\ttypeMap.set(paramName, type);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn typeMap;\n\t}\n\n\t/**\n\t * Extract property access chain (e.g., \"dataRenamed.id\" from dataRenamed.id)\n\t * Handles fallbacks like: data.permissions || []\n\t */\n\tprivate getPropertyAccessChain (expr: ts.Expression): string | undefined {\n\t\t// Handle identifier: data\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text;\n\t\t}\n\t\t// Handle property access: data.permissions\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\tconst base = this.getPropertyAccessChain(expr.expression);\n\t\t\tif (base) {\n\t\t\t\treturn `${base}.${expr.name.text}`;\n\t\t\t}\n\t\t}\n\t\t// Handle fallback pattern: data.permissions || []\n\t\tif (ts.isBinaryExpression(expr) &&\n\t\t\texpr.operatorToken.kind === ts.SyntaxKind.BarBarToken) {\n\t\t\t// Return the left side of || operator\n\t\t\treturn this.getPropertyAccessChain(expr.left);\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract property assignment from statement\n\t */\n\tprivate extractPropertyFromStatement (\n\t\texpr: ts.Expression,\n\t\tproperties: Map<string, PropertyInfo>,\n\t\tdataTypeMap: Map<string, string> = new Map()\n\t): void {\n\t\t// Handle: this.property = value\n\t\tif (ts.isBinaryExpression(expr) &&\n\t\t\texpr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n\t\t\tconst { left } = expr;\n\n\t\t\tif (ts.isPropertyAccessExpression(left)) {\n\t\t\t\t// Check if accessing 'this' (ThisKeyword)\n\t\t\t\tif (left.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\tconst name = left.name?.text;\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\t// Try to get type from dataTypeMap using full access chain (e.g., \"dataRenamed.id\")\n\t\t\t\t\t\tconst accessChain = this.getPropertyAccessChain(expr.right);\n\t\t\t\t\t\tlet type = accessChain ? dataTypeMap.get(accessChain) : undefined;\n\t\t\t\t\t\t// If not found and RHS is a simple identifier, try looking it up directly\n\t\t\t\t\t\tif (!type && ts.isIdentifier(expr.right)) {\n\t\t\t\t\t\t\ttype = dataTypeMap.get(expr.right.text);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!type) {\n\t\t\t\t\t\t\ttype = this.inferTypeFromInitializer(expr.right, dataTypeMap);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Don't overwrite a known type from a `this` annotation\n\t\t\t\t\t\t// with an unknown-bearing inference: an empty-array\n\t\t\t\t\t\t// initializer infers 'Array<unknown>', which must not\n\t\t\t\t\t\t// clobber an annotated 'Array<{ id: number }>' either\n\t\t\t\t\t\tconst existing = properties.get(name);\n\t\t\t\t\t\tconst typeHasUnknown = !type || type.includes('unknown');\n\t\t\t\t\t\tconst existingIsKnown = existing ? !existing.type.includes('unknown') : false;\n\t\t\t\t\t\tif (existingIsKnown && typeHasUnknown) {\n\t\t\t\t\t\t\t// Keep the better type from explicit annotation\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Handle: Object.assign(this, { prop: value })\n\t\tif (ts.isCallExpression(expr)) {\n\t\t\tconst fn = expr.expression;\n\t\t\tif (ts.isPropertyAccessExpression(fn) &&\n\t\t\t\tfn.name?.text === 'assign' &&\n\t\t\t\tts.isIdentifier(fn.expression) &&\n\t\t\t\tfn.expression.text === 'Object') {\n\t\t\t\tconst args = expr.arguments;\n\t\t\t\tif (args.length >= 2 && args[ 0 ].kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\t// Extract properties from the second argument\n\t\t\t\t\tconst [ , propsArg ] = args;\n\t\t\t\t\tif (ts.isObjectLiteralExpression(propsArg)) {\n\t\t\t\t\t\tfor (const prop of propsArg.properties) {\n\t\t\t\t\t\t\tif (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {\n\t\t\t\t\t\t\t\tconst name = prop.name.text;\n\t\t\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\t\ttype     : this.inferTypeFromInitializer(prop.initializer),\n\t\t\t\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Extract properties from class declaration (including methods and getters)\n\t */\n\tprivate extractClassProperties (classDecl: ts.ClassDeclaration): Map<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\tfor (const member of classDecl.members) {\n\t\t\t// Handle property declarations\n\t\t\tif (ts.isPropertyDeclaration(member) && member.name) {\n\t\t\t\t// Skip private and protected properties\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = ts.isIdentifier(member.name) ? member.name.text : '';\n\t\t\t\tif (name) {\n\t\t\t\t\t// If no explicit type but has initializer, infer from initializer\n\t\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\t\tif (type === 'unknown' && member.initializer) {\n\t\t\t\t\t\ttype = this.inferTypeFromInitializer(member.initializer);\n\t\t\t\t\t}\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Handle method declarations\n\t\t\tif (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Skip private and protected methods\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = member.name.text;\n\t\t\t\tconst type = this.inferMethodType(member);\n\t\t\t\tproperties.set(name, {\n\t\t\t\t\tname,\n\t\t\t\t\ttype,\n\t\t\t\t\toptional : false,\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// Handle getter declarations\n\t\t\tif (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Skip private and protected getters\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = member.name.text;\n\t\t\t\t// First try explicit type annotation, then infer from getter body\n\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\tif (type === 'unknown' && member.body) {\n\t\t\t\t\ttype = this.inferReturnTypeFromBody(member.body);\n\t\t\t\t}\n\t\t\t\tproperties.set(name, {\n\t\t\t\t\tname,\n\t\t\t\t\ttype,\n\t\t\t\t\toptional : false,\n\t\t\t\t\treadonly : true,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t * Extract class property types for method return type inference\n\t * Maps property names to their TypeScript type strings\n\t * Note: Includes private/protected properties for method inference\n\t */\n\tprivate extractClassPropertyTypes (classDecl: ts.ClassExpression): Map<string, string> {\n\t\tconst propertyTypes = new Map<string, string>();\n\n\t\tfor (const member of classDecl.members) {\n\t\t\tif (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Include ALL properties (even private) for method return type inference\n\t\t\t\t// The visibility check is done when adding to output properties\n\t\t\t\tconst name = member.name.text;\n\t\t\t\tif (member.type) {\n\t\t\t\t\tpropertyTypes.set(name, this.inferType(member.type));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn propertyTypes;\n\t}\n\n\t/**\n\t * Infer method type from method declaration\n\t */\n\tprivate inferMethodType (method: ts.MethodDeclaration, classPropertyTypes?: Map<string, string>): string {\n\t\tconst params = method.parameters.map(param => {\n\t\t\tconst paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';\n\t\t\tconst paramType = this.inferType(param.type);\n\t\t\treturn `${paramName}: ${paramType}`;\n\t\t}).join(', ');\n\n\t\tconst returnType = this.inferReturnType(method, classPropertyTypes);\n\n\t\tif (params) {\n\t\t\treturn `(${params}) => ${returnType}`;\n\t\t}\n\t\treturn `() => ${returnType}`;\n\t}\n\n\t/**\n\t\t* Extract properties from `this` parameter type annotation\n\t\t* Handles patterns like: function(this: SomeType, data: SomeType) { }\n\t\t*/\n\tprivate extractThisParamProperties (handlerArg: ts.FunctionExpression | ts.ArrowFunction):\n\t\tMap<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\t// Find the `this` parameter (if any)\n\t\tfor (const param of handlerArg.parameters) {\n\t\t\tif (param.name && ts.isIdentifier(param.name) && param.name.text === 'this' && param.type) {\n\t\t\t\t// Check if it's a type reference (e.g., `this: usage`)\n\t\t\t\tif (ts.isTypeReferenceNode(param.type)) {\n\t\t\t\t\tconst typeName = ts.isIdentifier(param.type.typeName)\n\t\t\t\t\t\t? param.type.typeName.text\n\t\t\t\t\t\t: '';\n\n\t\t\t\t\t// Look up the type alias in our collected type aliases\n\t\t\t\t\tconst aliasedType = this.typeAliases.get(typeName);\n\t\t\t\t\tif (aliasedType && ts.isTypeLiteralNode(aliasedType)) {\n\t\t\t\t\t\t// Extract properties from the type literal\n\t\t\t\t\t\tfor (const member of aliasedType.members) {\n\t\t\t\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\t\t\t\tproperties.set(propName, {\n\t\t\t\t\t\t\t\t\tname     : propName,\n\t\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Check if it's directly an inline type literal (e.g., `this: { id: string }`)\n\t\t\t\telse if (ts.isTypeLiteralNode(param.type)) {\n\t\t\t\t\tfor (const member of param.type.members) {\n\t\t\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\t\t\tproperties.set(propName, {\n\t\t\t\t\t\t\t\tname     : propName,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Found the `this` parameter, no need to continue\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t\t* Infer TypeScript type from type node\n\t\t*/\n\t/**\n\t * Infer TypeScript type from type node\n\t */\n\tprivate inferType (typeNode?: ts.TypeNode): string {\n\t\tif (!typeNode) {\n\t\t\treturn 'unknown';\n\t\t}\n\n\t\tswitch (typeNode.kind) {\n\t\tcase ts.SyntaxKind.StringKeyword:\n\t\t\treturn 'string';\n\t\tcase ts.SyntaxKind.NumberKeyword:\n\t\t\treturn 'number';\n\t\tcase ts.SyntaxKind.BooleanKeyword:\n\t\t\treturn 'boolean';\n\t\tcase ts.SyntaxKind.UndefinedKeyword:\n\t\t\treturn 'undefined';\n\t\tcase ts.SyntaxKind.NullKeyword:\n\t\t\treturn 'null';\n\t\tcase ts.SyntaxKind.AnyKeyword:\n\t\t\treturn 'any';\n\t\tcase ts.SyntaxKind.UnknownKeyword:\n\t\t\treturn 'unknown';\n\t\tcase ts.SyntaxKind.VoidKeyword:\n\t\t\treturn 'void';\n\t\tcase ts.SyntaxKind.ArrayType:\n\t\t\treturn `Array<${  this.inferType((typeNode as ts.ArrayTypeNode).elementType)  }>`;\n\t\tcase ts.SyntaxKind.TypeLiteral: {\n\t\t\t// Inline-expand type literals instead of collapsing to 'object'\n\t\t\tconst typeLit = typeNode as ts.TypeLiteralNode;\n\t\t\tconst props: string[] = [];\n\t\t\tfor (const member of typeLit.members) {\n\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\tconst optional = member.questionToken ? '?' : '';\n\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\tprops.push(`${propName}${optional}: ${type}`);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `{ ${props.join('; ')} }`;\n\t\t}\n\t\tcase ts.SyntaxKind.LiteralType: {\n\t\t\t// Handle string literal types like 'user', 'admin', etc.\n\t\t\tconst { literal } = (typeNode as ts.LiteralTypeNode);\n\t\t\tif (ts.isStringLiteral(literal)) {\n\t\t\t\t// Return the actual literal value (e.g., 'user' instead of string)\n\t\t\t\treturn `'${literal.text}'`;\n\t\t\t}\n\t\t\tif (ts.isNumericLiteral(literal)) {\n\t\t\t\treturn literal.text;\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\treturn 'true';\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\treturn 'false';\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.NullKeyword) {\n\t\t\t\treturn 'null';\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.TypeReference: {\n\t\t\t// Handle type references like Map<string, number>, PropertyInfo, etc.\n\t\t\tconst typeRef = typeNode as ts.TypeReferenceNode;\n\t\t\tconst typeName = ts.isIdentifier(typeRef.typeName)\n\t\t\t\t? typeRef.typeName.text\n\t\t\t\t: ts.isQualifiedName(typeRef.typeName)\n\t\t\t\t\t? this.getQualifiedNameText(typeRef.typeName)\n\t\t\t\t\t: 'unknown';\n\n\t\t\t// Check if this is a type alias we can resolve\n\t\t\tconst aliasedType = this.typeAliases.get(typeName);\n\t\t\tif (aliasedType) {\n\t\t\t\t// Resolve the type alias\n\t\t\t\treturn this.inferType(aliasedType);\n\t\t\t}\n\n\t\t\t// Handle InstanceType<typeof X> pattern -> convert to Parent_X\n\t\t\tif (typeName === 'InstanceType' && typeRef.typeArguments && typeRef.typeArguments.length === 1) {\n\t\t\t\tconst [ arg ] = typeRef.typeArguments;\n\t\t\t\tif (arg.kind === ts.SyntaxKind.TypeQuery) {\n\t\t\t\t\tconst typeQuery = arg as ts.TypeQueryNode;\n\t\t\t\t\tif (ts.isIdentifier(typeQuery.exprName)) {\n\t\t\t\t\t\tconst queryTypeName = typeQuery.exprName.text;\n\t\t\t\t\t\t// Look up the type in the graph to get full path\n\t\t\t\t\t\tconst matchedType = this.graph.findTypeByName(queryTypeName);\n\t\t\t\t\t\tif (matchedType) {\n\t\t\t\t\t\t\t// Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry\n\t\t\t\t\t\t\treturn matchedType.fullPath.replace(/\\./g, '_');\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Fallback: just use the type name if not found in graph\n\t\t\t\t\t\treturn queryTypeName;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (!typeRef.typeArguments || typeRef.typeArguments.length === 0) {\n\t\t\t\t// Check if this type exists in our graph - convert to full path format\n\t\t\t\tconst matchedType = this.graph.findTypeByName(typeName);\n\t\t\t\tif (matchedType) {\n\t\t\t\t\t// Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry\n\t\t\t\t\treturn matchedType.fullPath.replace(/\\./g, '_');\n\t\t\t\t}\n\t\t\t\treturn typeName;\n\t\t\t}\n\n\t\t\t// Build generic type arguments\n\t\t\tconst typeArgs = typeRef.typeArguments.map(arg => this.inferType(arg));\n\t\t\treturn `${typeName}<${typeArgs.join(', ')}>`;\n\t\t}\n\t\tcase ts.SyntaxKind.UnionType: {\n\t\t\t// Handle union types like 'a' | 'b' | 'c'\n\t\t\tconst unionType = typeNode as ts.UnionTypeNode;\n\t\t\tconst types = unionType.types.map(t => this.inferType(t));\n\t\t\treturn types.join(' | ');\n\t\t}\n\t\tcase ts.SyntaxKind.IntersectionType: {\n\t\t\t// Handle intersection types like TypeA & TypeB\n\t\t\tconst intersectionType = typeNode as ts.IntersectionTypeNode;\n\t\t\tconst types = intersectionType.types.map(t => this.inferType(t));\n\t\t\treturn types.join(' & ');\n\t\t}\n\t\tcase ts.SyntaxKind.TupleType: {\n\t\t\t// Handle tuple types like [string, number]\n\t\t\tconst tupleType = typeNode as ts.TupleTypeNode;\n\t\t\tconst elements = tupleType.elements.map(elem => this.inferType(elem as ts.TypeNode));\n\t\t\treturn `[${elements.join(', ')}]`;\n\t\t}\n\t\tcase ts.SyntaxKind.OptionalType: {\n\t\t\t// Handle optional element in tuple: string?\n\t\t\tconst optionalType = typeNode as ts.OptionalTypeNode;\n\t\t\treturn `${this.inferType(optionalType.type)  }?`;\n\t\t}\n\t\tcase ts.SyntaxKind.RestType: {\n\t\t\t// Handle rest element: ...T\n\t\t\tconst restType = typeNode as ts.RestTypeNode;\n\t\t\treturn `...${  this.inferType(restType.type)}`;\n\t\t}\n\t\tcase ts.SyntaxKind.ParenthesizedType: {\n\t\t\t// Handle parenthesized types: (A | B)\n\t\t\treturn this.inferType((typeNode as ts.ParenthesizedTypeNode).type);\n\t\t}\n\t\tcase ts.SyntaxKind.IndexedAccessType: {\n\t\t\t// Handle indexed access: T[K]\n\t\t\tconst indexed = typeNode as ts.IndexedAccessTypeNode;\n\t\t\tlet objectType = this.inferType(indexed.objectType);\n\t\t\tconst indexType = this.inferType(indexed.indexType);\n\t\t\t// If objectType is 'object', try to resolve the underlying type alias\n\t\t\tif (objectType === 'object' && ts.isTypeReferenceNode(indexed.objectType)) {\n\t\t\t\tconst refName = ts.isIdentifier(indexed.objectType.typeName) ? indexed.objectType.typeName.text : '';\n\t\t\t\tconst aliased = this.typeAliases.get(refName);\n\t\t\t\tif (aliased) {\n\t\t\t\t\tobjectType = this.inferType(aliased);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `${objectType}[${indexType}]`;\n\t\t}\n\t\tcase ts.SyntaxKind.TypeOperator: {\n\t\t\t// Handle keyof, readonly, unique operators\n\t\t\tconst typeOp = typeNode as ts.TypeOperatorNode;\n\t\t\tconst operator = ts.SyntaxKind[ typeOp.operator ];\n\t\t\treturn `${operator} ${this.inferType(typeOp.type)}`;\n\t\t}\n\t\tcase ts.SyntaxKind.TypeQuery: {\n\t\t\t// Handle typeof expressions like `typeof UsageEntry`\n\t\t\tconst typeQuery = typeNode as ts.TypeQueryNode;\n\t\t\tif (ts.isIdentifier(typeQuery.exprName)) {\n\t\t\t\treturn `typeof ${typeQuery.exprName.text}`;\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tdefault:\n\t\t\t// For complex types, return the text representation\n\t\t\treturn 'unknown';\n\t\t}\n\t}\n\n\t/**\n\t\t* Infer return type from a method declaration\n\t\t* Uses explicit return type annotation or infers from return statements\n\t\t*/\n\tprivate inferReturnType (method: ts.MethodDeclaration, classPropertyTypes?: Map<string, string>): string {\n\t\t// If method has explicit return type annotation, use it\n\t\tif (method.type) {\n\t\t\treturn this.inferType(method.type);\n\t\t}\n\n\t\t// Otherwise, try to infer from return statements in the method body\n\t\tif (method.body) {\n\t\t\treturn this.inferReturnTypeFromBody(method.body, classPropertyTypes);\n\t\t}\n\n\t\treturn 'unknown';\n\t}\n\n\t/**\n\t\t* Infer return type by analyzing return statements in the method body\n\t\t*/\n\tprivate inferReturnTypeFromBody (body: ts.Block, classPropertyTypes?: Map<string, string>): string {\n\t\tconst returnTypes = new Set<string>();\n\n\t\tconst visit = (node: ts.Node): void => {\n\t\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\t\tconst type = this.inferTypeFromInitializer(node.expression, undefined, classPropertyTypes);\n\t\t\t\tif (type !== 'unknown') {\n\t\t\t\t\treturnTypes.add(type);\n\t\t\t\t}\n\t\t\t}\n\t\t\tts.forEachChild(node, visit);\n\t\t};\n\n\t\tvisit(body);\n\n\t\tif (returnTypes.size === 0) {\n\t\t\treturn 'void';\n\t\t}\n\t\tif (returnTypes.size === 1) {\n\t\t\treturn Array.from(returnTypes)[ 0 ];\n\t\t}\n\t\treturn Array.from(returnTypes).join(' | ');\n\t}\n\n\t/**\n\t\t* Get full text from a qualified name (e.g., Namespace.Type)\n\t\t*/\n\tprivate getQualifiedNameText (qualifiedName: ts.QualifiedName): string {\n\t\tconst parts: string[] = [];\n\t\tlet current: ts.QualifiedName | ts.Identifier = qualifiedName;\n\n\t\twhile (ts.isQualifiedName(current)) {\n\t\t\tparts.unshift(current.right.text);\n\t\t\tcurrent = current.left;\n\t\t}\n\t\tparts.unshift(current.text);\n\n\t\treturn parts.join('.');\n\t}\n\n\t/**\n\t * Infer type from initializer\n\t */\n\tprivate inferTypeFromInitializer (\n\t\tinitializer: ts.Expression,\n\t\tdataTypeMap?: Map<string, string>,\n\t\tclassPropertyTypes?: Map<string, string>\n\t): string {\n\t\tswitch (initializer.kind) {\n\t\tcase ts.SyntaxKind.StringLiteral:\n\t\t\treturn 'string';\n\t\tcase ts.SyntaxKind.NumericLiteral:\n\t\t\treturn 'number';\n\t\tcase ts.SyntaxKind.TrueKeyword:\n\t\tcase ts.SyntaxKind.FalseKeyword:\n\t\t\treturn 'boolean';\n\t\tcase ts.SyntaxKind.NullKeyword:\n\t\t\treturn 'null';\n\t\tcase ts.SyntaxKind.UndefinedKeyword:\n\t\t\treturn 'undefined';\n\t\tcase ts.SyntaxKind.ArrayLiteralExpression:\n\t\t\treturn 'Array<unknown>';\n\t\tcase ts.SyntaxKind.ObjectLiteralExpression:\n\t\t\treturn 'object';\n\t\tcase ts.SyntaxKind.NewExpression: {\n\t\t\t// Handle new Date(), new Map(), etc.\n\t\t\tconst newExpr = initializer as ts.NewExpression;\n\t\t\tif (ts.isIdentifier(newExpr.expression)) {\n\t\t\t\treturn newExpr.expression.text;\n\t\t\t}\n\t\t\treturn 'object';\n\t\t}\n\t\tcase ts.SyntaxKind.BinaryExpression: {\n\t\t\t// Handle arithmetic operations: a * b, a + b, a - b, a / b\n\t\t\tconst binaryExpr = initializer as ts.BinaryExpression;\n\t\t\tconst leftType = this.inferTypeFromInitializer(binaryExpr.left, dataTypeMap, classPropertyTypes);\n\t\t\tconst rightType = this.inferTypeFromInitializer(binaryExpr.right, dataTypeMap, classPropertyTypes);\n\t\t\t\t\n\t\t\t// Check if it's an arithmetic operator\n\t\t\tconst operator = binaryExpr.operatorToken.kind;\n\t\t\tif (operator === ts.SyntaxKind.AsteriskToken ||\n\t\t\t\t    operator === ts.SyntaxKind.SlashToken ||\n\t\t\t\t    operator === ts.SyntaxKind.MinusToken ||\n\t\t\t\t    operator === ts.SyntaxKind.PercentToken) {\n\t\t\t\t// Arithmetic operations on numbers produce numbers\n\t\t\t\tif ((leftType === 'number' || leftType === 'unknown') &&\n\t\t\t\t\t    (rightType === 'number' || rightType === 'unknown')) {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (operator === ts.SyntaxKind.PlusToken) {\n\t\t\t\t// Plus can be addition or string concatenation\n\t\t\t\tif (leftType === 'string' || rightType === 'string') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\tif (leftType === 'number' && rightType === 'number') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.PropertyAccessExpression: {\n\t\t\t// Handle property access like data.value, data.id\n\t\t\tif (dataTypeMap) {\n\t\t\t\tconst accessChain = this.getPropertyAccessChain(initializer);\n\t\t\t\tif (accessChain) {\n\t\t\t\t\tconst type = dataTypeMap.get(accessChain);\n\t\t\t\t\tif (type) {\n\t\t\t\t\t\treturn type;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Handle this.map.size pattern (Map.size returns number)\n\t\t\tconst propAccess = initializer as ts.PropertyAccessExpression;\n\t\t\tif (ts.isPropertyAccessExpression(propAccess.expression)) {\n\t\t\t\tconst outerProp = propAccess.expression;\n\t\t\t\t// Check for this.map pattern\n\t\t\t\tlet innerName = '';\n\t\t\t\tif (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\tinnerName = 'this';\n\t\t\t\t} else if (ts.isIdentifier(outerProp.expression)) {\n\t\t\t\t\tinnerName = outerProp.expression.text;\n\t\t\t\t}\n\t\t\t\tconst mapProp = outerProp.name.text;\n\t\t\t\tconst finalProp = propAccess.name.text;\n\t\t\t\t// this.map.size -> number\n\t\t\t\tif (innerName === 'this' && mapProp === 'map' && finalProp === 'size') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.Identifier: {\n\t\t\t// Handle identifier references if in dataTypeMap\n\t\t\tif (dataTypeMap) {\n\t\t\t\tconst name = (initializer as ts.Identifier).text;\n\t\t\t\tconst type = dataTypeMap.get(name);\n\t\t\t\tif (type) {\n\t\t\t\t\treturn type;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.CallExpression: {\n\t\t\t// Handle function calls like Date.now(), parseInt(), etc.\n\t\t\tconst callExpr = initializer as ts.CallExpression;\n\t\t\tif (ts.isPropertyAccessExpression(callExpr.expression)) {\n\t\t\t\tconst methodName = callExpr.expression.name.text;\n\t\t\t\tconst objName = ts.isIdentifier(callExpr.expression.expression)\n\t\t\t\t\t? callExpr.expression.expression.text\n\t\t\t\t\t: '';\n\t\t\t\t\t\n\t\t\t\t// Date.now() -> number\n\t\t\t\tif (objName === 'Date' && methodName === 'now') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\t// String methods that return string\n\t\t\t\tif (methodName === 'toString' || methodName === 'valueOf') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\t// Handle Map property access on class instances (this.map.*)\n\t\t\t\tif (ts.isPropertyAccessExpression(callExpr.expression.expression)) {\n\t\t\t\t\tconst outerProp = callExpr.expression.expression;\n\t\t\t\t\t// Handle both 'this' keyword and identifier patterns\n\t\t\t\t\tlet innerName = '';\n\t\t\t\t\tif (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\t\tinnerName = 'this';\n\t\t\t\t\t} else if (ts.isIdentifier(outerProp.expression)) {\n\t\t\t\t\t\tinnerName = outerProp.expression.text;\n\t\t\t\t\t}\n\t\t\t\t\tconst mapProp = outerProp.name.text;\n\t\t\t\t\t// this.map.X() patterns\n\t\t\t\t\tif (innerName === 'this' && mapProp === 'map') {\n\t\t\t\t\t\t// Try to get the Map's value type from class properties\n\t\t\t\t\t\tlet mapValueType = 'unknown';\n\t\t\t\t\t\tif (classPropertyTypes) {\n\t\t\t\t\t\t\tconst mapType = classPropertyTypes.get('map');\n\t\t\t\t\t\t\tif (mapType && mapType.startsWith('Map<')) {\n\t\t\t\t\t\t\t\t// Parse Map<K, V> to get V\n\t\t\t\t\t\t\t\tconst match = mapType.match(/Map<[^,]+,\\s*(.+)>$/);\n\t\t\t\t\t\t\t\tif (match) {\n\t\t\t\t\t\t\t\t\t[ , mapValueType ] = match;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (methodName === 'has') return 'boolean';\n\t\t\t\t\t\tif (methodName === 'set') return 'this';\n\t\t\t\t\t\tif (methodName === 'get') return mapValueType;\n\t\t\t\t\t\tif (methodName === 'delete') return 'boolean';\n\t\t\t\t\t\tif (methodName === 'clear') return 'void';\n\t\t\t\t\t\tif (methodName === 'values') return `IterableIterator<${mapValueType}>`;\n\t\t\t\t\t\tif (methodName === 'keys') return 'IterableIterator<string>';\n\t\t\t\t\t\tif (methodName === 'entries') return `IterableIterator<[string, ${mapValueType}]>`;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Direct map.X() calls\n\t\t\t\tif (objName === 'map' || objName === 'obj') {\n\t\t\t\t\tif (methodName === 'has') return 'boolean';\n\t\t\t\t\tif (methodName === 'set') return 'this';\n\t\t\t\t\tif (methodName === 'get') return 'unknown';\n\t\t\t\t\tif (methodName === 'delete') return 'boolean';\n\t\t\t\t\tif (methodName === 'clear') return 'void';\n\t\t\t\t\tif (methodName === 'values') return 'IterableIterator<unknown>';\n\t\t\t\t\tif (methodName === 'keys') return 'IterableIterator<string>';\n\t\t\t\t\tif (methodName === 'entries') return 'IterableIterator<[string, unknown]>';\n\t\t\t\t}\n\t\t\t}\n\t\t\t// parseInt, parseFloat -> number\n\t\t\tif (ts.isIdentifier(callExpr.expression)) {\n\t\t\t\tconst fnName = callExpr.expression.text;\n\t\t\t\tif (fnName === 'parseInt' || fnName === 'parseFloat') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'String') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'Number') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'Boolean') {\n\t\t\t\t\treturn 'boolean';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.TemplateExpression:\n\t\tcase ts.SyntaxKind.NoSubstitutionTemplateLiteral: {\n\t\t\t// Template literals like `${baseValue}-${extra}` always produce strings\n\t\t\treturn 'string';\n\t\t}\n\t\tdefault:\n\t\t\treturn 'unknown';\n\t\t}\n\t}\n\t\n\t/**\n\t\t\t* Collect usage information for type references\n\t\t\t*/\n\tprivate collectUsage (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\t// Check for new Type() instantiation\n\t\tif (ts.isNewExpression(node) && node.expression) {\n\t\t\tlet typeName: string | undefined;\n\t\t\tif (ts.isPropertyAccessExpression(node.expression)) {\n\t\t\t\ttypeName = this.resolveTypePath(node.expression);\n\t\t\t} else {\n\t\t\t\ttypeName = this.getTypeNameFromExpression(node.expression);\n\t\t\t}\n\t\t\tif (typeName) {\n\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\tthis.addUsage(typeName, {\n\t\t\t\t\tlocation        : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\tkind            : 'instantiation',\n\t\t\t\t\tcode            : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t// Constructor expression text ('Thing', 'user.AdminEntity',\n\t\t\t\t\t// a lookup alias) — CreationAnchor.constructorText (Phase 3)\n\t\t\t\t\tconstructorText : node.expression.getText(sourceFile).slice(0, 100),\n\t\t\t\t});\n\t\t\t\t// Track variable assignment from new Type() for flow analysis\n\t\t\t\tthis.trackNewAssignment(node, typeName);\n\t\t\t\t// Also record as flow event\n\t\t\t\tthis.addFlow(typeName, {\n\t\t\t\t\tlocation : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\tkind     : 'instantiation',\n\t\t\t\t\tcode     : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\tcontext  : 'new expression',\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\n\t\t// Check for property access on instances (user.AdminType)\n\t\tif (ts.isPropertyAccessExpression(node)) {\n\t\t\tconst propName = node.name.text;\n\t\t\t// Check if this looks like a type access pattern\n\t\t\tif (propName && this.isLikelyTypeName(propName)) {\n\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\t\t// Try to resolve full path\n\t\t\t\tconst fullPath = this.resolveTypePath(node);\n\t\t\t\tif (fullPath) {\n\t\t\t\t\tthis.addUsage(fullPath, {\n\t\t\t\t\t\tlocation : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\t\tkind     : 'propertyAccess',\n\t\t\t\t\t\tcode     : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\t// Check for lookup('TypeName') or lookup(source, 'TypeName') calls\n\t\tif (ts.isCallExpression(node) && node.expression) {\n\t\t\tconst funcName = this.getFunctionName(node.expression);\n\t\t\tif (funcName === 'lookup' && node.arguments.length > 0) {\n\t\t\t\tconst typePath = this.resolveLookupPath(node);\n\t\t\t\tif (typePath) {\n\t\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\t\tsourceFile,\n\t\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t\t);\n\t\t\t\t\tthis.addUsage(typePath, {\n\t\t\t\t\t\tlocation : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\t\tkind     : 'lookup',\n\t\t\t\t\t\tcode     : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t});\n\t\t\t\t\t// Track variable assignment from lookup for instantiation tracking\n\t\t\t\t\tthis.trackLookupAssignment(node, typePath);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t\t\t* Get function name from expression (identifier or property access)\n\t\t\t*/\n\tprivate getFunctionName (expr: ts.Expression): string | undefined {\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\treturn expr.name.text;\n\t\t}\n\t\treturn undefined;\n\t}\n\t\n\t/**\n\t\t\t* Add a usage to the collection\n\t\t\t*/\n\tprivate addUsage (typePath: string, usage: UsageInfo): void {\n\t\t// Only track usages of mnemonica-defined types\n\t\tif (!this.definitions.has(typePath)) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.usages.has(typePath)) {\n\t\t\tthis.usages.set(typePath, []);\n\t\t}\n\n\t\t// Check for duplicates based on location, code, and kind\n\t\tconst existingUsages = this.usages.get(typePath)!;\n\t\tconst isDuplicate = existingUsages.some(existing =>\n\t\t\texisting.location === usage.location &&\n\t\t\t\texisting.code === usage.code &&\n\t\t\t\texisting.kind === usage.kind);\n\n\t\tif (!isDuplicate) {\n\t\t\texistingUsages.push(usage);\n\t\t}\n\t}\n\n\t/**\n\t * Collect EDS (Execution Data Storage) usage information\n\t */\n\tprivate collectEDS (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isCallExpression(node) || !node.expression) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst funcName = this.getFunctionName(node.expression);\n\t\tif (!funcName) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\t\t// Enclosing mnemonica type path — wrap args are usually local\n\t\t// functions, so the owning define()/lazy() handler or decorated\n\t\t// class is what eds.json consumers (GraphBuilder) can join on.\n\t\tconst scope = this.resolveEDSScope(node);\n\n\t\t// wrap(fn), wrapConstructorArg(fn, parent), upgradeConstructorArg(arg, inst), wrapInstanceMethods(obj)\n\t\tif (\n\t\t\tfuncName === 'wrap' ||\n\t\t\tfuncName === 'wrapConstructorArg' ||\n\t\t\tfuncName === 'upgradeConstructorArg' ||\n\t\t\tfuncName === 'wrapInstanceMethods'\n\t\t) {\n\t\t\tconst targetType = this.resolveEDSArgumentType(node.arguments[ 0 ]);\n\t\t\tconst info: EDSInfo = {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'wrap',\n\t\t\t\tcode,\n\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\tscope,\n\t\t\t\tfn         : funcName,\n\t\t\t};\n\t\t\t// dive's wrap-family signatures (dive/src/index.ts):\n\t\t\t//   wrap(fn, label?) | wrap(fn, context?, label?)\n\t\t\t//   wrapConstructorArg(fn, context)\n\t\t\t//   upgradeConstructorArg(arg, instance)\n\t\t\t//   wrapInstanceMethods(instance)\n\t\t\t// …so the instance/context arg sits at args[1] (args[0] for\n\t\t\t// wrapInstanceMethods) and a string literal in args[1..2] is the label\n\t\t\tconst instanceArgNode = funcName === 'wrapInstanceMethods'\n\t\t\t\t? node.arguments[ 0 ]\n\t\t\t\t: node.arguments[ 1 ];\n\t\t\tif (instanceArgNode && ts.isIdentifier(instanceArgNode)) {\n\t\t\t\tinfo.instanceArg = instanceArgNode.text;\n\t\t\t}\n\t\t\tfor (const extraArg of [ node.arguments[ 1 ], node.arguments[ 2 ] ]) {\n\t\t\t\tif (extraArg && ts.isStringLiteral(extraArg)) {\n\t\t\t\t\tinfo.label = extraArg.text;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// A wrap() call nested inside another wrapped body carries the\n\t\t\t// link to the site whose runtime wrapping caused it\n\t\t\tconst via = this.nestedWrapVia.get(node);\n\t\t\tif (via) {\n\t\t\t\tinfo.via = via;\n\t\t\t}\n\t\t\t// dive wraps returned functions too, and any mnemonica instance\n\t\t\t// created inside the wrapped body is a guaranteed path hit —\n\t\t\t// both are calculable AoT, so record them\n\t\t\tconst wrapped = this.resolveFunctionArgument(node.arguments[ 0 ], sourceFile);\n\t\t\tif (wrapped) {\n\t\t\t\t// The wrapped callback gets its own scope in scopes.json keyed by\n\t\t\t\t// its start position — record that scopeId so graph consumers can\n\t\t\t\t// join a wrap entry to the callback's creation node\n\t\t\t\tconst callbackPos = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\twrapped.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\tconst callbackFile = nodePath.resolve(sourceFile.fileName);\n\t\t\t\tinfo.callbackScopeId = `${callbackFile}:${callbackPos.line + 1}:${callbackPos.character + 1}`;\n\t\t\t\tconst createsTypes = new Set<string>();\n\t\t\t\tthis.analyzeWrappedBody(wrapped, location, sourceFile, 0, new Set(), createsTypes);\n\t\t\t\tif (createsTypes.size > 0) {\n\t\t\t\t\tinfo.createsTypes = Array.from(createsTypes);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst stored = this.addEDS(targetType || scope || 'unknown', info);\n\t\t\tthis.wrapEntryByNode.set(node, stored);\n\t\t\treturn;\n\t\t}\n\n\t\t// current(), getErrorInstance(err), getFlow(target?)\n\t\tif (funcName === 'current' || funcName === 'getErrorInstance' || funcName === 'getFlow') {\n\t\t\tthis.addEDS(scope || 'unknown', {\n\t\t\t\tlocation,\n\t\t\t\tkind : 'contextConsume',\n\t\t\t\tcode,\n\t\t\t\tscope,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// attachHooks(collection) — from @mnemonica/otel, wires a\n\t\t// TypesCollection to dive's lifecycle tracing\n\t\tif (funcName === 'attachHooks' && node.arguments.length > 0) {\n\t\t\tconst [ arg ] = node.arguments;\n\t\t\tif (ts.isArrayLiteralExpression(arg)) {\n\t\t\t\tfor (const element of arg.elements) {\n\t\t\t\t\tconst targetType = this.resolveEDSArgumentType(element);\n\t\t\t\t\tthis.addEDS(targetType || scope || 'unknown', {\n\t\t\t\t\t\tlocation,\n\t\t\t\t\t\tkind       : 'hookAttach',\n\t\t\t\t\t\tcode,\n\t\t\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\t\t\tscope,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst targetType = this.resolveEDSArgumentType(arg);\n\t\t\t\tthis.addEDS(targetType || scope || 'unknown', {\n\t\t\t\t\tlocation,\n\t\t\t\t\tkind       : 'hookAttach',\n\t\t\t\t\tcode,\n\t\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\t\tscope,\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t}\n\n\t/**\n\t * Resolve type from EDS call argument (best effort)\n\t */\n\tprivate resolveEDSArgumentType (arg: ts.Expression | undefined): string | undefined {\n\t\tif (!arg) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Identifier: variable name\n\t\tif (ts.isIdentifier(arg)) {\n\t\t\tconst mapped = this.variableToTypeMap.get(arg.text);\n\t\t\tif (mapped) {\n\t\t\t\treturn mapped;\n\t\t\t}\n\t\t\t// Maybe it's a type name directly\n\t\t\tif (this.definitions.has(arg.text)) {\n\t\t\t\treturn arg.text;\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Property access: obj.prop\n\t\tif (ts.isPropertyAccessExpression(arg)) {\n\t\t\treturn this.resolveTypePath(arg);\n\t\t}\n\n\t\t// This expression: this.something\n\t\tif (ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.expression) && arg.expression.text === 'this') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve the enclosing mnemonica scope of an EDS call site by walking\n\t * up the parent chain: nearest define()/lazy() call whose handler holds\n\t * the node, or nearest @decorate()-ed class declaration. Best effort —\n\t * returns undefined for calls outside any type scope (module top level).\n\t */\n\tprivate resolveEDSScope (node: ts.Node): string | undefined {\n\t\tlet current: ts.Node | undefined = node.parent;\n\t\twhile (current) {\n\t\t\tconst scopePath = this.edsScopeByNode.get(current);\n\t\t\tif (scopePath) {\n\t\t\t\treturn scopePath;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve a wrap() argument to its function node without the type\n\t * checker: direct function expressions/arrows, or same-file bindings\n\t * (`const fn = () => ...`, `function fn() ...`). Best effort — method\n\t * references, .bind() products and cross-file identifiers stay\n\t * unresolved; the callsite entry itself is still recorded.\n\t */\n\tprivate resolveFunctionArgument (\n\t\targ: ts.Expression | undefined,\n\t\tsourceFile: ts.SourceFile\n\t): ts.FunctionLikeDeclaration | undefined {\n\t\tif (!arg) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {\n\t\t\treturn arg;\n\t\t}\n\t\tif (ts.isIdentifier(arg)) {\n\t\t\tconst key = `${sourceFile.fileName}#${arg.text}`;\n\t\t\tconst bound = this.functionBindings.get(key);\n\t\t\tif (bound) {\n\t\t\t\treturn bound;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Analyse a wrapped function's body for guaranteed runtime paths:\n\t * dive wraps returned functions as well (recursively), so each\n\t * function-valued return is a nested wrap site, and each `new Type()`\n\t * inside the body means the path hits that type's constructor (which\n\t * attachHooks wraps too). Both facts are 100% ensured, so they are\n\t * recorded AoT. Nested function bodies are NOT walked here — they\n\t * belong to their own wrap analysis, reached via the return chain.\n\t * Depth-capped and cycle-guarded.\n\t */\n\tprivate analyzeWrappedBody (\n\t\tfn: ts.FunctionLikeDeclaration,\n\t\tviaLocation: string,\n\t\tsourceFile: ts.SourceFile,\n\t\tdepth: number,\n\t\tvisited: Set<ts.Node>,\n\t\tcreatesTypes: Set<string>\n\t): void {\n\t\tif (depth > 5 || visited.has(fn) || !fn.body) {\n\t\t\treturn;\n\t\t}\n\t\tvisited.add(fn);\n\n\t\t// Arrow with expression body: implicit return\n\t\tif (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) {\n\t\t\tthis.recordWrappedReturn(fn.body, viaLocation, sourceFile, depth, visited);\n\t\t\treturn;\n\t\t}\n\n\t\tconst walk = (node: ts.Node): void => {\n\t\t\tif (node !== fn.body && (\n\t\t\t\tts.isFunctionExpression(node) ||\n\t\t\t\tts.isArrowFunction(node) ||\n\t\t\t\tts.isFunctionDeclaration(node) ||\n\t\t\t\tts.isMethodDeclaration(node)\n\t\t\t)) {\n\t\t\t\t// nested function bodies are analysed through the return chain\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\t\tthis.recordWrappedReturn(node.expression, viaLocation, sourceFile, depth, visited);\n\t\t\t}\n\t\t\tif (ts.isNewExpression(node)) {\n\t\t\t\tconst created = this.resolveExpressionType(node.expression) ||\n\t\t\t\t\t(ts.isIdentifier(node.expression) && this.definitions.has(node.expression.text)\n\t\t\t\t\t\t? node.expression.text\n\t\t\t\t\t\t: undefined);\n\t\t\t\tif (created) {\n\t\t\t\t\tcreatesTypes.add(created);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (ts.isCallExpression(node)) {\n\t\t\t\tconst nestedName = this.getFunctionName(node.expression);\n\t\t\t\tif (\n\t\t\t\t\tnestedName === 'wrap' ||\n\t\t\t\t\tnestedName === 'wrapConstructorArg' ||\n\t\t\t\t\tnestedName === 'upgradeConstructorArg' ||\n\t\t\t\t\tnestedName === 'wrapInstanceMethods'\n\t\t\t\t) {\n\t\t\t\t\t// the nested call may already be collected (visited\n\t\t\t\t\t// before this outer wrap site) — back-patch its entry,\n\t\t\t\t\t// otherwise leave the link for collectEDS to pick up\n\t\t\t\t\tconst nestedEntry = this.wrapEntryByNode.get(node);\n\t\t\t\t\tif (nestedEntry) {\n\t\t\t\t\t\tnestedEntry.via = viaLocation;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.nestedWrapVia.set(node, viaLocation);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tts.forEachChild(node, walk);\n\t\t};\n\t\twalk(fn.body);\n\t}\n\n\t/**\n\t * Record one function-valued return of a wrapped body as a nested wrap\n\t * site (`via` = the site whose wrapping caused it) and recurse into\n\t * its own returns. Returns through identifiers resolve through the\n\t * same-file bindings table; unresolvable returns are simply skipped.\n\t */\n\tprivate recordWrappedReturn (\n\t\texpr: ts.Expression,\n\t\tviaLocation: string,\n\t\tsourceFile: ts.SourceFile,\n\t\tdepth: number,\n\t\tvisited: Set<ts.Node>\n\t): void {\n\t\tconst returned = this.resolveFunctionArgument(expr, sourceFile);\n\t\tif (!returned) {\n\t\t\treturn;\n\t\t}\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\treturned.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = returned.getText(sourceFile).slice(0, 100);\n\t\tconst scope = this.resolveEDSScope(returned);\n\t\tconst entry = this.addEDS(scope || 'unknown', {\n\t\t\tlocation,\n\t\t\tkind : 'wrap',\n\t\t\tcode,\n\t\t\tscope,\n\t\t\tvia  : viaLocation,\n\t\t\t// dive wraps returned functions through the same wrap machinery\n\t\t\tfn   : 'wrap',\n\t\t});\n\t\t// the returned function's own returns are wrapped in turn; `via`\n\t\t// chains to this nested entry's location\n\t\tconst nestedCreates = new Set<string>();\n\t\tthis.analyzeWrappedBody(returned, location, sourceFile, depth + 1, visited, nestedCreates);\n\t\tif (nestedCreates.size > 0) {\n\t\t\tentry.createsTypes = Array.from(nestedCreates);\n\t\t}\n\t}\n\n\t/**\n\t * Add an EDS usage to the collection\n\t * Returns the stored entry (the existing one when this is a duplicate),\n\t * so callers can enrich it after nested body analysis.\n\t */\n\tprivate addEDS (typePath: string, info: EDSInfo): EDSInfo {\n\t\tif (!this.edsUsages.has(typePath)) {\n\t\t\tthis.edsUsages.set(typePath, []);\n\t\t}\n\n\t\tconst existing = this.edsUsages.get(typePath)!;\n\t\tconst duplicate = existing.find(e => {\n\t\t\treturn e.location === info.location &&\n\t\t\t\te.kind === info.kind &&\n\t\t\t\te.code === info.code;\n\t\t});\n\n\t\tif (duplicate) {\n\t\t\treturn duplicate;\n\t\t}\n\t\texisting.push(info);\n\t\treturn info;\n\t}\n\n\t/**\n\t * Collect native flow patterns (instance usage after creation)\n\t * Phase 1: property access, method calls, arguments, return, destructuring, etc.\n\t */\n\tprivate collectFlow (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\t// Property read: user.name or user?.name\n\t\tif (ts.isPropertyAccessExpression(node)) {\n\t\t\tthis.collectFlowPropertyAccess(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Element access: user['name']\n\t\tif (ts.isElementAccessExpression(node)) {\n\t\t\tthis.collectFlowElementAccess(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Property write: user.name = value\n\t\tif (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n\t\t\tthis.collectFlowAssignment(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Method call: user.validate()  AND  argument passing: processUser(user)\n\t\tif (ts.isCallExpression(node) && node.expression) {\n\t\t\tthis.collectFlowMethodCall(node, sourceFile);\n\t\t\tthis.collectFlowArgumentPass(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Destructure read: const { name } = user\n\t\tif (ts.isVariableDeclaration(node) && node.initializer) {\n\t\t\tthis.collectFlowDestructure(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Return instance: return user\n\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\tthis.collectFlowReturn(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Spread: { ...user }\n\t\tif (ts.isSpreadElement(node)) {\n\t\t\tthis.collectFlowSpread(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\t}\n\n\t/**\n\t * Collect property access flow (read or conditional)\n\t */\n\tprivate collectFlowPropertyAccess (node: ts.PropertyAccessExpression, sourceFile: ts.SourceFile): void {\n\t\tconst objectType = this.resolveExpressionType(node.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst propName = node.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Skip if this is a type constructor access (e.g., UserType.define)\n\t\tif (propName === 'define' || propName === 'lazy') { return; }\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind         : 'propertyRead',\n\t\t\tcode,\n\t\t\tpropertyName : propName,\n\t\t\ttargetType   : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect element access flow: user['name']\n\t */\n\tprivate collectFlowElementAccess (node: ts.ElementAccessExpression, sourceFile: ts.SourceFile): void {\n\t\tconst objectType = this.resolveExpressionType(node.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind       : 'elementAccess',\n\t\t\tcode,\n\t\t\ttargetType : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect assignment flow: user.name = value or user = other\n\t */\n\tprivate collectFlowAssignment (node: ts.BinaryExpression, sourceFile: ts.SourceFile): void {\n\t\t// Property write: user.name = value\n\t\tif (ts.isPropertyAccessExpression(node.left)) {\n\t\t\tconst objectType = this.resolveExpressionType(node.left.expression);\n\t\t\tif (!objectType) { return; }\n\n\t\t\tconst propName = node.left.name.text;\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(objectType, {\n\t\t\t\tlocation,\n\t\t\t\tkind         : 'propertyWrite',\n\t\t\t\tcode,\n\t\t\t\tpropertyName : propName,\n\t\t\t\ttargetType   : objectType\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Variable reassignment: user = other\n\t\tif (ts.isIdentifier(node.left)) {\n\t\t\tconst varName = node.left.text;\n\t\t\tconst mappedType = this.variableToTypeMap.get(varName);\n\t\t\tif (!mappedType) { return; }\n\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(mappedType, {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'reassignment',\n\t\t\t\tcode,\n\t\t\t\ttargetType : mappedType\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Collect method call flow: user.validate()\n\t */\n\tprivate collectFlowMethodCall (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isPropertyAccessExpression(node.expression)) { return; }\n\n\t\tconst objectType = this.resolveExpressionType(node.expression.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst methodName = node.expression.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Skip if this is a type constructor call (e.g., new UserType())\n\t\tif (methodName === 'define' || methodName === 'lazy') { return; }\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind         : 'methodCall',\n\t\t\tcode,\n\t\t\tpropertyName : methodName,\n\t\t\ttargetType   : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect argument passing flow: processUser(user)\n\t */\n\tprivate collectFlowArgumentPass (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tfor (let i = 0; i < node.arguments.length; i++) {\n\t\t\tconst arg = node.arguments[ i ];\n\t\t\tconst argType = this.resolveExpressionType(arg);\n\t\t\tif (!argType) { continue; }\n\n\t\t\tconst funcName = this.getFunctionName(node.expression) || 'anonymous';\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(argType, {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'passAsArg',\n\t\t\t\tcode,\n\t\t\t\ttargetType : argType,\n\t\t\t\tcontext    : `arg ${i} to ${funcName}`\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Collect destructuring flow: const { name } = user\n\t */\n\tprivate collectFlowDestructure (node: ts.VariableDeclaration, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isObjectBindingPattern(node.name)) { return; }\n\n\t\tconst sourceType = this.resolveExpressionType(node.initializer!);\n\t\tif (!sourceType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Extract destructured property names\n\t\tconst props: string[] = [];\n\t\tfor (const element of node.name.elements) {\n\t\t\tif (ts.isIdentifier(element.name)) {\n\t\t\t\tprops.push(element.name.text);\n\t\t\t}\n\t\t}\n\n\t\tthis.addFlow(sourceType, {\n\t\t\tlocation,\n\t\t\tkind       : 'destructureRead',\n\t\t\tcode,\n\t\t\ttargetType : sourceType,\n\t\t\tcontext    : props.join(', ')\n\t\t});\n\t}\n\n\t/**\n\t * Collect return flow: return user\n\t */\n\tprivate collectFlowReturn (node: ts.ReturnStatement, sourceFile: ts.SourceFile): void {\n\t\tconst returnType = this.resolveExpressionType(node.expression!);\n\t\tif (!returnType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(returnType, {\n\t\t\tlocation,\n\t\t\tkind       : 'return',\n\t\t\tcode,\n\t\t\ttargetType : returnType\n\t\t});\n\t}\n\n\t/**\n\t * Collect spread flow: { ...user }\n\t */\n\tprivate collectFlowSpread (node: ts.SpreadElement, sourceFile: ts.SourceFile): void {\n\t\tconst spreadType = this.resolveExpressionType(node.expression);\n\t\tif (!spreadType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(spreadType, {\n\t\t\tlocation,\n\t\t\tkind       : 'spread',\n\t\t\tcode,\n\t\t\ttargetType : spreadType\n\t\t});\n\t}\n\n\t/**\n\t * Resolve type from an expression (identifier, property access, etc.)\n\t */\n\tprivate resolveExpressionType (expr: ts.Expression): string | undefined {\n\t\t// Identifier: user\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn this.variableToTypeMap.get(expr.text);\n\t\t}\n\n\t\t// Property access: user.name (return object type, not property type)\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\treturn this.resolveExpressionType(expr.expression);\n\t\t}\n\n\t\t// Element access: user['name']\n\t\tif (ts.isElementAccessExpression(expr)) {\n\t\t\treturn this.resolveExpressionType(expr.expression);\n\t\t}\n\n\t\t// This expression: this (if in a method, we can't resolve without more context)\n\t\tif (expr.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Add a flow usage to the collection\n\t */\n\tprivate addFlow (typePath: string, info: FlowInfo): void {\n\t\tif (!this.flowUsages.has(typePath)) {\n\t\t\tthis.flowUsages.set(typePath, []);\n\t\t}\n\n\t\tconst existing = this.flowUsages.get(typePath)!;\n\t\tconst isDuplicate = existing.some(e => {\n\t\t\treturn e.location === info.location &&\n\t\t\t\te.kind === info.kind &&\n\t\t\t\te.code === info.code;\n\t\t});\n\n\t\tif (!isDuplicate) {\n\t\t\texisting.push(info);\n\t\t}\n\t}\n\n\t/**\n\t\t\t* Get type name from expression (identifier or property access)\n\t\t\t*/\n\tprivate getTypeNameFromExpression (expr: ts.Expression): string | undefined {\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\tconst name = expr.text;\n\t\t\t// Check if this identifier is a variable mapped to a type (e.g., from lookup)\n\t\t\tconst mappedType = this.variableToTypeMap.get(name);\n\t\t\tif (mappedType) {\n\t\t\t\treturn mappedType;\n\t\t\t}\n\t\t\treturn name;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\tconst chain = this.getPropertyChain(expr);\n\t\t\treturn chain.join('.');\n\t\t}\n\t\treturn undefined;\n\t}\n\t\n\t/**\n\t\t\t* Resolve full type path from property access\n\t\t\t*/\n\tprivate resolveTypePath (expr: ts.PropertyAccessExpression): string | undefined {\n\t\tconst chain = this.getPropertyChain(expr);\n\t\tif (chain.length === 0) return undefined;\n\t\n\t\t// Check if this chain matches a known type\n\t\tconst fullPath = chain.join('.');\n\t\tif (this.definitions.has(fullPath)) {\n\t\t\treturn fullPath;\n\t\t}\n\t\n\t\t// Try just the property name\n\t\tconst propName = chain[ chain.length - 1 ];\n\t\tfor (const [ path ] of this.definitions) {\n\t\t\tif (path.endsWith(`.${propName}`) || path === propName) {\n\t\t\t\treturn path;\n\t\t\t}\n\t\t}\n\t\n\t\treturn fullPath;\n\t}\n\t\n\t/**\n\t\t\t * Check if a name looks like a type (starts with uppercase)\n\t\t\t */\n\tprivate isLikelyTypeName (name: string): boolean {\n\t\treturn name[ 0 ] >= 'A' && name[ 0 ] <= 'Z';\n\t}\n\t\n\t/**\n\t\t\t * Resolve a constructor parameter type, expanding inline object literals\n\t\t\t * and type aliases where possible.\n\t\t\t */\n\tprivate resolveConstructorParamType (typeNode: ts.TypeNode | undefined): string | undefined {\n\t\tif (!typeNode) return undefined;\n\n\t\t// Direct inline type literal: { prop: type }\n\t\tif (ts.isTypeLiteralNode(typeNode)) {\n\t\t\tconst props: string[] = [];\n\t\t\tfor (const member of typeNode.members) {\n\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\tconst optional = member.questionToken ? '?' : '';\n\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\tprops.push(`${propName}${optional}: ${type}`);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `{ ${props.join('; ')} }`;\n\t\t}\n\n\t\t// Type reference: usage, UserData, etc. - recursively expand\n\t\tif (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {\n\t\t\tconst typeName = typeNode.typeName.text;\n\t\t\tconst aliasedType = this.typeAliases.get(typeName);\n\t\t\tif (aliasedType) {\n\t\t\t\tconst expanded = this.resolveConstructorParamType(aliasedType);\n\t\t\t\tif (expanded) return expanded;\n\t\t\t}\n\t\t\t// If not an object type alias, return the type name with args\n\t\t\tif (typeNode.typeArguments && typeNode.typeArguments.length > 0) {\n\t\t\t\tconst args = typeNode.typeArguments.map(arg => this.inferType(arg));\n\t\t\t\treturn `${typeName  }<${  args.join(', ')  }>`;\n\t\t\t}\n\t\t\treturn typeName;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from a class-like node.\n\t\t\t */\n\tprivate extractClassConstructorParams (classLike: ts.ClassDeclaration | ts.ClassExpression):\n\t\tConstructorParamInfo[] {\n\t\tconst params: ConstructorParamInfo[] = [];\n\n\t\tfor (const member of classLike.members) {\n\t\t\tif (!ts.isConstructorDeclaration(member)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tfor (const param of member.parameters) {\n\t\t\t\tif (!param.name || !ts.isIdentifier(param.name)) continue;\n\t\t\t\tif (!param.type) continue;\n\n\t\t\t\tconst paramName = param.name.text;\n\t\t\t\tconst expandedType = this.resolveConstructorParamType(param.type) || this.inferType(param.type);\n\n\t\t\t\tparams.push({\n\t\t\t\t\tname     : paramName,\n\t\t\t\t\ttype     : expandedType,\n\t\t\t\t\toptional : !!param.questionToken || !!param.initializer\n\t\t\t\t});\n\t\t\t}\n\t\t\t// Only process first constructor\n\t\t\tbreak;\n\t\t}\n\n\t\treturn params;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from define() call\n\t\t\t * This is used for TypeRegistry constructor signatures\n\t\t\t * Preserves parameter names and expands object types to their structure\n\t\t\t */\n\tprivate extractConstructorParams (call: ts.CallExpression): ConstructorParamInfo[] {\n\t\tconst constructorExpr = this.extractConstructorExpression(call);\n\t\tif (!constructorExpr) {\n\t\t\treturn [];\n\t\t}\n\t\tconst result = this.extractConstructorParamsFromConstructor(constructorExpr);\n\t\treturn result;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from a constructor expression.\n\t\t\t */\n\tprivate extractConstructorParamsFromConstructor (constructorExpr: ts.Expression): ConstructorParamInfo[] {\n\t\tconst params: ConstructorParamInfo[] = [];\n\t\n\t\t// Handle function expression or arrow function\n\t\tif (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {\n\t\t\t// Look for constructor parameters (second param after `this`)\n\t\t\t// Patterns: function(this: Type, data: { ... }) or (this: Type, data: { ... }) =>\n\t\t\tfor (let i = 0; i < constructorExpr.parameters.length; i++) {\n\t\t\t\tconst param = constructorExpr.parameters[ i ];\n\t\t\t\tif (!param.type) continue;\n\t\n\t\t\t\t// Skip `this` parameter (first param)\n\t\t\t\tif (\n\t\t\t\t\ti === 0 &&\n\t\t\t\t\tparam.name.kind === ts.SyntaxKind.Identifier &&\n\t\t\t\t\t(param.name as ts.Identifier).text === 'this'\n\t\t\t\t) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\n\t\t\t\t// Get parameter name and expand its type\n\t\t\t\tconst paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';\n\t\t\t\tconst expandedType = this.resolveConstructorParamType(param.type) || this.inferType(param.type);\n\t\t\t\t\t\n\t\t\t\tparams.push({\n\t\t\t\t\tname     : paramName,\n\t\t\t\t\ttype     : expandedType,\n\t\t\t\t\toptional : !!param.questionToken || !!param.initializer\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\n\t\t// Handle class expression - check constructor method\n\t\tif (ts.isClassExpression(constructorExpr)) {\n\t\t\tconst classParams = this.extractClassConstructorParams(constructorExpr);\n\t\t\tfor (const param of classParams) {\n\t\t\t\tparams.push(param);\n\t\t\t}\n\t\t}\n\n\t\treturn params;\n\t}\n\n\t/**\n\t * Collect framework instrumentation points. Purely syntactic: heritage\n\t * clauses, decorator application sites, provider-token object literals\n\t * and consumer.apply().forRoutes() wiring. The vocabulary comes from\n\t * plugins; identifier text is matched as-is — no import resolution,\n\t * the type checker stays unused.\n\t */\n\tprivate collectInstrumentation (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (ts.isClassDeclaration(node) && node.name) {\n\t\t\tthis.collectInstrumentationClass(node, sourceFile);\n\t\t}\n\t\tif (ts.isDecorator(node)) {\n\t\t\tthis.collectInstrumentationDecorator(node, sourceFile);\n\t\t}\n\t\tif (ts.isObjectLiteralExpression(node)) {\n\t\t\tthis.collectInstrumentationProvider(node, sourceFile);\n\t\t}\n\t\tif (ts.isCallExpression(node)) {\n\t\t\tthis.collectInstrumentationMiddleware(node, sourceFile);\n\t\t}\n\t}\n\n\t/**\n\t * Record a named class declaration for instrumentation site resolution\n\t * and detect heritage-based kinds (`implements <plugin interface>`)\n\t */\n\tprivate collectInstrumentationClass (node: ts.ClassDeclaration, sourceFile: ts.SourceFile): void {\n\t\tif (!node.name) {\n\t\t\treturn;\n\t\t}\n\t\tconst className = node.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.name.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t// First line of the declaration, like EDS `code` snippets\n\t\tconst code = node.getText(sourceFile).split('\\n')[ 0 ].slice(0, 100);\n\n\t\tlet kind: InstrumentationKind | undefined;\n\t\tif (node.heritageClauses) {\n\t\t\tfor (const clause of node.heritageClauses) {\n\t\t\t\tif (clause.token !== ts.SyntaxKind.ImplementsKeyword) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tfor (const type of clause.types) {\n\t\t\t\t\tif (!ts.isIdentifier(type.expression)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst matched = this.instrumentationVocabulary.interfaces[ type.expression.text ];\n\t\t\t\t\tif (matched) {\n\t\t\t\t\t\tkind = matched;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst decl: InstrumentationClassDecl = {\n\t\t\tlocation,\n\t\t\tcode,\n\t\t};\n\t\tif (kind) {\n\t\t\tdecl.kind = kind;\n\t\t}\n\t\tthis.instrumentationClassDecls.set(className, decl);\n\t}\n\n\t/**\n\t * Detect decorator application sites: plugin-listed decorators applied\n\t * with class arguments on a class or one of its methods. One site per\n\t * referenced class identifier.\n\t */\n\tprivate collectInstrumentationDecorator (node: ts.Decorator, sourceFile: ts.SourceFile): void {\n\t\tconst { expression } = node;\n\t\tif (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression)) {\n\t\t\treturn;\n\t\t}\n\t\tconst kind = this.instrumentationVocabulary.useDecorators[ expression.expression.text ];\n\t\tif (!kind) {\n\t\t\treturn;\n\t\t}\n\n\t\t// The decorator's parent is the decorated node: a controller class\n\t\t// or one of its methods\n\t\tconst decorated = node.parent;\n\t\tlet scope: InstrumentationScope;\n\t\tlet targets: string[];\n\t\tif (ts.isClassDeclaration(decorated) && decorated.name) {\n\t\t\tscope = `controller:${decorated.name.text}`;\n\t\t\ttargets = [ decorated.name.text ];\n\t\t} else if (\n\t\t\tts.isMethodDeclaration(decorated) &&\n\t\t\tts.isIdentifier(decorated.name) &&\n\t\t\tts.isClassDeclaration(decorated.parent) &&\n\t\t\tdecorated.parent.name\n\t\t) {\n\t\t\tconst className = decorated.parent.name.text;\n\t\t\tscope = `method:${className}.${decorated.name.text}`;\n\t\t\ttargets = [ className ];\n\t\t} else {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tfor (const arg of expression.arguments) {\n\t\t\t// Class reference: @Register(Impl) or an inline instance:\n\t\t\t// @Register(new Impl({ ...options }))\n\t\t\tlet className: string | undefined;\n\t\t\tif (ts.isIdentifier(arg)) {\n\t\t\t\tclassName = arg.text;\n\t\t\t} else if (ts.isNewExpression(arg) && ts.isIdentifier(arg.expression)) {\n\t\t\t\tclassName = arg.expression.text;\n\t\t\t}\n\t\t\tif (!className) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.instrumentationSites.push({\n\t\t\t\tkind,\n\t\t\t\tclassName,\n\t\t\t\tlocation,\n\t\t\t\tcode,\n\t\t\t\tscope,\n\t\t\t\ttargets,\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Detect global registrations: object literals shaped like\n\t * `{ provide: <plugin-listed token>, useClass: X }`.\n\t * useExisting/useFactory without a useClass identifier are not\n\t * statically obvious — skipped rather than guessed.\n\t */\n\tprivate collectInstrumentationProvider (node: ts.ObjectLiteralExpression, sourceFile: ts.SourceFile): void {\n\t\tlet kind: InstrumentationKind | undefined;\n\t\tlet useClassName: string | undefined;\n\n\t\tfor (const prop of node.properties) {\n\t\t\tif (\n\t\t\t\t!ts.isPropertyAssignment(prop) ||\n\t\t\t\t!ts.isIdentifier(prop.name) ||\n\t\t\t\t!ts.isIdentifier(prop.initializer)\n\t\t\t) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (prop.name.text === 'provide') {\n\t\t\t\tkind = this.instrumentationVocabulary.appTokens[ prop.initializer.text ];\n\t\t\t}\n\t\t\tif (prop.name.text === 'useClass') {\n\t\t\t\tuseClassName = prop.initializer.text;\n\t\t\t}\n\t\t}\n\n\t\tif (!kind || !useClassName) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.instrumentationSites.push({\n\t\t\tkind,\n\t\t\tclassName : useClassName,\n\t\t\tlocation,\n\t\t\tcode,\n\t\t\tscope     : 'global',\n\t\t\ttargets   : [],\n\t\t});\n\t}\n\n\t/**\n\t * Detect middleware wiring: `consumer.apply(Mw1, Mw2).forRoutes(...)`\n\t * inside a class's configure() method. Targets come from forRoutes\n\t * arguments when statically readable (string routes or controller\n\t * identifiers), else []. Shape-based, so a plugin must opt in via\n\t * `middlewareWiring: true`.\n\t */\n\tprivate collectInstrumentationMiddleware (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tif (!this.instrumentationVocabulary.middlewareWiring) {\n\t\t\treturn;\n\t\t}\n\t\tif (\n\t\t\t!ts.isPropertyAccessExpression(node.expression) ||\n\t\t\tnode.expression.name.text !== 'forRoutes'\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t\tconst applyCall = node.expression.expression;\n\t\tif (\n\t\t\t!ts.isCallExpression(applyCall) ||\n\t\t\t!ts.isPropertyAccessExpression(applyCall.expression) ||\n\t\t\tapplyCall.expression.name.text !== 'apply'\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.isInsideConfigureMethod(node)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst targets: string[] = [];\n\t\tfor (const arg of node.arguments) {\n\t\t\tif (ts.isIdentifier(arg) || ts.isStringLiteral(arg)) {\n\t\t\t\ttargets.push(arg.text);\n\t\t\t}\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tapplyCall.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tfor (const arg of applyCall.arguments) {\n\t\t\tif (!ts.isIdentifier(arg)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.instrumentationSites.push({\n\t\t\t\tkind      : 'middleware',\n\t\t\t\tclassName : arg.text,\n\t\t\t\tlocation,\n\t\t\t\tcode,\n\t\t\t\tscope     : 'module',\n\t\t\t\ttargets,\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Walk up the parent chain looking for an enclosing configure() method\n\t */\n\tprivate isInsideConfigureMethod (node: ts.Node): boolean {\n\t\tlet current: ts.Node | undefined = node.parent;\n\t\twhile (current) {\n\t\t\tif (\n\t\t\t\tts.isMethodDeclaration(current) &&\n\t\t\t\tts.isIdentifier(current.name) &&\n\t\t\t\tcurrent.name.text === 'configure'\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn false;\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport * as nodePath from 'path';\nimport * as ts from 'typescript';\nimport {\n\tTypeNode, PropertyInfo, AnalyzeResult, AnalyzeError,\n\tDefinitionInfo, UsageInfo, ConstructorParamInfo,\n\tEDSInfo, FlowInfo, InstrumentationKind, InstrumentationPoint,\n\tInstrumentationScope, ResolutionError\n} from './types';\nimport {\n\tTypeGraphImpl, resolveGraphTypeReference, GraphTypeReferenceResult \n} from './graph';\nimport {\n\tInstrumentationVocabulary, TacticaPlugin, mergeTacticaPlugins\n} from './plugins';\n\ninterface CollectionInfo {\n\tvariableName: string;\n\tsourceFile: string;\n\tregistryInterfaceName?: string;\n}\n\n/**\n * Location/code captured at a class declaration, used to resolve\n * instrumentation registration sites to the declared class\n */\ninterface InstrumentationClassDecl {\n\tkind?: InstrumentationKind;\n\tlocation: string;\n\tcode: string;\n}\n\n/**\n * Raw registration site (decorator, APP_* provider, consumer.apply).\n * Location/code are the site's own; getInstrumentationPoints() rewrites\n * them to the class declaration when the class is declared in-project.\n */\ninterface InstrumentationSite {\n\tkind: InstrumentationKind;\n\tclassName: string;\n\tlocation: string;\n\tcode: string;\n\tscope: InstrumentationScope;\n\ttargets: string[];\n}\n\n/**\n * A named referenced-type declaration (type alias, class, or interface)\n * recorded per file, so references can be resolved through the importing\n * file's own imports instead of a program-wide last-wins name map (F10).\n */\ninterface ReferencedTypeDeclaration {\n\tkind: 'alias' | 'class' | 'interface';\n\tnode: ts.TypeAliasDeclaration | ts.ClassDeclaration | ts.InterfaceDeclaration;\n\t/** file that declares the type — nested references resolve against it */\n\tfile: string;\n}\n\n/**\n * One import binding of a referenced type: the local name under which the\n * file knows it, the original exported name in the source module, and the\n * specifier it came from.\n */\ninterface ReferencedTypeImport {\n\toriginalName: string;\n\tspecifier: string;\n\tisNamespace: boolean;\n}\n\n/**\n * Result of resolving one module specifier from one containing file.\n */\ninterface ReferencedTypeResolution {\n\tresolvedPath: string;\n\tisExternal: boolean;\n}\n\n/**\n * Global/builtin type names that are safe to emit bare into generated files\n * — they resolve in any TypeScript compilation without an import.\n */\nconst KNOWN_GLOBAL_TYPES = new Set([\n\t'Date', 'RegExp', 'Error', 'EvalError', 'RangeError', 'ReferenceError',\n\t'SyntaxError', 'TypeError', 'URIError', 'AggregateError',\n\t'Map', 'Set', 'WeakMap', 'WeakSet', 'WeakRef', 'FinalizationRegistry',\n\t'Promise', 'Array', 'ReadonlyArray', 'Record', 'Partial', 'Required',\n\t'Readonly', 'Pick', 'Omit', 'Exclude', 'Extract', 'NonNullable',\n\t'ReturnType', 'InstanceType', 'Parameters', 'ConstructorParameters',\n\t'ThisType', 'ThisParameterType', 'OmitThisParameter',\n\t'Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize',\n\t'String', 'Number', 'Boolean', 'Symbol', 'BigInt', 'Object', 'Function',\n\t'Iterable', 'Iterator', 'Generator', 'AsyncIterable', 'AsyncIterator',\n\t'AsyncGenerator', 'IterableIterator', 'AsyncIterableIterator',\n\t'PropertyKey', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView',\n\t'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array',\n\t'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array',\n\t'Float64Array', 'BigInt64Array', 'BigUint64Array', 'Intl'\n]);\n\n// Bound for chasing re-export barrels (export { X } from '…', export * from '…')\nconst MAX_REEXPORT_CHASE_DEPTH = 5;\n// Bound for walking class/interface extends chains during referenced-type\n// expansion (inherited members merge into the expanded fields)\nconst MAX_HERITAGE_DEPTH = 8;\n\n/**\n * AST Analyzer for finding Mnemonica define() and decorate() calls\n *\n * Framework-blind by construction: instrumentation detection vocabulary\n * (interface names, decorator names, provider tokens, middleware wiring)\n * comes entirely from plugins — with none loaded, zero points are collected.\n */\nexport class MnemonicaAnalyzer {\n\tprivate errors: AnalyzeError[] = [];\n\tprivate graph = new TypeGraphImpl();\n\tprivate definitions = new Map<string, DefinitionInfo>();\n\tprivate usages = new Map<string, UsageInfo[]>();\n\tprivate edsUsages = new Map<string, EDSInfo[]>();\n\tprivate flowUsages = new Map<string, FlowInfo[]>();\n\t// Enclosing mnemonica scope for EDS keying: define()/lazy() call node\n\t// or @decorate()-ed class declaration -> fullPath of the type it owns.\n\t// Populated on the definitions pass; AST nodes persist across passes,\n\t// so entries stay valid after resetUsages().\n\tprivate edsScopeByNode = new Map<ts.Node, string>();\n\t// Same-file function bindings (`fileName#name` -> function node) for\n\t// resolving wrap(fn) arguments syntactically — the checker stays unused\n\tprivate functionBindings = new Map<string, ts.FunctionLikeDeclaration>();\n\t// wrap call node -> location of the enclosing wrap site (plus that\n\t// site's scope attribution), so nested wrap() calls inside a wrapped\n\t// body carry the `via` link — and inherit the scope when they have\n\t// none of their own\n\tprivate nestedWrapVia = new Map<ts.Node, { via: string; scope?: string }>();\n\t// wrap call node -> its collected entry, so a lexically nested wrap\n\t// (visited BEFORE the outer wrap call, per source order) gets its\n\t// `via` back-patched when the outer body is analysed\n\tprivate wrapEntryByNode = new Map<ts.Node, EDSInfo>();\n\t// Track variable assignments: variableName -> fullPath of the type it holds\n\tprivate variableToTypeMap = new Map<string, string>();\n\t// Track mnemonica module-object variables (e.g., import { mnemonica } from 'mnemonica'; const m = mnemonica)\n\tprivate moduleObjectVariables = new Set<string>();\n\t// Track imported aliases of createTypesCollection (e.g., import { createTypesCollection as ctc })\n\tprivate createTypesCollectionVariables = new Set<string>();\n\t// Track custom collection variables: variableName -> collectionId\n\tprivate collectionVariables = new Map<string, string>();\n\t// Track custom collection metadata for Option B registry emission\n\tprivate collectionInfo = new Map<string, CollectionInfo>();\n\tprivate collectionCounter = 0;\n\t// Instrumentation collection (syntactic only — no type checker):\n\t// every named class declaration by simple name, for resolving\n\t// registration sites to declaration locations (best effort, last wins)\n\tprivate instrumentationClassDecls = new Map<string, InstrumentationClassDecl>();\n\t// Registration sites: decorator applications, provider-token object\n\t// literals, consumer.apply() middleware wiring\n\tprivate instrumentationSites: InstrumentationSite[] = [];\n\t// Merged plugin vocabulary for instrumentation detection (empty when\n\t// no plugins were passed — the analyzer then collects no points)\n\tprivate instrumentationVocabulary: InstrumentationVocabulary;\n\t// Referenced-type resolution (F10): per-file declarations and imports.\n\t// A type name used in file X resolves through X's own import statements\n\t// first (relative + tsconfig-paths, via ts.resolveModuleName), then\n\t// X's local declarations, then — only when nothing imports or declares\n\t// the name — the unique same-named declaration across scanned files.\n\t// Genuine ambiguity or an unresolvable reference yields `unknown`, never\n\t// a bare emitted name: generated types.ts carries no imports of its own.\n\tprivate referencedTypeDecls = new Map<string, Map<string, ReferencedTypeDeclaration>>();\n\tprivate referencedTypeImports = new Map<string, Map<string, ReferencedTypeImport>>();\n\t// file -> (exported name -> re-export specifier) for `export { X } from '…'`\n\tprivate referencedTypeReExports = new Map<string, Map<string, string>>();\n\t// file -> specifiers of `export * from '…'`\n\tprivate referencedTypeExportStars = new Map<string, string[]>();\n\t// file -> (exported name -> local name) for `export { X as Y }`\n\tprivate referencedTypeExportAliases = new Map<string, Map<string, string>>();\n\t// file -> (namespace name -> namespace declaration) — middle segments\n\t// of qualified references (models.Inner.Crate) descend through these\n\tprivate referencedTypeNamespaces = new Map<string, Map<string, ts.ModuleDeclaration>>();\n\t// file -> (namespace name -> specifier) for `export * as ns from '…'`\n\t// barrels — a nested module namespace one segment deep\n\tprivate referencedTypeNamespaceStars = new Map<string, Map<string, string>>();\n\t// `${containingFile}::${specifier}` -> resolution (undefined = failed)\n\tprivate referencedTypeResolutionCache = new Map<string, ReferencedTypeResolution | undefined>();\n\t// file -> (const name -> array literal) for consts with array-literal\n\t// initializers (`as const` / `satisfies` unwrapped), so a\n\t// `typeof statusList[number]` field type expands to the element literal\n\t// union instead of leaking a bare unresolvable `typeof` query into the\n\t// generated file. Declarations persist across passes — entries stay\n\t// valid after resetUsages(), same as referencedTypeDecls\n\tprivate referencedTypeConstArrays = new Map<string, Map<string, ts.ArrayLiteralExpression>>();\n\tprivate referencedTypeCompilerOptions: ts.CompilerOptions;\n\t// File whose AST is currently being visited; references resolve against it\n\tprivate currentReferencedTypeFile = '';\n\t// Alias names currently being expanded (cycle guard)\n\tprivate expandingReferencedAliases = new Set<string>();\n\t// Mnemonica-graph identity law (hard fail): every define()/lazy()/\n\t// @decorate() site keyed by its runtime namespace (collection roots:\n\t// `<collection>::<name>`; subtypes: `<parentFullPath>.<name>`). Two\n\t// sites in one namespace are a same-namespace duplicate — the runtime\n\t// throws ALREADY_DECLARED — and must abort generation.\n\tprivate defineSites = new Map<string, string[]>();\n\t// Mnemonica-graph references that stayed ambiguous after path-aware\n\t// resolution or resolved to nothing (hard-fail class 2)\n\tprivate graphReferenceErrors: ResolutionError[] = [];\n\t// Guards lookup()-path validation so it runs once per usages pass\n\t// (getResolutionErrors may be called repeatedly); resetUsages re-arms it\n\tprivate lookupReferencesValidated = false;\n\t// Literal lookup() call sites with their resolved paths. Kept apart from\n\t// the usages map on purpose: addUsage drops paths the graph does not\n\t// know (usages.json indexes references to KNOWN types), but an unknown\n\t// lookup path is exactly the hard-fail case — the runtime returns\n\t// undefined there and the TypeError arrives one line later\n\tprivate lookupReferences: { path: string; location: string }[] = [];\n\t// Guards plain-TS reference validation so it runs once per usages pass\n\t// (getResolutionErrors may be called repeatedly); resetUsages re-arms it\n\tprivate plainTypeReferencesValidated = false;\n\t// Plain-TS type reference sites whose resolution fell through imports,\n\t// locals, the program-wide scan, and the graph to a soft `unknown`.\n\t// Validated lazily from getResolutionErrors against the complete\n\t// declaration map: a name several project-source files declare — with\n\t// no import in the referencing file to anchor it — is the plain-TS\n\t// ambiguity hard-fail class (one tier below the graph identity law);\n\t// absence (ghost names) stays soft. Recording happens on every pass,\n\t// the verdict only here — pass 1 sees an incomplete declaration map,\n\t// so only the usages pass is authoritative (mirrors lookup references)\n\tprivate plainTypeReferences: { name: string; location: string; file: string }[] = [];\n\t// Per-file top-level variable -> mnemonica fullPath bindings (value\n\t// scope): `const Address = User.define('Address', …)` makes `Address`\n\t// denote User.Address wherever that file's references are resolved\n\tprivate fileGraphBindings = new Map<string, Map<string, string>>();\n\t// The graph type whose constructor is currently being extracted;\n\t// anchors relative-first graph reference resolution\n\tprivate currentGraphAnchor: TypeNode | undefined;\n\t// define()/lazy() calls already extracted this pass. The CLI re-analyzes\n\t// every file after resetUsages(); clearing the set lets the second pass\n\t// re-extract every constructor against the COMPLETE graph — pass 1 sees\n\t// forward references as `none` (soft unknown) because later files have\n\t// not been visited yet, so only pass-2 resolution is authoritative for\n\t// the hard-fail identity law. The stamp lives here rather than on the\n\t// AST node so it can actually be cleared. (Chained calls visit the same\n\t// node twice within one pass; the in-pass dedup below stays.)\n\tprivate processedCalls = new Set<ts.CallExpression>();\n\n\tconstructor (program?: ts.Program, plugins: TacticaPlugin[] = []) {\n\t\t// Compiler options drive ts.resolveModuleName for import-aware\n\t\t// referenced-type resolution (tsconfig `paths`, extensionless\n\t\t// imports); the type checker itself stays unused.\n\t\tthis.referencedTypeCompilerOptions = program?.getCompilerOptions() ?? {};\n\t\tthis.instrumentationVocabulary = mergeTacticaPlugins(plugins);\n\t}\n\n\t/**\n\t * Reset usage-related state for a fresh pass.\n\t * Call before the usage-collection pass to avoid duplicates from definition pass.\n\t */\n\tresetUsages (): void {\n\t\tthis.usages.clear();\n\t\tthis.edsUsages.clear();\n\t\tthis.flowUsages.clear();\n\t\tthis.variableToTypeMap.clear();\n\t\t// EDS entry references go stale with edsUsages; via links are\n\t\t// re-derived on the next pass\n\t\tthis.wrapEntryByNode.clear();\n\t\tthis.nestedWrapVia.clear();\n\t\t// Note: moduleObjectVariables and collectionVariables intentionally persist\n\t\t// across definition and usage passes.\n\t\t// Re-extraction in the usages pass is what makes graph reference\n\t\t// resolution authoritative: pass 1 resolves against an incomplete\n\t\t// graph (forward references read as `none`), pass 2 against all of it.\n\t\tthis.processedCalls.clear();\n\t\t// lookup()-path validation runs against the recorded sites; a fresh\n\t\t// pass must re-record and re-validate (pass-1 results would be\n\t\t// premature — the graph is still incomplete)\n\t\tthis.lookupReferencesValidated = false;\n\t\tthis.lookupReferences = [];\n\t\tthis.plainTypeReferencesValidated = false;\n\t\tthis.plainTypeReferences = [];\n\t}\n\n\t/**\n\t * Analyze a source file for Mnemonica type definitions\n\t */\n\tanalyzeFile (sourceFile: ts.SourceFile): AnalyzeResult {\n\t\tthis.errors = [];\n\t\t// Referenced-type names in this file resolve against its own imports\n\t\tthis.currentReferencedTypeFile = nodePath.resolve(sourceFile.fileName);\n\t\t// Ensure parent nodes are set for AST traversal\n\t\tthis.setParentNodesInSourceFile(sourceFile);\n\t\tthis.visitNode(sourceFile, sourceFile);\n\n\t\treturn {\n\t\t\ttypes  : this.graph.getAllTypes(),\n\t\t\terrors : this.errors,\n\t\t};\n\t}\n\n\t/**\n\t * Analyze source code string\n\t */\n\tanalyzeSource (sourceCode: string, fileName = 'temp.ts'): AnalyzeResult {\n\t\tconst sourceFile = ts.createSourceFile(\n\t\t\tfileName,\n\t\t\tsourceCode,\n\t\t\tts.ScriptTarget.Latest,\n\t\t\ttrue\n\t\t);\n\t\treturn this.analyzeFile(sourceFile);\n\t}\n\n\t/**\n\t * Get the type graph\n\t */\n\tgetGraph (): TypeGraphImpl {\n\t\treturn this.graph;\n\t}\n\n\t/**\n\t * Get collected definitions\n\t */\n\tgetDefinitions (): Map<string, DefinitionInfo> {\n\t\treturn this.definitions;\n\t}\n\n\t/**\n\t * Get collected usages\n\t */\n\tgetUsages (): Map<string, UsageInfo[]> {\n\t\treturn this.usages;\n\t}\n\n\t/**\n\t * Get collected EDS usages\n\t */\n\tgetEDSUsages (): Map<string, EDSInfo[]> {\n\t\treturn this.edsUsages;\n\t}\n\n\t/**\n\t * Get collected flow usages\n\t */\n\tgetFlowUsages (): Map<string, FlowInfo[]> {\n\t\treturn this.flowUsages;\n\t}\n\n\t/**\n\t * Get collected instrumentation points.\n\t * Registration sites referencing a class declared in the same project\n\t * resolve to the class declaration's location/code; external classes\n\t * (e.g., a framework-builtin implementation from node_modules) keep\n\t * the registration site.\n\t * Deduped by kind+className+location+scope with targets merged — a\n\t * class detected by heritage AND by a decorator site yields separate\n\t * entries with distinct scopes (see InstrumentationPoint in types.ts).\n\t */\n\tgetInstrumentationPoints (): InstrumentationPoint[] {\n\t\tconst points = new Map<string, InstrumentationPoint>();\n\n\t\tconst addPoint = (point: InstrumentationPoint): void => {\n\t\t\tconst key = `${point.kind}|${point.className}|${point.location}|${point.scope}`;\n\t\t\tconst existing = points.get(key);\n\t\t\tif (existing) {\n\t\t\t\tconst merged = new Set([ ...existing.targets, ...point.targets ]);\n\t\t\t\texisting.targets = Array.from(merged);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tpoints.set(key, point);\n\t\t};\n\n\t\tfor (const site of this.instrumentationSites) {\n\t\t\tconst decl = this.instrumentationClassDecls.get(site.className);\n\t\t\tconst point: InstrumentationPoint = {\n\t\t\t\tkind      : site.kind,\n\t\t\t\tclassName : site.className,\n\t\t\t\tlocation  : decl ? decl.location : site.location,\n\t\t\t\tcode      : decl ? decl.code : site.code,\n\t\t\t\tscope     : site.scope,\n\t\t\t\ttargets   : site.targets,\n\t\t\t};\n\t\t\taddPoint(point);\n\t\t}\n\n\t\t// Heritage-declared classes always emit a declaration point with\n\t\t// scope 'module' (attachment statically unknown); registration\n\t\t// sites above carry the narrower scopes as separate entries\n\t\tfor (const [ className, decl ] of this.instrumentationClassDecls) {\n\t\t\tif (!decl.kind) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst point: InstrumentationPoint = {\n\t\t\t\tkind      : decl.kind,\n\t\t\t\tclassName : className,\n\t\t\t\tlocation  : decl.location,\n\t\t\t\tcode      : decl.code,\n\t\t\t\tscope     : 'module',\n\t\t\t\ttargets   : [],\n\t\t\t};\n\t\t\taddPoint(point);\n\t\t}\n\n\t\tconst result = Array.from(points.values());\n\t\treturn result;\n\t}\n\n\t/**\n\t * Add a topologica type to the analyzer for usage tracking.\n\t * This allows the analyzer to recognize topologica types when collecting usages.\n\t */\n\taddTopologicaType (fullPath: string, node: import('./types').TypeNode): void {\n\t\t// Skip if already exists\n\t\tif (this.graph.allTypes.has(fullPath)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Add to graph so it can be found during usage collection\n\t\tif (node.parent) {\n\t\t\t// Add as child of parent\n\t\t\tthis.graph.addChild(node.parent, node);\n\t\t} else {\n\t\t\t// Add as root\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Also add to definitions so it's recognized as a known type\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : node.name,\n\t\t\tlocation    : `${node.sourceFile}:${node.line}:${node.column}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : node.parent ? node.parent.fullPath : null,\n\t\t\tstrictChain : true,\n\t\t\tblockErrors : false\n\t\t};\n\t\tthis.definitions.set(fullPath, definition);\n\t}\n\n\t/**\n\t * Set parent nodes in a source file to enable AST traversal up\n\t */\n\tprivate setParentNodesInSourceFile (sourceFile: ts.SourceFile): void {\n\t\tconst setParent = (node: ts.Node, parent?: ts.Node) => {\n\t\t\t// TypeScript doesn't expose parent as writable, but we need it\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\t(node as any).parent = parent;\n\t\t\tts.forEachChild(node, child => setParent(child, node));\n\t\t};\n\t\tsetParent(sourceFile);\n\t}\n\n\t/**\n\t * Visit a node in the AST\n\t */\n\tprivate visitNode (node: ts.Node, sourceFile: ts.SourceFile, currentClass?: ts.ClassDeclaration): void {\n\t\t// Track mnemonica module-object aliases and custom collection variables\n\t\t// before processing define()/lookup() calls so source resolution works.\n\t\tthis.trackImports(node);\n\t\tthis.trackModuleObjectAliases(node);\n\t\tthis.trackCollectionAliases(node, sourceFile);\n\n\t\t// Check for define() calls\n\t\tif (this.isDefineCall(node)) {\n\t\t\tthis.processDefineCall(node as ts.CallExpression, sourceFile);\n\t\t}\n\n\t\t// Check for lazy() calls\n\t\tif (this.isLazyCall(node)) {\n\t\t\tthis.processLazyCall(node as ts.CallExpression, sourceFile);\n\t\t}\n\n\t\t// Check for decorate() decorator\n\t\tif (this.isDecorateDecorator(node)) {\n\t\t\tthis.processDecorateDecorator(node as ts.Decorator, sourceFile, currentClass);\n\t\t}\n\n\t\t// Check for type usages (new Type(), type annotations, etc.)\n\t\tthis.collectUsage(node, sourceFile);\n\n\t\t// Check for EDS patterns (wrap, current, getFlow, etc.)\n\t\tthis.collectEDS(node, sourceFile);\n\n\t\t// Check for native flow patterns (property access, method calls, etc.)\n\t\tthis.collectFlow(node, sourceFile);\n\n\t\t// Check for framework instrumentation points (vocabulary supplied\n\t\t// by plugins; syntactic only — no type checker)\n\t\tthis.collectInstrumentation(node, sourceFile);\n\n\t\t// Collect referenced-type declarations (aliases, classes, interfaces)\n\t\t// per file, and the file's import wiring, for import-aware resolution\n\t\tthis.trackReferencedTypeDeclaration(node);\n\t\tthis.trackReferencedTypeImport(node);\n\t\tthis.trackReferencedTypeReExport(node);\n\t\tthis.trackReferencedTypeConstArray(node);\n\n\t\t// Track same-file function bindings so EDS can resolve wrap(fn)\n\t\t// arguments without the type checker (best effort, last wins)\n\t\tif (ts.isFunctionDeclaration(node) && node.name) {\n\t\t\tconst key = `${sourceFile.fileName}#${node.name.text}`;\n\t\t\tthis.functionBindings.set(key, node);\n\t\t}\n\t\tif (\n\t\t\tts.isVariableDeclaration(node) &&\n\t\t\tts.isIdentifier(node.name) &&\n\t\t\tnode.initializer &&\n\t\t\t(ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))\n\t\t) {\n\t\t\tconst key = `${sourceFile.fileName}#${node.name.text}`;\n\t\t\tthis.functionBindings.set(key, node.initializer);\n\t\t}\n\n\t\t// Track class declarations for decorator parent lookup\n\t\tif (ts.isClassDeclaration(node)) {\n\t\t\t// Visit children with this class as the current context\n\t\t\tts.forEachChild(node, child => this.visitNode(child, sourceFile, node));\n\t\t} else {\n\t\t\t// Recursively visit children\n\t\t\tts.forEachChild(node, child => this.visitNode(child, sourceFile, currentClass));\n\t\t}\n\t}\n\n\t/**\n\t * Track imports from 'mnemonica' so aliases of the module object and\n\t * createTypesCollection are recognized without relying on the type checker.\n\t */\n\tprivate trackImports (node: ts.Node): void {\n\t\tif (!ts.isImportDeclaration(node)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { moduleSpecifier } = node;\n\t\tif (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== 'mnemonica') {\n\t\t\treturn;\n\t\t}\n\n\t\tconst clause = node.importClause;\n\t\tif (!clause) {\n\t\t\treturn;\n\t\t}\n\n\t\t// import { mnemonica, createTypesCollection } from 'mnemonica'\n\t\tif (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {\n\t\t\tfor (const element of clause.namedBindings.elements) {\n\t\t\t\tconst localName = element.name.text;\n\t\t\t\tconst importedName = element.propertyName\n\t\t\t\t\t? element.propertyName.text\n\t\t\t\t\t: localName;\n\t\t\t\tif (importedName === 'mnemonica') {\n\t\t\t\t\tthis.moduleObjectVariables.add(localName);\n\t\t\t\t}\n\t\t\t\tif (importedName === 'createTypesCollection') {\n\t\t\t\t\tthis.createTypesCollectionVariables.add(localName);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// import * as mnemonica from 'mnemonica'\n\t\tif (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {\n\t\t\tthis.moduleObjectVariables.add(clause.namedBindings.name.text);\n\t\t}\n\n\t\t// import mnemonica from 'mnemonica' (default import) — treat as module object too\n\t\tif (clause.name) {\n\t\t\tthis.moduleObjectVariables.add(clause.name.text);\n\t\t}\n\t}\n\n\t/**\n\t * Record a named referenced-type declaration (type alias, class, or\n\t * interface) for the file currently being visited.\n\t */\n\tprivate trackReferencedTypeDeclaration (node: ts.Node): void {\n\t\t// Namespaces are the middle segments of qualified references\n\t\t// (models.Inner.Crate) — recorded separately from the plain-name\n\t\t// declaration table (string-named `module '…'` declarations are\n\t\t// ambient externals and stay out)\n\t\tif (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name) &&\n\t\t\tnode.body && ts.isModuleBlock(node.body)) {\n\t\t\tconst namespaceFilePath = this.currentReferencedTypeFile;\n\t\t\tlet namespaces = this.referencedTypeNamespaces.get(namespaceFilePath);\n\t\t\tif (!namespaces) {\n\t\t\t\tnamespaces = new Map<string, ts.ModuleDeclaration>();\n\t\t\t\tthis.referencedTypeNamespaces.set(namespaceFilePath, namespaces);\n\t\t\t}\n\t\t\tnamespaces.set(node.name.text, node);\n\t\t\treturn;\n\t\t}\n\n\t\tlet name = '';\n\t\tlet kind: ReferencedTypeDeclaration['kind'] | undefined;\n\t\tlet declNode: ReferencedTypeDeclaration['node'] | undefined;\n\n\t\tif (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name)) {\n\t\t\tname = node.name.text;\n\t\t\tkind = 'alias';\n\t\t\tdeclNode = node;\n\t\t} else if (ts.isClassDeclaration(node) && node.name) {\n\t\t\tname = node.name.text;\n\t\t\tkind = 'class';\n\t\t\tdeclNode = node;\n\t\t} else if (ts.isInterfaceDeclaration(node) && ts.isIdentifier(node.name)) {\n\t\t\tname = node.name.text;\n\t\t\tkind = 'interface';\n\t\t\tdeclNode = node;\n\t\t}\n\n\t\tif (!kind || !declNode || !name) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst filePath = this.currentReferencedTypeFile;\n\t\tlet decls = this.referencedTypeDecls.get(filePath);\n\t\tif (!decls) {\n\t\t\tdecls = new Map<string, ReferencedTypeDeclaration>();\n\t\t\tthis.referencedTypeDecls.set(filePath, decls);\n\t\t}\n\t\tconst entry: ReferencedTypeDeclaration = { kind, node : declNode, file : filePath };\n\t\tdecls.set(name, entry);\n\n\t\t// `export default class Foo {}` is also reachable under the 'default'\n\t\t// binding for default importers\n\t\tif (kind === 'class') {\n\t\t\tconst classNode = declNode as ts.ClassDeclaration;\n\t\t\tconst isExported = classNode.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;\n\t\t\tconst isDefault = classNode.modifiers?.some(m => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;\n\t\t\tif (isExported && isDefault) {\n\t\t\t\tdecls.set('default', entry);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Record consts initialized with an array literal (optionally wrapped in\n\t * `as const` / `satisfies`), so a `typeof statusList[number]` field type\n\t * expands to the element literal union — the generated file carries no\n\t * imports, so emitting the bare `typeof statusList` query would be an\n\t * unresolvable name downstream. First binding wins: a nested shadow\n\t * must not replace the module-level const the typeof refers to.\n\t */\n\tprivate trackReferencedTypeConstArray (node: ts.Node): void {\n\t\tif (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer) {\n\t\t\treturn;\n\t\t}\n\t\tconst { initializer: rawInitializer } = node;\n\t\tlet initializer: ts.Expression = rawInitializer;\n\t\twhile (ts.isAsExpression(initializer) || ts.isSatisfiesExpression(initializer)) {\n\t\t\tinitializer = initializer.expression;\n\t\t}\n\t\tif (!ts.isArrayLiteralExpression(initializer)) {\n\t\t\treturn;\n\t\t}\n\t\tconst filePath = this.currentReferencedTypeFile;\n\t\tlet consts = this.referencedTypeConstArrays.get(filePath);\n\t\tif (!consts) {\n\t\t\tconsts = new Map<string, ts.ArrayLiteralExpression>();\n\t\t\tthis.referencedTypeConstArrays.set(filePath, consts);\n\t\t}\n\t\tif (!consts.has(node.name.text)) {\n\t\t\tconsts.set(node.name.text, initializer);\n\t\t}\n\t}\n\n\t/**\n\t * Find the array literal behind a module const referenced through\n\t * `typeof`: the declaring file's own consts first (the F13 case is a\n\t * NON-exported const in the same module as the expanded class), then —\n\t * when the file imports the name — the imported module's consts.\n\t * External modules are never analyzed, so those yield nothing.\n\t */\n\tprivate findReferencedConstArray (\n\t\tname: string,\n\t\tfromFile: string\n\t): ts.ArrayLiteralExpression | undefined {\n\t\tconst local = this.referencedTypeConstArrays.get(fromFile)?.get(name);\n\t\tif (local) {\n\t\t\treturn local;\n\t\t}\n\t\tconst imported = this.referencedTypeImports.get(fromFile)?.get(name);\n\t\tif (!imported || imported.isNamespace) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst resolution = this.resolveReferencedTypeModule(imported.specifier, fromFile);\n\t\tif (!resolution || resolution.isExternal) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst found = this.referencedTypeConstArrays.get(resolution.resolvedPath)?.get(imported.originalName);\n\t\treturn found;\n\t}\n\n\t/**\n\t * Element literal types of a tracked const array: every element must be\n\t * a plain literal (optionally wrapped in `as const` / `satisfies`) —\n\t * string, numeric, boolean, or null. Spreads, identifiers, and nested\n\t * arrays mean the union is not statically visible and yield undefined,\n\t * so the caller degrades the field to `unknown` rather than guessing.\n\t */\n\tprivate literalTypesOfArray (arrayLiteral: ts.ArrayLiteralExpression): string[] | undefined {\n\t\tconst literals: string[] = [];\n\t\tfor (const element of arrayLiteral.elements) {\n\t\t\tif (ts.isSpreadElement(element)) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tlet expr: ts.Expression = element;\n\t\t\twhile (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) {\n\t\t\t\texpr = expr.expression;\n\t\t\t}\n\t\t\tif (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {\n\t\t\t\tliterals.push(`'${expr.text}'`);\n\t\t\t} else if (ts.isNumericLiteral(expr)) {\n\t\t\t\tliterals.push(expr.text);\n\t\t\t} else if (expr.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\tliterals.push('true');\n\t\t\t} else if (expr.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\tliterals.push('false');\n\t\t\t} else if (expr.kind === ts.SyntaxKind.NullKeyword) {\n\t\t\t\tliterals.push('null');\n\t\t\t} else {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t}\n\t\tif (literals.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst result = literals;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Emit-type for `typeof name` when `name` is a tracked const array: the\n\t * union of its element literal types (`'active' | 'closed'`). Every\n\t * other typeof source — non-array consts, functions, classes, names not\n\t * tracked at all — yields undefined, so the caller degrades the field\n\t * to `unknown`: a bare `typeof name` emitted into types.ts has no\n\t * import to resolve against downstream.\n\t */\n\tprivate typeOfConstArrayUnion (name: string, fromFile: string): string | undefined {\n\t\tconst arrayLiteral = this.findReferencedConstArray(name, fromFile);\n\t\tif (!arrayLiteral) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst literals = this.literalTypesOfArray(arrayLiteral);\n\t\tif (!literals) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst union = literals.join(' | ');\n\t\treturn union;\n\t}\n\n\t/**\n\t * Record the importing file's named/namespace/default import bindings so\n\t * referenced-type names resolve through the file's own import statements\n\t * (F10) rather than a program-wide name map.\n\t */\n\tprivate trackReferencedTypeImport (node: ts.Node): void {\n\t\tif (!ts.isImportDeclaration(node)) {\n\t\t\treturn;\n\t\t}\n\t\tconst { moduleSpecifier } = node;\n\t\tif (!ts.isStringLiteral(moduleSpecifier)) {\n\t\t\treturn;\n\t\t}\n\t\tconst clause = node.importClause;\n\t\tif (!clause) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst filePath = this.currentReferencedTypeFile;\n\t\tlet imports = this.referencedTypeImports.get(filePath);\n\t\tif (!imports) {\n\t\t\timports = new Map<string, ReferencedTypeImport>();\n\t\t\tthis.referencedTypeImports.set(filePath, imports);\n\t\t}\n\n\t\t// import { SharedShape } from '…' / import { SharedShape as S } from '…'\n\t\tif (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {\n\t\t\tfor (const element of clause.namedBindings.elements) {\n\t\t\t\tconst localName = element.name.text;\n\t\t\t\tconst originalName = element.propertyName ? element.propertyName.text : localName;\n\t\t\t\timports.set(localName, {\n\t\t\t\t\toriginalName,\n\t\t\t\t\tspecifier   : moduleSpecifier.text,\n\t\t\t\t\tisNamespace : false\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\t// import * as models from '…' — resolved when a qualified name\n\t\t// (models.SharedShape) is encountered\n\t\tif (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {\n\t\t\timports.set(clause.namedBindings.name.text, {\n\t\t\t\toriginalName : '',\n\t\t\t\tspecifier    : moduleSpecifier.text,\n\t\t\t\tisNamespace  : true\n\t\t\t});\n\t\t}\n\n\t\t// import SharedShape from '…' (default import)\n\t\tif (clause.name) {\n\t\t\timports.set(clause.name.text, {\n\t\t\t\toriginalName : 'default',\n\t\t\t\tspecifier    : moduleSpecifier.text,\n\t\t\t\tisNamespace  : false\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Record re-export wiring (`export { X } from '…'`, `export * from '…'`,\n\t * `export { X as Y }`) so resolution can chase barrels to the origin\n\t * module. Mirrors ModuleGraphBuilder.resolveOrigin, name-based only.\n\t */\n\tprivate trackReferencedTypeReExport (node: ts.Node): void {\n\t\tif (!ts.isExportDeclaration(node)) {\n\t\t\treturn;\n\t\t}\n\t\tconst filePath = this.currentReferencedTypeFile;\n\t\tconst { moduleSpecifier } = node;\n\t\tconst specifierText = moduleSpecifier && ts.isStringLiteral(moduleSpecifier)\n\t\t\t? moduleSpecifier.text\n\t\t\t: undefined;\n\n\t\tif (node.exportClause && ts.isNamedExports(node.exportClause)) {\n\t\t\tfor (const element of node.exportClause.elements) {\n\t\t\t\tconst exportedName = element.name.text;\n\t\t\t\tconst localName = element.propertyName ? element.propertyName.text : exportedName;\n\t\t\t\tif (specifierText) {\n\t\t\t\t\t// export { X } from '…' / export { X as Y } from '…'\n\t\t\t\t\tlet reExports = this.referencedTypeReExports.get(filePath);\n\t\t\t\t\tif (!reExports) {\n\t\t\t\t\t\treExports = new Map<string, string>();\n\t\t\t\t\t\tthis.referencedTypeReExports.set(filePath, reExports);\n\t\t\t\t\t}\n\t\t\t\t\treExports.set(exportedName, specifierText);\n\t\t\t\t} else if (localName !== exportedName) {\n\t\t\t\t\t// export { X as Y } — same-file alias of a local declaration\n\t\t\t\t\tlet aliases = this.referencedTypeExportAliases.get(filePath);\n\t\t\t\t\tif (!aliases) {\n\t\t\t\t\t\taliases = new Map<string, string>();\n\t\t\t\t\t\tthis.referencedTypeExportAliases.set(filePath, aliases);\n\t\t\t\t\t}\n\t\t\t\t\taliases.set(exportedName, localName);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tif (node.exportClause && ts.isNamespaceExport(node.exportClause)) {\n\t\t\t// `export * as ns from '…'` — a nested module namespace; middle\n\t\t\t// segments of qualified references (barrel.Deep.Gadget) chase it\n\t\t\tif (specifierText) {\n\t\t\t\tlet stars = this.referencedTypeNamespaceStars.get(filePath);\n\t\t\t\tif (!stars) {\n\t\t\t\t\tstars = new Map<string, string>();\n\t\t\t\t\tthis.referencedTypeNamespaceStars.set(filePath, stars);\n\t\t\t\t}\n\t\t\t\tstars.set(node.exportClause.name.text, specifierText);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tif (!node.exportClause && specifierText) {\n\t\t\t// export * from '…'\n\t\t\tlet stars = this.referencedTypeExportStars.get(filePath);\n\t\t\tif (!stars) {\n\t\t\t\tstars = [];\n\t\t\t\tthis.referencedTypeExportStars.set(filePath, stars);\n\t\t\t}\n\t\t\tstars.push(specifierText);\n\t\t}\n\t}\n\n\t/**\n\t * Resolve a module specifier from a containing file with the program's\n\t * compilerOptions (tsconfig `paths`, extensionless imports, index files).\n\t * Module resolution only — the no-getTypeChecker() precedent stays.\n\t */\n\tprivate resolveReferencedTypeModule (specifier: string, containingFile: string):\n\t\tReferencedTypeResolution | undefined {\n\t\tconst cacheKey = `${containingFile}::${specifier}`;\n\t\tif (this.referencedTypeResolutionCache.has(cacheKey)) {\n\t\t\tconst cached = this.referencedTypeResolutionCache.get(cacheKey);\n\t\t\treturn cached === undefined ? undefined : cached;\n\t\t}\n\n\t\tconst resolution = ts.resolveModuleName(\n\t\t\tspecifier,\n\t\t\tcontainingFile,\n\t\t\tthis.referencedTypeCompilerOptions,\n\t\t\tts.sys\n\t\t).resolvedModule;\n\n\t\tconst result: ReferencedTypeResolution | undefined = resolution\n\t\t\t? {\n\t\t\t\tresolvedPath : nodePath.resolve(resolution.resolvedFileName),\n\t\t\t\tisExternal   : !!resolution.isExternalLibraryImport\n\t\t\t}\n\t\t\t: undefined;\n\n\t\tthis.referencedTypeResolutionCache.set(cacheKey, result);\n\t\tconst finalResult = result;\n\t\treturn finalResult;\n\t}\n\n\t/**\n\t * Look up a name in one resolved module, chasing re-export barrels with a\n\t * bounded depth. External (node_modules) modules hold no in-project\n\t * declarations and stop the chase.\n\t */\n\tprivate findReferencedTypeInModule (\n\t\tmodulePath: string,\n\t\tname: string,\n\t\tdepth: number\n\t): ReferencedTypeDeclaration | undefined {\n\t\tif (depth > MAX_REEXPORT_CHASE_DEPTH) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst decls = this.referencedTypeDecls.get(modulePath);\n\t\tconst direct = decls?.get(name);\n\t\tif (direct) {\n\t\t\treturn direct;\n\t\t}\n\t\t// export { X as Y } — resolve through the local name\n\t\tconst localAlias = this.referencedTypeExportAliases.get(modulePath)?.get(name);\n\t\tif (localAlias) {\n\t\t\tconst aliased = decls?.get(localAlias);\n\t\t\tif (aliased) {\n\t\t\t\treturn aliased;\n\t\t\t}\n\t\t}\n\n\t\tconst reExports = this.referencedTypeReExports.get(modulePath);\n\t\tconst reExportSpecifier = reExports?.get(name);\n\t\tif (reExportSpecifier) {\n\t\t\tconst nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, modulePath);\n\t\t\tif (nextResolution && !nextResolution.isExternal) {\n\t\t\t\tconst found = this.findReferencedTypeInModule(nextResolution.resolvedPath, name, depth + 1);\n\t\t\t\tif (found) {\n\t\t\t\t\treturn found;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst stars = this.referencedTypeExportStars.get(modulePath);\n\t\tif (stars) {\n\t\t\tfor (const starSpecifier of stars) {\n\t\t\t\tconst nextResolution = this.resolveReferencedTypeModule(starSpecifier, modulePath);\n\t\t\t\tif (!nextResolution || nextResolution.isExternal) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst found = this.findReferencedTypeInModule(nextResolution.resolvedPath, name, depth + 1);\n\t\t\t\tif (found) {\n\t\t\t\t\treturn found;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve a referenced type name as used in fromFile, import-aware:\n\t *   1. the file's own import statements (relative + tsconfig paths,\n\t *      chased through re-export barrels),\n\t *   2. the file's local declarations,\n\t *   3. the unique same-named declaration across scanned files.\n\t * Returns undefined when nothing matches (or the match is ambiguous),\n\t * in which case the caller falls back to `unknown`.\n\t */\n\tprivate resolveReferencedTypeDeclaration (\n\t\tname: string,\n\t\tfromFile: string\n\t): ReferencedTypeDeclaration | undefined {\n\t\t// 1. the file's own imports win — an import is never shadowed by a\n\t\t// same-named local declaration elsewhere in the program (F10)\n\t\tconst imported = this.referencedTypeImports.get(fromFile)?.get(name);\n\t\tif (imported && !imported.isNamespace) {\n\t\t\tconst resolution = this.resolveReferencedTypeModule(imported.specifier, fromFile);\n\t\t\tif (resolution && !resolution.isExternal) {\n\t\t\t\tconst found = this.findReferencedTypeInModule(resolution.resolvedPath, imported.originalName, 0);\n\t\t\t\tif (found) {\n\t\t\t\t\treturn found;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// 2. local declaration in the referencing file itself\n\t\tconst local = this.referencedTypeDecls.get(fromFile)?.get(name);\n\t\tif (local) {\n\t\t\treturn local;\n\t\t}\n\n\t\t// 3. program-wide fallback, unique declaration only — ambiguity and\n\t\t// absence both yield undefined (the caller emits `unknown`).\n\t\t// External/ambient declarations (.d.ts, node_modules) do not\n\t\t// participate: a user-local declaration always wins over a\n\t\t// package-declared same-named type (the plain-TS tier of the\n\t\t// identity law; ambiguity among the remaining declarations is\n\t\t// validated separately as a hard fail)\n\t\tlet unique: ReferencedTypeDeclaration | undefined;\n\t\tlet count = 0;\n\t\tfor (const [ filePath, decls ] of this.referencedTypeDecls) {\n\t\t\tif (this.isExternalDeclFile(filePath)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst candidate = decls.get(name);\n\t\t\tif (candidate) {\n\t\t\t\tcount++;\n\t\t\t\tunique = candidate;\n\t\t\t\tif (count > 1) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst result = count === 1 ? unique : undefined;\n\t\treturn result;\n\t}\n\n\t/**\n\t * External/ambient declaration files (.d.ts, anything under\n\t * node_modules) never participate in plain-TS referenced-type\n\t * resolution or the ambiguity law: they are not project source, the\n\t * CLI never analyzes them, and a user-local declaration always wins\n\t * over a package-declared same-named type.\n\t */\n\tprivate isExternalDeclFile (file: string): boolean {\n\t\tconst external = file.endsWith('.d.ts') ||\n\t\t\tfile.includes(`${nodePath.sep}node_modules${nodePath.sep}`);\n\t\treturn external;\n\t}\n\n\t/**\n\t * Properties of a referenced class/interface/alias-of-literal declaration,\n\t * shared by `this:`-parameter expansion and inline type emission.\n\t * Inherited members are included: the extends chain is walked\n\t * (depth-capped, cycle-guarded) and parent fields merge first, the\n\t * declaration's own fields overriding on name clash.\n\t */\n\tprivate referencedDeclarationProperties (decl: ReferencedTypeDeclaration):\n\t\tMap<string, PropertyInfo> {\n\t\tconst visited = new Set<string>();\n\t\tconst properties = this.referencedDeclarationPropertiesInner(decl, visited, 0);\n\t\treturn properties;\n\t}\n\n\tprivate referencedDeclarationPropertiesInner (\n\t\tdecl: ReferencedTypeDeclaration,\n\t\tvisited: Set<string>,\n\t\tdepth: number\n\t): Map<string, PropertyInfo> {\n\t\tconst ownProperties = new Map<string, PropertyInfo>();\n\t\tconst declNode = decl.node as ts.ClassDeclaration | ts.InterfaceDeclaration;\n\t\tconst declName = declNode.name && ts.isIdentifier(declNode.name) ? declNode.name.text : '';\n\t\tconst visitKey = `${decl.kind}:${decl.file}:${declName}`;\n\t\tif (depth > MAX_HERITAGE_DEPTH || visited.has(visitKey)) {\n\t\t\treturn ownProperties;\n\t\t}\n\t\tvisited.add(visitKey);\n\n\t\tif (decl.kind === 'class') {\n\t\t\tconst classProps = this.extractClassProperties(decl.node as ts.ClassDeclaration);\n\t\t\tfor (const [ name, info ] of classProps) {\n\t\t\t\townProperties.set(name, info);\n\t\t\t}\n\t\t} else if (decl.kind === 'interface') {\n\t\t\tconst iface = decl.node as ts.InterfaceDeclaration;\n\t\t\tthis.collectTypeElementProperties([ ...iface.members ], ownProperties);\n\t\t} else {\n\t\t\tconst aliasType = (decl.node as ts.TypeAliasDeclaration).type;\n\t\t\tif (ts.isTypeLiteralNode(aliasType)) {\n\t\t\t\tthis.collectTypeElementProperties([ ...aliasType.members ], ownProperties);\n\t\t\t} else {\n\t\t\t\treturn ownProperties;\n\t\t\t}\n\t\t}\n\n\t\t// heritage merges parent fields first; the declaration's own fields\n\t\t// override on name clash (later bases override earlier ones)\n\t\tconst merged = new Map<string, PropertyInfo>();\n\t\tfor (const baseDecl of this.resolveHeritageDeclarations(decl)) {\n\t\t\tconst baseProps = this.referencedDeclarationPropertiesInner(baseDecl, visited, depth + 1);\n\t\t\tfor (const [ name, info ] of baseProps) {\n\t\t\t\tmerged.set(name, info);\n\t\t\t}\n\t\t}\n\t\tfor (const [ name, info ] of ownProperties) {\n\t\t\tmerged.set(name, info);\n\t\t}\n\t\treturn merged;\n\t}\n\n\t/**\n\t * Property signatures of interface/alias type-literal members, into\n\t * the given map.\n\t */\n\tprivate collectTypeElementProperties (\n\t\tmembers: readonly ts.TypeElement[],\n\t\tproperties: Map<string, PropertyInfo>\n\t): void {\n\t\tfor (const member of members) {\n\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\tconst propName = member.name.text;\n\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\tproperties.set(propName, {\n\t\t\t\t\tname     : propName,\n\t\t\t\t\ttype,\n\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Resolve the heritage clause of a class (`extends Base`) or interface\n\t * (`extends A, B`) to referenced-type declarations through the SAME\n\t * import-aware machinery as plain references (the declaring file's own\n\t * imports first, then its locals, then the unique program-wide\n\t * declaration). Unresolvable or external bases yield nothing — their\n\t * inherited fields simply stay absent, same as before this walk\n\t * existed. Mixin calls (`extends mixin(X)`) and namespace access are\n\t * not followed.\n\t */\n\tprivate resolveHeritageDeclarations (decl: ReferencedTypeDeclaration): ReferencedTypeDeclaration[] {\n\t\tconst { heritageClauses } = (decl.node as ts.ClassDeclaration | ts.InterfaceDeclaration);\n\t\tif (!heritageClauses) {\n\t\t\treturn [];\n\t\t}\n\t\tconst bases: ReferencedTypeDeclaration[] = [];\n\t\tfor (const clause of heritageClauses) {\n\t\t\tif (clause.token !== ts.SyntaxKind.ExtendsKeyword) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (const heritageType of clause.types) {\n\t\t\t\tif (!ts.isIdentifier(heritageType.expression)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst baseName = heritageType.expression.text;\n\t\t\t\tconst baseDecl = this.resolveReferencedTypeDeclaration(baseName, decl.file);\n\t\t\t\tif (baseDecl) {\n\t\t\t\t\tbases.push(baseDecl);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst result = bases;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Expand a referenced-type declaration to a self-contained type string\n\t * for emission into generated files: type aliases through inferType,\n\t * classes and interfaces through their (public, non-method) fields.\n\t * Nested references resolve against the declaring file while expanding.\n\t */\n\tprivate expandReferencedTypeDeclaration (decl: ReferencedTypeDeclaration): string | undefined {\n\t\tconst referencingFile = this.currentReferencedTypeFile;\n\t\tthis.currentReferencedTypeFile = decl.file;\n\t\ttry {\n\t\t\tconst result = this.expandReferencedTypeDeclarationInner(decl);\n\t\t\treturn result;\n\t\t} finally {\n\t\t\tthis.currentReferencedTypeFile = referencingFile;\n\t\t}\n\t}\n\n\tprivate expandReferencedTypeDeclarationInner (decl: ReferencedTypeDeclaration): string | undefined {\n\t\tif (decl.kind === 'alias') {\n\t\t\tconst aliasNode = decl.node as ts.TypeAliasDeclaration;\n\t\t\tconst aliasName = ts.isIdentifier(aliasNode.name) ? aliasNode.name.text : '';\n\t\t\tif (aliasName && this.expandingReferencedAliases.has(aliasName)) {\n\t\t\t\t// Self-referential alias chain — bail out\n\t\t\t\treturn 'unknown';\n\t\t\t}\n\t\t\tif (aliasName) {\n\t\t\t\tthis.expandingReferencedAliases.add(aliasName);\n\t\t\t}\n\t\t\tconst expanded = this.inferType(aliasNode.type);\n\t\t\tif (aliasName) {\n\t\t\t\tthis.expandingReferencedAliases.delete(aliasName);\n\t\t\t}\n\t\t\treturn expanded;\n\t\t}\n\n\t\tconst declProperties = this.referencedDeclarationProperties(decl);\n\t\tconst props = Array.from(declProperties.entries()).map(([ propName, info ]) => {\n\t\t\tconst optional = info.optional ? '?' : '';\n\t\t\treturn `${propName}${optional}: ${info.type}`;\n\t\t});\n\n\t\tconst result = `{ ${props.join('; ')} }`;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Resolve a simple (non-qualified) type reference: import-aware\n\t * declaration expansion first, then the InstanceType<typeof X> pattern,\n\t * then mnemonica graph types; known globals keep their bare name and\n\t * anything else falls back to `unknown` so generated files never carry\n\t * an unresolvable bare name. Returns undefined when the caller should\n\t * keep the generic spelling (handled separately).\n\t */\n\tprivate resolveSimpleTypeReference (\n\t\ttypeName: string,\n\t\ttypeArgs?: ts.NodeArray<ts.TypeNode>,\n\t\trefNode?: ts.Node\n\t): string | undefined {\n\t\t// Import-aware referenced-type declaration (F10)\n\t\tconst decl = this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile);\n\t\tif (decl) {\n\t\t\tconst expanded = this.expandReferencedTypeDeclaration(decl);\n\t\t\tif (expanded !== undefined) {\n\t\t\t\treturn expanded;\n\t\t\t}\n\t\t\tconst unknownResult = 'unknown';\n\t\t\treturn unknownResult;\n\t\t}\n\n\t\t// Mnemonica-graph identity law: path-aware resolution (value scope,\n\t\t// imports, nearest-chain, root, program-wide). Ambiguity between\n\t\t// real graph types is a hard failure; a name no graph type carries\n\t\t// stays in the plain-TS soft scope and falls to `unknown`.\n\t\tconst graphResult = this.resolveGraphTypeName(typeName);\n\t\tif (graphResult.status === 'unique') {\n\t\t\t// Handle InstanceType<typeof X> pattern -> convert to Parent_X\n\t\t\tif (typeName === 'InstanceType' && typeArgs && typeArgs.length === 1) {\n\t\t\t\tconst [ arg ] = typeArgs;\n\t\t\t\tif (arg.kind === ts.SyntaxKind.TypeQuery) {\n\t\t\t\t\tconst typeQuery = arg as ts.TypeQueryNode;\n\t\t\t\t\tif (ts.isIdentifier(typeQuery.exprName)) {\n\t\t\t\t\t\tconst queryResult = this.resolveGraphTypeName(typeQuery.exprName.text);\n\t\t\t\t\t\tif (queryResult.status === 'unique') {\n\t\t\t\t\t\t\t// Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry\n\t\t\t\t\t\t\treturn queryResult.node.fullPath.replace(/\\./g, '_');\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (queryResult.status === 'ambiguous') {\n\t\t\t\t\t\t\tthis.recordGraphReferenceError(typeQuery.exprName.text, typeQuery, queryResult);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Not a known mnemonica type — no bare emission\n\t\t\t\t\t\treturn 'unknown';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!typeArgs || typeArgs.length === 0) {\n\t\t\t\t// Convert full path with dots to underscores: Usages.UsageEntry -> Usages_UsageEntry\n\t\t\t\treturn graphResult.node.fullPath.replace(/\\./g, '_');\n\t\t\t}\n\t\t\t// Generic use of a graph type keeps its simple name; the\n\t\t\t// generator upgrades it to the full-path instance type name\n\t\t\treturn `${typeName}<${typeArgs.map(a => this.inferType(a)).join(', ')}>`;\n\t\t}\n\t\tif (graphResult.status === 'ambiguous') {\n\t\t\tthis.recordGraphReferenceError(typeName, refNode ?? this.currentReferencedTypeFile, graphResult);\n\t\t}\n\n\t\tif (typeArgs && typeArgs.length > 0) {\n\t\t\tif (KNOWN_GLOBAL_TYPES.has(typeName)) {\n\t\t\t\tconst genericResult = `${typeName}<${typeArgs.map(a => this.inferType(a)).join(', ')}>`;\n\t\t\t\treturn genericResult;\n\t\t\t}\n\t\t\t// Generic reference to a non-global, non-graph type cannot be\n\t\t\t// emitted bare into the generated file\n\t\t\tif (refNode) {\n\t\t\t\tthis.recordPlainTypeReferenceSite(typeName, refNode);\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\n\t\tconst fallbackResult = this.unresolvedTypeReferenceFallback(typeName, refNode);\n\t\treturn fallbackResult;\n\t}\n\n\t/**\n\t * Resolve a qualified type reference (models.Inner.Crate) through the\n\t * current file's namespace imports. The chain's head must be a namespace\n\t * import; middle segments descend through namespace declarations, named\n\t * re-exports of namespaces, and `export * as ns from '…'` barrels (each\n\t * segment consumed exactly once, so the walk cannot cycle); the final\n\t * segment resolves to a declaration which is expanded inline. When the\n\t * precise walk finds nothing, the legacy rightmost-name lookup in the\n\t * head module keeps one-level forms (models.Type) working — nested\n\t * declarations are recorded by plain name there too. Returns undefined\n\t * when the head is not a namespace import or nothing resolves.\n\t */\n\tprivate inferQualifiedTypeReference (typeRef: ts.TypeReferenceNode): string | undefined {\n\t\tif (!ts.isQualifiedName(typeRef.typeName)) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// flatten the qualified name chain: models.Inner.Crate → ['models', 'Inner', 'Crate']\n\t\tconst segments: string[] = [];\n\t\tlet chain: ts.EntityName = typeRef.typeName;\n\t\twhile (ts.isQualifiedName(chain)) {\n\t\t\tsegments.unshift(chain.right.text);\n\t\t\tchain = chain.left;\n\t\t}\n\t\tsegments.unshift(chain.text);\n\n\t\tconst namespaceImport = this.referencedTypeImports.get(this.currentReferencedTypeFile)?.get(segments[ 0 ]);\n\t\tif (!namespaceImport || !namespaceImport.isNamespace) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst resolution = this.resolveReferencedTypeModule(namespaceImport.specifier, this.currentReferencedTypeFile);\n\t\tif (!resolution || resolution.isExternal) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// descend the middle segments: a module context resolves the segment\n\t\t// as a namespace declaration / namespace re-export; a namespace-block\n\t\t// context resolves it as a nested namespace declaration\n\t\tlet qualifier: { modulePath: string; block?: ts.ModuleBlock } | undefined = {\n\t\t\tmodulePath : resolution.resolvedPath\n\t\t};\n\t\tfor (let i = 1; i < segments.length - 1 && qualifier; i++) {\n\t\t\tconst segment = segments[ i ];\n\t\t\tif (qualifier.block) {\n\t\t\t\tconst nested = this.findNamespaceInBlock(qualifier.block, segment);\n\t\t\t\tif (nested?.body && ts.isModuleBlock(nested.body)) {\n\t\t\t\t\tqualifier = { modulePath : qualifier.modulePath, block : nested.body };\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tqualifier = undefined;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tconst namespaceDecl: ts.ModuleDeclaration | undefined =\n\t\t\t\tthis.referencedTypeNamespaces.get(qualifier.modulePath)?.get(segment);\n\t\t\tif (namespaceDecl?.body && ts.isModuleBlock(namespaceDecl.body)) {\n\t\t\t\tqualifier = { modulePath : qualifier.modulePath, block : namespaceDecl.body };\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst starSpecifier = this.referencedTypeNamespaceStars.get(qualifier.modulePath)?.get(segment);\n\t\t\tif (starSpecifier) {\n\t\t\t\tconst nextResolution = this.resolveReferencedTypeModule(starSpecifier, qualifier.modulePath);\n\t\t\t\tif (nextResolution && !nextResolution.isExternal) {\n\t\t\t\t\tqualifier = { modulePath : nextResolution.resolvedPath };\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst reExportSpecifier = this.referencedTypeReExports.get(qualifier.modulePath)?.get(segment);\n\t\t\tif (reExportSpecifier) {\n\t\t\t\tconst nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, qualifier.modulePath);\n\t\t\t\tconst reExported: ts.ModuleDeclaration | undefined =\n\t\t\t\t\tnextResolution && !nextResolution.isExternal\n\t\t\t\t\t\t? this.referencedTypeNamespaces.get(nextResolution.resolvedPath)?.get(segment)\n\t\t\t\t\t\t: undefined;\n\t\t\t\tif (reExported?.body && ts.isModuleBlock(reExported.body)) {\n\t\t\t\t\tqualifier = { modulePath : nextResolution!.resolvedPath, block : reExported.body };\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tqualifier = undefined;\n\t\t}\n\n\t\tconst finalName = segments[ segments.length - 1 ];\n\t\tlet decl: ReferencedTypeDeclaration | undefined;\n\t\tif (qualifier?.block) {\n\t\t\tdecl = this.findReferencedTypeInBlock(qualifier.block, qualifier.modulePath, finalName);\n\t\t} else if (qualifier) {\n\t\t\tdecl = this.findReferencedTypeInModule(qualifier.modulePath, finalName, 0);\n\t\t}\n\t\t// legacy fallback: rightmost name anywhere in the head module\n\t\t// (namespace-nested declarations are also recorded by plain name)\n\t\tif (!decl) {\n\t\t\tdecl = this.findReferencedTypeInModule(resolution.resolvedPath, finalName, 0);\n\t\t}\n\t\tif (!decl) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst expanded = this.expandReferencedTypeDeclaration(decl);\n\t\treturn expanded;\n\t}\n\n\t/**\n\t * Find a namespace declaration by name directly inside a module block.\n\t */\n\tprivate findNamespaceInBlock (block: ts.ModuleBlock, name: string): ts.ModuleDeclaration | undefined {\n\t\tfor (const statement of block.statements) {\n\t\t\tif (ts.isModuleDeclaration(statement) && ts.isIdentifier(statement.name) &&\n\t\t\t\tstatement.name.text === name) {\n\t\t\t\tconst result = statement;\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Find a named type declaration (alias, class, interface) directly inside\n\t * a namespace block — the final segment of a descended qualified chain.\n\t */\n\tprivate findReferencedTypeInBlock (\n\t\tblock: ts.ModuleBlock,\n\t\tfilePath: string,\n\t\tname: string\n\t): ReferencedTypeDeclaration | undefined {\n\t\tfor (const statement of block.statements) {\n\t\t\tif (ts.isTypeAliasDeclaration(statement) && ts.isIdentifier(statement.name) &&\n\t\t\t\tstatement.name.text === name) {\n\t\t\t\tconst result: ReferencedTypeDeclaration = { kind : 'alias', node : statement, file : filePath };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\tif (ts.isClassDeclaration(statement) && statement.name && statement.name.text === name) {\n\t\t\t\tconst result: ReferencedTypeDeclaration = { kind : 'class', node : statement, file : filePath };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\tif (ts.isInterfaceDeclaration(statement) && ts.isIdentifier(statement.name) &&\n\t\t\t\tstatement.name.text === name) {\n\t\t\t\tconst result: ReferencedTypeDeclaration = { kind : 'interface', node : statement, file : filePath };\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Fallback for a type-reference name that resolves to no declaration and\n\t * no graph type: known globals keep their bare name (they resolve without\n\t * an import); everything else becomes `unknown` so generated types.ts\n\t * never carries an unresolvable bare name (README's documented behavior)\n\t * and the site is recorded for the plain-TS ambiguity validation.\n\t */\n\tprivate unresolvedTypeReferenceFallback (typeName: string, refNode?: ts.Node): string {\n\t\tif (KNOWN_GLOBAL_TYPES.has(typeName)) {\n\t\t\treturn typeName;\n\t\t}\n\t\tif (refNode) {\n\t\t\tthis.recordPlainTypeReferenceSite(typeName, refNode);\n\t\t}\n\t\tconst result = 'unknown';\n\t\treturn result;\n\t}\n\n\t/**\n\t * Record one define()/lazy()/@decorate() site under its runtime\n\t * namespace key. Two sites in one namespace are a same-namespace\n\t * duplicate (the runtime throws ALREADY_DECLARED); every site is kept\n\t * so the failure can report all locations.\n\t */\n\tprivate recordDefineSite (namespaceKey: string, location: string): void {\n\t\tlet sites = this.defineSites.get(namespaceKey);\n\t\tif (!sites) {\n\t\t\tsites = [];\n\t\t\tthis.defineSites.set(namespaceKey, sites);\n\t\t}\n\t\tif (!sites.includes(location)) {\n\t\t\tsites.push(location);\n\t\t}\n\t}\n\n\t/**\n\t * Fatal resolution failures (hard-fail law): same-namespace duplicate\n\t * mnemonica definitions plus ambiguous/unresolved mnemonica-graph\n\t * references. The CLI prints every location and writes no output.\n\t */\n\tgetResolutionErrors (): ResolutionError[] {\n\t\tthis.validateLookupReferences();\n\t\tthis.validatePlainTypeReferences();\n\t\tconst errors: ResolutionError[] = [];\n\t\tfor (const [ namespaceKey, sites ] of this.defineSites) {\n\t\t\tif (sites.length < 2) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst displayName = namespaceKey.replace(/^[^:]+::/, '');\n\t\t\tconst message = `Duplicate definition of '${displayName}' in one namespace — ` +\n\t\t\t\t'the mnemonica runtime would throw ALREADY_DECLARED';\n\t\t\terrors.push({ message, locations : [ ...sites ] });\n\t\t}\n\t\tfor (const error of this.graphReferenceErrors) {\n\t\t\terrors.push(error);\n\t\t}\n\t\tconst result = errors;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Resolve a reference to a mnemonica graph type name, import-aware and\n\t * path-aware (the hard-fail identity law, mirroring the runtime):\n\t *   1. value scope — a tracked top-level binding in the referencing file\n\t *      (`const Address = User.define('Address', …)`),\n\t *   2. import scope — a binding exported from a module this file imports\n\t *      (barrels chased),\n\t *   3. nearest-chain — the anchor type's own subtypes first, then each\n\t *      ancestor level (relative-first),\n\t *   4. root — roots of the anchor's collection,\n\t *   5. program-wide — only when exactly one type carries the name.\n\t * Ambiguity (several candidates and nothing disambiguates) and absence\n\t * are both returned as such — the caller records a hard failure; a bare\n\t * first-match name is never emitted.\n\t */\n\tprivate resolveGraphTypeName (name: string): GraphTypeReferenceResult {\n\t\t// 1. value scope in the referencing file itself\n\t\tconst localBinding = this.fileGraphBindings.get(this.currentReferencedTypeFile)?.get(name);\n\t\tif (localBinding) {\n\t\t\tconst node = this.graph.findType(localBinding);\n\t\t\tif (node) {\n\t\t\t\tconst valueResult: GraphTypeReferenceResult = { status : 'unique', node };\n\t\t\t\treturn valueResult;\n\t\t\t}\n\t\t}\n\n\t\t// 2. import scope — the imported module's exported binding\n\t\tconst imported = this.referencedTypeImports.get(this.currentReferencedTypeFile)?.get(name);\n\t\tif (imported && !imported.isNamespace) {\n\t\t\tconst resolution = this.resolveReferencedTypeModule(imported.specifier, this.currentReferencedTypeFile);\n\t\t\tif (resolution && !resolution.isExternal) {\n\t\t\t\tconst fullPath = this.findGraphBindingInModule(resolution.resolvedPath, imported.originalName, 0);\n\t\t\t\tif (fullPath) {\n\t\t\t\t\tconst node = this.graph.findType(fullPath);\n\t\t\t\t\tif (node) {\n\t\t\t\t\t\tconst importResult: GraphTypeReferenceResult = { status : 'unique', node };\n\t\t\t\t\t\treturn importResult;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// 3-5. chain / root / program-wide tiers\n\t\tconst result = resolveGraphTypeReference(this.graph, name, this.currentGraphAnchor);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Find a graph constructor binding exported by a resolved module,\n\t * chasing re-export barrels with a bounded depth.\n\t */\n\tprivate findGraphBindingInModule (modulePath: string, name: string, depth: number): string | undefined {\n\t\tif (depth > MAX_REEXPORT_CHASE_DEPTH) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst direct = this.fileGraphBindings.get(modulePath)?.get(name);\n\t\tif (direct) {\n\t\t\treturn direct;\n\t\t}\n\n\t\tconst reExports = this.referencedTypeReExports.get(modulePath);\n\t\tconst reExportSpecifier = reExports?.get(name);\n\t\tif (reExportSpecifier) {\n\t\t\tconst nextResolution = this.resolveReferencedTypeModule(reExportSpecifier, modulePath);\n\t\t\tif (nextResolution && !nextResolution.isExternal) {\n\t\t\t\tconst found = this.findGraphBindingInModule(nextResolution.resolvedPath, name, depth + 1);\n\t\t\t\tif (found) {\n\t\t\t\t\treturn found;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst stars = this.referencedTypeExportStars.get(modulePath);\n\t\tif (stars) {\n\t\t\tfor (const starSpecifier of stars) {\n\t\t\t\tconst nextResolution = this.resolveReferencedTypeModule(starSpecifier, modulePath);\n\t\t\t\tif (!nextResolution || nextResolution.isExternal) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst found = this.findGraphBindingInModule(nextResolution.resolvedPath, name, depth + 1);\n\t\t\t\tif (found) {\n\t\t\t\t\treturn found;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Validate literal lookup() paths recorded during the usages pass\n\t * against the complete graph. A lookup path matching no type is what the\n\t * runtime answers with `undefined` — the TypeError arrives one line\n\t * later at the `new` — so it joins the hard-fail law. The relative-first\n\t * step already ran inside resolveLookupPath; whatever was recorded is\n\t * the root-resolution result, so a plain findType check is the exact\n\t * runtime law. Same-named types elsewhere in the graph are listed as\n\t * did-you-mean candidates. Runs once per usages pass (re-armed by\n\t * resetUsages); non-literal lookup arguments are never recorded and\n\t * stay best-effort.\n\t */\n\tprivate validateLookupReferences (): void {\n\t\tif (this.lookupReferencesValidated) {\n\t\t\treturn;\n\t\t}\n\t\tthis.lookupReferencesValidated = true;\n\t\t// group sites by path: every failing site of the same path is listed\n\t\tconst sitesByPath = new Map<string, string[]>();\n\t\tfor (const ref of this.lookupReferences) {\n\t\t\tconst sites = sitesByPath.get(ref.path) ?? [];\n\t\t\tsites.push(ref.location);\n\t\t\tsitesByPath.set(ref.path, sites);\n\t\t}\n\t\tfor (const [ typePath, sites ] of sitesByPath) {\n\t\t\tif (this.graph.findType(typePath)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// did-you-mean: types carrying the same name anywhere in the\n\t\t\t// graph (never a first-match pick — the full list only)\n\t\t\tconst unprefixed = typePath.replace(/^[^:]+::/, '');\n\t\t\tconst lastSegment = unprefixed.split('.').pop() ?? unprefixed;\n\t\t\tconst candidates = this.graph.getAllTypes().filter(t => t.name === lastSegment);\n\t\t\tif (candidates.length === 0) {\n\t\t\t\tconst noneError: ResolutionError = {\n\t\t\t\t\tmessage : `Unresolved lookup of mnemonica type '${typePath}': no type at that path — ` +\n\t\t\t\t\t\t'the runtime would return undefined',\n\t\t\t\t\tlocations : sites,\n\t\t\t\t};\n\t\t\t\tthis.graphReferenceErrors.push(noneError);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst candidateLocations = candidates.map(n => `${n.sourceFile}:${n.line}:${n.column}`);\n\t\t\tconst candidatePaths = candidates.map(n => n.fullPath).join(', ');\n\t\t\tconst ambiguousError: ResolutionError = {\n\t\t\t\tmessage : `Unresolved lookup of mnemonica type '${typePath}': the runtime would return ` +\n\t\t\t\t\t`undefined — ${candidates.length} graph type(s) carry the name ` +\n\t\t\t\t\t`off-root (${candidatePaths}); use the full dotted path`,\n\t\t\t\tlocations : [ ...sites, ...candidateLocations ],\n\t\t\t};\n\t\t\tthis.graphReferenceErrors.push(ambiguousError);\n\t\t}\n\t}\n\n\t/**\n\t * Record a plain-TS type reference site that resolved to nothing and\n\t * fell back to `unknown`, for the lazily-run ambiguity validation.\n\t * Deduped by (name, location): inferType can visit the same node more\n\t * than once per pass (constructor params + property inference).\n\t */\n\tprivate recordPlainTypeReferenceSite (name: string, refNode: ts.Node): void {\n\t\tconst location = this.nodeLocation(refNode);\n\t\tconst file = this.currentReferencedTypeFile;\n\t\tconst already = this.plainTypeReferences.some((ref) => ref.name === name && ref.location === location);\n\t\tif (already) {\n\t\t\treturn;\n\t\t}\n\t\tthis.plainTypeReferences.push({ name, location, file });\n\t}\n\n\t/**\n\t * Project-source declaration files carrying `name` — one entry per\n\t * file, so same-file interface merging counts once (not ambiguous).\n\t * External/ambient declarations (.d.ts, anything under node_modules)\n\t * never count: a user-local declaration always wins over a package-\n\t * declared same-named type, so an external collision stays soft.\n\t */\n\tprivate plainTypeDeclarationFiles (name: string): string[] {\n\t\tconst files: string[] = [];\n\t\tfor (const [ file, decls ] of this.referencedTypeDecls) {\n\t\t\tif (!this.isExternalDeclFile(file) && decls.has(name)) {\n\t\t\t\tfiles.push(file);\n\t\t\t}\n\t\t}\n\t\treturn files;\n\t}\n\n\t/**\n\t * Validate plain-TS type reference sites recorded during the usages\n\t * pass against the complete declaration map. A name declared in\n\t * several project-source files — with no import in the referencing\n\t * file to anchor it — is ambiguous: silently emitting `unknown` would\n\t * hide a real type the author meant, so it joins the hard-fail law\n\t * (the plain-TS tier of the same identity law as graph references).\n\t * Absence (ghost names) and external collisions stay soft `unknown`.\n\t * Runs once per usages pass (re-armed by resetUsages), mirroring\n\t * validateLookupReferences: recording happens on every pass, but only\n\t * the usages pass sees the complete declaration map.\n\t */\n\tprivate validatePlainTypeReferences (): void {\n\t\tif (this.plainTypeReferencesValidated) {\n\t\t\treturn;\n\t\t}\n\t\tthis.plainTypeReferencesValidated = true;\n\t\tconst sitesByName = new Map<string, { name: string; location: string; file: string }[]>();\n\t\tfor (const ref of this.plainTypeReferences) {\n\t\t\tconst sites = sitesByName.get(ref.name) ?? [];\n\t\t\tsites.push(ref);\n\t\t\tsitesByName.set(ref.name, sites);\n\t\t}\n\t\tfor (const [ name, sites ] of sitesByName) {\n\t\t\t// an import binding in the referencing file anchors the name —\n\t\t\t// the author already disambiguated (the import may just point\n\t\t\t// at an unanalyzable external module, which stays soft)\n\t\t\tconst unanchored = sites.filter((site) => !this.referencedTypeImports.get(site.file)?.has(name));\n\t\t\tif (unanchored.length === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst declFiles = this.plainTypeDeclarationFiles(name);\n\t\t\tif (declFiles.length < 2) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst message = `Ambiguous reference to type '${name}': ${declFiles.length} declarations ` +\n\t\t\t\t'share the name and no import disambiguates — import the one you mean';\n\t\t\tconst declLocations = declFiles.map((file) => this.plainDeclLocation(file, name));\n\t\t\tconst error: ResolutionError = {\n\t\t\t\tmessage,\n\t\t\t\tlocations : [ ...unanchored.map((site) => site.location), ...declLocations ]\n\t\t\t};\n\t\t\tthis.graphReferenceErrors.push(error);\n\t\t}\n\t}\n\n\t/**\n\t * `file:line:column` of a recorded declaration, for the ambiguity\n\t * report. Nodes recorded during traversal keep their positions; a\n\t * synthetic/unpositioned node falls back to the file itself.\n\t */\n\tprivate plainDeclLocation (file: string, name: string): string {\n\t\tconst decl = this.referencedTypeDecls.get(file)?.get(name);\n\t\tconst node = decl?.node;\n\t\tlet location = `${file}:1:1`;\n\t\tif (node && node.pos >= 0) {\n\t\t\tconst sourceFile = node.getSourceFile();\n\t\t\tconst line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;\n\t\t\tconst column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;\n\t\t\tlocation = `${file}:${line}:${column}`;\n\t\t}\n\t\tconst result = location;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Record a hard-fail graph reference error with the reference site and\n\t * every candidate location.\n\t */\n\tprivate recordGraphReferenceError (\n\t\tname: string,\n\t\trefNode: ts.Node | string,\n\t\tresult: Extract<GraphTypeReferenceResult, { status: 'ambiguous' | 'none' }>\n\t): void {\n\t\tconst location = typeof refNode === 'string' ? refNode : this.nodeLocation(refNode);\n\t\tif (result.status === 'ambiguous') {\n\t\t\tconst candidateLocations = result.candidates.map(n => `${n.sourceFile}:${n.line}:${n.column}`);\n\t\t\tconst ambiguousMessage = `Ambiguous reference to mnemonica type '${name}': ` +\n\t\t\t\t`${result.candidates.length} types share the name and neither the parent chain ` +\n\t\t\t\t'nor the imports disambiguate';\n\t\t\tconst ambiguousError: ResolutionError = {\n\t\t\t\tmessage   : ambiguousMessage,\n\t\t\t\tlocations : [ location, ...candidateLocations ],\n\t\t\t};\n\t\t\tthis.graphReferenceErrors.push(ambiguousError);\n\t\t\treturn;\n\t\t}\n\t\tconst unresolvedMessage = `Unresolved reference to mnemonica type '${name}': no type matches ` +\n\t\t\t'by value scope, imports, parent chain, or root path';\n\t\tconst unresolvedError: ResolutionError = { message : unresolvedMessage, locations : [ location ] };\n\t\tthis.graphReferenceErrors.push(unresolvedError);\n\t}\n\n\t/**\n\t * Location (`file:line:column`) of an AST node, derived without parent\n\t * pointers when necessary.\n\t */\n\tprivate nodeLocation (node: ts.Node): string {\n\t\tlet current: ts.Node | undefined = node;\n\t\twhile (current && !ts.isSourceFile(current)) {\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\tif (!current) {\n\t\t\tconst fallback = this.currentReferencedTypeFile;\n\t\t\treturn fallback;\n\t\t}\n\t\tconst start = node.getStart(current);\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(current, start);\n\t\tconst location = `${current.fileName}:${line + 1}:${character + 1}`;\n\t\treturn location;\n\t}\n\n\t/**\n\t * Track aliases of the mnemonica module object, e.g.:\n\t *   const m = mnemonica;\n\t *   const App = m;\n\t */\n\tprivate trackModuleObjectAliases (node: ts.Node): void {\n\t\tif (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { initializer } = node;\n\t\tif (!initializer) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (ts.isIdentifier(initializer) && this.moduleObjectVariables.has(initializer.text)) {\n\t\t\tthis.moduleObjectVariables.add(node.name.text);\n\t\t}\n\t}\n\n\t/**\n\t * Track custom collection variables, e.g.:\n\t *   const MyCollection = createTypesCollection();\n\t *   const Other = MyCollection;\n\t *\n\t * Also detects Option B user-provided registry interfaces:\n\t *   export interface MyCollectionRegistry {}\n\t *   const MyCollection = createTypesCollection<MyCollectionRegistry>();\n\t */\n\tprivate trackCollectionAliases (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { initializer } = node;\n\t\tif (!initializer) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Direct createTypesCollection() call\n\t\tif (this.isCreateTypesCollectionCall(initializer)) {\n\t\t\tconst collectionId = this.nextCollectionId();\n\t\t\tthis.collectionVariables.set(node.name.text, collectionId);\n\n\t\t\tconst registryInterfaceName = this.extractRegistryInterfaceName(\n\t\t\t\tinitializer as ts.CallExpression,\n\t\t\t\tsourceFile\n\t\t\t);\n\t\t\tthis.collectionInfo.set(collectionId, {\n\t\t\t\tvariableName          : node.name.text,\n\t\t\t\tsourceFile            : sourceFile.fileName,\n\t\t\t\tregistryInterfaceName : registryInterfaceName\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Alias of another collection variable\n\t\tif (ts.isIdentifier(initializer)) {\n\t\t\tconst existing = this.collectionVariables.get(initializer.text);\n\t\t\tif (existing) {\n\t\t\t\tthis.collectionVariables.set(node.name.text, existing);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Extract the registry interface name from createTypesCollection<Registry>()\n\t * when the interface is declared in the same source file.\n\t */\n\tprivate extractRegistryInterfaceName (\n\t\tcall: ts.CallExpression,\n\t\tsourceFile: ts.SourceFile\n\t): string | undefined {\n\t\tconst typeArgs = call.typeArguments;\n\t\tif (!typeArgs || typeArgs.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstTypeArg ] = typeArgs;\n\t\tif (!ts.isTypeReferenceNode(firstTypeArg) || !ts.isIdentifier(firstTypeArg.typeName)) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst name = firstTypeArg.typeName.text;\n\n\t\t// Confirm the interface exists in the same source file.\n\t\tfor (const statement of sourceFile.statements) {\n\t\t\tif (\n\t\t\t\tts.isInterfaceDeclaration(statement) &&\n\t\t\t\tstatement.name.text === name\n\t\t\t) {\n\t\t\t\treturn name;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Get the registry interface name for a collection id.\n\t */\n\tprivate getRegistryInterfaceName (collectionId?: string): string | undefined {\n\t\tif (!collectionId) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.collectionInfo.get(collectionId)?.registryInterfaceName;\n\t}\n\n\t/**\n\t * Check if an expression is a createTypesCollection() call.\n\t * Handles:\n\t *   createTypesCollection()\n\t *   ctc() // aliased import\n\t *   mnemonica.createTypesCollection() // module object method\n\t *   m.createTypesCollection() // aliased module object\n\t */\n\tprivate isCreateTypesCollectionCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\t\tconst expr = node.expression;\n\n\t\t// Direct call or aliased import: createTypesCollection() / ctc()\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text === 'createTypesCollection' ||\n\t\t\t\tthis.createTypesCollectionVariables.has(expr.text);\n\t\t}\n\n\t\t// Module object method: mnemonica.createTypesCollection()\n\t\tif (\n\t\t\tts.isPropertyAccessExpression(expr) &&\n\t\t\texpr.name.text === 'createTypesCollection' &&\n\t\t\tts.isIdentifier(expr.expression) &&\n\t\t\tthis.moduleObjectVariables.has(expr.expression.text)\n\t\t) {\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Generate a unique collection identifier.\n\t */\n\tprivate nextCollectionId (): string {\n\t\tthis.collectionCounter++;\n\t\tconst result = `collection_${this.collectionCounter}`;\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a node is a define() call\n\t */\n\tprivate isDefineCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for direct call: define('TypeName', ...)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'define') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for method call: SomeType.define('SubType', ...)\n\t\tif (ts.isPropertyAccessExpression(expression)) {\n\t\t\treturn expression.name?.text === 'define';\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Check if a node is a lazy() call\n\t */\n\tprivate isLazyCall (node: ts.Node): node is ts.CallExpression {\n\t\tif (!ts.isCallExpression(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for direct call: lazy('TypeName', getter, ...)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'lazy') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for method call: SomeType.lazy('SubType', getter, ...)\n\t\tif (ts.isPropertyAccessExpression(expression)) {\n\t\t\treturn expression.name?.text === 'lazy';\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t\t* Extract config options from an object literal\n\t\t*/\n\tprivate extractConfigFromObjectLiteral (configArg: ts.ObjectLiteralExpression):\n\t\t{ strictChain?: boolean; blockErrors?: boolean } {\n\t\tconst config: { strictChain?: boolean; blockErrors?: boolean } = {};\n\n\t\tfor (const prop of configArg.properties) {\n\t\t\tif (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {\n\t\t\t\tconst propName = prop.name.text;\n\t\t\t\tif (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\t\tconfig.strictChain = true;\n\t\t\t\t} else if (propName === 'strictChain' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\t\tconfig.strictChain = false;\n\t\t\t\t} else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\t\tconfig.blockErrors = true;\n\t\t\t\t} else if (propName === 'blockErrors' && prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\t\tconfig.blockErrors = false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn config;\n\t}\n\n\t/**\n\t\t* Extract config options from define() call\n\t\t*/\n\tprivate extractConfig (call: ts.CallExpression): { strictChain?: boolean; blockErrors?: boolean } {\n\t\t// Config is the third argument: define('Name', handler, config)\n\t\tconst [ , , configArg ] = call.arguments;\n\t\tif (!configArg || !ts.isObjectLiteralExpression(configArg)) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst configResult = this.extractConfigFromObjectLiteral(configArg);\n\t\treturn configResult;\n\t}\n\n\t/**\n\t\t* Check if a node is a @decorate() decorator\n\t\t*/\n\tprivate isDecorateDecorator (node: ts.Node): node is ts.Decorator {\n\t\tif (!ts.isDecorator(node)) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst { expression } = node;\n\n\t\t// Check for @decorate\n\t\tif (ts.isIdentifier(expression) && expression.text === 'decorate') {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Check for @decorate() or @decorate(ParentType)\n\t\tif (ts.isCallExpression(expression)) {\n\t\t\tconst fnName = expression.expression;\n\t\t\tif (ts.isIdentifier(fnName) && fnName.text === 'decorate') {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\t// Check for @MyCollection.decorate() where MyCollection is a custom collection\n\t\t\tif (\n\t\t\t\tts.isPropertyAccessExpression(fnName) &&\n\t\t\t\tfnName.name.text === 'decorate' &&\n\t\t\t\tts.isIdentifier(fnName.expression) &&\n\t\t\t\tthis.collectionVariables.has(fnName.expression.text)\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Mark a call expression as processed and return whether it already was.\n\t */\n\tprivate markProcessed (call: ts.CallExpression): boolean {\n\t\tif (this.processedCalls.has(call)) {\n\t\t\treturn true;\n\t\t}\n\t\tthis.processedCalls.add(call);\n\t\treturn false;\n\t}\n\n\t/**\n\t * Process a define() call\n\t */\n\tprivate processDefineCall (call: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\t// Check if this exact call has already been processed (prevents duplicates from chained calls)\n\t\tif (this.markProcessed(call)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Get the type name and source context from arguments\n\t\tconst defineContext = this.extractDefineContext(call);\n\n\t\t// For chained calls like define('A').define('B'), we want the position of the .define('B') part\n\t\t// not the start of the entire expression\n\t\tlet positionNode: ts.Node = call;\n\n\t\t// If this is a chained call, get the position of the property access expression\n\t\t// which is the .define part\n\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t// The expression is the property access: (define('RootAsync', ...)).define\n\t\t\t// We want the position of just the .define part\n\t\t\t// This is the 'define' identifier\n\t\t\tpositionNode = call.expression.name;\n\t\t}\n\n\t\tconst startPos = positionNode.getStart(sourceFile);\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);\n\n\t\tif (!defineContext.typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Could not extract type name from define() call',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst { typeName } = defineContext;\n\n\t\t// Determine parent type and collection based on the call source.\n\t\tconst parentNode = defineContext.parentType;\n\t\tconst { collectionId } = defineContext;\n\n\t\t// Extract config options\n\t\tconst config = this.extractConfig(call);\n\n\t\t// Create type node first so its internal fullPath (including any collection prefix) is resolved.\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(collectionId);\n\n\t\t// Same-namespace duplicate detection (hard-fail law): key by the\n\t\t// runtime namespace — collection roots `<collection>::<name>`, or\n\t\t// `<parentFullPath>.<name>` for subtypes\n\t\tthis.recordDefineSite(\n\t\t\tparentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`,\n\t\t\t`${sourceFile.fileName}:${line + 1}:${character + 1}`\n\t\t);\n\n\t\t// Extract properties from constructor function — the new node anchors\n\t\t// relative-first graph reference resolution while its own signature\n\t\t// is being read\n\t\tconst previousAnchor = this.currentGraphAnchor;\n\t\tthis.currentGraphAnchor = node;\n\t\ttry {\n\t\t\tnode.properties = this.extractProperties(call);\n\n\t\t\t// Extract constructor parameters for TypeRegistry signature\n\t\t\tnode.constructorParams = this.extractConstructorParams(call);\n\t\t} finally {\n\t\t\tthis.currentGraphAnchor = previousAnchor;\n\t\t}\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Create definition info using the node's resolved fullPath\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : parentNode ? parentNode.fullPath : null,\n\t\t\tstrictChain : config.strictChain ?? true,\n\t\t\tblockErrors : config.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(node.fullPath, definition);\n\t\tthis.edsScopeByNode.set(call, node.fullPath);\n\n\t\t// Track variable assignment: const User = define('UserEntity', ...) -> map \"User\" to \"UserEntity\"\n\t\t// For chained calls like const X = define('A').define('B'), we want to map X -> A (the root)\n\t\tthis.trackVariableAssignment(call, parentNode, node.fullPath);\n\t}\n\n\t/**\n\t * Process a lazy() call\n\t */\n\tprivate processLazyCall (call: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\t// Check if this exact call has already been processed (prevents duplicates from chained calls)\n\t\tif (this.markProcessed(call)) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Get the type name and source context from arguments\n\t\tconst lazyContext = this.extractLazyContext(call, sourceFile);\n\n\t\t// For chained calls like define('A').lazy('B'), we want the position of the .lazy('B') part\n\t\t// not the start of the entire expression\n\t\tlet positionNode: ts.Node = call;\n\n\t\t// If this is a chained call, get the position of the property access expression\n\t\t// which is the .lazy part\n\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t// The expression is the property access: (define('RootAsync', ...)).lazy\n\t\t\t// We want the position of just the .lazy part\n\t\t\t// This is the 'lazy' identifier\n\t\t\tpositionNode = call.expression.name;\n\t\t}\n\n\t\tconst startPos = positionNode.getStart(sourceFile);\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(sourceFile, startPos);\n\n\t\tif (!lazyContext.typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Could not extract type name from lazy() call',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst { typeName } = lazyContext;\n\n\t\t// Determine parent type and collection based on the call source.\n\t\tconst parentNode = lazyContext.parentType;\n\t\tconst { collectionId } = lazyContext;\n\n\t\t// Extract config options\n\t\tconst config = this.extractLazyConfig(call);\n\n\t\t// Create type node first so its internal fullPath (including any collection prefix) is resolved.\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(collectionId);\n\n\t\t// Same-namespace duplicate detection (hard-fail law)\n\t\tthis.recordDefineSite(\n\t\t\tparentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`,\n\t\t\t`${sourceFile.fileName}:${line + 1}:${character + 1}`\n\t\t);\n\n\t\t// Extract properties from the constructor returned by the lazy getter\n\t\t// — the new node anchors relative-first graph reference resolution\n\t\tconst previousAnchor = this.currentGraphAnchor;\n\t\tthis.currentGraphAnchor = node;\n\t\ttry {\n\t\t\tnode.properties = this.extractProperties(call);\n\n\t\t\t// Extract constructor parameters for TypeRegistry signature\n\t\t\tnode.constructorParams = this.extractConstructorParams(call);\n\t\t} finally {\n\t\t\tthis.currentGraphAnchor = previousAnchor;\n\t\t}\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\n\t\t// Create definition info using the node's resolved fullPath\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'define',\n\t\t\tparent      : parentNode ? parentNode.fullPath : null,\n\t\t\tstrictChain : config.strictChain ?? true,\n\t\t\tblockErrors : config.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(node.fullPath, definition);\n\t\tthis.edsScopeByNode.set(call, node.fullPath);\n\n\t\t// Track variable assignment: const LazyType = lazy('LazyType', ...) -> map \"LazyType\" -> \"LazyType\"\n\t\t// For chained calls like const X = lazy('A').define('B'), we want to map X -> A (the root)\n\t\tthis.trackVariableAssignment(call, parentNode, node.fullPath);\n\t}\n\n\t/**\n\t * Extract lazy() call arguments into a normalized shape.\n\t * Handles named/unnamed and explicit-source forms, both as free calls\n\t * and as method calls.\n\t */\n\tprivate extractLazyCallArgs (call: ts.CallExpression): {\n\t\tsource?: ts.Expression;\n\t\tname?: string;\n\t\tgetter: ts.Expression;\n\t\tconfig?: ts.Expression;\n\t} | undefined {\n\t\tconst args = call.arguments;\n\t\tconst isMethodCall = ts.isPropertyAccessExpression(call.expression);\n\n\t\tif (isMethodCall) {\n\t\t\t// Source is the object of the property access: Type.lazy(...)\n\t\t\tconst source = call.expression.expression;\n\t\t\tif (args.length === 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst [ methodFirstArg ] = args;\n\t\t\tif (ts.isStringLiteral(methodFirstArg)) {\n\t\t\t\t// Type.lazy('Name', getter, config?)\n\t\t\t\tif (args.length < 2) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tsource,\n\t\t\t\t\tname   : methodFirstArg.text,\n\t\t\t\t\tgetter : args[ 1 ],\n\t\t\t\t\tconfig : args[ 2 ],\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Type.lazy(getter, config?)\n\t\t\treturn {\n\t\t\t\tsource,\n\t\t\t\tgetter : methodFirstArg,\n\t\t\t\tconfig : args[ 1 ],\n\t\t\t};\n\t\t}\n\n\t\t// Free call: lazy(...)\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstArg ] = args;\n\n\t\t// Explicit-source form: lazy(source, 'Name', getter, config?)\n\t\t// or lazy(source, getter, config?)\n\t\tif (args.length >= 2 && ts.isIdentifier(firstArg)) {\n\t\t\tconst [ , secondArg ] = args;\n\t\t\tif (ts.isStringLiteral(secondArg)) {\n\t\t\t\t// lazy(source, 'Name', getter, config?)\n\t\t\t\tif (args.length < 3) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tsource : firstArg,\n\t\t\t\t\tname   : secondArg.text,\n\t\t\t\t\tgetter : args[ 2 ],\n\t\t\t\t\tconfig : args[ 3 ],\n\t\t\t\t};\n\t\t\t}\n\t\t\t// lazy(source, getter, config?)\n\t\t\treturn {\n\t\t\t\tsource : firstArg,\n\t\t\t\tgetter : secondArg,\n\t\t\t\tconfig : args[ 2 ],\n\t\t\t};\n\t\t}\n\n\t\t// Named root form: lazy('Name', getter, config?)\n\t\tif (ts.isStringLiteral(firstArg)) {\n\t\t\tif (args.length < 2) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tname   : firstArg.text,\n\t\t\t\tgetter : args[ 1 ],\n\t\t\t\tconfig : args[ 2 ],\n\t\t\t};\n\t\t}\n\n\t\t// Unnamed root form: lazy(getter, config?)\n\t\treturn {\n\t\t\tgetter : firstArg,\n\t\t\tconfig : args[ 1 ],\n\t\t};\n\t}\n\n\t/**\n\t * Unwrap the constructor returned by a lazy getter.\n\t * Supports:\n\t *   () => class Name {}\n\t *   () => function Name() {}\n\t *   () => { return class Name {}; }\n\t *   function () { return function Name() {}; }\n\t */\n\tprivate unwrapLazyGetter (getterExpr: ts.Expression): ts.Expression | undefined {\n\t\tif (ts.isArrowFunction(getterExpr)) {\n\t\t\tconst { body } = getterExpr;\n\t\t\tif (!ts.isBlock(body)) {\n\t\t\t\treturn body;\n\t\t\t}\n\t\t\tfor (const stmt of body.statements) {\n\t\t\t\tif (ts.isReturnStatement(stmt) && stmt.expression) {\n\t\t\t\t\treturn stmt.expression;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\tif (ts.isFunctionExpression(getterExpr)) {\n\t\t\tconst { body } = getterExpr;\n\t\t\tfor (const stmt of body.statements) {\n\t\t\t\tif (ts.isReturnStatement(stmt) && stmt.expression) {\n\t\t\t\t\treturn stmt.expression;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Not a recognized getter pattern\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract a constructor name from a class expression, class declaration,\n\t * or named function expression.\n\t */\n\tprivate extractConstructorName (constructorExpr: ts.Expression): string | undefined {\n\t\tif (ts.isClassExpression(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\tif (ts.isClassDeclaration(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\tif (ts.isFunctionExpression(constructorExpr) && constructorExpr.name) {\n\t\t\treturn constructorExpr.name.text;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the type name from either a define() or lazy() call.\n\t */\n\tprivate extractMnemonicaTypeName (call: ts.CallExpression): string | undefined {\n\t\tif (this.isDefineCall(call)) {\n\t\t\treturn this.extractTypeName(call);\n\t\t}\n\t\tif (this.isLazyCall(call)) {\n\t\t\tconst args = this.extractLazyCallArgs(call);\n\t\t\tif (!args) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tif (args.name) {\n\t\t\t\treturn args.name;\n\t\t\t}\n\t\t\tconst constructorExpr = this.unwrapLazyGetter(args.getter);\n\t\t\tif (constructorExpr) {\n\t\t\t\treturn this.extractConstructorName(constructorExpr);\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the full lazy() call context: type name, parent type, and collection.\n\t * Handles direct calls, property-access calls, chained calls, and the\n\t * explicit-source form `lazy(source, 'TypeName', getter)`.\n\t */\n\tprivate extractLazyContext (call: ts.CallExpression, sourceFile: ts.SourceFile): {\n\t\ttypeName?: string;\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\tconst args = this.extractLazyCallArgs(call);\n\t\tif (!args) {\n\t\t\treturn {};\n\t\t}\n\n\t\tlet typeName: string | undefined = args.name;\n\t\tif (!typeName) {\n\t\t\tconst constructorExpr = this.unwrapLazyGetter(args.getter);\n\t\t\tif (constructorExpr) {\n\t\t\t\ttypeName = this.extractConstructorName(constructorExpr);\n\t\t\t}\n\t\t}\n\t\tif (!typeName) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst { expression } = call;\n\n\t\t// Direct call: lazy('TypeName', ...) or lazy(source, 'TypeName', getter)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'lazy') {\n\t\t\tif (args.source && ts.isIdentifier(args.source)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(args.source.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\t\t\t// Plain root lazy in default collection\n\t\t\treturn { typeName };\n\t\t}\n\n\t\t// Property access: X.lazy('TypeName', ...)\n\t\tif (ts.isPropertyAccessExpression(expression) && expression.name.text === 'lazy') {\n\t\t\tconst obj = expression.expression;\n\n\t\t\tif (ts.isIdentifier(obj)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(obj.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (ts.isPropertyAccessExpression(obj)) {\n\t\t\t\t// Nested access: instance.Type.lazy - try to resolve\n\t\t\t\tconst chain = this.getPropertyChain(obj);\n\t\t\t\tif (chain.length > 0) {\n\t\t\t\t\tconst parentNode = this.graph.findType(chain.join('.'));\n\t\t\t\t\treturn { typeName, parentType : parentNode };\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (ts.isCallExpression(obj)) {\n\t\t\t\t// Determine the collection context from the root of the chain so that\n\t\t\t\t// custom-collection types do not get confused with default-collection types.\n\t\t\t\tconst rootId = this.getRootIdentifier(obj.expression);\n\t\t\t\tconst expectedCollectionId = rootId\n\t\t\t\t\t? this.resolveDefineSource(rootId.text).collectionId\n\t\t\t\t\t: undefined;\n\n\t\t\t\t// Chained call: define('A').lazy('B') or lazy('A').lazy('B')\n\t\t\t\tif (this.isDefineCall(obj)) {\n\t\t\t\t\tthis.processDefineCall(obj, sourceFile);\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (this.isLazyCall(obj)) {\n\t\t\t\t\tthis.processLazyCall(obj, sourceFile);\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Builder lookup chain: App.lookup('User').lazy('Admin')\n\t\t\t\tif (this.isLookupCall(obj)) {\n\t\t\t\t\tconst lookedUpPath = this.resolveLookupPath(obj);\n\t\t\t\t\tif (lookedUpPath) {\n\t\t\t\t\t\tconst parentNode = this.graph.findType(lookedUpPath);\n\t\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode.collectionId };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn { typeName };\n\t}\n\n\t/**\n\t * Extract config options from lazy() call\n\t */\n\tprivate extractLazyConfig (call: ts.CallExpression): { strictChain?: boolean; blockErrors?: boolean } {\n\t\tconst args = this.extractLazyCallArgs(call);\n\t\tif (!args || !args.config || !ts.isObjectLiteralExpression(args.config)) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst configResult = this.extractConfigFromObjectLiteral(args.config);\n\t\treturn configResult;\n\t}\n\n\t/**\n\t\t* Track variable assignments that capture define() results\n\t\t* e.g., const User = define('UserEntity', ...) maps \"User\" -> \"UserEntity\"\n\t\t* For chained calls like const X = define('A').define('B'), we map X -> A (the root type)\n\t\t*/\n\tprivate trackVariableAssignment (\n\t\tcall: ts.CallExpression,\n\t\tparentNode: TypeNode | undefined,\n\t\tfullPath: string\n\t): void {\n\t\t// Check if this call is the right-hand side of a variable declaration\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = call.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = define(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\t// If this is a chained call (has parent), don't overwrite existing mapping\n\t\t\t\t\t// The first define in the chain sets the mapping to the root type\n\t\t\t\t\tif (parentNode && this.variableToTypeMap.has(varName)) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tthis.variableToTypeMap.set(varName, fullPath);\n\t\t\t\t\tthis.trackFileGraphBinding(varName, fullPath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\n\t/**\n\t * Mirror a variable -> mnemonica fullPath binding into the per-file\n\t * value-scope map (graph identity law: `typeof X` and bare references\n\t * resolve through the file's own bindings first).\n\t */\n\tprivate trackFileGraphBinding (varName: string, fullPath: string): void {\n\t\tconst filePath = this.currentReferencedTypeFile;\n\t\tlet bindings = this.fileGraphBindings.get(filePath);\n\t\tif (!bindings) {\n\t\t\tbindings = new Map<string, string>();\n\t\t\tthis.fileGraphBindings.set(filePath, bindings);\n\t\t}\n\t\tbindings.set(varName, fullPath);\n\t}\n\t\n\t/**\n\t\t* Track variable assignments from lookup() calls\n\t\t* e.g., const SentienceConstructor = lookup('Sentience') maps \"SentienceConstructor\" -> \"Sentience\"\n\t\t*/\n\tprivate trackLookupAssignment (call: ts.CallExpression, typePath: string): void {\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = call.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = lookup(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\tthis.variableToTypeMap.set(varName, typePath);\n\t\t\t\t\tthis.trackFileGraphBinding(varName, typePath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\n\t/**\n\t\t* Track variable assignments from new Type() calls\n\t\t* e.g., const user = new UserType() maps \"user\" -> \"UserType\"\n\t\t*/\n\tprivate trackNewAssignment (newExpr: ts.NewExpression, typePath: string): void {\n\t\t// Walk up the tree to find VariableDeclaration\n\t\tlet current: ts.Node | undefined = newExpr.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isVariableDeclaration(current)) {\n\t\t\t\t// Found: const X = new Type(...)\n\t\t\t\tif (ts.isIdentifier(current.name)) {\n\t\t\t\t\tconst varName = current.name.text;\n\t\t\t\t\tthis.variableToTypeMap.set(varName, typePath);\n\t\t\t\t\tthis.trackFileGraphBinding(varName, typePath);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t}\n\n\t/**\n\t\t* Process a @decorate() decorator\n\t */\n\tprivate processDecorateDecorator (\n\t\tdecorator: ts.Decorator,\n\t\tsourceFile: ts.SourceFile,\n\t\tclassDeclParam?: ts.ClassDeclaration\n\t): void {\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tdecorator.getStart(sourceFile)\n\t\t);\n\n\t\t// Get the class declaration - use the passed context if parent is not set\n\t\tconst classDecl = decorator.parent as ts.ClassDeclaration | undefined || classDeclParam;\n\t\tif (!classDecl || !classDecl.name) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Decorated class has no name',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst typeName = classDecl.name.text;\n\t\tif (!typeName) {\n\t\t\tthis.errors.push({\n\t\t\t\tmessage : 'Decorated class has no name',\n\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\tline    : line + 1,\n\t\t\t\tcolumn  : character + 1,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Parse decorator arguments: @decorate(), @decorate(Parent),\n\t\t// @decorate({ ... }), @decorate(Parent, { ... }),\n\t\t// @MyCollection.decorate(), @MyCollection.decorate({ ... })\n\t\tlet parentNode: TypeNode | undefined;\n\t\tlet parentFullPath: string | null = null;\n\t\tlet collectionId: string | undefined;\n\t\tlet decoratorConfig: { strictChain?: boolean; blockErrors?: boolean } = {};\n\n\t\tif (ts.isCallExpression(decorator.expression)) {\n\t\t\tconst callExpr = decorator.expression;\n\t\t\tconst callee = callExpr.expression;\n\n\t\t\t// Check for @MyCollection.decorate() where MyCollection is a custom collection.\n\t\t\t// The decorated class becomes a root type in that collection.\n\t\t\tif (\n\t\t\t\tts.isPropertyAccessExpression(callee) &&\n\t\t\t\tcallee.name.text === 'decorate' &&\n\t\t\t\tts.isIdentifier(callee.expression) &&\n\t\t\t\tthis.collectionVariables.has(callee.expression.text)\n\t\t\t) {\n\t\t\t\tcollectionId = this.collectionVariables.get(callee.expression.text);\n\t\t\t\tif (callExpr.arguments.length === 1 && ts.isObjectLiteralExpression(callExpr.arguments[ 0 ])) {\n\t\t\t\t\tdecoratorConfig = this.extractConfigFromObjectLiteral(callExpr.arguments[ 0 ]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst args = callExpr.arguments;\n\t\t\t\tlet parentArg: ts.Identifier | undefined;\n\t\t\t\tlet configArg: ts.ObjectLiteralExpression | undefined;\n\n\t\t\t\tfor (const arg of args) {\n\t\t\t\t\tif (ts.isIdentifier(arg)) {\n\t\t\t\t\t\tif (parentArg) {\n\t\t\t\t\t\t\tthis.errors.push({\n\t\t\t\t\t\t\t\tmessage : '@decorate() accepts only one parent reference',\n\t\t\t\t\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\t\t\t\t\tline    : line + 1,\n\t\t\t\t\t\t\t\tcolumn  : character + 1,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tparentArg = arg;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (ts.isObjectLiteralExpression(arg)) {\n\t\t\t\t\t\tif (configArg) {\n\t\t\t\t\t\t\tthis.errors.push({\n\t\t\t\t\t\t\t\tmessage : '@decorate() accepts only one config object',\n\t\t\t\t\t\t\t\tfile    : sourceFile.fileName,\n\t\t\t\t\t\t\t\tline    : line + 1,\n\t\t\t\t\t\t\t\tcolumn  : character + 1,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconfigArg = arg;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (parentArg) {\n\t\t\t\t\tparentNode = this.findParentTypeByIdentifier(parentArg.text);\n\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\tparentFullPath = parentNode.fullPath;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (configArg) {\n\t\t\t\t\tdecoratorConfig = this.extractConfigFromObjectLiteral(configArg);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Build full path\n\t\tconst fullPath = parentNode ? `${parentNode.fullPath}.${typeName}` : typeName;\n\n\t\t// Create definition info for decorate\n\t\tconst definition: DefinitionInfo = {\n\t\t\tname        : typeName,\n\t\t\tlocation    : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\tkind        : 'decorate',\n\t\t\tparent      : parentFullPath,\n\t\t\tstrictChain : decoratorConfig.strictChain ?? true,\n\t\t\tblockErrors : decoratorConfig.blockErrors ?? false,\n\t\t};\n\t\tthis.definitions.set(fullPath, definition);\n\t\tthis.edsScopeByNode.set(classDecl, fullPath);\n\n\t\t// Create type node\n\t\tconst node = TypeGraphImpl.createNode(\n\t\t\ttypeName,\n\t\t\tparentNode,\n\t\t\tsourceFile.fileName,\n\t\t\tline + 1,\n\t\t\tcharacter + 1,\n\t\t\tcollectionId\n\t\t);\n\t\tnode.registryInterfaceName = this.getRegistryInterfaceName(node.collectionId);\n\n\t\t// Same-namespace duplicate detection (hard-fail law)\n\t\tthis.recordDefineSite(\n\t\t\tparentNode ? `${parentNode.fullPath}.${typeName}` : `${collectionId ?? 'default'}::${typeName}`,\n\t\t\t`${sourceFile.fileName}:${line + 1}:${character + 1}`\n\t\t);\n\n\t\t// Extract properties and constructor parameters from class members —\n\t\t// the new node anchors relative-first graph reference resolution\n\t\tconst previousAnchor = this.currentGraphAnchor;\n\t\tthis.currentGraphAnchor = node;\n\t\ttry {\n\t\t\tnode.properties = this.extractClassProperties(classDecl);\n\t\t\tnode.constructorParams = this.extractClassConstructorParams(classDecl);\n\t\t} finally {\n\t\t\tthis.currentGraphAnchor = previousAnchor;\n\t\t}\n\n\t\t// Add to graph\n\t\tif (parentNode) {\n\t\t\tthis.graph.addChild(parentNode, node);\n\t\t} else {\n\t\t\tthis.graph.addRoot(node);\n\t\t}\n\t}\n\n\t/**\n\t * Extract type name from define() call arguments.\n\t * Handles:\n\t *   define('TypeName', handler)\n\t *   define(source, 'TypeName', handler)   // explicit-source form\n\t *   define(function TypeName() {})\n\t *   define(() => class TypeName {})\n\t */\n\tprivate extractTypeName (call: ts.CallExpression): string | undefined {\n\t\tconst args = call.arguments;\n\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst [ firstArg ] = args;\n\n\t\t// Explicit-source form: define(source, 'TypeName', handler)\n\t\tif (args.length >= 2 && ts.isIdentifier(firstArg) && ts.isStringLiteral(args[ 1 ])) {\n\t\t\treturn args[ 1 ].text;\n\t\t}\n\n\t\t// String literal: define('TypeName', ...)\n\t\tif (ts.isStringLiteral(firstArg)) {\n\t\t\treturn firstArg.text;\n\t\t}\n\n\t\t// Function with name: define(function TypeName() {})\n\t\tif (ts.isFunctionExpression(firstArg) && firstArg.name) {\n\t\t\treturn firstArg.name.text;\n\t\t}\n\n\t\t// Arrow function returning class: define(() => class TypeName {})\n\t\tif (ts.isArrowFunction(firstArg)) {\n\t\t\tconst { body } = firstArg;\n\t\t\tif (ts.isClassExpression(body) && body.name) {\n\t\t\t\treturn body.name.text;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract the full define() call context: type name, parent type, and collection.\n\t * Handles direct calls, property-access calls, chained calls, and the\n\t * explicit-source form `define(source, 'TypeName', handler)`.\n\t */\n\tprivate extractDefineContext (call: ts.CallExpression): {\n\t\ttypeName?: string;\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\tconst typeName = this.extractTypeName(call);\n\t\tif (!typeName) {\n\t\t\treturn {};\n\t\t}\n\n\t\tconst { expression } = call;\n\n\t\t// Direct call: define('TypeName', ...) or define(source, 'TypeName', handler)\n\t\tif (ts.isIdentifier(expression) && expression.text === 'define') {\n\t\t\t// Explicit-source form: define(source, 'TypeName', handler)\n\t\t\tif (call.arguments.length >= 2 && ts.isIdentifier(call.arguments[ 0 ])) {\n\t\t\t\tconst sourceName = call.arguments[ 0 ].text;\n\t\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// Plain root define in default collection\n\t\t\treturn { typeName };\n\t\t}\n\n\t\t// Property access: X.define('TypeName', ...)\n\t\tif (ts.isPropertyAccessExpression(expression) && expression.name.text === 'define') {\n\t\t\tconst obj = expression.expression;\n\n\t\t\tif (ts.isIdentifier(obj)) {\n\t\t\t\tconst sourceContext = this.resolveDefineSource(obj.text);\n\t\t\t\treturn {\n\t\t\t\t\ttypeName,\n\t\t\t\t\tparentType   : sourceContext.parentType,\n\t\t\t\t\tcollectionId : sourceContext.collectionId,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tif (ts.isPropertyAccessExpression(obj)) {\n\t\t\t\t// Nested access: instance.Type.define - try to resolve\n\t\t\t\tconst chain = this.getPropertyChain(obj);\n\t\t\t\tif (chain.length > 0) {\n\t\t\t\t\tconst parentNode = this.graph.findType(chain.join('.'));\n\t\t\t\t\treturn { typeName, parentType : parentNode };\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (ts.isCallExpression(obj)) {\n\t\t\t\t// Determine the collection context from the root of the chain so that\n\t\t\t\t// custom-collection types do not get confused with default-collection types.\n\t\t\t\tconst rootId = this.getRootIdentifier(obj.expression);\n\t\t\t\tconst expectedCollectionId = rootId\n\t\t\t\t\t? this.resolveDefineSource(rootId.text).collectionId\n\t\t\t\t\t: undefined;\n\n\t\t\t\t// Chained call: define('A').define('B') or mnemonica.define('A').define('B')\n\t\t\t\tif (this.isDefineCall(obj)) {\n\t\t\t\t\tthis.processDefineCall(obj, call.getSourceFile());\n\t\t\t\t\tconst parentTypeName = this.extractTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\t// Inherit collection from the parent type (if any)\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Chained lazy call: lazy('A').define('B') or Type.lazy('A').define('B')\n\t\t\t\tif (this.isLazyCall(obj)) {\n\t\t\t\t\tthis.processLazyCall(obj, call.getSourceFile());\n\t\t\t\t\tconst parentTypeName = this.extractMnemonicaTypeName(obj);\n\t\t\t\t\tif (parentTypeName) {\n\t\t\t\t\t\tconst parentNode = this.findParentTypeByName(parentTypeName, expectedCollectionId);\n\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode?.collectionId };\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Builder lookup chain: App.lookup('User').define('Admin')\n\t\t\t\tif (this.isLookupCall(obj)) {\n\t\t\t\t\tconst lookedUpPath = this.resolveLookupPath(obj);\n\t\t\t\t\tif (lookedUpPath) {\n\t\t\t\t\t\tconst parentNode = this.graph.findType(lookedUpPath);\n\t\t\t\t\t\tif (parentNode) {\n\t\t\t\t\t\t\treturn { typeName, parentType : parentNode, collectionId : parentNode.collectionId };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn { typeName };\n\t}\n\n\t/**\n\t * Prefix a dotted type path with a collection identifier so custom-collection\n\t * types do not collide with default-collection types in the graph.\n\t */\n\tprivate prefixCollectionPath (path: string, collectionId: string): string {\n\t\treturn `${collectionId}::${path}`;\n\t}\n\n\t/**\n\t * Resolve a define() source identifier to either a parent type, a collection,\n\t * or the default (module object) collection.\n\t */\n\tprivate resolveDefineSource (sourceName: string): {\n\t\tparentType?: TypeNode;\n\t\tcollectionId?: string;\n\t} {\n\t\t// Module object aliases -> root in default collection\n\t\tif (this.moduleObjectVariables.has(sourceName)) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// Collection variables -> root in that collection\n\t\tconst collectionId = this.collectionVariables.get(sourceName);\n\t\tif (collectionId) {\n\t\t\treturn { collectionId };\n\t\t}\n\n\t\t// Otherwise treat as a type variable reference\n\t\tconst parentNode = this.findParentTypeByIdentifier(sourceName);\n\t\treturn { parentType : parentNode, collectionId : parentNode?.collectionId };\n\t}\n\n\t/**\n\t * Check if a call expression is a lookup() call.\n\t */\n\tprivate isLookupCall (node: ts.CallExpression): boolean {\n\t\tconst expr = node.expression;\n\t\tif (ts.isIdentifier(expr) && expr.text === 'lookup') {\n\t\t\treturn true;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr) && expr.name.text === 'lookup') {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Resolve a lookup() call to a dotted type path (best effort).\n\t * Handles:\n\t *   lookup('User')\n\t *   lookup(source, 'User')\n\t *   App.lookup('User')\n\t *   collection.lookup('User.Admin')\n\t */\n\tprivate resolveLookupPath (call: ts.CallExpression): string | undefined {\n\t\tconst args = call.arguments;\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Single-arg lookup: lookup('User') or App.lookup('User')\n\t\tif (args.length === 1) {\n\t\t\tconst [ arg ] = args;\n\t\t\tif (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {\n\t\t\t\tconst path = arg.text;\n\t\t\t\t// If this is a method call on a source, resolve relative to that source.\n\t\t\t\tif (ts.isPropertyAccessExpression(call.expression)) {\n\t\t\t\t\tconst sourceExpr = call.expression.expression;\n\t\t\t\t\tif (ts.isIdentifier(sourceExpr)) {\n\t\t\t\t\t\tconst sourceName = sourceExpr.text;\n\t\t\t\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\t\t\t\tif (sourceContext.collectionId) {\n\t\t\t\t\t\t\t// Collection lookup: prefix path with the collection id\n\t\t\t\t\t\t\treturn this.prefixCollectionPath(path, sourceContext.collectionId);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (sourceContext.parentType) {\n\t\t\t\t\t\t\t// Type lookup: relative first, then root fallback\n\t\t\t\t\t\t\tconst relativePath = `${sourceContext.parentType.fullPath}.${path}`;\n\t\t\t\t\t\t\tif (this.graph.findType(relativePath)) {\n\t\t\t\t\t\t\t\treturn relativePath;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn path;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn path;\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Two-arg lookup: lookup(source, 'User')\n\t\tif (args.length >= 2) {\n\t\t\tconst [ sourceArg, pathArg ] = args;\n\t\t\tif (!ts.isIdentifier(sourceArg) || !ts.isStringLiteral(pathArg)) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst sourceName = sourceArg.text;\n\t\t\tconst path = pathArg.text;\n\t\t\tconst sourceContext = this.resolveDefineSource(sourceName);\n\t\t\tif (sourceContext.collectionId) {\n\t\t\t\treturn this.prefixCollectionPath(path, sourceContext.collectionId);\n\t\t\t}\n\t\t\tif (sourceContext.parentType) {\n\t\t\t\tconst relativePath = `${sourceContext.parentType.fullPath}.${path}`;\n\t\t\t\tif (this.graph.findType(relativePath)) {\n\t\t\t\t\treturn relativePath;\n\t\t\t\t}\n\t\t\t\treturn path;\n\t\t\t}\n\t\t\treturn path;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Lookup-law delegate for the local-scope walker (scopes.json typePath\n\t * metadata): resolve a lookup() initializer call through exactly the\n\t * tiers the usages pass resolved it against (same source resolution,\n\t * same complete graph). The walker runs its own scope-chain value-scope\n\t * tier before delegating; everything above value scope lands here, so\n\t * scopes.json never disagrees with the hard-fail-law verdicts.\n\t */\n\tresolveLookupCallPath (call: ts.CallExpression): string | undefined {\n\t\tconst result = this.resolveLookupPath(call);\n\t\treturn result;\n\t}\n\n\t/**\n\t\t* Find a parent type by its name, searching in the graph.\n\t\t* When collectionId is provided, only types from that collection are considered.\n\t\t*/\n\tprivate findParentTypeByName (\n\t\tname: string,\n\t\tcollectionId?: string\n\t): TypeNode | undefined {\n\t\tconst matchesCollection = (type: TypeNode): boolean => {\n\t\t\tif (collectionId === undefined) {\n\t\t\t\treturn type.collectionId === undefined;\n\t\t\t}\n\t\t\treturn type.collectionId === collectionId;\n\t\t};\n\n\t\t// First try exact match (default-collection types use the plain dotted path)\n\t\tconst exact = this.graph.findType(name);\n\t\tif (exact && matchesCollection(exact)) {\n\t\t\treturn exact;\n\t\t}\n\n\t\t// Then search through all types for one with matching name and collection\n\t\tfor (const type of this.graph.getAllTypes()) {\n\t\t\tif (type.name === name && matchesCollection(type)) {\n\t\t\t\treturn type;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t* Find a parent type from an identifier reference.\n\t\t* Handles both aliased variables (const User = define('UserEntity', ...))\n\t\t* and direct class/type names.\n\t\t*/\n\tprivate findParentTypeByIdentifier (name: string): TypeNode | undefined {\n\t\t// First check variable mapping: const User = define('UserEntity', ...)\n\t\tconst mappedFullPath = this.variableToTypeMap.get(name);\n\t\tif (mappedFullPath) {\n\t\t\tconst mappedNode = this.graph.findType(mappedFullPath);\n\t\t\tif (mappedNode) return mappedNode;\n\t\t}\n\n\t\tconst parentNode = this.findParentTypeByName(name);\n\t\treturn parentNode;\n\t}\n\n\t/**\n\t * Get the leftmost identifier of a property-access chain.\n\t * For `App.define('User').define('Admin')` this returns the `App` identifier.\n\t */\n\tprivate getRootIdentifier (expr: ts.Expression): ts.Identifier | undefined {\n\t\tlet current: ts.Expression = expr;\n\t\twhile (ts.isPropertyAccessExpression(current)) {\n\t\t\tcurrent = current.expression;\n\t\t}\n\t\tif (ts.isIdentifier(current)) {\n\t\t\treturn current;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t* Get property chain from nested access\n\t\t*/\n\tprivate getPropertyChain (expr: ts.PropertyAccessExpression | ts.Identifier): string[] {\n\t\tconst chain: string[] = [];\n\n\t\tlet current: ts.Expression = expr;\n\t\twhile (ts.isPropertyAccessExpression(current)) {\n\t\t\tif (current.name) {\n\t\t\t\tchain.unshift(current.name.text);\n\t\t\t}\n\t\t\tcurrent = current.expression;\n\t\t}\n\n\t\tif (ts.isIdentifier(current)) {\n\t\t\tchain.unshift(current.text);\n\t\t}\n\n\t\treturn chain;\n\t}\n\n\t/**\n\t * Determine the constructor expression for either a define() or lazy() call.\n\t * For define() this is the construct handler; for lazy() it is the value\n\t * returned by the lazy getter.\n\t */\n\tprivate extractConstructorExpression (call: ts.CallExpression): ts.Expression | undefined {\n\t\tconst expr = call.expression;\n\t\tconst name = ts.isIdentifier(expr)\n\t\t\t? expr.text\n\t\t\t: ts.isPropertyAccessExpression(expr)\n\t\t\t\t? expr.name.text\n\t\t\t\t: '';\n\n\t\tif (name === 'lazy') {\n\t\t\tconst lazyArgs = this.extractLazyCallArgs(call);\n\t\t\tif (!lazyArgs) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\treturn this.unwrapLazyGetter(lazyArgs.getter);\n\t\t}\n\n\t\t// define() call\n\t\tconst args = call.arguments;\n\t\tif (args.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Modern form: define('Name', handler, config?)\n\t\tif (ts.isStringLiteral(args[ 0 ])) {\n\t\t\treturn args[ 1 ];\n\t\t}\n\n\t\t// Legacy form: define(function Name() {}) or define(() => class Name {})\n\t\treturn args[ 0 ];\n\t}\n\n\t/**\n\t * Extract properties from constructor function\n\t */\n\tprivate extractProperties (call: ts.CallExpression): Map<string, PropertyInfo> {\n\t\tconst constructorExpr = this.extractConstructorExpression(call);\n\t\tif (!constructorExpr) {\n\t\t\treturn new Map<string, PropertyInfo>();\n\t\t}\n\t\tconst result = this.extractPropertiesFromConstructor(constructorExpr);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Extract properties from a constructor expression (function, arrow, or class).\n\t */\n\tprivate extractPropertiesFromConstructor (constructorExpr: ts.Expression): Map<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\t// Build type map from data parameter (for this.x = data.x patterns)\n\t\tconst dataTypeMap = this.buildDataTypeMap(constructorExpr);\n\n\t\t// Handle function expression\n\t\tif (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {\n\t\t\tconst { body } = constructorExpr;\n\n\t\t\t// First, extract properties from `this` parameter type annotation\n\t\t\t// This handles patterns like: function(this: SomeType, data: SomeType) { }\n\t\t\tconst thisParamProperties = this.extractThisParamProperties(constructorExpr);\n\t\t\tfor (const [ name, propInfo ] of thisParamProperties) {\n\t\t\t\tproperties.set(name, propInfo);\n\t\t\t}\n\n\t\t\t// Function body with statements\n\t\t\tif (ts.isBlock(body)) {\n\t\t\t\tfor (const stmt of body.statements) {\n\t\t\t\t\tif (ts.isExpressionStatement(stmt)) {\n\t\t\t\t\t\tthis.extractPropertyFromStatement(stmt.expression, properties, dataTypeMap);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Handle class expression\n\t\tif (ts.isClassExpression(constructorExpr)) {\n\t\t\t// First pass: collect all property types for method inference\n\t\t\tconst classPropertyTypes = this.extractClassPropertyTypes(constructorExpr);\n\n\t\t\tfor (const member of constructorExpr.members) {\n\t\t\t\t// Handle property declarations\n\t\t\t\tif (ts.isPropertyDeclaration(member) && member.name) {\n\t\t\t\t\t// Skip private and protected properties\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = ts.isIdentifier(member.name) ? member.name.text : '';\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\ttype     : this.inferType(member.type),\n\t\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Handle method declarations\n\t\t\t\tif (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t\t// Skip private and protected methods\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = member.name.text;\n\t\t\t\t\tconst type = this.inferMethodType(member, classPropertyTypes);\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : false,\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\t// Handle getter declarations\n\t\t\t\tif (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t\t// Skip private and protected getters\n\t\t\t\t\tif (member.modifiers) {\n\t\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => {\n\t\t\t\t\t\t\treturn m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t\t\tm.kind === ts.SyntaxKind.ProtectedKeyword;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst name = member.name.text;\n\t\t\t\t\t// First try explicit type annotation, then infer from getter body\n\t\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\t\tif (type === 'unknown' && member.body) {\n\t\t\t\t\t\ttype = this.inferReturnTypeFromBody(member.body, classPropertyTypes);\n\t\t\t\t\t}\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\treadonly : true,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t * Build a type map from all parameters with inline object type annotations\n\t * Returns a map of \"paramName.propertyName\" -> type\n\t */\n\tprivate buildDataTypeMap (handlerArg: ts.Expression): Map<string, string> {\n\t\tconst typeMap = new Map<string, string>();\n\n\t\tif (!ts.isFunctionExpression(handlerArg) && !ts.isArrowFunction(handlerArg)) {\n\t\t\treturn typeMap;\n\t\t}\n\n\t\t// Iterate over ALL parameters\n\t\tfor (const param of handlerArg.parameters) {\n\t\t\tif (!param.name || !param.type) continue;\n\n\t\t\t// Get parameter name\n\t\t\tlet paramName = '';\n\t\t\tif (ts.isIdentifier(param.name)) {\n\t\t\t\tparamName = param.name.text;\n\t\t\t} else {\n\t\t\t\t// Skip destructured parameters for now\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Check if it's an inline object type literal\n\t\t\tif (ts.isTypeLiteralNode(param.type)) {\n\t\t\t\tfor (const member of param.type.members) {\n\t\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\t\ttypeMap.set(`${paramName}.${propName}`, type);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Store simple parameter types like `decorateValue: string`\n\t\t\t\tconst type = this.inferType(param.type);\n\t\t\t\tif (type !== 'unknown') {\n\t\t\t\t\ttypeMap.set(paramName, type);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn typeMap;\n\t}\n\n\t/**\n\t * Extract property access chain (e.g., \"dataRenamed.id\" from dataRenamed.id)\n\t * Handles fallbacks like: data.permissions || []\n\t */\n\tprivate getPropertyAccessChain (expr: ts.Expression): string | undefined {\n\t\t// Handle identifier: data\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text;\n\t\t}\n\t\t// Handle property access: data.permissions\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\tconst base = this.getPropertyAccessChain(expr.expression);\n\t\t\tif (base) {\n\t\t\t\treturn `${base}.${expr.name.text}`;\n\t\t\t}\n\t\t}\n\t\t// Handle fallback pattern: data.permissions || []\n\t\tif (ts.isBinaryExpression(expr) &&\n\t\t\texpr.operatorToken.kind === ts.SyntaxKind.BarBarToken) {\n\t\t\t// Return the left side of || operator\n\t\t\treturn this.getPropertyAccessChain(expr.left);\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Extract property assignment from statement\n\t */\n\tprivate extractPropertyFromStatement (\n\t\texpr: ts.Expression,\n\t\tproperties: Map<string, PropertyInfo>,\n\t\tdataTypeMap: Map<string, string> = new Map()\n\t): void {\n\t\t// Handle: this.property = value\n\t\tif (ts.isBinaryExpression(expr) &&\n\t\t\texpr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n\t\t\tconst { left } = expr;\n\n\t\t\tif (ts.isPropertyAccessExpression(left)) {\n\t\t\t\t// Check if accessing 'this' (ThisKeyword)\n\t\t\t\tif (left.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\tconst name = left.name?.text;\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\t// Try to get type from dataTypeMap using full access chain (e.g., \"dataRenamed.id\")\n\t\t\t\t\t\tconst accessChain = this.getPropertyAccessChain(expr.right);\n\t\t\t\t\t\tlet type = accessChain ? dataTypeMap.get(accessChain) : undefined;\n\t\t\t\t\t\t// If not found and RHS is a simple identifier, try looking it up directly\n\t\t\t\t\t\tif (!type && ts.isIdentifier(expr.right)) {\n\t\t\t\t\t\t\ttype = dataTypeMap.get(expr.right.text);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (!type) {\n\t\t\t\t\t\t\ttype = this.inferTypeFromInitializer(expr.right, dataTypeMap);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Don't overwrite a known type from a `this` annotation\n\t\t\t\t\t\t// with an unknown-bearing inference: an empty-array\n\t\t\t\t\t\t// initializer infers 'Array<unknown>', which must not\n\t\t\t\t\t\t// clobber an annotated 'Array<{ id: number }>' either\n\t\t\t\t\t\tconst existing = properties.get(name);\n\t\t\t\t\t\tconst typeHasUnknown = !type || type.includes('unknown');\n\t\t\t\t\t\tconst existingIsKnown = existing ? !existing.type.includes('unknown') : false;\n\t\t\t\t\t\tif (existingIsKnown && typeHasUnknown) {\n\t\t\t\t\t\t\t// Keep the better type from explicit annotation\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Handle: Object.assign(this, { prop: value })\n\t\tif (ts.isCallExpression(expr)) {\n\t\t\tconst fn = expr.expression;\n\t\t\tif (ts.isPropertyAccessExpression(fn) &&\n\t\t\t\tfn.name?.text === 'assign' &&\n\t\t\t\tts.isIdentifier(fn.expression) &&\n\t\t\t\tfn.expression.text === 'Object') {\n\t\t\t\tconst args = expr.arguments;\n\t\t\t\tif (args.length >= 2 && args[ 0 ].kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\t// Extract properties from the second argument\n\t\t\t\t\tconst [ , propsArg ] = args;\n\t\t\t\t\tif (ts.isObjectLiteralExpression(propsArg)) {\n\t\t\t\t\t\tfor (const prop of propsArg.properties) {\n\t\t\t\t\t\t\tif (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {\n\t\t\t\t\t\t\t\tconst name = prop.name.text;\n\t\t\t\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t\t\t\ttype     : this.inferTypeFromInitializer(prop.initializer),\n\t\t\t\t\t\t\t\t\toptional : false,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Extract properties from class declaration (including methods and getters)\n\t */\n\tprivate extractClassProperties (classDecl: ts.ClassDeclaration): Map<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\tfor (const member of classDecl.members) {\n\t\t\t// Handle property declarations\n\t\t\tif (ts.isPropertyDeclaration(member) && member.name) {\n\t\t\t\t// Skip private and protected properties\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = ts.isIdentifier(member.name) ? member.name.text : '';\n\t\t\t\tif (name) {\n\t\t\t\t\t// If no explicit type but has initializer, infer from initializer\n\t\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\t\tif (type === 'unknown' && member.initializer) {\n\t\t\t\t\t\ttype = this.inferTypeFromInitializer(member.initializer);\n\t\t\t\t\t}\n\t\t\t\t\tproperties.set(name, {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Handle method declarations\n\t\t\tif (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Skip private and protected methods\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = member.name.text;\n\t\t\t\tconst type = this.inferMethodType(member);\n\t\t\t\tproperties.set(name, {\n\t\t\t\t\tname,\n\t\t\t\t\ttype,\n\t\t\t\t\toptional : false,\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// Handle getter declarations\n\t\t\tif (ts.isGetAccessor(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Skip private and protected getters\n\t\t\t\tif (member.modifiers) {\n\t\t\t\t\tconst hasPrivateOrProtected = member.modifiers.some(m => m.kind === ts.SyntaxKind.PrivateKeyword ||\n\t\t\t\t\t\t     m.kind === ts.SyntaxKind.ProtectedKeyword);\n\t\t\t\t\tif (hasPrivateOrProtected) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tconst name = member.name.text;\n\t\t\t\t// First try explicit type annotation, then infer from getter body\n\t\t\t\tlet type = this.inferType(member.type);\n\t\t\t\tif (type === 'unknown' && member.body) {\n\t\t\t\t\ttype = this.inferReturnTypeFromBody(member.body);\n\t\t\t\t}\n\t\t\t\tproperties.set(name, {\n\t\t\t\t\tname,\n\t\t\t\t\ttype,\n\t\t\t\t\toptional : false,\n\t\t\t\t\treadonly : true,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t * Extract class property types for method return type inference\n\t * Maps property names to their TypeScript type strings\n\t * Note: Includes private/protected properties for method inference\n\t */\n\tprivate extractClassPropertyTypes (classDecl: ts.ClassExpression): Map<string, string> {\n\t\tconst propertyTypes = new Map<string, string>();\n\n\t\tfor (const member of classDecl.members) {\n\t\t\tif (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n\t\t\t\t// Include ALL properties (even private) for method return type inference\n\t\t\t\t// The visibility check is done when adding to output properties\n\t\t\t\tconst name = member.name.text;\n\t\t\t\tif (member.type) {\n\t\t\t\t\tpropertyTypes.set(name, this.inferType(member.type));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn propertyTypes;\n\t}\n\n\t/**\n\t * Infer method type from method declaration\n\t */\n\tprivate inferMethodType (method: ts.MethodDeclaration, classPropertyTypes?: Map<string, string>): string {\n\t\tconst params = method.parameters.map(param => {\n\t\t\tconst paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';\n\t\t\tconst paramType = this.inferType(param.type);\n\t\t\treturn `${paramName}: ${paramType}`;\n\t\t}).join(', ');\n\n\t\tconst returnType = this.inferReturnType(method, classPropertyTypes);\n\n\t\tif (params) {\n\t\t\treturn `(${params}) => ${returnType}`;\n\t\t}\n\t\treturn `() => ${returnType}`;\n\t}\n\n\t/**\n\t\t* Extract properties from `this` parameter type annotation\n\t\t* Handles patterns like: function(this: SomeType, data: SomeType) { }\n\t\t*/\n\tprivate extractThisParamProperties (handlerArg: ts.FunctionExpression | ts.ArrowFunction):\n\t\tMap<string, PropertyInfo> {\n\t\tconst properties = new Map<string, PropertyInfo>();\n\n\t\t// Find the `this` parameter (if any)\n\t\tfor (const param of handlerArg.parameters) {\n\t\t\tif (param.name && ts.isIdentifier(param.name) && param.name.text === 'this' && param.type) {\n\t\t\t\t// Check if it's a type reference (e.g., `this: usage`)\n\t\t\t\tif (ts.isTypeReferenceNode(param.type)) {\n\t\t\t\t\tconst typeName = ts.isIdentifier(param.type.typeName)\n\t\t\t\t\t\t? param.type.typeName.text\n\t\t\t\t\t\t: '';\n\n\t\t\t\t\t// Resolve through the referencing file's own imports first (F10)\n\t\t\t\t\tconst decl = typeName\n\t\t\t\t\t\t? this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile)\n\t\t\t\t\t\t: undefined;\n\t\t\t\t\tif (decl) {\n\t\t\t\t\t\tconst declProperties = this.referencedDeclarationProperties(decl);\n\t\t\t\t\t\tfor (const [ propName, info ] of declProperties) {\n\t\t\t\t\t\t\tproperties.set(propName, info);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Check if it's directly an inline type literal (e.g., `this: { id: string }`)\n\t\t\t\telse if (ts.isTypeLiteralNode(param.type)) {\n\t\t\t\t\tfor (const member of param.type.members) {\n\t\t\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\t\t\tproperties.set(propName, {\n\t\t\t\t\t\t\t\tname     : propName,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\toptional : !!member.questionToken,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Found the `this` parameter, no need to continue\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn properties;\n\t}\n\n\t/**\n\t\t* Infer TypeScript type from type node\n\t\t*/\n\t/**\n\t * Infer TypeScript type from type node\n\t */\n\tprivate inferType (typeNode?: ts.TypeNode): string {\n\t\tif (!typeNode) {\n\t\t\treturn 'unknown';\n\t\t}\n\n\t\tswitch (typeNode.kind) {\n\t\tcase ts.SyntaxKind.StringKeyword:\n\t\t\treturn 'string';\n\t\tcase ts.SyntaxKind.NumberKeyword:\n\t\t\treturn 'number';\n\t\tcase ts.SyntaxKind.BooleanKeyword:\n\t\t\treturn 'boolean';\n\t\tcase ts.SyntaxKind.UndefinedKeyword:\n\t\t\treturn 'undefined';\n\t\tcase ts.SyntaxKind.NullKeyword:\n\t\t\treturn 'null';\n\t\tcase ts.SyntaxKind.AnyKeyword:\n\t\t\treturn 'any';\n\t\tcase ts.SyntaxKind.UnknownKeyword:\n\t\t\treturn 'unknown';\n\t\tcase ts.SyntaxKind.VoidKeyword:\n\t\t\treturn 'void';\n\t\tcase ts.SyntaxKind.ArrayType:\n\t\t\treturn `Array<${  this.inferType((typeNode as ts.ArrayTypeNode).elementType)  }>`;\n\t\tcase ts.SyntaxKind.TypeLiteral: {\n\t\t\t// Inline-expand type literals instead of collapsing to 'object'\n\t\t\tconst typeLit = typeNode as ts.TypeLiteralNode;\n\t\t\tconst props: string[] = [];\n\t\t\tfor (const member of typeLit.members) {\n\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\tconst optional = member.questionToken ? '?' : '';\n\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\tprops.push(`${propName}${optional}: ${type}`);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `{ ${props.join('; ')} }`;\n\t\t}\n\t\tcase ts.SyntaxKind.LiteralType: {\n\t\t\t// Handle string literal types like 'user', 'admin', etc.\n\t\t\tconst { literal } = (typeNode as ts.LiteralTypeNode);\n\t\t\tif (ts.isStringLiteral(literal)) {\n\t\t\t\t// Return the actual literal value (e.g., 'user' instead of string)\n\t\t\t\treturn `'${literal.text}'`;\n\t\t\t}\n\t\t\tif (ts.isNumericLiteral(literal)) {\n\t\t\t\treturn literal.text;\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.TrueKeyword) {\n\t\t\t\treturn 'true';\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.FalseKeyword) {\n\t\t\t\treturn 'false';\n\t\t\t}\n\t\t\tif (literal.kind === ts.SyntaxKind.NullKeyword) {\n\t\t\t\treturn 'null';\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.TypeReference: {\n\t\t\t// Handle type references like Map<string, number>, PropertyInfo, etc.\n\t\t\tconst typeRef = typeNode as ts.TypeReferenceNode;\n\n\t\t\t// Qualified names (Namespace.Type): resolve through namespace imports\n\t\t\tif (ts.isQualifiedName(typeRef.typeName)) {\n\t\t\t\tconst resolvedQualified = this.inferQualifiedTypeReference(typeRef);\n\t\t\t\tif (resolvedQualified !== undefined) {\n\t\t\t\t\treturn resolvedQualified;\n\t\t\t\t}\n\t\t\t\t// unresolved qualified references must not leak a bare name\n\t\t\t\treturn 'unknown';\n\t\t\t}\n\n\t\t\tconst typeName = ts.isIdentifier(typeRef.typeName) ? typeRef.typeName.text : 'unknown';\n\n\t\t\t// Import-aware referenced-type resolution (F10): a declaration\n\t\t\t// reached through the current file's own imports (or its locals,\n\t\t\t// or a unique program-wide declaration) expands inline\n\t\t\tconst simpleRef = this.resolveSimpleTypeReference(typeName, typeRef.typeArguments, typeRef);\n\t\t\tif (simpleRef !== undefined) {\n\t\t\t\treturn simpleRef;\n\t\t\t}\n\n\t\t\t// Build generic type arguments\n\t\t\tconst typeArgs = (typeRef.typeArguments ?? []).map(arg => this.inferType(arg));\n\t\t\treturn `${typeName}<${typeArgs.join(', ')}>`;\n\t\t}\n\t\tcase ts.SyntaxKind.UnionType: {\n\t\t\t// Handle union types like 'a' | 'b' | 'c'\n\t\t\tconst unionType = typeNode as ts.UnionTypeNode;\n\t\t\tconst types = unionType.types.map(t => this.inferType(t));\n\t\t\treturn types.join(' | ');\n\t\t}\n\t\tcase ts.SyntaxKind.IntersectionType: {\n\t\t\t// Handle intersection types like TypeA & TypeB\n\t\t\tconst intersectionType = typeNode as ts.IntersectionTypeNode;\n\t\t\tconst types = intersectionType.types.map(t => this.inferType(t));\n\t\t\treturn types.join(' & ');\n\t\t}\n\t\tcase ts.SyntaxKind.TupleType: {\n\t\t\t// Handle tuple types like [string, number]\n\t\t\tconst tupleType = typeNode as ts.TupleTypeNode;\n\t\t\tconst elements = tupleType.elements.map(elem => this.inferType(elem as ts.TypeNode));\n\t\t\treturn `[${elements.join(', ')}]`;\n\t\t}\n\t\tcase ts.SyntaxKind.OptionalType: {\n\t\t\t// Handle optional element in tuple: string?\n\t\t\tconst optionalType = typeNode as ts.OptionalTypeNode;\n\t\t\treturn `${this.inferType(optionalType.type)  }?`;\n\t\t}\n\t\tcase ts.SyntaxKind.RestType: {\n\t\t\t// Handle rest element: ...T\n\t\t\tconst restType = typeNode as ts.RestTypeNode;\n\t\t\treturn `...${  this.inferType(restType.type)}`;\n\t\t}\n\t\tcase ts.SyntaxKind.ParenthesizedType: {\n\t\t\t// Handle parenthesized types: (A | B)\n\t\t\treturn this.inferType((typeNode as ts.ParenthesizedTypeNode).type);\n\t\t}\n\t\tcase ts.SyntaxKind.IndexedAccessType: {\n\t\t\t// Handle indexed access: T[K]\n\t\t\tconst indexed = typeNode as ts.IndexedAccessTypeNode;\n\t\t\t// `typeof constArray[K]` — element type of a tracked const array:\n\t\t\t// emit the element literal union directly (assembling\n\t\t\t// `union[K]` text would misread precedence, and when the const\n\t\t\t// is not statically visible the honest answer is `unknown`,\n\t\t\t// never a bare `typeof name` query)\n\t\t\tif (ts.isTypeQueryNode(indexed.objectType) && ts.isIdentifier(indexed.objectType.exprName)) {\n\t\t\t\tconst queryName = indexed.objectType.exprName.text;\n\t\t\t\tconst arrayLiteral = this.findReferencedConstArray(queryName, this.currentReferencedTypeFile);\n\t\t\t\tconst literals = arrayLiteral ? this.literalTypesOfArray(arrayLiteral) : undefined;\n\t\t\t\tif (!literals) {\n\t\t\t\t\treturn 'unknown';\n\t\t\t\t}\n\t\t\t\tif (ts.isLiteralTypeNode(indexed.indexType) && ts.isNumericLiteral(indexed.indexType.literal)) {\n\t\t\t\t\tconst elementIndex = parseInt(indexed.indexType.literal.text, 10);\n\t\t\t\t\tconst element = literals[ elementIndex ];\n\t\t\t\t\tconst elementResult = element === undefined ? 'unknown' : element;\n\t\t\t\t\treturn elementResult;\n\t\t\t\t}\n\t\t\t\tconst unionResult = literals.join(' | ');\n\t\t\t\treturn unionResult;\n\t\t\t}\n\t\t\tlet objectType = this.inferType(indexed.objectType);\n\t\t\tconst indexType = this.inferType(indexed.indexType);\n\t\t\t// If objectType is 'object', try to resolve the underlying referenced type\n\t\t\tif (objectType === 'object' && ts.isTypeReferenceNode(indexed.objectType)) {\n\t\t\t\tconst refName = ts.isIdentifier(indexed.objectType.typeName) ? indexed.objectType.typeName.text : '';\n\t\t\t\tif (refName) {\n\t\t\t\t\tconst decl = this.resolveReferencedTypeDeclaration(refName, this.currentReferencedTypeFile);\n\t\t\t\t\tif (decl) {\n\t\t\t\t\t\tconst expanded = this.expandReferencedTypeDeclaration(decl);\n\t\t\t\t\t\tif (expanded) {\n\t\t\t\t\t\t\tobjectType = expanded;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `${objectType}[${indexType}]`;\n\t\t}\n\t\tcase ts.SyntaxKind.TypeOperator: {\n\t\t\t// Handle keyof, readonly, unique operators\n\t\t\tconst typeOp = typeNode as ts.TypeOperatorNode;\n\t\t\tconst operator = ts.SyntaxKind[ typeOp.operator ];\n\t\t\treturn `${operator} ${this.inferType(typeOp.type)}`;\n\t\t}\n\t\tcase ts.SyntaxKind.TypeQuery: {\n\t\t\t// `typeof x` as a FIELD TYPE: the generated file has no imports,\n\t\t\t// so a bare `typeof x` would be an unresolvable name downstream.\n\t\t\t// When x is a tracked const array, emit its element literal\n\t\t\t// union; otherwise degrade to `unknown`. (InstanceType<typeof X>\n\t\t\t// graph types are handled in resolveSimpleTypeReference before\n\t\t\t// inferType runs.)\n\t\t\tconst typeQuery = typeNode as ts.TypeQueryNode;\n\t\t\tif (ts.isIdentifier(typeQuery.exprName)) {\n\t\t\t\tconst union = this.typeOfConstArrayUnion(typeQuery.exprName.text, this.currentReferencedTypeFile);\n\t\t\t\tif (union) {\n\t\t\t\t\treturn union;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tdefault:\n\t\t\t// For complex types, return the text representation\n\t\t\treturn 'unknown';\n\t\t}\n\t}\n\n\t/**\n\t\t* Infer return type from a method declaration\n\t\t* Uses explicit return type annotation or infers from return statements\n\t\t*/\n\tprivate inferReturnType (method: ts.MethodDeclaration, classPropertyTypes?: Map<string, string>): string {\n\t\t// If method has explicit return type annotation, use it\n\t\tif (method.type) {\n\t\t\treturn this.inferType(method.type);\n\t\t}\n\n\t\t// Otherwise, try to infer from return statements in the method body\n\t\tif (method.body) {\n\t\t\treturn this.inferReturnTypeFromBody(method.body, classPropertyTypes);\n\t\t}\n\n\t\treturn 'unknown';\n\t}\n\n\t/**\n\t\t* Infer return type by analyzing return statements in the method body\n\t\t*/\n\tprivate inferReturnTypeFromBody (body: ts.Block, classPropertyTypes?: Map<string, string>): string {\n\t\tconst returnTypes = new Set<string>();\n\n\t\tconst visit = (node: ts.Node): void => {\n\t\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\t\tconst type = this.inferTypeFromInitializer(node.expression, undefined, classPropertyTypes);\n\t\t\t\tif (type !== 'unknown') {\n\t\t\t\t\treturnTypes.add(type);\n\t\t\t\t}\n\t\t\t}\n\t\t\tts.forEachChild(node, visit);\n\t\t};\n\n\t\tvisit(body);\n\n\t\tif (returnTypes.size === 0) {\n\t\t\treturn 'void';\n\t\t}\n\t\tif (returnTypes.size === 1) {\n\t\t\treturn Array.from(returnTypes)[ 0 ];\n\t\t}\n\t\treturn Array.from(returnTypes).join(' | ');\n\t}\n\n\t/**\n\t * Infer type from initializer\n\t */\n\tprivate inferTypeFromInitializer (\n\t\tinitializer: ts.Expression,\n\t\tdataTypeMap?: Map<string, string>,\n\t\tclassPropertyTypes?: Map<string, string>\n\t): string {\n\t\tswitch (initializer.kind) {\n\t\tcase ts.SyntaxKind.StringLiteral:\n\t\t\treturn 'string';\n\t\tcase ts.SyntaxKind.NumericLiteral:\n\t\t\treturn 'number';\n\t\tcase ts.SyntaxKind.TrueKeyword:\n\t\tcase ts.SyntaxKind.FalseKeyword:\n\t\t\treturn 'boolean';\n\t\tcase ts.SyntaxKind.NullKeyword:\n\t\t\treturn 'null';\n\t\tcase ts.SyntaxKind.UndefinedKeyword:\n\t\t\treturn 'undefined';\n\t\tcase ts.SyntaxKind.ArrayLiteralExpression:\n\t\t\treturn 'Array<unknown>';\n\t\tcase ts.SyntaxKind.ObjectLiteralExpression:\n\t\t\treturn 'object';\n\t\tcase ts.SyntaxKind.NewExpression: {\n\t\t\t// Handle new Date(), new Map(), etc.\n\t\t\tconst newExpr = initializer as ts.NewExpression;\n\t\t\tif (ts.isIdentifier(newExpr.expression)) {\n\t\t\t\treturn newExpr.expression.text;\n\t\t\t}\n\t\t\treturn 'object';\n\t\t}\n\t\tcase ts.SyntaxKind.BinaryExpression: {\n\t\t\t// Handle arithmetic operations: a * b, a + b, a - b, a / b\n\t\t\tconst binaryExpr = initializer as ts.BinaryExpression;\n\t\t\tconst leftType = this.inferTypeFromInitializer(binaryExpr.left, dataTypeMap, classPropertyTypes);\n\t\t\tconst rightType = this.inferTypeFromInitializer(binaryExpr.right, dataTypeMap, classPropertyTypes);\n\t\t\t\t\n\t\t\t// Check if it's an arithmetic operator\n\t\t\tconst operator = binaryExpr.operatorToken.kind;\n\t\t\tif (operator === ts.SyntaxKind.AsteriskToken ||\n\t\t\t\t    operator === ts.SyntaxKind.SlashToken ||\n\t\t\t\t    operator === ts.SyntaxKind.MinusToken ||\n\t\t\t\t    operator === ts.SyntaxKind.PercentToken) {\n\t\t\t\t// Arithmetic operations on numbers produce numbers\n\t\t\t\tif ((leftType === 'number' || leftType === 'unknown') &&\n\t\t\t\t\t    (rightType === 'number' || rightType === 'unknown')) {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (operator === ts.SyntaxKind.PlusToken) {\n\t\t\t\t// Plus can be addition or string concatenation\n\t\t\t\tif (leftType === 'string' || rightType === 'string') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\tif (leftType === 'number' && rightType === 'number') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.PropertyAccessExpression: {\n\t\t\t// Handle property access like data.value, data.id\n\t\t\tif (dataTypeMap) {\n\t\t\t\tconst accessChain = this.getPropertyAccessChain(initializer);\n\t\t\t\tif (accessChain) {\n\t\t\t\t\tconst type = dataTypeMap.get(accessChain);\n\t\t\t\t\tif (type) {\n\t\t\t\t\t\treturn type;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Handle this.map.size pattern (Map.size returns number)\n\t\t\tconst propAccess = initializer as ts.PropertyAccessExpression;\n\t\t\tif (ts.isPropertyAccessExpression(propAccess.expression)) {\n\t\t\t\tconst outerProp = propAccess.expression;\n\t\t\t\t// Check for this.map pattern\n\t\t\t\tlet innerName = '';\n\t\t\t\tif (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\tinnerName = 'this';\n\t\t\t\t} else if (ts.isIdentifier(outerProp.expression)) {\n\t\t\t\t\tinnerName = outerProp.expression.text;\n\t\t\t\t}\n\t\t\t\tconst mapProp = outerProp.name.text;\n\t\t\t\tconst finalProp = propAccess.name.text;\n\t\t\t\t// this.map.size -> number\n\t\t\t\tif (innerName === 'this' && mapProp === 'map' && finalProp === 'size') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.Identifier: {\n\t\t\t// Handle identifier references if in dataTypeMap\n\t\t\tif (dataTypeMap) {\n\t\t\t\tconst name = (initializer as ts.Identifier).text;\n\t\t\t\tconst type = dataTypeMap.get(name);\n\t\t\t\tif (type) {\n\t\t\t\t\treturn type;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.CallExpression: {\n\t\t\t// Handle function calls like Date.now(), parseInt(), etc.\n\t\t\tconst callExpr = initializer as ts.CallExpression;\n\t\t\tif (ts.isPropertyAccessExpression(callExpr.expression)) {\n\t\t\t\tconst methodName = callExpr.expression.name.text;\n\t\t\t\tconst objName = ts.isIdentifier(callExpr.expression.expression)\n\t\t\t\t\t? callExpr.expression.expression.text\n\t\t\t\t\t: '';\n\t\t\t\t\t\n\t\t\t\t// Date.now() -> number\n\t\t\t\tif (objName === 'Date' && methodName === 'now') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\t// String methods that return string\n\t\t\t\tif (methodName === 'toString' || methodName === 'valueOf') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\t// Handle Map property access on class instances (this.map.*)\n\t\t\t\tif (ts.isPropertyAccessExpression(callExpr.expression.expression)) {\n\t\t\t\t\tconst outerProp = callExpr.expression.expression;\n\t\t\t\t\t// Handle both 'this' keyword and identifier patterns\n\t\t\t\t\tlet innerName = '';\n\t\t\t\t\tif (outerProp.expression.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\t\t\t\tinnerName = 'this';\n\t\t\t\t\t} else if (ts.isIdentifier(outerProp.expression)) {\n\t\t\t\t\t\tinnerName = outerProp.expression.text;\n\t\t\t\t\t}\n\t\t\t\t\tconst mapProp = outerProp.name.text;\n\t\t\t\t\t// this.map.X() patterns\n\t\t\t\t\tif (innerName === 'this' && mapProp === 'map') {\n\t\t\t\t\t\t// Try to get the Map's value type from class properties\n\t\t\t\t\t\tlet mapValueType = 'unknown';\n\t\t\t\t\t\tif (classPropertyTypes) {\n\t\t\t\t\t\t\tconst mapType = classPropertyTypes.get('map');\n\t\t\t\t\t\t\tif (mapType && mapType.startsWith('Map<')) {\n\t\t\t\t\t\t\t\t// Parse Map<K, V> to get V\n\t\t\t\t\t\t\t\tconst match = mapType.match(/Map<[^,]+,\\s*(.+)>$/);\n\t\t\t\t\t\t\t\tif (match) {\n\t\t\t\t\t\t\t\t\t[ , mapValueType ] = match;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (methodName === 'has') return 'boolean';\n\t\t\t\t\t\tif (methodName === 'set') return 'this';\n\t\t\t\t\t\tif (methodName === 'get') return mapValueType;\n\t\t\t\t\t\tif (methodName === 'delete') return 'boolean';\n\t\t\t\t\t\tif (methodName === 'clear') return 'void';\n\t\t\t\t\t\tif (methodName === 'values') return `IterableIterator<${mapValueType}>`;\n\t\t\t\t\t\tif (methodName === 'keys') return 'IterableIterator<string>';\n\t\t\t\t\t\tif (methodName === 'entries') return `IterableIterator<[string, ${mapValueType}]>`;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Direct map.X() calls\n\t\t\t\tif (objName === 'map' || objName === 'obj') {\n\t\t\t\t\tif (methodName === 'has') return 'boolean';\n\t\t\t\t\tif (methodName === 'set') return 'this';\n\t\t\t\t\tif (methodName === 'get') return 'unknown';\n\t\t\t\t\tif (methodName === 'delete') return 'boolean';\n\t\t\t\t\tif (methodName === 'clear') return 'void';\n\t\t\t\t\tif (methodName === 'values') return 'IterableIterator<unknown>';\n\t\t\t\t\tif (methodName === 'keys') return 'IterableIterator<string>';\n\t\t\t\t\tif (methodName === 'entries') return 'IterableIterator<[string, unknown]>';\n\t\t\t\t}\n\t\t\t}\n\t\t\t// parseInt, parseFloat -> number\n\t\t\tif (ts.isIdentifier(callExpr.expression)) {\n\t\t\t\tconst fnName = callExpr.expression.text;\n\t\t\t\tif (fnName === 'parseInt' || fnName === 'parseFloat') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'String') {\n\t\t\t\t\treturn 'string';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'Number') {\n\t\t\t\t\treturn 'number';\n\t\t\t\t}\n\t\t\t\tif (fnName === 'Boolean') {\n\t\t\t\t\treturn 'boolean';\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'unknown';\n\t\t}\n\t\tcase ts.SyntaxKind.TemplateExpression:\n\t\tcase ts.SyntaxKind.NoSubstitutionTemplateLiteral: {\n\t\t\t// Template literals like `${baseValue}-${extra}` always produce strings\n\t\t\treturn 'string';\n\t\t}\n\t\tdefault:\n\t\t\treturn 'unknown';\n\t\t}\n\t}\n\t\n\t/**\n\t\t\t* Collect usage information for type references\n\t\t\t*/\n\tprivate collectUsage (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\t// Check for new Type() instantiation\n\t\tif (ts.isNewExpression(node) && node.expression) {\n\t\t\tlet typeName: string | undefined;\n\t\t\tif (ts.isPropertyAccessExpression(node.expression)) {\n\t\t\t\ttypeName = this.resolveTypePath(node.expression);\n\t\t\t} else {\n\t\t\t\ttypeName = this.getTypeNameFromExpression(node.expression);\n\t\t\t}\n\t\t\tif (typeName) {\n\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\tthis.addUsage(typeName, {\n\t\t\t\t\tlocation        : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\tkind            : 'instantiation',\n\t\t\t\t\tcode            : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t// Constructor expression text ('Thing', 'user.AdminEntity',\n\t\t\t\t\t// a lookup alias) — CreationAnchor.constructorText (Phase 3)\n\t\t\t\t\tconstructorText : node.expression.getText(sourceFile).slice(0, 100),\n\t\t\t\t});\n\t\t\t\t// Track variable assignment from new Type() for flow analysis\n\t\t\t\tthis.trackNewAssignment(node, typeName);\n\t\t\t\t// Also record as flow event\n\t\t\t\tthis.addFlow(typeName, {\n\t\t\t\t\tlocation : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\tkind     : 'instantiation',\n\t\t\t\t\tcode     : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\tcontext  : 'new expression',\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\n\t\t// Check for property access on instances (user.AdminType)\n\t\tif (ts.isPropertyAccessExpression(node)) {\n\t\t\tconst propName = node.name.text;\n\t\t\t// Check if this looks like a type access pattern\n\t\t\tif (propName && this.isLikelyTypeName(propName)) {\n\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\t\t// Try to resolve full path\n\t\t\t\tconst fullPath = this.resolveTypePath(node);\n\t\t\t\tif (fullPath) {\n\t\t\t\t\tthis.addUsage(fullPath, {\n\t\t\t\t\t\tlocation : `${sourceFile.fileName}:${line + 1}:${character + 1}`,\n\t\t\t\t\t\tkind     : 'propertyAccess',\n\t\t\t\t\t\tcode     : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\t// Check for lookup('TypeName') or lookup(source, 'TypeName') calls\n\t\tif (ts.isCallExpression(node) && node.expression) {\n\t\t\tconst funcName = this.getFunctionName(node.expression);\n\t\t\tif (funcName === 'lookup' && node.arguments.length > 0) {\n\t\t\t\tconst typePath = this.resolveLookupPath(node);\n\t\t\t\tif (typePath) {\n\t\t\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\t\tsourceFile,\n\t\t\t\t\t\tnode.getStart(sourceFile)\n\t\t\t\t\t);\n\t\t\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\t\t\tthis.addUsage(typePath, {\n\t\t\t\t\t\tlocation,\n\t\t\t\t\t\tkind : 'lookup',\n\t\t\t\t\t\tcode : node.getText(sourceFile).slice(0, 100),\n\t\t\t\t\t});\n\t\t\t\t\t// Track variable assignment from lookup for instantiation tracking\n\t\t\t\t\tthis.trackLookupAssignment(node, typePath);\n\t\t\t\t\t// Record for the hard-fail law even when addUsage dropped\n\t\t\t\t\t// the path (unknown paths are exactly the failure class)\n\t\t\t\t\tthis.lookupReferences.push({ path : typePath, location });\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t\t\t* Get function name from expression (identifier or property access)\n\t\t\t*/\n\tprivate getFunctionName (expr: ts.Expression): string | undefined {\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn expr.text;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\treturn expr.name.text;\n\t\t}\n\t\treturn undefined;\n\t}\n\t\n\t/**\n\t\t\t* Add a usage to the collection\n\t\t\t*/\n\tprivate addUsage (typePath: string, usage: UsageInfo): void {\n\t\t// Only track usages of mnemonica-defined types\n\t\tif (!this.definitions.has(typePath)) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.usages.has(typePath)) {\n\t\t\tthis.usages.set(typePath, []);\n\t\t}\n\n\t\t// Check for duplicates based on location, code, and kind\n\t\tconst existingUsages = this.usages.get(typePath)!;\n\t\tconst isDuplicate = existingUsages.some(existing =>\n\t\t\texisting.location === usage.location &&\n\t\t\t\texisting.code === usage.code &&\n\t\t\t\texisting.kind === usage.kind);\n\n\t\tif (!isDuplicate) {\n\t\t\texistingUsages.push(usage);\n\t\t}\n\t}\n\n\t/**\n\t * Collect EDS (Execution Data Storage) usage information\n\t */\n\tprivate collectEDS (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isCallExpression(node) || !node.expression) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst funcName = this.getFunctionName(node.expression);\n\t\tif (!funcName) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\t\t// Enclosing mnemonica type path — wrap args are usually local\n\t\t// functions, so the owning define()/lazy() handler or decorated\n\t\t// class is what eds.json consumers (GraphBuilder) can join on.\n\t\tconst scope = this.resolveEDSScope(node);\n\n\t\t// wrap(fn), wrapConstructorArg(fn, parent), upgradeConstructorArg(arg, inst), wrapInstanceMethods(obj)\n\t\tif (\n\t\t\tfuncName === 'wrap' ||\n\t\t\tfuncName === 'wrapConstructorArg' ||\n\t\t\tfuncName === 'upgradeConstructorArg' ||\n\t\t\tfuncName === 'wrapInstanceMethods'\n\t\t) {\n\t\t\tconst targetType = this.resolveEDSArgumentType(node.arguments[ 0 ]);\n\t\t\t// dive's wrap-family signatures (dive/src/index.ts):\n\t\t\t//   wrap(fn, label?) | wrap(fn, context?, label?)\n\t\t\t//   wrapConstructorArg(fn, context)\n\t\t\t//   upgradeConstructorArg(arg, instance)\n\t\t\t//   wrapInstanceMethods(instance)\n\t\t\t// …so the instance/context arg sits at args[1] (args[0] for\n\t\t\t// wrapInstanceMethods) and a string literal in args[1..2] is the label\n\t\t\tconst instanceArgNode = funcName === 'wrapInstanceMethods'\n\t\t\t\t? node.arguments[ 0 ]\n\t\t\t\t: node.arguments[ 1 ];\n\t\t\t// Fire-and-forget wrappers (wire-up helpers, registration\n\t\t\t// functions) sit outside any define()/lazy() handler, so the\n\t\t\t// lexical scope is absent — attribute through the instance/context\n\t\t\t// argument instead: a tracked assignment, else the enclosing\n\t\t\t// function's parameter annotation resolved through the graph law\n\t\t\tconst instanceTypePath = instanceArgNode\n\t\t\t\t? this.resolveWrapInstanceTypePath(instanceArgNode)\n\t\t\t\t: undefined;\n\t\t\tconst effectiveScope = scope ?? instanceTypePath;\n\t\t\tconst info: EDSInfo = {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'wrap',\n\t\t\t\tcode,\n\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\tscope      : effectiveScope,\n\t\t\t\tfn         : funcName,\n\t\t\t};\n\t\t\tif (instanceArgNode && ts.isIdentifier(instanceArgNode)) {\n\t\t\t\tinfo.instanceArg = instanceArgNode.text;\n\t\t\t}\n\t\t\tfor (const extraArg of [ node.arguments[ 1 ], node.arguments[ 2 ] ]) {\n\t\t\t\tif (extraArg && ts.isStringLiteral(extraArg)) {\n\t\t\t\t\tinfo.label = extraArg.text;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// A wrap() call nested inside another wrapped body carries the\n\t\t\t// link to the site whose runtime wrapping caused it — and, when\n\t\t\t// the nested site has no scope of its own, the causing site's\n\t\t\t// scope attribution travels with the link\n\t\t\tconst viaLink = this.nestedWrapVia.get(node);\n\t\t\tif (viaLink) {\n\t\t\t\tinfo.via = viaLink.via;\n\t\t\t\tif (info.scope === undefined) {\n\t\t\t\t\tinfo.scope = viaLink.scope;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// dive wraps returned functions too, and any mnemonica instance\n\t\t\t// created inside the wrapped body is a guaranteed path hit —\n\t\t\t// both are calculable AoT, so record them\n\t\t\tconst wrapped = this.resolveFunctionArgument(node.arguments[ 0 ], sourceFile);\n\t\t\tif (wrapped) {\n\t\t\t\t// The wrapped callback gets its own scope in scopes.json keyed by\n\t\t\t\t// its start position — record that scopeId so graph consumers can\n\t\t\t\t// join a wrap entry to the callback's creation node\n\t\t\t\tconst callbackPos = ts.getLineAndCharacterOfPosition(\n\t\t\t\t\tsourceFile,\n\t\t\t\t\twrapped.getStart(sourceFile)\n\t\t\t\t);\n\t\t\t\tconst callbackFile = nodePath.resolve(sourceFile.fileName);\n\t\t\t\tinfo.callbackScopeId = `${callbackFile}:${callbackPos.line + 1}:${callbackPos.character + 1}`;\n\t\t\t\tconst createsTypes = new Set<string>();\n\t\t\t\tthis.analyzeWrappedBody(wrapped, location, sourceFile, 0, new Set(), createsTypes, effectiveScope);\n\t\t\t\tif (createsTypes.size > 0) {\n\t\t\t\t\tinfo.createsTypes = Array.from(createsTypes);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst stored = this.addEDS(targetType || effectiveScope || 'unknown', info);\n\t\t\tthis.wrapEntryByNode.set(node, stored);\n\t\t\treturn;\n\t\t}\n\n\t\t// current(), getErrorInstance(err), getFlow(target?)\n\t\tif (funcName === 'current' || funcName === 'getErrorInstance' || funcName === 'getFlow') {\n\t\t\tthis.addEDS(scope || 'unknown', {\n\t\t\t\tlocation,\n\t\t\t\tkind : 'contextConsume',\n\t\t\t\tcode,\n\t\t\t\tscope,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// attachHooks(collection) — from @mnemonica/otel, wires a\n\t\t// TypesCollection to dive's lifecycle tracing\n\t\tif (funcName === 'attachHooks' && node.arguments.length > 0) {\n\t\t\tconst [ arg ] = node.arguments;\n\t\t\tif (ts.isArrayLiteralExpression(arg)) {\n\t\t\t\tfor (const element of arg.elements) {\n\t\t\t\t\tconst targetType = this.resolveEDSArgumentType(element);\n\t\t\t\t\tthis.addEDS(targetType || scope || 'unknown', {\n\t\t\t\t\t\tlocation,\n\t\t\t\t\t\tkind       : 'hookAttach',\n\t\t\t\t\t\tcode,\n\t\t\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\t\t\tscope,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst targetType = this.resolveEDSArgumentType(arg);\n\t\t\t\tthis.addEDS(targetType || scope || 'unknown', {\n\t\t\t\t\tlocation,\n\t\t\t\t\tkind       : 'hookAttach',\n\t\t\t\t\tcode,\n\t\t\t\t\ttargetType : targetType || undefined,\n\t\t\t\t\tscope,\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t}\n\n\t/**\n\t * Resolve type from EDS call argument (best effort)\n\t */\n\tprivate resolveEDSArgumentType (arg: ts.Expression | undefined): string | undefined {\n\t\tif (!arg) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Identifier: variable name\n\t\tif (ts.isIdentifier(arg)) {\n\t\t\tconst mapped = this.variableToTypeMap.get(arg.text);\n\t\t\tif (mapped) {\n\t\t\t\treturn mapped;\n\t\t\t}\n\t\t\t// Maybe it's a type name directly\n\t\t\tif (this.definitions.has(arg.text)) {\n\t\t\t\treturn arg.text;\n\t\t\t}\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Property access: obj.prop\n\t\tif (ts.isPropertyAccessExpression(arg)) {\n\t\t\treturn this.resolveTypePath(arg);\n\t\t}\n\n\t\t// This expression: this.something\n\t\tif (ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.expression) && arg.expression.text === 'this') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve the enclosing mnemonica scope of an EDS call site by walking\n\t * up the parent chain: nearest define()/lazy() call whose handler holds\n\t * the node, or nearest @decorate()-ed class declaration. Best effort —\n\t * returns undefined for calls outside any type scope (module top level).\n\t */\n\tprivate resolveEDSScope (node: ts.Node): string | undefined {\n\t\tlet current: ts.Node | undefined = node.parent;\n\t\twhile (current) {\n\t\t\tconst scopePath = this.edsScopeByNode.get(current);\n\t\t\tif (scopePath) {\n\t\t\t\treturn scopePath;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve a wrap site's instance/context argument to a mnemonica type\n\t * path — the fire-and-forget-wrapper attribution fallback when the call\n\t * sits outside any define()/lazy() handler: a tracked assignment\n\t * (`const holder = new Holder(...)`), else the root identifier's\n\t * (property-access roots included) parameter annotation resolved\n\t * through the graph law. Ambiguity or absence stays silent — this is a\n\t * metadata heuristic, not the identity-law surface.\n\t */\n\tprivate resolveWrapInstanceTypePath (arg: ts.Expression): string | undefined {\n\t\tconst fromBinding = (name: string, from: ts.Node): string | undefined => {\n\t\t\tconst mapped = this.variableToTypeMap.get(name);\n\t\t\tif (mapped) {\n\t\t\t\treturn mapped;\n\t\t\t}\n\t\t\tconst annotationType = this.resolveParameterAnnotationTypePath(name, from);\n\t\t\treturn annotationType;\n\t\t};\n\n\t\tif (ts.isIdentifier(arg)) {\n\t\t\tconst result = fromBinding(arg.text, arg);\n\t\t\treturn result;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(arg)) {\n\t\t\tconst root = this.getRootIdentifier(arg);\n\t\t\tif (root) {\n\t\t\t\tconst result = fromBinding(root.text, arg);\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve a bare-identifier type annotation of the nearest enclosing\n\t * function's parameter through the mnemonica-graph tiers (value scope,\n\t * imports, roots, program-wide-unique). Non-identifier and generic\n\t * annotations are not graph references; ambiguity and absence yield\n\t * undefined.\n\t */\n\tprivate resolveParameterAnnotationTypePath (name: string, from: ts.Node): string | undefined {\n\t\tlet current: ts.Node | undefined = from.parent;\n\t\twhile (current) {\n\t\t\tif (ts.isFunctionLike(current)) {\n\t\t\t\tfor (const param of current.parameters ?? []) {\n\t\t\t\t\tif (!ts.isIdentifier(param.name) || param.name.text !== name || !param.type ||\n\t\t\t\t\t\t!ts.isTypeReferenceNode(param.type) ||\n\t\t\t\t\t\t!ts.isIdentifier(param.type.typeName) ||\n\t\t\t\t\t\t(param.type.typeArguments?.length ?? 0) > 0) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst graphResult = this.resolveGraphTypeName(param.type.typeName.text);\n\t\t\t\t\tif (graphResult.status === 'unique') {\n\t\t\t\t\t\tconst result = graphResult.node.fullPath;\n\t\t\t\t\t\treturn result;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Resolve a wrap() argument to its function node without the type\n\t * checker: direct function expressions/arrows, or same-file bindings\n\t * (`const fn = () => ...`, `function fn() ...`). Best effort — method\n\t * references, .bind() products and cross-file identifiers stay\n\t * unresolved; the callsite entry itself is still recorded.\n\t */\n\tprivate resolveFunctionArgument (\n\t\targ: ts.Expression | undefined,\n\t\tsourceFile: ts.SourceFile\n\t): ts.FunctionLikeDeclaration | undefined {\n\t\tif (!arg) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {\n\t\t\treturn arg;\n\t\t}\n\t\tif (ts.isIdentifier(arg)) {\n\t\t\tconst key = `${sourceFile.fileName}#${arg.text}`;\n\t\t\tconst bound = this.functionBindings.get(key);\n\t\t\tif (bound) {\n\t\t\t\treturn bound;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Analyse a wrapped function's body for guaranteed runtime paths:\n\t * dive wraps returned functions as well (recursively), so each\n\t * function-valued return is a nested wrap site, and each `new Type()`\n\t * inside the body means the path hits that type's constructor (which\n\t * attachHooks wraps too). Both facts are 100% ensured, so they are\n\t * recorded AoT. Nested function bodies are NOT walked here — they\n\t * belong to their own wrap analysis, reached via the return chain.\n\t * Depth-capped and cycle-guarded.\n\t */\n\tprivate analyzeWrappedBody (\n\t\tfn: ts.FunctionLikeDeclaration,\n\t\tviaLocation: string,\n\t\tsourceFile: ts.SourceFile,\n\t\tdepth: number,\n\t\tvisited: Set<ts.Node>,\n\t\tcreatesTypes: Set<string>,\n\t\tfallbackScope?: string\n\t): void {\n\t\tif (depth > 5 || visited.has(fn) || !fn.body) {\n\t\t\treturn;\n\t\t}\n\t\tvisited.add(fn);\n\n\t\t// Arrow with expression body: implicit return\n\t\tif (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) {\n\t\t\tthis.recordWrappedReturn(fn.body, viaLocation, sourceFile, depth, visited, fallbackScope);\n\t\t\treturn;\n\t\t}\n\n\t\tconst walk = (node: ts.Node): void => {\n\t\t\tif (node !== fn.body && (\n\t\t\t\tts.isFunctionExpression(node) ||\n\t\t\t\tts.isArrowFunction(node) ||\n\t\t\t\tts.isFunctionDeclaration(node) ||\n\t\t\t\tts.isMethodDeclaration(node)\n\t\t\t)) {\n\t\t\t\t// nested function bodies are analysed through the return chain\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\t\tthis.recordWrappedReturn(node.expression, viaLocation, sourceFile, depth, visited, fallbackScope);\n\t\t\t}\n\t\t\tif (ts.isNewExpression(node)) {\n\t\t\t\tconst created = this.resolveExpressionType(node.expression) ||\n\t\t\t\t\t(ts.isIdentifier(node.expression) && this.definitions.has(node.expression.text)\n\t\t\t\t\t\t? node.expression.text\n\t\t\t\t\t\t: undefined);\n\t\t\t\tif (created) {\n\t\t\t\t\tcreatesTypes.add(created);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (ts.isCallExpression(node)) {\n\t\t\t\tconst nestedName = this.getFunctionName(node.expression);\n\t\t\t\tif (\n\t\t\t\t\tnestedName === 'wrap' ||\n\t\t\t\t\tnestedName === 'wrapConstructorArg' ||\n\t\t\t\t\tnestedName === 'upgradeConstructorArg' ||\n\t\t\t\t\tnestedName === 'wrapInstanceMethods'\n\t\t\t\t) {\n\t\t\t\t\t// the nested call may already be collected (visited\n\t\t\t\t\t// before this outer wrap site) — back-patch its entry,\n\t\t\t\t\t// otherwise leave the link (with this site's scope) for\n\t\t\t\t\t// collectEDS to pick up\n\t\t\t\t\tconst nestedEntry = this.wrapEntryByNode.get(node);\n\t\t\t\t\tif (nestedEntry) {\n\t\t\t\t\t\tnestedEntry.via = viaLocation;\n\t\t\t\t\t\tif (nestedEntry.scope === undefined) {\n\t\t\t\t\t\t\tnestedEntry.scope = fallbackScope;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.nestedWrapVia.set(node, { via : viaLocation, scope : fallbackScope });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tts.forEachChild(node, walk);\n\t\t};\n\t\twalk(fn.body);\n\t}\n\n\t/**\n\t * Record one function-valued return of a wrapped body as a nested wrap\n\t * site (`via` = the site whose wrapping caused it) and recurse into\n\t * its own returns. Returns through identifiers resolve through the\n\t * same-file bindings table; unresolvable returns are simply skipped.\n\t * A return declared outside any type scope inherits the causing wrap\n\t * site's scope attribution (the generation chain is the only holder).\n\t */\n\tprivate recordWrappedReturn (\n\t\texpr: ts.Expression,\n\t\tviaLocation: string,\n\t\tsourceFile: ts.SourceFile,\n\t\tdepth: number,\n\t\tvisited: Set<ts.Node>,\n\t\tfallbackScope?: string\n\t): void {\n\t\tconst returned = this.resolveFunctionArgument(expr, sourceFile);\n\t\tif (!returned) {\n\t\t\treturn;\n\t\t}\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\treturned.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = returned.getText(sourceFile).slice(0, 100);\n\t\tconst scope = this.resolveEDSScope(returned) ?? fallbackScope;\n\t\tconst entry = this.addEDS(scope || 'unknown', {\n\t\t\tlocation,\n\t\t\tkind : 'wrap',\n\t\t\tcode,\n\t\t\tscope,\n\t\t\tvia  : viaLocation,\n\t\t\t// dive wraps returned functions through the same wrap machinery\n\t\t\tfn   : 'wrap',\n\t\t});\n\t\t// the returned function's own returns are wrapped in turn; `via`\n\t\t// chains to this nested entry's location\n\t\tconst nestedCreates = new Set<string>();\n\t\tthis.analyzeWrappedBody(returned, location, sourceFile, depth + 1, visited, nestedCreates, scope);\n\t\tif (nestedCreates.size > 0) {\n\t\t\tentry.createsTypes = Array.from(nestedCreates);\n\t\t}\n\t}\n\n\t/**\n\t * Add an EDS usage to the collection\n\t * Returns the stored entry (the existing one when this is a duplicate),\n\t * so callers can enrich it after nested body analysis.\n\t */\n\tprivate addEDS (typePath: string, info: EDSInfo): EDSInfo {\n\t\tif (!this.edsUsages.has(typePath)) {\n\t\t\tthis.edsUsages.set(typePath, []);\n\t\t}\n\n\t\tconst existing = this.edsUsages.get(typePath)!;\n\t\tconst duplicate = existing.find(e => {\n\t\t\treturn e.location === info.location &&\n\t\t\t\te.kind === info.kind &&\n\t\t\t\te.code === info.code;\n\t\t});\n\n\t\tif (duplicate) {\n\t\t\treturn duplicate;\n\t\t}\n\t\texisting.push(info);\n\t\treturn info;\n\t}\n\n\t/**\n\t * Collect native flow patterns (instance usage after creation)\n\t * Phase 1: property access, method calls, arguments, return, destructuring, etc.\n\t */\n\tprivate collectFlow (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\t// Property read: user.name or user?.name\n\t\tif (ts.isPropertyAccessExpression(node)) {\n\t\t\tthis.collectFlowPropertyAccess(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Element access: user['name']\n\t\tif (ts.isElementAccessExpression(node)) {\n\t\t\tthis.collectFlowElementAccess(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Property write: user.name = value\n\t\tif (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n\t\t\tthis.collectFlowAssignment(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Method call: user.validate()  AND  argument passing: processUser(user)\n\t\tif (ts.isCallExpression(node) && node.expression) {\n\t\t\tthis.collectFlowMethodCall(node, sourceFile);\n\t\t\tthis.collectFlowArgumentPass(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Destructure read: const { name } = user\n\t\tif (ts.isVariableDeclaration(node) && node.initializer) {\n\t\t\tthis.collectFlowDestructure(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Return instance: return user\n\t\tif (ts.isReturnStatement(node) && node.expression) {\n\t\t\tthis.collectFlowReturn(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\n\t\t// Spread: { ...user }\n\t\tif (ts.isSpreadElement(node)) {\n\t\t\tthis.collectFlowSpread(node, sourceFile);\n\t\t\treturn;\n\t\t}\n\t}\n\n\t/**\n\t * Collect property access flow (read or conditional)\n\t */\n\tprivate collectFlowPropertyAccess (node: ts.PropertyAccessExpression, sourceFile: ts.SourceFile): void {\n\t\tconst objectType = this.resolveExpressionType(node.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst propName = node.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Skip if this is a type constructor access (e.g., UserType.define)\n\t\tif (propName === 'define' || propName === 'lazy') { return; }\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind         : 'propertyRead',\n\t\t\tcode,\n\t\t\tpropertyName : propName,\n\t\t\ttargetType   : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect element access flow: user['name']\n\t */\n\tprivate collectFlowElementAccess (node: ts.ElementAccessExpression, sourceFile: ts.SourceFile): void {\n\t\tconst objectType = this.resolveExpressionType(node.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind       : 'elementAccess',\n\t\t\tcode,\n\t\t\ttargetType : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect assignment flow: user.name = value or user = other\n\t */\n\tprivate collectFlowAssignment (node: ts.BinaryExpression, sourceFile: ts.SourceFile): void {\n\t\t// Property write: user.name = value\n\t\tif (ts.isPropertyAccessExpression(node.left)) {\n\t\t\tconst objectType = this.resolveExpressionType(node.left.expression);\n\t\t\tif (!objectType) { return; }\n\n\t\t\tconst propName = node.left.name.text;\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(objectType, {\n\t\t\t\tlocation,\n\t\t\t\tkind         : 'propertyWrite',\n\t\t\t\tcode,\n\t\t\t\tpropertyName : propName,\n\t\t\t\ttargetType   : objectType\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// Variable reassignment: user = other\n\t\tif (ts.isIdentifier(node.left)) {\n\t\t\tconst varName = node.left.text;\n\t\t\tconst mappedType = this.variableToTypeMap.get(varName);\n\t\t\tif (!mappedType) { return; }\n\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(mappedType, {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'reassignment',\n\t\t\t\tcode,\n\t\t\t\ttargetType : mappedType\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Collect method call flow: user.validate()\n\t */\n\tprivate collectFlowMethodCall (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isPropertyAccessExpression(node.expression)) { return; }\n\n\t\tconst objectType = this.resolveExpressionType(node.expression.expression);\n\t\tif (!objectType) { return; }\n\n\t\tconst methodName = node.expression.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Skip if this is a type constructor call (e.g., new UserType())\n\t\tif (methodName === 'define' || methodName === 'lazy') { return; }\n\n\t\tthis.addFlow(objectType, {\n\t\t\tlocation,\n\t\t\tkind         : 'methodCall',\n\t\t\tcode,\n\t\t\tpropertyName : methodName,\n\t\t\ttargetType   : objectType\n\t\t});\n\t}\n\n\t/**\n\t * Collect argument passing flow: processUser(user)\n\t */\n\tprivate collectFlowArgumentPass (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tfor (let i = 0; i < node.arguments.length; i++) {\n\t\t\tconst arg = node.arguments[ i ];\n\t\t\tconst argType = this.resolveExpressionType(arg);\n\t\t\tif (!argType) { continue; }\n\n\t\t\tconst funcName = this.getFunctionName(node.expression) || 'anonymous';\n\t\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\t\tsourceFile,\n\t\t\t\tnode.getStart(sourceFile)\n\t\t\t);\n\t\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t\tthis.addFlow(argType, {\n\t\t\t\tlocation,\n\t\t\t\tkind       : 'passAsArg',\n\t\t\t\tcode,\n\t\t\t\ttargetType : argType,\n\t\t\t\tcontext    : `arg ${i} to ${funcName}`\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Collect destructuring flow: const { name } = user\n\t */\n\tprivate collectFlowDestructure (node: ts.VariableDeclaration, sourceFile: ts.SourceFile): void {\n\t\tif (!ts.isObjectBindingPattern(node.name)) { return; }\n\n\t\tconst sourceType = this.resolveExpressionType(node.initializer!);\n\t\tif (!sourceType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\t// Extract destructured property names\n\t\tconst props: string[] = [];\n\t\tfor (const element of node.name.elements) {\n\t\t\tif (ts.isIdentifier(element.name)) {\n\t\t\t\tprops.push(element.name.text);\n\t\t\t}\n\t\t}\n\n\t\tthis.addFlow(sourceType, {\n\t\t\tlocation,\n\t\t\tkind       : 'destructureRead',\n\t\t\tcode,\n\t\t\ttargetType : sourceType,\n\t\t\tcontext    : props.join(', ')\n\t\t});\n\t}\n\n\t/**\n\t * Collect return flow: return user\n\t */\n\tprivate collectFlowReturn (node: ts.ReturnStatement, sourceFile: ts.SourceFile): void {\n\t\tconst returnType = this.resolveExpressionType(node.expression!);\n\t\tif (!returnType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(returnType, {\n\t\t\tlocation,\n\t\t\tkind       : 'return',\n\t\t\tcode,\n\t\t\ttargetType : returnType\n\t\t});\n\t}\n\n\t/**\n\t * Collect spread flow: { ...user }\n\t */\n\tprivate collectFlowSpread (node: ts.SpreadElement, sourceFile: ts.SourceFile): void {\n\t\tconst spreadType = this.resolveExpressionType(node.expression);\n\t\tif (!spreadType) { return; }\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.addFlow(spreadType, {\n\t\t\tlocation,\n\t\t\tkind       : 'spread',\n\t\t\tcode,\n\t\t\ttargetType : spreadType\n\t\t});\n\t}\n\n\t/**\n\t * Resolve type from an expression (identifier, property access, etc.)\n\t */\n\tprivate resolveExpressionType (expr: ts.Expression): string | undefined {\n\t\t// Identifier: user\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\treturn this.variableToTypeMap.get(expr.text);\n\t\t}\n\n\t\t// Property access: user.name (return object type, not property type)\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\treturn this.resolveExpressionType(expr.expression);\n\t\t}\n\n\t\t// Element access: user['name']\n\t\tif (ts.isElementAccessExpression(expr)) {\n\t\t\treturn this.resolveExpressionType(expr.expression);\n\t\t}\n\n\t\t// This expression: this (if in a method, we can't resolve without more context)\n\t\tif (expr.kind === ts.SyntaxKind.ThisKeyword) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Add a flow usage to the collection\n\t */\n\tprivate addFlow (typePath: string, info: FlowInfo): void {\n\t\tif (!this.flowUsages.has(typePath)) {\n\t\t\tthis.flowUsages.set(typePath, []);\n\t\t}\n\n\t\tconst existing = this.flowUsages.get(typePath)!;\n\t\tconst isDuplicate = existing.some(e => {\n\t\t\treturn e.location === info.location &&\n\t\t\t\te.kind === info.kind &&\n\t\t\t\te.code === info.code;\n\t\t});\n\n\t\tif (!isDuplicate) {\n\t\t\texisting.push(info);\n\t\t}\n\t}\n\n\t/**\n\t\t\t* Get type name from expression (identifier or property access)\n\t\t\t*/\n\tprivate getTypeNameFromExpression (expr: ts.Expression): string | undefined {\n\t\tif (ts.isIdentifier(expr)) {\n\t\t\tconst name = expr.text;\n\t\t\t// Check if this identifier is a variable mapped to a type (e.g., from lookup)\n\t\t\tconst mappedType = this.variableToTypeMap.get(name);\n\t\t\tif (mappedType) {\n\t\t\t\treturn mappedType;\n\t\t\t}\n\t\t\treturn name;\n\t\t}\n\t\tif (ts.isPropertyAccessExpression(expr)) {\n\t\t\tconst chain = this.getPropertyChain(expr);\n\t\t\treturn chain.join('.');\n\t\t}\n\t\treturn undefined;\n\t}\n\t\n\t/**\n\t\t\t* Resolve full type path from property access\n\t\t\t*/\n\tprivate resolveTypePath (expr: ts.PropertyAccessExpression): string | undefined {\n\t\tconst chain = this.getPropertyChain(expr);\n\t\tif (chain.length === 0) return undefined;\n\t\n\t\t// Check if this chain matches a known type\n\t\tconst fullPath = chain.join('.');\n\t\tif (this.definitions.has(fullPath)) {\n\t\t\treturn fullPath;\n\t\t}\n\t\n\t\t// Try just the property name\n\t\tconst propName = chain[ chain.length - 1 ];\n\t\tfor (const [ path ] of this.definitions) {\n\t\t\tif (path.endsWith(`.${propName}`) || path === propName) {\n\t\t\t\treturn path;\n\t\t\t}\n\t\t}\n\t\n\t\treturn fullPath;\n\t}\n\t\n\t/**\n\t\t\t * Check if a name looks like a type (starts with uppercase)\n\t\t\t */\n\tprivate isLikelyTypeName (name: string): boolean {\n\t\treturn name[ 0 ] >= 'A' && name[ 0 ] <= 'Z';\n\t}\n\t\n\t/**\n\t\t\t * Resolve a constructor parameter type, expanding inline object literals\n\t\t\t * and type aliases where possible.\n\t\t\t */\n\tprivate resolveConstructorParamType (typeNode: ts.TypeNode | undefined): string | undefined {\n\t\tif (!typeNode) return undefined;\n\n\t\t// Direct inline type literal: { prop: type }\n\t\tif (ts.isTypeLiteralNode(typeNode)) {\n\t\t\tconst props: string[] = [];\n\t\t\tfor (const member of typeNode.members) {\n\t\t\t\tif (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {\n\t\t\t\t\tconst propName = member.name.text;\n\t\t\t\t\tconst optional = member.questionToken ? '?' : '';\n\t\t\t\t\tconst type = this.inferType(member.type);\n\t\t\t\t\tprops.push(`${propName}${optional}: ${type}`);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn `{ ${props.join('; ')} }`;\n\t\t}\n\n\t\t// Type reference: usage, UserData, etc. - resolve import-aware and\n\t\t// expand the referenced declaration where possible (F10)\n\t\tif (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {\n\t\t\tconst typeName = typeNode.typeName.text;\n\t\t\tconst decl = this.resolveReferencedTypeDeclaration(typeName, this.currentReferencedTypeFile);\n\t\t\tif (decl) {\n\t\t\t\tconst expanded = this.expandReferencedTypeDeclaration(decl);\n\t\t\t\tif (expanded) return expanded;\n\t\t\t}\n\t\t\t// mnemonica graph types keep their simple name — the generator\n\t\t\t// upgrades them to full-path instance type names. Resolution is\n\t\t\t// path-aware (hard-fail law): ambiguity between real graph types\n\t\t\t// records a fatal error instead of silently picking one.\n\t\t\tconst graphResult = this.resolveGraphTypeName(typeName);\n\t\t\tif (graphResult.status === 'unique') {\n\t\t\t\tconst simpleResult = typeName;\n\t\t\t\treturn simpleResult;\n\t\t\t}\n\t\t\tif (graphResult.status === 'ambiguous') {\n\t\t\t\tthis.recordGraphReferenceError(typeName, typeNode, graphResult);\n\t\t\t\tconst unknownGraphResult = 'unknown';\n\t\t\t\treturn unknownGraphResult;\n\t\t\t}\n\t\t\t// If not an object type alias, return the type name with args\n\t\t\tif (typeNode.typeArguments && typeNode.typeArguments.length > 0) {\n\t\t\t\tif (KNOWN_GLOBAL_TYPES.has(typeName)) {\n\t\t\t\t\tconst args = typeNode.typeArguments.map(arg => this.inferType(arg));\n\t\t\t\t\treturn `${typeName  }<${  args.join(', ')  }>`;\n\t\t\t\t}\n\t\t\t\t// generic reference to a non-global, non-graph type cannot be\n\t\t\t\t// emitted bare into the generated file\n\t\t\t\tthis.recordPlainTypeReferenceSite(typeName, typeNode);\n\t\t\t\tconst unknownGenericResult = 'unknown';\n\t\t\t\treturn unknownGenericResult;\n\t\t\t}\n\t\t\tconst fallbackResult = this.unresolvedTypeReferenceFallback(typeName, typeNode);\n\t\t\treturn fallbackResult;\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from a class-like node.\n\t\t\t */\n\tprivate extractClassConstructorParams (classLike: ts.ClassDeclaration | ts.ClassExpression):\n\t\tConstructorParamInfo[] {\n\t\tconst params: ConstructorParamInfo[] = [];\n\n\t\tfor (const member of classLike.members) {\n\t\t\tif (!ts.isConstructorDeclaration(member)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tfor (const param of member.parameters) {\n\t\t\t\tif (!param.name || !ts.isIdentifier(param.name)) continue;\n\t\t\t\tif (!param.type) continue;\n\n\t\t\t\tconst paramName = param.name.text;\n\t\t\t\tconst expandedType = this.resolveConstructorParamType(param.type) || this.inferType(param.type);\n\n\t\t\t\tparams.push({\n\t\t\t\t\tname     : paramName,\n\t\t\t\t\ttype     : expandedType,\n\t\t\t\t\toptional : !!param.questionToken || !!param.initializer\n\t\t\t\t});\n\t\t\t}\n\t\t\t// Only process first constructor\n\t\t\tbreak;\n\t\t}\n\n\t\treturn params;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from define() call\n\t\t\t * This is used for TypeRegistry constructor signatures\n\t\t\t * Preserves parameter names and expands object types to their structure\n\t\t\t */\n\tprivate extractConstructorParams (call: ts.CallExpression): ConstructorParamInfo[] {\n\t\tconst constructorExpr = this.extractConstructorExpression(call);\n\t\tif (!constructorExpr) {\n\t\t\treturn [];\n\t\t}\n\t\tconst result = this.extractConstructorParamsFromConstructor(constructorExpr);\n\t\treturn result;\n\t}\n\n\t/**\n\t\t\t * Extract constructor parameters from a constructor expression.\n\t\t\t */\n\tprivate extractConstructorParamsFromConstructor (constructorExpr: ts.Expression): ConstructorParamInfo[] {\n\t\tconst params: ConstructorParamInfo[] = [];\n\t\n\t\t// Handle function expression or arrow function\n\t\tif (ts.isFunctionExpression(constructorExpr) || ts.isArrowFunction(constructorExpr)) {\n\t\t\t// Look for constructor parameters (second param after `this`)\n\t\t\t// Patterns: function(this: Type, data: { ... }) or (this: Type, data: { ... }) =>\n\t\t\tfor (let i = 0; i < constructorExpr.parameters.length; i++) {\n\t\t\t\tconst param = constructorExpr.parameters[ i ];\n\t\t\t\tif (!param.type) continue;\n\t\n\t\t\t\t// Skip `this` parameter (first param)\n\t\t\t\tif (\n\t\t\t\t\ti === 0 &&\n\t\t\t\t\tparam.name.kind === ts.SyntaxKind.Identifier &&\n\t\t\t\t\t(param.name as ts.Identifier).text === 'this'\n\t\t\t\t) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\n\t\t\t\t// Get parameter name and expand its type\n\t\t\t\tconst paramName = ts.isIdentifier(param.name) ? param.name.text : 'arg';\n\t\t\t\tconst expandedType = this.resolveConstructorParamType(param.type) || this.inferType(param.type);\n\t\t\t\t\t\n\t\t\t\tparams.push({\n\t\t\t\t\tname     : paramName,\n\t\t\t\t\ttype     : expandedType,\n\t\t\t\t\toptional : !!param.questionToken || !!param.initializer\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\n\t\t// Handle class expression - check constructor method\n\t\tif (ts.isClassExpression(constructorExpr)) {\n\t\t\tconst classParams = this.extractClassConstructorParams(constructorExpr);\n\t\t\tfor (const param of classParams) {\n\t\t\t\tparams.push(param);\n\t\t\t}\n\t\t}\n\n\t\treturn params;\n\t}\n\n\t/**\n\t * Collect framework instrumentation points. Purely syntactic: heritage\n\t * clauses, decorator application sites, provider-token object literals\n\t * and consumer.apply().forRoutes() wiring. The vocabulary comes from\n\t * plugins; identifier text is matched as-is — no import resolution,\n\t * the type checker stays unused.\n\t */\n\tprivate collectInstrumentation (node: ts.Node, sourceFile: ts.SourceFile): void {\n\t\tif (ts.isClassDeclaration(node) && node.name) {\n\t\t\tthis.collectInstrumentationClass(node, sourceFile);\n\t\t}\n\t\tif (ts.isDecorator(node)) {\n\t\t\tthis.collectInstrumentationDecorator(node, sourceFile);\n\t\t}\n\t\tif (ts.isObjectLiteralExpression(node)) {\n\t\t\tthis.collectInstrumentationProvider(node, sourceFile);\n\t\t}\n\t\tif (ts.isCallExpression(node)) {\n\t\t\tthis.collectInstrumentationMiddleware(node, sourceFile);\n\t\t}\n\t}\n\n\t/**\n\t * Record a named class declaration for instrumentation site resolution\n\t * and detect heritage-based kinds (`implements <plugin interface>`)\n\t */\n\tprivate collectInstrumentationClass (node: ts.ClassDeclaration, sourceFile: ts.SourceFile): void {\n\t\tif (!node.name) {\n\t\t\treturn;\n\t\t}\n\t\tconst className = node.name.text;\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.name.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\t// First line of the declaration, like EDS `code` snippets\n\t\tconst code = node.getText(sourceFile).split('\\n')[ 0 ].slice(0, 100);\n\n\t\tlet kind: InstrumentationKind | undefined;\n\t\tif (node.heritageClauses) {\n\t\t\tfor (const clause of node.heritageClauses) {\n\t\t\t\tif (clause.token !== ts.SyntaxKind.ImplementsKeyword) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tfor (const type of clause.types) {\n\t\t\t\t\tif (!ts.isIdentifier(type.expression)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst matched = this.instrumentationVocabulary.interfaces[ type.expression.text ];\n\t\t\t\t\tif (matched) {\n\t\t\t\t\t\tkind = matched;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst decl: InstrumentationClassDecl = {\n\t\t\tlocation,\n\t\t\tcode,\n\t\t};\n\t\tif (kind) {\n\t\t\tdecl.kind = kind;\n\t\t}\n\t\tthis.instrumentationClassDecls.set(className, decl);\n\t}\n\n\t/**\n\t * Detect decorator application sites: plugin-listed decorators applied\n\t * with class arguments on a class or one of its methods. One site per\n\t * referenced class identifier.\n\t */\n\tprivate collectInstrumentationDecorator (node: ts.Decorator, sourceFile: ts.SourceFile): void {\n\t\tconst { expression } = node;\n\t\tif (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression)) {\n\t\t\treturn;\n\t\t}\n\t\tconst kind = this.instrumentationVocabulary.useDecorators[ expression.expression.text ];\n\t\tif (!kind) {\n\t\t\treturn;\n\t\t}\n\n\t\t// The decorator's parent is the decorated node: a controller class,\n\t\t// one of its methods, or one of its method parameters\n\t\t// (@Body(mvp.forType(Dto)) on a handler argument)\n\t\tconst decorated = node.parent;\n\t\tlet scope: InstrumentationScope;\n\t\tlet targets: string[];\n\t\tif (ts.isClassDeclaration(decorated) && decorated.name) {\n\t\t\tscope = `controller:${decorated.name.text}`;\n\t\t\ttargets = [ decorated.name.text ];\n\t\t} else if (\n\t\t\tts.isMethodDeclaration(decorated) &&\n\t\t\tts.isIdentifier(decorated.name) &&\n\t\t\tts.isClassDeclaration(decorated.parent) &&\n\t\t\tdecorated.parent.name\n\t\t) {\n\t\t\tconst className = decorated.parent.name.text;\n\t\t\tscope = `method:${className}.${decorated.name.text}`;\n\t\t\ttargets = [ className ];\n\t\t} else if (ts.isParameter(decorated)) {\n\t\t\t// Parameter decorators take the enclosing method's scope — the\n\t\t\t// attachment point is the handler, not the argument name; the\n\t\t\t// same method:Class.method form as method-level sites. Params of\n\t\t\t// constructors, functions, and unnameable hosts stay silent, the\n\t\t\t// same convention as other unresolvable decorator parents\n\t\t\tconst host = decorated.parent;\n\t\t\tif (\n\t\t\t\thost &&\n\t\t\t\tts.isMethodDeclaration(host) &&\n\t\t\t\tts.isIdentifier(host.name) &&\n\t\t\t\tts.isClassDeclaration(host.parent) &&\n\t\t\t\thost.parent.name\n\t\t\t) {\n\t\t\t\tconst className = host.parent.name.text;\n\t\t\t\tscope = `method:${className}.${host.name.text}`;\n\t\t\t\ttargets = [ className ];\n\t\t\t} else {\n\t\t\t\treturn;\n\t\t\t}\n\t\t} else {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tfor (const arg of expression.arguments) {\n\t\t\t// Class reference: @Register(Impl) or an inline instance:\n\t\t\t// @Register(new Impl({ ...options }))\n\t\t\tlet className: string | undefined;\n\t\t\t// per-arg kind: factory-call args carry their own configured\n\t\t\t// kind, everything else takes the decorator's\n\t\t\tlet argKind = kind;\n\t\t\tif (ts.isIdentifier(arg)) {\n\t\t\t\tclassName = arg.text;\n\t\t\t} else if (ts.isNewExpression(arg) && ts.isIdentifier(arg.expression)) {\n\t\t\t\tclassName = arg.expression.text;\n\t\t\t} else if (ts.isCallExpression(arg) && ts.isPropertyAccessExpression(arg.expression)) {\n\t\t\t\t// Pipe-factory shape: @UsePipes(mvp.forType(Dto)) — the\n\t\t\t\t// call's method name is plugin-listed, the target class sits\n\t\t\t\t// in the configured argument position (default 0)\n\t\t\t\tconst factory = this.instrumentationVocabulary.decoratorArgFactories[ arg.expression.name.text ];\n\t\t\t\tif (factory) {\n\t\t\t\t\tconst targetArg = arg.arguments[ factory.targetArg ?? 0 ];\n\t\t\t\t\tif (targetArg && ts.isIdentifier(targetArg)) {\n\t\t\t\t\t\tclassName = targetArg.text;\n\t\t\t\t\t\targKind = factory.kind;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!className) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.instrumentationSites.push({\n\t\t\t\tkind : argKind,\n\t\t\t\tclassName,\n\t\t\t\tlocation,\n\t\t\t\tcode,\n\t\t\t\tscope,\n\t\t\t\ttargets,\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Detect global registrations: object literals shaped like\n\t * `{ provide: <plugin-listed token>, useClass: X }`.\n\t * useExisting/useFactory without a useClass identifier are not\n\t * statically obvious — skipped rather than guessed.\n\t */\n\tprivate collectInstrumentationProvider (node: ts.ObjectLiteralExpression, sourceFile: ts.SourceFile): void {\n\t\tlet kind: InstrumentationKind | undefined;\n\t\tlet useClassName: string | undefined;\n\n\t\tfor (const prop of node.properties) {\n\t\t\tif (\n\t\t\t\t!ts.isPropertyAssignment(prop) ||\n\t\t\t\t!ts.isIdentifier(prop.name) ||\n\t\t\t\t!ts.isIdentifier(prop.initializer)\n\t\t\t) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (prop.name.text === 'provide') {\n\t\t\t\tkind = this.instrumentationVocabulary.appTokens[ prop.initializer.text ];\n\t\t\t}\n\t\t\tif (prop.name.text === 'useClass') {\n\t\t\t\tuseClassName = prop.initializer.text;\n\t\t\t}\n\t\t}\n\n\t\tif (!kind || !useClassName) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tnode.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tthis.instrumentationSites.push({\n\t\t\tkind,\n\t\t\tclassName : useClassName,\n\t\t\tlocation,\n\t\t\tcode,\n\t\t\tscope     : 'global',\n\t\t\ttargets   : [],\n\t\t});\n\t}\n\n\t/**\n\t * Detect middleware wiring: `consumer.apply(Mw1, Mw2).forRoutes(...)`\n\t * inside a class's configure() method. Targets come from forRoutes\n\t * arguments when statically readable (string routes or controller\n\t * identifiers), else []. Shape-based, so a plugin must opt in via\n\t * `middlewareWiring: true`.\n\t */\n\tprivate collectInstrumentationMiddleware (node: ts.CallExpression, sourceFile: ts.SourceFile): void {\n\t\tif (!this.instrumentationVocabulary.middlewareWiring) {\n\t\t\treturn;\n\t\t}\n\t\tif (\n\t\t\t!ts.isPropertyAccessExpression(node.expression) ||\n\t\t\tnode.expression.name.text !== 'forRoutes'\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t\tconst applyCall = node.expression.expression;\n\t\tif (\n\t\t\t!ts.isCallExpression(applyCall) ||\n\t\t\t!ts.isPropertyAccessExpression(applyCall.expression) ||\n\t\t\tapplyCall.expression.name.text !== 'apply'\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.isInsideConfigureMethod(node)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst targets: string[] = [];\n\t\tfor (const arg of node.arguments) {\n\t\t\tif (ts.isIdentifier(arg) || ts.isStringLiteral(arg)) {\n\t\t\t\ttargets.push(arg.text);\n\t\t\t}\n\t\t}\n\n\t\tconst { line, character } = ts.getLineAndCharacterOfPosition(\n\t\t\tsourceFile,\n\t\t\tapplyCall.getStart(sourceFile)\n\t\t);\n\t\tconst location = `${sourceFile.fileName}:${line + 1}:${character + 1}`;\n\t\tconst code = node.getText(sourceFile).slice(0, 100);\n\n\t\tfor (const arg of applyCall.arguments) {\n\t\t\tif (!ts.isIdentifier(arg)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.instrumentationSites.push({\n\t\t\t\tkind      : 'middleware',\n\t\t\t\tclassName : arg.text,\n\t\t\t\tlocation,\n\t\t\t\tcode,\n\t\t\t\tscope     : 'module',\n\t\t\t\ttargets,\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Walk up the parent chain looking for an enclosing configure() method\n\t */\n\tprivate isInsideConfigureMethod (node: ts.Node): boolean {\n\t\tlet current: ts.Node | undefined = node.parent;\n\t\twhile (current) {\n\t\t\tif (\n\t\t\t\tts.isMethodDeclaration(current) &&\n\t\t\t\tts.isIdentifier(current.name) &&\n\t\t\t\tcurrent.name.text === 'configure'\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn false;\n\t}\n}\n"]}