@getmikk/core 1.8.2 → 1.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getmikk/core",
-    "version": "1.8.2",
+    "version": "1.8.3",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",

package/src/contract/lock-compiler.ts

@@ -325,18 +325,19 @@ export class LockCompiler {
         for (const file of parsedFiles) {
             const moduleId = this.findModule(file.path, contract.declared.modules)
 
-            // Collect file-level imports from the graph's import edges
-            const outEdges = graph.outEdges.get(file.path) || []
-            const importedFiles = outEdges
-                .filter(e => e.type === 'imports')
-                .map(e => e.target)
-
+            // Collect file-level imports from the parsed file info directly
+            // to include both source and resolvedPath for unresolved analysis.
+            const imports = file.imports.map(imp => ({
+                source: imp.source,
+                resolvedPath: imp.resolvedPath || undefined,
+            }))
+ 
             result[file.path] = {
                 path: file.path,
                 hash: file.hash,
                 moduleId: moduleId || 'unknown',
                 lastModified: new Date(file.parsedAt).toISOString(),
-                ...(importedFiles.length > 0 ? { imports: importedFiles } : {}),
+                ...(imports.length > 0 ? { imports } : {}),
             }
         }
 

package/src/contract/schema.ts

@@ -83,12 +83,17 @@ export const MikkLockModuleSchema = z.object({
     fragmentPath: z.string(),
 })
 
+export const MikkLockImportSchema = z.object({
+    source: z.string(),
+    resolvedPath: z.string().optional(),
+})
+
 export const MikkLockFileSchema = z.object({
     path: z.string(),
     hash: z.string(),
     moduleId: z.string(),
     lastModified: z.string(),
-    imports: z.array(z.string()).optional(),
+    imports: z.array(MikkLockImportSchema).optional(),
 })
 
 export const MikkLockClassSchema = z.object({

package/src/graph/dead-code-detector.ts

@@ -195,9 +195,31 @@ export class DeadCodeDetector {
     }
 
     private isCalledByExportedInSameFile(fn: MikkLock['functions'][string]): boolean {
-        for (const callerId of fn.calledBy) {
-            const caller = this.lock.functions[callerId]
-            if (caller && caller.isExported && caller.file === fn.file) return true
+        // Multi-pass transitive liveness: propagate liveness through the full calledBy
+        // chain until no new live functions are discovered.  A single-hop check misses
+        // patterns like: exportedFn → internalA → internalB (internalB is still live).
+        const file = fn.file
+        const visited = new Set<string>()
+        const queue: string[] = [fn.id]
+
+        while (queue.length > 0) {
+            const currentId = queue.pop()!
+            if (visited.has(currentId)) continue
+            visited.add(currentId)
+
+            const current = this.lock.functions[currentId]
+            if (!current) continue
+
+            for (const callerId of current.calledBy) {
+                if (visited.has(callerId)) continue
+                const caller = this.lock.functions[callerId]
+                if (!caller) continue
+                // Only follow the chain within the same file
+                if (caller.file !== file) continue
+                // Found a live exported caller in the same file — the original fn is live
+                if (caller.isExported) return true
+                queue.push(callerId)
+            }
         }
         return false
     }
@@ -213,9 +235,9 @@ export class DeadCodeDetector {
      *  high   — none of the above: safe to remove.
      */
     private inferConfidence(fn: MikkLock['functions'][string]): DeadCodeConfidence {
+        if (DYNAMIC_USAGE_PATTERNS.some(p => p.test(fn.name))) return 'low'
         if (fn.calledBy.length > 0) return 'medium'
         if (this.filesWithUnresolvedImports.has(fn.file)) return 'medium'
-        if (DYNAMIC_USAGE_PATTERNS.some(p => p.test(fn.name))) return 'low'
         return 'high'
     }
 
@@ -240,7 +262,7 @@ export class DeadCodeDetector {
         if (!this.lock.files) return result
 
         for (const [filePath, fileInfo] of Object.entries(this.lock.files)) {
-            const imports = (fileInfo as any).imports ?? []
+            const imports = fileInfo.imports ?? []
             for (const imp of imports) {
                 if (!imp.resolvedPath || imp.resolvedPath === '') {
                     result.add(filePath)

package/src/graph/graph-builder.ts

@@ -143,7 +143,11 @@ export class GraphBuilder {
                 endLine: gen.endLine,
                 isExported: gen.isExported,
                 purpose: gen.purpose,
-                hash: gen.type,
+                // Store the declaration kind (interface|type|const) separately from the
+                // content hash.  gen.hash is the actual content hash; gen.type is the
+                // declaration kind string — they are different things and must not be mixed.
+                hash: gen.hash ?? undefined,
+                genericKind: gen.type,
             },
         })
     }
@@ -232,7 +236,11 @@ export class GraphBuilder {
                 const receiver = hasDot ? call.split('.')[0] : null
 
                 // --- 1. Named import exact match ---
-                const namedId = importedNames.get(call) ?? importedNames.get(simpleName)
+                // Only fall back to simpleName when there is no dotted receiver.
+                // If call = "jwt.verify", falling back to importedNames.get("verify") could
+                // match a completely different import named "verify" — wrong target, high
+                // confidence false-positive.  Only strip the receiver when there is none.
+                const namedId = importedNames.get(call) ?? (receiver === null ? importedNames.get(simpleName) : undefined)
                 if (namedId && graph.nodes.has(namedId)) {
                     this.pushEdge(graph, edgeKeys, {
                         source: fn.id,
@@ -294,7 +302,7 @@ export class GraphBuilder {
         }
     }
 
-    /** Containment edges: file → function, file → class, class → method */
+    /** Containment edges: file → function, file → class, class → method, file → generic */
     private addContainmentEdges(
         graph: DependencyGraph,
         file: ParsedFile,
@@ -321,6 +329,15 @@ export class GraphBuilder {
                 })
             }
         }
+        // Generic declarations (interfaces, type aliases, top-level constants) are also
+        // contained by their file — needed so dead-code and impact analysis can trace them.
+        for (const gen of file.generics ?? []) {
+            this.pushEdge(graph, edgeKeys, {
+                source: file.path,
+                target: gen.id,
+                type: 'contains',
+            })
+        }
     }
 
     // -------------------------------------------------------------------------

package/src/graph/impact-analyzer.ts

@@ -27,19 +27,23 @@ export class ImpactAnalyzer {
 
         const queue: { id: string; depth: number; confidence: number }[] =
             changedNodeIds.map(id => ({ id, depth: 0, confidence: 1.0 }))
+        // Use an index pointer instead of queue.shift() to avoid O(n) cost per dequeue.
+        let queueHead = 0
         let maxDepth = 0
 
         const changedSet = new Set(changedNodeIds)
 
-        // Collect module IDs of the changed nodes
-        const changedModules = new Set<string | undefined>()
+        // Collect module IDs of the changed nodes — filter out undefined so that
+        // nodes without a moduleId don't accidentally match every other unmoduled node
+        // and cause everything to appear "same module".
+        const changedModules = new Set<string>()
         for (const id of changedNodeIds) {
             const node = this.graph.nodes.get(id)
-            if (node) changedModules.add(node.moduleId)
+            if (node?.moduleId) changedModules.add(node.moduleId)
         }
 
-        while (queue.length > 0) {
-            const { id: current, depth, confidence: pathConf } = queue.shift()!
+        while (queueHead < queue.length) {
+            const { id: current, depth, confidence: pathConf } = queue[queueHead++]
             if (visited.has(current)) continue
             visited.add(current)
             depthMap.set(current, depth)
@@ -74,7 +78,9 @@ export class ImpactAnalyzer {
             if (!node) continue
 
             const depth = depthMap.get(id) ?? 999
-            const crossesBoundary = !changedModules.has(node.moduleId)
+            // A node crosses a module boundary when its module differs from ALL changed modules.
+            // If the node has no moduleId, treat it as crossing a boundary (unknown module ≠ known).
+            const crossesBoundary = !node.moduleId || !changedModules.has(node.moduleId)
 
             const risk: RiskLevel =
                 depth === 1 && crossesBoundary ? 'critical' :

package/src/graph/types.ts

@@ -19,6 +19,7 @@ export interface GraphNode {
         isAsync?: boolean
         hash?: string
         purpose?: string
+        genericKind?: string
         params?: { name: string; type: string; optional?: boolean }[]
         returnType?: string
         edgeCasesHandled?: string[]

package/src/parser/boundary-checker.ts

@@ -74,7 +74,9 @@ export class BoundaryChecker {
 
         for (const file of Object.values(this.lock.files)) {
             if (file.moduleId === 'unknown' || !file.imports?.length) continue
-            for (const importedPath of file.imports) {
+            for (const imp of file.imports) {
+                const importedPath = imp.resolvedPath
+                if (!importedPath) continue
                 const importedFile = this.lock.files[importedPath]
                 if (!importedFile || importedFile.moduleId === 'unknown' || file.moduleId === importedFile.moduleId) continue
                 const v = this.checkFileImport(file, importedFile)

package/src/parser/go/go-extractor.ts

@@ -54,6 +54,7 @@ const ROUTE_PATTERNS: RoutePattern[] = [
  */
 export class GoExtractor {
     private readonly lines: string[]
+    private cachedFunctions: ReturnType<typeof this.scanFunctions> | null = null
 
     constructor(
         private readonly filePath: string,
@@ -174,6 +175,7 @@ export class GoExtractor {
         endLine: number
         purpose: string
     }> {
+        if (this.cachedFunctions) return this.cachedFunctions
         const results: Array<{
             name: string
             receiverType?: string
@@ -237,6 +239,7 @@ export class GoExtractor {
             i = bodyEnd + 1
         }
 
+        this.cachedFunctions = results
         return results
     }
 
@@ -547,11 +550,17 @@ function findBodyBounds(lines: string[], startLine: number): { bodyStart: number
 
             if (ch === '/' && next === '/') { inLineComment = true; break }
             if (ch === '/' && next === '*') { inBlockComment = true; j++; continue }
-            if (ch === '"' || ch === '`' || ch === '\'') {
+            if (ch === '"' || ch === '`') {
                 inString = true
                 stringChar = ch
                 continue
             }
+            if (ch === '\'') {
+                // Go rune literal: consume exactly one character (or escape) then close
+                if (next === '\\') j += 3 // '\n' or '\x00' etc.
+                else j += 2 // 'a'
+                continue
+            }
 
             if (ch === '{') {
                 if (bodyStart === -1) bodyStart = i

package/src/parser/tree-sitter/parser.ts

@@ -142,6 +142,7 @@ function assignCallsToFunctions(
 export class TreeSitterParser extends BaseParser {
     private parser: any = null
     private languages = new Map<string, any>()
+    private nameCounter = new Map<string, number>()
 
     getSupportedExtensions(): string[] {
         return ['.py', '.java', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.go', '.rs', '.php', '.rb']
@@ -155,6 +156,7 @@ export class TreeSitterParser extends BaseParser {
     }
 
     async parse(filePath: string, content: string): Promise<ParsedFile> {
+        this.nameCounter.clear()
         await this.init()
         const ext = path.extname(filePath).toLowerCase()
         const config = await this.getLanguageConfig(ext)
@@ -215,11 +217,12 @@ export class TreeSitterParser extends BaseParser {
                     const startLine = defNode.startPosition.row + 1
                     const endLine = defNode.endPosition.row + 1
                     const nodeText = defNode.text ?? ''
+                    const count = (this.nameCounter.get(fnName) ?? 0) + 1
+                    this.nameCounter.set(fnName, count)
 
-                    // Unique ID: include start line to handle overloads and same-name scoped functions
-                    let fnId = `fn:${filePath}:${fnName}:${startLine}`
+                    // Unique ID: use stable format with counter for collisions
+                    let fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
                     if (seenFnIds.has(fnId)) {
-                        // Extremely rare duplicate — skip rather than corrupt
                         continue
                     }
                     seenFnIds.add(fnId)
@@ -269,7 +272,7 @@ export class TreeSitterParser extends BaseParser {
                     const startLine = defNode.startPosition.row + 1
                     const endLine = defNode.endPosition.row + 1
                     const nodeText = defNode.text ?? ''
-                    const clsId = `cls:${filePath}:${clsName}:${startLine}`
+                    const clsId = `class:${filePath}:${clsName}` // consistent with ts-extractor
 
                     if (!classesMap.has(clsId)) {
                         classesMap.set(clsId, {
@@ -300,7 +303,7 @@ export class TreeSitterParser extends BaseParser {
                 endLine: lineCount || 1,
                 params: [],
                 returnType: 'void',
-                isExported: true,
+                isExported: false, // Don't export the synthetic module function
                 isAsync: false,
                 calls: Array.from(new Set(unassignedCalls)),
                 hash: '',

package/src/parser/typescript/ts-extractor.ts

@@ -5,9 +5,18 @@ import { hashContent } from '../../hash/file-hasher.js'
 /**
  * TypeScript AST extractor walks the TypeScript AST using the TS Compiler API
  * and extracts functions, classes, imports, exports and call relationships.
+ *
+ * ID FORMAT: fn:<filePath>:<name> — no startLine suffix.
+ * Same-name collisions within the same file are resolved with a #2, #3 suffix.
+ * Removing startLine from the ID means:
+ *  1. graph-builder local lookup (fn:file:name) matches without extra info
+ *  2. lock-reader parseEntityKey correctly extracts name via lastIndexOf(':')
+ *  3. Incremental caching is not invalidated by line-number shifts on edits
  */
 export class TypeScriptExtractor {
     protected readonly sourceFile: ts.SourceFile
+    /** Per-file collision counter: name -> count of times seen so far */
+    private nameCounter = new Map<string, number>()
 
     constructor(
         protected readonly filePath: string,
@@ -30,6 +39,23 @@ export class TypeScriptExtractor {
         return ts.ScriptKind.TS
     }
 
+    /**
+     * Allocate a stable, collision-free function ID.
+     * First occurrence: fn:file:name
+     * Second occurrence: fn:file:name#2
+     * Third occurrence:  fn:file:name#3  … etc.
+     */
+    private allocateFnId(name: string): string {
+        const count = (this.nameCounter.get(name) ?? 0) + 1
+        this.nameCounter.set(name, count)
+        return count === 1 ? `fn:${this.filePath}:${name}` : `fn:${this.filePath}:${name}#${count}`
+    }
+
+    /** Reset the collision counter (call before each full extraction pass if reused) */
+    resetCounters(): void {
+        this.nameCounter.clear()
+    }
+
     /** Extract all top-level and variable-assigned functions */
     extractFunctions(): ParsedFunction[] {
         const functions: ParsedFunction[] = []
@@ -78,7 +104,7 @@ export class TypeScriptExtractor {
                     name: node.name.text,
                     type: 'interface',
                     file: this.filePath,
-                    startLine: this.getLineNumber(node.getStart()),
+                    startLine: this.getLineNumber(node.getStart(this.sourceFile)),
                     endLine: this.getLineNumber(node.getEnd()),
                     isExported: this.hasExportModifier(node),
                     ...(tp.length > 0 ? { typeParameters: tp } : {}),
@@ -91,7 +117,7 @@ export class TypeScriptExtractor {
                     name: node.name.text,
                     type: 'type',
                     file: this.filePath,
-                    startLine: this.getLineNumber(node.getStart()),
+                    startLine: this.getLineNumber(node.getStart(this.sourceFile)),
                     endLine: this.getLineNumber(node.getEnd()),
                     isExported: this.hasExportModifier(node),
                     ...(tp.length > 0 ? { typeParameters: tp } : {}),
@@ -106,7 +132,7 @@ export class TypeScriptExtractor {
                             name: decl.name.text,
                             type: 'const',
                             file: this.filePath,
-                            startLine: this.getLineNumber(node.getStart()),
+                            startLine: this.getLineNumber(node.getStart(this.sourceFile)),
                             endLine: this.getLineNumber(node.getEnd()),
                             isExported: this.hasExportModifier(node),
                             purpose: this.extractPurpose(node),
@@ -299,7 +325,7 @@ export class TypeScriptExtractor {
                         handler,
                         middlewares,
                         file: this.filePath,
-                        line: this.getLineNumber(node.getStart()),
+                        line: this.getLineNumber(node.getStart(this.sourceFile)),
                     })
                 }
             }
@@ -313,7 +339,8 @@ export class TypeScriptExtractor {
 
     protected parseFunctionDeclaration(node: ts.FunctionDeclaration): ParsedFunction {
         const name = node.name!.text
-        const startLine = this.getLineNumber(node.getStart())
+        const id = this.allocateFnId(name)
+        const startLine = this.getLineNumber(node.getStart(this.sourceFile))
         const endLine = this.getLineNumber(node.getEnd())
         const params = this.extractParams(node.parameters)
         const returnType = normalizeTypeAnnotation(node.type ? node.type.getText(this.sourceFile) : 'void')
@@ -324,9 +351,7 @@ export class TypeScriptExtractor {
         const bodyText = node.getText(this.sourceFile)
 
         return {
-            // Include startLine in the ID to prevent collision between overload signatures
-            // and same-named functions in different scopes (e.g. two `init` declarations).
-            id: `fn:${this.filePath}:${name}:${startLine}`,
+            id,
             name,
             file: this.filePath,
             startLine,
@@ -352,7 +377,8 @@ export class TypeScriptExtractor {
         fn: ts.ArrowFunction | ts.FunctionExpression
     ): ParsedFunction {
         const name = (decl.name as ts.Identifier).text
-        const startLine = this.getLineNumber(stmt.getStart())
+        const id = this.allocateFnId(name)
+        const startLine = this.getLineNumber(stmt.getStart(this.sourceFile))
         const endLine = this.getLineNumber(stmt.getEnd())
         const params = this.extractParams(fn.parameters)
         const returnType = normalizeTypeAnnotation(fn.type ? fn.type.getText(this.sourceFile) : 'void')
@@ -363,9 +389,7 @@ export class TypeScriptExtractor {
         const bodyText = stmt.getText(this.sourceFile)
 
         return {
-            // Include startLine to prevent collision between same-named const arrow functions
-            // at different scopes (e.g. two `handler` declarations in different blocks).
-            id: `fn:${this.filePath}:${name}:${startLine}`,
+            id,
             name,
             file: this.filePath,
             startLine,
@@ -387,7 +411,7 @@ export class TypeScriptExtractor {
 
     protected parseClass(node: ts.ClassDeclaration): ParsedClass {
         const name = node.name!.text
-        const startLine = this.getLineNumber(node.getStart())
+        const startLine = this.getLineNumber(node.getStart(this.sourceFile))
         const endLine = this.getLineNumber(node.getEnd())
         const methods: ParsedFunction[] = []
         const decorators = this.extractDecorators(node)
@@ -396,15 +420,16 @@ export class TypeScriptExtractor {
         for (const member of node.members) {
             if (ts.isConstructorDeclaration(member)) {
                 // Track class constructors as methods
-                const mStartLine = this.getLineNumber(member.getStart())
+                const mStartLine = this.getLineNumber(member.getStart(this.sourceFile))
                 const mEndLine = this.getLineNumber(member.getEnd())
                 const params = this.extractParams(member.parameters)
                 const calls = this.extractCalls(member)
                 const bodyText = member.getText(this.sourceFile)
+                const methodName = `${name}.constructor`
 
                 methods.push({
-                    id: `fn:${this.filePath}:${name}.constructor:${mStartLine}`,
-                    name: `${name}.constructor`,
+                    id: this.allocateFnId(methodName),
+                    name: methodName,
                     file: this.filePath,
                     startLine: mStartLine,
                     endLine: mEndLine,
@@ -420,8 +445,8 @@ export class TypeScriptExtractor {
                     detailedLines: this.extractDetailedLines(member),
                 })
             } else if (ts.isMethodDeclaration(member) && member.name) {
-                const methodName = member.name.getText(this.sourceFile)
-                const mStartLine = this.getLineNumber(member.getStart())
+                const methodName = `${name}.${member.name.getText(this.sourceFile)}`
+                const mStartLine = this.getLineNumber(member.getStart(this.sourceFile))
                 const mEndLine = this.getLineNumber(member.getEnd())
                 const params = this.extractParams(member.parameters)
                 const returnType = normalizeTypeAnnotation(member.type ? member.type.getText(this.sourceFile) : 'void')
@@ -432,8 +457,8 @@ export class TypeScriptExtractor {
                 const bodyText = member.getText(this.sourceFile)
 
                 methods.push({
-                    id: `fn:${this.filePath}:${name}.${methodName}:${mStartLine}`,
-                    name: `${name}.${methodName}`,
+                    id: this.allocateFnId(methodName),
+                    name: methodName,
                     file: this.filePath,
                     startLine: mStartLine,
                     endLine: mEndLine,
@@ -475,6 +500,9 @@ export class TypeScriptExtractor {
         let isDefault = false
 
         if (node.importClause) {
+            // Skip type-only imports: import type { Foo } or import type * as X
+            if (node.importClause.isTypeOnly) return null
+
             // import Foo from './module' (default import)
             if (node.importClause.name) {
                 names.push(node.importClause.name.text)
@@ -484,7 +512,10 @@ export class TypeScriptExtractor {
             if (node.importClause.namedBindings) {
                 if (ts.isNamedImports(node.importClause.namedBindings)) {
                     for (const element of node.importClause.namedBindings.elements) {
-                        names.push(element.name.text)
+                        // Skip individual type-only elements: import { type Foo }
+                        if (!element.isTypeOnly) {
+                            names.push(element.name.text)
+                        }
                     }
                 }
                 // import * as foo from './module'
@@ -494,9 +525,6 @@ export class TypeScriptExtractor {
             }
         }
 
-        // Skip type-only imports
-        if (node.importClause?.isTypeOnly) return null
-
         return {
             source,
             resolvedPath: '', // Filled in by resolver
@@ -506,9 +534,21 @@ export class TypeScriptExtractor {
         }
     }
 
-    /** Extract function/method call expressions from a node (including new Foo()) */
+    /**
+     * Extract function/method call expressions from the BODY of a node only.
+     * Deliberately skips parameter lists, decorator expressions and type annotations
+     * to avoid recording spurious calls from default-param expressions like
+     *   fn(config = getDefaultConfig())  → getDefaultConfig should NOT appear in calls
+     *
+     * Strategy: walk only the body block, not the full node subtree.
+     */
     protected extractCalls(node: ts.Node): string[] {
         const calls: string[] = []
+
+        // Determine the actual body to walk — skip params, type nodes, decorators
+        const bodyNode = getBodyNode(node)
+        if (!bodyNode) return []
+
         const walkCalls = (n: ts.Node) => {
             if (ts.isCallExpression(n)) {
                 const callee = n.expression
@@ -530,7 +570,7 @@ export class TypeScriptExtractor {
             }
             ts.forEachChild(n, walkCalls)
         }
-        ts.forEachChild(node, walkCalls)
+        ts.forEachChild(bodyNode, walkCalls)
         return [...new Set(calls)] // deduplicate
     }
 
@@ -545,9 +585,6 @@ export class TypeScriptExtractor {
                 const comment = fullText.slice(range.pos, range.end)
                 let clean = ''
                 if (comment.startsWith('/**') || comment.startsWith('/*')) {
-                    // Strip only the comment delimiters (/* ** */) NOT arbitrary slashes.
-                    // Using /[\/\*]/g was wrong — it removes slashes inside URL paths and
-                    // regex literals embedded in doc comments (e.g. "/api/users" → "apiusers").
                     clean = comment
                         .replace(/^\/\*+/, '')   // remove leading /*  or /**
                         .replace(/\*+\/$/, '')   // remove trailing */
@@ -563,7 +600,6 @@ export class TypeScriptExtractor {
                 if (clean) meaningfulLines.push(clean)
             }
 
-            // Return the first meaningful line in JSDoc, the first line is the summary.
             const fromComment = meaningfulLines.length > 0 ? meaningfulLines[0].split('\n')[0].trim() : ''
             if (fromComment) return fromComment
         }
@@ -585,7 +621,7 @@ export class TypeScriptExtractor {
         if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) return node.name.text
         if (ts.isConstructorDeclaration(node)) return 'constructor'
         if ((ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node)) && node.name) {
-            return (node as any).name.text
+            return (node as ts.InterfaceDeclaration | ts.TypeAliasDeclaration | ts.ClassDeclaration).name!.text
         }
         return ''
     }
@@ -617,14 +653,14 @@ export class TypeScriptExtractor {
         const walkErrors = (n: ts.Node) => {
             if (ts.isTryStatement(n)) {
                 errors.push({
-                    line: this.getLineNumber(n.getStart()),
+                    line: this.getLineNumber(n.getStart(this.sourceFile)),
                     type: 'try-catch',
                     detail: 'try-catch block'
                 })
             }
             if (ts.isThrowStatement(n)) {
                 errors.push({
-                    line: this.getLineNumber(n.getStart()),
+                    line: this.getLineNumber(n.getStart(this.sourceFile)),
                     type: 'throw',
                     detail: n.expression ? n.expression.getText(this.sourceFile) : 'throw error'
                 })
@@ -641,18 +677,16 @@ export class TypeScriptExtractor {
         const walkBlocks = (n: ts.Node) => {
             if (ts.isIfStatement(n) || ts.isSwitchStatement(n)) {
                 blocks.push({
-                    startLine: this.getLineNumber(n.getStart()),
+                    startLine: this.getLineNumber(n.getStart(this.sourceFile)),
                     endLine: this.getLineNumber(n.getEnd()),
                     blockType: 'ControlFlow'
                 })
             } else if (ts.isForStatement(n) || ts.isWhileStatement(n) || ts.isForOfStatement(n) || ts.isForInStatement(n)) {
                 blocks.push({
-                    startLine: this.getLineNumber(n.getStart()),
+                    startLine: this.getLineNumber(n.getStart(this.sourceFile)),
                     endLine: this.getLineNumber(n.getEnd()),
                     blockType: 'Loop'
                 })
-            } else if (ts.isVariableStatement(n) || ts.isExpressionStatement(n)) {
-                // Ignore single lines for brevity unless part of larger logical units
             }
             ts.forEachChild(n, walkBlocks)
         }
@@ -705,15 +739,45 @@ export class TypeScriptExtractor {
         return this.sourceFile.getLineAndCharacterOfPosition(pos).line + 1
     }
 
-    /** Walk the top-level children of a node (non-recursive callbacks decide depth) */
+    /**
+     * Walk ALL descendant nodes recursively (depth-first).
+     * This ensures nested functions inside if/try/namespace/module blocks are found.
+     *
+     * NOTE: The callback controls depth — returning early from the callback is NOT
+     * supported here. If you need to stop at certain depths (e.g. don't recurse
+     * into nested function bodies), handle that in the callback by checking node kind.
+     */
     protected walkNode(node: ts.Node, callback: (node: ts.Node) => void): void {
         ts.forEachChild(node, (child) => {
             callback(child)
+            this.walkNode(child, callback)
         })
     }
 }
 
-// 
+// ---------------------------------------------------------------------------
+// Module-level helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Return the body node of a function-like node to limit call extraction scope.
+ * Skips parameter lists, type annotations and decorators.
+ * Returns null for nodes with no body (abstract methods, overload signatures).
+ */
+function getBodyNode(node: ts.Node): ts.Node | null {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+        return (node as ts.FunctionLikeDeclaration).body ?? null
+    }
+    if (ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)) {
+        return (node as ts.MethodDeclaration).body ?? null
+    }
+    // For class declarations, walk members but not decorators/heritage
+    if (ts.isClassDeclaration(node)) {
+        return node
+    }
+    // For anything else (e.g. class body node) walk as-is
+    return node
+}
 
 /**
  * Derive a human-readable purpose sentence from a camelCase/PascalCase identifier.