@fairfox/polly 0.4.2 → 0.5.1

package/dist/vendor/verify/src/cli.js

@@ -723,16 +723,353 @@ import * as path3 from "node:path";
 import { Project as Project2 } from "ts-morph";
 
 // vendor/analysis/src/extract/handlers.ts
-import { Project, SyntaxKind, Node } from "ts-morph";
+import { Project, SyntaxKind as SyntaxKind2, Node as Node2 } from "ts-morph";
 
+// vendor/analysis/src/extract/relationships.ts
+import { Node } from "ts-morph";
+
+class RelationshipExtractor {
+  extractFromHandler(handlerNode, sourceFile, handlerName) {
+    const relationships = [];
+    const visited = new Set;
+    this.extractFromNode(handlerNode, sourceFile, handlerName, relationships, visited);
+    return this.deduplicateRelationships(relationships);
+  }
+  extractFromNode(node, sourceFile, handlerName, relationships, visited) {
+    node.forEachDescendant((descendant) => {
+      if (Node.isCallExpression(descendant)) {
+        const expr = descendant.getExpression();
+        if (Node.isIdentifier(expr)) {
+          const functionName = expr.getText();
+          let functionDecl = sourceFile.getFunction(functionName);
+          let targetSourceFile = sourceFile;
+          if (!functionDecl) {
+            const resolved = this.resolveImportedFunction(functionName, sourceFile);
+            if (resolved) {
+              functionDecl = resolved.functionDecl;
+              targetSourceFile = resolved.sourceFile;
+            }
+          }
+          if (functionDecl && !visited.has(functionName)) {
+            visited.add(functionName);
+            const body = functionDecl.getBody();
+            if (body) {
+              this.extractFromNode(body, targetSourceFile, handlerName, relationships, visited);
+            }
+            return;
+          }
+          if (!functionDecl) {
+            const componentFromName = this.inferComponentFromFunctionName(functionName);
+            if (componentFromName) {
+              relationships.push({
+                from: this.toComponentId(handlerName),
+                to: componentFromName,
+                description: `Calls ${functionName}()`,
+                technology: "Function Call",
+                confidence: "medium",
+                evidence: [`Function call: ${functionName}`]
+              });
+              return;
+            }
+          }
+        }
+        if (Node.isPropertyAccessExpression(expr)) {
+          const rel2 = this.extractFromPropertyAccess(expr, handlerName);
+          if (rel2) {
+            relationships.push(rel2);
+            return;
+          }
+        }
+        const rel = this.extractFromFunctionCall(descendant, handlerName, sourceFile);
+        if (rel) {
+          relationships.push(rel);
+        }
+      }
+      if (Node.isAwaitExpression(descendant)) {
+        const rel = this.extractFromDatabaseCall(descendant, handlerName);
+        if (rel) {
+          relationships.push(rel);
+        }
+      }
+      if (Node.isCallExpression(descendant) && descendant.getExpression().getText() === "fetch") {
+        const rel = this.extractFromFetchCall(descendant, handlerName);
+        if (rel) {
+          relationships.push(rel);
+        }
+      }
+    });
+  }
+  extractFromFunctionCall(callExpr, handlerName, sourceFile) {
+    const expr = callExpr.getExpression();
+    const exprText = expr.getText();
+    const skipList = [
+      "console.",
+      "JSON.",
+      "Math.",
+      "Object.",
+      "Array.",
+      "String.",
+      "Number.",
+      "Date.",
+      "Promise.",
+      "setTimeout",
+      "setInterval",
+      "clearTimeout",
+      "clearInterval"
+    ];
+    if (skipList.some((skip) => exprText.startsWith(skip))) {
+      return null;
+    }
+    let functionName = exprText;
+    let targetComponent = null;
+    if (Node.isPropertyAccessExpression(expr)) {
+      const objectExpr = expr.getExpression();
+      const objectName = objectExpr.getText();
+      const methodName = expr.getName();
+      targetComponent = this.inferComponentFromCall(objectName, methodName);
+      if (!targetComponent) {
+        return null;
+      }
+      functionName = methodName;
+    } else {
+      targetComponent = this.resolveComponentFromImport(exprText, sourceFile);
+      if (!targetComponent) {
+        return null;
+      }
+    }
+    return {
+      from: this.toComponentId(handlerName),
+      to: targetComponent,
+      description: `Calls ${functionName}()`,
+      technology: "Function Call",
+      confidence: "high",
+      evidence: [`Function call: ${exprText}`]
+    };
+  }
+  extractFromPropertyAccess(propAccess, handlerName) {
+    if (!Node.isPropertyAccessExpression(propAccess)) {
+      return null;
+    }
+    const fullChain = propAccess.getText();
+    const methodName = propAccess.getName();
+    let rootObject = propAccess.getExpression();
+    while (Node.isPropertyAccessExpression(rootObject)) {
+      rootObject = rootObject.getExpression();
+    }
+    const objectName = rootObject.getText();
+    const targetComponent = this.inferComponentFromCall(objectName, methodName);
+    if (!targetComponent) {
+      return null;
+    }
+    return {
+      from: this.toComponentId(handlerName),
+      to: targetComponent,
+      description: `Calls ${methodName}()`,
+      technology: "Function Call",
+      confidence: "high",
+      evidence: [`Property access: ${fullChain}`]
+    };
+  }
+  extractFromDatabaseCall(awaitExpr, handlerName) {
+    if (!Node.isAwaitExpression(awaitExpr)) {
+      return null;
+    }
+    const innerExpr = awaitExpr.getExpression();
+    if (!Node.isCallExpression(innerExpr)) {
+      return null;
+    }
+    const callExpr = innerExpr.getExpression().getText();
+    if (callExpr.includes("db.query") || callExpr.includes("db.execute") || callExpr.includes("db.select") || callExpr.includes("db.insert") || callExpr.includes("db.update") || callExpr.includes("db.delete")) {
+      const operation = this.inferDatabaseOperation(callExpr);
+      return {
+        from: this.toComponentId(handlerName),
+        to: "database",
+        description: operation,
+        technology: "SQL",
+        confidence: "high",
+        evidence: [`Database call: ${callExpr}`]
+      };
+    }
+    return null;
+  }
+  extractFromFetchCall(callExpr, handlerName) {
+    const args = callExpr.getArguments();
+    if (args.length === 0) {
+      return null;
+    }
+    const urlArg = args[0].getText();
+    let apiName = "external_api";
+    if (urlArg.includes("openai")) {
+      apiName = "openai_api";
+    } else if (urlArg.includes("anthropic")) {
+      apiName = "anthropic_api";
+    }
+    return {
+      from: this.toComponentId(handlerName),
+      to: apiName,
+      description: "Calls external API",
+      technology: "HTTP/REST",
+      confidence: "high",
+      evidence: [`fetch() call to: ${urlArg}`]
+    };
+  }
+  inferComponentFromCall(objectName, methodName) {
+    const mappings = {
+      db: "db_client",
+      database: "database",
+      repos: "repositories",
+      repository: "repositories",
+      repositories: "repositories",
+      cache: "cache",
+      storage: "storage",
+      ai: "ai_service",
+      auth: "auth_service",
+      authservice: "auth_service",
+      user: "user_service",
+      userservice: "user_service",
+      logger: "logger",
+      queue: "queue_service"
+    };
+    const normalized = objectName.toLowerCase();
+    return mappings[normalized] || null;
+  }
+  inferComponentFromFunctionName(functionName) {
+    const normalized = functionName.toLowerCase();
+    if (normalized.startsWith("get") || normalized.startsWith("create")) {
+      const suffix = functionName.substring(normalized.startsWith("get") ? 3 : 6);
+      const suffixLower = suffix.toLowerCase();
+      if (suffixLower.includes("database") || suffixLower === "db" || suffixLower.includes("dbconnection") || suffixLower.includes("connection")) {
+        return "db_client";
+      }
+      if (suffixLower.includes("repositories") || suffixLower.includes("repos") || suffixLower.includes("repository")) {
+        return "repositories";
+      }
+      if (suffixLower.includes("service")) {
+        const serviceMatch = suffix.match(/^(.+?)Service/i);
+        if (serviceMatch) {
+          return this.toComponentId(`${serviceMatch[1]}_service`);
+        }
+        return "service";
+      }
+      if (suffixLower.includes("cache")) {
+        return "cache";
+      }
+      if (suffixLower.includes("storage")) {
+        return "storage";
+      }
+      if (suffixLower.includes("ai") || suffixLower.includes("llm")) {
+        return "ai_service";
+      }
+      if (suffixLower.includes("logger")) {
+        return "logger";
+      }
+    }
+    if (normalized.startsWith("init") || normalized.startsWith("setup")) {
+      const suffix = functionName.substring(normalized.startsWith("init") ? 4 : 5);
+      const suffixLower = suffix.toLowerCase();
+      if (suffixLower.includes("database") || suffixLower === "db") {
+        return "db_client";
+      }
+      if (suffixLower.includes("cache")) {
+        return "cache";
+      }
+    }
+    return null;
+  }
+  resolveComponentFromImport(functionName, sourceFile) {
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const namedImports = importDecl.getNamedImports();
+      for (const namedImport of namedImports) {
+        if (namedImport.getName() === functionName) {
+          const modulePath = importDecl.getModuleSpecifierValue();
+          if (modulePath.includes("/db/") || modulePath.includes("/database/")) {
+            return "db_client";
+          }
+          if (modulePath.includes("/repos") || modulePath.includes("/repositories")) {
+            return "repositories";
+          }
+          if (modulePath.includes("/service") || modulePath.includes("/services")) {
+            const match = modulePath.match(/\/([^/]+)\.ts$/);
+            if (match) {
+              return this.toComponentId(match[1]);
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  resolveImportedFunction(functionName, sourceFile) {
+    try {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const namedImports = importDecl.getNamedImports();
+        for (const namedImport of namedImports) {
+          if (namedImport.getName() === functionName) {
+            const moduleSpecifier = importDecl.getModuleSpecifierSourceFile();
+            if (!moduleSpecifier)
+              continue;
+            const functionDecl = moduleSpecifier.getFunction(functionName);
+            if (functionDecl) {
+              return {
+                functionDecl,
+                sourceFile: moduleSpecifier
+              };
+            }
+            const variableDecl = moduleSpecifier.getVariableDeclaration(functionName);
+            if (variableDecl) {
+              const initializer = variableDecl.getInitializer();
+              if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
+                return {
+                  functionDecl: initializer,
+                  sourceFile: moduleSpecifier
+                };
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      return null;
+    }
+    return null;
+  }
+  inferDatabaseOperation(callExpr) {
+    if (callExpr.includes("query") || callExpr.includes("select")) {
+      return "Reads from database";
+    }
+    if (callExpr.includes("execute") || callExpr.includes("insert") || callExpr.includes("update") || callExpr.includes("delete")) {
+      return "Writes to database";
+    }
+    return "Accesses database";
+  }
+  toComponentId(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  }
+  deduplicateRelationships(relationships) {
+    const seen = new Set;
+    const unique = [];
+    for (const rel of relationships) {
+      const key = `${rel.from}->${rel.to}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(rel);
+      }
+    }
+    return unique;
+  }
+}
+
+// vendor/analysis/src/extract/handlers.ts
 class HandlerExtractor {
   project;
   typeGuardCache;
+  relationshipExtractor;
   constructor(tsConfigPath) {
     this.project = new Project({
       tsConfigFilePath: tsConfigPath
     });
     this.typeGuardCache = new WeakMap;
+    this.relationshipExtractor = new RelationshipExtractor;
   }
   extractHandlers() {
     const handlers = [];
@@ -766,9 +1103,9 @@ class HandlerExtractor {
     const filePath = sourceFile.getFilePath();
     const context = this.inferContext(filePath);
     sourceFile.forEachDescendant((node) => {
-      if (Node.isCallExpression(node)) {
+      if (Node2.isCallExpression(node)) {
         const expression = node.getExpression();
-        if (Node.isPropertyAccessExpression(expression)) {
+        if (Node2.isPropertyAccessExpression(expression)) {
           const methodName = expression.getName();
           if (methodName === "on" || methodName === "addEventListener") {
             const handler = this.extractHandler(node, context, filePath);
@@ -778,17 +1115,17 @@ class HandlerExtractor {
           }
         }
       }
-      if (Node.isSwitchStatement(node)) {
+      if (Node2.isSwitchStatement(node)) {
         const switchHandlers = this.extractSwitchCaseHandlers(node, context, filePath);
         handlers.push(...switchHandlers);
       }
-      if (Node.isVariableDeclaration(node)) {
+      if (Node2.isVariableDeclaration(node)) {
         const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
         handlers.push(...mapHandlers);
       }
-      if (Node.isIfStatement(node)) {
+      if (Node2.isIfStatement(node)) {
         const parent = node.getParent();
-        const isElseIf = parent && Node.isIfStatement(parent);
+        const isElseIf = parent && Node2.isIfStatement(parent);
         if (!isElseIf) {
           const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
           handlers.push(...typeGuardHandlers);
@@ -804,9 +1141,9 @@ class HandlerExtractor {
     }
     const messageTypeArg = args[0];
     let messageType = null;
-    if (Node.isStringLiteral(messageTypeArg)) {
+    if (Node2.isStringLiteral(messageTypeArg)) {
       messageType = messageTypeArg.getLiteralValue();
-    } else if (Node.isTemplateExpression(messageTypeArg)) {
+    } else if (Node2.isTemplateExpression(messageTypeArg)) {
       messageType = messageTypeArg.getText().replace(/[`'"]/g, "");
     }
     if (!messageType) {
@@ -816,11 +1153,20 @@ class HandlerExtractor {
     const assignments = [];
     const preconditions = [];
     const postconditions = [];
-    if (Node.isArrowFunction(handlerArg) || Node.isFunctionExpression(handlerArg)) {
+    if (Node2.isArrowFunction(handlerArg) || Node2.isFunctionExpression(handlerArg)) {
       this.extractAssignments(handlerArg, assignments);
       this.extractVerificationConditions(handlerArg, preconditions, postconditions);
     }
     const line = callExpr.getStartLineNumber();
+    const sourceFile = callExpr.getSourceFile();
+    const handlerName = `${messageType}_handler`;
+    let relationships = undefined;
+    if (Node2.isArrowFunction(handlerArg) || Node2.isFunctionExpression(handlerArg)) {
+      const detectedRelationships = this.relationshipExtractor.extractFromHandler(handlerArg, sourceFile, handlerName);
+      if (detectedRelationships.length > 0) {
+        relationships = detectedRelationships;
+      }
+    }
     return {
       messageType,
       node: context,
@@ -830,17 +1176,18 @@ class HandlerExtractor {
       location: {
         file: filePath,
         line
-      }
+      },
+      relationships
     };
   }
   extractAssignments(funcNode, assignments) {
     funcNode.forEachDescendant((node) => {
-      if (Node.isBinaryExpression(node)) {
+      if (Node2.isBinaryExpression(node)) {
         const operator = node.getOperatorToken().getText();
         if (operator === "=") {
           const left = node.getLeft();
           const right = node.getRight();
-          if (Node.isPropertyAccessExpression(left)) {
+          if (Node2.isPropertyAccessExpression(left)) {
             const fieldPath = this.getPropertyPath(left);
             if (fieldPath.startsWith("state.")) {
               const field = fieldPath.substring(6);
@@ -859,13 +1206,13 @@ class HandlerExtractor {
   }
   extractVerificationConditions(funcNode, preconditions, postconditions) {
     const body = funcNode.getBody();
-    const statements = Node.isBlock(body) ? body.getStatements() : [body];
+    const statements = Node2.isBlock(body) ? body.getStatements() : [body];
     statements.forEach((statement, index) => {
-      if (Node.isExpressionStatement(statement)) {
+      if (Node2.isExpressionStatement(statement)) {
         const expr = statement.getExpression();
-        if (Node.isCallExpression(expr)) {
+        if (Node2.isCallExpression(expr)) {
           const callee = expr.getExpression();
-          if (Node.isIdentifier(callee)) {
+          if (Node2.isIdentifier(callee)) {
             const functionName = callee.getText();
             if (functionName === "requires") {
               const condition = this.extractCondition(expr);
@@ -891,7 +1238,7 @@ class HandlerExtractor {
     const conditionArg = args[0];
     const expression = conditionArg.getText();
     let message;
-    if (args.length >= 2 && Node.isStringLiteral(args[1])) {
+    if (args.length >= 2 && Node2.isStringLiteral(args[1])) {
       message = args[1].getLiteralValue();
     }
     const line = callExpr.getStartLineNumber();
@@ -908,29 +1255,29 @@ class HandlerExtractor {
   getPropertyPath(node) {
     const parts = [];
     let current = node;
-    while (Node.isPropertyAccessExpression(current)) {
+    while (Node2.isPropertyAccessExpression(current)) {
       parts.unshift(current.getName());
       current = current.getExpression();
     }
-    if (Node.isIdentifier(current)) {
+    if (Node2.isIdentifier(current)) {
       parts.unshift(current.getText());
     }
     return parts.join(".");
   }
   extractValue(node) {
-    if (Node.isStringLiteral(node)) {
+    if (Node2.isStringLiteral(node)) {
       return node.getLiteralValue();
     }
-    if (Node.isNumericLiteral(node)) {
+    if (Node2.isNumericLiteral(node)) {
       return node.getLiteralValue();
     }
-    if (node.getKind() === SyntaxKind.TrueKeyword) {
+    if (node.getKind() === SyntaxKind2.TrueKeyword) {
       return true;
     }
-    if (node.getKind() === SyntaxKind.FalseKeyword) {
+    if (node.getKind() === SyntaxKind2.FalseKeyword) {
       return false;
     }
-    if (node.getKind() === SyntaxKind.NullKeyword) {
+    if (node.getKind() === SyntaxKind2.NullKeyword) {
       return null;
     }
     return;
@@ -945,10 +1292,10 @@ class HandlerExtractor {
       }
       const caseClauses = switchNode.getClauses();
       for (const clause of caseClauses) {
-        if (Node.isCaseClause(clause)) {
+        if (Node2.isCaseClause(clause)) {
           const caseExpr = clause.getExpression();
           let messageType = null;
-          if (Node.isStringLiteral(caseExpr)) {
+          if (Node2.isStringLiteral(caseExpr)) {
             messageType = caseExpr.getLiteralValue();
           }
           if (messageType) {
@@ -971,7 +1318,7 @@ class HandlerExtractor {
     const handlers = [];
     try {
       const initializer = varDecl.getInitializer();
-      if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+      if (!initializer || !Node2.isObjectLiteralExpression(initializer)) {
         return handlers;
       }
       const varName = varDecl.getName().toLowerCase();
@@ -980,12 +1327,12 @@ class HandlerExtractor {
       }
       const properties = initializer.getProperties();
       for (const prop of properties) {
-        if (Node.isPropertyAssignment(prop)) {
+        if (Node2.isPropertyAssignment(prop)) {
           const nameNode = prop.getNameNode();
           let messageType = null;
-          if (Node.isStringLiteral(nameNode)) {
+          if (Node2.isStringLiteral(nameNode)) {
             messageType = nameNode.getLiteralValue();
-          } else if (Node.isIdentifier(nameNode)) {
+          } else if (Node2.isIdentifier(nameNode)) {
             messageType = nameNode.getText();
           }
           if (messageType) {
@@ -1032,7 +1379,7 @@ class HandlerExtractor {
           }
         }
         const elseStatement = currentIf.getElseStatement();
-        if (elseStatement && Node.isIfStatement(elseStatement)) {
+        if (elseStatement && Node2.isIfStatement(elseStatement)) {
           currentIf = elseStatement;
         } else {
           break;
@@ -1048,12 +1395,12 @@ class HandlerExtractor {
   extractHandlerFromIfClause(ifNode, typeGuards, context, filePath) {
     try {
       const condition = ifNode.getExpression();
-      if (!Node.isCallExpression(condition)) {
+      if (!Node2.isCallExpression(condition)) {
         return null;
       }
       const funcExpr = condition.getExpression();
       let funcName;
-      if (Node.isIdentifier(funcExpr)) {
+      if (Node2.isIdentifier(funcExpr)) {
         funcName = funcExpr.getText();
       }
       if (process.env.POLLY_DEBUG && funcName) {
@@ -1065,7 +1412,7 @@ class HandlerExtractor {
         if (process.env.POLLY_DEBUG) {
           console.log(`[DEBUG] Found in local type guards: ${funcName} → ${messageType}`);
         }
-      } else if (Node.isIdentifier(funcExpr)) {
+      } else if (Node2.isIdentifier(funcExpr)) {
         if (process.env.POLLY_DEBUG) {
           console.log(`[DEBUG] Not found locally, trying import resolution for: ${funcName}`);
         }
@@ -1078,13 +1425,24 @@ class HandlerExtractor {
         return null;
       }
       const line = ifNode.getStartLineNumber();
+      const sourceFile = ifNode.getSourceFile();
+      const handlerName = `${messageType}_handler`;
+      let relationships = undefined;
+      const thenStatement = ifNode.getThenStatement();
+      if (thenStatement) {
+        const detectedRelationships = this.relationshipExtractor.extractFromHandler(thenStatement, sourceFile, handlerName);
+        if (detectedRelationships.length > 0) {
+          relationships = detectedRelationships;
+        }
+      }
       return {
         messageType,
         node: context,
         assignments: [],
         preconditions: [],
         postconditions: [],
-        location: { file: filePath, line }
+        location: { file: filePath, line },
+        relationships
       };
     } catch (error) {
       return null;
@@ -1093,20 +1451,20 @@ class HandlerExtractor {
   findTypePredicateFunctions(sourceFile) {
     const typeGuards = new Map;
     sourceFile.forEachDescendant((node) => {
-      if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+      if (Node2.isFunctionDeclaration(node) || Node2.isFunctionExpression(node) || Node2.isArrowFunction(node)) {
         const returnTypeNode = node.getReturnTypeNode();
-        if (returnTypeNode && Node.isTypePredicate(returnTypeNode)) {
+        if (returnTypeNode && Node2.isTypePredicate(returnTypeNode)) {
           let functionName;
-          if (Node.isFunctionDeclaration(node)) {
+          if (Node2.isFunctionDeclaration(node)) {
             functionName = node.getName();
-          } else if (Node.isFunctionExpression(node)) {
+          } else if (Node2.isFunctionExpression(node)) {
             const parent = node.getParent();
-            if (Node.isVariableDeclaration(parent)) {
+            if (Node2.isVariableDeclaration(parent)) {
               functionName = parent.getName();
             }
-          } else if (Node.isArrowFunction(node)) {
+          } else if (Node2.isArrowFunction(node)) {
             const parent = node.getParent();
-            if (Node.isVariableDeclaration(parent)) {
+            if (Node2.isVariableDeclaration(parent)) {
               functionName = parent.getName();
             }
           }
@@ -1147,15 +1505,15 @@ class HandlerExtractor {
         return null;
       }
       for (const def of definitions) {
-        if (Node.isFunctionDeclaration(def) || Node.isFunctionExpression(def) || Node.isArrowFunction(def)) {
+        if (Node2.isFunctionDeclaration(def) || Node2.isFunctionExpression(def) || Node2.isArrowFunction(def)) {
           const returnTypeNode = def.getReturnTypeNode();
           if (process.env.POLLY_DEBUG) {
             const returnType = def.getReturnType().getText();
             console.log(`[DEBUG] Function ${funcName} return type (resolved): ${returnType}`);
             console.log(`[DEBUG] Has return type node: ${!!returnTypeNode}`);
-            console.log(`[DEBUG] Is type predicate node: ${returnTypeNode && Node.isTypePredicate(returnTypeNode)}`);
+            console.log(`[DEBUG] Is type predicate node: ${returnTypeNode && Node2.isTypePredicate(returnTypeNode)}`);
           }
-          if (returnTypeNode && Node.isTypePredicate(returnTypeNode)) {
+          if (returnTypeNode && Node2.isTypePredicate(returnTypeNode)) {
             const typeNode = returnTypeNode.getTypeNode();
             if (typeNode) {
               const typeName = typeNode.getText();
@@ -2385,4 +2743,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=EE34F5E282168E7C64756E2164756E21
+//# debugId=C40ED4F55177D0FC64756E2164756E21