@sarj/eslint-plugin 4.1.0 → 4.2.0

package/dist/index.cjs

@@ -3046,6 +3046,9 @@ var import_utils21 = require("@typescript-eslint/utils");
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
 var ZOD_SUFFIX_RE = /Schema$/;
 var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
+function isZodModule(source) {
+  return /(^|[/@-])zod([/-]|$)/.test(source);
+}
 
 // src/rules/require-zod-form-validation.ts
 var looksLikeZodSchema = (node) => {
@@ -4675,9 +4678,6 @@ var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator
 
 // src/rules/prefer-zod-enum.ts
 var import_utils31 = require("@typescript-eslint/utils");
-function isZodModule(source) {
-  return /(^|[/@-])zod([/-]|$)/.test(source);
-}
 var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
@@ -4763,11 +4763,414 @@ var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
   }
 });
 
+// src/rules/prefer-zod-infer.ts
+var import_utils32 = require("@typescript-eslint/utils");
+var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
+  "describe",
+  "refine",
+  "superRefine",
+  "check",
+  "meta",
+  "register"
+]);
+var OPTIONAL_MODIFIERS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullish",
+  "default",
+  "prefault",
+  "catch"
+]);
+var NULLABLE_MODIFIERS = /* @__PURE__ */ new Set(["nullable", "nullish"]);
+var RESHAPING_MODIFIERS = /* @__PURE__ */ new Set([
+  "transform",
+  "pipe",
+  "preprocess",
+  "brand",
+  "overwrite"
+]);
+var MODULE_LEVEL_RESHAPERS = /* @__PURE__ */ new Set([
+  "transform",
+  "pipe",
+  "preprocess"
+]);
+var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "ZodType",
+  "ZodSchema",
+  "ZodTypeAny",
+  "ZodMiniType",
+  "Schema"
+]);
+var LEAF_NODE_TYPES = {
+  string: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils32.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils32.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils32.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils32.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils32.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils32.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils32.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils32.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils32.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils32.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils32.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils32.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils32.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils32.AST_NODE_TYPES.TSArrayType, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils32.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils32.AST_NODE_TYPES.TSTypeLiteral, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils32.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils32.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils32.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference, import_utils32.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils32.AST_NODE_TYPES.TSUnionType, import_utils32.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils32.AST_NODE_TYPES.TSIntersectionType, import_utils32.AST_NODE_TYPES.TSTypeReference]
+};
+function normalizeSchemaName(name) {
+  return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
+}
+function normalizeTypeName(name) {
+  return name.replace(/Type$/, "").toLowerCase();
+}
+function unwrapNullish(annotation) {
+  if (annotation.type !== import_utils32.AST_NODE_TYPES.TSUnionType) {
+    return {
+      core: annotation,
+      nullable: annotation.type === import_utils32.AST_NODE_TYPES.TSNullKeyword
+    };
+  }
+  const rest = [];
+  let nullable = false;
+  for (const member of annotation.types) {
+    if (member.type === import_utils32.AST_NODE_TYPES.TSNullKeyword) {
+      nullable = true;
+      continue;
+    }
+    if (member.type === import_utils32.AST_NODE_TYPES.TSUndefinedKeyword) {
+      continue;
+    }
+    rest.push(member);
+  }
+  if (rest.length === 1) {
+    return { core: rest[0] ?? null, nullable };
+  }
+  return { core: rest.length === 0 ? null : annotation, nullable };
+}
+function leafAgrees(leaf, annotation) {
+  if (leaf === null || annotation === null) {
+    return null;
+  }
+  const expected = LEAF_NODE_TYPES[leaf];
+  if (expected === void 0) {
+    return null;
+  }
+  const { core } = unwrapNullish(annotation);
+  if (core === null) {
+    return null;
+  }
+  return expected.includes(core.type);
+}
+var prefer_zod_infer_default = import_utils32.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
+)({
+  name: "prefer-zod-infer",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Derive a type from its Zod schema with `z.infer` instead of hand-writing a twin declaration beside it."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          ignoreTypeNames: {
+            type: "array",
+            items: { type: "string" }
+          },
+          requireIdenticalShape: { type: "boolean" }
+        }
+      }
+    ],
+    messages: {
+      handWrittenTwin: "`{{typeName}}` restates the shape of the Zod schema `{{schemaName}}` declared in this module. Derive it instead \u2014 `type {{typeName}} = z.infer<typeof {{schemaName}}>` \u2014 so a field added to the schema cannot silently leave the type behind."
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [optionsArg]) {
+    const ignorePatterns = (optionsArg?.ignoreTypeNames ?? []).map(
+      (source) => new RegExp(source, "u")
+    );
+    const requireIdenticalShape = optionsArg?.requireIdenticalShape ?? true;
+    if (isTestFile(context.filename) || isStoryFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+      return {};
+    }
+    const zodNamespaces = /* @__PURE__ */ new Set();
+    const schemas = [];
+    const typeDeclarations = [];
+    const constrainedTypeNames = /* @__PURE__ */ new Set();
+    const reshapedSchemaNames = /* @__PURE__ */ new Set();
+    function zodCallChain(node) {
+      const chain = [];
+      let current = node;
+      while (current.type === import_utils32.AST_NODE_TYPES.CallExpression) {
+        const callee = current.callee;
+        if (callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
+          return null;
+        }
+        chain.push(current);
+        const receiver = callee.object;
+        if (receiver.type === import_utils32.AST_NODE_TYPES.Identifier) {
+          return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
+        }
+        current = receiver;
+      }
+      return null;
+    }
+    function methodName(call) {
+      const callee = call.callee;
+      return callee.type === import_utils32.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils32.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+    }
+    function schemaField(node) {
+      const modifiers = [];
+      let current = node;
+      let leaf = null;
+      while (current.type === import_utils32.AST_NODE_TYPES.CallExpression) {
+        const callee = current.callee;
+        if (callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
+          break;
+        }
+        const receiver = callee.object;
+        if (receiver.type === import_utils32.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+          leaf = callee.property.name;
+          break;
+        }
+        modifiers.push(callee.property.name);
+        current = receiver;
+      }
+      return {
+        leaf,
+        optional: modifiers.some((name) => OPTIONAL_MODIFIERS.has(name)),
+        nullable: modifiers.some((name) => NULLABLE_MODIFIERS.has(name)),
+        reshaped: modifiers.some((name) => RESHAPING_MODIFIERS.has(name))
+      };
+    }
+    function schemaFields(init) {
+      const chain = zodCallChain(init);
+      if (chain === null || chain.length === 0) {
+        return null;
+      }
+      const [base, ...rest] = chain;
+      if (base === void 0) {
+        return null;
+      }
+      const baseMethod = methodName(base);
+      if (baseMethod !== "object" && baseMethod !== "strictObject") {
+        return null;
+      }
+      if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(methodName(call)))) {
+        return null;
+      }
+      const shape = base.arguments[0];
+      if (shape === void 0 || shape.type !== import_utils32.AST_NODE_TYPES.ObjectExpression) {
+        return null;
+      }
+      const fields = /* @__PURE__ */ new Map();
+      for (const property of shape.properties) {
+        if (property.type !== import_utils32.AST_NODE_TYPES.Property || property.computed) {
+          return null;
+        }
+        const { key } = property;
+        const name = key.type === import_utils32.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils32.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        if (name === null) {
+          return null;
+        }
+        fields.set(name, schemaField(property.value));
+      }
+      return fields.size === 0 ? null : fields;
+    }
+    function typeMembers(members) {
+      const result = /* @__PURE__ */ new Map();
+      for (const member of members) {
+        if (member.type !== import_utils32.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+          return null;
+        }
+        const { key } = member;
+        const name = key.type === import_utils32.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils32.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        if (name === null) {
+          return null;
+        }
+        const annotation = member.typeAnnotation?.typeAnnotation ?? null;
+        result.set(name, {
+          optional: member.optional === true,
+          nullable: annotation !== null && unwrapNullish(annotation).nullable,
+          annotation
+        });
+      }
+      return result.size === 0 ? null : result;
+    }
+    function collectConstrainedNames(node) {
+      if (node.type === import_utils32.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils32.AST_NODE_TYPES.Identifier) {
+          constrainedTypeNames.add(node.typeName.name);
+        }
+        for (const argument of node.typeArguments?.params ?? []) {
+          collectConstrainedNames(argument);
+        }
+        return;
+      }
+      if (node.type === import_utils32.AST_NODE_TYPES.TSArrayType) {
+        collectConstrainedNames(node.elementType);
+        return;
+      }
+      if (node.type === import_utils32.AST_NODE_TYPES.TSUnionType || node.type === import_utils32.AST_NODE_TYPES.TSIntersectionType) {
+        for (const member of node.types) {
+          collectConstrainedNames(member);
+        }
+      }
+    }
+    function isTwin(fields, members) {
+      if (!requireIdenticalShape) {
+        return true;
+      }
+      if (fields.size !== members.size) {
+        return false;
+      }
+      let agreements = 0;
+      for (const [name, field] of fields) {
+        const member = members.get(name);
+        if (member === void 0) {
+          return false;
+        }
+        if (field.reshaped) {
+          return false;
+        }
+        if (field.optional !== member.optional) {
+          return false;
+        }
+        if (field.nullable !== member.nullable) {
+          return false;
+        }
+        const agrees = leafAgrees(field.leaf, member.annotation);
+        if (agrees === false) {
+          return false;
+        }
+        if (agrees === true) {
+          agreements += 1;
+        }
+      }
+      return agreements > 0;
+    }
+    return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils32.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils32.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils32.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils32.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+            zodNamespaces.add(specifier.local.name);
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== import_utils32.AST_NODE_TYPES.Identifier || node.init == null) {
+          return;
+        }
+        const fields = schemaFields(node.init);
+        if (fields !== null) {
+          schemas.push({ name: node.id.name, fields });
+        }
+      },
+      /** Guard (f): `XSchema.transform(...)` anywhere in the module. */
+      "MemberExpression[computed=false]"(node) {
+        if (node.object.type === import_utils32.AST_NODE_TYPES.Identifier && node.property.type === import_utils32.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+          reshapedSchemaNames.add(node.object.name);
+        }
+      },
+      /** Guard (c): `z.ZodType<T>` and every other type argument it carries. */
+      TSTypeReference(node) {
+        const { typeName } = node;
+        const referenced = typeName.type === import_utils32.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils32.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils32.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
+          return;
+        }
+        for (const argument of node.typeArguments?.params ?? []) {
+          collectConstrainedNames(argument);
+        }
+      },
+      TSInterfaceDeclaration(node) {
+        if (node.typeParameters !== void 0 || (node.extends?.length ?? 0) > 0) {
+          return;
+        }
+        const members = typeMembers(node.body.body);
+        if (members !== null) {
+          typeDeclarations.push({ name: node.id.name, node: node.id, members });
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils32.AST_NODE_TYPES.TSTypeLiteral) {
+          return;
+        }
+        const members = typeMembers(node.typeAnnotation.members);
+        if (members !== null) {
+          typeDeclarations.push({ name: node.id.name, node: node.id, members });
+        }
+      },
+      "Program:exit"() {
+        if (schemas.length === 0 || typeDeclarations.length === 0) {
+          return;
+        }
+        const byName = /* @__PURE__ */ new Map();
+        for (const schema of schemas) {
+          const key = normalizeSchemaName(schema.name);
+          if (key !== "" && !byName.has(key)) {
+            byName.set(key, schema);
+          }
+        }
+        for (const declaration of typeDeclarations) {
+          if (constrainedTypeNames.has(declaration.name)) {
+            continue;
+          }
+          if (ignorePatterns.some((pattern) => pattern.test(declaration.name))) {
+            continue;
+          }
+          const schema = byName.get(normalizeTypeName(declaration.name));
+          if (schema === void 0 || reshapedSchemaNames.has(schema.name)) {
+            continue;
+          }
+          if (!isTwin(schema.fields, declaration.members)) {
+            continue;
+          }
+          context.report({
+            node: declaration.node,
+            messageId: "handWrittenTwin",
+            data: { typeName: declaration.name, schemaName: schema.name }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-offset-pagination.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 
 // src/rules/_sql.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 function stripSqlNoise(text) {
   const out = [...text];
   const n = text.length;
@@ -4828,13 +5231,13 @@ function stripSqlNoise(text) {
 var SUBSTITUTION_MARKER = "?";
 function sqlTextOf(node) {
   switch (node.type) {
-    case import_utils32.AST_NODE_TYPES.Literal:
+    case import_utils33.AST_NODE_TYPES.Literal:
       return typeof node.value === "string" ? node.value : null;
-    case import_utils32.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils33.AST_NODE_TYPES.TemplateLiteral:
       return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join(SUBSTITUTION_MARKER);
-    case import_utils32.AST_NODE_TYPES.TaggedTemplateExpression:
+    case import_utils33.AST_NODE_TYPES.TaggedTemplateExpression:
       return sqlTextOf(node.quasi);
-    case import_utils32.AST_NODE_TYPES.BinaryExpression: {
+    case import_utils33.AST_NODE_TYPES.BinaryExpression: {
       if (node.operator !== "+") {
         return null;
       }
@@ -4842,7 +5245,7 @@ function sqlTextOf(node) {
       const right = sqlTextOf(node.right);
       return left !== null && right !== null ? left + right : null;
     }
-    case import_utils32.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils33.AST_NODE_TYPES.ArrayExpression: {
       const parts = [];
       for (const element of node.elements) {
         if (element === null) {
@@ -4862,7 +5265,7 @@ function sqlTextOf(node) {
 }
 function isJoinedFragmentArray(node) {
   const parent = node.parent;
-  return parent?.type === import_utils32.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils32.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils32.AST_NODE_TYPES.CallExpression;
+  return parent?.type === import_utils33.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils33.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils33.AST_NODE_TYPES.CallExpression;
 }
 function markConsumed(node, consumed) {
   consumed.add(node);
@@ -4912,7 +5315,7 @@ function createSqlListener(handler) {
 // src/rules/no-offset-pagination.ts
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
 var OFFSET_GATE = /offset/i;
-var no_offset_pagination_default = import_utils33.ESLintUtils.RuleCreator(
+var no_offset_pagination_default = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-offset-pagination",
@@ -4941,15 +5344,15 @@ var no_offset_pagination_default = import_utils33.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-positional-tuple-return.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 var MIN_ELEMENTS = 2;
 var ACCESSOR_PAIR_LENGTH = 2;
 var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited"]);
 function tupleReturnType(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.TSTupleType) {
+  if (node.type === import_utils35.AST_NODE_TYPES.TSTupleType) {
     return node;
   }
-  if (node.type === import_utils34.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+  if (node.type === import_utils35.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils35.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params[0];
     return argument === void 0 ? null : tupleReturnType(argument);
   }
@@ -4963,30 +5366,30 @@ function isPermittedTuple(tuple, sourceCode) {
   if (elements.length < MIN_ELEMENTS) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSRestType)) {
+  if (elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSRestType)) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSNamedTupleMember)) {
+  if (elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSNamedTupleMember)) {
     return true;
   }
-  if (elements[0]?.type === import_utils34.AST_NODE_TYPES.TSLiteralType) {
+  if (elements[0]?.type === import_utils35.AST_NODE_TYPES.TSLiteralType) {
     return true;
   }
-  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSFunctionType)) {
+  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils35.AST_NODE_TYPES.TSFunctionType)) {
     return true;
   }
   const texts = new Set(elements.map((element) => normalizedText(sourceCode, element)));
   return texts.size === 1;
 }
 function functionName(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration) {
     return node.id?.name ?? null;
   }
   const parent = node.parent;
-  if (parent?.type === import_utils34.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils34.AST_NODE_TYPES.Identifier) {
+  if (parent?.type === import_utils35.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils35.AST_NODE_TYPES.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === import_utils34.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils34.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils34.AST_NODE_TYPES.Property) && parent.key.type === import_utils34.AST_NODE_TYPES.Identifier) {
+  if ((parent?.type === import_utils35.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils35.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils35.AST_NODE_TYPES.Property) && parent.key.type === import_utils35.AST_NODE_TYPES.Identifier) {
     return parent.key.name;
   }
   return null;
@@ -4994,7 +5397,7 @@ function functionName(node) {
 function isInlineExported(node) {
   for (let current = node; current != null; current = current.parent) {
     const parent = current.parent;
-    if (parent?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (parent?.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -5003,18 +5406,18 @@ function isInlineExported(node) {
 function moduleScopeBindingName(node) {
   let current = node;
   let child = node;
-  while (current.parent != null && current.parent.type !== import_utils34.AST_NODE_TYPES.Program) {
+  while (current.parent != null && current.parent.type !== import_utils35.AST_NODE_TYPES.Program) {
     child = current;
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils34.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils35.AST_NODE_TYPES.Program) {
     return null;
   }
-  if (current.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils34.AST_NODE_TYPES.ClassDeclaration) {
+  if (current.type === import_utils35.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils35.AST_NODE_TYPES.ClassDeclaration) {
     return current.id?.name ?? null;
   }
-  if (current.type === import_utils34.AST_NODE_TYPES.VariableDeclaration) {
-    if (child.type !== import_utils34.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils34.AST_NODE_TYPES.Identifier) {
+  if (current.type === import_utils35.AST_NODE_TYPES.VariableDeclaration) {
+    if (child.type !== import_utils35.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils35.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return child.id.name;
@@ -5024,19 +5427,19 @@ function moduleScopeBindingName(node) {
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
-        if (specifier.exportKind !== "type" && specifier.local.type === import_utils34.AST_NODE_TYPES.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === import_utils35.AST_NODE_TYPES.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils34.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils35.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils35.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === import_utils34.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils34.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils35.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils35.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -5052,7 +5455,7 @@ function isExported(node, specifierExports) {
   const binding = moduleScopeBindingName(node);
   return binding !== null && specifierExports.has(binding);
 }
-var no_positional_tuple_return_default = import_utils34.ESLintUtils.RuleCreator(
+var no_positional_tuple_return_default = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-positional-tuple-return",
@@ -5100,16 +5503,16 @@ var no_positional_tuple_return_default = import_utils34.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-repeated-string-literal.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils36 = require("@typescript-eslint/utils");
 var MIN_LENGTH = 40;
 var MIN_DISTINCT_SCOPES = 2;
 var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
 var FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils35.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils35.AST_NODE_TYPES.FunctionExpression,
-  import_utils35.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils36.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils36.AST_NODE_TYPES.FunctionExpression,
+  import_utils36.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -5131,9 +5534,9 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  return parent.type === import_utils35.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils35.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils35.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils35.AST_NODE_TYPES.TSImportType || parent.type === import_utils35.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils35.AST_NODE_TYPES.TSLiteralType;
+  return parent.type === import_utils36.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils36.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils36.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils36.AST_NODE_TYPES.TSImportType || parent.type === import_utils36.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils36.AST_NODE_TYPES.TSLiteralType;
 }
-var no_repeated_string_literal_default = import_utils35.ESLintUtils.RuleCreator(
+var no_repeated_string_literal_default = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-repeated-string-literal",
@@ -5173,7 +5576,7 @@ var no_repeated_string_literal_default = import_utils35.ESLintUtils.RuleCreator(
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === import_utils35.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.parent.type === import_utils36.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -5207,7 +5610,7 @@ var no_repeated_string_literal_default = import_utils35.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-select-star.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var QUERY_SHAPE = /\bSELECT\b[\s\S]*?\bFROM\b/i;
 var SELECT_KEYWORD = /\bSELECT\b/gi;
 var FROM_KEYWORD = /^FROM\b/i;
@@ -5247,7 +5650,7 @@ function hasRealSelectStar(sql) {
   }
   return false;
 }
-var no_select_star_default = import_utils36.ESLintUtils.RuleCreator(
+var no_select_star_default = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-select-star",
@@ -5276,7 +5679,7 @@ var no_select_star_default = import_utils36.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sleep-in-test-body.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS = /* @__PURE__ */ new Set([
   "it",
@@ -5285,34 +5688,34 @@ var TEST_CALLERS = /* @__PURE__ */ new Set([
   "afterEach"
 ]);
 var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
-  import_utils37.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils37.AST_NODE_TYPES.FunctionExpression,
-  import_utils37.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils38.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils38.AST_NODE_TYPES.FunctionExpression,
+  import_utils38.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === import_utils37.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === import_utils38.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === import_utils37.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  return node.type === import_utils38.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils38.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== import_utils37.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== import_utils38.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== import_utils37.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils37.AST_NODE_TYPES.FunctionExpression) {
+  if (executor?.type !== import_utils38.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils38.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const body = executor.body;
-  if (body.type !== import_utils37.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils38.AST_NODE_TYPES.BlockStatement) {
     return isTimedSetTimeout(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === import_utils37.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+    (stmt) => stmt.type === import_utils38.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === import_utils37.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === import_utils38.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
 }
 function nearestEnclosingFunction(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -5320,7 +5723,7 @@ function nearestEnclosingFunction(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils37.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils38.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -5328,29 +5731,29 @@ function nearestEnclosingFunction(node) {
   return null;
 }
 function testCallerName(callee) {
-  if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils37.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
     return testCallerName(callee.object);
   }
-  if (callee.type === import_utils37.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
     return testCallerName(callee.callee);
   }
-  if (callee.type === import_utils37.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName(callee.tag);
   }
   return null;
 }
 function isTestBody(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils37.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils38.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName(call.callee);
   return name !== null && TEST_CALLERS.has(name);
 }
-var no_sleep_in_test_body_default = import_utils37.ESLintUtils.RuleCreator(
+var no_sleep_in_test_body_default = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sleep-in-test-body",
@@ -5392,12 +5795,12 @@ var no_sleep_in_test_body_default = import_utils37.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-conditional-in-test.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 var TEST_CALLERS2 = /* @__PURE__ */ new Set(["it", "test"]);
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils38.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils38.AST_NODE_TYPES.FunctionExpression,
-  import_utils38.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils39.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils39.AST_NODE_TYPES.FunctionExpression,
+  import_utils39.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -5408,29 +5811,29 @@ function nearestEnclosingFunction2(node) {
   return null;
 }
 function testCallerName2(callee) {
-  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils39.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils38.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils39.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName2(call.callee);
   return name !== null && TEST_CALLERS2.has(name);
 }
-var no_conditional_in_test_default = import_utils38.ESLintUtils.RuleCreator(
+var no_conditional_in_test_default = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-conditional-in-test",
@@ -5474,7 +5877,7 @@ var no_conditional_in_test_default = import_utils38.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils40 = require("@typescript-eslint/utils");
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
 var SENTINEL_WORDS = /(^|_)(SENTINEL|EMPTY|NONE|NULL|UNSET|MISSING|PLACEHOLDER|DUMMY|FAKE|EXAMPLE)(_|$)/;
@@ -5487,36 +5890,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils39.AST_NODE_TYPES.Literal:
+    case import_utils40.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils40.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils39.AST_NODE_TYPES.Identifier:
+    case import_utils40.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case import_utils39.AST_NODE_TYPES.MemberExpression:
-      return !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case import_utils40.AST_NODE_TYPES.MemberExpression:
+      return !node.computed && node.property.type === import_utils40.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils40.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils39.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils40.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils40.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -5527,7 +5930,7 @@ function secretNameOf(node) {
   }
   return operandName(node);
 }
-var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.RuleCreator(
+var prefer_constant_time_secret_compare_default = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-constant-time-secret-compare",
@@ -5570,11 +5973,11 @@ var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.Rul
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
 var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b/i;
 var INSERT_GATE = /insert/i;
-var store_insert_requires_on_conflict_default = import_utils40.ESLintUtils.RuleCreator(
+var store_insert_requires_on_conflict_default = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "store-insert-requires-on-conflict",
@@ -5603,17 +6006,17 @@ var store_insert_requires_on_conflict_default = import_utils40.ESLintUtils.RuleC
 });
 
 // src/rules/no-dynamic-sql.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS = ["prepare", "exec", "query"];
 var CONSTANT_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
 function isStaticFragment(expression) {
-  if (expression.type === import_utils41.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.name);
   }
-  if (expression.type === import_utils41.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils42.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.property.name);
   }
-  if (expression.type === import_utils41.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils42.AST_NODE_TYPES.Literal) {
     return typeof expression.value === "string";
   }
   return false;
@@ -5624,36 +6027,36 @@ function runtimeInterpolations(template) {
   );
 }
 function concatOperands(node) {
-  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return [...concatOperands(node.left), ...concatOperands(node.right)];
   }
   return [node];
 }
 function runtimeConcatOperands(node) {
-  if (node.type !== import_utils41.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
+  if (node.type !== import_utils42.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
     return [];
   }
   const operands = concatOperands(node);
   const hasStringLiteral = operands.some(
-    (operand) => operand.type === import_utils41.AST_NODE_TYPES.Literal && typeof operand.value === "string"
+    (operand) => operand.type === import_utils42.AST_NODE_TYPES.Literal && typeof operand.value === "string"
   );
   if (!hasStringLiteral) {
     return [];
   }
   return operands.filter(
-    (operand) => operand.type !== import_utils41.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
+    (operand) => operand.type !== import_utils42.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
   );
 }
 var SQL_STATEMENT_RE = /\b(?:select\s|insert\s+into\b|insert\s+or\b|update\s+\w|delete\s+from\b|replace\s+into\b|merge\s+into\b|upsert\s+into\b|create\s+(?:temp(?:orary)?\s+)?(?:table|index|view|trigger|schema|database)\b|alter\s+table\b|drop\s+(?:table|index|view|trigger)\b|truncate\s+table\b|pragma\s+\w|with\s+\w+\s+as\s*\(|from\s+\w+\s+where\b)/i;
 var RUNTIME_MARKER = " ? ";
 function staticStatementText(node) {
-  if (node.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils42.AST_NODE_TYPES.TemplateLiteral) {
     return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(RUNTIME_MARKER);
   }
-  if (node.type === import_utils41.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils42.AST_NODE_TYPES.Literal) {
     return typeof node.value === "string" ? node.value : RUNTIME_MARKER;
   }
-  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils42.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return staticStatementText(node.left) + staticStatementText(node.right);
   }
   return RUNTIME_MARKER;
@@ -5663,13 +6066,13 @@ function looksLikeSql(node) {
 }
 function statementMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils41.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils42.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
   return methods.has(name) ? name : null;
 }
-var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
+var no_dynamic_sql_default = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-dynamic-sql",
@@ -5708,7 +6111,7 @@ var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
         if (statement === void 0 || !looksLikeSql(statement)) {
           return;
         }
-        const offenders = statement.type === import_utils41.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
+        const offenders = statement.type === import_utils42.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
         for (const offender of offenders) {
           context.report({
             node: offender,
@@ -5722,7 +6125,7 @@ var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -5786,7 +6189,7 @@ function compile(patterns) {
   }
   return compiled;
 }
-var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreator(
+var no_raw_fetch_outside_clients_default = import_utils43.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-fetch-outside-clients",
@@ -5834,7 +6237,7 @@ var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -5853,7 +6256,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils43.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils43.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -5865,7 +6268,7 @@ function storageMethodName(node, methods) {
   }
   return name;
 }
-var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCreator(
+var no_storage_in_stateless_modules_default = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-storage-in-stateless-modules",
@@ -5923,7 +6326,7 @@ var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCre
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS2 = [
   /[\\/]generated[\\/]/,
@@ -5941,7 +6344,7 @@ function isZodModule2(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap3(node) {
-  if (node.type === import_utils44.AST_NODE_TYPES.TSAsExpression || node.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap3(node.expression);
   }
   return node;
@@ -5949,14 +6352,14 @@ function unwrap3(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils44.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
       return null;
     }
     if (prop.computed || prop.shorthand || prop.method || prop.kind !== "init") {
       return null;
     }
     const value = prop.value;
-    if (value.type !== import_utils44.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils45.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -5972,7 +6375,7 @@ function resolvesToLocalEnum(node, scope) {
     const variable = current.variables.find((v) => v.name === node.name);
     if (variable !== void 0) {
       return variable.defs.some(
-        (def) => def.node.type === import_utils44.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils45.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -5992,7 +6395,7 @@ function resolvesToImportedEnum(node, services) {
   }
   return (symbol.flags & ENUM_SYMBOL_FLAGS) !== 0;
 }
-var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
+var no_zod_native_enum_default = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-zod-native-enum",
@@ -6019,32 +6422,32 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
     }
     let services;
     try {
-      services = import_utils44.ESLintUtils.getParserServices(context);
+      services = import_utils45.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils44.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap3(arg);
-      if (inner.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils45.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -6064,7 +6467,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils45.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils45.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -6083,7 +6486,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -6100,7 +6503,7 @@ var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS3 = [
@@ -6136,9 +6539,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils45.AST_NODE_TYPES.FunctionExpression,
-  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils46.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils46.AST_NODE_TYPES.FunctionExpression,
+  import_utils46.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile3(filename, sourceText) {
@@ -6151,13 +6554,13 @@ function isTestFile2(filename) {
   return TEST_FILE_PATTERNS.some((re) => re.test(filename));
 }
 function unwrap4(node) {
-  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.TSAsExpression || node.type === import_utils46.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils46.AST_NODE_TYPES.TSNonNullExpression) {
     return unwrap4(node.expression);
   }
   return node;
 }
 function isRegexLiteral(node) {
-  return node.type === import_utils45.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils46.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6165,29 +6568,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap4(node);
   switch (inner.type) {
-    case import_utils45.AST_NODE_TYPES.Literal: {
+    case import_utils46.AST_NODE_TYPES.Literal: {
       return true;
     }
-    case import_utils45.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils46.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils45.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils45.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    case import_utils46.AST_NODE_TYPES.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils46.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
     }
-    case import_utils45.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils46.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils45.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils46.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils45.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils46.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils46.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils45.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils46.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6200,7 +6603,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap4(node);
-  if (inner.type === import_utils45.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils45.AST_NODE_TYPES.SpreadElement) {
+  if (inner.type === import_utils46.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils46.AST_NODE_TYPES.SpreadElement) {
     return unwrap4(inner.arguments[0]);
   }
   return inner;
@@ -6216,19 +6619,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils45.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils46.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils46.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap4(arg);
-    if (entries.type !== import_utils45.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -6257,10 +6660,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils46.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils45.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils46.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils46.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils46.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -6274,43 +6677,43 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils45.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils45.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === import_utils46.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils46.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
 }
-var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreator(
+var prefer_module_level_constant_default = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-module-level-constant",
@@ -6362,7 +6765,7 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils46.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6374,10 +6777,10 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils45.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils46.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils46.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6404,7 +6807,7 @@ var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreato
 });
 
 // src/rules/jsdoc-restates-signature.ts
-var import_utils46 = require("@typescript-eslint/utils");
+var import_utils47 = require("@typescript-eslint/utils");
 var VALUE_TAGS = /* @__PURE__ */ new Set([
   "alpha",
   "author",
@@ -6487,30 +6890,30 @@ function declarationNames(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
-    case import_utils46.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils46.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils47.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils47.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case import_utils46.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils46.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils47.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case import_utils46.AST_NODE_TYPES.ClassDeclaration:
-    case import_utils46.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils46.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils46.AST_NODE_TYPES.TSEnumDeclaration:
+    case import_utils47.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSEnumDeclaration:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case import_utils46.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils47.AST_NODE_TYPES.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== import_utils46.AST_NODE_TYPES.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== import_utils47.AST_NODE_TYPES.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils46.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === import_utils47.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils47.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case import_utils46.AST_NODE_TYPES.MethodDefinition:
-    case import_utils46.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils46.AST_NODE_TYPES.TSMethodSignature:
-    case import_utils46.AST_NODE_TYPES.TSPropertySignature: {
-      if (node.key.type !== import_utils46.AST_NODE_TYPES.Identifier) return null;
-      const params = node.type === import_utils46.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils46.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
+    case import_utils47.AST_NODE_TYPES.MethodDefinition:
+    case import_utils47.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils47.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils47.AST_NODE_TYPES.TSPropertySignature: {
+      if (node.key.type !== import_utils47.AST_NODE_TYPES.Identifier) return null;
+      const params = node.type === import_utils47.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils47.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -6520,9 +6923,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === import_utils46.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
-    if (target.type === import_utils46.AST_NODE_TYPES.Identifier) names.push(target.name);
-    else if (target.type === import_utils46.AST_NODE_TYPES.TSParameterProperty) continue;
+    const target = param.type === import_utils47.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+    if (target.type === import_utils47.AST_NODE_TYPES.Identifier) names.push(target.name);
+    else if (target.type === import_utils47.AST_NODE_TYPES.TSParameterProperty) continue;
   }
   return names;
 }
@@ -6531,7 +6934,7 @@ function tokensOf(names) {
   for (const name of names) for (const part of splitIdentifier(name)) tokens.add(part);
   return tokens;
 }
-var jsdoc_restates_signature_default = import_utils46.ESLintUtils.RuleCreator(
+var jsdoc_restates_signature_default = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "jsdoc-restates-signature",
@@ -6567,7 +6970,7 @@ var jsdoc_restates_signature_default = import_utils46.ESLintUtils.RuleCreator(
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
           let declaration = null;
-          while (node != null && node.type !== import_utils46.AST_NODE_TYPES.Program) {
+          while (node != null && node.type !== import_utils47.AST_NODE_TYPES.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -6622,7 +7025,7 @@ var jsdoc_restates_signature_default = import_utils46.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-restated-comment.ts
-var import_utils47 = require("@typescript-eslint/utils");
+var import_utils48 = require("@typescript-eslint/utils");
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
 var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
@@ -6646,7 +7049,7 @@ function headsSiblingRun(node) {
   const next = index >= 0 ? body[index + 1] : void 0;
   return next !== void 0 && next.type === node.type;
 }
-var no_restated_comment_default = import_utils47.ESLintUtils.RuleCreator(
+var no_restated_comment_default = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-restated-comment",
@@ -6674,7 +7077,7 @@ var no_restated_comment_default = import_utils47.ESLintUtils.RuleCreator(
     function labelsASiblingRun(comment) {
       const token = sourceCode.getTokenAfter(comment, { includeComments: false });
       if (token === null) return false;
-      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils47.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils48.AST_NODE_TYPES.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -6714,7 +7117,7 @@ var no_restated_comment_default = import_utils47.ESLintUtils.RuleCreator(
 });
 
 // src/rules/trailing-value-narration.ts
-var import_utils48 = require("@typescript-eslint/utils");
+var import_utils49 = require("@typescript-eslint/utils");
 var NUMBER_RE = /(?<![\w.])(\d+(?:\.\d+)?)(?![\w.])/g;
 var WORD_RE3 = /[A-Za-z]+(?:'[a-z]+)?|\d+(?:\.\d+)?/g;
 var UNIT_WORDS = /* @__PURE__ */ new Set([
@@ -6798,7 +7201,7 @@ function narratesValue(body, code) {
     (word) => STOPWORDS3.has(word) || UNIT_WORDS.has(word) || commentNumbers.has(word) || identifiers.has(word) || stems.has(stem(word))
   );
 }
-var trailing_value_narration_default = import_utils48.ESLintUtils.RuleCreator(
+var trailing_value_narration_default = import_utils49.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "trailing-value-narration",
@@ -6839,7 +7242,7 @@ var trailing_value_narration_default = import_utils48.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-tautological-expect.ts
-var import_utils49 = require("@typescript-eslint/utils");
+var import_utils50 = require("@typescript-eslint/utils");
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
   "toBeDefined",
@@ -6853,17 +7256,17 @@ var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
 function isLiteral(node) {
   switch (node.type) {
-    case import_utils49.AST_NODE_TYPES.Literal:
+    case import_utils50.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils49.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils50.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils49.AST_NODE_TYPES.UnaryExpression:
+    case import_utils50.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
-    case import_utils49.AST_NODE_TYPES.ArrayExpression:
+    case import_utils50.AST_NODE_TYPES.ArrayExpression:
       return node.elements.every((element) => element !== null && isLiteral(element));
-    case import_utils49.AST_NODE_TYPES.ObjectExpression:
+    case import_utils50.AST_NODE_TYPES.ObjectExpression:
       return node.properties.every(
-        (property) => property.type === import_utils49.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+        (property) => property.type === import_utils50.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
       );
     default:
       return false;
@@ -6871,12 +7274,12 @@ function isLiteral(node) {
 }
 function expectOperand(callee) {
   const receiver = callee.object;
-  if (receiver.type !== import_utils49.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils49.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== import_utils50.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils50.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
     return null;
   }
   return receiver.arguments[0] ?? null;
 }
-var no_tautological_expect_default = import_utils49.ESLintUtils.RuleCreator(
+var no_tautological_expect_default = import_utils50.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-tautological-expect",
@@ -6903,10 +7306,10 @@ var no_tautological_expect_default = import_utils49.ESLintUtils.RuleCreator(
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== import_utils49.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.computed) {
           return;
         }
-        if (callee.property.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
           return;
         }
         const matcher = callee.property.name;
@@ -6940,26 +7343,26 @@ var no_tautological_expect_default = import_utils49.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils50 = require("@typescript-eslint/utils");
+var import_utils51 = require("@typescript-eslint/utils");
 var CONFIGISH_TYPE_RE = /(?:Options|Opts|Config|Configuration|Settings|Params|Props|Args|Env|Environment|Callbacks|Flags)$/;
 var CONFIGISH_NAME_RE = /^(?:options|opts|config|configuration|settings|params|props|args|env|environment|callbacks|flags|logger|log|clock)$/i;
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
 var TRANSPORT_WRAPPER_NAME_RE = /Client$/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
-var isExportedClass = (node) => node.parent.type === import_utils50.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils50.AST_NODE_TYPES.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === import_utils50.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils50.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var isExportedClass = (node) => node.parent.type === import_utils51.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils51.AST_NODE_TYPES.ExportDefaultDeclaration;
+var qualifiedName = (name) => name.type === import_utils51.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils51.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var typeReferenceName = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils50.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils50.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils50.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils51.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils51.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils51.AST_NODE_TYPES.Identifier) return null;
   const annotation = target.typeAnnotation?.typeAnnotation;
-  if (annotation === void 0 || annotation.type !== import_utils50.AST_NODE_TYPES.TSTypeReference) {
+  if (annotation === void 0 || annotation.type !== import_utils51.AST_NODE_TYPES.TSTypeReference) {
     return null;
   }
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils50.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils50.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils51.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils51.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { name: target.name, typeName: rightmost, display: qualifiedName(typeName) };
 };
@@ -6969,17 +7372,17 @@ var readConstructor = (ctor) => {
   let constructedFields = 0;
   if (body !== null && body !== void 0) {
     for (const statement of body.body) {
-      if (statement.type !== import_utils50.AST_NODE_TYPES.ExpressionStatement) continue;
+      if (statement.type !== import_utils51.AST_NODE_TYPES.ExpressionStatement) continue;
       const expression = statement.expression;
-      if (expression.type !== import_utils50.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils50.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils50.AST_NODE_TYPES.ThisExpression) {
+      if (expression.type !== import_utils51.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils51.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils51.AST_NODE_TYPES.ThisExpression) {
         continue;
       }
       const source = expression.right;
-      if (source.type === import_utils50.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils51.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils50.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils51.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === import_utils50.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils50.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils51.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils51.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -6988,7 +7391,7 @@ var readConstructor = (ctor) => {
   for (const parameter of ctor.value.params) {
     const reference = typeReferenceName(parameter);
     if (reference === null) continue;
-    const stored = parameter.type === import_utils50.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
+    const stored = parameter.type === import_utils51.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
     if (!stored) continue;
     if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
     if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -7018,19 +7421,19 @@ var subtreeHas = (root, found) => {
   return hit;
 };
 var isFrameworkWiring = (body) => subtreeHas(body, (node) => {
-  if (node.type === import_utils50.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils51.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils50.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils50.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils50.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils51.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils50.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils50.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils51.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils51.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var stem2 = (name) => name.replace(/^I(?=[A-Z])/, "").replace(/Impl$/, "");
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils50.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils50.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils51.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils51.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
@@ -7048,16 +7451,16 @@ var isTransportWrapper = (className, collaborators, program) => {
 var publicMethodNames = (body) => {
   const names = [];
   for (const member of body.body) {
-    if (member.type !== import_utils50.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils51.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils50.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils50.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils51.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils51.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
 };
-var require_interface_for_injected_service_default = import_utils50.ESLintUtils.RuleCreator(
+var require_interface_for_injected_service_default = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-interface-for-injected-service",
@@ -7085,7 +7488,7 @@ var require_interface_for_injected_service_default = import_utils50.ESLintUtils.
         if (node.implements.length > 0) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils50.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils51.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(ctor);
@@ -7110,26 +7513,26 @@ var require_interface_for_injected_service_default = import_utils50.ESLintUtils.
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils51 = require("@typescript-eslint/utils");
+var import_utils52 = require("@typescript-eslint/utils");
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === import_utils51.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils51.AST_NODE_TYPES.Literal) return String(key.value);
+  if (key.type === import_utils52.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils52.AST_NODE_TYPES.Literal) return String(key.value);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === import_utils51.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils51.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils51.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils52.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils52.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils52.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function isNullishType(node) {
-  return node.type === import_utils51.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils51.AST_NODE_TYPES.TSUndefinedKeyword;
+  return node.type === import_utils52.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils52.AST_NODE_TYPES.TSUndefinedKeyword;
 }
 function isNullableArrayOnly(node) {
   const values = node.types.filter((member) => !isNullishType(member));
   return values.length > 0 && values.length < node.types.length && values.every(isArrayType);
 }
-var prefer_non_nullable_collection_default = import_utils51.ESLintUtils.RuleCreator(
+var prefer_non_nullable_collection_default = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
   name: "prefer-non-nullable-collection",
@@ -7152,7 +7555,7 @@ var prefer_non_nullable_collection_default = import_utils51.ESLintUtils.RuleCrea
     function checkOptionalProperty(node) {
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== import_utils51.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== import_utils52.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -7165,7 +7568,7 @@ var prefer_non_nullable_collection_default = import_utils51.ESLintUtils.RuleCrea
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils51.AST_NODE_TYPES.TSUnionType) return;
+        if (node.typeAnnotation.type !== import_utils52.AST_NODE_TYPES.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -7178,7 +7581,7 @@ var prefer_non_nullable_collection_default = import_utils51.ESLintUtils.RuleCrea
 });
 
 // src/rules/no-implicit-attribute-access.ts
-var import_utils52 = require("@typescript-eslint/utils");
+var import_utils53 = require("@typescript-eslint/utils");
 var EXCLUDED_BASES = /* @__PURE__ */ new Set([
   "environ",
   "headers",
@@ -7194,15 +7597,15 @@ var EXCLUDED_BASES = /* @__PURE__ */ new Set([
   "sessionStorage"
 ]);
 function getBaseName(node) {
-  if (node.type === import_utils52.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils53.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils52.AST_NODE_TYPES.MemberExpression && node.property.type === import_utils52.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils53.AST_NODE_TYPES.MemberExpression && node.property.type === import_utils53.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
-var no_implicit_attribute_access_default = import_utils52.ESLintUtils.RuleCreator(
+var no_implicit_attribute_access_default = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-implicit-attribute-access",
@@ -7223,7 +7626,7 @@ var no_implicit_attribute_access_default = import_utils52.ESLintUtils.RuleCreato
         if (!node.computed) {
           return;
         }
-        if (node.property.type === import_utils52.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+        if (node.property.type === import_utils53.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
           const baseName = getBaseName(node.object);
           if (!baseName || !EXCLUDED_BASES.has(baseName)) {
             context.report({
@@ -7236,11 +7639,11 @@ var no_implicit_attribute_access_default = import_utils52.ESLintUtils.RuleCreato
       },
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type === import_utils52.AST_NODE_TYPES.MemberExpression) {
-          const method = callee.property.type === import_utils52.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+        if (callee.type === import_utils53.AST_NODE_TYPES.MemberExpression) {
+          const method = callee.property.type === import_utils53.AST_NODE_TYPES.Identifier ? callee.property.name : null;
           if (method === "get") {
             const arg = node.arguments[0];
-            if (arg && arg.type === import_utils52.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
+            if (arg && arg.type === import_utils53.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
               const baseName = getBaseName(callee.object);
               if (!baseName || !EXCLUDED_BASES.has(baseName)) {
                 context.report({
@@ -7258,8 +7661,8 @@ var no_implicit_attribute_access_default = import_utils52.ESLintUtils.RuleCreato
 });
 
 // src/rules/strict-test-assertions.ts
-var import_utils53 = require("@typescript-eslint/utils");
-var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.withoutDocs({
+var import_utils54 = require("@typescript-eslint/utils");
+var strict_test_assertions_default = import_utils54.ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "suggestion",
     docs: {
@@ -7277,9 +7680,9 @@ var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.with
       let currentObject = null;
       let sequence = [];
       function getExpectObject(expr) {
-        if (expr.type === import_utils53.AST_NODE_TYPES.CallExpression && expr.callee.type === import_utils53.AST_NODE_TYPES.MemberExpression && expr.callee.object.type === import_utils53.AST_NODE_TYPES.CallExpression && expr.callee.object.callee.type === import_utils53.AST_NODE_TYPES.Identifier && expr.callee.object.callee.name === "expect" && expr.callee.object.arguments.length === 1) {
+        if (expr.type === import_utils54.AST_NODE_TYPES.CallExpression && expr.callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && expr.callee.object.type === import_utils54.AST_NODE_TYPES.CallExpression && expr.callee.object.callee.type === import_utils54.AST_NODE_TYPES.Identifier && expr.callee.object.callee.name === "expect" && expr.callee.object.arguments.length === 1) {
           const arg = expr.callee.object.arguments.at(0);
-          if (arg?.type === import_utils53.AST_NODE_TYPES.MemberExpression) {
+          if (arg?.type === import_utils54.AST_NODE_TYPES.MemberExpression) {
             return arg.object;
           }
         }
@@ -7295,12 +7698,12 @@ var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.with
               if (!currentObject) return null;
               const objectText = context.sourceCode.getText(currentObject);
               const props = sequence.map((stmt) => {
-                if (stmt.expression.type !== import_utils53.AST_NODE_TYPES.CallExpression || stmt.expression.callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || stmt.expression.callee.object.type !== import_utils53.AST_NODE_TYPES.CallExpression) {
+                if (stmt.expression.type !== import_utils54.AST_NODE_TYPES.CallExpression || stmt.expression.callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || stmt.expression.callee.object.type !== import_utils54.AST_NODE_TYPES.CallExpression) {
                   return null;
                 }
                 const actual = stmt.expression.callee.object.arguments.at(0);
                 const expected = stmt.expression.arguments.at(0);
-                if (actual?.type === import_utils53.AST_NODE_TYPES.MemberExpression && actual.property.type === import_utils53.AST_NODE_TYPES.Identifier && expected) {
+                if (actual?.type === import_utils54.AST_NODE_TYPES.MemberExpression && actual.property.type === import_utils54.AST_NODE_TYPES.Identifier && expected) {
                   const propName2 = actual.property.name;
                   const valText = context.sourceCode.getText(expected);
                   return `${propName2}: ${valText}`;
@@ -7318,7 +7721,7 @@ var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.with
         }
       }
       for (const statement of body) {
-        if (statement.type === import_utils53.AST_NODE_TYPES.ExpressionStatement) {
+        if (statement.type === import_utils54.AST_NODE_TYPES.ExpressionStatement) {
           const obj = getExpectObject(statement.expression);
           if (obj && currentObject && context.sourceCode.getText(obj) === context.sourceCode.getText(currentObject)) {
             sequence.push(statement);
@@ -7352,8 +7755,8 @@ var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.with
 });
 
 // src/rules/no-async-callback-in-waitfor.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var no_async_callback_in_waitfor_default = import_utils54.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var no_async_callback_in_waitfor_default = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-async-callback-in-waitfor",
@@ -7374,9 +7777,9 @@ var no_async_callback_in_waitfor_default = import_utils54.ESLintUtils.RuleCreato
     }
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils54.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
+        if (node.callee.type === import_utils55.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
           const callback = node.arguments[0];
-          if (callback && (callback.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils54.AST_NODE_TYPES.FunctionExpression) && callback.async) {
+          if (callback && (callback.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils55.AST_NODE_TYPES.FunctionExpression) && callback.async) {
             context.report({
               node: callback,
               messageId: "noAsyncCallbackInWaitFor"
@@ -7389,7 +7792,7 @@ var no_async_callback_in_waitfor_default = import_utils54.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-hand-rolled-sleep.ts
-var import_utils55 = require("@typescript-eslint/utils");
+var import_utils56 = require("@typescript-eslint/utils");
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -7408,66 +7811,66 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function isSetTimeoutCallee(callee) {
-  if (callee.type === import_utils55.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils56.AST_NODE_TYPES.Identifier) {
     return callee.name === "setTimeout";
   }
-  return callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && callee.property.name === "setTimeout" && callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name);
+  return callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && callee.property.name === "setTimeout" && callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name);
 }
 function soleCall(fn) {
-  if (fn.body.type !== import_utils55.AST_NODE_TYPES.BlockStatement) {
-    return fn.body.type === import_utils55.AST_NODE_TYPES.CallExpression ? fn.body : null;
+  if (fn.body.type !== import_utils56.AST_NODE_TYPES.BlockStatement) {
+    return fn.body.type === import_utils56.AST_NODE_TYPES.CallExpression ? fn.body : null;
   }
   if (fn.body.body.length !== 1) {
     return null;
   }
   const [only] = fn.body.body;
-  if (only?.type !== import_utils55.AST_NODE_TYPES.ExpressionStatement) {
+  if (only?.type !== import_utils56.AST_NODE_TYPES.ExpressionStatement) {
     return null;
   }
-  return only.expression.type === import_utils55.AST_NODE_TYPES.CallExpression ? only.expression : null;
+  return only.expression.type === import_utils56.AST_NODE_TYPES.CallExpression ? only.expression : null;
 }
 function isTimedDelay(delay) {
   if (delay === void 0) {
     return false;
   }
-  if (delay.type === import_utils55.AST_NODE_TYPES.Literal && typeof delay.value === "number") {
+  if (delay.type === import_utils56.AST_NODE_TYPES.Literal && typeof delay.value === "number") {
     return delay.value !== 0;
   }
   return true;
 }
 function settlesWithoutValue(callback, name) {
-  if (callback.type === import_utils55.AST_NODE_TYPES.Identifier) {
+  if (callback.type === import_utils56.AST_NODE_TYPES.Identifier) {
     return callback.name === name;
   }
-  if (callback.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
+  if (callback.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const call = soleCall(callback);
-  return call !== null && call.arguments.length === 0 && call.callee.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.name === name;
+  return call !== null && call.arguments.length === 0 && call.callee.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.name === name;
 }
 function rejectsInCallback(callback, name) {
-  if (callback.type === import_utils55.AST_NODE_TYPES.Identifier) {
+  if (callback.type === import_utils56.AST_NODE_TYPES.Identifier) {
     return callback.name === name;
   }
-  if (callback.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
+  if (callback.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const call = soleCall(callback);
-  return call !== null && call.callee.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.name === name;
+  return call !== null && call.callee.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.name === name;
 }
 function parameterName(fn, index) {
   const parameter = fn.params[index];
-  return parameter?.type === import_utils55.AST_NODE_TYPES.Identifier ? parameter.name : null;
+  return parameter?.type === import_utils56.AST_NODE_TYPES.Identifier ? parameter.name : null;
 }
 function isRaceArm(node) {
   const array = node.parent;
-  if (array?.type !== import_utils55.AST_NODE_TYPES.ArrayExpression) {
+  if (array?.type !== import_utils56.AST_NODE_TYPES.ArrayExpression) {
     return false;
   }
   const call = array.parent;
-  return call?.type === import_utils55.AST_NODE_TYPES.CallExpression && call.arguments[0] === array && call.callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && call.callee.object.name === "Promise" && call.callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && RACE_METHODS.has(call.callee.property.name);
+  return call?.type === import_utils56.AST_NODE_TYPES.CallExpression && call.arguments[0] === array && call.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && call.callee.object.name === "Promise" && call.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && RACE_METHODS.has(call.callee.property.name);
 }
-var no_hand_rolled_sleep_default = import_utils55.ESLintUtils.RuleCreator(
+var no_hand_rolled_sleep_default = import_utils56.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-hand-rolled-sleep",
@@ -7515,10 +7918,10 @@ var no_hand_rolled_sleep_default = import_utils55.ESLintUtils.RuleCreator(
       }
       const program = sourceCode.ast;
       for (const statement of program.body) {
-        if (statement.type === import_utils55.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils55.AST_NODE_TYPES.Literal && statement.expression.value === "use client") {
+        if (statement.type === import_utils56.AST_NODE_TYPES.ExpressionStatement && statement.expression.type === import_utils56.AST_NODE_TYPES.Literal && statement.expression.value === "use client") {
           return true;
         }
-        if (statement.type === import_utils55.AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && CLIENT_ONLY_MODULES.test(statement.source.value)) {
+        if (statement.type === import_utils56.AST_NODE_TYPES.ImportDeclaration && typeof statement.source.value === "string" && CLIENT_ONLY_MODULES.test(statement.source.value)) {
           return true;
         }
       }
@@ -7534,11 +7937,11 @@ var no_hand_rolled_sleep_default = import_utils55.ESLintUtils.RuleCreator(
     };
     return {
       NewExpression(node) {
-        if (node.callee.type !== import_utils55.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+        if (node.callee.type !== import_utils56.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
           return;
         }
         const executor = node.arguments[0];
-        if (executor?.type !== import_utils55.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils55.AST_NODE_TYPES.FunctionExpression) {
+        if (executor?.type !== import_utils56.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils56.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const call = soleCall(executor);
@@ -7566,8 +7969,8 @@ var no_hand_rolled_sleep_default = import_utils55.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-setup-file-mocks.ts
-var import_utils56 = require("@typescript-eslint/utils");
-var prefer_setup_file_mocks_default = import_utils56.ESLintUtils.RuleCreator(
+var import_utils57 = require("@typescript-eslint/utils");
+var prefer_setup_file_mocks_default = import_utils57.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-setup-file-mocks",
@@ -7588,7 +7991,7 @@ var prefer_setup_file_mocks_default = import_utils56.ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && (node.callee.object.name === "vi" || node.callee.object.name === "jest") && node.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && node.callee.property.name === "mock") {
+        if (node.callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils57.AST_NODE_TYPES.Identifier && (node.callee.object.name === "vi" || node.callee.object.name === "jest") && node.callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && node.callee.property.name === "mock") {
           context.report({
             node,
             messageId: "preferSetupFileMocks"
@@ -7626,6 +8029,7 @@ var rules = {
   "no-unsafe-mock-casting": no_unsafe_mock_casting_default,
   "prefer-string-literal-union": prefer_string_literal_union_default,
   "prefer-zod-enum": prefer_zod_enum_default,
+  "prefer-zod-infer": prefer_zod_infer_default,
   "no-silent-promise-catch": no_silent_promise_catch_default,
   "require-fetch-timeout": require_fetch_timeout_default,
   "no-offset-pagination": no_offset_pagination_default,
@@ -7656,7 +8060,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "4.1.0"
+    version: "4.2.0"
   },
   rules,
   configs: {
@@ -7692,6 +8096,11 @@ var plugin = {
         "@sarj/no-unsafe-mock-casting": "warn",
         "@sarj/prefer-string-literal-union": "warn",
         "@sarj/prefer-zod-enum": "warn",
+        // A type hand-written beside the Zod schema it restates drifts the
+        // moment the schema gains a field. 30,759-file, 17-repo sweep
+        // (2026-07): 5 reports, 5 true positives, all in public repos.
+        // `requireIdenticalShape: false` widens it to 8 reports, 1 of them noise.
+        "@sarj/prefer-zod-infer": "warn",
         // Mined from 2y of PR review feedback + 5-repo code-smell audit (2026-07).
         "@sarj/require-fetch-timeout": "warn",
         "@sarj/no-silent-promise-catch": "warn",
@@ -7787,6 +8196,8 @@ var plugin = {
         // Promoted to error 2026-07-25 — strict means strict (user directive).
         "@sarj/prefer-string-literal-union": "error",
         "@sarj/prefer-zod-enum": "error",
+        // See the `recommended` block for the measured counts.
+        "@sarj/prefer-zod-infer": "error",
         // Mined from 2y of PR review feedback + 5-repo code-smell audit (2026-07).
         "@sarj/require-fetch-timeout": "error",
         "@sarj/no-silent-promise-catch": "error",