fix(core): address code review — WASM cleanup, type coverage accuracy

- Fix Query object WASM leak: call q.delete() in finally after matches()
- Fix type coverage ratio inflation: add arrow-total and function-total
  queries for accurate denominator (was counting only typed functions)
- Fix try/catch-alone classification: fall through to regex instead of
  mapping to 'throw' style (try-catch is a mechanism, not a style)
- Add comment explaining AST/regex import count asymmetry

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: prosdev

packages/core/src/pattern-matcher/rules.ts

@@ -90,6 +90,18 @@ export const TYPE_COVERAGE_QUERIES: PatternMatchRule[] = [
     category: 'type-coverage',
     query: '(function_declaration return_type: (type_annotation)) @match',
   },
+  {
+    // Count ALL arrow functions (typed or not) for accurate denominator
+    id: 'arrow-total',
+    category: 'type-coverage',
+    query: '(arrow_function) @match',
+  },
+  {
+    // Count ALL function declarations (typed or not) for accurate denominator
+    id: 'function-total',
+    category: 'type-coverage',
+    query: '(function_declaration) @match',
+  },
 ];
 
 // ============================================================================

packages/core/src/scanner/tree-sitter.ts

@@ -365,13 +365,16 @@ export async function runQueries(
 
     const QueryCls = QueryClass;
     for (const { id, query: queryString } of queries) {
+      let q: InstanceType<typeof QueryCls> | null = null;
       try {
-        const q = new QueryCls(lang, queryString);
+        q = new QueryCls(lang, queryString);
         const matches = q.matches(tree.rootNode);
         results.set(id, matches.length);
       } catch {
         // Invalid query — skip, return 0 for this rule
         results.set(id, 0);
+      } finally {
+        q?.delete();
       }
     }
   } catch {

packages/core/src/services/pattern-analysis-service.ts

@@ -152,8 +152,8 @@ export async function extractErrorHandlingWithAst(
   }
   if (hasThrow) return { style: 'throw', examples: [] };
   if (hasResultRegex) return regex; // AST can't detect Result<T>, keep regex
-  if (hasTryCatch || hasPromiseCatch) return { style: 'throw', examples: [] };
-
+  // try-catch or promise.catch alone is a mechanism, not a style —
+  // fall through to regex which may have found throw/Result in content
   return regex;
 }
 
@@ -174,7 +174,9 @@ export async function extractImportStyleWithAst(
   const reExports = ast.get('re-export') ?? 0;
   const requires = ast.get('require') ?? 0;
 
-  // Dynamic imports count as ESM
+  // AST affects style classification but not importCount — importCount only adds
+  // genuinely new detections (dynamic imports) that regex missed. AST require
+  // matches overlap with regex require matches so they don't inflate the count.
   const esmCount =
     (regex.style === 'esm' || regex.style === 'mixed' ? regex.importCount : 0) +
     dynamicImports +
@@ -206,11 +208,14 @@ export async function extractTypeCoverageWithAst(
 
   const arrowTyped = ast.get('arrow-return-type') ?? 0;
   const functionTyped = ast.get('function-return-type') ?? 0;
+  const arrowTotal = ast.get('arrow-total') ?? 0;
+  const functionTotal = ast.get('function-total') ?? 0;
   const astAnnotated = arrowTyped + functionTyped;
+  const astTotal = arrowTotal + functionTotal;
 
-  // Merge: use the higher count (AST catches arrows that signatures miss)
+  // Merge: use the higher of AST total vs regex total for accurate denominator
   const annotatedCount = Math.max(regex.annotatedCount, astAnnotated);
-  const totalCount = Math.max(regex.totalCount, astAnnotated); // at least as many as annotated
+  const totalCount = Math.max(regex.totalCount, astTotal);
 
   if (totalCount === 0) return regex;