@sarj/eslint-plugin 2.17.0 → 4.0.0

package/dist/index.cjs

@@ -1856,257 +1856,8 @@ var no_sentinel_return_on_catch_default = import_utils12.ESLintUtils.RuleCreator
   }
 });
 
-// src/rules/no-sequential-await.ts
-var import_utils13 = require("@typescript-eslint/utils");
-var ARRAY_ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map", "filter"]);
-var SEQUENTIAL_ITERABLE_HINT = /sort|reverse|ordered|sequence|hook|middleware|pipeline|preset|plugin|extension|\bstage|\bstep|\bphase|migration|chain|buffer|stream|teleport|chunk|\bqueue|drain/i;
-var BENCH_FILE_RE = /(^|[\\/])bench(marks?)?[\\/]|\.bench\.[cm]?[jt]sx?$/i;
-function isFunctionLike(node) {
-  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
-}
-function isLoop(node) {
-  return node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
-}
-function isNode2(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function visitScope(root, visit) {
-  visit(root);
-  for (const key of Object.keys(root)) {
-    if (key === "parent") {
-      continue;
-    }
-    const value = root[key];
-    const children = Array.isArray(value) ? value : [value];
-    for (const child of children) {
-      if (isNode2(child) && !isFunctionLike(child) && !isLoop(child)) {
-        visitScope(child, visit);
-      }
-    }
-  }
-}
-function collectAwaits(root) {
-  const awaits = [];
-  visitScope(root, (node) => {
-    if (node.type === "AwaitExpression") {
-      awaits.push(node);
-    }
-  });
-  return awaits;
-}
-var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
-function hasEarlyExit(root) {
-  let found = false;
-  visitScope(root, (node) => {
-    if (node.type === "ReturnStatement" || node.type === "BreakStatement" || node.type === "ContinueStatement") {
-      found = true;
-    }
-  });
-  return found;
-}
-var TIMER_HELPER_RE = /^(sleep|timeout|delay|wait|pause|tick)$/i;
-function calleeName2(callee) {
-  if (callee.type === "Identifier") return callee.name;
-  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
-    return callee.property.name;
-  }
-  return null;
-}
-function isTimerYield(node) {
-  const arg = node.argument;
-  if (arg.type === "NewExpression" && arg.callee.type === "Identifier" && arg.callee.name === "Promise") {
-    return true;
-  }
-  if (arg.type === "CallExpression") {
-    if (arg.callee.type === "MemberExpression" && !arg.callee.computed && arg.callee.object.type === "Identifier" && arg.callee.object.name === "Promise" && arg.callee.property.type === "Identifier" && (arg.callee.property.name === "resolve" || arg.callee.property.name === "reject")) {
-      return true;
-    }
-    const name = calleeName2(arg.callee);
-    return name !== null && TIMER_HELPER_RE.test(name);
-  }
-  return false;
-}
-var QUEUE_DRAIN_METHODS = /^(shift|pop|dequeue|next|poll)$/;
-function isQueueDrain(node) {
-  const arg = node.argument;
-  return arg.type === "CallExpression" && arg.callee.type === "MemberExpression" && !arg.callee.computed && arg.callee.property.type === "Identifier" && QUEUE_DRAIN_METHODS.test(arg.callee.property.name);
-}
-function hasAssertion(root) {
-  let found = false;
-  visitScope(root, (node) => {
-    if (node.type !== "CallExpression") {
-      return;
-    }
-    let callee = node.callee;
-    while (callee.type === "MemberExpression") {
-      callee = callee.object;
-    }
-    if (callee.type === "CallExpression") {
-      callee = callee.callee;
-    }
-    if (callee.type === "Identifier" && ASSERTION_CALLEE_RE.test(callee.name)) {
-      found = true;
-    }
-  });
-  return found;
-}
-function referencesName(root, name) {
-  let found = false;
-  visitScope(root, (node) => {
-    if (node.type === "Identifier" && node.name === name) {
-      found = true;
-    }
-  });
-  return found;
-}
-function isThreadedAccumulator(node) {
-  const parent = node.parent;
-  let target = null;
-  if (parent.type === "AssignmentExpression" && parent.operator === "=" && parent.right === node && parent.left.type === "Identifier") {
-    target = parent.left.name;
-  } else if (parent.type === "VariableDeclarator" && parent.init === node && parent.id.type === "Identifier") {
-    target = parent.id.name;
-  }
-  if (target === null) {
-    return false;
-  }
-  return referencesName(node.argument, target);
-}
-function namesReadBy(test) {
-  const names = /* @__PURE__ */ new Set();
-  visitScope(test, (node) => {
-    if (node.type === "Identifier") {
-      names.add(node.name);
-    }
-  });
-  return names;
-}
-function testStateIsAssignedInBody(test, body) {
-  const testNames = namesReadBy(test);
-  if (testNames.size === 0) {
-    return false;
-  }
-  let found = false;
-  visitScope(body, (node) => {
-    if (node.type === "AssignmentExpression" && node.operator === "=" && node.left.type === "Identifier" && testNames.has(node.left.name)) {
-      found = true;
-    }
-  });
-  return found;
-}
-function shouldReport(awaits, earlyExit, iterableText, asserts = false) {
-  if (awaits.length === 0) {
-    return false;
-  }
-  if (earlyExit) {
-    return false;
-  }
-  if (asserts) {
-    return false;
-  }
-  if (iterableText !== null && SEQUENTIAL_ITERABLE_HINT.test(iterableText)) {
-    return false;
-  }
-  return awaits.some(
-    (node) => !isTimerYield(node) && !isThreadedAccumulator(node) && !isQueueDrain(node)
-  );
-}
-var no_sequential_await_default = import_utils13.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "no-sequential-await",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow serial `await` inside a loop; use `await Promise.all(...)` to run the operations concurrently."
-    },
-    schema: [],
-    messages: {
-      noSequentialAwait: "Avoid `await` inside a loop \u2014 it serializes I/O. Collect the promises and `await Promise.all(xs.map(async (x) => ...))` instead."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (isTestFile(context.filename) || BENCH_FILE_RE.test(context.filename)) {
-      return {};
-    }
-    function loopParts(node) {
-      if (node.type === "ForStatement") {
-        return [node.body, node.test, node.update];
-      }
-      if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
-        return [node.body];
-      }
-      return [node.body, node.test];
-    }
-    function iterableTextOf(node) {
-      if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
-        return context.sourceCode.getText(node.right);
-      }
-      return null;
-    }
-    function checkLoop(node) {
-      if ((node.type === "WhileStatement" || node.type === "DoWhileStatement") && testStateIsAssignedInBody(node.test, node.body)) {
-        return;
-      }
-      const awaits = [];
-      let earlyExit = false;
-      let asserts = false;
-      for (const part of loopParts(node)) {
-        if (part === null || isLoop(part)) {
-          continue;
-        }
-        awaits.push(...collectAwaits(part));
-        if (!earlyExit && hasEarlyExit(part)) {
-          earlyExit = true;
-        }
-        if (!asserts && hasAssertion(part)) {
-          asserts = true;
-        }
-      }
-      if (shouldReport(awaits, earlyExit, iterableTextOf(node), asserts)) {
-        context.report({ node, messageId: "noSequentialAwait" });
-      }
-    }
-    return {
-      ForStatement: checkLoop,
-      ForInStatement: checkLoop,
-      WhileStatement: checkLoop,
-      DoWhileStatement: checkLoop,
-      ForOfStatement(node) {
-        if (node.await) {
-          return;
-        }
-        checkLoop(node);
-      },
-      CallExpression(node) {
-        const callee = node.callee;
-        if (callee.type !== "MemberExpression" || callee.computed) {
-          return;
-        }
-        if (callee.property.type !== "Identifier" || !ARRAY_ITERATION_METHODS.has(callee.property.name)) {
-          return;
-        }
-        const callback = node.arguments[0];
-        if (callback === void 0 || !isFunctionLike(callback) || !("async" in callback && callback.async)) {
-          return;
-        }
-        if (callee.property.name !== "forEach" && node.parent.type !== "ExpressionStatement") {
-          return;
-        }
-        const awaits = collectAwaits(callback.body);
-        const earlyExit = hasEarlyExit(callback.body);
-        const iterableText = context.sourceCode.getText(callee.object);
-        if (shouldReport(awaits, earlyExit, iterableText, hasAssertion(callback.body))) {
-          context.report({ node, messageId: "noSequentialAwait" });
-        }
-      }
-    };
-  }
-});
-
 // src/rules/no-string-concat-in-loop.ts
-var import_utils14 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -2191,7 +1942,7 @@ function enclosingLoop(node) {
   }
   return null;
 }
-var no_string_concat_in_loop_default = import_utils14.ESLintUtils.RuleCreator(
+var no_string_concat_in_loop_default = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-string-concat-in-loop",
@@ -2254,7 +2005,7 @@ var no_string_concat_in_loop_default = import_utils14.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils15 = require("@typescript-eslint/utils");
+var import_utils14 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -2280,13 +2031,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === import_utils15.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils14.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils15.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils14.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils15.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -2301,16 +2052,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils15.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils15.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils14.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils14.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils15.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils14.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils15.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils14.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -2327,7 +2078,7 @@ var isGlobalReference = (node, context) => {
   }
   return true;
 };
-var no_unnecessary_use_client_default = import_utils15.ESLintUtils.RuleCreator(
+var no_unnecessary_use_client_default = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unnecessary-use-client",
@@ -2352,13 +2103,13 @@ var no_unnecessary_use_client_default = import_utils15.ESLintUtils.RuleCreator(
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils15.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils14.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils15.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils15.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils14.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils14.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -2368,7 +2119,7 @@ var no_unnecessary_use_client_default = import_utils15.ESLintUtils.RuleCreator(
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils15.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils14.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -2381,7 +2132,7 @@ var no_unnecessary_use_client_default = import_utils15.ESLintUtils.RuleCreator(
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils15.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils14.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -2448,8 +2199,8 @@ var no_unnecessary_use_client_default = import_utils15.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-discriminated-union.ts
+var import_utils15 = require("@typescript-eslint/utils");
 var import_utils16 = require("@typescript-eslint/utils");
-var import_utils17 = require("@typescript-eslint/utils");
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -2459,27 +2210,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils17.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils17.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils17.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils16.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils17.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils16.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   let optionalPayloadCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== import_utils17.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils16.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -2495,7 +2246,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   }
   return hasStatusBoolean && optionalCount >= MIN_OPTIONAL_MEMBERS && optionalPayloadCount >= 1;
 }
-var prefer_discriminated_union_default = import_utils16.ESLintUtils.RuleCreator(
+var prefer_discriminated_union_default = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-discriminated-union",
@@ -2523,7 +2274,7 @@ var prefer_discriminated_union_default = import_utils16.ESLintUtils.RuleCreator(
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils17.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils16.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -2536,13 +2287,13 @@ var prefer_discriminated_union_default = import_utils16.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var unwrap = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils18.AST_NODE_TYPES.TSAsExpression || current.type === import_utils18.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils18.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils18.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils17.AST_NODE_TYPES.TSAsExpression || current.type === import_utils17.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils17.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils17.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils18.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils17.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -2553,25 +2304,25 @@ var unwrap = (node) => {
 var isRawPayloadSource = (node) => {
   let current = unwrap(node);
   if (current === null) return false;
-  if (current.type === import_utils18.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils17.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap(current.argument);
   }
-  if (current === null || current.type !== import_utils18.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils17.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap(current.callee);
-  if (callee === null || callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap(callee.property);
-  if (property === null || property.type !== import_utils18.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils17.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
     return true;
   }
   const object = unwrap(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils18.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
+  return property.name === "parse" && object !== null && object.type === import_utils17.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
   !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
@@ -2579,9 +2330,9 @@ var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils18.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils17.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap(current.callee);
-      const name = callee?.type === import_utils18.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils18.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils18.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      const name = callee?.type === import_utils17.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils17.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils17.AST_NODE_TYPES.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -2600,18 +2351,18 @@ var isLocalFileRead = (node) => {
   visit(node);
   return found;
 };
-var ASSERTION_CALLEE_RE2 = /^(expect|assert|should|invariant)$/;
+var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils18.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils17.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils18.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils17.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils18.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils17.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils18.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE2.test(callee.name)) {
+    if (callee.type === import_utils17.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -2632,17 +2383,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils18.AST_NODE_TYPES.UnaryExpression:
-      case import_utils18.AST_NODE_TYPES.LogicalExpression:
-      case import_utils18.AST_NODE_TYPES.ChainExpression:
+      case import_utils17.AST_NODE_TYPES.UnaryExpression:
+      case import_utils17.AST_NODE_TYPES.LogicalExpression:
+      case import_utils17.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils18.AST_NODE_TYPES.IfStatement:
-      case import_utils18.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils18.AST_NODE_TYPES.WhileStatement:
-      case import_utils18.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils18.AST_NODE_TYPES.ForStatement:
+      case import_utils17.AST_NODE_TYPES.IfStatement:
+      case import_utils17.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils17.AST_NODE_TYPES.WhileStatement:
+      case import_utils17.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils17.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -2652,13 +2403,13 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap(node);
-  if (unwrapped === null || unwrapped.type !== import_utils18.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils17.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
   return variable !== null && tracked.has(variable);
 };
-var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreator(
+var prefer_schema_for_api_payload_default = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-schema-for-api-payload",
@@ -2689,11 +2440,11 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils18.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils18.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils18.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             context.report({ node: node.id, messageId: "unparsedJsonAccess" });
             return;
@@ -2705,7 +2456,7 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils18.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils17.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -2715,7 +2466,7 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
           }
           return;
         }
-        if (node.left.type === import_utils18.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils18.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils17.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils17.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -2732,15 +2483,15 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils18.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils17.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils18.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils17.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils18.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils17.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -2753,13 +2504,13 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
         const obj = unwrap(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils18.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils18.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
+          if (parent.type === import_utils17.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils17.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils18.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils17.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -2772,7 +2523,7 @@ var prefer_schema_for_api_payload_default = import_utils18.ESLintUtils.RuleCreat
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils18 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -2825,6 +2576,7 @@ var DETECTION_FILES = [
   "src/styles/globals.css",
   "styles/globals.css"
 ];
+var MAX_UPWARD_DEPTH = 8;
 var semanticTokenCache = /* @__PURE__ */ new Map();
 var SVG_DEFS_CONTAINERS = /* @__PURE__ */ new Set([
   "mask",
@@ -2846,8 +2598,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils19.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils19.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils19.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils18.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils18.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils18.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -2858,7 +2610,7 @@ function isSvgLikeElementName(name) {
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils19.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils18.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -2869,7 +2621,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils19.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils19.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils19.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils19.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils18.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils18.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils18.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils18.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -2879,9 +2631,15 @@ var isInsideIconFactoryPath = (node) => {
 var hasSemanticTokenSystem = (filename) => {
   let dir = (0, import_path.dirname)(filename);
   const root = (0, import_path.parse)(dir).root;
-  for (let depth = 0; depth < 8; depth += 1) {
+  const visited = [];
+  let answer;
+  for (let depth = 0; depth < MAX_UPWARD_DEPTH; depth += 1) {
     const cached = semanticTokenCache.get(dir);
-    if (cached !== void 0) return cached;
+    if (cached !== void 0) {
+      answer = cached;
+      break;
+    }
+    visited.push(dir);
     let found = false;
     for (const rel of DETECTION_FILES) {
       const candidate = (0, import_path.join)(dir, rel);
@@ -2898,18 +2656,26 @@ var hasSemanticTokenSystem = (filename) => {
       } catch {
       }
     }
-    semanticTokenCache.set(dir, found);
-    if (found || dir === root) return found;
+    if (found) {
+      answer = true;
+      break;
+    }
+    if (dir === root) {
+      answer = false;
+      break;
+    }
     dir = (0, import_path.dirname)(dir);
   }
-  return false;
+  if (answer === void 0) return false;
+  for (const seen of visited) semanticTokenCache.set(seen, answer);
+  return answer;
 };
 var propName = (key) => {
-  if (key.type === import_utils19.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils19.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils18.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils18.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
-var prefer_semantic_colors_default = import_utils19.ESLintUtils.RuleCreator(
+var prefer_semantic_colors_default = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-semantic-colors",
@@ -2952,27 +2718,27 @@ var prefer_semantic_colors_default = import_utils19.ESLintUtils.RuleCreator(
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils19.AST_NODE_TYPES.Literal:
+        case import_utils18.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils19.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils18.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils19.AST_NODE_TYPES.ArrayExpression:
+        case import_utils18.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils19.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils19.AST_NODE_TYPES.ObjectExpression:
+        case import_utils18.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils19.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils18.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils19.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils18.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils19.AST_NODE_TYPES.LogicalExpression:
+        case import_utils18.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -2980,29 +2746,29 @@ var prefer_semantic_colors_default = import_utils19.ESLintUtils.RuleCreator(
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils19.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
+      if (node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value)) {
         context.report({ node, messageId: "inlineColor", data: { value: node.value } });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils19.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils19.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils19.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils18.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils18.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils18.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils19.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils19.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils18.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils19.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils18.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -3014,7 +2780,7 @@ var prefer_semantic_colors_default = import_utils19.ESLintUtils.RuleCreator(
       // Neutral drawing literals and anything inside an SVG defs container are
       // structural, not UI tokens, so they never fire.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils19.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils18.AST_NODE_TYPES.Literal) return;
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
           return;
         }
@@ -3031,7 +2797,7 @@ var prefer_semantic_colors_default = import_utils19.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
@@ -3111,7 +2877,7 @@ function getPropertyNode(objNode, propName2) {
   }
   return null;
 }
-var prefer_server_actions_default = import_utils20.ESLintUtils.RuleCreator(
+var prefer_server_actions_default = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-server-actions",
@@ -3185,116 +2951,37 @@ var prefer_server_actions_default = import_utils20.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/prefer-shadcn.ts
-var import_utils21 = require("@typescript-eslint/utils");
-var REPLACEMENTS = {
-  select: "Select",
-  textarea: "Textarea",
-  dialog: "Dialog"
-};
-var INPUT_TYPE_REPLACEMENTS = {
-  checkbox: "Checkbox",
-  radio: "RadioGroup",
-  range: "Slider"
-};
-var SKIPPED_INPUT_TYPES = /* @__PURE__ */ new Set(["file", "hidden"]);
-var kebabCase = (component) => component.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-var literalTypeAttr = (node) => {
-  for (const attribute of node.attributes) {
-    if (attribute.type !== import_utils21.AST_NODE_TYPES.JSXAttribute || attribute.name.type !== import_utils21.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== "type") {
-      continue;
-    }
-    if (attribute.value?.type === import_utils21.AST_NODE_TYPES.Literal && typeof attribute.value.value === "string") {
-      return { kind: "literal", value: attribute.value.value.toLowerCase() };
-    }
-    return { kind: "dynamic" };
-  }
-  return null;
-};
-var hasFileAcceptAttr = (node) => node.attributes.some(
-  (attribute) => attribute.type === import_utils21.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils21.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "accept"
-);
-var resolveInputReplacement = (node) => {
-  const typeAttr = literalTypeAttr(node);
-  if (hasFileAcceptAttr(node)) return null;
-  if (typeAttr === null || typeAttr.kind === "dynamic") return "Input";
-  if (SKIPPED_INPUT_TYPES.has(typeAttr.value)) return null;
-  return INPUT_TYPE_REPLACEMENTS[typeAttr.value] ?? "Input";
-};
-var prefer_shadcn_default = import_utils21.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "prefer-shadcn",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer shadcn/ui form primitives over native `<input>`, `<select>`, `<textarea>`, and `<dialog>` elements."
-    },
-    schema: [],
-    messages: {
-      preferShadcn: "Use the shadcn <{{replacement}}> component from @/components/ui/{{lowercase}} instead of native <{{element}}>."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (isTestFile(context.filename) || isStoryFile(context.filename)) {
-      return {};
-    }
-    return {
-      JSXOpeningElement(node) {
-        if (node.name.type !== "JSXIdentifier") {
-          return;
-        }
-        const elementName = node.name.name;
-        const replacement = elementName === "input" ? resolveInputReplacement(node) : REPLACEMENTS[elementName];
-        if (replacement === void 0 || replacement === null) {
-          return;
-        }
-        context.report({
-          node,
-          messageId: "preferShadcn",
-          data: {
-            element: elementName,
-            replacement,
-            lowercase: kebabCase(replacement)
-          }
-        });
-      }
-    };
-  }
-});
-
 // src/rules/require-assert-never.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils22.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils20.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === import_utils22.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return callee.name === "assertNever";
   }
-  if (callee.type === import_utils22.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils22.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils20.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "assertNever";
   }
   return false;
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === import_utils22.AST_NODE_TYPES.ExpressionStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils22.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils22.AST_NODE_TYPES.ReturnStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils22.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils22.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils22.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils20.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils20.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -3310,12 +2997,12 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils22.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils20.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
 };
-var require_assert_never_default = import_utils22.ESLintUtils.RuleCreator(
+var require_assert_never_default = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-assert-never",
@@ -3353,7 +3040,7 @@ var require_assert_never_default = import_utils22.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -3364,14 +3051,14 @@ var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils23.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils21.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils23.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils21.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils23.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils21.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -3379,25 +3066,25 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils23.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils23.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
   const method = callee.property.name;
   if (method !== "parse" && method !== "safeParse") return false;
   return looksLikeZodSchema(callee.object);
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils23.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils21.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils23.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils21.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils23.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils21.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils21.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
-var require_zod_form_validation_default = import_utils23.ESLintUtils.RuleCreator(
+var require_zod_form_validation_default = import_utils21.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-zod-form-validation",
@@ -3417,14 +3104,14 @@ var require_zod_form_validation_default = import_utils23.ESLintUtils.RuleCreator
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils23.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils21.AST_NODE_TYPES.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils23.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils21.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -3435,8 +3122,8 @@ var require_zod_form_validation_default = import_utils23.ESLintUtils.RuleCreator
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils23.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -3451,11 +3138,11 @@ var require_zod_form_validation_default = import_utils23.ESLintUtils.RuleCreator
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils23.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
+      return parent !== null && parent !== void 0 && parent.type === import_utils21.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === import_utils23.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils23.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils21.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils21.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -3483,7 +3170,7 @@ var require_zod_form_validation_default = import_utils23.ESLintUtils.RuleCreator
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -3507,15 +3194,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils24.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils22.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils24.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils22.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils24.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils22.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils24.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils22.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -3523,7 +3210,7 @@ var calleeChainStartsWithZ = (node) => {
   }
   return false;
 };
-var zod_naming_convention_default = import_utils24.ESLintUtils.RuleCreator(
+var zod_naming_convention_default = import_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "zod-naming-convention",
@@ -3562,13 +3249,13 @@ var zod_naming_convention_default = import_utils24.ESLintUtils.RuleCreator(
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils24.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils22.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== import_utils24.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils22.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -3581,7 +3268,7 @@ var zod_naming_convention_default = import_utils24.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-cors-wildcard-with-credentials.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 var ACAO_HEADER = "access-control-allow-origin";
 var ACAC_HEADER = "access-control-allow-credentials";
 var HEADER_SET_METHODS = /* @__PURE__ */ new Set(["setheader", "set", "append"]);
@@ -3613,17 +3300,17 @@ function subtreeContainsStarLiteral(node) {
     const value = node[key];
     if (Array.isArray(value)) {
       for (const child of value) {
-        if (isNode3(child) && subtreeContainsStarLiteral(child)) {
+        if (isNode2(child) && subtreeContainsStarLiteral(child)) {
           return true;
         }
       }
-    } else if (isNode3(value) && subtreeContainsStarLiteral(value)) {
+    } else if (isNode2(value) && subtreeContainsStarLiteral(value)) {
       return true;
     }
   }
   return false;
 }
-function isNode3(value) {
+function isNode2(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 function propertyKeyName(prop) {
@@ -3639,7 +3326,7 @@ function propertyKeyName(prop) {
   }
   return void 0;
 }
-function calleeName3(node) {
+function calleeName2(node) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
     return callee.name;
@@ -3650,7 +3337,7 @@ function calleeName3(node) {
   return void 0;
 }
 function isCorsWildcardCredentialsCall(node) {
-  const name = calleeName3(node);
+  const name = calleeName2(node);
   if (name === void 0 || name.toLowerCase() !== "cors") {
     return false;
   }
@@ -3723,7 +3410,7 @@ function enclosingScope(node) {
   }
   return void 0;
 }
-var no_cors_wildcard_with_credentials_default = import_utils25.ESLintUtils.RuleCreator(
+var no_cors_wildcard_with_credentials_default = import_utils23.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-cors-wildcard-with-credentials",
@@ -3791,9 +3478,9 @@ var no_cors_wildcard_with_credentials_default = import_utils25.ESLintUtils.RuleC
 });
 
 // src/rules/no-silent-promise-catch.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 function isBodyParseCall(node) {
-  return node.type === import_utils26.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils26.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils26.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+  return node.type === import_utils24.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils24.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils24.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -3808,21 +3495,21 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
-  return node.type === import_utils26.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils26.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils26.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
+  return node.type === import_utils24.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils24.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils24.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
 function isSilentExpression(node) {
   switch (node.type) {
-    case import_utils26.AST_NODE_TYPES.Literal:
+    case import_utils24.AST_NODE_TYPES.Literal:
       return !("regex" in node);
-    case import_utils26.AST_NODE_TYPES.Identifier:
+    case import_utils24.AST_NODE_TYPES.Identifier:
       return node.name === "undefined";
-    case import_utils26.AST_NODE_TYPES.UnaryExpression:
-      return node.operator === "void" && node.argument.type === import_utils26.AST_NODE_TYPES.Literal;
-    case import_utils26.AST_NODE_TYPES.ObjectExpression:
+    case import_utils24.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils24.AST_NODE_TYPES.Literal;
+    case import_utils24.AST_NODE_TYPES.ObjectExpression:
       return node.properties.length === 0;
-    case import_utils26.AST_NODE_TYPES.ArrayExpression:
+    case import_utils24.AST_NODE_TYPES.ArrayExpression:
       return node.elements.length === 0;
-    case import_utils26.AST_NODE_TYPES.TSAsExpression:
+    case import_utils24.AST_NODE_TYPES.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
@@ -3830,7 +3517,7 @@ function isSilentExpression(node) {
 }
 function isSilentHandler(handler) {
   const body = handler.body;
-  if (body.type !== import_utils26.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils24.AST_NODE_TYPES.BlockStatement) {
     return isSilentExpression(body);
   }
   if (body.body.length === 0) {
@@ -3838,13 +3525,13 @@ function isSilentHandler(handler) {
   }
   if (body.body.length === 1) {
     const only = body.body[0];
-    if (only !== void 0 && only.type === import_utils26.AST_NODE_TYPES.ReturnStatement) {
+    if (only !== void 0 && only.type === import_utils24.AST_NODE_TYPES.ReturnStatement) {
       return only.argument === null || isSilentExpression(only.argument);
     }
   }
   return false;
 }
-var no_silent_promise_catch_default = import_utils26.ESLintUtils.RuleCreator(
+var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-silent-promise-catch",
@@ -3869,7 +3556,7 @@ var no_silent_promise_catch_default = import_utils26.ESLintUtils.RuleCreator(
         return true;
       }
       let statement = call;
-      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils26.AST_NODE_TYPES.VariableDeclaration) {
+      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils24.AST_NODE_TYPES.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -3881,7 +3568,7 @@ var no_silent_promise_catch_default = import_utils26.ESLintUtils.RuleCreator(
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils26.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils26.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
+        if (node.callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils24.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
           return;
         }
         if (isBodyParseCall(node.callee.object)) {
@@ -3890,14 +3577,14 @@ var no_silent_promise_catch_default = import_utils26.ESLintUtils.RuleCreator(
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === import_utils26.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
+        if (node.parent.type === import_utils24.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
           return;
         }
         if (node.arguments.length !== 1) {
           return;
         }
         const handler = node.arguments[0];
-        if (handler === void 0 || handler.type !== import_utils26.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils26.AST_NODE_TYPES.FunctionExpression) {
+        if (handler === void 0 || handler.type !== import_utils24.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils24.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -3912,7 +3599,7 @@ var no_silent_promise_catch_default = import_utils26.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var CODEMOD_FIXTURE_RE = /[\\/]__testfixtures__[\\/]/;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
   "globalThis",
@@ -3929,14 +3616,14 @@ function matchesAnyPattern2(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils27.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils25.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils27.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils25.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils27.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils27.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils25.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils25.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -3946,9 +3633,9 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isStringish(node) {
-  return node.type === import_utils27.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils27.AST_NODE_TYPES.TemplateLiteral;
+  return node.type === import_utils25.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils25.AST_NODE_TYPES.TemplateLiteral;
 }
-var require_fetch_timeout_default = import_utils27.ESLintUtils.RuleCreator(
+var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-fetch-timeout",
@@ -3985,14 +3672,14 @@ var require_fetch_timeout_default = import_utils27.ESLintUtils.RuleCreator(
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils27.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils25.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils27.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils25.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils27.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils27.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils25.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils25.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils25.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -4011,100 +3698,13 @@ var require_fetch_timeout_default = import_utils27.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/require-schema-validate-search.ts
-var import_utils28 = require("@typescript-eslint/utils");
-var VALIDATOR_METHODS = /* @__PURE__ */ new Set([
-  "parse",
-  "safeParse",
-  "decode"
-]);
-function isConstTypeAnnotation(typeAnnotation) {
-  return typeAnnotation.type === import_utils28.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils28.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
-}
-function isValidatorCall(node) {
-  return node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier && VALIDATOR_METHODS.has(node.callee.property.name);
-}
-function findCastExpression(node, insideValidatorArg) {
-  if ((node.type === import_utils28.AST_NODE_TYPES.TSAsExpression || node.type === import_utils28.AST_NODE_TYPES.TSTypeAssertion) && !isConstTypeAnnotation(node.typeAnnotation) && !insideValidatorArg) {
-    return node;
-  }
-  if (node.type === import_utils28.AST_NODE_TYPES.CallExpression && isValidatorCall(node)) {
-    const inCallee = findCastExpression(node.callee, insideValidatorArg);
-    if (inCallee !== null) {
-      return inCallee;
-    }
-    for (const arg of node.arguments) {
-      const found = findCastExpression(arg, true);
-      if (found !== null) {
-        return found;
-      }
-    }
-    return null;
-  }
-  for (const key of Object.keys(node)) {
-    if (key === "parent") {
-      continue;
-    }
-    const value = node[key];
-    const children = Array.isArray(value) ? value : [value];
-    for (const child of children) {
-      if (child !== null && typeof child === "object" && "type" in child && typeof child.type === "string") {
-        const found = findCastExpression(
-          child,
-          insideValidatorArg
-        );
-        if (found !== null) {
-          return found;
-        }
-      }
-    }
-  }
-  return null;
-}
-var require_schema_validate_search_default = import_utils28.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "require-schema-validate-search",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `as` casts inside hand-rolled `validateSearch` functions; use a schema validator (e.g. zodValidator) so search params are validated at runtime."
-    },
-    schema: [],
-    messages: {
-      castInValidateSearch: "This `validateSearch` asserts the search-param shape with `as` instead of validating it \u2014 malformed query params flow through typed as clean data. Use a schema validator (e.g. `zodValidator(searchSchema)` or `searchSchema.parse`) instead of casting."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (isTestFile(context.filename)) {
-      return {};
-    }
-    return {
-      Property(node) {
-        const isValidateSearchKey = !node.computed && node.key.type === import_utils28.AST_NODE_TYPES.Identifier && node.key.name === "validateSearch" || node.key.type === import_utils28.AST_NODE_TYPES.Literal && node.key.value === "validateSearch";
-        if (!isValidateSearchKey) {
-          return;
-        }
-        if (node.value.type !== import_utils28.AST_NODE_TYPES.ArrowFunctionExpression && node.value.type !== import_utils28.AST_NODE_TYPES.FunctionExpression) {
-          return;
-        }
-        const cast = findCastExpression(node.value.body, false);
-        if (cast !== null) {
-          context.report({ node: cast, messageId: "castInValidateSearch" });
-        }
-      }
-    };
-  }
-});
-
 // src/rules/no-fat-try-blocks.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils29.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils29.AST_NODE_TYPES.FunctionExpression,
-  import_utils29.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils26.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils26.AST_NODE_TYPES.FunctionExpression,
+  import_utils26.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -4197,25 +3797,25 @@ var PURE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "Response",
   "AbortController"
 ]);
-function isNode4(value) {
+function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
 function isPureCall(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils29.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type !== import_utils26.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== import_utils29.AST_NODE_TYPES.Identifier) {
+  if (property.type !== import_utils26.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  if (callee.object.type === import_utils29.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === import_utils26.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
     return true;
   }
   return PURE_METHODS.has(property.name);
 }
 function isPureNew(node) {
-  return node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === import_utils26.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
 function subtreeMatches(stmt, predicate) {
   let found = false;
@@ -4237,11 +3837,11 @@ function subtreeMatches(stmt, predicate) {
       const value = current[key];
       if (Array.isArray(value)) {
         for (const child of value) {
-          if (isNode4(child)) {
+          if (isNode3(child)) {
             visit(child);
           }
         }
-      } else if (isNode4(value)) {
+      } else if (isNode3(value)) {
         visit(value);
       }
       if (found) {
@@ -4252,20 +3852,20 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils29.AST_NODE_TYPES.AwaitExpression);
+var hasAwait = (node) => subtreeMatches(node, (n) => n.type === import_utils26.AST_NODE_TYPES.AwaitExpression);
 var hasThrowingCallOrNew = (node) => subtreeMatches(
   node,
-  (n) => n.type === import_utils29.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils29.AST_NODE_TYPES.NewExpression && !isPureNew(n)
+  (n) => n.type === import_utils26.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils26.AST_NODE_TYPES.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === import_utils29.AST_NODE_TYPES.ChainExpression || current.type === import_utils29.AST_NODE_TYPES.TSNonNullExpression) {
+  while (current.type === import_utils26.AST_NODE_TYPES.ChainExpression || current.type === import_utils26.AST_NODE_TYPES.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
 }
 function isBareCallStatement(stmt) {
-  return stmt.type === import_utils29.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils29.AST_NODE_TYPES.CallExpression;
+  return stmt.type === import_utils26.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils26.AST_NODE_TYPES.CallExpression;
 }
 function canThrow(stmt) {
   if (hasAwait(stmt)) {
@@ -4274,10 +3874,10 @@ function canThrow(stmt) {
   if (isBareCallStatement(stmt)) {
     return false;
   }
-  if (stmt.type === import_utils29.AST_NODE_TYPES.BlockStatement) {
+  if (stmt.type === import_utils26.AST_NODE_TYPES.BlockStatement) {
     return stmt.body.some(canThrow);
   }
-  if (stmt.type === import_utils29.AST_NODE_TYPES.IfStatement) {
+  if (stmt.type === import_utils26.AST_NODE_TYPES.IfStatement) {
     return hasThrowingCallOrNew(stmt.test) || canThrow(stmt.consequent) || stmt.alternate !== null && canThrow(stmt.alternate);
   }
   return hasThrowingCallOrNew(stmt);
@@ -4288,9 +3888,9 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === import_utils29.AST_NODE_TYPES.ThrowStatement;
+  return last !== void 0 && last.type === import_utils26.AST_NODE_TYPES.ThrowStatement;
 }
-var no_fat_try_blocks_default = import_utils29.ESLintUtils.RuleCreator(
+var no_fat_try_blocks_default = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-fat-try-blocks",
@@ -4334,7 +3934,7 @@ var no_fat_try_blocks_default = import_utils29.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 
 // src/rules/_secret_names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -4596,7 +4196,7 @@ function propertyKeyName2(prop) {
   }
   return null;
 }
-var no_secret_in_log_default = import_utils30.ESLintUtils.RuleCreator(
+var no_secret_in_log_default = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-secret-in-log",
@@ -4672,74 +4272,25 @@ var no_secret_in_log_default = import_utils30.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/no-unsafe-cast.ts
-var import_utils31 = require("@typescript-eslint/utils");
-var import_utils32 = require("@typescript-eslint/utils");
-function isAnyAnnotation(node) {
-  return node.type === import_utils32.AST_NODE_TYPES.TSAnyKeyword;
-}
-function isConstAssertion(typeAnnotation) {
-  return typeAnnotation.type === import_utils32.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils32.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
-}
-var no_unsafe_cast_default = import_utils31.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "no-unsafe-cast",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow `as any`/`<any>` casts and `as unknown as T` double-casts, which fully disable type checking."
-    },
-    schema: [],
-    messages: {
-      asAny: "`as any` disables type checking on this value. Narrow with a type guard, model the shape, or cast to a specific type instead.",
-      doubleCast: "`as unknown as T` double-cast bypasses the compiler's structural check. Prefer a runtime validator (e.g. a zod schema) or an accurate type at the boundary."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
-      return {};
-    }
-    function checkAssertion(node) {
-      if (isConstAssertion(node.typeAnnotation)) {
-        return;
-      }
-      if (isAnyAnnotation(node.typeAnnotation)) {
-        context.report({ node, messageId: "asAny" });
-        return;
-      }
-      const inner = node.expression;
-      if (inner.type === import_utils32.AST_NODE_TYPES.TSAsExpression || inner.type === import_utils32.AST_NODE_TYPES.TSTypeAssertion) {
-        context.report({ node, messageId: "doubleCast" });
-      }
-    }
-    return {
-      TSAsExpression: checkAssertion,
-      TSTypeAssertion: checkAssertion
-    };
-  }
-});
-
 // src/rules/no-unsafe-mock-casting.ts
-var import_utils33 = require("@typescript-eslint/utils");
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 function isMockTypeReference(node) {
-  if (node.type !== import_utils34.AST_NODE_TYPES.TSTypeReference) {
+  if (node.type !== import_utils29.AST_NODE_TYPES.TSTypeReference) {
     return false;
   }
   const typeName = node.typeName;
-  if (typeName.type === import_utils34.AST_NODE_TYPES.Identifier) {
+  if (typeName.type === import_utils29.AST_NODE_TYPES.Identifier) {
     const name = typeName.name;
     return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
   }
-  if (typeName.type === import_utils34.AST_NODE_TYPES.TSQualifiedName) {
+  if (typeName.type === import_utils29.AST_NODE_TYPES.TSQualifiedName) {
     const rightName = typeName.right.name;
     return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
   }
   return false;
 }
-var no_unsafe_mock_casting_default = import_utils33.ESLintUtils.RuleCreator(
+var no_unsafe_mock_casting_default = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unsafe-mock-casting",
@@ -4771,7 +4322,7 @@ var no_unsafe_mock_casting_default = import_utils33.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -4814,19 +4365,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils30.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils35.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils30.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils35.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils35.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils30.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils30.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils35.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils30.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -4855,12 +4406,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils30.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils35.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils30.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils35.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils30.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -4868,12 +4419,12 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils35.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils30.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
 }
-var prefer_string_literal_union_default = import_utils35.ESLintUtils.RuleCreator(
+var prefer_string_literal_union_default = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-string-literal-union",
@@ -4911,7 +4462,7 @@ var prefer_string_literal_union_default = import_utils35.ESLintUtils.RuleCreator
     );
     let services;
     try {
-      services = import_utils35.ESLintUtils.getParserServices(context);
+      services = import_utils30.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -5023,7 +4574,7 @@ var prefer_string_literal_union_default = import_utils35.ESLintUtils.RuleCreator
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils35.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils30.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -5111,10 +4662,10 @@ var prefer_string_literal_union_default = import_utils35.ESLintUtils.RuleCreator
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils35.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils30.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils35.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils30.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -5123,11 +4674,11 @@ var prefer_string_literal_union_default = import_utils35.ESLintUtils.RuleCreator
 });
 
 // src/rules/prefer-zod-enum.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 function isZodModule(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
-var prefer_zod_enum_default = import_utils36.ESLintUtils.RuleCreator(
+var prefer_zod_enum_default = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
   name: "prefer-zod-enum",
@@ -5148,20 +4699,20 @@ var prefer_zod_enum_default = import_utils36.ESLintUtils.RuleCreator(
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils36.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils36.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils36.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils31.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
         return null;
       }
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils36.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== import_utils31.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
         return null;
       }
       const values = [];
       for (const element of argument.elements) {
-        if (element === null || element.type !== import_utils36.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils36.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils36.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils36.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
+        if (element === null || element.type !== import_utils31.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils31.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
           return null;
         }
         const value = element.arguments[0];
-        if (value === void 0 || value.type !== import_utils36.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+        if (value === void 0 || value.type !== import_utils31.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
           return null;
         }
         values.push(value);
@@ -5170,11 +4721,11 @@ var prefer_zod_enum_default = import_utils36.ESLintUtils.RuleCreator(
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils36.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== import_utils31.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== import_utils36.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils36.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -5191,7 +4742,7 @@ var prefer_zod_enum_default = import_utils36.ESLintUtils.RuleCreator(
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils36.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils36.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils36.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils36.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils31.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils31.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils31.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -5212,157 +4763,11 @@ var prefer_zod_enum_default = import_utils36.ESLintUtils.RuleCreator(
   }
 });
 
-// src/rules/single-public-export.ts
-var import_utils37 = require("@typescript-eslint/utils");
-var JUNK_DRAWER_STEMS = /* @__PURE__ */ new Set([
-  "util",
-  "utils",
-  "helper",
-  "helpers",
-  "common",
-  "constant",
-  "constants",
-  "type",
-  "types",
-  "model",
-  "models",
-  "shared",
-  "misc"
-]);
-var CONVENTIONAL_BUCKET_EXPORTS = /* @__PURE__ */ new Set(["cn"]);
-var ACRONYM_OVERRIDES = [
-  [/OAuth/g, "Oauth"],
-  [/GraphQL/g, "Graphql"],
-  [/gRPC/g, "Grpc"]
-];
-var CAMEL_BOUNDARY_RE = /(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
-var TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
-var SCRIPT_EXT_RE = /\.[cm]?[jt]sx?$/i;
-var basename = (filename) => filename.split(/[/\\]/).pop() ?? filename;
-var stemOf = (base) => base.replace(SCRIPT_EXT_RE, "");
-var kebabCase2 = (name) => {
-  let normalized = name;
-  for (const [pattern, replacement] of ACRONYM_OVERRIDES) {
-    normalized = normalized.replace(pattern, replacement);
-  }
-  return normalized.replace(CAMEL_BOUNDARY_RE, "-").toLowerCase();
-};
-var isFunctionExpression = (node) => node !== null && (node.type === import_utils37.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils37.AST_NODE_TYPES.FunctionExpression);
-var functionConstName = (decl) => {
-  if (decl.declarations.length !== 1) return null;
-  const [declarator] = decl.declarations;
-  if (declarator === void 0) return null;
-  if (declarator.id.type !== import_utils37.AST_NODE_TYPES.Identifier) return null;
-  if (!isFunctionExpression(declarator.init)) return null;
-  return declarator.id.name;
-};
-var summarizeExports = (body) => {
-  let names = 0;
-  let hasReExport = false;
-  let candidate = null;
-  const addCandidate = (name, node) => {
-    names += 1;
-    candidate = { name, node };
-  };
-  for (const statement of body) {
-    switch (statement.type) {
-      case import_utils37.AST_NODE_TYPES.ExportAllDeclaration:
-        hasReExport = true;
-        break;
-      case import_utils37.AST_NODE_TYPES.ExportDefaultDeclaration: {
-        names += 1;
-        const decl = statement.declaration;
-        if (decl.type === import_utils37.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
-          candidate = { name: decl.id.name, node: statement };
-        } else if (decl.type === import_utils37.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
-          candidate = { name: decl.id.name, node: statement };
-        }
-        break;
-      }
-      case import_utils37.AST_NODE_TYPES.ExportNamedDeclaration: {
-        if (statement.source !== null) {
-          hasReExport = true;
-          break;
-        }
-        const decl = statement.declaration;
-        if (decl === null) {
-          names += statement.specifiers.length;
-          break;
-        }
-        switch (decl.type) {
-          case import_utils37.AST_NODE_TYPES.FunctionDeclaration:
-            if (decl.id !== null) addCandidate(decl.id.name, statement);
-            else names += 1;
-            break;
-          case import_utils37.AST_NODE_TYPES.ClassDeclaration:
-            if (decl.id !== null) addCandidate(decl.id.name, statement);
-            else names += 1;
-            break;
-          case import_utils37.AST_NODE_TYPES.VariableDeclaration: {
-            const fnName = functionConstName(decl);
-            if (fnName !== null && decl.declarations.length === 1) {
-              addCandidate(fnName, statement);
-            } else {
-              names += decl.declarations.length;
-            }
-            break;
-          }
-          default:
-            names += 1;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return { names, hasReExport, candidate };
-};
-var single_public_export_default = import_utils37.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "single-public-export",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "A junk-drawer module stem (`utils`, `helpers`, `types`, ...) with a single public function/class/const export should be renamed after that export."
-    },
-    schema: [],
-    messages: {
-      renameJunkDrawer: "Module stem `{{stem}}` is a generic junk-drawer name; its sole public export is `{{name}}` \u2014 rename the file to `{{expected}}.ts` to describe its responsibility."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    const base = basename(context.filename);
-    if (base.endsWith(".d.ts")) return {};
-    if (TEST_FILE_RE.test(base)) return {};
-    if (isTestFile(context.filename)) return {};
-    const stem3 = stemOf(base);
-    if (!JUNK_DRAWER_STEMS.has(stem3.toLowerCase())) return {};
-    return {
-      Program(node) {
-        const { names, hasReExport, candidate } = summarizeExports(node.body);
-        if (hasReExport) return;
-        if (names !== 1 || candidate === null) return;
-        if (CONVENTIONAL_BUCKET_EXPORTS.has(candidate.name)) return;
-        const expected = kebabCase2(candidate.name);
-        if (stem3 === expected) return;
-        context.report({
-          node: candidate.node,
-          messageId: "renameJunkDrawer",
-          data: { stem: stem3, name: candidate.name, expected }
-        });
-      }
-    };
-  }
-});
-
 // src/rules/no-offset-pagination.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 
 // src/rules/_sql.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 function stripSqlNoise(text) {
   const out = [...text];
   const n = text.length;
@@ -5423,13 +4828,13 @@ function stripSqlNoise(text) {
 var SUBSTITUTION_MARKER = "?";
 function sqlTextOf(node) {
   switch (node.type) {
-    case import_utils38.AST_NODE_TYPES.Literal:
+    case import_utils32.AST_NODE_TYPES.Literal:
       return typeof node.value === "string" ? node.value : null;
-    case import_utils38.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils32.AST_NODE_TYPES.TemplateLiteral:
       return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join(SUBSTITUTION_MARKER);
-    case import_utils38.AST_NODE_TYPES.TaggedTemplateExpression:
+    case import_utils32.AST_NODE_TYPES.TaggedTemplateExpression:
       return sqlTextOf(node.quasi);
-    case import_utils38.AST_NODE_TYPES.BinaryExpression: {
+    case import_utils32.AST_NODE_TYPES.BinaryExpression: {
       if (node.operator !== "+") {
         return null;
       }
@@ -5437,7 +4842,7 @@ function sqlTextOf(node) {
       const right = sqlTextOf(node.right);
       return left !== null && right !== null ? left + right : null;
     }
-    case import_utils38.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils32.AST_NODE_TYPES.ArrayExpression: {
       const parts = [];
       for (const element of node.elements) {
         if (element === null) {
@@ -5457,7 +4862,7 @@ function sqlTextOf(node) {
 }
 function isJoinedFragmentArray(node) {
   const parent = node.parent;
-  return parent?.type === import_utils38.AST_NODE_TYPES.MemberExpression && parent.object === node && !parent.computed && parent.property.type === import_utils38.AST_NODE_TYPES.Identifier && parent.property.name === "join" && parent.parent?.type === import_utils38.AST_NODE_TYPES.CallExpression;
+  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;
 }
 function markConsumed(node, consumed) {
   consumed.add(node);
@@ -5507,7 +4912,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_utils39.ESLintUtils.RuleCreator(
+var no_offset_pagination_default = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-offset-pagination",
@@ -5536,15 +4941,15 @@ var no_offset_pagination_default = import_utils39.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-positional-tuple-return.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils34 = 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_utils40.AST_NODE_TYPES.TSTupleType) {
+  if (node.type === import_utils34.AST_NODE_TYPES.TSTupleType) {
     return node;
   }
-  if (node.type === import_utils40.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils40.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+  if (node.type === import_utils34.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params[0];
     return argument === void 0 ? null : tupleReturnType(argument);
   }
@@ -5558,30 +4963,30 @@ function isPermittedTuple(tuple, sourceCode) {
   if (elements.length < MIN_ELEMENTS) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils40.AST_NODE_TYPES.TSRestType)) {
+  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSRestType)) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils40.AST_NODE_TYPES.TSNamedTupleMember)) {
+  if (elements.some((element) => element.type === import_utils34.AST_NODE_TYPES.TSNamedTupleMember)) {
     return true;
   }
-  if (elements[0]?.type === import_utils40.AST_NODE_TYPES.TSLiteralType) {
+  if (elements[0]?.type === import_utils34.AST_NODE_TYPES.TSLiteralType) {
     return true;
   }
-  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils40.AST_NODE_TYPES.TSFunctionType)) {
+  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils34.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_utils40.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration) {
     return node.id?.name ?? null;
   }
   const parent = node.parent;
-  if (parent?.type === import_utils40.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils40.AST_NODE_TYPES.Identifier) {
+  if (parent?.type === import_utils34.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils34.AST_NODE_TYPES.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === import_utils40.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils40.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils40.AST_NODE_TYPES.Property) && parent.key.type === import_utils40.AST_NODE_TYPES.Identifier) {
+  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) {
     return parent.key.name;
   }
   return null;
@@ -5589,7 +4994,7 @@ function functionName(node) {
 function isInlineExported(node) {
   for (let current = node; current != null; current = current.parent) {
     const parent = current.parent;
-    if (parent?.type === import_utils40.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils40.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (parent?.type === import_utils34.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -5598,18 +5003,18 @@ function isInlineExported(node) {
 function moduleScopeBindingName(node) {
   let current = node;
   let child = node;
-  while (current.parent != null && current.parent.type !== import_utils40.AST_NODE_TYPES.Program) {
+  while (current.parent != null && current.parent.type !== import_utils34.AST_NODE_TYPES.Program) {
     child = current;
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils40.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils34.AST_NODE_TYPES.Program) {
     return null;
   }
-  if (current.type === import_utils40.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils40.AST_NODE_TYPES.ClassDeclaration) {
+  if (current.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils34.AST_NODE_TYPES.ClassDeclaration) {
     return current.id?.name ?? null;
   }
-  if (current.type === import_utils40.AST_NODE_TYPES.VariableDeclaration) {
-    if (child.type !== import_utils40.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils40.AST_NODE_TYPES.Identifier) {
+  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) {
       return null;
     }
     return child.id.name;
@@ -5619,19 +5024,19 @@ function moduleScopeBindingName(node) {
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils40.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === import_utils34.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_utils40.AST_NODE_TYPES.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === import_utils34.AST_NODE_TYPES.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === import_utils40.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils40.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils34.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils34.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === import_utils40.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils40.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils34.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils34.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -5647,7 +5052,7 @@ function isExported(node, specifierExports) {
   const binding = moduleScopeBindingName(node);
   return binding !== null && specifierExports.has(binding);
 }
-var no_positional_tuple_return_default = import_utils40.ESLintUtils.RuleCreator(
+var no_positional_tuple_return_default = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-positional-tuple-return",
@@ -5695,16 +5100,16 @@ var no_positional_tuple_return_default = import_utils40.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-repeated-string-literal.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils35 = 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_utils41.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils41.AST_NODE_TYPES.FunctionExpression,
-  import_utils41.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils35.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils35.AST_NODE_TYPES.FunctionExpression,
+  import_utils35.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -5726,9 +5131,9 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  return parent.type === import_utils41.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils41.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils41.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils41.AST_NODE_TYPES.TSImportType || parent.type === import_utils41.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils41.AST_NODE_TYPES.TSLiteralType;
+  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;
 }
-var no_repeated_string_literal_default = import_utils41.ESLintUtils.RuleCreator(
+var no_repeated_string_literal_default = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-repeated-string-literal",
@@ -5768,7 +5173,7 @@ var no_repeated_string_literal_default = import_utils41.ESLintUtils.RuleCreator(
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === import_utils41.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.parent.type === import_utils35.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -5802,7 +5207,7 @@ var no_repeated_string_literal_default = import_utils41.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-select-star.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils36 = 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;
@@ -5842,7 +5247,7 @@ function hasRealSelectStar(sql) {
   }
   return false;
 }
-var no_select_star_default = import_utils42.ESLintUtils.RuleCreator(
+var no_select_star_default = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-select-star",
@@ -5871,7 +5276,7 @@ var no_select_star_default = import_utils42.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-sleep-in-test-body.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS = /* @__PURE__ */ new Set([
   "it",
@@ -5880,34 +5285,34 @@ var TEST_CALLERS = /* @__PURE__ */ new Set([
   "afterEach"
 ]);
 var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
-  import_utils43.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils43.AST_NODE_TYPES.FunctionExpression,
-  import_utils43.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils37.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils37.AST_NODE_TYPES.FunctionExpression,
+  import_utils37.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === import_utils43.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === import_utils37.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === import_utils43.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils43.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  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]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== import_utils43.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== import_utils37.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== import_utils43.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils43.AST_NODE_TYPES.FunctionExpression) {
+  if (executor?.type !== import_utils37.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils37.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const body = executor.body;
-  if (body.type !== import_utils43.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils37.AST_NODE_TYPES.BlockStatement) {
     return isTimedSetTimeout(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === import_utils43.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+    (stmt) => stmt.type === import_utils37.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === import_utils43.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === import_utils37.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) {
@@ -5915,7 +5320,7 @@ function nearestEnclosingFunction(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils43.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils37.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -5923,29 +5328,29 @@ function nearestEnclosingFunction(node) {
   return null;
 }
 function testCallerName(callee) {
-  if (callee.type === import_utils43.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils43.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.MemberExpression) {
     return testCallerName(callee.object);
   }
-  if (callee.type === import_utils43.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.CallExpression) {
     return testCallerName(callee.callee);
   }
-  if (callee.type === import_utils43.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils37.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName(callee.tag);
   }
   return null;
 }
 function isTestBody(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils43.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils37.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_utils43.ESLintUtils.RuleCreator(
+var no_sleep_in_test_body_default = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-sleep-in-test-body",
@@ -5987,12 +5392,12 @@ var no_sleep_in_test_body_default = import_utils43.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-conditional-in-test.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 var TEST_CALLERS2 = /* @__PURE__ */ new Set(["it", "test"]);
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils44.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils44.AST_NODE_TYPES.FunctionExpression,
-  import_utils44.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils38.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils38.AST_NODE_TYPES.FunctionExpression,
+  import_utils38.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -6003,29 +5408,29 @@ function nearestEnclosingFunction2(node) {
   return null;
 }
 function testCallerName2(callee) {
-  if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils44.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === import_utils44.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === import_utils44.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils38.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils44.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 = testCallerName2(call.callee);
   return name !== null && TEST_CALLERS2.has(name);
 }
-var no_conditional_in_test_default = import_utils44.ESLintUtils.RuleCreator(
+var no_conditional_in_test_default = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-conditional-in-test",
@@ -6069,7 +5474,7 @@ var no_conditional_in_test_default = import_utils44.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils39 = 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)(_|$)/;
@@ -6082,36 +5487,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils45.AST_NODE_TYPES.Literal:
+    case import_utils39.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils45.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils45.AST_NODE_TYPES.Identifier:
+    case import_utils39.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case import_utils45.AST_NODE_TYPES.MemberExpression:
-      return !node.computed && node.property.type === import_utils45.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.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));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils45.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils39.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils45.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils39.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_utils45.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -6122,7 +5527,7 @@ function secretNameOf(node) {
   }
   return operandName(node);
 }
-var prefer_constant_time_secret_compare_default = import_utils45.ESLintUtils.RuleCreator(
+var prefer_constant_time_secret_compare_default = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-constant-time-secret-compare",
@@ -6165,11 +5570,11 @@ var prefer_constant_time_secret_compare_default = import_utils45.ESLintUtils.Rul
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils46 = require("@typescript-eslint/utils");
+var import_utils40 = 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_utils46.ESLintUtils.RuleCreator(
+var store_insert_requires_on_conflict_default = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "store-insert-requires-on-conflict",
@@ -6198,17 +5603,17 @@ var store_insert_requires_on_conflict_default = import_utils46.ESLintUtils.RuleC
 });
 
 // src/rules/no-dynamic-sql.ts
-var import_utils47 = require("@typescript-eslint/utils");
+var import_utils41 = 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_utils47.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.name);
   }
-  if (expression.type === import_utils47.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils47.AST_NODE_TYPES.Identifier) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.MemberExpression && !expression.computed && expression.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return CONSTANT_CASE_RE.test(expression.property.name);
   }
-  if (expression.type === import_utils47.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils41.AST_NODE_TYPES.Literal) {
     return typeof expression.value === "string";
   }
   return false;
@@ -6219,36 +5624,36 @@ function runtimeInterpolations(template) {
   );
 }
 function concatOperands(node) {
-  if (node.type === import_utils47.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return [...concatOperands(node.left), ...concatOperands(node.right)];
   }
   return [node];
 }
 function runtimeConcatOperands(node) {
-  if (node.type !== import_utils47.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
+  if (node.type !== import_utils41.AST_NODE_TYPES.BinaryExpression || node.operator !== "+") {
     return [];
   }
   const operands = concatOperands(node);
   const hasStringLiteral = operands.some(
-    (operand) => operand.type === import_utils47.AST_NODE_TYPES.Literal && typeof operand.value === "string"
+    (operand) => operand.type === import_utils41.AST_NODE_TYPES.Literal && typeof operand.value === "string"
   );
   if (!hasStringLiteral) {
     return [];
   }
   return operands.filter(
-    (operand) => operand.type !== import_utils47.AST_NODE_TYPES.Literal && !isStaticFragment(operand)
+    (operand) => operand.type !== import_utils41.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_utils47.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
     return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(RUNTIME_MARKER);
   }
-  if (node.type === import_utils47.AST_NODE_TYPES.Literal) {
+  if (node.type === import_utils41.AST_NODE_TYPES.Literal) {
     return typeof node.value === "string" ? node.value : RUNTIME_MARKER;
   }
-  if (node.type === import_utils47.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
+  if (node.type === import_utils41.AST_NODE_TYPES.BinaryExpression && node.operator === "+") {
     return staticStatementText(node.left) + staticStatementText(node.right);
   }
   return RUNTIME_MARKER;
@@ -6258,13 +5663,13 @@ function looksLikeSql(node) {
 }
 function statementMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils47.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils47.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils41.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
   return methods.has(name) ? name : null;
 }
-var no_dynamic_sql_default = import_utils47.ESLintUtils.RuleCreator(
+var no_dynamic_sql_default = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-dynamic-sql",
@@ -6303,7 +5708,7 @@ var no_dynamic_sql_default = import_utils47.ESLintUtils.RuleCreator(
         if (statement === void 0 || !looksLikeSql(statement)) {
           return;
         }
-        const offenders = statement.type === import_utils47.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
+        const offenders = statement.type === import_utils41.AST_NODE_TYPES.TemplateLiteral ? runtimeInterpolations(statement) : runtimeConcatOperands(statement);
         for (const offender of offenders) {
           context.report({
             node: offender,
@@ -6317,7 +5722,7 @@ var no_dynamic_sql_default = import_utils47.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils48 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -6381,7 +5786,7 @@ function compile(patterns) {
   }
   return compiled;
 }
-var no_raw_fetch_outside_clients_default = import_utils48.ESLintUtils.RuleCreator(
+var no_raw_fetch_outside_clients_default = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-raw-fetch-outside-clients",
@@ -6429,7 +5834,7 @@ var no_raw_fetch_outside_clients_default = import_utils48.ESLintUtils.RuleCreato
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils49 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -6448,7 +5853,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils49.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils43.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils43.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -6460,7 +5865,7 @@ function storageMethodName(node, methods) {
   }
   return name;
 }
-var no_storage_in_stateless_modules_default = import_utils49.ESLintUtils.RuleCreator(
+var no_storage_in_stateless_modules_default = import_utils43.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-storage-in-stateless-modules",
@@ -6518,7 +5923,7 @@ var no_storage_in_stateless_modules_default = import_utils49.ESLintUtils.RuleCre
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils50 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS2 = [
   /[\\/]generated[\\/]/,
@@ -6536,7 +5941,7 @@ function isZodModule2(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap3(node) {
-  if (node.type === import_utils50.AST_NODE_TYPES.TSAsExpression || node.type === import_utils50.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils44.AST_NODE_TYPES.TSAsExpression || node.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap3(node.expression);
   }
   return node;
@@ -6544,14 +5949,14 @@ function unwrap3(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils50.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils44.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_utils50.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils44.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -6567,7 +5972,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_utils50.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils44.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -6587,7 +5992,7 @@ function resolvesToImportedEnum(node, services) {
   }
   return (symbol.flags & ENUM_SYMBOL_FLAGS) !== 0;
 }
-var no_zod_native_enum_default = import_utils50.ESLintUtils.RuleCreator(
+var no_zod_native_enum_default = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-zod-native-enum",
@@ -6614,32 +6019,32 @@ var no_zod_native_enum_default = import_utils50.ESLintUtils.RuleCreator(
     }
     let services;
     try {
-      services = import_utils50.ESLintUtils.getParserServices(context);
+      services = import_utils44.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils50.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils50.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 callee.property.name === api;
       }
-      if (callee.type === import_utils50.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils50.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap3(arg);
-      if (inner.type !== import_utils50.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils44.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -6659,7 +6064,7 @@ var no_zod_native_enum_default = import_utils50.ESLintUtils.RuleCreator(
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils50.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils50.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils44.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -6678,7 +6083,7 @@ var no_zod_native_enum_default = import_utils50.ESLintUtils.RuleCreator(
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils44.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -6695,7 +6100,7 @@ var no_zod_native_enum_default = import_utils50.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils51 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS3 = [
@@ -6731,9 +6136,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  import_utils51.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils51.AST_NODE_TYPES.FunctionExpression,
-  import_utils51.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils45.AST_NODE_TYPES.FunctionExpression,
+  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile3(filename, sourceText) {
@@ -6746,13 +6151,13 @@ function isTestFile2(filename) {
   return TEST_FILE_PATTERNS.some((re) => re.test(filename));
 }
 function unwrap4(node) {
-  if (node.type === import_utils51.AST_NODE_TYPES.TSAsExpression || node.type === import_utils51.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils51.AST_NODE_TYPES.TSNonNullExpression) {
+  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) {
     return unwrap4(node.expression);
   }
   return node;
 }
 function isRegexLiteral(node) {
-  return node.type === import_utils51.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils45.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6760,29 +6165,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap4(node);
   switch (inner.type) {
-    case import_utils51.AST_NODE_TYPES.Literal: {
+    case import_utils45.AST_NODE_TYPES.Literal: {
       return true;
     }
-    case import_utils51.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils45.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils51.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils51.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    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_utils51.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils45.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils51.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils45.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils51.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils45.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils51.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils51.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils45.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6795,7 +6200,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap4(node);
-  if (inner.type === import_utils51.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils51.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils51.AST_NODE_TYPES.SpreadElement) {
+  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) {
     return unwrap4(inner.arguments[0]);
   }
   return inner;
@@ -6811,19 +6216,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils51.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils51.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils51.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils51.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils45.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils45.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_utils51.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap4(arg);
-    if (entries.type !== import_utils51.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils45.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -6852,10 +6257,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils51.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils51.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils51.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+  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) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -6869,43 +6274,43 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils51.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils51.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils51.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils51.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils51.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils51.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    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) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils51.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils51.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils51.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils51.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils51.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
 }
-var prefer_module_level_constant_default = import_utils51.ESLintUtils.RuleCreator(
+var prefer_module_level_constant_default = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-module-level-constant",
@@ -6957,7 +6362,7 @@ var prefer_module_level_constant_default = import_utils51.ESLintUtils.RuleCreato
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6969,10 +6374,10 @@ var prefer_module_level_constant_default = import_utils51.ESLintUtils.RuleCreato
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils51.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils45.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils51.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6999,7 +6404,7 @@ var prefer_module_level_constant_default = import_utils51.ESLintUtils.RuleCreato
 });
 
 // src/rules/jsdoc-restates-signature.ts
-var import_utils52 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var VALUE_TAGS = /* @__PURE__ */ new Set([
   "alpha",
   "author",
@@ -7082,30 +6487,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_utils52.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils52.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils46.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils46.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case import_utils52.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils52.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils46.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils46.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case import_utils52.AST_NODE_TYPES.ClassDeclaration:
-    case import_utils52.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils52.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils52.AST_NODE_TYPES.TSEnumDeclaration:
+    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:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case import_utils52.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils46.AST_NODE_TYPES.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== import_utils52.AST_NODE_TYPES.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== import_utils46.AST_NODE_TYPES.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === import_utils52.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils52.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils46.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case import_utils52.AST_NODE_TYPES.MethodDefinition:
-    case import_utils52.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils52.AST_NODE_TYPES.TSMethodSignature:
-    case import_utils52.AST_NODE_TYPES.TSPropertySignature: {
-      if (node.key.type !== import_utils52.AST_NODE_TYPES.Identifier) return null;
-      const params = node.type === import_utils52.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils52.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.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) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -7115,9 +6520,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === import_utils52.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
-    if (target.type === import_utils52.AST_NODE_TYPES.Identifier) names.push(target.name);
-    else if (target.type === import_utils52.AST_NODE_TYPES.TSParameterProperty) continue;
+    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;
   }
   return names;
 }
@@ -7126,7 +6531,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_utils52.ESLintUtils.RuleCreator(
+var jsdoc_restates_signature_default = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "jsdoc-restates-signature",
@@ -7162,7 +6567,7 @@ var jsdoc_restates_signature_default = import_utils52.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_utils52.AST_NODE_TYPES.Program) {
+          while (node != null && node.type !== import_utils46.AST_NODE_TYPES.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -7217,7 +6622,7 @@ var jsdoc_restates_signature_default = import_utils52.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-restated-comment.ts
-var import_utils53 = require("@typescript-eslint/utils");
+var import_utils47 = 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;
@@ -7241,7 +6646,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_utils53.ESLintUtils.RuleCreator(
+var no_restated_comment_default = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-restated-comment",
@@ -7269,7 +6674,7 @@ var no_restated_comment_default = import_utils53.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_utils53.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils47.AST_NODE_TYPES.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -7309,7 +6714,7 @@ var no_restated_comment_default = import_utils53.ESLintUtils.RuleCreator(
 });
 
 // src/rules/trailing-value-narration.ts
-var import_utils54 = require("@typescript-eslint/utils");
+var import_utils48 = 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([
@@ -7393,7 +6798,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_utils54.ESLintUtils.RuleCreator(
+var trailing_value_narration_default = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "trailing-value-narration",
@@ -7434,7 +6839,7 @@ var trailing_value_narration_default = import_utils54.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-tautological-expect.ts
-var import_utils55 = require("@typescript-eslint/utils");
+var import_utils49 = require("@typescript-eslint/utils");
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
   "toBeDefined",
@@ -7448,17 +6853,17 @@ var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
 function isLiteral(node) {
   switch (node.type) {
-    case import_utils55.AST_NODE_TYPES.Literal:
+    case import_utils49.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils55.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils49.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils55.AST_NODE_TYPES.UnaryExpression:
+    case import_utils49.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
-    case import_utils55.AST_NODE_TYPES.ArrayExpression:
+    case import_utils49.AST_NODE_TYPES.ArrayExpression:
       return node.elements.every((element) => element !== null && isLiteral(element));
-    case import_utils55.AST_NODE_TYPES.ObjectExpression:
+    case import_utils49.AST_NODE_TYPES.ObjectExpression:
       return node.properties.every(
-        (property) => property.type === import_utils55.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+        (property) => property.type === import_utils49.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
       );
     default:
       return false;
@@ -7466,12 +6871,12 @@ function isLiteral(node) {
 }
 function expectOperand(callee) {
   const receiver = callee.object;
-  if (receiver.type !== import_utils55.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils55.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+  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) {
     return null;
   }
   return receiver.arguments[0] ?? null;
 }
-var no_tautological_expect_default = import_utils55.ESLintUtils.RuleCreator(
+var no_tautological_expect_default = import_utils49.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-tautological-expect",
@@ -7498,10 +6903,10 @@ var no_tautological_expect_default = import_utils55.ESLintUtils.RuleCreator(
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        if (callee.type !== import_utils49.AST_NODE_TYPES.MemberExpression || callee.computed) {
           return;
         }
-        if (callee.property.type !== import_utils55.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils49.AST_NODE_TYPES.Identifier) {
           return;
         }
         const matcher = callee.property.name;
@@ -7535,26 +6940,26 @@ var no_tautological_expect_default = import_utils55.ESLintUtils.RuleCreator(
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils56 = require("@typescript-eslint/utils");
+var import_utils50 = 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_utils56.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils56.AST_NODE_TYPES.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === import_utils56.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils56.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+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 typeReferenceName = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils56.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils56.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils56.AST_NODE_TYPES.Identifier) return null;
+  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;
   const annotation = target.typeAnnotation?.typeAnnotation;
-  if (annotation === void 0 || annotation.type !== import_utils56.AST_NODE_TYPES.TSTypeReference) {
+  if (annotation === void 0 || annotation.type !== import_utils50.AST_NODE_TYPES.TSTypeReference) {
     return null;
   }
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils56.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils56.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils50.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils50.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { name: target.name, typeName: rightmost, display: qualifiedName(typeName) };
 };
@@ -7564,17 +6969,17 @@ var readConstructor = (ctor) => {
   let constructedFields = 0;
   if (body !== null && body !== void 0) {
     for (const statement of body.body) {
-      if (statement.type !== import_utils56.AST_NODE_TYPES.ExpressionStatement) continue;
+      if (statement.type !== import_utils50.AST_NODE_TYPES.ExpressionStatement) continue;
       const expression = statement.expression;
-      if (expression.type !== import_utils56.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils56.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils56.AST_NODE_TYPES.ThisExpression) {
+      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) {
         continue;
       }
       const source = expression.right;
-      if (source.type === import_utils56.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils50.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils56.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils50.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === import_utils56.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils56.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils50.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils50.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -7583,7 +6988,7 @@ var readConstructor = (ctor) => {
   for (const parameter of ctor.value.params) {
     const reference = typeReferenceName(parameter);
     if (reference === null) continue;
-    const stored = parameter.type === import_utils56.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
+    const stored = parameter.type === import_utils50.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;
@@ -7613,19 +7018,19 @@ var subtreeHas = (root, found) => {
   return hit;
 };
 var isFrameworkWiring = (body) => subtreeHas(body, (node) => {
-  if (node.type === import_utils56.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils50.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils56.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    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;
   }
-  return node.type === import_utils56.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils56.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.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);
 });
 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_utils56.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils56.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    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);
   }
   return names;
 };
@@ -7643,16 +7048,16 @@ var isTransportWrapper = (className, collaborators, program) => {
 var publicMethodNames = (body) => {
   const names = [];
   for (const member of body.body) {
-    if (member.type !== import_utils56.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils50.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_utils56.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils56.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    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);
     else names.push("\u2026");
   }
   return names;
 };
-var require_interface_for_injected_service_default = import_utils56.ESLintUtils.RuleCreator(
+var require_interface_for_injected_service_default = import_utils50.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "require-interface-for-injected-service",
@@ -7680,7 +7085,7 @@ var require_interface_for_injected_service_default = import_utils56.ESLintUtils.
         if (node.implements.length > 0) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils56.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils50.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(ctor);
@@ -7705,26 +7110,26 @@ var require_interface_for_injected_service_default = import_utils56.ESLintUtils.
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils57 = require("@typescript-eslint/utils");
+var import_utils51 = require("@typescript-eslint/utils");
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === import_utils57.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils57.AST_NODE_TYPES.Literal) return String(key.value);
+  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);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === import_utils57.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils57.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils57.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  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);
 }
 function isNullishType(node) {
-  return node.type === import_utils57.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils57.AST_NODE_TYPES.TSUndefinedKeyword;
+  return node.type === import_utils51.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils51.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_utils57.ESLintUtils.RuleCreator(
+var prefer_non_nullable_collection_default = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/tree/main/packages/typescript#${name}`
 )({
   name: "prefer-non-nullable-collection",
@@ -7747,7 +7152,7 @@ var prefer_non_nullable_collection_default = import_utils57.ESLintUtils.RuleCrea
     function checkOptionalProperty(node) {
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== import_utils57.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== import_utils51.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -7760,7 +7165,7 @@ var prefer_non_nullable_collection_default = import_utils57.ESLintUtils.RuleCrea
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils57.AST_NODE_TYPES.TSUnionType) return;
+        if (node.typeAnnotation.type !== import_utils51.AST_NODE_TYPES.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -7772,126 +7177,8 @@ var prefer_non_nullable_collection_default = import_utils57.ESLintUtils.RuleCrea
   }
 });
 
-// src/rules/primary-export-file-name.ts
-var import_utils58 = require("@typescript-eslint/utils");
-var CONVENTIONAL_BUCKET_EXPORTS2 = /* @__PURE__ */ new Set(["cn"]);
-var GENERIC_ENTRYPOINTS = /* @__PURE__ */ new Set(["main", "run", "cli", "setup", "teardown", "execute"]);
-var ACRONYM_OVERRIDES2 = [
-  [/OAuth/g, "Oauth"],
-  [/GraphQL/g, "Graphql"],
-  [/gRPC/g, "Grpc"]
-];
-var CAMEL_BOUNDARY_RE2 = /(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
-var basename2 = (filename) => filename.split(/[/\\]/).pop() ?? filename;
-var stemOf2 = (base) => base.replace(/\.(test|spec|config|d|stories)\.[cm]?[jt]sx?$/i, "").replace(/\.[cm]?[jt]sx?$/i, "");
-var kebabCase3 = (name) => {
-  let normalized = name;
-  for (const [pattern, replacement] of ACRONYM_OVERRIDES2) {
-    normalized = normalized.replace(pattern, replacement);
-  }
-  return normalized.replace(CAMEL_BOUNDARY_RE2, "-").toLowerCase();
-};
-var isFunctionOrClass = (node) => node.type === import_utils58.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils58.AST_NODE_TYPES.FunctionExpression;
-var findPrimaryExport = (body) => {
-  let exportCount = 0;
-  let primaryCandidate = null;
-  for (const statement of body) {
-    if (statement.type === import_utils58.AST_NODE_TYPES.ExportAllDeclaration) {
-      return null;
-    }
-    if (statement.type === import_utils58.AST_NODE_TYPES.ExportDefaultDeclaration) {
-      exportCount += 1;
-      const decl = statement.declaration;
-      if ((decl.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration || decl.type === import_utils58.AST_NODE_TYPES.ClassDeclaration) && decl.id !== null) {
-        primaryCandidate = { name: decl.id.name, node: statement, isDefault: true };
-      } else if (decl.type === import_utils58.AST_NODE_TYPES.Identifier) {
-        primaryCandidate = { name: decl.name, node: statement, isDefault: true };
-      }
-    } else if (statement.type === import_utils58.AST_NODE_TYPES.ExportNamedDeclaration) {
-      if (statement.source !== null) {
-        return null;
-      }
-      const decl = statement.declaration;
-      if (decl === null) {
-        exportCount += statement.specifiers.length;
-        if (statement.specifiers.length === 1 && primaryCandidate === null) {
-          const spec = statement.specifiers[0];
-          if (spec && spec.exported.type === import_utils58.AST_NODE_TYPES.Identifier) {
-            primaryCandidate = { name: spec.exported.name, node: statement, isDefault: false };
-          }
-        }
-      } else if (decl.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration || decl.type === import_utils58.AST_NODE_TYPES.ClassDeclaration) {
-        if (decl.id !== null) {
-          exportCount += 1;
-          if (primaryCandidate === null) {
-            primaryCandidate = { name: decl.id.name, node: statement, isDefault: false };
-          }
-        }
-      } else if (decl.type === import_utils58.AST_NODE_TYPES.VariableDeclaration) {
-        for (const declarator of decl.declarations) {
-          if (declarator.id.type === import_utils58.AST_NODE_TYPES.Identifier) {
-            exportCount += 1;
-            if (primaryCandidate === null && declarator.init && isFunctionOrClass(declarator.init)) {
-              primaryCandidate = { name: declarator.id.name, node: statement, isDefault: false };
-            }
-          }
-        }
-      } else if (decl.type === import_utils58.AST_NODE_TYPES.TSTypeAliasDeclaration || decl.type === import_utils58.AST_NODE_TYPES.TSInterfaceDeclaration) {
-        exportCount += 1;
-        if (primaryCandidate === null) {
-          primaryCandidate = { name: decl.id.name, node: statement, isDefault: false };
-        }
-      }
-    }
-  }
-  if (primaryCandidate === null || exportCount > 2) {
-    return null;
-  }
-  return { ...primaryCandidate, count: exportCount };
-};
-var primary_export_file_name_default = import_utils58.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
-)({
-  name: "primary-export-file-name",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce semantic naming alignment: a file with a single primary export must be named after that export."
-    },
-    schema: [],
-    messages: {
-      primaryExportMismatch: "Module stem '{{stem}}' does not match its primary export '{{name}}' \u2014 rename the file to '{{expected}}{{ext}}' to describe its responsibility."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    const base = basename2(context.filename);
-    if (base.endsWith(".d.ts") || base.startsWith("index.") || base.startsWith("_")) return {};
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
-    const stem3 = stemOf2(base);
-    if (stem3 === "page" || stem3 === "layout" || stem3 === "loading" || stem3 === "error" || stem3 === "not-found" || stem3 === "route" || stem3 === "__root" || stem3 === "config" || stem3 === "constants" || stem3 === "types" || stem3.startsWith("$") || stem3.startsWith("[")) {
-      return {};
-    }
-    return {
-      Program(node) {
-        const primary = findPrimaryExport(node.body);
-        if (primary === null) return;
-        if (CONVENTIONAL_BUCKET_EXPORTS2.has(primary.name) || GENERIC_ENTRYPOINTS.has(primary.name)) return;
-        const expectedStem = kebabCase3(primary.name);
-        if (stem3 === expectedStem) return;
-        const ext = base.endsWith(".tsx") ? ".tsx" : ".ts";
-        context.report({
-          node: primary.node,
-          messageId: "primaryExportMismatch",
-          data: { stem: stem3, name: primary.name, expected: expectedStem, ext }
-        });
-      }
-    };
-  }
-});
-
 // src/rules/no-implicit-attribute-access.ts
-var import_utils59 = require("@typescript-eslint/utils");
+var import_utils52 = require("@typescript-eslint/utils");
 var EXCLUDED_BASES = /* @__PURE__ */ new Set([
   "environ",
   "headers",
@@ -7907,15 +7194,15 @@ var EXCLUDED_BASES = /* @__PURE__ */ new Set([
   "sessionStorage"
 ]);
 function getBaseName(node) {
-  if (node.type === import_utils59.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils52.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils59.AST_NODE_TYPES.MemberExpression && node.property.type === import_utils59.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils52.AST_NODE_TYPES.MemberExpression && node.property.type === import_utils52.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
-var no_implicit_attribute_access_default = import_utils59.ESLintUtils.RuleCreator(
+var no_implicit_attribute_access_default = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-implicit-attribute-access",
@@ -7936,7 +7223,7 @@ var no_implicit_attribute_access_default = import_utils59.ESLintUtils.RuleCreato
         if (!node.computed) {
           return;
         }
-        if (node.property.type === import_utils59.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+        if (node.property.type === import_utils52.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
           const baseName = getBaseName(node.object);
           if (!baseName || !EXCLUDED_BASES.has(baseName)) {
             context.report({
@@ -7949,11 +7236,11 @@ var no_implicit_attribute_access_default = import_utils59.ESLintUtils.RuleCreato
       },
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type === import_utils59.AST_NODE_TYPES.MemberExpression) {
-          const method = callee.property.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+        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 (method === "get") {
             const arg = node.arguments[0];
-            if (arg && arg.type === import_utils59.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
+            if (arg && arg.type === import_utils52.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
               const baseName = getBaseName(callee.object);
               if (!baseName || !EXCLUDED_BASES.has(baseName)) {
                 context.report({
@@ -7971,8 +7258,8 @@ var no_implicit_attribute_access_default = import_utils59.ESLintUtils.RuleCreato
 });
 
 // src/rules/strict-test-assertions.ts
-var import_utils60 = require("@typescript-eslint/utils");
-var strict_test_assertions_default = import_utils60.ESLintUtils.RuleCreator.withoutDocs({
+var import_utils53 = require("@typescript-eslint/utils");
+var strict_test_assertions_default = import_utils53.ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "suggestion",
     docs: {
@@ -7990,9 +7277,9 @@ var strict_test_assertions_default = import_utils60.ESLintUtils.RuleCreator.with
       let currentObject = null;
       let sequence = [];
       function getExpectObject(expr) {
-        if (expr.type === import_utils60.AST_NODE_TYPES.CallExpression && expr.callee.type === import_utils60.AST_NODE_TYPES.MemberExpression && expr.callee.object.type === import_utils60.AST_NODE_TYPES.CallExpression && expr.callee.object.callee.type === import_utils60.AST_NODE_TYPES.Identifier && expr.callee.object.callee.name === "expect" && expr.callee.object.arguments.length === 1) {
+        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) {
           const arg = expr.callee.object.arguments.at(0);
-          if (arg?.type === import_utils60.AST_NODE_TYPES.MemberExpression) {
+          if (arg?.type === import_utils53.AST_NODE_TYPES.MemberExpression) {
             return arg.object;
           }
         }
@@ -8008,12 +7295,12 @@ var strict_test_assertions_default = import_utils60.ESLintUtils.RuleCreator.with
               if (!currentObject) return null;
               const objectText = context.sourceCode.getText(currentObject);
               const props = sequence.map((stmt) => {
-                if (stmt.expression.type !== import_utils60.AST_NODE_TYPES.CallExpression || stmt.expression.callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || stmt.expression.callee.object.type !== import_utils60.AST_NODE_TYPES.CallExpression) {
+                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) {
                   return null;
                 }
                 const actual = stmt.expression.callee.object.arguments.at(0);
                 const expected = stmt.expression.arguments.at(0);
-                if (actual?.type === import_utils60.AST_NODE_TYPES.MemberExpression && actual.property.type === import_utils60.AST_NODE_TYPES.Identifier && expected) {
+                if (actual?.type === import_utils53.AST_NODE_TYPES.MemberExpression && actual.property.type === import_utils53.AST_NODE_TYPES.Identifier && expected) {
                   const propName2 = actual.property.name;
                   const valText = context.sourceCode.getText(expected);
                   return `${propName2}: ${valText}`;
@@ -8031,7 +7318,7 @@ var strict_test_assertions_default = import_utils60.ESLintUtils.RuleCreator.with
         }
       }
       for (const statement of body) {
-        if (statement.type === import_utils60.AST_NODE_TYPES.ExpressionStatement) {
+        if (statement.type === import_utils53.AST_NODE_TYPES.ExpressionStatement) {
           const obj = getExpectObject(statement.expression);
           if (obj && currentObject && context.sourceCode.getText(obj) === context.sourceCode.getText(currentObject)) {
             sequence.push(statement);
@@ -8065,8 +7352,8 @@ var strict_test_assertions_default = import_utils60.ESLintUtils.RuleCreator.with
 });
 
 // src/rules/no-async-callback-in-waitfor.ts
-var import_utils61 = require("@typescript-eslint/utils");
-var no_async_callback_in_waitfor_default = import_utils61.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var no_async_callback_in_waitfor_default = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-async-callback-in-waitfor",
@@ -8087,9 +7374,9 @@ var no_async_callback_in_waitfor_default = import_utils61.ESLintUtils.RuleCreato
     }
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils61.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
+        if (node.callee.type === import_utils54.AST_NODE_TYPES.Identifier && node.callee.name === "waitFor") {
           const callback = node.arguments[0];
-          if (callback && (callback.type === import_utils61.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils61.AST_NODE_TYPES.FunctionExpression) && callback.async) {
+          if (callback && (callback.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils54.AST_NODE_TYPES.FunctionExpression) && callback.async) {
             context.report({
               node: callback,
               messageId: "noAsyncCallbackInWaitFor"
@@ -8102,8 +7389,8 @@ var no_async_callback_in_waitfor_default = import_utils61.ESLintUtils.RuleCreato
 });
 
 // src/rules/prefer-setup-file-mocks.ts
-var import_utils62 = require("@typescript-eslint/utils");
-var prefer_setup_file_mocks_default = import_utils62.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var prefer_setup_file_mocks_default = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-setup-file-mocks",
@@ -8124,7 +7411,7 @@ var prefer_setup_file_mocks_default = import_utils62.ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils62.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils62.AST_NODE_TYPES.Identifier && (node.callee.object.name === "vi" || node.callee.object.name === "jest") && node.callee.property.type === import_utils62.AST_NODE_TYPES.Identifier && node.callee.property.name === "mock") {
+        if (node.callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && (node.callee.object.name === "vi" || node.callee.object.name === "jest") && node.callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && node.callee.property.name === "mock") {
           context.report({
             node,
             messageId: "preferSetupFileMocks"
@@ -8147,29 +7434,23 @@ var rules = {
   "no-log-only-catch": no_log_only_catch_default,
   "no-raw-env": no_raw_env_default,
   "no-sentinel-return-on-catch": no_sentinel_return_on_catch_default,
-  "no-sequential-await": no_sequential_await_default,
   "no-string-concat-in-loop": no_string_concat_in_loop_default,
   "no-unnecessary-use-client": no_unnecessary_use_client_default,
   "prefer-discriminated-union": prefer_discriminated_union_default,
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
   "prefer-semantic-colors": prefer_semantic_colors_default,
   "prefer-server-actions": prefer_server_actions_default,
-  "prefer-shadcn": prefer_shadcn_default,
   "require-assert-never": require_assert_never_default,
   "require-zod-form-validation": require_zod_form_validation_default,
   "zod-naming-convention": zod_naming_convention_default,
   "no-cors-wildcard-with-credentials": no_cors_wildcard_with_credentials_default,
   "no-fat-try-blocks": no_fat_try_blocks_default,
   "no-secret-in-log": no_secret_in_log_default,
-  "no-unsafe-cast": no_unsafe_cast_default,
   "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,
-  "single-public-export": single_public_export_default,
-  "primary-export-file-name": primary_export_file_name_default,
   "no-silent-promise-catch": no_silent_promise_catch_default,
   "require-fetch-timeout": require_fetch_timeout_default,
-  "require-schema-validate-search": require_schema_validate_search_default,
   "no-offset-pagination": no_offset_pagination_default,
   "no-positional-tuple-return": no_positional_tuple_return_default,
   "no-repeated-string-literal": no_repeated_string_literal_default,
@@ -8197,7 +7478,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.17.0"
+    version: "4.0.0"
   },
   rules,
   configs: {
@@ -8214,7 +7495,6 @@ var plugin = {
         "@sarj/no-unnecessary-use-client": "warn",
         "@sarj/prefer-schema-for-api-payload": "warn",
         // Distilled from sarj-audit skills — warn in recommended, error in strict.
-        "@sarj/no-sequential-await": "warn",
         "@sarj/no-sentinel-return-on-catch": "warn",
         "@sarj/no-log-only-catch": "warn",
         "@sarj/no-insecure-random-id": "warn",
@@ -8231,16 +7511,12 @@ var plugin = {
         "@sarj/no-fat-try-blocks": "warn",
         "@sarj/no-cors-wildcard-with-credentials": "warn",
         "@sarj/no-secret-in-log": "warn",
-        "@sarj/no-unsafe-cast": "warn",
         "@sarj/no-unsafe-mock-casting": "warn",
-        "@sarj/single-public-export": "warn",
-        "@sarj/primary-export-file-name": "warn",
         "@sarj/prefer-string-literal-union": "warn",
         "@sarj/prefer-zod-enum": "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",
-        "@sarj/require-schema-validate-search": "warn",
         // Second SARJ port wave — the TS/Python parity gap. Each targets a
         // defect class seen in production Workers code: timing-leaky secret
         // compares, non-idempotent store writes under queue redelivery,
@@ -8301,14 +7577,12 @@ var plugin = {
         "@sarj/ban-loose-type-guards-in-tests": "error",
         "@sarj/enforce-file-structure": "error",
         "@sarj/no-raw-env": "error",
-        "@sarj/prefer-shadcn": "error",
         "@sarj/no-enum": "error",
         "@sarj/no-client-side-data-fetching": "error",
         "@sarj/prefer-server-actions": "error",
         "@sarj/no-unnecessary-use-client": "error",
         "@sarj/prefer-schema-for-api-payload": "error",
         // Distilled from sarj-audit skills.
-        "@sarj/no-sequential-await": "error",
         "@sarj/no-sentinel-return-on-catch": "error",
         "@sarj/no-log-only-catch": "error",
         "@sarj/no-insecure-random-id": "error",
@@ -8326,17 +7600,13 @@ var plugin = {
         "@sarj/no-fat-try-blocks": "error",
         "@sarj/no-cors-wildcard-with-credentials": "error",
         "@sarj/no-secret-in-log": "error",
-        "@sarj/no-unsafe-cast": "error",
         "@sarj/no-unsafe-mock-casting": "error",
-        "@sarj/single-public-export": "error",
-        "@sarj/primary-export-file-name": "error",
         // Promoted to error 2026-07-25 — strict means strict (user directive).
         "@sarj/prefer-string-literal-union": "error",
         "@sarj/prefer-zod-enum": "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",
-        "@sarj/require-schema-validate-search": "error",
         // Second SARJ port wave — the TS/Python parity gap.
         "@sarj/prefer-constant-time-secret-compare": "error",
         "@sarj/store-insert-requires-on-conflict": "error",