@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/ast/handlers/ThrowHandler.ts

@@ -0,0 +1,101 @@
+/**
+ * ThrowHandler — handles ThrowStatement nodes.
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~3908-3985.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class ThrowHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      // Phase 6 (REG-267): Track throw statements for control flow metadata
+      // REG-311: Detect async_throw rejection patterns
+      // REG-286: Detect sync_throw patterns for ALL functions (THROWS edges)
+      ThrowStatement: (throwPath: NodePath<t.ThrowStatement>) => {
+        // Skip if this throw is inside a nested function (not the function we're analyzing)
+        let parent: NodePath | null = throwPath.parentPath;
+        while (parent) {
+          if (t.isFunction(parent.node) && parent.node !== ctx.funcNode) {
+            // This throw is inside a nested function - skip it
+            return;
+          }
+          parent = parent.parentPath;
+        }
+
+        ctx.controlFlowState.hasThrow = true;
+
+        // REG-286: Track throw patterns for ALL functions (sync and async)
+        // Async throws -> REJECTS edges, sync throws -> THROWS edges
+        const isAsyncFunction = ctx.functionNode?.async === true;
+        if (ctx.currentFunctionId && ctx.functionNode && ctx.functionPath) {
+          const throwNode = throwPath.node;
+          const arg = throwNode.argument;
+          const throwLine = getLine(throwNode);
+          const throwColumn = getColumn(throwNode);
+
+          // Case 1: throw new Error() or throw new CustomError()
+          if (arg && t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+            ctx.rejectionPatterns.push({
+              functionId: ctx.currentFunctionId,
+              errorClassName: arg.callee.name,
+              rejectionType: isAsyncFunction ? 'async_throw' : 'sync_throw',
+              isAsync: isAsyncFunction,
+              file: ctx.module.file,
+              line: throwLine,
+              column: throwColumn
+            });
+          }
+          // Case 2: throw identifier - needs micro-trace
+          else if (arg && t.isIdentifier(arg)) {
+            const varName = arg.name;
+
+            // Check if it's a parameter
+            const isParameter = ctx.functionNode.params.some(param =>
+              t.isIdentifier(param) && param.name === varName
+            );
+
+            if (isParameter) {
+              // Parameter forwarding - can't resolve statically
+              ctx.rejectionPatterns.push({
+                functionId: ctx.currentFunctionId,
+                errorClassName: null,
+                rejectionType: 'variable_parameter',
+                isAsync: isAsyncFunction,
+                file: ctx.module.file,
+                line: throwLine,
+                column: throwColumn,
+                sourceVariableName: varName
+              });
+            } else {
+              // Try micro-trace
+              const { errorClassName, tracePath } = analyzer.microTraceToErrorClass(
+                varName,
+                ctx.functionPath,
+                ctx.variableDeclarations
+              );
+
+              ctx.rejectionPatterns.push({
+                functionId: ctx.currentFunctionId,
+                errorClassName,
+                rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                isAsync: isAsyncFunction,
+                file: ctx.module.file,
+                line: throwLine,
+                column: throwColumn,
+                sourceVariableName: varName,
+                tracePath
+              });
+            }
+          }
+        }
+      },
+    };
+  }
+}

package/src/plugins/analysis/ast/handlers/TryCatchHandler.ts

@@ -0,0 +1,262 @@
+/**
+ * TryCatchHandler -- handles try/catch/finally control flow nodes.
+ *
+ * Inlines the createTryStatementHandler and createCatchClauseHandler logic
+ * from JSASTAnalyzer (REG-422).
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class TryCatchHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    return {
+      TryStatement: this.createTryStatementVisitor(),
+      CatchClause: this.createCatchClauseVisitor(),
+    };
+  }
+
+  private createTryStatementVisitor(): {
+    enter: (tryPath: NodePath<t.TryStatement>) => void;
+    exit: (tryPath: NodePath<t.TryStatement>) => void;
+  } {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      enter: (tryPath: NodePath<t.TryStatement>) => {
+        const tryNode = tryPath.node;
+
+        // Phase 6 (REG-267): Mark that this function has try/catch
+        if (ctx.controlFlowState) {
+          ctx.controlFlowState.hasTryCatch = true;
+          // REG-311: Increment try block depth for O(1) isInsideTry detection
+          ctx.controlFlowState.tryBlockDepth++;
+        }
+
+        // Determine actual parent - use stack for nested structures, otherwise original parentScopeId
+        const actualParentScopeId = (ctx.scopeIdStack && ctx.scopeIdStack.length > 0)
+          ? ctx.scopeIdStack[ctx.scopeIdStack.length - 1]
+          : ctx.parentScopeId;
+
+        // 1. Create TRY_BLOCK node
+        const tryBlockCounter = ctx.tryBlockCounterRef.value++;
+        const legacyTryBlockId = `${ctx.module.file}:TRY_BLOCK:${getLine(tryNode)}:${tryBlockCounter}`;
+        const tryBlockId = ctx.scopeTracker
+          ? computeSemanticId('TRY_BLOCK', 'try', ctx.scopeTracker.getContext(), { discriminator: tryBlockCounter })
+          : legacyTryBlockId;
+
+        ctx.tryBlocks.push({
+          id: tryBlockId,
+          semanticId: tryBlockId,
+          type: 'TRY_BLOCK',
+          file: ctx.module.file,
+          line: getLine(tryNode),
+          column: getColumn(tryNode),
+          parentScopeId: actualParentScopeId
+        });
+
+        // 2. Create try-body SCOPE (backward compatibility)
+        // Parent is now TRY_BLOCK, not original parentScopeId
+        const tryScopeId = `SCOPE#try-block#${ctx.module.file}#${getLine(tryNode)}:${ctx.scopeCounterRef.value++}`;
+        const trySemanticId = analyzer.generateSemanticId('try-block', ctx.scopeTracker);
+        ctx.scopes.push({
+          id: tryScopeId,
+          type: 'SCOPE',
+          scopeType: 'try-block',
+          semanticId: trySemanticId,
+          file: ctx.module.file,
+          line: getLine(tryNode),
+          parentScopeId: tryBlockId  // Parent is TRY_BLOCK
+        });
+
+        // 3. Create CATCH_BLOCK and catch-body SCOPE if handler exists
+        let catchBlockId: string | null = null;
+        let catchScopeId: string | null = null;
+        if (tryNode.handler) {
+          const catchClause = tryNode.handler;
+          const catchBlockCounter = ctx.catchBlockCounterRef.value++;
+          const legacyCatchBlockId = `${ctx.module.file}:CATCH_BLOCK:${getLine(catchClause)}:${catchBlockCounter}`;
+          catchBlockId = ctx.scopeTracker
+            ? computeSemanticId('CATCH_BLOCK', 'catch', ctx.scopeTracker.getContext(), { discriminator: catchBlockCounter })
+            : legacyCatchBlockId;
+
+          // Extract parameter name if present
+          let parameterName: string | undefined;
+          if (catchClause.param && t.isIdentifier(catchClause.param)) {
+            parameterName = catchClause.param.name;
+          }
+
+          ctx.catchBlocks.push({
+            id: catchBlockId,
+            semanticId: catchBlockId,
+            type: 'CATCH_BLOCK',
+            file: ctx.module.file,
+            line: getLine(catchClause),
+            column: getColumn(catchClause),
+            parentScopeId: ctx.parentScopeId,
+            parentTryBlockId: tryBlockId,
+            parameterName
+          });
+
+          // Create catch-body SCOPE (backward compatibility)
+          catchScopeId = `SCOPE#catch-block#${ctx.module.file}#${getLine(catchClause)}:${ctx.scopeCounterRef.value++}`;
+          const catchSemanticId = analyzer.generateSemanticId('catch-block', ctx.scopeTracker);
+          ctx.scopes.push({
+            id: catchScopeId,
+            type: 'SCOPE',
+            scopeType: 'catch-block',
+            semanticId: catchSemanticId,
+            file: ctx.module.file,
+            line: getLine(catchClause),
+            parentScopeId: catchBlockId  // Parent is CATCH_BLOCK
+          });
+        }
+
+        // 4. Create FINALLY_BLOCK and finally-body SCOPE if finalizer exists
+        let finallyBlockId: string | null = null;
+        let finallyScopeId: string | null = null;
+        if (tryNode.finalizer) {
+          const finallyBlockCounter = ctx.finallyBlockCounterRef.value++;
+          const legacyFinallyBlockId = `${ctx.module.file}:FINALLY_BLOCK:${getLine(tryNode.finalizer)}:${finallyBlockCounter}`;
+          finallyBlockId = ctx.scopeTracker
+            ? computeSemanticId('FINALLY_BLOCK', 'finally', ctx.scopeTracker.getContext(), { discriminator: finallyBlockCounter })
+            : legacyFinallyBlockId;
+
+          ctx.finallyBlocks.push({
+            id: finallyBlockId,
+            semanticId: finallyBlockId,
+            type: 'FINALLY_BLOCK',
+            file: ctx.module.file,
+            line: getLine(tryNode.finalizer),
+            column: getColumn(tryNode.finalizer),
+            parentScopeId: ctx.parentScopeId,
+            parentTryBlockId: tryBlockId
+          });
+
+          // Create finally-body SCOPE (backward compatibility)
+          finallyScopeId = `SCOPE#finally-block#${ctx.module.file}#${getLine(tryNode.finalizer)}:${ctx.scopeCounterRef.value++}`;
+          const finallySemanticId = analyzer.generateSemanticId('finally-block', ctx.scopeTracker);
+          ctx.scopes.push({
+            id: finallyScopeId,
+            type: 'SCOPE',
+            scopeType: 'finally-block',
+            semanticId: finallySemanticId,
+            file: ctx.module.file,
+            line: getLine(tryNode.finalizer),
+            parentScopeId: finallyBlockId  // Parent is FINALLY_BLOCK
+          });
+        }
+
+        // 5. Push try scope onto stack for CONTAINS edges
+        if (ctx.scopeIdStack) {
+          ctx.scopeIdStack.push(tryScopeId);
+        }
+
+        // Enter try scope for semantic ID generation
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.enterCountedScope('try');
+        }
+
+        // 6. Store scope info for catch/finally transitions
+        ctx.tryScopeMap.set(tryNode, {
+          tryScopeId,
+          catchScopeId,
+          finallyScopeId,
+          currentBlock: 'try',
+          tryBlockId,
+          catchBlockId,
+          finallyBlockId
+        });
+      },
+      exit: (tryPath: NodePath<t.TryStatement>) => {
+        const tryNode = tryPath.node;
+        const _scopeInfo = ctx.tryScopeMap.get(tryNode);
+
+        // REG-311: Only decrement try block depth if we're still in 'try' block
+        // (not transitioned to catch/finally, where we already decremented)
+        if (ctx.controlFlowState && _scopeInfo?.currentBlock === 'try') {
+          ctx.controlFlowState.tryBlockDepth--;
+        }
+
+        // Pop the current scope from stack (could be try, catch, or finally)
+        if (ctx.scopeIdStack) {
+          ctx.scopeIdStack.pop();
+        }
+
+        // Exit the current scope
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.exitScope();
+        }
+
+        // Clean up
+        ctx.tryScopeMap.delete(tryNode);
+      }
+    };
+  }
+
+  private createCatchClauseVisitor(): {
+    enter: (catchPath: NodePath<t.CatchClause>) => void;
+  } {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      enter: (catchPath: NodePath<t.CatchClause>) => {
+        const catchNode = catchPath.node;
+        const parent = catchPath.parent;
+
+        if (!t.isTryStatement(parent)) return;
+
+        const scopeInfo = ctx.tryScopeMap.get(parent);
+        if (!scopeInfo || !scopeInfo.catchScopeId) return;
+
+        // Transition from try scope to catch scope
+        if (scopeInfo.currentBlock === 'try') {
+          // Pop try scope, push catch scope
+          if (ctx.scopeIdStack) {
+            ctx.scopeIdStack.pop();
+            ctx.scopeIdStack.push(scopeInfo.catchScopeId);
+          }
+
+          // Exit try scope, enter catch scope for semantic ID
+          if (ctx.scopeTracker) {
+            ctx.scopeTracker.exitScope();
+            ctx.scopeTracker.enterCountedScope('catch');
+          }
+
+          // REG-311: Decrement tryBlockDepth when leaving try block for catch
+          // Calls in catch block should NOT have isInsideTry=true
+          if (ctx.controlFlowState) {
+            ctx.controlFlowState.tryBlockDepth--;
+          }
+
+          scopeInfo.currentBlock = 'catch';
+        }
+
+        // Handle catch parameter (e.g., catch (e) or catch ({ message }))
+        if (catchNode.param) {
+          const errorVarInfo = analyzer.extractVariableNamesFromPattern(catchNode.param);
+
+          errorVarInfo.forEach(varInfo => {
+            const legacyId = `VARIABLE#${varInfo.name}#${ctx.module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${ctx.varDeclCounterRef.value++}`;
+            const varId = ctx.scopeTracker
+              ? computeSemanticId('VARIABLE', varInfo.name, ctx.scopeTracker.getContext())
+              : legacyId;
+
+            ctx.variableDeclarations.push({
+              id: varId,
+              type: 'VARIABLE',
+              name: varInfo.name,
+              file: ctx.module.file,
+              line: varInfo.loc.start.line,
+              parentScopeId: scopeInfo.catchScopeId!
+            });
+          });
+        }
+      }
+    };
+  }
+}

package/src/plugins/analysis/ast/handlers/VariableHandler.ts

@@ -0,0 +1,93 @@
+/**
+ * VariableHandler — handles VariableDeclaration and AssignmentExpression nodes.
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~3765-3833.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type {
+  ArrayMutationInfo,
+  ObjectMutationInfo,
+  VariableReassignmentInfo,
+} from '../types.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class VariableHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
+        analyzer.handleVariableDeclaration(
+          varPath,
+          ctx.getCurrentScopeId(),
+          ctx.module,
+          ctx.variableDeclarations,
+          ctx.classInstantiations,
+          ctx.literals,
+          ctx.variableAssignments,
+          ctx.varDeclCounterRef,
+          ctx.literalCounterRef,
+          ctx.scopeTracker,
+          ctx.parentScopeVariables,
+          ctx.objectLiterals,
+          ctx.objectProperties,
+          ctx.objectLiteralCounterRef
+        );
+
+        // REG-416: Track parameter aliases for HOF detection
+        // When `const f = fn` where fn is a parameter, map f -> param index.
+        if (ctx.paramNameToIndex.size > 0) {
+          for (const declarator of varPath.node.declarations) {
+            if (t.isIdentifier(declarator.id) && t.isIdentifier(declarator.init)) {
+              const initName = declarator.init.name;
+              const paramIndex = ctx.paramNameToIndex.get(initName) ?? ctx.aliasToParamIndex.get(initName);
+              if (paramIndex !== undefined) {
+                ctx.aliasToParamIndex.set(declarator.id.name, paramIndex);
+              }
+            }
+          }
+        }
+      },
+
+      // Detect indexed array assignments: arr[i] = value
+      AssignmentExpression: (assignPath: NodePath<t.AssignmentExpression>) => {
+        const assignNode = assignPath.node;
+
+        // === VARIABLE REASSIGNMENT (REG-290) ===
+        // Check if LHS is simple identifier (not obj.prop, not arr[i])
+        // Must be checked FIRST before array/object mutation handlers
+        if (assignNode.left.type === 'Identifier') {
+          // Initialize collection if not exists
+          if (!ctx.collections.variableReassignments) {
+            ctx.collections.variableReassignments = [];
+          }
+          const variableReassignments = ctx.collections.variableReassignments as VariableReassignmentInfo[];
+
+          analyzer.detectVariableReassignment(assignNode, ctx.module, variableReassignments, ctx.scopeTracker);
+        }
+        // === END VARIABLE REASSIGNMENT ===
+
+        // Initialize collection if not exists
+        if (!ctx.collections.arrayMutations) {
+          ctx.collections.arrayMutations = [];
+        }
+        const arrayMutations = ctx.collections.arrayMutations as ArrayMutationInfo[];
+
+        // Check for indexed array assignment: arr[i] = value
+        analyzer.detectIndexedArrayAssignment(assignNode, ctx.module, arrayMutations, ctx.scopeTracker, ctx.collections);
+
+        // Initialize object mutations collection if not exists
+        if (!ctx.collections.objectMutations) {
+          ctx.collections.objectMutations = [];
+        }
+        const objectMutations = ctx.collections.objectMutations as ObjectMutationInfo[];
+
+        // Check for object property assignment: obj.prop = value
+        analyzer.detectObjectPropertyAssignment(assignNode, ctx.module, objectMutations, ctx.scopeTracker);
+      },
+    };
+  }
+}

package/src/plugins/analysis/ast/handlers/index.ts

@@ -0,0 +1,12 @@
+export type { AnalyzerDelegate } from './AnalyzerDelegate.js';
+export { FunctionBodyHandler } from './FunctionBodyHandler.js';
+export { ReturnYieldHandler } from './ReturnYieldHandler.js';
+export { ThrowHandler } from './ThrowHandler.js';
+export { VariableHandler } from './VariableHandler.js';
+export { NestedFunctionHandler } from './NestedFunctionHandler.js';
+export { PropertyAccessHandler } from './PropertyAccessHandler.js';
+export { NewExpressionHandler } from './NewExpressionHandler.js';
+export { CallExpressionHandler } from './CallExpressionHandler.js';
+export { LoopHandler } from './LoopHandler.js';
+export { TryCatchHandler } from './TryCatchHandler.js';
+export { BranchHandler } from './BranchHandler.js';

package/src/plugins/analysis/ast/types.ts

@@ -31,10 +31,17 @@ export interface FunctionInfo {
   isCallback?: boolean;
   parentScopeId?: string;
   controlFlow?: ControlFlowMetadata;
+  // Class method fields (set by ClassVisitor)
+  isClassMethod?: boolean;
+  className?: string;
   // REG-271: Private methods support
   isPrivate?: boolean;   // true for #privateMethod
   isStatic?: boolean;    // true for static #method()
   methodKind?: 'constructor' | 'method' | 'get' | 'set';
+  // REG-401: Parameter invocation tracking for user-defined HOFs
+  invokesParamIndexes?: number[];
+  // REG-417: Destructured parameter invocation — property paths for OBJECT_LITERAL resolution
+  invokesParamBindings?: { paramIndex: number; propertyPath: string[] }[];
 }
 
 // === PARAMETER INFO ===
@@ -50,6 +57,10 @@ export interface ParameterInfo {
   isRest?: boolean;      // Rest parameter (e.g., function(...args))
   functionId?: string;   // Legacy field - prefer parentFunctionId
   parentFunctionId?: string;
+  scopePath?: string[];
+  // REG-399: Destructuring metadata
+  propertyPath?: string[];  // For nested object destructuring: ['data', 'user'] for ({ data: { user } })
+  arrayIndex?: number;      // For array destructuring: 0 for first element in ([first, second])
 }
 
 // === SCOPE INFO ===
@@ -197,6 +208,8 @@ export interface ControlFlowMetadata {
   canReject?: boolean;         // True if function can reject (has rejection patterns)
   hasAsyncThrow?: boolean;     // True if async function has throw statements
   rejectedBuiltinErrors?: string[];  // List of builtin error class names this function can reject
+  // REG-286: Sync throw tracking
+  thrownBuiltinErrors?: string[];    // List of builtin error class names this function can throw
 }
 
 // === VARIABLE DECLARATION INFO ===
@@ -210,6 +223,7 @@ export interface VariableDeclarationInfo {
   column?: number;
   value?: unknown;
   parentScopeId?: string;
+  scopePath?: string[];
   // REG-271: Private fields support
   isPrivate?: boolean;      // true for #privateField
   isStatic?: boolean;       // true for static #field
@@ -261,6 +275,8 @@ export interface CallSiteInfo {
   isAwaited?: boolean;
   /** REG-311: true if inside try block (protected from propagation) */
   isInsideTry?: boolean;
+  /** REG-298: true if awaited call is inside a loop body */
+  isInsideLoop?: boolean;
 }
 
 // === METHOD CALL INFO ===
@@ -285,6 +301,8 @@ export interface MethodCallInfo {
   isAwaited?: boolean;
   /** REG-311: true if inside try block (protected from propagation) */
   isInsideTry?: boolean;
+  /** REG-298: true if awaited call is inside a loop body */
+  isInsideLoop?: boolean;
   /** REG-311: true if this is a method call (for CALL node filtering) */
   isMethodCall?: boolean;
 }
@@ -377,6 +395,18 @@ export interface TypeAliasInfo {
   line: number;
   column?: number;
   aliasOf?: string;  // строковое представление типа
+  mappedType?: boolean;
+  keyName?: string;
+  keyConstraint?: string;
+  valueType?: string;
+  mappedReadonly?: boolean | '+' | '-';
+  mappedOptional?: boolean | '+' | '-';
+  nameType?: string;
+  conditionalType?: boolean;
+  checkType?: string;
+  extendsType?: string;
+  trueType?: string;
+  falseType?: string;
 }
 
 // === ENUM DECLARATION INFO ===
@@ -415,6 +445,19 @@ export interface DecoratorInfo {
   targetType: 'CLASS' | 'METHOD' | 'PROPERTY' | 'PARAMETER';
 }
 
+// === TYPE PARAMETER INFO ===
+export interface TypeParameterInfo {
+  name: string;              // "T", "K", "V"
+  constraintType?: string;   // "Serializable" (string repr via typeNodeToString)
+  defaultType?: string;      // "string" (string repr via typeNodeToString)
+  variance?: 'in' | 'out' | 'in out';
+  parentId: string;          // ID of owning function/class/interface/type
+  parentType: 'FUNCTION' | 'CLASS' | 'INTERFACE' | 'TYPE';
+  file: string;
+  line: number;
+  column: number;
+}
+
 // === METHOD CALLBACK INFO ===
 export interface MethodCallbackInfo {
   methodCallId: string;
@@ -442,6 +485,10 @@ export interface CallArgumentInfo {
   functionColumn?: number;
   nestedCallLine?: number;
   nestedCallColumn?: number;
+  // REG-402: MemberExpression argument fields for this.method callback resolution
+  objectName?: string;
+  propertyName?: string;
+  enclosingClassName?: string;
 }
 
 // === IMPORT INFO ===
@@ -967,18 +1014,23 @@ export interface PromiseResolutionInfo {
   line: number;
 }
 
-// === REJECTION PATTERN INFO (REG-311) ===
+// === REJECTION PATTERN INFO (REG-311, REG-286) ===
 /**
- * Tracks patterns that can cause Promise rejection in a function.
- * Used for REJECTS edge creation and error flow analysis.
+ * Tracks patterns that can cause errors (throws or Promise rejections) in a function.
+ * Used for THROWS/REJECTS edge creation and error flow analysis.
  *
  * Patterns detected:
  * - promise_reject: Promise.reject(new Error())
  * - executor_reject: reject(new Error()) in Promise executor
  * - async_throw: throw new Error() in async function
- * - variable_traced: reject(err) where err traced to NewExpression
- * - variable_parameter: reject(param) where param is function parameter
- * - variable_unknown: reject(x) where x couldn't be traced
+ * - sync_throw: throw new Error() in non-async function (REG-286)
+ * - variable_traced: throw/reject(err) where err traced to NewExpression
+ * - variable_parameter: throw/reject(param) where param is function parameter
+ * - variable_unknown: throw/reject(x) where x couldn't be traced
+ *
+ * Edge type selection:
+ * - isAsync=true patterns → REJECTS edge (async errors caught by .catch())
+ * - isAsync=false patterns → THROWS edge (sync errors caught by try/catch)
  */
 export interface RejectionPatternInfo {
   /** ID of the containing FUNCTION node */
@@ -990,9 +1042,12 @@ export interface RejectionPatternInfo {
     | 'promise_reject'     // Promise.reject(new Error())
     | 'executor_reject'    // reject(new Error()) in Promise executor
     | 'async_throw'        // throw new Error() in async function
-    | 'variable_traced'    // reject(err) where err traced to NewExpression
-    | 'variable_parameter' // reject(param) where param is function parameter
-    | 'variable_unknown';  // reject(x) where x couldn't be traced
+    | 'sync_throw'         // throw new Error() in non-async function (REG-286)
+    | 'variable_traced'    // throw/reject(err) where err traced to NewExpression
+    | 'variable_parameter' // throw/reject(param) where param is function parameter
+    | 'variable_unknown';  // throw/reject(x) where x couldn't be traced
+  /** Whether the containing function is async (determines THROWS vs REJECTS edge) */
+  isAsync: boolean;
   /** File path */
   file: string;
   /** Line number of rejection call */
@@ -1105,11 +1160,15 @@ export interface ASTCollections {
   catchesFromInfos?: CatchesFromInfo[];
   // Property access tracking for PROPERTY_ACCESS nodes (REG-395)
   propertyAccesses?: PropertyAccessInfo[];
+  // REG-297: Top-level await tracking
+  hasTopLevelAwait?: boolean;
   // TypeScript-specific collections
   interfaces?: InterfaceDeclarationInfo[];
   typeAliases?: TypeAliasInfo[];
   enums?: EnumDeclarationInfo[];
   decorators?: DecoratorInfo[];
+  // Type parameter tracking for generics (REG-303)
+  typeParameters?: TypeParameterInfo[];
   // Counter refs (used internally during collection)
   ifScopeCounterRef?: CounterRef;
   scopeCounterRef?: CounterRef;