@sarj/eslint-plugin 16.4.6 → 16.4.8

package/dist/index.cjs

@@ -49,6 +49,125 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// package.json
+var package_default = {
+  name: "@sarj/eslint-plugin",
+  version: "16.4.8",
+  packageManager: "npm@12.1.0",
+  description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  sideEffects: false,
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sarj-ai/code-standards.git",
+    directory: "packages/typescript"
+  },
+  homepage: "https://code-standards.sarj.ai/rules/eslint/",
+  bugs: {
+    url: "https://github.com/sarj-ai/code-standards/issues"
+  },
+  scripts: {
+    build: "tsup",
+    dogfood: "npm run build && npm run dogfood:built",
+    lint: "eslint . ../../.github/scripts ../standards/src ../standards/eslint.config.mjs --max-warnings 0",
+    prepack: "npm run build && npm run verify-package",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    "verify-package": `node -e "const fs=require('node:fs'),p=require('./package.json'),walk=x=>typeof x==='string'?[x]:x&&typeof x==='object'?Object.values(x).flatMap(walk):[];for(const file of new Set([p.main,p.module,p.types,...walk(p.exports)].filter(Boolean).map(x=>x.startsWith('./')?x.slice(2):x))){if(!file.startsWith('dist/'))throw new Error('export must live under dist: '+file);const stat=fs.statSync(file);if(!stat.isFile()||stat.size===0)throw new Error('missing or empty export: '+file)}"`,
+    "dogfood:built": `eslint --config eslint.dogfood.config.mjs src tests eslint.config.mjs eslint.dogfood.config.mjs module-constant-naming-options.mjs tsup.config.ts vitest.config.ts --max-warnings 0 && node -e "import('./dist/index.js').then(({default:p}) => console.log('dogfood: '+Object.keys(p.rules).length+' TypeScript rules, 0 diagnostics'))"`
+  },
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "sarj",
+    "react",
+    "nextjs",
+    "zod"
+  ],
+  author: "sarj-ai",
+  license: "MIT",
+  dependencies: {
+    "@typescript-eslint/typescript-estree": "^8.70.1",
+    "@typescript-eslint/utils": "^8.70.1",
+    "jsonc-parser": "^3.3.1"
+  },
+  devDependencies: {
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
+    "@eslint/compat": "^2.1.1",
+    "@eslint/js": "10.0.1",
+    "@shadcn/lint": "0.2.0",
+    "@types/node": "26.6.2",
+    "@typescript-eslint/parser": "8.70.1",
+    "@typescript-eslint/rule-tester": "8.70.1",
+    "@typescript-eslint/utils": "8.70.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "@vitest/eslint-plugin": "1.6.27",
+    eslint: "10.11.0",
+    "eslint-node-test": "0.4.0",
+    "eslint-plugin-better-tailwindcss": "^4.7.0",
+    "eslint-plugin-jest": "29.16.6",
+    "eslint-plugin-jsdoc": "64.5.4",
+    "eslint-plugin-n": "^18.3.0",
+    "eslint-plugin-perfectionist": "5.12.1",
+    "eslint-plugin-playwright": "2.12.0",
+    "eslint-plugin-promise": "^7.3.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "eslint-plugin-testing-library": "7.16.2",
+    "eslint-plugin-unicorn": "^76.0.0",
+    "eslint-plugin-zod": "^4.14.2",
+    globals: "15.15.0",
+    tsup: "latest",
+    typescript: "npm:@typescript/typescript6@6.0.2",
+    "typescript-eslint": "^8.70.1",
+    vitest: "5.0.1"
+  },
+  peerDependencies: {
+    eslint: ">=9.39.4",
+    typescript: ">=5.0.0"
+  },
+  engines: {
+    node: ">=22.22.2"
+  },
+  allowScripts: {
+    "esbuild@0.28.2": true,
+    "fsevents@2.3.3": true
+  },
+  peerDependenciesMeta: {
+    typescript: {
+      optional: true
+    }
+  },
+  overrides: {
+    "brace-expansion@^5.0.0": "5.0.9",
+    esbuild: "0.28.2",
+    "nanoid@<3.3.18": "3.3.18",
+    "eslint-plugin-react": {
+      eslint: "$eslint"
+    }
+  }
+};
+
 // src/rules/require-explicit-contract-implementation.ts
 var import_utils2 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
@@ -262,6 +381,7 @@ function deepFreeze(value) {
 }
 
 // src/rules/_paths.ts
+var LINE_TERMINATOR_RE = /[\n\r\u2028\u2029]/u;
 var SCRIPT_FILE_RE = /(?:^|[\\/])scripts[\\/]|\.mjs$/;
 var STORY_FILE_RE = /\.stories\.[cm]?[jt]sx?$/i;
 var STORY_TREE_RE = /(^|\/)stories(?:[_-][^/]*)?\//i;
@@ -311,8 +431,8 @@ function leadingCommentBodies(sourceText) {
   const bodies = [];
   let index = 0;
   if (sourceText.startsWith("#!")) {
-    const shebangEnd = sourceText.indexOf("\n");
-    index = shebangEnd === -1 ? sourceText.length : shebangEnd + 1;
+    const shebangEnd = commentLineEnd(sourceText, 2);
+    index = shebangEnd === sourceText.length ? sourceText.length : shebangEnd + 1;
   }
   while (index < sourceText.length) {
     while (/\s/u.test(sourceText[index] ?? "")) index++;
@@ -326,7 +446,7 @@ function leadingCommentBodies(sourceText) {
       const end = sourceText.indexOf("*/", index + 2);
       if (end === -1) break;
       bodies.push(
-        ...sourceText.slice(index + 2, end).split("\n").map((line) => line.replace(/^\s*\*?\s?/u, "").trim()).filter((line) => line.length > 0)
+        ...sourceText.slice(index + 2, end).split(LINE_TERMINATOR_RE).map((line) => line.replace(/^\s*\*?\s?/u, "").trim()).filter((line) => line.length > 0)
       );
       index = end + 2;
       continue;
@@ -345,8 +465,8 @@ function isScriptFile(filename) {
   return SCRIPT_FILE_RE.test(filename);
 }
 function commentLineEnd(sourceText, start) {
-  const end = sourceText.indexOf("\n", start);
-  return end === -1 ? sourceText.length : end;
+  const end = sourceText.slice(start).search(LINE_TERMINATOR_RE);
+  return end === -1 ? sourceText.length : start + end;
 }
 
 // src/rules/require-explicit-contract-implementation.ts
@@ -4793,6 +4913,41 @@ function staticString(node) {
   if (value.type === import_utils29.AST_NODE_TYPES.Literal && typeof value.value === "string") return value.value;
   return value.type === import_utils29.AST_NODE_TYPES.TemplateLiteral && value.expressions.length === 0 ? value.quasis[0]?.value.cooked ?? null : null;
 }
+var SCOPED_STRING_VALUES = /* @__PURE__ */ new WeakMap();
+function scopedStaticString(node, sourceCode) {
+  let value = unwrapExpression(node);
+  if (value.type !== import_utils29.AST_NODE_TYPES.Identifier) return staticString(value);
+  let values = SCOPED_STRING_VALUES.get(sourceCode);
+  if (values === void 0) {
+    values = /* @__PURE__ */ new WeakMap();
+    SCOPED_STRING_VALUES.set(sourceCode, values);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [];
+  let result = null;
+  while (value.type === import_utils29.AST_NODE_TYPES.Identifier) {
+    const binding = import_utils29.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+    if (binding === null || seen.has(binding)) break;
+    if (values.has(binding)) {
+      result = values.get(binding) ?? null;
+      break;
+    }
+    seen.add(binding);
+    pending.push(binding);
+    const definition = binding.defs.length === 1 ? binding.defs[0] : void 0;
+    if (definition?.type !== "Variable" || definition.node.id.type !== import_utils29.AST_NODE_TYPES.Identifier || definition.node.init === null || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) break;
+    value = unwrapExpression(definition.node.init);
+    if (value.type !== import_utils29.AST_NODE_TYPES.Identifier) result = staticString(value);
+  }
+  for (const binding of pending) values.set(binding, result);
+  return result;
+}
+function staticPropertyName(node, sourceCode) {
+  const direct = import_utils29.ASTUtils.getPropertyName(node);
+  if (direct !== null || !node.computed) return direct;
+  const key = node.type === import_utils29.AST_NODE_TYPES.MemberExpression ? node.property : node.key;
+  return key.type === import_utils29.AST_NODE_TYPES.Identifier ? scopedStaticString(key, sourceCode) : null;
+}
 
 // src/rules/no-duplicate-lifecycle-refresh-listeners.ts
 var NO_DUPLICATE_LIFECYCLE_REFRESH_LISTENERS_DOCUMENTATION = {
@@ -5473,7 +5628,9 @@ var NO_ENUM_DOCUMENTATION = {
       focusPath: "src/status.ts",
       expectedCount: 1,
       public: true
-    }
+    },
+    { id: "authored-after-comment", scenarioId: "native-header-boundary", title: "Keep executable authored code in scope", outcome: "match", files: [{ path: "src/status.ts", source: '// ordinary header\u2028const marker="auto-generated file"; enum Mode {Start} console.log(Mode.Start, marker);' }], focusPath: "src/status.ts", expectedCount: 1, public: true },
+    { id: "generated-header", scenarioId: "native-header-boundary", title: "Respect a native generated banner", outcome: "no-match", files: [{ path: "src/status.ts", source: '// auto-generated file\u2028const marker="auto-generated file"; enum Mode {Start} console.log(Mode.Start, marker);' }], focusPath: "src/status.ts", expectedCount: 0, public: true }
   ]
 };
 function matchesAnyPattern(filename, patterns) {
@@ -6830,29 +6987,26 @@ var NO_JSON_STRINGIFY_ERROR_DOCUMENTATION = {
   rationale: "Native Error details are non-enumerable, so generic JSON serialization discards diagnostic information.",
   remediation: "Serialize explicit error fields or use an error-aware serializer.",
   category: "correctness",
-  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Custom replacers are left to their serializer contract; a catch value is not guaranteed to be an Error."],
+  limitations: ["The rule uses stable local catch bindings and unshadowed built-in constructors, not runtime type information. Custom replacers and explicit toJSON hooks are left to their serializer contract; a catch value is not guaranteed to be an Error. Member values, including cause, do not inherit the base Error's provenance; even an Error-valued member requires explicit value/dataflow proof outside this rule. Known literal __proto__ initializer chains preserve native hook inheritance and own toJSON precedence; computed __proto__ keys remain data. Unknown prototype expressions, hook values/spreads and deferred hook writes conservatively lose default serializer proof. Explicit writes invalidate constructor provenance except a later, separate top-level statement; deferred functions, loops, and unknown property keys conservatively lose constructor proof. Statically owned global/property writes and native Reflect.set/Reflect.defineProperty/Object.defineProperty/Object.defineProperties calls are tracked. Mutator aliases, replaced Reflect/Object methods, external calls, and runtime-only property names are not resolved; uncertain ordering conservatively loses proof."],
   examples: [
     { id: "explicit-error-message", title: "Narrow an unknown catch value before selecting fields", outcome: "no-match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err instanceof Error ? err.message : String(err) }); }" }], focusPath: "src/report.ts", expectedCount: 0, public: true },
-    { id: "stringified-error", title: "Do not stringify an Error object", outcome: "match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err }); }" }], focusPath: "src/report.ts", expectedCount: 1, public: true }
+    { id: "stringified-error", title: "Do not stringify an Error object", outcome: "match", files: [{ path: "src/report.ts", source: "try { f(); } catch (err) { JSON.stringify({ error: err }); }" }], focusPath: "src/report.ts", expectedCount: 1, public: true },
+    { id: "shadowed-error-binding", scenarioId: "binding-provenance", title: "Keep native binding provenance", outcome: "match", files: [{ path: "src/error.ts", source: 'function probe(){try{throw {id:1};}catch(err){if(err instanceof Error)return err.message;{const err=new Error("lost");return JSON.stringify(err);}}}\nconsole.log(probe());' }], focusPath: "src/error.ts", expectedCount: 1, public: true },
+    { id: "escaped-fallback-binding", scenarioId: "binding-provenance", title: "Keep native binding provenance", outcome: "no-match", files: [{ path: "src/error.ts", source: "function probe(){try{throw {id:1};}catch(err){if(err instanceof Error)return err.message;return JSON.stringify(\\u0065rr);}}\nconsole.log(probe());" }], focusPath: "src/error.ts", expectedCount: 0, public: true },
+    { id: "constructor-before-write", scenarioId: "explicit-constructor-write", title: "A later write does not change an already constructed native Error", outcome: "match", files: [{ path: "src/error.js", source: "const value=new Error('lost');Error=class Other{message='kept'};JSON.stringify(value);" }], focusPath: "src/error.js", expectedCount: 1, public: true },
+    { id: "constructor-after-write", scenarioId: "explicit-constructor-write", title: "A replaced constructor does not prove a native Error", outcome: "no-match", files: [{ path: "src/error.js", source: "Error=class Other{message='kept'};const value=new Error();JSON.stringify(value);" }], focusPath: "src/error.js", expectedCount: 0, public: true },
+    { "id": "native-serializer-before-write", "scenarioId": "explicit-serializer-write", "title": "A later write does not change an earlier native serialization", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const result=JSON.stringify(new Error('lost'));JSON.stringify=value=>'kept:'+value.message;" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "native-serializer-after-write", "scenarioId": "explicit-serializer-write", "title": "A replaced serializer owns its error-field contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify=value=>'kept:'+value.message;JSON.stringify(new Error('lost'));" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "static-serializer-key", "scenarioId": "static-property-provenance", "title": "A constant computed serializer still loses native Error details", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const key='stringify';JSON[key](new Error('lost'));" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "static-error-field", "scenarioId": "static-property-provenance", "title": "A constant message field selects the explicit string escape hatch", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "const key='message';const error=new Error('lost');JSON.stringify(error[key]);" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "scalar-cause", "scenarioId": "member-value-provenance", "title": "Native Error cause can be a string value", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "const error=new Error('lost',{cause:'kept'});JSON.stringify(error.cause);" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "whole-error-with-cause", "scenarioId": "member-value-provenance", "title": "Serializing the whole Error still loses its native details", "outcome": "match", "files": [{ "path": "src/error.js", "source": "const error=new Error('lost',{cause:'kept'});JSON.stringify(error);" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "explicit-to-json-hook", "scenarioId": "custom-serializer-contract", "title": "An explicit callable toJSON owns its serialization contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),toJSON(){return {message:'kept'};}});" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "noncallable-to-json", "scenarioId": "custom-serializer-contract", "title": "A noncallable toJSON does not replace native serialization", "outcome": "match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),toJSON:42});" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true },
+    { "id": "literal-prototype-hook", "scenarioId": "native-prototype-serializer", "title": "A literal prototype hook owns the payload serializer contract", "outcome": "no-match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),__proto__:{toJSON(){return {message:'kept'};}}});" }], "focusPath": "src/error.js", "expectedCount": 0, "public": true },
+    { "id": "computed-prototype-data", "scenarioId": "native-prototype-serializer", "title": "A computed prototype name remains ordinary serialized data", "outcome": "match", "files": [{ "path": "src/error.js", "source": "JSON.stringify({error:new Error('lost'),['__proto__']:{toJSON(){return {message:'kept'};}}});" }], "focusPath": "src/error.js", "expectedCount": 1, "public": true }
   ]
 };
-var SAFE_STRING_PROPS = /* @__PURE__ */ new Set(["message", "stack", "name"]);
-var PAYLOAD_PROPS = /* @__PURE__ */ new Set([
-  "data",
-  "status",
-  "statuscode",
-  "statustext",
-  "code",
-  "issues",
-  "details",
-  "body",
-  "payload",
-  "response",
-  "info",
-  "meta",
-  "metadata",
-  "context"
-]);
 var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "AggregateError",
   "Error",
@@ -6863,25 +7017,211 @@ var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "TypeError",
   "URIError"
 ]);
-function identifierIsProvenError(identifier, scope) {
-  const variable = import_utils41.ASTUtils.findVariable(scope, identifier.name);
-  if (variable === null || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
-  const definition = variable.defs[0];
-  if (definition?.type === "CatchClause") return true;
-  if (definition?.type !== "Variable") return false;
-  const initializer = definition.node.init;
-  return initializer?.type === "NewExpression" && initializer.callee.type === "Identifier" && BUILTIN_ERROR_CONSTRUCTORS.has(initializer.callee.name) && isGlobalIdentifier(initializer.callee.name, scope);
+var TRACKED_BUILTINS = /* @__PURE__ */ new Set([...BUILTIN_ERROR_CONSTRUCTORS, "JSON", "JSON.stringify"]);
+function nativeObjectName(expression, sourceCode) {
+  const value = unwrapExpression(expression);
+  const scope = sourceCode.getScope(value);
+  if (value.type === "Identifier" && (value.name === "globalThis" || value.name === "JSON") && isGlobalIdentifier(value.name, scope)) return value.name;
+  if (value.type === "MemberExpression" && nativeObjectName(value.object, sourceCode) === "globalThis" && staticPropertyName(value, sourceCode) === "JSON") return "JSON";
+  return null;
+}
+function globalBuiltinName(expression, sourceCode) {
+  const value = unwrapExpression(expression);
+  const scope = sourceCode.getScope(value);
+  if (value.type === "Identifier") return TRACKED_BUILTINS.has(value.name) && isGlobalIdentifier(value.name, scope) ? value.name : null;
+  if (value.type !== "MemberExpression") return null;
+  const receiver = nativeObjectName(value.object, sourceCode);
+  const name = staticPropertyName(value, sourceCode);
+  if (receiver === "JSON") return name === "stringify" ? "JSON.stringify" : null;
+  return receiver === "globalThis" && name !== null && name !== "JSON.stringify" && TRACKED_BUILTINS.has(name) ? name : null;
+}
+function writePreservesBuiltin(target, sourceCode) {
+  const assignment = target.parent;
+  if (assignment?.type !== "AssignmentExpression" || assignment.left !== target) return false;
+  const name = globalBuiltinName(target, sourceCode);
+  if (name === null) return false;
+  if (assignment.operator === "||=" || assignment.operator === "??=") return true;
+  return (assignment.operator === "=" || assignment.operator === "&&=") && globalBuiltinName(assignment.right, sourceCode) === name;
+}
+function mayBeCallable(value) {
+  return !["Literal", "TemplateLiteral", "ObjectExpression", "ArrayExpression"].includes(value.type);
+}
+var BUILTIN_WRITES = /* @__PURE__ */ new WeakMap();
+function directProgramStatement(node) {
+  let current = node;
+  while (current.parent !== void 0) {
+    if (current.parent.type === "Program") return current;
+    if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression", "ClassBody", "StaticBlock", "ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement"].includes(current.parent.type)) return null;
+    current = current.parent;
+  }
+  return null;
+}
+function hasUnchangedBuiltin(name, read, sourceCode) {
+  const summary = builtinWrites(sourceCode).get(name);
+  if (summary === void 0) return true;
+  const statement = directProgramStatement(read);
+  return !summary.unknownOrder && statement !== null && statement.range[1] <= summary.earliestStatementStart;
+}
+function builtinWrites(sourceCode) {
+  const cached = BUILTIN_WRITES.get(sourceCode);
+  if (cached !== void 0) return cached;
+  const writes = /* @__PURE__ */ new Map();
+  const record = (name, node) => {
+    const statement = directProgramStatement(node);
+    const existing = writes.get(name);
+    writes.set(name, { earliestStatementStart: Math.min(existing?.earliestStatementStart ?? Infinity, statement?.range[0] ?? Infinity), unknownOrder: (existing?.unknownOrder ?? false) || statement === null });
+  };
+  for (const scope of sourceCode.scopeManager?.scopes ?? []) {
+    for (const reference of scope.references) {
+      const name = reference.identifier.name;
+      if (reference.identifier.type === "Identifier" && reference.isWrite() && TRACKED_BUILTINS.has(name) && (reference.resolved === null || reference.resolved.defs.length === 0) && !writePreservesBuiltin(reference.identifier, sourceCode)) record(name, reference.identifier);
+    }
+  }
+  const propertyReceiver = (expression) => {
+    const native = nativeObjectName(expression, sourceCode);
+    if (native !== null) return native;
+    const value = unwrapExpression(expression);
+    if (value.type === "Identifier") return import_utils41.ASTUtils.findVariable(sourceCode.getScope(value), value.name);
+    if (value.type === "MemberExpression" && staticPropertyName(value, sourceCode) === "prototype") {
+      const constructor = globalBuiltinName(value.object, sourceCode);
+      if (constructor !== null && BUILTIN_ERROR_CONSTRUCTORS.has(constructor)) return constructor + ".prototype";
+    }
+    return null;
+  };
+  const propertyWrite = (receiver, name, node) => {
+    if (receiver === "JSON") {
+      if (name === null || name === "stringify") record("JSON.stringify", node);
+    } else if (receiver === "globalThis") {
+      if (name === null) {
+        for (const builtin of TRACKED_BUILTINS) record(builtin, node);
+      } else if (name !== "JSON.stringify" && TRACKED_BUILTINS.has(name)) record(name, node);
+    } else if (name === null || name === "toJSON") record(receiver, node);
+  };
+  const visit = (node) => {
+    if (node.type === "AssignmentExpression") propertyTarget(node.left);
+    else if (node.type === "UpdateExpression") propertyTarget(node.argument);
+    else if (node.type === "ForInStatement" || node.type === "ForOfStatement") propertyTarget(node.left);
+    else if (node.type === "UnaryExpression" && node.operator === "delete") propertyTarget(node.argument);
+    else if (node.type === "CallExpression") mutationCall(node);
+    forEachAstChild(node, sourceCode.visitorKeys, visit);
+  };
+  function propertyTarget(target) {
+    if (target.type === "MemberExpression") {
+      memberPropertyWrite(target);
+      return;
+    }
+    switch (target.type) {
+      case "ObjectPattern":
+        for (const property of target.properties) propertyTarget(property.type === "RestElement" ? property.argument : property.value);
+        return;
+      case "ArrayPattern":
+        for (const element of target.elements) if (element !== null) propertyTarget(element);
+        return;
+      case "AssignmentPattern":
+        propertyTarget(target.left);
+        return;
+      case "RestElement":
+        propertyTarget(target.argument);
+    }
+  }
+  function memberPropertyWrite(target) {
+    const receiver = propertyReceiver(target.object);
+    if (receiver === null || writePreservesBuiltin(target, sourceCode)) return;
+    const name = staticPropertyName(target, sourceCode);
+    if (name === "toJSON") {
+      const assignment = target.parent;
+      if (assignment?.type === "UnaryExpression" && assignment.operator === "delete") return;
+      if (assignment?.type === "AssignmentExpression" && assignment.operator === "=" && !mayBeCallable(assignment.right)) return;
+    }
+    propertyWrite(receiver, name, target);
+  }
+  function mutationCall(node) {
+    const callee = unwrapExpression(node.callee);
+    if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return;
+    const owner = callee.object.name;
+    if (!["Reflect", "Object"].includes(owner) || !isGlobalIdentifier(owner, sourceCode.getScope(callee))) return;
+    const method = staticPropertyName(callee, sourceCode);
+    const [target, key, value, receiver] = node.arguments;
+    if (target === void 0 || target.type === "SpreadElement" || key === void 0) return;
+    const object = propertyReceiver(target);
+    if (object === null) return;
+    switch (method) {
+      case "set":
+        if (owner === "Reflect") reflectSet(object, scopedStaticString(key, sourceCode), value, receiver, node);
+        return;
+      case "defineProperty":
+        descriptorWrite(object, scopedStaticString(key, sourceCode), value, node);
+        return;
+      case "defineProperties":
+        if (owner === "Object") descriptorBatch(object, key, node);
+    }
+  }
+  function reflectSet(object, name, value, receiver, node) {
+    if (receiver !== void 0 && receiver.type !== "SpreadElement" && ["ObjectExpression", "ArrayExpression", "Literal"].includes(unwrapExpression(receiver).type)) return;
+    const builtin = builtinPropertyName(object, name);
+    if (value !== void 0 && value.type !== "SpreadElement" && builtin !== null && globalBuiltinName(value, sourceCode) === builtin) return;
+    if (name === "toJSON" && value !== void 0 && !mayBeCallable(value)) return;
+    propertyWrite(object, name, node);
+  }
+  function descriptorBatch(object, descriptors, node) {
+    if (descriptors.type !== "ObjectExpression") {
+      propertyWrite(object, null, node);
+      return;
+    }
+    for (const property of descriptors.properties) {
+      if (property.type !== "Property") {
+        propertyWrite(object, null, node);
+        continue;
+      }
+      descriptorWrite(object, staticPropertyName(property, sourceCode), property.value, node);
+    }
+  }
+  function descriptorWrite(object, name, descriptor, node) {
+    if (descriptor !== void 0 && !descriptorChangesValue(descriptor, builtinPropertyName(object, name))) return;
+    propertyWrite(object, name, node);
+  }
+  function descriptorChangesValue(descriptor, name) {
+    if (descriptor.type !== "ObjectExpression") return true;
+    return descriptor.properties.some((property) => {
+      if (property.type !== "Property") return true;
+      const key = staticPropertyName(property, sourceCode);
+      if (key === "value" && name === "toJSON" && !mayBeCallable(property.value)) return false;
+      if (key === "value" && property.value.type !== "AssignmentPattern" && property.value.type !== "ArrayPattern" && property.value.type !== "ObjectPattern" && property.value.type !== "TSEmptyBodyFunctionExpression") return name === null || globalBuiltinName(property.value, sourceCode) !== name;
+      return key === null || key === "get" || key === "set";
+    });
+  }
+  function builtinPropertyName(object, name) {
+    return object === "JSON" && name === "stringify" ? "JSON.stringify" : name;
+  }
+  visit(sourceCode.ast);
+  BUILTIN_WRITES.set(sourceCode, writes);
+  return writes;
+}
+function hasDefaultErrorSerialization(expression, call, sourceCode) {
+  let constructor = null;
+  if (expression.type === "Identifier") {
+    const variable = import_utils41.ASTUtils.findVariable(sourceCode.getScope(expression), expression.name);
+    if (variable !== null && !hasUnchangedBuiltin(variable, call, sourceCode)) return false;
+    const definition = variable?.defs[0];
+    const initializer = definition?.type === "Variable" ? definition.node.init : null;
+    if (initializer?.type === "NewExpression" && initializer.callee.type === "Identifier") constructor = initializer.callee.name;
+  } else if (expression.type === "NewExpression" && expression.callee.type === "Identifier") constructor = expression.callee.name;
+  const families = constructor === null ? BUILTIN_ERROR_CONSTRUCTORS : ["Error", constructor];
+  return [...families].every((name) => hasUnchangedBuiltin(name + ".prototype", call, sourceCode));
+}
+function isBuiltinErrorConstructor(identifier, sourceCode) {
+  return sourceCode.scopeManager !== null && BUILTIN_ERROR_CONSTRUCTORS.has(identifier.name) && isGlobalIdentifier(identifier.name, sourceCode.getScope(identifier)) && hasUnchangedBuiltin(identifier.name, identifier, sourceCode);
 }
 function isGlobalIdentifier(name, scope) {
   const binding = import_utils41.ASTUtils.findVariable(scope, name);
   return binding === null || binding.defs.length === 0;
 }
-function positiveErrorSubject(test) {
-  return instanceofErrorSubject(test) ?? typeGuardSubject(test);
+function positiveErrorSubject(test, sourceCode) {
+  return instanceofErrorSubject(test, sourceCode) ?? typeGuardSubject(test);
 }
 var TYPE_GUARD_PATTERN = /^(is|has)[A-Z]/;
-function instanceofErrorSubject(test) {
-  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.right.type === "Identifier" && test.right.name === "Error") {
+function instanceofErrorSubject(test, sourceCode) {
+  if (test.type === "BinaryExpression" && test.operator === "instanceof" && test.right.type === "Identifier" && test.right.name === "Error" && isBuiltinErrorConstructor(test.right, sourceCode)) {
     return test.left;
   }
   return null;
@@ -6895,36 +7235,34 @@ function typeGuardSubject(test) {
   return null;
 }
 function isNarrowedByEarlyReturn(node, argExpr, sourceCode) {
-  const argText = sourceCode.getText(argExpr);
   let current = node.parent;
   while (current) {
     if (current.type === "BlockStatement" || current.type === "Program") {
-      if (hasEarlierErrorGuard(current.body, node, argText, sourceCode)) return true;
+      if (hasEarlierErrorGuard(current.body, node, argExpr, sourceCode)) return true;
     }
     current = current.parent;
   }
   return false;
 }
 function isGuardedByInstanceofError(node, argExpr, sourceCode) {
-  const argText = sourceCode.getText(argExpr);
-  const sameSubject = (subject) => sourceCode.getText(subject) === argText;
+  const sameSubject = (subject) => sameSubjectBinding(subject, argExpr, sourceCode);
   let current = node.parent;
   while (current) {
     if (current.type === "ConditionalExpression") {
-      const subject = positiveErrorSubject(current.test);
+      const subject = positiveErrorSubject(current.test, sourceCode);
       if (subject && sameSubject(subject) && nodeWithin(node, current.alternate)) {
         return true;
       }
-      const negated = negatedInstanceofErrorSubject(current.test);
+      const negated = negatedInstanceofErrorSubject(current.test, sourceCode);
       if (negated && sameSubject(negated) && nodeWithin(node, current.consequent)) {
         return true;
       }
     } else if (current.type === "IfStatement") {
-      const subject = positiveErrorSubject(current.test);
+      const subject = positiveErrorSubject(current.test, sourceCode);
       if (subject && sameSubject(subject) && nodeWithin(node, current.alternate)) {
         return true;
       }
-      const negated = negatedInstanceofErrorSubject(current.test);
+      const negated = negatedInstanceofErrorSubject(current.test, sourceCode);
       if (negated && sameSubject(negated) && nodeWithin(node, current.consequent)) {
         return true;
       }
@@ -6933,25 +7271,35 @@ function isGuardedByInstanceofError(node, argExpr, sourceCode) {
   }
   return false;
 }
-function negatedInstanceofErrorSubject(test) {
+function negatedInstanceofErrorSubject(test, sourceCode) {
   if (test.type === "UnaryExpression" && test.operator === "!") {
-    return positiveErrorSubject(test.argument);
+    return positiveErrorSubject(test.argument, sourceCode);
   }
   return null;
 }
+function sameSubjectBinding(subject, value, sourceCode) {
+  const left = unwrapExpression(subject);
+  const right = unwrapExpression(value);
+  if (left.type === "Identifier" && right.type === "Identifier") {
+    const binding = import_utils41.ASTUtils.findVariable(sourceCode.getScope(left), left.name);
+    return binding !== null && binding === import_utils41.ASTUtils.findVariable(sourceCode.getScope(right), right.name);
+  }
+  return sourceCode.getText(subject) === sourceCode.getText(value);
+}
 function nodeWithin(node, container) {
   return container !== null && node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
 }
-function isJsonStringify(callee) {
+function isJsonStringify(callee, sourceCode) {
   if (callee.type !== "MemberExpression") return false;
   const receiver = unwrapExpression(callee.object);
-  return callee.type === "MemberExpression" && receiver.type === "Identifier" && receiver.name === "JSON" && import_utils41.ASTUtils.getPropertyName(callee) === "stringify";
+  return callee.type === "MemberExpression" && receiver.type === "Identifier" && receiver.name === "JSON" && staticPropertyName(callee, sourceCode) === "stringify";
 }
-function directLiteralValues(argument) {
+function directLiteralValues(argument, sourceCode) {
   argument = unwrapExpression(argument);
   if (argument.type === "ObjectExpression") {
+    if (literalHasSerializer(argument, sourceCode)) return [];
     return argument.properties.flatMap((property) => {
-      if (property.type !== "Property" || import_utils41.ASTUtils.getPropertyName(property) === null) return [];
+      if (property.type !== "Property" || staticPropertyName(property, sourceCode) === null) return [];
       const value = property.value;
       if (value.type === "AssignmentPattern" || value.type === "ArrayPattern" || value.type === "ObjectPattern" || value.type === "TSEmptyBodyFunctionExpression") {
         return [];
@@ -6966,30 +7314,40 @@ function directLiteralValues(argument) {
   }
   return argument.type === "SpreadElement" ? [] : [argument];
 }
-function expressionSuggestsError(expression, scope) {
+function literalHasSerializer(argument, sourceCode) {
+  for (const property of argument.properties.toReversed()) {
+    if (property.type !== "Property") return true;
+    const key = staticPropertyName(property, sourceCode);
+    if (key === null) return true;
+    if (key === "toJSON") return mayBeCallable(property.value);
+  }
+  for (const property of argument.properties) {
+    if (property.type !== "Property" || property.computed || property.method || property.shorthand || property.kind !== "init" || staticPropertyName(property, sourceCode) !== "__proto__") continue;
+    const prototype = property.value;
+    return prototype.type === "ObjectExpression" ? literalHasSerializer(prototype, sourceCode) : prototype.type !== "Literal" || "regex" in prototype && prototype.regex !== void 0;
+  }
+  return false;
+}
+function expressionSuggestsError(expression, sourceCode) {
   expression = unwrapExpression(expression);
   const unwrappedExpressionCallee = expression.type === "CallExpression" || expression.type === "NewExpression" ? unwrapExpression(expression.callee) : null;
   if (expression.type === "Identifier") {
-    return identifierIsProvenError(expression, scope);
+    return identifierIsProvenError(expression, sourceCode);
   }
   if (expression.type === "NewExpression" && unwrappedExpressionCallee?.type === "Identifier") {
-    return BUILTIN_ERROR_CONSTRUCTORS.has(unwrappedExpressionCallee.name) && isGlobalIdentifier(unwrappedExpressionCallee.name, scope);
-  }
-  return expression.type === "MemberExpression" && memberSuggestsError(expression, scope);
-}
-function memberSuggestsError(member, scope) {
-  const propName2 = import_utils41.ASTUtils.getPropertyName(member);
-  const base = member.object;
-  const baseSuggestsError = base.type === "Identifier" && identifierIsProvenError(base, scope);
-  if (baseSuggestsError) {
-    if (propName2 === null) {
-      return true;
-    }
-    const lowered = propName2.toLowerCase();
-    return !SAFE_STRING_PROPS.has(lowered) && !PAYLOAD_PROPS.has(lowered);
+    return isBuiltinErrorConstructor(unwrappedExpressionCallee, sourceCode);
   }
   return false;
 }
+function identifierIsProvenError(identifier, sourceCode) {
+  const variable = import_utils41.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+  if (variable === null || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
+  const definition = variable.defs[0];
+  if (definition?.type === "CatchClause") return true;
+  if (definition?.type !== "Variable") return false;
+  const initializer = definition.node.init;
+  return initializer?.type === "NewExpression" && initializer.callee.type === "Identifier" && isBuiltinErrorConstructor(initializer.callee, sourceCode);
+}
 var no_json_stringify_error_default = createRule({
   name: "no-json-stringify-error",
   documentation: NO_JSON_STRINGIFY_ERROR_DOCUMENTATION,
@@ -7008,7 +7366,7 @@ var no_json_stringify_error_default = createRule({
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (!isJsonStringify(unwrappedNodeCallee)) {
+        if (!isJsonStringify(unwrappedNodeCallee, context.sourceCode)) {
           return;
         }
         const firstArg = node.arguments[0];
@@ -7016,11 +7374,11 @@ var no_json_stringify_error_default = createRule({
           return;
         }
         const scope = context.sourceCode.getScope(firstArg);
-        if (!isGlobalIdentifier("JSON", scope)) return;
+        if (!isGlobalIdentifier("JSON", scope) || !hasUnchangedBuiltin("JSON", node, context.sourceCode) || !hasUnchangedBuiltin("JSON.stringify", node, context.sourceCode)) return;
         const replacer = node.arguments[1] === void 0 ? void 0 : unwrapExpression(node.arguments[1]);
         if (replacer !== void 0 && !(replacer.type === "Literal" && replacer.value === null) && !(replacer.type === "Identifier" && replacer.name === "undefined" && isGlobalIdentifier("undefined", scope))) return;
-        const unsafeValue = directLiteralValues(firstArg).find(
-          (value) => expressionSuggestsError(value, scope) && !isGuardedByInstanceofError(node, value, context.sourceCode) && !isNarrowedByEarlyReturn(node, value, context.sourceCode)
+        const unsafeValue = directLiteralValues(firstArg, context.sourceCode).find(
+          (value) => expressionSuggestsError(value, context.sourceCode) && hasDefaultErrorSerialization(unwrapExpression(value), node, context.sourceCode) && !isGuardedByInstanceofError(node, value, context.sourceCode) && !isNarrowedByEarlyReturn(node, value, context.sourceCode)
         );
         if (unsafeValue === void 0) {
           return;
@@ -7033,14 +7391,14 @@ var no_json_stringify_error_default = createRule({
     };
   }
 });
-function hasEarlierErrorGuard(statements, node, argText, sourceCode) {
+function hasEarlierErrorGuard(statements, node, argExpr, sourceCode) {
   for (const stmt of statements) {
     if (stmt.range[0] >= node.range[0]) {
       break;
     }
     if (stmt.type === "IfStatement" && stmt.alternate === null && branchTerminates(stmt.consequent)) {
-      const subject = positiveErrorSubject(stmt.test);
-      if (subject && sourceCode.getText(subject) === argText) {
+      const subject = positiveErrorSubject(stmt.test, sourceCode);
+      if (subject && sameSubjectBinding(subject, argExpr, sourceCode)) {
         return true;
       }
     }
@@ -8840,11 +9198,12 @@ var NO_OFFSET_PAGINATION_DOCUMENTATION = {
   limitations: ["A SELECT/FROM query shape or adjacent LIMIT/OFFSET fragment is required. Isolated OFFSET fragments and test files are excluded; this lexical context does not prove a database execution sink. Performance and concurrent-write behavior depend on indexes, ordering, isolation, and dialect; bounded pages and random page access can justify OFFSET."],
   examples: [
     { id: "keyset-pagination", title: "Page from a stable cursor", outcome: "no-match", files: [{ path: "src/runs.ts", source: "db.prepare(`SELECT id FROM runs WHERE id > ? ORDER BY id LIMIT ?`).all();" }], focusPath: "src/runs.ts", expectedCount: 0, public: true },
-    { id: "offset-pagination", title: "Do not page by offset", outcome: "match", files: [{ path: "src/runs.ts", source: "db.query(`SELECT id FROM runs ORDER BY id LIMIT ? OFFSET ?`);" }], focusPath: "src/runs.ts", expectedCount: 1, public: true }
+    { id: "offset-pagination", title: "Do not page by offset", outcome: "match", files: [{ path: "src/runs.ts", source: "db.query(`SELECT id FROM runs ORDER BY id LIMIT ? OFFSET ?`);" }], focusPath: "src/runs.ts", expectedCount: 1, public: true },
+    { id: "decoded-query", scenarioId: "native-decoded-sql", title: "Inspect native-decoded query text", outcome: "match", files: [{ path: "src/page.ts", source: 'db.query("SELECT id FROM runs ORDER BY id LIMIT 1 OFF\\u0053ET 1");' }], focusPath: "src/page.ts", expectedCount: 1, public: true },
+    { id: "decoded-comment-data", scenarioId: "native-decoded-sql", title: "Ignore native-decoded comment data", outcome: "no-match", files: [{ path: "src/page.ts", source: 'db.query("SELECT id FROM runs /* OFF\\x53ET 1 */");' }], focusPath: "src/page.ts", expectedCount: 0, public: true }
   ]
 };
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
-var OFFSET_GATE = /offset/i;
 var PAGINATION_CONTEXT = /\bSELECT\b[\s\S]*\bFROM\b[\s\S]*\bOFFSET\b|\bLIMIT\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)\s+OFFSET\b/i;
 var no_offset_pagination_default = createRule({
   name: "no-offset-pagination",
@@ -8861,7 +9220,7 @@ var no_offset_pagination_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || !OFFSET_GATE.test(context.sourceCode.text)) {
+    if (isTestFile(context.filename)) {
       return {};
     }
     return createSqlListener((sql, node) => {
@@ -10978,7 +11337,9 @@ var NO_SELECT_STAR_DOCUMENTATION = {
   limitations: ["Only statically visible embedded SQL is checked; quoted strings (including PostgreSQL dollar strings), comments, function arguments such as COUNT(*), and stars inside EXISTS are excluded. This is a bounded lexical scan, not a complete SQL parser."],
   examples: [
     { id: "explicit-projection", title: "Select the required columns", outcome: "no-match", files: [{ path: "src/runs.ts", source: "db.prepare(`SELECT id, status FROM runs`).all();" }], focusPath: "src/runs.ts", expectedCount: 0, public: true },
-    { id: "wildcard-projection", title: "Do not select every column", outcome: "match", files: [{ path: "src/runs.ts", source: "db.prepare(`SELECT * FROM runs`).all();" }], focusPath: "src/runs.ts", expectedCount: 1, public: true }
+    { id: "wildcard-projection", title: "Do not select every column", outcome: "match", files: [{ path: "src/runs.ts", source: "db.prepare(`SELECT * FROM runs`).all();" }], focusPath: "src/runs.ts", expectedCount: 1, public: true },
+    { id: "decoded-query", scenarioId: "native-decoded-sql", title: "Inspect native-decoded query text", outcome: "match", files: [{ path: "src/page.ts", source: 'db.query("SEL\\u0045CT * FROM runs");' }], focusPath: "src/page.ts", expectedCount: 1, public: true },
+    { id: "decoded-comment-data", scenarioId: "native-decoded-sql", title: "Ignore native-decoded comment data", outcome: "no-match", files: [{ path: "src/page.ts", source: 'db.query("SEL\\x45CT id FROM runs /* SELECT * FROM runs */");' }], focusPath: "src/page.ts", expectedCount: 0, public: true }
   ]
 };
 var QUERY_SHAPE = /\bSELECT\b[\s\S]*?\bFROM\b/i;
@@ -10986,7 +11347,6 @@ var SELECT_KEYWORD = /\bSELECT\b/gi;
 var FROM_KEYWORD = /^FROM\b/i;
 var EXISTS_BEFORE = /\bEXISTS\s*\(\s*$/i;
 var QUALIFIED_PREFIX = /\w\.$/;
-var SELECT_GATE = /select/i;
 function hasRealSelectStar(sql) {
   const selects = [...sql.matchAll(SELECT_KEYWORD)].map((m) => m.index);
   for (let pos = 0; pos < sql.length; pos++) {
@@ -11035,7 +11395,7 @@ var no_select_star_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || !SELECT_GATE.test(context.sourceCode.text)) {
+    if (isTestFile(context.filename)) {
       return {};
     }
     return createSqlListener((sql, node) => {
@@ -11492,10 +11852,12 @@ var NO_SILENT_PROMISE_CATCH_DOCUMENTATION = {
   rationale: "A swallowed rejection hides failures and gives callers an indistinguishable fallback value.",
   remediation: "Log, rethrow, or explicitly recover from the rejection; explain intentional teardown suppression.",
   category: "correctness",
-  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded. Other untyped catch-like APIs are not proven to be Promises."],
+  limitations: ["Test files, teardown calls, explanatory comments, non-function handlers, and handlers that consume or report the error are excluded.", "Recognized imported Zod construction chains and their stable local aliases are excluded. Other untyped catch-like APIs are not proven to be Promises.", "Computed methods resolve literal syntax and stable local string aliases in lexical scope. Function-derived, object-derived and mutated computed keys remain unproven."],
   examples: [
     { id: "reported-rejection", title: "Report the rejection", outcome: "no-match", files: [{ path: "src/load.ts", source: "load().catch((error) => logger.error({ error }, 'load failed'));" }], focusPath: "src/load.ts", expectedCount: 0, public: true },
-    { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true }
+    { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true },
+    { id: "stable-computed-catch", scenarioId: "computed-method-scope", title: "Report a rejection through a stable computed method", outcome: "match", files: [{ path: "src/load.ts", source: "const method = 'catch'; Promise.reject(new Error('lost'))[method](() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true },
+    { id: "stable-computed-body-parser", scenarioId: "computed-method-scope", title: "Preserve a recognized optional body parse fallback", outcome: "no-match", files: [{ path: "src/load.ts", source: "const method = 'json'; new Response('')[method]().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 0, public: true }
   ]
 };
 var BODY_PARSE_METHODS = /* @__PURE__ */ new Set([
@@ -11543,9 +11905,11 @@ var ZOD_CHAIN_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-function isBodyParseCall(node) {
+function isBodyParseCall(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) !== null && BODY_PARSE_METHODS.has(import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "");
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || node.arguments.length !== 0 || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
+  const method = staticPropertyName(unwrappedNodeCallee, sourceCode);
+  return method !== null && BODY_PARSE_METHODS.has(method);
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -11559,13 +11923,15 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
-function isTeardownCall(node) {
+function isTeardownCall(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) !== null && TEARDOWN_METHODS.has(import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "");
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
+  const method = staticPropertyName(unwrappedNodeCallee, sourceCode);
+  return method !== null && TEARDOWN_METHODS.has(method);
 }
-function isCancelledWebShare(node) {
+function isCancelledWebShare(node, sourceCode) {
   const unwrappedNodeCallee = node.type === "CallExpression" || node.type === "NewExpression" ? unwrapExpression(node.callee) : null;
-  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && unwrappedNodeCallee.object.type === import_utils68.AST_NODE_TYPES.Identifier && unwrappedNodeCallee.object.name === "navigator" && import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === "share";
+  return node.type === import_utils68.AST_NODE_TYPES.CallExpression && unwrappedNodeCallee?.type === import_utils68.AST_NODE_TYPES.MemberExpression && unwrappedNodeCallee.object.type === import_utils68.AST_NODE_TYPES.Identifier && unwrappedNodeCallee.object.name === "navigator" && staticPropertyName(unwrappedNodeCallee, sourceCode) === "share";
 }
 function isSilentHandler(handler) {
   const body2 = handler.body;
@@ -11629,9 +11995,9 @@ var no_silent_promise_catch_default = createRule({
         const [definition] = binding.defs;
         return binding.defs.length === 1 && definition?.node.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && definition.node.init !== null && isZodSchema(definition.node.init, seen);
       }
-      if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression || import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === null) return false;
+      if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || unwrappedNodeCallee?.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
       const { object } = unwrappedNodeCallee;
-      const method = import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee);
+      const method = staticPropertyName(unwrappedNodeCallee, context.sourceCode);
       if (object.type === import_utils68.AST_NODE_TYPES.Identifier && method !== null && ZOD_CONSTRUCTORS.has(method)) {
         const binding = import_utils68.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
         if (binding?.defs.some((definition) => {
@@ -11660,23 +12026,23 @@ var no_silent_promise_catch_default = createRule({
     return {
       CallExpression(node) {
         const unwrappedNodeCallee = unwrapExpression(node.callee);
-        if (unwrappedNodeCallee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) === null) {
+        if (unwrappedNodeCallee.type !== import_utils68.AST_NODE_TYPES.MemberExpression) {
           return;
         }
-        const method = import_utils68.ASTUtils.getPropertyName(unwrappedNodeCallee) ?? "";
+        const method = staticPropertyName(unwrappedNodeCallee, context.sourceCode);
         const handlerIndex = method === "catch" ? 0 : method === "then" ? 1 : null;
         if (handlerIndex === null) return;
         if (method === "catch" && isZodSchema(unwrappedNodeCallee.object)) return;
-        if (isBodyParseCall(unwrappedNodeCallee.object)) {
+        if (isBodyParseCall(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (isTeardownCall(unwrappedNodeCallee.object)) {
+        if (isTeardownCall(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (isCancelledWebShare(unwrappedNodeCallee.object)) {
+        if (isCancelledWebShare(unwrappedNodeCallee.object, context.sourceCode)) {
           return;
         }
-        if (node.parent.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.parent.object === node && import_utils68.ASTUtils.getPropertyName(node.parent) === "then") {
+        if (node.parent.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.parent.object === node && staticPropertyName(node.parent, context.sourceCode) === "then") {
           return;
         }
         const expectedArguments = method === "catch" ? 1 : 2;
@@ -18959,16 +19325,20 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   ],
   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: "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;}
+console.log(JSON.stringify(["a","b","c","d"].map(probe)));` }], focusPath: "src/dispatch.ts", expectedCount: 0, public: true }
   ]
 };
-function discriminantText(sourceCode, test) {
+function discriminantName(test) {
   if (test.type !== import_utils110.AST_NODE_TYPES.BinaryExpression || test.operator !== "===") return null;
   const leftIsCase = isCaseValue(test.left);
   const rightIsCase = isCaseValue(test.right);
   if (leftIsCase === rightIsCase) return null;
   const discriminant = leftIsCase ? test.right : test.left;
-  return discriminant.type === import_utils110.AST_NODE_TYPES.Identifier ? sourceCode.getText(discriminant) : null;
+  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;
@@ -18992,12 +19362,12 @@ var prefer_switch_for_repeated_equality_default = createRule({
     return {
       IfStatement(node) {
         if (node.parent.type === import_utils110.AST_NODE_TYPES.IfStatement && node.parent.alternate === node) return;
-        const first = discriminantText(context.sourceCode, node.test);
+        const first = discriminantName(node.test);
         if (first === null) return;
         let count = 1;
         let current = node.alternate;
         while (current?.type === import_utils110.AST_NODE_TYPES.IfStatement) {
-          if (discriminantText(context.sourceCode, current.test) !== first) return;
+          if (discriminantName(current.test) !== first) return;
           count += 1;
           current = current.alternate;
         }
@@ -22190,7 +22560,7 @@ var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
     }
   ]
 };
-function staticPropertyName(property) {
+function staticPropertyName2(property) {
   if (property.computed) return null;
   if (property.key.type === import_utils122.AST_NODE_TYPES.Identifier) return property.key.name;
   if (property.key.type === import_utils122.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
@@ -22239,7 +22609,7 @@ var require_use_form_default_values_default = createRule({
       for (const property of node.properties) {
         if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
         if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
-        const name = staticPropertyName(property);
+        const name = staticPropertyName2(property);
         if (name === "defaultValues" || name === "values") initialization.set(name, !isDefinitelyUndefined(property.value));
       }
       return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
@@ -22265,7 +22635,7 @@ var require_use_form_default_values_default = createRule({
       for (const property of node.properties) {
         if (property.type === import_utils122.AST_NODE_TYPES.SpreadElement || property.computed) return false;
         if (property.type !== import_utils122.AST_NODE_TYPES.Property) continue;
-        const name = staticPropertyName(property);
+        const name = staticPropertyName2(property);
         if (name === "control") control = property.value;
         if (name === "defaultValue") hasDefault = !isDefinitelyUndefined(property.value);
       }
@@ -22281,7 +22651,7 @@ var require_use_form_default_values_default = createRule({
     };
     const trackDestructuredControl = (pattern) => {
       for (const property of pattern.properties) {
-        if (property.type !== import_utils122.AST_NODE_TYPES.Property || staticPropertyName(property) !== "control" || property.value.type !== import_utils122.AST_NODE_TYPES.Identifier) continue;
+        if (property.type !== import_utils122.AST_NODE_TYPES.Property || staticPropertyName2(property) !== "control" || property.value.type !== import_utils122.AST_NODE_TYPES.Identifier) continue;
         const variable = bindingOf(property.value);
         if (variable !== null) uninitializedControls.add(variable);
       }
@@ -22725,7 +23095,9 @@ var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   limitations: ["Only the nearest statically named callable is considered; top-level inserts and anonymous callbacks are excluded. Recognized conflict syntax does not prove idempotence or concurrency safety: WHERE NOT EXISTS can race, and INSERT OR REPLACE can delete an existing row. Review unique constraints and dialect semantics manually."],
   examples: [
     { id: "conflict-safe-insert", title: "Review the conflict policy for a replayed insert", outcome: "no-match", files: [{ path: "src/store.ts", source: "function seed() { db.prepare(`INSERT INTO runs (id) VALUES (?) ON CONFLICT(id) DO NOTHING`).run(); }" }], focusPath: "src/store.ts", expectedCount: 0, public: true },
-    { id: "bare-insert", title: "Review a bare insert in a replay-named callable", outcome: "match", files: [{ path: "src/store.ts", source: "function seed() { db.prepare(`INSERT INTO runs (id) VALUES (?)`).run(); }" }], focusPath: "src/store.ts", expectedCount: 1, public: true }
+    { id: "bare-insert", title: "Review a bare insert in a replay-named callable", outcome: "match", files: [{ path: "src/store.ts", source: "function seed() { db.prepare(`INSERT INTO runs (id) VALUES (?)`).run(); }" }], focusPath: "src/store.ts", expectedCount: 1, public: true },
+    { id: "decoded-query", scenarioId: "native-decoded-sql", title: "Inspect native-decoded query text", outcome: "match", files: [{ path: "src/page.ts", source: `function seed(){db.query("INS\\u0045RT INTO runs(id,note) VALUES(4,'new')");}` }], focusPath: "src/page.ts", expectedCount: 1, public: true },
+    { id: "decoded-comment-data", scenarioId: "native-decoded-sql", title: "Ignore native-decoded comment data", outcome: "no-match", files: [{ path: "src/page.ts", source: `function seed(){db.query("SELECT id FROM runs /* INS\\x45RT INTO runs(id,note) VALUES(4,'new') */");}` }], focusPath: "src/page.ts", expectedCount: 0, public: true }
   ]
 };
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
@@ -22745,7 +23117,6 @@ function owningCallableName(node) {
   }
   return null;
 }
-var INSERT_GATE = /insert/i;
 var store_insert_requires_on_conflict_default = createRule({
   name: "store-insert-requires-on-conflict",
   documentation: STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION,
@@ -22761,7 +23132,7 @@ var store_insert_requires_on_conflict_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || !INSERT_GATE.test(context.sourceCode.text)) {
+    if (isTestFile(context.filename)) {
       return {};
     }
     return createSqlListener((sql, node) => {
@@ -24314,7 +24685,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "16.4.6"
+  version: package_default.version
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {