@sarj/eslint-plugin 16.6.0 → 16.8.0

package/dist/index.cjs

@@ -52,7 +52,7 @@ module.exports = __toCommonJS(src_exports);
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.6.0",
+  version: "16.8.0",
   packageManager: "npm@12.1.0",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -470,8 +470,9 @@ function commentLineEnd(sourceText, start) {
 }
 
 // src/rules/require-explicit-contract-implementation.ts
+var ESCAPED_CLASSES = /* @__PURE__ */ new WeakMap();
 var REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Require nominal inheritance when an injected abstract class is rejected by an instanceof guard.",
   rationale: "A structurally assignable fake can still fail a constructor's nominal runtime guard. Pure structural interfaces do not require an implements clause.",
   remediation: "Use an implementation inheriting the existing abstract class, or remove the nominal guard if the boundary is intentionally structural.",
@@ -479,8 +480,8 @@ var REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION = {
   autofix: "none",
   limitations: [
     "Requires direct construction of both owned consumer and collaborator classes, with a first-statement consumer constructor guard rejecting the exact parameter with if (!(parameter instanceof Contract)) throw.",
-    "The contract must resolve to an abstract class without decorators, unresolved ancestors, or custom computed static members in its resolved hierarchy.",
-    "Structural interfaces, non-rejecting branches, reassignment before the guard, casts, unresolved heritage, dynamic factories, explicit implementation constructors or initializers, modules referencing prototype-mutator members or assigning prototypes, and third-party classes are excluded."
+    "The contract must resolve to an abstract class without decorators, static blocks, unresolved ancestors, or custom computed static members in its resolved hierarchy. Escaped class constructors are checked across every owned module in the typed program.",
+    "Structural interfaces, non-rejecting branches, reassignment before the guard, casts, unresolved heritage, dynamic factories, implementation static blocks, explicit implementation constructors or initializers, involved modules referencing prototype-mutator members or assigning prototypes, escaped class constructors, and third-party classes are excluded."
   ],
   examples: [
     {
@@ -503,6 +504,115 @@ var REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION = {
     }
   ]
 };
+function hasPrototypeMutation(source) {
+  function visit(node) {
+    const member = memberName(node);
+    if (member === "setPrototypeOf" || member === "__proto__" || member === "hasInstance") return true;
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && memberName(node.left) === "prototype") return true;
+    return ts.forEachChild(node, visit);
+  }
+  return visit(source) === true;
+}
+function memberName(node) {
+  if (ts.isPropertyAccessExpression(node)) return node.name.text;
+  if (ts.isElementAccessExpression(node) && ts.isStringLiteralLike(node.argumentExpression)) return node.argumentExpression.text;
+  return null;
+}
+function ownedSource(source) {
+  return !source.isDeclarationFile && !/(?:^|[/\\])(?:node_modules|vendor|vendored|generated|dist)(?:[/\\])/u.test(source.fileName) && !isGeneratedFile(source.fileName, source.text);
+}
+function escapedClasses(program, checker) {
+  const cached = ESCAPED_CLASSES.get(program);
+  if (cached !== void 0) return cached;
+  const escaped = /* @__PURE__ */ new Set();
+  const namespaceValues = /* @__PURE__ */ new Map();
+  function visit(node) {
+    if (ts.isTypeNode(node) || ts.isImportDeclaration(node)) return;
+    if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+      recordEscapedReference(checker, node, escaped, namespaceValues);
+    }
+    ts.forEachChild(node, visit);
+  }
+  for (const source of program.getSourceFiles()) if (ownedSource(source)) visit(source);
+  ESCAPED_CLASSES.set(program, escaped);
+  return escaped;
+}
+function recordEscapedReference(checker, node, escaped, namespaceValues) {
+  const symbol = canonicalSymbol(checker, node);
+  if (symbol !== void 0) {
+    let values = namespaceValues.get(symbol);
+    if (values === void 0) {
+      values = ownedClassValues(checker, symbol);
+      namespaceValues.set(symbol, values);
+    }
+    if (!namespacePrefix(symbol, node) && !safeClassReference(node)) for (const value of values) escaped.add(value);
+  }
+  if (ts.isElementAccessExpression(node) && !safeClassReference(node)) {
+    const receiver = canonicalSymbol(checker, node.expression) ?? checker.getTypeAtLocation(node.expression).getSymbol();
+    if (receiver !== void 0) for (const value of ownedClassValues(checker, receiver)) escaped.add(value);
+  }
+}
+function ownedClassValues(checker, original, seen = /* @__PURE__ */ new Set()) {
+  const symbol = original.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(original) : original;
+  const values = /* @__PURE__ */ new Set();
+  if (seen.has(symbol)) return values;
+  seen.add(symbol);
+  if (symbol.declarations?.some((declaration) => ts.isClassDeclaration(declaration) && ownedSource(declaration.getSourceFile()))) values.add(symbol);
+  if (symbol.declarations?.some((declaration) => (ts.isSourceFile(declaration) || ts.isModuleDeclaration(declaration)) && ownedSource(declaration.getSourceFile()))) {
+    for (const exported of checker.getExportsOfModule(symbol)) {
+      for (const value of ownedClassValues(checker, exported, seen)) values.add(value);
+    }
+  }
+  return values;
+}
+function safeClassReference(node) {
+  let reference = ts.isPropertyAccessExpression(node.parent) && node.parent.name === node ? node.parent : node;
+  while (ts.isParenthesizedExpression(reference.parent)) reference = reference.parent;
+  const parent = reference.parent;
+  return ts.isClassDeclaration(parent) && parent.name === reference || ts.isNewExpression(parent) && parent.expression === reference || ts.isExpressionWithTypeArguments(parent) && parent.expression === reference || ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword && parent.right === reference;
+}
+function namespacePrefix(symbol, node) {
+  const parent = node.parent;
+  const memberCall = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && ts.isCallExpression(parent.parent) && parent.parent.expression === parent;
+  return !symbol.declarations?.some(ts.isClassDeclaration) && (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === node && !memberCall;
+}
+function closedNominalBoundary(program, checker, call, consumer, missing) {
+  const { implementation, contractSymbol } = missing;
+  const implementationSymbol = implementation.name === void 0 ? void 0 : canonicalSymbol(checker, implementation.name);
+  const consumerSymbol = consumer.name === void 0 ? void 0 : canonicalSymbol(checker, consumer.name);
+  if (implementationSymbol === void 0 || consumerSymbol === void 0) return false;
+  const contract = contractSymbol.declarations?.find(ts.isClassDeclaration);
+  if (contract === void 0) return false;
+  const targets = /* @__PURE__ */ new Set([consumerSymbol, ...classHierarchySymbols(checker, contract), ...classHierarchySymbols(checker, implementation)]);
+  const sources = /* @__PURE__ */ new Set([call.getSourceFile(), consumer.getSourceFile(), implementation.getSourceFile(), ...contractSymbol.declarations?.map((item) => item.getSourceFile()) ?? []]);
+  return ![...sources].some(hasPrototypeMutation) && ![...targets].some((target) => escapedClasses(program, checker).has(target));
+}
+function classHierarchySymbols(checker, declaration, seen = /* @__PURE__ */ new Set()) {
+  const symbol = declaration.name === void 0 ? void 0 : canonicalSymbol(checker, declaration.name);
+  if (symbol === void 0 || seen.has(symbol)) return seen;
+  seen.add(symbol);
+  for (const clause of declaration.heritageClauses ?? []) {
+    if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+    for (const parent of clause.types) {
+      const ancestor = canonicalSymbol(checker, parent.expression)?.declarations?.find(ts.isClassDeclaration);
+      if (ancestor !== void 0) classHierarchySymbols(checker, ancestor, seen);
+    }
+  }
+  return seen;
+}
+function missingImplementation(checker, signature, parameter, call, argument) {
+  const parameterType = checker.getTypeOfSymbolAtLocation(parameter, call);
+  const contractType = behavioralContract(checker, parameterType);
+  if (contractType === null) return null;
+  const contractSymbol = contractType.getSymbol();
+  if (contractSymbol === void 0 || !hasNominalRejectionGuard(checker, signature, parameter, contractSymbol)) return null;
+  const actualType = checker.getTypeAtLocation(argument);
+  if (!checker.isTypeAssignableTo(actualType, contractType)) return null;
+  const implementation = ownedClass(checker, argument);
+  if (implementation === null) return null;
+  if (nominallyInherits(checker, implementation, contractSymbol, /* @__PURE__ */ new Set()) !== false) return null;
+  return { implementation, contractSymbol };
+}
 function behavioralContract(checker, type) {
   if (type.isUnion()) {
     const substantive = type.types.filter((member) => (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
@@ -527,23 +637,9 @@ function ownedClass(checker, expression) {
   if (declaration === void 0 || declaration !== constructed || declaration.getSourceFile().isDeclarationFile || /(?:^|[/\\])(?:node_modules|vendor|generated)(?:[/\\])/u.test(declaration.getSourceFile().fileName)) return null;
   return declaration;
 }
-function memberName(node) {
-  if (ts.isPropertyAccessExpression(node)) return node.name.text;
-  if (ts.isElementAccessExpression(node) && ts.isStringLiteralLike(node.argumentExpression)) return node.argumentExpression.text;
-  return null;
-}
-function hasPrototypeMutation(source) {
-  function visit(node) {
-    const member = memberName(node);
-    if (member === "setPrototypeOf" || member === "__proto__" || member === "hasInstance") return true;
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && memberName(node.left) === "prototype") return true;
-    return ts.forEachChild(node, visit);
-  }
-  return visit(source) === true;
-}
 function nominallyInherits(checker, declaration, target, seen) {
   if (ts.canHaveDecorators(declaration) && ts.getDecorators(declaration)?.length) return null;
-  if (hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some((member) => ts.isConstructorDeclaration(member) || ts.isPropertyDeclaration(member) && member.initializer !== void 0)) return null;
+  if (hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some((member) => ts.isConstructorDeclaration(member) || ts.isClassStaticBlockDeclaration(member) || ts.isPropertyDeclaration(member) && member.initializer !== void 0)) return null;
   const symbol = declaration.name === void 0 ? void 0 : canonicalSymbol(checker, declaration.name);
   if (symbol !== void 0) {
     if (seen.has(symbol)) return null;
@@ -558,10 +654,6 @@ function nominallyInherits(checker, declaration, target, seen) {
   const inherited = parentSymbol.declarations?.find(ts.isClassDeclaration);
   return inherited === void 0 ? null : nominallyInherits(checker, inherited, target, new Set(seen));
 }
-function canonicalSymbol(checker, node) {
-  const symbol = checker.getSymbolAtLocation(node);
-  return symbol === void 0 ? void 0 : (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
-}
 function hasNominalRejectionGuard(checker, signature, parameter, contract) {
   const declaration = signature.getDeclaration();
   if (declaration === void 0 || !ts.isConstructorDeclaration(declaration)) return false;
@@ -586,7 +678,7 @@ function alwaysThrows(statement) {
   return ts.isThrowStatement(statement) || ts.isBlock(statement) && statement.statements.length === 1 && ts.isThrowStatement(statement.statements[0]);
 }
 function hasOrdinaryInstanceCheck(checker, declaration, seen) {
-  if (seen.has(declaration) || ts.getDecorators(declaration)?.length || hasPrototypeMutation(declaration.getSourceFile())) return false;
+  if (seen.has(declaration) || ts.getDecorators(declaration)?.length || hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some(ts.isClassStaticBlockDeclaration)) return false;
   seen.add(declaration);
   if (declaration.members.some((member) => member.name !== void 0 && ts.isComputedPropertyName(member.name) && ts.canHaveModifiers(member) && ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) return false;
   for (const clause of declaration.heritageClauses ?? []) {
@@ -598,6 +690,10 @@ function hasOrdinaryInstanceCheck(checker, declaration, seen) {
   }
   return true;
 }
+function canonicalSymbol(checker, node) {
+  const symbol = checker.getSymbolAtLocation(node);
+  return symbol === void 0 ? void 0 : (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+}
 var require_explicit_contract_implementation_default = createRule({
   name: "require-explicit-contract-implementation",
   documentation: REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION,
@@ -627,22 +723,13 @@ var require_explicit_contract_implementation_default = createRule({
         if (argument.type !== import_utils2.AST_NODE_TYPES.NewExpression) continue;
         const parameter = parameters[index];
         if (parameter === void 0) continue;
-        const parameterType = checker.getTypeOfSymbolAtLocation(parameter, tsNode);
-        const contractType = behavioralContract(checker, parameterType);
-        if (contractType === null) continue;
-        const contractSymbol = contractType.getSymbol();
-        if (contractSymbol === void 0 || !hasNominalRejectionGuard(checker, signature, parameter, contractSymbol)) continue;
         const tsArgument = services.esTreeNodeToTSNodeMap.get(argument);
-        const actualType = checker.getTypeAtLocation(tsArgument);
-        if (!checker.isTypeAssignableTo(actualType, contractType)) continue;
-        const implementation = ownedClass(checker, tsArgument);
-        if (implementation === null) continue;
-        const relationship = nominallyInherits(checker, implementation, contractSymbol, /* @__PURE__ */ new Set());
-        if (relationship !== false) continue;
+        const missing = missingImplementation(checker, signature, parameter, tsNode, tsArgument);
+        if (missing === null || !closedNominalBoundary(services.program, checker, tsNode, consumer, missing)) continue;
         context.report({
           node: argument,
           messageId: "declareActualContract",
-          data: { implementation: implementation.name?.text ?? "class", contract: contractSymbol.getName() }
+          data: { implementation: missing.implementation.name?.text ?? "class", contract: missing.contractSymbol.getName() }
         });
       }
     }
@@ -1482,7 +1569,7 @@ function abstractContractOperations(node, functionAliases) {
 
 // src/rules/require-explicit-service-contract.ts
 var REQUIRE_EXPLICIT_SERVICE_CONTRACT_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Require explicit contracts for classes that invoke retained collaborators.",
   rationale: "A one-operation service can orchestrate a collaborator without declaring the contract that callers consume and implementations and fakes satisfy.",
   remediation: "Explicitly implement a focused interface or extend an abstract class covering the service operations. Export the contract only when its consumers need it.",
@@ -7469,7 +7556,7 @@ function branchTerminates(branch) {
 var import_utils42 = require("@typescript-eslint/utils");
 var import_typescript5 = __toESM(require("typescript"), 1);
 var NO_JSON_STRINGIFY_OBJECT_EQUALITY_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Do not use JSON serialization as structural object equality.",
   rationale: "JSON text equality depends on property insertion order and serialization behavior, so semantically equal objects can compare unequal and distinct values can collapse together.",
   remediation: "Compare an explicit domain projection structurally, or use a reviewed canonical serializer when JSON semantics are required.",
@@ -12690,7 +12777,7 @@ var TEST_MODULES = /* @__PURE__ */ new Set(["vitest", "@jest/globals", "bun:test
 var TEST_NAMES2 = /* @__PURE__ */ new Set(["it", "test"]);
 var MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "concurrent", "fails", "failing", "todo"]);
 var NO_DUPLICATE_TEST_CASE_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Report repeated literal rows in framework test.each or it.each tables.",
   rationale: "Identical rows repeat the same inputs and expected values without exposing a distinct case. Accidental duplicates consume test time and hide a missing boundary vector.",
   remediation: "Remove the accidental duplicate or replace it with the intended distinct boundary. Preserve intentional repeated or stateful scenarios with a local explanation; do not delete their coverage automatically.",
@@ -17549,7 +17636,7 @@ var OPERATIONAL_ROLES = /* @__PURE__ */ new Set([
 ]);
 var MAX_ALIAS_DEPTH = 16;
 var PREFER_NOMINAL_ID_TYPES_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Distinguish identifier roles sharing primitive types at callable boundaries.",
   rationale: "Two identifier roles represented by the same primitive accept each other's values, so swapped arguments survive type checking. Transparent aliases do not prevent this.",
   remediation: "Introduce distinct branded identifier types at a validated domain boundary and use them in the callable contract. Keep wire representations primitive until validation; suppress a required external signature locally with a reason.",
@@ -17714,14 +17801,14 @@ var prefer_named_callback_domain_default = createRule({
 // src/rules/prefer-named-complex-return-type.ts
 var import_utils101 = require("@typescript-eslint/utils");
 var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Prefer a named contract for structurally complex function return types.",
   rationale: "A large inline return annotation hides a reusable domain concept and makes signatures difficult to scan.",
   remediation: "Name the complex nested shape while preserving its generic wrappers and type parameters; reference the named contract from the return annotation.",
   category: "maintainability",
   limitations: [
     "Only explicit object types with at least three members and unions with at least three object variants are reported.",
-    "Any single-argument generic wrapper is traversed to find nested shapes, not assumed semantically transparent. Inferred return types are outside this rule; extraction is manual and must preserve locally bound type parameters."
+    "Any single-argument generic wrapper is traversed to find nested shapes, not assumed semantically transparent. Inferred return types are outside this rule; extraction is manual and must preserve locally bound type parameters with generic named contracts. Types depending on polymorphic this or a local value query are excluded."
   ],
   examples: [
     { id: "named-result", title: "Name a multi-state result", outcome: "no-match", files: [{ path: "src/queue.ts", source: "type ClaimResult = { state: 'idle' } | { state: 'waiting'; retryAt: number } | { state: 'claimed'; id: string }; export function claim(): ClaimResult { return { state: 'idle' }; }" }], focusPath: "src/queue.ts", expectedCount: 0, public: true },
@@ -17737,10 +17824,13 @@ function unwrap4(node) {
 }
 function report(context, node) {
   const annotation = node.returnType?.typeAnnotation;
-  if (annotation !== void 0 && isComplex(annotation)) {
+  if (annotation !== void 0 && isComplex(annotation) && !hasValueDependency(annotation)) {
     context.report({ node: annotation, messageId: "nameComplexReturnType" });
   }
 }
+function hasValueDependency(node) {
+  return node.type === import_utils101.AST_NODE_TYPES.TSThisType || node.type === import_utils101.AST_NODE_TYPES.TSTypeQuery || forEachOwnAstChild(node, hasValueDependency);
+}
 function isComplex(node) {
   const type = unwrap4(node);
   if (type.type === import_utils101.AST_NODE_TYPES.TSTypeLiteral) return type.members.length >= 3;
@@ -19388,20 +19478,20 @@ var prefer_shared_zod_enum_default = createRule({
 // src/rules/prefer-switch-for-repeated-equality.ts
 var import_utils110 = require("@typescript-eslint/utils");
 var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
   rationale: "A switch makes finite dispatch cases visually uniform and easier to extend without duplicating the discriminant.",
   remediation: "Replace three or more strict-equality branches over the same discriminant with a switch; keep if statements for ranges, guards, and heterogeneous predicates.",
   category: "maintainability",
   limitations: [
     "Only direct if/else-if chains with at least three strict-equality tests are reported.",
-    "The discriminant must be a bare identifier; calls, getters, indexed reads and other repeatedly evaluated expressions are excluded. Review case-value effects, selector mutation, branch scoping, and break/continue targets when converting manually; this is not an equivalence proof.",
-    "Case values may be literals, enum-like member references, or upper-case named constants; dynamic expressions are excluded.",
+    "The discriminant must be a resolved lexical variable or parameter; unresolved globals, calls, getters, and indexed reads are excluded. Preserve branch scopes and break/continue targets when converting manually; no autofix is offered.",
+    "Case values must be primitive literals. Member references and named constants are excluded because evaluating them can observe getters or mutate the selector. Generated sources are excluded.",
     "The rule deliberately ignores compound predicates, loose equality, ranges, and chains that compare different discriminants."
   ],
   examples: [
     { id: "switch-dispatch", title: "Make finite dispatch explicit", outcome: "no-match", files: [{ path: "src/render.ts", source: "switch (kind) { case 'a': return a(); case 'b': return b(); case 'c': return c(); default: return fallback(); }" }], focusPath: "src/render.ts", expectedCount: 0, public: true },
-    { id: "repeated-equality", title: "Avoid repeating the discriminant", outcome: "match", files: [{ path: "src/render.ts", source: "if (kind === 'a') return a(); else if (kind === 'b') return b(); else if (kind === 'c') return c();" }], focusPath: "src/render.ts", expectedCount: 1, public: true },
+    { id: "repeated-equality", title: "Avoid repeating the discriminant", outcome: "match", files: [{ path: "src/render.ts", source: "function render(kind: string) { if (kind === 'a') return a(); else if (kind === 'b') return b(); else if (kind === 'c') return c(); }" }], focusPath: "src/render.ts", expectedCount: 1, public: true },
     { id: "escaped-middle", scenarioId: "native-discriminant", title: "Use native identifier identity", outcome: "match", files: [{ path: "src/dispatch.ts", source: `function probe(kind){if(kind==='a')return 1;else if(\\u006bind==='b')return 2;else if(kind==='c')return 3;return 0;}
 console.log(JSON.stringify(["a","b","c","d"].map(probe)));` }], focusPath: "src/dispatch.ts", expectedCount: 1, public: true },
     { id: "different-discriminants", scenarioId: "native-discriminant", title: "Use native identifier identity", outcome: "no-match", files: [{ path: "src/dispatch.ts", source: `function probe(kind){const other="other";if(kind==='a')return 1;else if(other==='b')return 2;else if(kind==='c')return 3;return 0;}
@@ -19417,10 +19507,7 @@ function discriminantName(test) {
   return discriminant.type === import_utils110.AST_NODE_TYPES.Identifier ? discriminant.name : null;
 }
 function isCaseValue(node) {
-  if (node.type === import_utils110.AST_NODE_TYPES.Literal) return true;
-  if (node.type === import_utils110.AST_NODE_TYPES.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
-  if (node.type !== import_utils110.AST_NODE_TYPES.MemberExpression || node.computed) return false;
-  return node.property.type === import_utils110.AST_NODE_TYPES.Identifier && (node.object.type === import_utils110.AST_NODE_TYPES.Identifier || isCaseValue(node.object));
+  return node.type === import_utils110.AST_NODE_TYPES.Literal && !("regex" in node);
 }
 var prefer_switch_for_repeated_equality_default = createRule({
   name: "prefer-switch-for-repeated-equality",
@@ -19435,11 +19522,16 @@ var prefer_switch_for_repeated_equality_default = createRule({
   },
   defaultOptions: [],
   create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     return {
       IfStatement(node) {
         if (node.parent.type === import_utils110.AST_NODE_TYPES.IfStatement && node.parent.alternate === node) return;
         const first = discriminantName(node.test);
         if (first === null) return;
+        const binding = import_utils110.ASTUtils.findVariable(context.sourceCode.getScope(node), first);
+        if (binding === null || binding.defs.length !== 1 || binding.scope.type === "global") return;
+        const [definition] = binding.defs;
+        if (definition?.type !== "Parameter" && definition?.type !== "Variable") return;
         let count = 1;
         let current = node.alternate;
         while (current?.type === import_utils110.AST_NODE_TYPES.IfStatement) {
@@ -21446,17 +21538,17 @@ var UNRESOLVED_TYPE_NODES = /* @__PURE__ */ new Set([
   import_utils116.AST_NODE_TYPES.TSUnknownKeyword
 ]);
 var NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Reference a named Zod record child's complete schema type instead of repeating its explicit annotation.",
   rationale: "Repeating a child schema's generic contract creates a second maintained declaration even though the record already uses that child at runtime.",
-  remediation: "Replace only the matching record type argument with `typeof ChildSchema`; retain the outer annotation required by isolatedDeclarations and every runtime schema operation.",
+  remediation: "Replace only the matching record type argument with `typeof ChildSchema`, or share one explicit named schema type alias between child and record to retain an independently named public contract. Keep the outer annotation required by isolatedDeclarations and every runtime schema operation.",
   category: "maintainability",
   autofix: "none",
   limitations: [
     "Only direct module-level const z.record calls with two arguments, a ZodRecord annotation, and an earlier local const child with a complete explicit Zod type are inspected.",
     "The entire generic child annotation must match token for token; input/output, defaults, transforms, readonly modifiers and brands are never compared by output shape alone.",
     "Bare leaf types, broad ZodType constraints, type queries, imported or unqualified type references, annotation cycles, comments on the repeated argument, mutable bindings and generated files are excluded.",
-    "Import aliases and namespace imports resolve through scope bindings. Independent public contract pins require review; this warning does not remove annotations or change runtime validation."
+    "Import aliases and namespace imports resolve through scope bindings. Independent public contract pins can use one shared named type alias or an exact reasoned suppression; runtime validation and outer annotations are preserved."
   ],
   examples: [
     { id: "named-child", title: "Reference the named child contract", outcome: "no-match", files: [{ path: "src/record.ts", source: 'import { z } from "zod"; const KeySchema: z.ZodEnum<{ a: "a"; b: "b" }> = z.enum(["a", "b"]); export const RecordSchema: z.ZodRecord<typeof KeySchema, z.ZodString> = z.record(KeySchema, z.string());' }], focusPath: "src/record.ts", expectedCount: 0, public: true },
@@ -21475,7 +21567,7 @@ var named_child_schema_type_default = createRule({
     type: "suggestion",
     docs: { description: NAMED_CHILD_SCHEMA_TYPE_DOCUMENTATION.summary },
     schema: [],
-    messages: { namedChildType: "Use `typeof {{name}}` for this exact child contract; keep the outer schema annotation and runtime operations." }
+    messages: { namedChildType: "Use `typeof {{name}}` or one shared named type alias for this exact child contract; keep the outer schema annotation and runtime operations." }
   },
   defaultOptions: [],
   create(context) {
@@ -22190,15 +22282,15 @@ var require_fetch_timeout_default = createRule({
 // src/rules/require-interface-for-exported-class.ts
 var import_utils120 = require("@typescript-eslint/utils");
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Require exported concrete classes with public behavior to declare a contract.",
   rationale: "An explicit contract names the intended public capability separately from implementation details. TypeScript already supports structural compatibility; this is an architecture policy, not a prerequisite for substitution.",
   remediation: "Declare a focused interface and add an implements clause, or inherit from an intentional base contract.",
   category: "architecture",
   limitations: [
     "JavaScript files are excluded because implements is TypeScript syntax; imported framework base contracts still require manual policy review.",
-    "An exported injected service may also receive require-port-for-service: its service-boundary error and this general exported-contract warning intentionally enforce distinct policy scopes.",
-    "The warning-stage rule checks module-level class declarations and direct class-expression values exported directly, through local export specifiers, or through a default identifier; re-exports and expressions wrapped in other calls require review.",
+    "An exported injected service may also receive require-port-for-service: the two diagnostics intentionally enforce distinct service-boundary and general exported-contract policy scopes.",
+    "The rule checks module-level class declarations and direct class-expression values exported directly, through local export specifiers, or through a default identifier; re-exports and expressions wrapped in other calls require review.",
     "An extends clause satisfies the contract only when its target is a locally declared abstract class; imported base-class contracts require an explicit implements clause.",
     "Static factories and data-only classes without public instance methods are outside the contract requirement."
   ],
@@ -24875,30 +24967,21 @@ var LIBRARY_IMPORT_POLICY = ["error", {
 }];
 var ADVISORY_RULES = [
   "@sarj/excessive-commentary",
-  "@sarj/named-child-schema-type",
   "@sarj/no-bespoke-api-case-conversion",
-  "@sarj/no-duplicate-test-case",
-  "@sarj/no-json-stringify-object-equality",
   "@sarj/no-restated-comment",
   "@sarj/no-restated-jsdoc",
   "@sarj/prefer-millisecond-control-duration-schema",
   "@sarj/prefer-module-level-refined-schema",
   "@sarj/prefer-multi-value-zod-literal",
-  "@sarj/prefer-named-complex-return-type",
   "@sarj/prefer-node-crypto-hash",
   "@sarj/prefer-node-fs-promises",
-  "@sarj/prefer-nominal-id-types",
   "@sarj/prefer-shared-zod-enum",
-  "@sarj/prefer-switch-for-repeated-equality",
   "@sarj/prefer-whole-object-assertion",
   "@sarj/require-camelcase-properties",
-  "@sarj/require-explicit-contract-implementation",
-  "@sarj/require-explicit-service-contract",
-  "@sarj/require-interface-for-exported-class",
   "@sarj/require-sql-access-class"
 ];
 var RECOMMENDED_RULES = {
-  "@sarj/named-child-schema-type": "warn",
+  "@sarj/named-child-schema-type": "error",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",
@@ -24936,7 +25019,7 @@ var RECOMMENDED_RULES = {
   "@sarj/no-bare-return-from-test-catch": "error",
   "@sarj/no-bespoke-api-case-conversion": "warn",
   "@sarj/no-detached-global-fetch": "error",
-  "@sarj/no-json-stringify-object-equality": "warn",
+  "@sarj/no-json-stringify-object-equality": "error",
   "@sarj/no-dangerously-allow-svg": "error",
   "@sarj/no-duplicate-lifecycle-refresh-listeners": "error",
   "@sarj/no-long-comment": "error",
@@ -24958,7 +25041,7 @@ var RECOMMENDED_RULES = {
   "@sarj/no-sleep-in-test-body": "error",
   "@sarj/no-string-concat-in-loop": "error",
   "@sarj/no-tautological-expect": "error",
-  "@sarj/no-duplicate-test-case": "warn",
+  "@sarj/no-duplicate-test-case": "error",
   "@sarj/no-typed-doc-sections": "error",
   "@sarj/no-trailing-value-narration": "error",
   "@sarj/no-declaration-comment-wall": "error",
@@ -24981,8 +25064,8 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-module-level-refined-schema": "warn",
   "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
   "@sarj/prefer-named-callback-domain": "error",
-  "@sarj/prefer-nominal-id-types": "warn",
-  "@sarj/prefer-named-complex-return-type": "warn",
+  "@sarj/prefer-nominal-id-types": "error",
+  "@sarj/prefer-named-complex-return-type": "error",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",
   "@sarj/prefer-non-nullable-collection": "error",
@@ -24990,7 +25073,7 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-shared-zod-enum": "warn",
-  "@sarj/prefer-switch-for-repeated-equality": "warn",
+  "@sarj/prefer-switch-for-repeated-equality": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
   "@sarj/prefer-whole-object-assertion": "warn",
@@ -24999,9 +25082,9 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-zod-parse-output-type": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
-  "@sarj/require-explicit-contract-implementation": "warn",
-  "@sarj/require-explicit-service-contract": "warn",
-  "@sarj/require-interface-for-exported-class": "warn",
+  "@sarj/require-explicit-contract-implementation": "error",
+  "@sarj/require-explicit-service-contract": "error",
+  "@sarj/require-interface-for-exported-class": "error",
   "@sarj/require-port-for-service": "error",
   "@sarj/require-sql-access-class": "warn",
   "@sarj/require-static-next-matcher": "error",
@@ -25016,7 +25099,7 @@ var RECOMMENDED_RULES = {
   "@sarj/require-pascal-case-zod-schema-name": "error"
 };
 var STRICT_RULES = {
-  "@sarj/named-child-schema-type": "warn",
+  "@sarj/named-child-schema-type": "error",
   "@sarj/no-conditional-empty-object-spread": "error",
   "@sarj/prefer-typed-reflection": "error",
   "@sarj/no-broad-return-type": "error",
@@ -25055,7 +25138,7 @@ var STRICT_RULES = {
   "@sarj/no-bare-return-from-test-catch": "error",
   "@sarj/no-bespoke-api-case-conversion": "warn",
   "@sarj/no-detached-global-fetch": "error",
-  "@sarj/no-json-stringify-object-equality": "warn",
+  "@sarj/no-json-stringify-object-equality": "error",
   "@sarj/no-dangerously-allow-svg": "error",
   "@sarj/no-duplicate-lifecycle-refresh-listeners": "error",
   "@sarj/no-long-comment": "error",
@@ -25080,7 +25163,7 @@ var STRICT_RULES = {
   "@sarj/no-storage-in-stateless-modules": "error",
   "@sarj/no-string-concat-in-loop": "error",
   "@sarj/no-tautological-expect": "error",
-  "@sarj/no-duplicate-test-case": "warn",
+  "@sarj/no-duplicate-test-case": "error",
   "@sarj/no-typed-doc-sections": "error",
   "@sarj/no-trailing-value-narration": "error",
   "@sarj/no-declaration-comment-wall": "error",
@@ -25103,8 +25186,8 @@ var STRICT_RULES = {
   "@sarj/prefer-module-level-refined-schema": "warn",
   "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
   "@sarj/prefer-named-callback-domain": "error",
-  "@sarj/prefer-nominal-id-types": "warn",
-  "@sarj/prefer-named-complex-return-type": "warn",
+  "@sarj/prefer-nominal-id-types": "error",
+  "@sarj/prefer-named-complex-return-type": "error",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",
   "@sarj/prefer-non-nullable-collection": "error",
@@ -25112,7 +25195,7 @@ var STRICT_RULES = {
   "@sarj/prefer-await-in-async-return": "error",
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-shared-zod-enum": "warn",
-  "@sarj/prefer-switch-for-repeated-equality": "warn",
+  "@sarj/prefer-switch-for-repeated-equality": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
   "@sarj/prefer-whole-object-assertion": "warn",
@@ -25121,9 +25204,9 @@ var STRICT_RULES = {
   "@sarj/prefer-zod-parse-output-type": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
-  "@sarj/require-explicit-contract-implementation": "warn",
-  "@sarj/require-explicit-service-contract": "warn",
-  "@sarj/require-interface-for-exported-class": "warn",
+  "@sarj/require-explicit-contract-implementation": "error",
+  "@sarj/require-explicit-service-contract": "error",
+  "@sarj/require-interface-for-exported-class": "error",
   "@sarj/require-port-for-service": "error",
   "@sarj/require-sql-access-class": "warn",
   "@sarj/require-static-next-matcher": "error",