@fairfox/polly 0.16.0 → 0.18.0

package/dist/tools/visualize/src/cli.js

@@ -39,6 +39,12 @@ class ProjectDetector {
     const packageJsonPath = path3.join(this.projectRoot, "package.json");
     if (fs3.existsSync(packageJsonPath)) {
       const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.workspaces) {
+        const monorepoConfig = this.detectMonorepo(packageJson);
+        if (monorepoConfig) {
+          return monorepoConfig;
+        }
+      }
       if (packageJson.dependencies?.electron || packageJson.devDependencies?.electron) {
         return this.detectElectron(packageJson);
       }
@@ -268,10 +274,11 @@ class ProjectDetector {
       }
     };
   }
-  scoreServerCandidates(candidates) {
+  scoreServerCandidates(candidates, baseDir) {
+    const root = baseDir || this.projectRoot;
     const scored = [];
     for (const candidate of candidates) {
-      const fullPath = path3.join(this.projectRoot, candidate);
+      const fullPath = path3.join(root, candidate);
       if (!fs3.existsSync(fullPath))
         continue;
       try {
@@ -426,6 +433,135 @@ class ProjectDetector {
     }
     return score;
   }
+  detectMonorepo(packageJson) {
+    const workspacesRaw = packageJson.workspaces;
+    const patterns = Array.isArray(workspacesRaw) ? workspacesRaw : Array.isArray(workspacesRaw?.packages) ? workspacesRaw.packages : [];
+    if (patterns.length === 0)
+      return null;
+    const workspaceDirs = this.resolveWorkspaceGlobs(patterns);
+    if (workspaceDirs.length === 0)
+      return null;
+    const entryPoints = {};
+    const contextMapping = {};
+    const workspacePackages = [];
+    for (const wsDir of workspaceDirs) {
+      const wsPkgPath = path3.join(wsDir, "package.json");
+      if (!fs3.existsSync(wsPkgPath))
+        continue;
+      let wsPkg;
+      try {
+        wsPkg = JSON.parse(fs3.readFileSync(wsPkgPath, "utf-8"));
+      } catch {
+        continue;
+      }
+      const pkgName = wsPkg.name || path3.basename(wsDir);
+      const context = this.inferContextFromPackageName(pkgName);
+      const serverCandidates = [
+        "src/server.ts",
+        "src/server.js",
+        "src/index.ts",
+        "src/index.js",
+        "src/main.ts",
+        "src/main.js",
+        "src/app.ts",
+        "src/app.js",
+        "server.ts",
+        "server.js",
+        "index.ts",
+        "index.js"
+      ];
+      const scoredServers = this.scoreServerCandidates(serverCandidates, wsDir);
+      if (scoredServers.length > 0) {
+        const best = scoredServers[0];
+        if (best) {
+          entryPoints[context] = best.path;
+          if (best.hasWebSocket) {
+            contextMapping[context] = "WebSocket Server";
+          } else if (best.hasHTTP) {
+            contextMapping[context] = "HTTP Server";
+          } else {
+            contextMapping[context] = this.capitalize(context);
+          }
+        }
+      } else {
+        const commonEntries = [
+          "src/index.ts",
+          "src/index.tsx",
+          "src/main.ts",
+          "src/main.tsx",
+          "src/app.ts",
+          "src/app.tsx",
+          "index.ts",
+          "index.tsx"
+        ];
+        for (const candidate of commonEntries) {
+          const fullPath = path3.join(wsDir, candidate);
+          if (fs3.existsSync(fullPath)) {
+            entryPoints[context] = fullPath;
+            contextMapping[context] = this.capitalize(context);
+            break;
+          }
+        }
+      }
+      workspacePackages.push({ name: pkgName, path: wsDir, context });
+    }
+    if (Object.keys(entryPoints).length === 0)
+      return null;
+    return {
+      type: "monorepo",
+      entryPoints,
+      contextMapping,
+      workspacePackages,
+      metadata: {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description
+      }
+    };
+  }
+  resolveWorkspaceGlobs(patterns) {
+    const dirs = [];
+    for (const pattern of patterns) {
+      if (pattern.includes("*")) {
+        const base = pattern.replace(/\/?\*.*$/, "");
+        const baseDir = path3.join(this.projectRoot, base);
+        if (fs3.existsSync(baseDir) && fs3.statSync(baseDir).isDirectory()) {
+          try {
+            const entries = fs3.readdirSync(baseDir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                dirs.push(path3.join(baseDir, entry.name));
+              }
+            }
+          } catch {}
+        }
+      } else {
+        const fullPath = path3.join(this.projectRoot, pattern);
+        if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isDirectory()) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+    return dirs;
+  }
+  inferContextFromPackageName(name) {
+    const parts = name.split("/");
+    const baseName = name.includes("/") ? parts[parts.length - 1] || name : name;
+    const lower = baseName.toLowerCase();
+    const serverAliases = ["api", "server", "backend"];
+    if (serverAliases.includes(lower))
+      return "server";
+    const clientAliases = ["web", "app", "frontend", "client", "ui"];
+    if (clientAliases.includes(lower))
+      return "client";
+    const sharedAliases = ["shared", "common", "lib", "core", "utils"];
+    if (sharedAliases.includes(lower))
+      return "shared";
+    return lower;
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
   detectGenericProject() {
     const entryPoints = {};
     const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
@@ -915,11 +1051,13 @@ import { Node as Node2, Project as Project2 } from "ts-morph";
 class FlowAnalyzer {
   project;
   handlers;
-  constructor(tsConfigPath, handlers) {
+  contextOverrides;
+  constructor(tsConfigPath, handlers, contextOverrides) {
     this.project = new Project2({
       tsConfigFilePath: tsConfigPath
     });
     this.handlers = handlers;
+    this.contextOverrides = contextOverrides || new Map;
   }
   analyzeFlows() {
     const flows = [];
@@ -1155,6 +1293,10 @@ class FlowAnalyzer {
     return { trigger, flowName, description };
   }
   inferContext(filePath) {
+    for (const [pathPrefix, context] of this.contextOverrides.entries()) {
+      if (filePath.startsWith(pathPrefix))
+        return context;
+    }
     const path2 = filePath.toLowerCase();
     const contextPatterns = [
       { context: "background", patterns: ["/background/", "\\background\\"] },
@@ -1585,7 +1727,8 @@ class HandlerExtractor {
   packageRoot;
   warnings;
   currentFunctionParams = [];
-  constructor(tsConfigPath) {
+  contextOverrides;
+  constructor(tsConfigPath, contextOverrides) {
     this.project = new Project3({
       tsConfigFilePath: tsConfigPath
     });
@@ -1593,6 +1736,7 @@ class HandlerExtractor {
     this.relationshipExtractor = new RelationshipExtractor;
     this.analyzedFiles = new Set;
     this.warnings = [];
+    this.contextOverrides = contextOverrides || new Map;
     this.packageRoot = this.findPackageRoot(tsConfigPath);
   }
   warnUnsupportedPattern(pattern, location, suggestion) {
@@ -1638,13 +1782,14 @@ class HandlerExtractor {
     const messageTypes = new Set;
     const invalidMessageTypes = new Set;
     const stateConstraints = [];
+    const globalStateConstraints = [];
     const verifiedStates = [];
     this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
     for (const entryPoint of entryPoints) {
-      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates);
+      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
     }
     if (verifiedStates.length > 0) {
       if (process.env["POLLY_DEBUG"]) {
@@ -1674,11 +1819,12 @@ class HandlerExtractor {
       handlers,
       messageTypes,
       stateConstraints,
+      globalStateConstraints,
       verifiedStates,
       warnings: this.warnings
     };
   }
-  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates) {
+  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
       return;
@@ -1692,6 +1838,8 @@ class HandlerExtractor {
     this.categorizeHandlerMessageTypes(fileHandlers, messageTypes, invalidMessageTypes);
     const fileConstraints = this.extractStateConstraintsFromFile(sourceFile);
     stateConstraints.push(...fileConstraints);
+    const fileGlobalConstraints = this.extractGlobalStateConstraintsFromFile(sourceFile);
+    globalStateConstraints.push(...fileGlobalConstraints);
     const fileVerifiedStates = this.extractVerifiedStatesFromFile(sourceFile);
     verifiedStates.push(...fileVerifiedStates);
     const importDeclarations = sourceFile.getImportDeclarations();
@@ -1705,7 +1853,7 @@ class HandlerExtractor {
           }
           continue;
         }
-        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates);
+        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
       } else if (process.env["POLLY_DEBUG"]) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith("node:") && !this.isNodeModuleImport(specifier)) {
@@ -1806,8 +1954,20 @@ class HandlerExtractor {
           handlers.push(handler);
         }
       }
+      if (methodName === "ws") {
+        this.extractElysiaWsHandlers(node, context, filePath, handlers);
+      }
+      if (this.isRestMethod(methodName) && this.isWebFrameworkFile(node.getSourceFile())) {
+        const restHandler = this.extractRestHandler(node, methodName, context, filePath);
+        if (restHandler) {
+          handlers.push(restHandler);
+        }
+      }
     }
   }
+  isRestMethod(name) {
+    return ["get", "post", "put", "delete", "patch"].includes(name);
+  }
   isElseIfStatement(node) {
     const parent = node.getParent();
     return parent !== undefined && Node4.isIfStatement(parent);
@@ -1873,6 +2033,135 @@ class HandlerExtractor {
       parameters
     };
   }
+  extractElysiaWsHandlers(node, context, filePath, handlers) {
+    const args = node.getArguments();
+    if (args.length < 2)
+      return;
+    const routeArg = args[0];
+    if (!routeArg || !Node4.isStringLiteral(routeArg))
+      return;
+    const routePath = routeArg.getLiteralValue();
+    const configArg = args[1];
+    if (!configArg || !Node4.isObjectLiteralExpression(configArg))
+      return;
+    const callbacks = ["message", "open", "close"];
+    for (const cbName of callbacks) {
+      const prop = configArg.getProperty(cbName);
+      if (!prop)
+        continue;
+      let funcBody = null;
+      if (Node4.isMethodDeclaration(prop)) {
+        funcBody = prop;
+      } else if (Node4.isPropertyAssignment(prop)) {
+        const init = prop.getInitializer();
+        if (init && (Node4.isArrowFunction(init) || Node4.isFunctionExpression(init))) {
+          funcBody = init;
+        }
+      }
+      if (!funcBody)
+        continue;
+      if (cbName === "message") {
+        const body = funcBody.getBody();
+        if (!body)
+          continue;
+        const subHandlers = this.extractSubHandlersFromBody(body, context, filePath);
+        if (subHandlers.length > 0) {
+          handlers.push(...subHandlers);
+        } else {
+          handlers.push(this.buildWsHandler(`ws_message`, routePath, context, filePath, funcBody, node.getStartLineNumber()));
+        }
+      } else {
+        handlers.push(this.buildWsHandler(`ws_${cbName}`, routePath, context, filePath, funcBody, node.getStartLineNumber()));
+      }
+    }
+  }
+  extractSubHandlersFromBody(body, context, filePath) {
+    const subHandlers = [];
+    body.forEachDescendant((child) => {
+      if (Node4.isIfStatement(child) && !this.isElseIfStatement(child)) {
+        const typeGuardHandlers = this.extractTypeGuardHandlers(child, context, filePath);
+        subHandlers.push(...typeGuardHandlers);
+      }
+      if (Node4.isSwitchStatement(child)) {
+        const switchHandlers = this.extractSwitchCaseHandlers(child, context, filePath);
+        subHandlers.push(...switchHandlers);
+      }
+    });
+    return subHandlers;
+  }
+  buildWsHandler(messageType, _routePath, context, filePath, funcBody, line) {
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    this.currentFunctionParams = this.extractParameterNames(funcBody);
+    this.extractAssignments(funcBody, assignments);
+    this.extractVerificationConditions(funcBody, preconditions, postconditions);
+    this.currentFunctionParams = [];
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: { file: filePath, line },
+      origin: "event"
+    };
+  }
+  extractRestHandler(node, methodName, context, filePath) {
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const routeArg = args[0];
+    if (!routeArg || !Node4.isStringLiteral(routeArg))
+      return null;
+    const routePath = routeArg.getLiteralValue();
+    const httpMethod = methodName.toUpperCase();
+    const messageType = `${httpMethod} ${routePath}`;
+    const handlerArg = args[1];
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    let actualHandler = null;
+    if (Node4.isArrowFunction(handlerArg) || Node4.isFunctionExpression(handlerArg)) {
+      actualHandler = handlerArg;
+    } else if (Node4.isIdentifier(handlerArg)) {
+      actualHandler = this.resolveFunctionReference(handlerArg);
+    }
+    let parameters;
+    if (actualHandler) {
+      this.currentFunctionParams = this.extractParameterNames(actualHandler);
+      parameters = this.currentFunctionParams.length > 0 ? [...this.currentFunctionParams] : undefined;
+      this.extractAssignments(actualHandler, assignments);
+      this.extractVerificationConditions(actualHandler, preconditions, postconditions);
+      this.currentFunctionParams = [];
+    }
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: {
+        file: filePath,
+        line: node.getStartLineNumber()
+      },
+      origin: "event",
+      parameters,
+      handlerKind: "rest",
+      httpMethod,
+      routePath
+    };
+  }
+  isWebFrameworkFile(sourceFile) {
+    const frameworks = ["elysia", "express", "hono", "fastify", "koa", "@elysiajs/eden"];
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const specifier = importDecl.getModuleSpecifierValue();
+      if (frameworks.some((fw) => specifier === fw || specifier.startsWith(`${fw}/`))) {
+        return true;
+      }
+    }
+    return false;
+  }
   extractAssignments(funcNode, assignments) {
     funcNode.forEachDescendant((node) => {
       if (Node4.isBinaryExpression(node)) {
@@ -2707,32 +2996,64 @@ class HandlerExtractor {
     try {
       const ifStmt = ifNode;
       const condition = ifStmt.getExpression();
-      if (!Node4.isCallExpression(condition)) {
-        return null;
+      if (Node4.isCallExpression(condition)) {
+        const funcExpr = condition.getExpression();
+        const funcName = Node4.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
+        this.debugLogProcessingFunction(funcName);
+        const messageType = this.resolveMessageType(funcExpr, funcName, typeGuards);
+        if (!messageType) {
+          this.debugLogUnresolvedMessageType(funcName);
+          return null;
+        }
+        const line = ifStmt.getStartLineNumber();
+        const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
+        return {
+          messageType,
+          node: context,
+          assignments: [],
+          preconditions: [],
+          postconditions: [],
+          location: { file: filePath, line },
+          relationships
+        };
       }
-      const funcExpr = condition.getExpression();
-      const funcName = Node4.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
-      this.debugLogProcessingFunction(funcName);
-      const messageType = this.resolveMessageType(funcExpr, funcName, typeGuards);
-      if (!messageType) {
-        this.debugLogUnresolvedMessageType(funcName);
-        return null;
+      if (Node4.isBinaryExpression(condition)) {
+        const messageType = this.extractMessageTypeFromEqualityCheck(condition);
+        if (messageType) {
+          const line = ifStmt.getStartLineNumber();
+          const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
+          return {
+            messageType,
+            node: context,
+            assignments: [],
+            preconditions: [],
+            postconditions: [],
+            location: { file: filePath, line },
+            relationships
+          };
+        }
       }
-      const line = ifStmt.getStartLineNumber();
-      const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
-      return {
-        messageType,
-        node: context,
-        assignments: [],
-        preconditions: [],
-        postconditions: [],
-        location: { file: filePath, line },
-        relationships
-      };
+      return null;
     } catch (_error) {
       return null;
     }
   }
+  extractMessageTypeFromEqualityCheck(expr) {
+    const operator = expr.getOperatorToken().getText();
+    if (operator !== "===" && operator !== "==")
+      return null;
+    const left = expr.getLeft();
+    const right = expr.getRight();
+    const stringLiteral = Node4.isStringLiteral(right) ? right : Node4.isStringLiteral(left) ? left : null;
+    const propAccess = Node4.isPropertyAccessExpression(left) ? left : Node4.isPropertyAccessExpression(right) ? right : null;
+    if (!stringLiteral || !propAccess)
+      return null;
+    const propName = propAccess.getName();
+    if (propName !== "type" && propName !== "kind" && propName !== "action") {
+      return null;
+    }
+    return stringLiteral.getLiteralValue();
+  }
   debugLogProcessingFunction(funcName) {
     if (process.env["POLLY_DEBUG"] && funcName) {
       console.log(`[DEBUG] Processing if condition with function: ${funcName}`);
@@ -2942,6 +3263,10 @@ class HandlerExtractor {
     return messageType;
   }
   inferContext(filePath) {
+    for (const [pathPrefix, context] of this.contextOverrides.entries()) {
+      if (filePath.startsWith(pathPrefix))
+        return context;
+    }
     const path2 = filePath.toLowerCase();
     return this.inferElectronContext(path2) || this.inferWorkerContext(path2) || this.inferServerAppContext(path2) || this.inferChromeExtensionContext(path2) || "unknown";
   }
@@ -3040,6 +3365,81 @@ class HandlerExtractor {
     });
     return constraints;
   }
+  extractGlobalStateConstraintsFromFile(sourceFile) {
+    const constraints = [];
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      const constraint = this.recognizeGlobalStateConstraint(node, filePath);
+      if (constraint) {
+        constraints.push(constraint);
+      }
+    });
+    return constraints;
+  }
+  recognizeGlobalStateConstraint(node, filePath) {
+    if (!Node4.isCallExpression(node)) {
+      return null;
+    }
+    const expression = node.getExpression();
+    if (!Node4.isIdentifier(expression)) {
+      return null;
+    }
+    const functionName = expression.getText();
+    if (functionName !== "stateConstraint") {
+      return null;
+    }
+    const args = node.getArguments();
+    if (args.length < 2) {
+      return null;
+    }
+    const nameArg = args[0];
+    if (!Node4.isStringLiteral(nameArg)) {
+      return null;
+    }
+    const name = nameArg.getLiteralValue();
+    const predicateArg = args[1];
+    if (!Node4.isArrowFunction(predicateArg)) {
+      return null;
+    }
+    const body = predicateArg.getBody();
+    let expressionText;
+    if (Node4.isBlock(body)) {
+      const returnStatement = body.getStatements().find((s) => Node4.isReturnStatement(s));
+      if (!returnStatement || !Node4.isReturnStatement(returnStatement)) {
+        return null;
+      }
+      const returnExpr = returnStatement.getExpression();
+      if (!returnExpr) {
+        return null;
+      }
+      expressionText = returnExpr.getText();
+    } else {
+      expressionText = body.getText();
+    }
+    let message;
+    if (args.length >= 3) {
+      const optionsArg = args[2];
+      if (Node4.isObjectLiteralExpression(optionsArg)) {
+        for (const prop of optionsArg.getProperties()) {
+          if (Node4.isPropertyAssignment(prop) && prop.getName() === "message") {
+            const value = prop.getInitializer();
+            if (value && Node4.isStringLiteral(value)) {
+              message = value.getLiteralValue();
+            }
+          }
+        }
+      }
+    }
+    return {
+      name,
+      expression: expressionText,
+      message,
+      location: {
+        file: filePath,
+        line: node.getStartLineNumber()
+      }
+    };
+  }
   recognizeStateConstraint(node, filePath) {
     if (!Node4.isCallExpression(node)) {
       return [];
@@ -3815,10 +4215,16 @@ class ArchitectureAnalyzer {
   }
   async analyze() {
     const { manifest, projectConfig, entryPoints, systemInfo } = await this.initializeSystemInfo();
-    const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath);
+    const contextOverrides = new Map;
+    if (projectConfig?.workspacePackages) {
+      for (const pkg of projectConfig.workspacePackages) {
+        contextOverrides.set(pkg.path, pkg.context);
+      }
+    }
+    const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath, contextOverrides.size > 0 ? contextOverrides : undefined);
     const { handlers } = handlerExtractor.extractHandlers();
     const contexts = this.analyzeContexts(entryPoints, handlers);
-    const flowAnalyzer = new FlowAnalyzer(this.options.tsConfigPath, handlers);
+    const flowAnalyzer = new FlowAnalyzer(this.options.tsConfigPath, handlers, contextOverrides.size > 0 ? contextOverrides : undefined);
     const messageFlows = flowAnalyzer.analyzeFlows();
     const integrationAnalyzer = new IntegrationAnalyzer(this.options.tsConfigPath);
     const integrations = integrationAnalyzer.analyzeIntegrations();
@@ -4150,12 +4556,16 @@ class StructurizrDSLGenerator {
       handlersByType.get(handler.messageType)?.push(handler);
     }
     for (const [messageType, handlers] of handlersByType) {
-      const componentName = this.toComponentName(messageType);
       const firstHandler = handlers[0];
       if (!firstHandler)
         continue;
+      const isRest = firstHandler.handlerKind === "rest";
+      const componentName = isRest ? messageType : this.toComponentName(messageType);
       const description = this.generateComponentDescription(messageType, firstHandler);
       const tags = this.getComponentTags(messageType, firstHandler);
+      if (isRest) {
+        tags.push("REST Endpoint");
+      }
       const properties = this.getComponentProperties(messageType, firstHandler, contextType);
       componentDefs.push({
         id: this.toId(componentName),
@@ -4987,9 +5397,12 @@ class StructurizrDSLGenerator {
       popup: "Browser Action Popup",
       devtools: "DevTools Panel",
       options: "Options Page",
-      offscreen: "Offscreen Document"
+      offscreen: "Offscreen Document",
+      server: "Server Application",
+      client: "Client Application",
+      shared: "Shared Library"
     };
-    return technologies[contextType] || "Extension Context";
+    return technologies[contextType] || "Application Context";
   }
   toComponentName(messageType) {
     return `${messageType.split("_").map((part) => this.capitalize(part.toLowerCase())).join(" ")} Handler`;
@@ -5639,4 +6052,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=E7AAE0901ACF898964756E2164756E21
+//# debugId=345DE519CB00B03D64756E2164756E21