@stripe/extensibility-eslint-plugin 0.15.6 → 0.17.1

package/dist/index.js

@@ -3268,7 +3268,7 @@ var require_RuleCreator = __commonJS({
     exports.RuleCreator = RuleCreator;
     var applyDefault_1 = require_applyDefault();
     function RuleCreator(urlCreator) {
-      return function createNamedRule({ meta: meta2, name, ...rule19 }) {
+      return function createNamedRule({ meta: meta2, name, ...rule20 }) {
         const ruleWithDocs = createRule23({
           meta: {
             ...meta2,
@@ -3278,7 +3278,7 @@ var require_RuleCreator = __commonJS({
             }
           },
           name,
-          ...rule19
+          ...rule20
         });
         return ruleWithDocs;
       };
@@ -35887,9 +35887,73 @@ var customObjectRules = {
 };
 
 // src/internal/analysis/eslint/module-scope.ts
+var TO_CONST_MODULE = "@stripe/extensibility-sdk";
+var KNOWN_GLOBAL_PRIMITIVES = /* @__PURE__ */ new Set(["undefined", "Infinity", "NaN"]);
+var COMPARISON_OPERATORS = /* @__PURE__ */ new Set([
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "in",
+  "instanceof"
+]);
+var ARITHMETIC_OPERATORS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "**",
+  "|",
+  "&",
+  "^",
+  "<<",
+  ">>",
+  ">>>"
+]);
+function isIdentifier10(node) {
+  return isNodeLike(node) && node.type === "Identifier";
+}
+function isNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function isTransparentExpressionLike(node) {
+  return (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression") && "expression" in node;
+}
+function isTemplateLiteralLike(node) {
+  return node.type === "TemplateLiteral" && "expressions" in node && Array.isArray(node.expressions);
+}
+function isUnaryExpressionLike(node) {
+  return node.type === "UnaryExpression" && "operator" in node && typeof node.operator === "string" && "argument" in node;
+}
+function isBinaryExpressionLike(node) {
+  return node.type === "BinaryExpression" && "operator" in node && typeof node.operator === "string" && "left" in node && "right" in node;
+}
+function isLogicalExpressionLike(node) {
+  return node.type === "LogicalExpression" && "left" in node && "right" in node;
+}
+function isConditionalExpressionLike(node) {
+  return node.type === "ConditionalExpression" && "consequent" in node && "alternate" in node;
+}
+function isSequenceExpressionLike(node) {
+  return node.type === "SequenceExpression" && "expressions" in node && Array.isArray(node.expressions);
+}
+function isMemberExpressionLike2(node) {
+  return node.type === "MemberExpression" && "object" in node && "property" in node && "computed" in node && typeof node.computed === "boolean";
+}
 function isTopLevelExport(node) {
   return node?.type === "ExportNamedDeclaration" && node.parent?.type === "Program";
 }
+function isProgramLike2(value) {
+  return isNodeLike(value) && value.type === "Program" && "body" in value && Array.isArray(value.body);
+}
+function isCallExpressionLike2(node) {
+  return node?.type === "CallExpression" && "callee" in node && isNodeLike(node.callee);
+}
 function isVarScopeBoundary(node) {
   return node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression" || node?.type === "StaticBlock";
 }
@@ -35924,6 +35988,290 @@ function isModuleScopedVariableKind(node, kind) {
   }
   return kind === "var" ? isVarHoistedToModuleScope(node) : isModuleScopedVariableDeclaration(node);
 }
+function unwrapTransparentExpression(node) {
+  if (!isNodeLike(node)) {
+    return void 0;
+  }
+  if (isTransparentExpressionLike(node)) {
+    return unwrapTransparentExpression(node.expression);
+  }
+  return node;
+}
+function isPrimitiveLiteral(node) {
+  return node.type === "Literal" && "value" in node && (node.value === null || typeof node.value === "string" || typeof node.value === "number" || typeof node.value === "boolean" || typeof node.value === "bigint");
+}
+function isScopeReferenceToIdentifier(scope, node) {
+  let current = scope;
+  while (current) {
+    for (const reference of current.references ?? []) {
+      if (reference.identifier === node) {
+        return reference;
+      }
+    }
+    for (const reference of current.through ?? []) {
+      if (reference.identifier === node) {
+        return reference;
+      }
+    }
+    current = current.upper ?? void 0;
+  }
+  return void 0;
+}
+function isKnownGlobalPrimitiveIdentifier(sourceCode, node) {
+  if (!KNOWN_GLOBAL_PRIMITIVES.has(node.name)) {
+    return false;
+  }
+  const reference = isScopeReferenceToIdentifier(sourceCode.getScope(node), node);
+  if (!reference) {
+    return false;
+  }
+  return !reference.resolved || (reference.resolved.defs?.length ?? 0) === 0;
+}
+function isPrimitiveValueExpression(sourceCode, node) {
+  const expression = unwrapTransparentExpression(node);
+  if (!expression) {
+    return false;
+  }
+  if (isPrimitiveLiteral(expression)) {
+    return true;
+  }
+  if (isIdentifier10(expression)) {
+    return isKnownGlobalPrimitiveIdentifier(sourceCode, expression);
+  }
+  if (isTemplateLiteralLike(expression)) {
+    return expression.expressions.every(
+      (part) => isPrimitiveValueExpression(sourceCode, part)
+    );
+  }
+  if (isUnaryExpressionLike(expression)) {
+    if (expression.operator === "void" || expression.operator === "typeof" || expression.operator === "!") {
+      return true;
+    }
+    return (expression.operator === "+" || expression.operator === "-" || expression.operator === "~") && isPrimitiveValueExpression(sourceCode, expression.argument);
+  }
+  if (isBinaryExpressionLike(expression)) {
+    if (COMPARISON_OPERATORS.has(expression.operator)) {
+      return true;
+    }
+    return ARITHMETIC_OPERATORS.has(expression.operator) && isPrimitiveValueExpression(sourceCode, expression.left) && isPrimitiveValueExpression(sourceCode, expression.right);
+  }
+  if (isLogicalExpressionLike(expression)) {
+    return isPrimitiveValueExpression(sourceCode, expression.left) && isPrimitiveValueExpression(sourceCode, expression.right);
+  }
+  if (isConditionalExpressionLike(expression)) {
+    return isPrimitiveValueExpression(sourceCode, expression.consequent) && isPrimitiveValueExpression(sourceCode, expression.alternate);
+  }
+  if (isSequenceExpressionLike(expression)) {
+    const finalExpression = expression.expressions.at(-1);
+    return isPrimitiveValueExpression(sourceCode, finalExpression);
+  }
+  return false;
+}
+function isImportDeclarationLike2(node) {
+  return node.type === "ImportDeclaration";
+}
+function isRuntimeImportDeclaration(node) {
+  return node.importKind !== "type";
+}
+function isToConstNamedSpecifier(specifier) {
+  return specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && isIdentifier10(specifier.imported) && specifier.imported.name === "toConst" && isIdentifier10(specifier.local);
+}
+function getToConstNamedLocalName(specifier) {
+  return isToConstNamedSpecifier(specifier) ? specifier.local?.name : void 0;
+}
+function createToConstImportAnalysis(namedLocalNames, namespaceLocalNames, importToAugment) {
+  return importToAugment ? {
+    namedLocalNames,
+    namespaceLocalNames,
+    importToAugment
+  } : {
+    namedLocalNames,
+    namespaceLocalNames
+  };
+}
+function analyzeToConstImports(program) {
+  const namedLocalNames = /* @__PURE__ */ new Set();
+  const namespaceLocalNames = /* @__PURE__ */ new Set();
+  let importToAugment;
+  if (!isProgramLike2(program)) {
+    return createToConstImportAnalysis(namedLocalNames, namespaceLocalNames);
+  }
+  for (const statement of program.body) {
+    if (!isImportDeclarationLike2(statement)) {
+      continue;
+    }
+    if (statement.source.value !== TO_CONST_MODULE) {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === "ImportNamespaceSpecifier" && isRuntimeImportDeclaration(statement) && isIdentifier10(specifier.local)) {
+        namespaceLocalNames.add(specifier.local.name);
+      }
+      const toConstLocalName = getToConstNamedLocalName(specifier);
+      if (toConstLocalName) {
+        namedLocalNames.add(toConstLocalName);
+      }
+    }
+    if (!importToAugment && isRuntimeImportDeclaration(statement) && !statement.specifiers.some(
+      (specifier) => specifier.type === "ImportNamespaceSpecifier"
+    )) {
+      importToAugment = statement;
+    }
+  }
+  return createToConstImportAnalysis(
+    namedLocalNames,
+    namespaceLocalNames,
+    importToAugment
+  );
+}
+function isToConstMemberAccess(callee, namespaceLocalNames) {
+  if (!isMemberExpressionLike2(callee) || !isNodeLike(callee.object) || !isIdentifier10(callee.object) || !namespaceLocalNames.has(callee.object.name)) {
+    return false;
+  }
+  return callee.computed ? isLiteralLike(callee.property) && callee.property.value === "toConst" : isNodeLike(callee.property) && isIdentifier10(callee.property) && callee.property.name === "toConst";
+}
+function isLiteralLike(node) {
+  return isNodeLike(node) && node.type === "Literal";
+}
+function isCanonicalToConstCall(node, analysis) {
+  const expression = unwrapTransparentExpression(node);
+  if (!expression || !isCallExpressionLike2(expression)) {
+    return false;
+  }
+  if (isIdentifier10(expression.callee) && analysis.namedLocalNames.has(expression.callee.name)) {
+    return true;
+  }
+  return isToConstMemberAccess(expression.callee, analysis.namespaceLocalNames);
+}
+function isFixableMutableConst(node) {
+  const expression = unwrapTransparentExpression(node);
+  return expression?.type === "ObjectExpression" || expression?.type === "ArrayExpression";
+}
+function classifyModuleScopedConstInitializer(sourceCode, node, analysis) {
+  if (isPrimitiveValueExpression(sourceCode, node)) {
+    return "primitive";
+  }
+  if (isCanonicalToConstCall(node, analysis)) {
+    return "wrapped-to-const";
+  }
+  if (isFixableMutableConst(node)) {
+    return "fixable-mutable-literal";
+  }
+  return "other";
+}
+function getModuleScopeBindingNames(sourceCode) {
+  const bindingNames = /* @__PURE__ */ new Set();
+  if (!isProgramLike2(sourceCode.ast)) {
+    return bindingNames;
+  }
+  for (const statement of sourceCode.ast.body) {
+    collectModuleScopeBindingNames(statement, bindingNames);
+  }
+  return bindingNames;
+}
+function collectModuleScopeBindingNames(node, bindingNames) {
+  if (!isNodeLike(node)) {
+    return;
+  }
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+    if ("declaration" in node) {
+      collectModuleScopeBindingNames(node.declaration, bindingNames);
+    }
+    return;
+  }
+  if (node.type === "ImportDeclaration" && "specifiers" in node && Array.isArray(node.specifiers)) {
+    for (const specifier of node.specifiers) {
+      const local = isNodeLike(specifier) && "local" in specifier ? specifier.local : void 0;
+      if (isIdentifier10(local)) {
+        bindingNames.add(local.name);
+      }
+    }
+    return;
+  }
+  if (node.type === "VariableDeclaration" && "declarations" in node && Array.isArray(node.declarations)) {
+    for (const declaration of node.declarations) {
+      if (isNodeLike(declaration) && "id" in declaration) {
+        collectPatternBindingNames(declaration.id, bindingNames);
+      }
+    }
+    return;
+  }
+  if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") {
+    const declarationId = "id" in node ? node.id : void 0;
+    if (isIdentifier10(declarationId)) {
+      bindingNames.add(declarationId.name);
+    }
+  }
+}
+function collectPatternBindingNames(node, bindingNames) {
+  if (!node || !isNodeLike(node)) {
+    return;
+  }
+  if (isIdentifier10(node)) {
+    bindingNames.add(node.name);
+    return;
+  }
+  if (node.type === "RestElement" && "argument" in node) {
+    collectPatternBindingNames(node.argument, bindingNames);
+    return;
+  }
+  if (node.type === "AssignmentPattern" && "left" in node) {
+    collectPatternBindingNames(node.left, bindingNames);
+    return;
+  }
+  if (node.type === "ArrayPattern" && "elements" in node && Array.isArray(node.elements)) {
+    for (const element of node.elements) {
+      collectPatternBindingNames(element, bindingNames);
+    }
+    return;
+  }
+  if (node.type === "ObjectPattern" && "properties" in node && Array.isArray(node.properties)) {
+    for (const property of node.properties) {
+      if (!isNodeLike(property)) {
+        continue;
+      }
+      if (property.type === "Property" && "value" in property) {
+        collectPatternBindingNames(property.value, bindingNames);
+        continue;
+      }
+      if (property.type === "RestElement" && "argument" in property) {
+        collectPatternBindingNames(property.argument, bindingNames);
+      }
+    }
+  }
+}
+function getUniqueBindingName(bindingNames, preferredName) {
+  if (!bindingNames.has(preferredName)) {
+    return preferredName;
+  }
+  let suffix = 1;
+  let candidate = `${preferredName}${String(suffix)}`;
+  while (bindingNames.has(candidate)) {
+    suffix += 1;
+    candidate = `${preferredName}${String(suffix)}`;
+  }
+  return candidate;
+}
+function getToConstImportLocalName(sourceCode, analysis) {
+  if (analysis.namedLocalNames.size > 0 || analysis.namespaceLocalNames.size > 0) {
+    return void 0;
+  }
+  return getUniqueBindingName(getModuleScopeBindingNames(sourceCode), "toConst");
+}
+function getToConstCallText(analysis) {
+  const [namespaceName] = analysis.namespaceLocalNames;
+  if (namespaceName) {
+    return `${namespaceName}.toConst`;
+  }
+  const [localName] = analysis.namedLocalNames;
+  return localName ?? "toConst";
+}
+function getRuntimeImportStatements(program) {
+  if (!isProgramLike2(program)) {
+    return [];
+  }
+  return program.body.filter(isImportDeclarationLike2);
+}
 
 // src/dsl-rules/no-module-scoped-let.ts
 function isAmbientDeclaration(node) {
@@ -35959,11 +36307,165 @@ var rule8 = {
 };
 var no_module_scoped_let_default = rule8;
 
-// src/dsl-rules/no-module-scoped-var.ts
+// src/dsl-rules/no-module-scoped-mutable-const.ts
 function isAmbientDeclaration2(node) {
   return "declare" in node && node.declare;
 }
+function isSourceCodeLike(value) {
+  return typeof value === "object" && value !== null && "ast" in value && "getText" in value && typeof value.getText === "function" && "getScope" in value && typeof value.getScope === "function";
+}
+function isVariableDeclaratorLike(node) {
+  return typeof node === "object" && node !== null && "type" in node && node.type === "VariableDeclarator";
+}
+function getVariableDeclarators(node) {
+  if (!("declarations" in node) || !Array.isArray(node.declarations)) {
+    return [];
+  }
+  return node.declarations.filter(isVariableDeclaratorLike);
+}
+function hasRange(value) {
+  return typeof value === "object" && value !== null && "range" in value && Array.isArray(value.range) && value.range.length === 2 && typeof value.range[0] === "number" && typeof value.range[1] === "number";
+}
+function buildToConstImportFix(fixer, sourceCode, analysis, localName) {
+  const importSpecifier = localName === "toConst" ? "toConst" : `toConst as ${localName}`;
+  const runtimeImports = getRuntimeImportStatements(sourceCode.ast);
+  const importToAugment = analysis.importToAugment;
+  if (importToAugment) {
+    const namedSpecifiers = importToAugment.specifiers.filter(
+      (specifier) => specifier.type === "ImportSpecifier"
+    );
+    if (namedSpecifiers.length > 0) {
+      const lastNamedSpecifier = namedSpecifiers.at(-1);
+      if (lastNamedSpecifier && hasRange(lastNamedSpecifier)) {
+        return fixer.insertTextAfterRange(
+          [lastNamedSpecifier.range[0], lastNamedSpecifier.range[1]],
+          `, ${importSpecifier}`
+        );
+      }
+    }
+    const defaultSpecifier = importToAugment.specifiers.find(
+      (specifier) => specifier.type === "ImportDefaultSpecifier"
+    );
+    if (defaultSpecifier && hasRange(defaultSpecifier)) {
+      return fixer.insertTextAfterRange(
+        [defaultSpecifier.range[0], defaultSpecifier.range[1]],
+        `, { ${importSpecifier} }`
+      );
+    }
+  }
+  const importStatement = `import { ${importSpecifier} } from '${TO_CONST_MODULE}';
+`;
+  const lastImport = runtimeImports.at(-1);
+  if (lastImport && hasRange(lastImport)) {
+    return fixer.insertTextAfterRange(
+      [lastImport.range[0], lastImport.range[1]],
+      `
+${importStatement}`
+    );
+  }
+  if (isProgramLike2(sourceCode.ast)) {
+    const firstStatement = sourceCode.ast.body[0];
+    if (firstStatement && hasRange(firstStatement)) {
+      return fixer.insertTextBeforeRange(
+        [firstStatement.range[0], firstStatement.range[0]],
+        importStatement
+      );
+    }
+  }
+  return fixer.insertTextAfterRange([0, 0], importStatement);
+}
 var rule9 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require module-scoped mutable const values in runtime DSL author source files to use the canonical toConst helper."
+    },
+    schema: [],
+    fixable: "code",
+    messages: {
+      noModuleScopedMutableConst: "Module-scoped non-primitive `const` values must use `toConst(...)` so they are deeply immutable across invocations.",
+      noModuleScopedMutableConstNoFix: "Module-scoped non-primitive `const` values must use `toConst(...)` or be refactored away from module scope."
+    }
+  },
+  create(context) {
+    const filename = context.filename;
+    if (filename.endsWith(".d.ts") || !isRuntimeDslAuthorSourceFile(filename)) {
+      return {};
+    }
+    const sourceCode = context.sourceCode;
+    if (!isSourceCodeLike(sourceCode)) {
+      return {};
+    }
+    const analysis = analyzeToConstImports(sourceCode.ast);
+    const toConstImportLocalName = getToConstImportLocalName(sourceCode, analysis);
+    const toConstCallText = toConstImportLocalName ?? getToConstCallText(analysis);
+    return {
+      VariableDeclaration(node) {
+        if (isAmbientDeclaration2(node) || !isModuleScopedVariableKind(node, "const")) {
+          return;
+        }
+        for (const declarator of getVariableDeclarators(node)) {
+          const init = declarator.init;
+          if (!init) {
+            continue;
+          }
+          const initializerKind = classifyModuleScopedConstInitializer(
+            sourceCode,
+            init,
+            analysis
+          );
+          if (initializerKind === "primitive" || initializerKind === "wrapped-to-const") {
+            continue;
+          }
+          if (initializerKind === "fixable-mutable-literal") {
+            context.report({
+              node: declarator,
+              messageId: "noModuleScopedMutableConst",
+              fix(fixer) {
+                if (!hasRange(init)) {
+                  return null;
+                }
+                const initializerText = context.sourceCode.text.slice(
+                  init.range[0],
+                  init.range[1]
+                );
+                const fixes = [
+                  fixer.replaceTextRange(
+                    [init.range[0], init.range[1]],
+                    `${toConstCallText}(${initializerText})`
+                  )
+                ];
+                if (toConstImportLocalName) {
+                  fixes.push(
+                    buildToConstImportFix(
+                      fixer,
+                      sourceCode,
+                      analysis,
+                      toConstImportLocalName
+                    )
+                  );
+                }
+                return fixes;
+              }
+            });
+            continue;
+          }
+          context.report({
+            node: declarator,
+            messageId: "noModuleScopedMutableConstNoFix"
+          });
+        }
+      }
+    };
+  }
+};
+var no_module_scoped_mutable_const_default = rule9;
+
+// src/dsl-rules/no-module-scoped-var.ts
+function isAmbientDeclaration3(node) {
+  return "declare" in node && node.declare;
+}
+var rule10 = {
   meta: {
     type: "problem",
     docs: {
@@ -35981,7 +36483,7 @@ var rule9 = {
     }
     return {
       VariableDeclaration(node) {
-        if (!isAmbientDeclaration2(node) && isModuleScopedVariableKind(node, "var")) {
+        if (!isAmbientDeclaration3(node) && isModuleScopedVariableKind(node, "var")) {
           context.report({
             node,
             messageId: "noModuleScopedVar"
@@ -35991,7 +36493,7 @@ var rule9 = {
     };
   }
 };
-var no_module_scoped_var_default = rule9;
+var no_module_scoped_var_default = rule10;
 
 // src/dsl-rules/no-non-public-instance-fields.ts
 import ts29 from "typescript";
@@ -36054,7 +36556,7 @@ function getRuntimeManagedClassNode(checker, sourceFile, fileName) {
   }
   return void 0;
 }
-var rule10 = {
+var rule11 = {
   meta: {
     type: "problem",
     docs: {
@@ -36096,11 +36598,12 @@ var rule10 = {
     };
   }
 };
-var no_non_public_instance_fields_default = rule10;
+var no_non_public_instance_fields_default = rule11;
 
 // src/dsl-rules/index.ts
 var dslRules = {
   "no-module-scoped-let": no_module_scoped_let_default,
+  "no-module-scoped-mutable-const": no_module_scoped_mutable_const_default,
   "no-module-scoped-var": no_module_scoped_var_default,
   "no-non-public-instance-fields": no_non_public_instance_fields_default
 };
@@ -36131,7 +36634,7 @@ function getConstructors(node) {
     (member) => ts30.isConstructorDeclaration(member) && member.body !== void 0
   );
 }
-var rule11 = {
+var rule12 = {
   meta: {
     type: "problem",
     docs: {
@@ -36181,7 +36684,7 @@ var rule11 = {
     };
   }
 };
-var no_custom_constructor_default = rule11;
+var no_custom_constructor_default = rule12;
 
 // src/extensibility-rules/no-extra-type-params.ts
 import ts31 from "typescript";
@@ -36216,7 +36719,7 @@ function isSoleTypeParameterUsedForFieldsType(checker, node) {
   const fieldsTypeSymbol = getTypeSymbol(getBaseObjectFieldsType(checker, node)?.type);
   return typeParameterSymbol !== void 0 && fieldsTypeSymbol === typeParameterSymbol;
 }
-var rule12 = {
+var rule13 = {
   meta: {
     type: "problem",
     docs: {
@@ -36294,7 +36797,7 @@ var rule12 = {
     };
   }
 };
-var no_extra_type_params_default = rule12;
+var no_extra_type_params_default = rule13;
 
 // src/extensibility-rules/no-public-instance-fields.ts
 import ts34 from "typescript";
@@ -36328,7 +36831,7 @@ function getConstructors2(node) {
     (member) => ts34.isConstructorDeclaration(member) && member.body !== void 0
   );
 }
-var rule13 = {
+var rule14 = {
   meta: {
     type: "problem",
     docs: {
@@ -36397,7 +36900,7 @@ var rule13 = {
     };
   }
 };
-var no_public_instance_fields_default = rule13;
+var no_public_instance_fields_default = rule14;
 
 // src/extensibility-rules/prefer-es-private.ts
 import ts35 from "typescript";
@@ -36506,7 +37009,7 @@ function getAutofix(method, classNode) {
     ];
   };
 }
-var rule14 = {
+var rule15 = {
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -36564,7 +37067,7 @@ var rule14 = {
     };
   }
 };
-var prefer_es_private_default = rule14;
+var prefer_es_private_default = rule15;
 
 // src/extensibility-rules/index.ts
 var extensibilityRules = {
@@ -36802,7 +37305,7 @@ function reportExplicitApiNameIssues(context, node) {
     });
   }
 }
-var rule15 = {
+var rule16 = {
   meta: {
     type: "problem",
     docs: {
@@ -36847,7 +37350,7 @@ var rule15 = {
     };
   }
 };
-var valid_api_name_default = rule15;
+var valid_api_name_default = rule16;
 
 // src/naming-rules/index.ts
 var namingRules = {
@@ -36870,7 +37373,7 @@ var noSecretsOptions = {
     "Stripe Webhook Secret": "whsec_[a-zA-Z0-9+/=]{20,}"
   }
 };
-var rule16 = {
+var rule17 = {
   ...originalRule,
   meta: {
     ...originalRule.meta,
@@ -36880,7 +37383,7 @@ var rule16 = {
     }
   }
 };
-var no_secrets_default = rule16;
+var no_secrets_default = rule17;
 
 // src/internal/analysis/apps/manifest-tools.ts
 import { parse } from "yaml";
@@ -36968,7 +37471,7 @@ function isObjectExpression(node) {
 function isProperty(node) {
   return node.type === "Property";
 }
-function isIdentifier10(node) {
+function isIdentifier11(node) {
   return node.type === "Identifier";
 }
 function isLiteral(node) {
@@ -36985,7 +37488,7 @@ function getStringProperty(obj, name, sourceCode, scopeNode) {
     if (!isProperty(prop)) {
       continue;
     }
-    const keyName = isIdentifier10(prop.key) && prop.key.name || isLiteral(prop.key) && prop.key.value;
+    const keyName = isIdentifier11(prop.key) && prop.key.name || isLiteral(prop.key) && prop.key.value;
     if (keyName !== name) {
       continue;
     }
@@ -36995,7 +37498,7 @@ function getStringProperty(obj, name, sourceCode, scopeNode) {
         node: prop.value
       };
     }
-    if (isIdentifier10(prop.value)) {
+    if (isIdentifier11(prop.value)) {
       const varName = prop.value.name;
       let scope = sourceCode.getScope(scopeNode);
       while (scope) {
@@ -37014,7 +37517,7 @@ function getStringProperty(obj, name, sourceCode, scopeNode) {
   }
   return void 0;
 }
-var rule17 = {
+var rule18 = {
   meta: {
     type: "problem",
     docs: {
@@ -37056,7 +37559,7 @@ var rule17 = {
     };
   }
 };
-var valid_endpoint_id_default = rule17;
+var valid_endpoint_id_default = rule18;
 
 // src/security-rules/valid-extension-interface.ts
 import * as path4 from "path";
@@ -37100,7 +37603,7 @@ function resolveExtensionTarget(context) {
   }
   return { interfaceId: extensionForFile.interface_id, expectedInterfaceName };
 }
-var rule18 = {
+var rule19 = {
   meta: {
     type: "problem",
     docs: {
@@ -37130,9 +37633,9 @@ var rule18 = {
           if (!sourceFile) {
             return;
           }
+          const sourceCode = context.sourceCode;
           const classDeclaration = getDefaultExportedClassDeclaration(sourceFile);
           if (!classDeclaration) {
-            const sourceCode = context.sourceCode;
             const firstToken = sourceCode.getFirstToken(sourceCode.ast);
             context.report({
               node: firstToken ?? sourceCode.ast,
@@ -37150,21 +37653,25 @@ var rule18 = {
             ({ interfaceSymbol }) => symbolMatchesExtensionInterface(checker, interfaceSymbol)
           );
           if (sdkInterfaces.length === 0) {
+            const highlightNode = classDeclaration.name ?? implementedTypes[0]?.heritageType.expression;
             context.report({
-              loc: toReportLoc(classDeclaration),
+              ...highlightNode ? { loc: toReportLoc(highlightNode) } : { node: sourceCode.getFirstToken(sourceCode.ast) ?? sourceCode.ast },
               messageId: "MISSING_SDK_INTERFACE",
               data: { expectedInterfaceName, interfaceId }
             });
             return;
           }
-          const matchesExpected = sdkInterfaces.some(({ interfaceSymbol }) => {
-            const resolvedName = interfaceSymbol?.getName();
-            return resolvedName === expectedInterfaceName;
-          });
+          const matchesExpected = sdkInterfaces.some(
+            ({ interfaceSymbol }) => interfaceSymbol?.getName().startsWith(expectedInterfaceName) ?? false
+          );
           if (!matchesExpected) {
+            const firstMismatch = sdkInterfaces[0];
+            if (!firstMismatch) {
+              return;
+            }
             const actualNames = sdkInterfaces.map(({ interfaceSymbol }) => interfaceSymbol?.getName() ?? "(unknown)").join(", ");
             context.report({
-              loc: toReportLoc(classDeclaration),
+              loc: toReportLoc(firstMismatch.heritageType.expression),
               messageId: "WRONG_INTERFACE",
               data: {
                 actualName: actualNames,
@@ -37180,16 +37687,16 @@ var rule18 = {
     };
   }
 };
-var valid_extension_interface_default = rule18;
+var valid_extension_interface_default = rule19;
 
 // src/security-rules/index.ts
 var security = require_eslint_plugin_security();
 function requireRule(rules2, name, pluginName) {
-  const rule19 = rules2[name];
-  if (!rule19) {
+  const rule20 = rules2[name];
+  if (!rule20) {
     throw new Error(`Expected rule '${name}' not found in ${pluginName}`);
   }
-  return rule19;
+  return rule20;
 }
 var securityRules = {
   "detect-bidi-characters": requireRule(