@noctcore/eslint-plugin-contracts 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -45,13 +45,16 @@ var recommended = {
   "noctcore-contracts/money-must-be-decimal": "error",
   "noctcore-contracts/require-error-cause": "error",
   "noctcore-contracts/restrict-throw-to-taxonomy": "error",
-  // Config-required / heuristic rules ship inert. `require-registered-keys` and
-  // `env-var-schema-parity` do nothing until their `sinks` / `schema` options are
-  // set; `require-schema-parse-at-boundary` is a conservative syntactic slice of a
+  "noctcore-contracts/schema-enum-field-consistency": "error",
+  "noctcore-contracts/fetch-must-check-ok": "error",
+  // Config-required / heuristic rules ship inert. `require-registered-keys`,
+  // `env-var-schema-parity` and `translation-key-exists` do nothing until their
+  // `sinks` / `schema` / `catalogs` options are set; `require-schema-parse-at-boundary` is a conservative syntactic slice of a
   // type-aware concern. Enable them explicitly once configured for your project.
   "noctcore-contracts/require-registered-keys": "off",
   "noctcore-contracts/env-var-schema-parity": "off",
-  "noctcore-contracts/require-schema-parse-at-boundary": "off"
+  "noctcore-contracts/require-schema-parse-at-boundary": "off",
+  "noctcore-contracts/translation-key-exists": "off"
 };
 
 // src/rules/env-var-schema-parity.ts
@@ -151,9 +154,476 @@ var envVarSchemaParityRule = createRule({
   }
 });
 
-// src/rules/money-must-be-decimal.ts
+// src/rules/fetch-must-check-ok.ts
 var import_utils2 = require("@typescript-eslint/utils");
-var RULE_NAME2 = "money-must-be-decimal";
+var RULE_NAME2 = "fetch-must-check-ok";
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    fetchFunctions: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true
+    }
+  }
+};
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function walkSome(root, keys, predicate) {
+  const stack = [root];
+  for (let node = stack.pop(); node !== void 0; node = stack.pop()) {
+    if (predicate(node)) {
+      return true;
+    }
+    for (const key of keys[node.type] ?? []) {
+      const value = Reflect.get(node, key);
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (isNode(child)) {
+            stack.push(child);
+          }
+        }
+      } else if (isNode(value)) {
+        stack.push(value);
+      }
+    }
+  }
+  return false;
+}
+function calleePath(node) {
+  if (node.type === import_utils2.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === import_utils2.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils2.AST_NODE_TYPES.Identifier) {
+    const object = calleePath(node.object);
+    return object === null ? null : `${object}.${node.property.name}`;
+  }
+  return null;
+}
+var OK_PROP = "ok";
+var OK_PROPS = /* @__PURE__ */ new Set([OK_PROP, "status"]);
+var ASSERTION_NAMES = /^(?:[Aa]ssert|[Ii]nvariant|[Ee]nsure|[Ee]xpect)(?:[A-Z_]\w*)?$/u;
+var COMPARISONS = /* @__PURE__ */ new Set(["===", "!==", "==", "!=", "<", "<=", ">", ">="]);
+var FIRST_ERROR_STATUS = 400;
+function literalValue(node) {
+  if (node.type !== import_utils2.AST_NODE_TYPES.Literal) {
+    return void 0;
+  }
+  return typeof node.value === "number" || typeof node.value === "boolean" ? node.value : void 0;
+}
+function mirror(operator) {
+  switch (operator) {
+    case "<":
+      return ">";
+    case "<=":
+      return ">=";
+    case ">":
+      return "<";
+    case ">=":
+      return "<=";
+    default:
+      return operator;
+  }
+}
+function booleanPolarity(operator, value) {
+  if (operator === "===" || operator === "==") {
+    return value ? "positive" : "negative";
+  }
+  if (operator === "!==" || operator === "!=") {
+    return value ? "negative" : "positive";
+  }
+  return "opaque";
+}
+function statusPolarity(operator, value) {
+  const isSuccessCode = value >= 200 && value < 300;
+  switch (operator) {
+    case "===":
+    case "==":
+      return isSuccessCode ? "positive" : "opaque";
+    case "!==":
+    case "!=":
+      return isSuccessCode ? "negative" : "opaque";
+    case "<":
+      return value <= FIRST_ERROR_STATUS ? "positive" : "opaque";
+    case "<=":
+      return value < FIRST_ERROR_STATUS ? "positive" : "opaque";
+    // A failure test is only useful for what it says about the OTHER side, so
+    // what matters is that everything below the threshold is a success:
+    // `>= 300` and `>= 400` both leave only good responses behind, while
+    // `>= 500` leaves every 4xx there.
+    case ">=":
+      return value <= FIRST_ERROR_STATUS ? "negative" : "opaque";
+    case ">":
+      return value < FIRST_ERROR_STATUS ? "negative" : "opaque";
+    default:
+      return "opaque";
+  }
+}
+function comparisonPolarity(node, readIsLeft) {
+  const value = literalValue(readIsLeft ? node.right : node.left);
+  const operator = readIsLeft ? node.operator : mirror(node.operator);
+  if (typeof value === "boolean") {
+    return booleanPolarity(operator, value);
+  }
+  return typeof value === "number" ? statusPolarity(operator, value) : "opaque";
+}
+function propReadOn(node, objectName, props) {
+  if (node.type !== import_utils2.AST_NODE_TYPES.MemberExpression || node.computed) {
+    return false;
+  }
+  if (node.object.type !== import_utils2.AST_NODE_TYPES.Identifier || node.object.name !== objectName || node.property.type !== import_utils2.AST_NODE_TYPES.Identifier) {
+    return false;
+  }
+  const name = node.property.name;
+  return typeof props === "string" ? name === props : props.has(name);
+}
+function findJsonReads(root, keys, name) {
+  const reads = [];
+  walkSome(root, keys, (node) => {
+    if (propReadOn(node, name, "json")) {
+      reads.push(node);
+    }
+    return false;
+  });
+  return reads;
+}
+function isAssertionName(node) {
+  return node.type === import_utils2.AST_NODE_TYPES.Identifier && ASSERTION_NAMES.test(node.name);
+}
+function isAssertionCallee(callee) {
+  if (callee.type === import_utils2.AST_NODE_TYPES.Identifier) {
+    return isAssertionName(callee);
+  }
+  return callee.type === import_utils2.AST_NODE_TYPES.MemberExpression && !callee.computed && (isAssertionName(callee.object) || isAssertionName(callee.property));
+}
+var TERMINAL_TYPES = /* @__PURE__ */ new Set([
+  import_utils2.AST_NODE_TYPES.IfStatement,
+  import_utils2.AST_NODE_TYPES.WhileStatement,
+  import_utils2.AST_NODE_TYPES.DoWhileStatement,
+  import_utils2.AST_NODE_TYPES.ConditionalExpression,
+  import_utils2.AST_NODE_TYPES.SwitchStatement,
+  import_utils2.AST_NODE_TYPES.CallExpression
+]);
+var ASSERTION_OPERATORS = /* @__PURE__ */ new Map([
+  ["equal", "==="],
+  ["equals", "==="],
+  ["strictEqual", "==="],
+  ["deepEqual", "==="],
+  ["deepStrictEqual", "==="],
+  ["toBe", "==="],
+  ["toEqual", "==="],
+  ["notEqual", "!=="],
+  ["notStrictEqual", "!=="],
+  ["notDeepEqual", "!=="]
+]);
+function assertionOperator(callee) {
+  return callee.type === import_utils2.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils2.AST_NODE_TYPES.Identifier ? ASSERTION_OPERATORS.get(callee.property.name) : void 0;
+}
+function assertionCheck(parent, child, check) {
+  if (check.compared) {
+    return check;
+  }
+  const operator = assertionOperator(parent.callee);
+  if (operator === void 0) {
+    return check;
+  }
+  const other = parent.arguments.find((arg) => arg !== child);
+  const value = other === void 0 ? void 0 : literalValue(other);
+  if (typeof value === "boolean") {
+    return {
+      ...check,
+      compared: true,
+      polarity: booleanPolarity(operator, value)
+    };
+  }
+  return typeof value === "number" ? { ...check, compared: true, polarity: statusPolarity(operator, value) } : check;
+}
+function terminalCheck(parent, child, state) {
+  const check = { owner: parent, ...state };
+  switch (parent.type) {
+    case import_utils2.AST_NODE_TYPES.IfStatement:
+    case import_utils2.AST_NODE_TYPES.WhileStatement:
+    case import_utils2.AST_NODE_TYPES.DoWhileStatement:
+    case import_utils2.AST_NODE_TYPES.ConditionalExpression:
+      return parent.test === child ? check : null;
+    case import_utils2.AST_NODE_TYPES.SwitchStatement:
+      return parent.discriminant === child ? { ...check, compared: true, polarity: "opaque" } : null;
+    // An assertion settles a status only when it COMPARES it.
+    // `assert.equal(res.status, 200)` does; `assert.ok(res.status)` asserts a
+    // number is truthy, which every response that arrived satisfies. Arity
+    // cannot tell them apart (`assert.ok(res.status, 'message')` also has two
+    // arguments), so the comparison is read from the assertion's own name.
+    case import_utils2.AST_NODE_TYPES.CallExpression:
+      return isAssertionCallee(parent.callee) && parent.callee !== child ? assertionCheck(parent, child, check) : null;
+    default:
+      return null;
+  }
+}
+function combinatorStep(parent, child, state, parse) {
+  switch (parent.type) {
+    case import_utils2.AST_NODE_TYPES.UnaryExpression:
+      if (parent.operator === "typeof") {
+        return "stop";
+      }
+      if (parent.operator === "!") {
+        state.polarity = state.polarity === "positive" ? "negative" : "positive";
+      }
+      return "continue";
+    case import_utils2.AST_NODE_TYPES.BinaryExpression: {
+      if (!COMPARISONS.has(parent.operator)) {
+        return "stop";
+      }
+      const polarity = comparisonPolarity(parent, parent.left === child);
+      state.compared = true;
+      state.polarity = polarity;
+      return polarity === "opaque" ? "stop" : "continue";
+    }
+    case import_utils2.AST_NODE_TYPES.LogicalExpression:
+      if (parent.operator === "&&") {
+        state.underAnd = true;
+      }
+      if (parent.operator === "||") {
+        state.underOr = true;
+      }
+      return parent.left === child && contains(parent.right, parse) ? { owner: parent, ...state } : "continue";
+    case import_utils2.AST_NODE_TYPES.ChainExpression:
+    case import_utils2.AST_NODE_TYPES.TSNonNullExpression:
+      return "continue";
+    default:
+      return "stop";
+  }
+}
+function climb(read, parse) {
+  const state = {
+    polarity: "positive",
+    compared: false,
+    underAnd: false,
+    underOr: false
+  };
+  let child = read;
+  let parent = read.parent;
+  while (parent !== void 0) {
+    if (TERMINAL_TYPES.has(parent.type)) {
+      return terminalCheck(parent, child, state);
+    }
+    const step = combinatorStep(parent, child, state, parse);
+    if (step === "stop") {
+      return null;
+    }
+    if (step !== "continue") {
+      return step;
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return null;
+}
+function contains(outer, inner) {
+  return outer.range[0] <= inner.range[0] && outer.range[1] >= inner.range[1];
+}
+function alwaysExits(node) {
+  if (node.type === import_utils2.AST_NODE_TYPES.ReturnStatement || node.type === import_utils2.AST_NODE_TYPES.ThrowStatement) {
+    return true;
+  }
+  return node.type === import_utils2.AST_NODE_TYPES.BlockStatement && node.body.some((stmt) => alwaysExits(stmt));
+}
+function scopeOfCheck(node) {
+  let current = node;
+  while (current.parent !== void 0 && !current.type.endsWith("Statement")) {
+    current = current.parent;
+  }
+  return current.parent ?? current;
+}
+function isSuccessCase(arm) {
+  if (arm.test === null) {
+    return false;
+  }
+  const value = literalValue(arm.test);
+  return typeof value === "number" && value >= 200 && value < 300;
+}
+function switchArmProtects(owner, parse) {
+  const index = owner.cases.findIndex((arm) => contains(arm, parse));
+  const own = owner.cases[index];
+  if (own === void 0 || !isSuccessCase(own)) {
+    return false;
+  }
+  for (let i = index - 1; i >= 0; i -= 1) {
+    const arm = owner.cases[i];
+    if (arm === void 0 || arm.consequent.length > 0) {
+      break;
+    }
+    if (!isSuccessCase(arm)) {
+      return false;
+    }
+  }
+  return true;
+}
+function branchProtects(check, parse) {
+  const { owner } = check;
+  if (owner.type === import_utils2.AST_NODE_TYPES.SwitchStatement) {
+    return switchArmProtects(owner, parse);
+  }
+  if (owner.type === import_utils2.AST_NODE_TYPES.LogicalExpression) {
+    if (!contains(owner.right, parse)) {
+      return false;
+    }
+    if (owner.operator === "&&") {
+      return check.polarity === "positive";
+    }
+    return owner.operator === "||" && check.polarity === "negative";
+  }
+  if (owner.type === import_utils2.AST_NODE_TYPES.WhileStatement || owner.type === import_utils2.AST_NODE_TYPES.DoWhileStatement) {
+    return contains(owner.body, parse) && entersOnSuccess(check);
+  }
+  if (owner.type !== import_utils2.AST_NODE_TYPES.ConditionalExpression && owner.type !== import_utils2.AST_NODE_TYPES.IfStatement) {
+    return false;
+  }
+  if (contains(owner.consequent, parse)) {
+    return entersOnSuccess(check);
+  }
+  return owner.alternate !== null && contains(owner.alternate, parse) && skipsOnSuccess(check);
+}
+function entersOnSuccess(check) {
+  return check.polarity === "positive" && !check.underOr;
+}
+function skipsOnSuccess(check) {
+  return check.polarity === "negative" && !check.underAnd;
+}
+function guardProtects(check, parse) {
+  const { owner } = check;
+  if (owner.type === import_utils2.AST_NODE_TYPES.CallExpression) {
+    return entersOnSuccess(check) && owner.range[1] <= parse.range[0] && contains(scopeOfCheck(owner), parse);
+  }
+  if (owner.type !== import_utils2.AST_NODE_TYPES.IfStatement) {
+    return false;
+  }
+  if (owner.range[1] > parse.range[0] || !contains(scopeOfCheck(owner), parse)) {
+    return false;
+  }
+  if (alwaysExits(owner.consequent)) {
+    return skipsOnSuccess(check);
+  }
+  return owner.alternate !== null && alwaysExits(owner.alternate) && entersOnSuccess(check);
+}
+function protects(check, parse) {
+  if (!check.compared) {
+    return false;
+  }
+  return branchProtects(check, parse) || guardProtects(check, parse);
+}
+function statusAliases(root, keys, name) {
+  const aliases = /* @__PURE__ */ new Map();
+  walkSome(root, keys, (node) => {
+    if (node.type === import_utils2.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils2.AST_NODE_TYPES.Identifier && node.init !== null && propReadOn(node.init, name, OK_PROPS) && node.init.property.type === import_utils2.AST_NODE_TYPES.Identifier) {
+      aliases.set(node.id.name, node.init.property.name);
+    }
+    return false;
+  });
+  return aliases;
+}
+function checkedProp(node, name, aliases) {
+  if (propReadOn(node, name, OK_PROPS)) {
+    return node.property.type === import_utils2.AST_NODE_TYPES.Identifier ? node.property.name : void 0;
+  }
+  return node.type === import_utils2.AST_NODE_TYPES.Identifier ? aliases.get(node.name) : void 0;
+}
+function isProtected(root, keys, name, aliases, parse) {
+  return walkSome(root, keys, (node) => {
+    const prop = checkedProp(node, name, aliases);
+    if (prop === void 0) {
+      return false;
+    }
+    const check = climb(node, parse);
+    if (check === null) {
+      return false;
+    }
+    return protects(
+      prop === OK_PROP ? { ...check, compared: true } : check,
+      parse
+    );
+  });
+}
+function scopeOf(node) {
+  let current = node.parent;
+  while (current !== void 0) {
+    if (current.type === import_utils2.AST_NODE_TYPES.BlockStatement || current.type === import_utils2.AST_NODE_TYPES.Program) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return node;
+}
+function skipAwait(node) {
+  return node?.type === import_utils2.AST_NODE_TYPES.AwaitExpression ? node.parent : node;
+}
+function thenCallbackParam(node) {
+  if (node.type !== import_utils2.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== import_utils2.AST_NODE_TYPES.Identifier || node.property.name !== "then" || node.parent.type !== import_utils2.AST_NODE_TYPES.CallExpression) {
+    return null;
+  }
+  const callback = node.parent.arguments[0];
+  if (callback === void 0 || callback.type !== import_utils2.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils2.AST_NODE_TYPES.FunctionExpression) {
+    return null;
+  }
+  const param = callback.params[0];
+  return param?.type === import_utils2.AST_NODE_TYPES.Identifier ? { name: param.name, body: callback.body } : null;
+}
+var fetchMustCheckOkRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require a fetch response to be checked with `.ok` or a status comparison before `.json()` parses its body."
+    },
+    schema: [optionSchema2],
+    messages: {
+      missingOkCheck: "`fetch` resolves on 4xx/5xx too, so `.json()` here can parse an error body as data. Check `response.ok` (or compare the status) and leave early before reading the body."
+    }
+  },
+  defaultOptions: [{ fetchFunctions: ["fetch"] }],
+  create(context, [options]) {
+    const fetchFunctions = new Set(options.fetchFunctions ?? ["fetch"]);
+    const keys = context.sourceCode.visitorKeys;
+    function reportUnprotected(root, name) {
+      const aliases = statusAliases(root, keys, name);
+      for (const read of findJsonReads(root, keys, name)) {
+        if (!isProtected(root, keys, name, aliases, read)) {
+          context.report({ node: read, messageId: "missingOkCheck" });
+        }
+      }
+    }
+    return {
+      CallExpression(node) {
+        const path3 = calleePath(node.callee);
+        if (path3 === null || !fetchFunctions.has(path3)) {
+          return;
+        }
+        const parent = skipAwait(node.parent);
+        if (parent === void 0) {
+          return;
+        }
+        if (parent.type === import_utils2.AST_NODE_TYPES.MemberExpression && !parent.computed && parent.property.type === import_utils2.AST_NODE_TYPES.Identifier && parent.property.name === "json") {
+          context.report({ node: parent, messageId: "missingOkCheck" });
+          return;
+        }
+        const callback = thenCallbackParam(parent);
+        if (callback !== null) {
+          reportUnprotected(callback.body, callback.name);
+          return;
+        }
+        if (parent.type !== import_utils2.AST_NODE_TYPES.VariableDeclarator || parent.id.type !== import_utils2.AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        reportUnprotected(scopeOf(parent), parent.id.name);
+      }
+    };
+  }
+});
+
+// src/rules/money-must-be-decimal.ts
+var import_utils3 = require("@typescript-eslint/utils");
+var RULE_NAME3 = "money-must-be-decimal";
 var DEFAULT_DECIMAL_TYPE = "Decimal";
 var DEFAULT_FIELD_PATTERNS = [
   "amount",
@@ -163,7 +633,7 @@ var DEFAULT_FIELD_PATTERNS = [
   "balance"
 ];
 var DEFAULT_ALLOWED_FILES = [];
-var optionSchema2 = {
+var optionSchema3 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -192,22 +662,22 @@ function isAllowedFile(filename, patterns) {
   return patterns.some((pattern) => normalized.endsWith(toForwardSlash(pattern)));
 }
 function staticName(node) {
-  if (node.type === import_utils2.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils3.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
   return void 0;
 }
 function isNumberAnnotation(annotation) {
-  return annotation?.typeAnnotation.type === import_utils2.AST_NODE_TYPES.TSNumberKeyword;
+  return annotation?.typeAnnotation.type === import_utils3.AST_NODE_TYPES.TSNumberKeyword;
 }
 var moneyMustBeDecimalRule = createRule({
-  name: RULE_NAME2,
+  name: RULE_NAME3,
   meta: {
     type: "problem",
     docs: {
       description: "Disallow monetary values typed as the JS primitive `number`. Money-named fields explicitly typed `: number` lose precision to float rounding; use a Decimal money type instead."
     },
-    schema: [optionSchema2],
+    schema: [optionSchema3],
     messages: {
       moneyMustBeDecimal: "Monetary values must use {{decimalType}}, never the JS `number` primitive, to avoid float rounding errors. Rename or retype this field to a {{decimalType}} money type."
     }
@@ -243,7 +713,7 @@ var moneyMustBeDecimalRule = createRule({
       },
       // `const total: number = ...`: annotated variable declarator.
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils2.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils3.AST_NODE_TYPES.Identifier) {
           return;
         }
         const name = node.id.name;
@@ -256,15 +726,15 @@ var moneyMustBeDecimalRule = createRule({
 });
 
 // src/rules/no-direct-process-env.ts
-var import_utils3 = require("@typescript-eslint/utils");
-var RULE_NAME3 = "no-direct-process-env";
+var import_utils4 = require("@typescript-eslint/utils");
+var RULE_NAME4 = "no-direct-process-env";
 var DEFAULT_CONFIG_MODULE = "@/config";
 var DEFAULT_ALLOWED_FILES2 = [
   "**/*.config.{ts,js,mjs,cjs}",
   "**/*.{spec,test}.{ts,tsx}",
   "**/scripts/**"
 ];
-var optionSchema3 = {
+var optionSchema4 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -319,22 +789,22 @@ function isAllowedFile2(filename, patterns) {
   return patterns.some((pattern) => globToRegExp(pattern).test(normalized));
 }
 function isProcessEnv2(node) {
-  if (node.type !== import_utils3.AST_NODE_TYPES.MemberExpression || node.object.type !== import_utils3.AST_NODE_TYPES.Identifier || node.object.name !== "process") {
+  if (node.type !== import_utils4.AST_NODE_TYPES.MemberExpression || node.object.type !== import_utils4.AST_NODE_TYPES.Identifier || node.object.name !== "process") {
     return false;
   }
   if (node.computed) {
-    return node.property.type === import_utils3.AST_NODE_TYPES.Literal && node.property.value === "env";
+    return node.property.type === import_utils4.AST_NODE_TYPES.Literal && node.property.value === "env";
   }
-  return node.property.type === import_utils3.AST_NODE_TYPES.Identifier && node.property.name === "env";
+  return node.property.type === import_utils4.AST_NODE_TYPES.Identifier && node.property.name === "env";
 }
 var noDirectProcessEnvRule = createRule({
-  name: RULE_NAME3,
+  name: RULE_NAME4,
   meta: {
     type: "problem",
     docs: {
       description: "Disallow direct `process.env` access. Force every consumer through a typed, validated config accessor so a missing variable fails at boot, not at use."
     },
-    schema: [optionSchema3],
+    schema: [optionSchema4],
     messages: {
       directProcessEnv: "Read environment variables through your typed config accessor (import from `{{configModule}}`). Direct `process.env` access bypasses boot-time validation."
     }
@@ -369,10 +839,10 @@ var noDirectProcessEnvRule = createRule({
 });
 
 // src/rules/no-error-stringify.ts
-var import_utils4 = require("@typescript-eslint/utils");
-var RULE_NAME4 = "no-error-stringify";
+var import_utils5 = require("@typescript-eslint/utils");
+var RULE_NAME5 = "no-error-stringify";
 var DEFAULT_ERROR_NAMES = ["error", "err", "e", "cause"];
-var optionSchema4 = {
+var optionSchema5 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -385,19 +855,19 @@ var optionSchema4 = {
   }
 };
 function isEmptyStringLiteral(node) {
-  return node.type === import_utils4.AST_NODE_TYPES.Literal && node.value === "";
+  return node.type === import_utils5.AST_NODE_TYPES.Literal && node.value === "";
 }
 function isErrorIdentifier(node, names) {
-  return node.type === import_utils4.AST_NODE_TYPES.Identifier && names.has(node.name);
+  return node.type === import_utils5.AST_NODE_TYPES.Identifier && names.has(node.name);
 }
 var noErrorStringifyRule = createRule({
-  name: RULE_NAME4,
+  name: RULE_NAME5,
   meta: {
     type: "problem",
     docs: {
       description: 'Disallow stringifying an error with bare `${error}` interpolation, `error.toString()`, or `error + ""`. These drop the cause chain. Use `error instanceof Error ? error.message : String(error)` instead.'
     },
-    schema: [optionSchema4],
+    schema: [optionSchema5],
     messages: {
       noErrorStringify: "Stringifying an error this way drops its cause chain. Use `{{name}} instanceof Error ? {{name}}.message : String({{name}})` (or pass the Error object straight to the logger)."
     }
@@ -412,7 +882,7 @@ var noErrorStringifyRule = createRule({
       // `error.toString()`
       'CallExpression[callee.type="MemberExpression"]'(node) {
         const callee = node.callee;
-        if (!callee.computed && callee.property.type === import_utils4.AST_NODE_TYPES.Identifier && callee.property.name === "toString" && node.arguments.length === 0 && isErrorIdentifier(callee.object, errorNames)) {
+        if (!callee.computed && callee.property.type === import_utils5.AST_NODE_TYPES.Identifier && callee.property.name === "toString" && node.arguments.length === 0 && isErrorIdentifier(callee.object, errorNames)) {
           report(node, callee.object.name);
         }
       },
@@ -445,14 +915,14 @@ var noErrorStringifyRule = createRule({
 });
 
 // src/rules/require-error-cause.ts
-var import_utils5 = require("@typescript-eslint/utils");
-var RULE_NAME5 = "require-error-cause";
+var import_utils6 = require("@typescript-eslint/utils");
+var RULE_NAME6 = "require-error-cause";
 function constructorSimpleName(node) {
   const callee = node.callee;
-  if (callee.type === import_utils5.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils6.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils5.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils5.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils6.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils6.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
   }
   return null;
@@ -462,16 +932,16 @@ function isErrorLikeName(name) {
 }
 function alreadyHasCause(node) {
   for (const arg of node.arguments) {
-    if (arg.type === import_utils5.AST_NODE_TYPES.SpreadElement) {
+    if (arg.type === import_utils6.AST_NODE_TYPES.SpreadElement) {
       return true;
     }
-    if (arg.type === import_utils5.AST_NODE_TYPES.ObjectExpression) {
+    if (arg.type === import_utils6.AST_NODE_TYPES.ObjectExpression) {
       for (const prop of arg.properties) {
-        if (prop.type === import_utils5.AST_NODE_TYPES.SpreadElement) {
+        if (prop.type === import_utils6.AST_NODE_TYPES.SpreadElement) {
           return true;
         }
         const key = prop.key;
-        const isCause = key.type === import_utils5.AST_NODE_TYPES.Identifier && key.name === "cause" || key.type === import_utils5.AST_NODE_TYPES.Literal && key.value === "cause";
+        const isCause = key.type === import_utils6.AST_NODE_TYPES.Identifier && key.name === "cause" || key.type === import_utils6.AST_NODE_TYPES.Literal && key.value === "cause";
         if (isCause) {
           return true;
         }
@@ -489,7 +959,7 @@ function buildFix(node, binding) {
   if (last === void 0) {
     return null;
   }
-  if (last.type === import_utils5.AST_NODE_TYPES.ObjectExpression) {
+  if (last.type === import_utils6.AST_NODE_TYPES.ObjectExpression) {
     const props = last.properties;
     if (props.length === 0) {
       return (fixer) => fixer.replaceText(last, `{ cause: ${binding} }`);
@@ -503,7 +973,7 @@ function buildFix(node, binding) {
   return (fixer) => fixer.insertTextAfter(last, `, { cause: ${binding} }`);
 }
 var requireErrorCauseRule = createRule({
-  name: RULE_NAME5,
+  name: RULE_NAME6,
   meta: {
     type: "problem",
     docs: {
@@ -522,7 +992,7 @@ var requireErrorCauseRule = createRule({
       CatchClause(node) {
         const param = node.param;
         catchBindings.push(
-          param && param.type === import_utils5.AST_NODE_TYPES.Identifier ? param.name : null
+          param && param.type === import_utils6.AST_NODE_TYPES.Identifier ? param.name : null
         );
       },
       "CatchClause:exit"() {
@@ -534,7 +1004,7 @@ var requireErrorCauseRule = createRule({
           return;
         }
         const arg = node.argument;
-        if (arg.type !== import_utils5.AST_NODE_TYPES.NewExpression) {
+        if (arg.type !== import_utils6.AST_NODE_TYPES.NewExpression) {
           return;
         }
         const ctor = constructorSimpleName(arg);
@@ -557,9 +1027,9 @@ var requireErrorCauseRule = createRule({
 });
 
 // src/rules/require-registered-keys.ts
-var import_utils6 = require("@typescript-eslint/utils");
-var RULE_NAME6 = "require-registered-keys";
-var optionSchema5 = {
+var import_utils7 = require("@typescript-eslint/utils");
+var RULE_NAME7 = "require-registered-keys";
+var optionSchema6 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -578,30 +1048,30 @@ var optionSchema5 = {
     registry: { type: "string", minLength: 1 }
   }
 };
-function calleePath(callee) {
-  if (callee.type === import_utils6.AST_NODE_TYPES.Identifier) {
+function calleePath2(callee) {
+  if (callee.type === import_utils7.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils6.AST_NODE_TYPES.MemberExpression && !callee.computed) {
-    if (callee.property.type !== import_utils6.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils7.AST_NODE_TYPES.MemberExpression && !callee.computed) {
+    if (callee.property.type !== import_utils7.AST_NODE_TYPES.Identifier) {
       return null;
     }
-    const objectPath = calleePath(callee.object);
+    const objectPath = calleePath2(callee.object);
     return objectPath === null ? null : `${objectPath}.${callee.property.name}`;
   }
   return null;
 }
 function isStringLiteral(node) {
-  return node.type === import_utils6.AST_NODE_TYPES.Literal && typeof node.value === "string";
+  return node.type === import_utils7.AST_NODE_TYPES.Literal && typeof node.value === "string";
 }
 var requireRegisteredKeysRule = createRule({
-  name: RULE_NAME6,
+  name: RULE_NAME7,
   meta: {
     type: "suggestion",
     docs: {
       description: "Require the key/name argument of configured sink APIs (storage, event channels, cache keys) to be an imported constant from a registry module, not a raw string literal."
     },
-    schema: [optionSchema5],
+    schema: [optionSchema6],
     messages: {
       unregisteredKey: "Pass an imported key constant to `{{callee}}`, not the raw string {{value}}{{registryHint}}. Raw string keys drift out of sync across call sites."
     }
@@ -625,11 +1095,11 @@ var requireRegisteredKeysRule = createRule({
     const registryHint = registry ? ` (import it from '${registry}')` : "";
     return {
       CallExpression(node) {
-        const path2 = calleePath(node.callee);
-        if (path2 === null) {
+        const path3 = calleePath2(node.callee);
+        if (path3 === null) {
           return;
         }
-        const indexes = sinkMap.get(path2);
+        const indexes = sinkMap.get(path3);
         if (indexes === void 0) {
           return;
         }
@@ -639,7 +1109,7 @@ var requireRegisteredKeysRule = createRule({
             context.report({
               node: arg,
               messageId: "unregisteredKey",
-              data: { callee: path2, value: `'${arg.value}'`, registryHint }
+              data: { callee: path3, value: `'${arg.value}'`, registryHint }
             });
           }
         }
@@ -649,29 +1119,29 @@ var requireRegisteredKeysRule = createRule({
 });
 
 // src/rules/require-schema-parse-at-boundary.ts
-var import_utils7 = require("@typescript-eslint/utils");
-var RULE_NAME7 = "require-schema-parse-at-boundary";
+var import_utils8 = require("@typescript-eslint/utils");
+var RULE_NAME8 = "require-schema-parse-at-boundary";
 function isJsonParseCall(node) {
-  return node.type === import_utils7.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils7.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils7.AST_NODE_TYPES.Identifier && node.callee.object.name === "JSON" && node.callee.property.type === import_utils7.AST_NODE_TYPES.Identifier && node.callee.property.name === "parse";
+  return node.type === import_utils8.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils8.AST_NODE_TYPES.Identifier && node.callee.object.name === "JSON" && node.callee.property.type === import_utils8.AST_NODE_TYPES.Identifier && node.callee.property.name === "parse";
 }
 function isAwaitJsonCall(node) {
-  if (node.type !== import_utils7.AST_NODE_TYPES.AwaitExpression) {
+  if (node.type !== import_utils8.AST_NODE_TYPES.AwaitExpression) {
     return false;
   }
   const call = node.argument;
-  return call.type === import_utils7.AST_NODE_TYPES.CallExpression && call.arguments.length === 0 && call.callee.type === import_utils7.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.property.type === import_utils7.AST_NODE_TYPES.Identifier && call.callee.property.name === "json";
+  return call.type === import_utils8.AST_NODE_TYPES.CallExpression && call.arguments.length === 0 && call.callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.property.type === import_utils8.AST_NODE_TYPES.Identifier && call.callee.property.name === "json";
 }
 function isShapeClaim(annotation) {
-  if (annotation.type === import_utils7.AST_NODE_TYPES.TSArrayType) {
+  if (annotation.type === import_utils8.AST_NODE_TYPES.TSArrayType) {
     return true;
   }
-  if (annotation.type === import_utils7.AST_NODE_TYPES.TSTypeReference) {
-    return !(annotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && annotation.typeName.name === "const");
+  if (annotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference) {
+    return !(annotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && annotation.typeName.name === "const");
   }
   return false;
 }
 var requireSchemaParseAtBoundaryRule = createRule({
-  name: RULE_NAME7,
+  name: RULE_NAME8,
   meta: {
     type: "problem",
     docs: {
@@ -699,10 +1169,10 @@ var requireSchemaParseAtBoundaryRule = createRule({
 });
 
 // src/rules/restrict-throw-to-taxonomy.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var RULE_NAME8 = "restrict-throw-to-taxonomy";
+var import_utils9 = require("@typescript-eslint/utils");
+var RULE_NAME9 = "restrict-throw-to-taxonomy";
 var DEFAULT_ALLOW = ["Error"];
-var optionSchema6 = {
+var optionSchema7 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -715,25 +1185,25 @@ var optionSchema6 = {
 };
 function constructorSimpleName2(node) {
   const callee = node.callee;
-  if (callee.type === import_utils8.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils9.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils8.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils9.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils9.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
   }
   return null;
 }
 function isNonErrorValue(node) {
-  return node.type === import_utils8.AST_NODE_TYPES.Literal || node.type === import_utils8.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils8.AST_NODE_TYPES.ObjectExpression || node.type === import_utils8.AST_NODE_TYPES.ArrayExpression;
+  return node.type === import_utils9.AST_NODE_TYPES.Literal || node.type === import_utils9.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils9.AST_NODE_TYPES.ObjectExpression || node.type === import_utils9.AST_NODE_TYPES.ArrayExpression;
 }
 var restrictThrowToTaxonomyRule = createRule({
-  name: RULE_NAME8,
+  name: RULE_NAME9,
   meta: {
     type: "problem",
     docs: {
       description: "Restrict `throw` to an approved error taxonomy. Flags throwing a non-allowlisted error class and throwing a non-Error value (string, object, number, ...)."
     },
-    schema: [optionSchema6],
+    schema: [optionSchema7],
     messages: {
       disallowedErrorClass: "Throw an error from your taxonomy, not `{{name}}`. Allowed: {{allowed}}. Add `{{name}}` to the `allow` option if it belongs to your taxonomy.",
       nonErrorThrow: "Throw an Error from your taxonomy, not a bare {{kind}} value. A non-Error throw carries no stack or cause."
@@ -746,7 +1216,7 @@ var restrictThrowToTaxonomyRule = createRule({
     return {
       ThrowStatement(node) {
         const arg = node.argument;
-        if (arg.type === import_utils8.AST_NODE_TYPES.NewExpression) {
+        if (arg.type === import_utils9.AST_NODE_TYPES.NewExpression) {
           const name = constructorSimpleName2(arg);
           if (name !== null && !allow.has(name)) {
             context.report({
@@ -758,7 +1228,7 @@ var restrictThrowToTaxonomyRule = createRule({
           return;
         }
         if (isNonErrorValue(arg)) {
-          const kind = arg.type === import_utils8.AST_NODE_TYPES.ObjectExpression ? "object" : arg.type === import_utils8.AST_NODE_TYPES.ArrayExpression ? "array" : "literal";
+          const kind = arg.type === import_utils9.AST_NODE_TYPES.ObjectExpression ? "object" : arg.type === import_utils9.AST_NODE_TYPES.ArrayExpression ? "array" : "literal";
           context.report({ node: arg, messageId: "nonErrorThrow", data: { kind } });
         }
       }
@@ -766,10 +1236,863 @@ var restrictThrowToTaxonomyRule = createRule({
   }
 });
 
+// src/rules/schema-enum-field-consistency.ts
+var import_utils10 = require("@typescript-eslint/utils");
+var RULE_NAME10 = "schema-enum-field-consistency";
+var MODIFIERS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "nullish",
+  "default",
+  "prefault",
+  "catch",
+  "describe",
+  "meta",
+  "readonly"
+]);
+var ENUM_PRESERVING = /* @__PURE__ */ new Set(["extract", "exclude"]);
+var OUTPUT_CHANGING = /* @__PURE__ */ new Set(["pipe", "transform"]);
+var OBJECT_FACTORIES = /* @__PURE__ */ new Set(["object", "strictObject", "looseObject"]);
+var SHAPE_EXTENDERS = /* @__PURE__ */ new Set(["extend", "safeExtend"]);
+var ENUM_FACTORIES = /* @__PURE__ */ new Set(["enum", "nativeEnum"]);
+var UNION = /* @__PURE__ */ new Set(["union"]);
+var LITERAL = /* @__PURE__ */ new Set(["literal"]);
+var STRING = /* @__PURE__ */ new Set(["string"]);
+var optionSchema8 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    zodIdentifiers: { type: "array", items: { type: "string" }, uniqueItems: true },
+    ignoreFields: { type: "array", items: { type: "string" }, uniqueItems: true },
+    enumIdentifierPattern: { type: "string" }
+  }
+};
+var OTHER = { kind: "other" };
+function isEnumOccurrence(occurrence) {
+  return occurrence.kind.kind === "enum";
+}
+function methodCall(node) {
+  if (node.type !== import_utils10.AST_NODE_TYPES.CallExpression) return null;
+  const callee = node.callee;
+  if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression || callee.computed) return null;
+  if (callee.property.type !== import_utils10.AST_NODE_TYPES.Identifier) return null;
+  return { receiver: callee.object, method: callee.property.name, call: node };
+}
+function propertyName(property) {
+  if (property.computed) return null;
+  if (property.key.type === import_utils10.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils10.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
+    return property.key.value;
+  }
+  return null;
+}
+var schemaEnumFieldConsistencyRule = createRule({
+  name: RULE_NAME10,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow a zod field that is an enum in one object schema of a module from being `z.string()` in another, which widens the wire type every consumer then narrows by hand."
+    },
+    schema: [optionSchema8],
+    messages: {
+      widenedEnumField: "`{{field}}` is `z.string()` here but an enum on line {{line}} of this file. The widened type leaks `string` to every consumer, which then has to narrow or cast it. Use {{suggestion}} instead (and, if the stored data is free text, migrate it first)."
+    }
+  },
+  defaultOptions: [{ zodIdentifiers: ["z"], ignoreFields: [] }],
+  create(context, [options]) {
+    const zodIdentifiers = new Set(options.zodIdentifiers ?? ["z"]);
+    const ignoreFields = new Set(options.ignoreFields ?? []);
+    const enumIdentifierPattern = options.enumIdentifierPattern === void 0 ? null : new RegExp(options.enumIdentifierPattern, "u");
+    const sourceCode = context.sourceCode;
+    const fields = /* @__PURE__ */ new Map();
+    function isZodCall(node, names) {
+      const call = methodCall(node);
+      return call !== null && call.receiver.type === import_utils10.AST_NODE_TYPES.Identifier && zodIdentifiers.has(call.receiver.name) && names.has(call.method);
+    }
+    function resolveVariable(identifier) {
+      let scope = sourceCode.getScope(identifier);
+      while (scope !== null) {
+        const variable = scope.set.get(identifier.name);
+        if (variable !== void 0) return variable;
+        scope = scope.upper;
+      }
+      return null;
+    }
+    function identifierIsEnum(identifier, seen) {
+      const definition = resolveVariable(identifier)?.defs[0];
+      if (definition === void 0) return false;
+      if (definition.type === "ImportBinding") {
+        return enumIdentifierPattern !== null && enumIdentifierPattern.test(identifier.name);
+      }
+      if (definition.type !== "Variable") return false;
+      const init = definition.node.init;
+      if (init === null || seen.has(init)) return false;
+      return classify(init, /* @__PURE__ */ new Set([...seen, init])).kind === "enum";
+    }
+    function isLiteralUnion(node) {
+      if (!isZodCall(node, UNION)) return false;
+      const members = node.arguments[0];
+      if (members?.type !== import_utils10.AST_NODE_TYPES.ArrayExpression || members.elements.length === 0) {
+        return false;
+      }
+      return members.elements.every((element) => element !== null && isZodCall(element, LITERAL));
+    }
+    function isMultiLiteral(node) {
+      if (!isZodCall(node, LITERAL)) return false;
+      const value = node.arguments[0];
+      return value?.type === import_utils10.AST_NODE_TYPES.ArrayExpression && value.elements.length > 1;
+    }
+    function classify(node, seen) {
+      let current = node;
+      for (; ; ) {
+        const call = methodCall(current);
+        if (call === null || !(MODIFIERS.has(call.method) || ENUM_PRESERVING.has(call.method))) {
+          break;
+        }
+        current = call.receiver;
+      }
+      if (current.type === import_utils10.AST_NODE_TYPES.Identifier) {
+        return identifierIsEnum(current, seen) ? { kind: "enum", identifier: current.name } : OTHER;
+      }
+      if (isZodCall(current, ENUM_FACTORIES) || isLiteralUnion(current) || isMultiLiteral(current)) {
+        return { kind: "enum", identifier: null };
+      }
+      current = node;
+      for (; ; ) {
+        if (isZodCall(current, STRING)) return { kind: "string" };
+        const call = methodCall(current);
+        if (call === null || OUTPUT_CHANGING.has(call.method)) return OTHER;
+        current = call.receiver;
+      }
+    }
+    function collectShape(shape) {
+      if (shape?.type !== import_utils10.AST_NODE_TYPES.ObjectExpression) return;
+      for (const property of shape.properties) {
+        if (property.type !== import_utils10.AST_NODE_TYPES.Property) continue;
+        const name = propertyName(property);
+        if (name === null || ignoreFields.has(name)) continue;
+        const kind = classify(property.value, /* @__PURE__ */ new Set());
+        if (kind.kind === "other") continue;
+        const occurrences = fields.get(name) ?? [];
+        occurrences.push({ property, kind });
+        fields.set(name, occurrences);
+      }
+    }
+    return {
+      CallExpression(node) {
+        if (isZodCall(node, OBJECT_FACTORIES)) {
+          collectShape(node.arguments[0]);
+          return;
+        }
+        const call = methodCall(node);
+        if (call !== null && SHAPE_EXTENDERS.has(call.method)) collectShape(node.arguments[0]);
+      },
+      "Program:exit"() {
+        for (const [field, occurrences] of fields) {
+          const enumOccurrence = occurrences.find(isEnumOccurrence);
+          if (enumOccurrence === void 0) continue;
+          const suggestion = enumOccurrence.kind.identifier === null ? "the same enum schema" : `\`${enumOccurrence.kind.identifier}\``;
+          for (const occurrence of occurrences) {
+            if (occurrence.kind.kind !== "string") continue;
+            context.report({
+              node: occurrence.property,
+              messageId: "widenedEnumField",
+              data: {
+                field,
+                line: String(enumOccurrence.property.loc.start.line),
+                suggestion
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/i18n/catalogs.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var NS_PLACEHOLDER = "{ns}";
+var SAFE_NAMESPACE = /^(?!\.{1,2}$)[^/\\\0]+$/u;
+var fileCache = /* @__PURE__ */ new Map();
+function readCatalogFile(absolute) {
+  let mtimeMs;
+  try {
+    const stats = (0, import_node_fs2.statSync)(absolute);
+    if (!stats.isFile()) return { kind: "missing" };
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return { kind: "missing" };
+  }
+  const cached = fileCache.get(absolute);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) {
+    return cached.value.ok ? { kind: "ok", entry: cached } : { kind: "invalid", reason: cached.value.reason };
+  }
+  let value;
+  try {
+    value = { ok: true, json: JSON.parse((0, import_node_fs2.readFileSync)(absolute, "utf8")) };
+  } catch (error) {
+    value = { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  const entry = { mtimeMs, value, flattened: /* @__PURE__ */ new Map() };
+  fileCache.set(absolute, entry);
+  return value.ok ? { kind: "ok", entry } : { kind: "invalid", reason: value.reason };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function descend(json, keyPath) {
+  if (keyPath === void 0 || keyPath === "") return json;
+  let current = json;
+  for (const segment of keyPath.split(".")) {
+    if (!isRecord(current) || !Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function flatten(root, keySeparator, label) {
+  const leaves = /* @__PURE__ */ new Set();
+  const branches = /* @__PURE__ */ new Set();
+  const visit = (value, prefix) => {
+    if (!isRecord(value)) {
+      leaves.add(prefix);
+      return;
+    }
+    branches.add(prefix);
+    if (keySeparator === false) return;
+    for (const [key, child] of Object.entries(value)) {
+      visit(child, `${prefix}${keySeparator}${key}`);
+    }
+  };
+  for (const [key, child] of Object.entries(root)) {
+    if (keySeparator === false) {
+      (isRecord(child) ? branches : leaves).add(key);
+    } else {
+      visit(child, key);
+    }
+  }
+  return { label, leaves, branches };
+}
+function loadSource(cwd, file, keyPath, keySeparator) {
+  const absolute = import_node_path2.default.isAbsolute(file) ? file : import_node_path2.default.resolve(cwd, file);
+  const read = readCatalogFile(absolute);
+  if (read.kind === "missing") return { kind: "absent" };
+  if (read.kind === "invalid") return { kind: "error", reason: `${file}: ${read.reason}` };
+  const cacheKey = `${keyPath ?? ""}\0${keySeparator === false ? "" : keySeparator}`;
+  const cached = read.entry.flattened.get(cacheKey);
+  if (cached !== void 0) {
+    return cached === null ? { kind: "absent" } : { kind: "ok", catalog: cached };
+  }
+  const subtree = read.entry.value.ok ? descend(read.entry.value.json, keyPath) : void 0;
+  const label = keyPath ? `${file}#${keyPath}` : file;
+  const catalog = isRecord(subtree) ? flatten(subtree, keySeparator, label) : null;
+  read.entry.flattened.set(cacheKey, catalog);
+  return catalog === null ? { kind: "absent" } : { kind: "ok", catalog };
+}
+function catalogsForNamespace(namespace, sources, settings) {
+  const catalogs = [];
+  const errors = [];
+  for (const source of sources) {
+    const templated = source.file.includes(NS_PLACEHOLDER) || (source.keyPath?.includes(NS_PLACEHOLDER) ?? false);
+    if (templated) {
+      if (!SAFE_NAMESPACE.test(namespace)) continue;
+      const file = source.file.replaceAll(NS_PLACEHOLDER, namespace);
+      const keyPath = source.keyPath?.replaceAll(NS_PLACEHOLDER, namespace);
+      const load2 = loadSource(settings.cwd, file, keyPath, settings.keySeparator);
+      if (load2.kind === "ok") catalogs.push(load2.catalog);
+      else if (load2.kind === "error") errors.push(load2.reason);
+      continue;
+    }
+    if ((source.namespace ?? settings.defaultNamespace) !== namespace) continue;
+    const load = loadSource(settings.cwd, source.file, source.keyPath, settings.keySeparator);
+    if (load.kind === "ok") catalogs.push(load.catalog);
+    else if (load.kind === "error") errors.push(load.reason);
+    else {
+      const where = source.keyPath ? `${source.file}#${source.keyPath}` : source.file;
+      errors.push(`${where}: not found or not a JSON object`);
+    }
+  }
+  return { catalogs, errors };
+}
+var PLURAL_CATEGORIES = ["zero", "one", "two", "few", "many", "other"];
+function catalogHasKey(catalog, key, lookup) {
+  if (catalog.leaves.has(key)) return true;
+  if (lookup.returnObjects && catalog.branches.has(key)) return true;
+  if (lookup.plural) {
+    const sep = lookup.pluralSeparator;
+    for (const category of PLURAL_CATEGORIES) {
+      if (catalog.leaves.has(`${key}${sep}${category}`)) return true;
+      if (catalog.leaves.has(`${key}${sep}ordinal${sep}${category}`)) return true;
+    }
+  }
+  if (lookup.context) {
+    const variant = `${key}${lookup.contextSeparator}`;
+    for (const leaf of catalog.leaves) {
+      if (leaf.startsWith(variant)) return true;
+    }
+  }
+  return false;
+}
+function catalogHasPrefix(catalog, prefix) {
+  for (const leaf of catalog.leaves) {
+    if (leaf.startsWith(prefix)) return true;
+  }
+  for (const branch of catalog.branches) {
+    if (branch.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+// src/i18n/translationUsage.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var UNRESOLVED = "unresolved";
+var MAX_DEPTH = 8;
+function unwrap(node) {
+  let current = node;
+  while (current.type === import_utils11.AST_NODE_TYPES.TSAsExpression || current.type === import_utils11.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils11.AST_NODE_TYPES.TSNonNullExpression) {
+    current = current.expression;
+  }
+  return current;
+}
+function staticString(node) {
+  const inner = unwrap(node);
+  if (inner.type === import_utils11.AST_NODE_TYPES.Literal && typeof inner.value === "string") return inner.value;
+  if (inner.type === import_utils11.AST_NODE_TYPES.TemplateLiteral && inner.expressions.length === 0) {
+    return inner.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
+}
+function propertyName2(property) {
+  if (property.computed) return staticString(property.key);
+  if (property.key.type === import_utils11.AST_NODE_TYPES.Identifier) return property.key.name;
+  return staticString(property.key);
+}
+function targetIdentifier(node) {
+  if (node.type === import_utils11.AST_NODE_TYPES.Identifier) return node;
+  if (node.type === import_utils11.AST_NODE_TYPES.AssignmentPattern && node.left.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    return node.left;
+  }
+  return null;
+}
+function createTranslationVisitor(context, settings, onUsage) {
+  const sourceCode = context.sourceCode;
+  const defaultBinding = { namespaces: [settings.defaultNamespace], keyPrefix: null };
+  function resolveVariable(identifier) {
+    let scope = sourceCode.getScope(identifier);
+    while (scope !== null) {
+      const variable = scope.set.get(identifier.name);
+      if (variable !== void 0) return variable;
+      scope = scope.upper;
+    }
+    return null;
+  }
+  function typedStringLiteral(node) {
+    const services = sourceCode.parserServices;
+    const program = services?.program;
+    const map = services?.esTreeNodeToTSNodeMap;
+    if (!program || !map) return null;
+    const type = program.getTypeChecker().getTypeAtLocation(map.get(node));
+    return type.isStringLiteral() ? type.value : null;
+  }
+  function resolveNamespaces(node, depth = 0) {
+    if (node === void 0) return defaultBinding.namespaces;
+    const inner = unwrap(node);
+    const literal = staticString(inner);
+    if (literal !== null) return [literal];
+    if (inner.type === import_utils11.AST_NODE_TYPES.Literal && inner.value === null) return defaultBinding.namespaces;
+    if (inner.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
+      const namespaces = [];
+      for (const element of inner.elements) {
+        if (element === null || element.type === import_utils11.AST_NODE_TYPES.SpreadElement) return UNRESOLVED;
+        const value2 = staticString(element) ?? resolveIdentifierString(element, depth);
+        if (value2 === null) return UNRESOLVED;
+        namespaces.push(value2);
+      }
+      return namespaces.length > 0 ? namespaces : defaultBinding.namespaces;
+    }
+    if (inner.type === import_utils11.AST_NODE_TYPES.Identifier && inner.name === "undefined") return defaultBinding.namespaces;
+    const value = resolveIdentifierString(inner, depth);
+    return value === null ? UNRESOLVED : [value];
+  }
+  function resolveIdentifierString(node, depth) {
+    if (node.type !== import_utils11.AST_NODE_TYPES.Identifier || depth > MAX_DEPTH) return null;
+    if (Object.hasOwn(settings.namespaceIdentifiers, node.name)) {
+      return settings.namespaceIdentifiers[node.name] ?? null;
+    }
+    const definition = resolveVariable(node)?.defs[0];
+    if (definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.id.type === import_utils11.AST_NODE_TYPES.Identifier && definition.node.init !== null) {
+      const init = unwrap(definition.node.init);
+      const literal = staticString(init);
+      if (literal !== null) return literal;
+      const chained = resolveIdentifierString(init, depth + 1);
+      if (chained !== null) return chained;
+    }
+    return typedStringLiteral(node);
+  }
+  function isHookCall(node) {
+    return node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.Identifier && settings.hooks.has(node.callee.name);
+  }
+  function isInstance(node) {
+    return node.type === import_utils11.AST_NODE_TYPES.Identifier && settings.instances.has(node.name);
+  }
+  function staticPrefix(node) {
+    if (node === void 0) return null;
+    const inner = unwrap(node);
+    if (inner.type === import_utils11.AST_NODE_TYPES.Identifier && inner.name === "undefined") return null;
+    if (inner.type === import_utils11.AST_NODE_TYPES.Literal && inner.value === null) return null;
+    return staticString(inner) ?? UNRESOLVED;
+  }
+  function bindingFromHook(call) {
+    const [nsArg, optionsArg] = call.arguments;
+    const namespaces = resolveNamespaces(nsArg);
+    if (namespaces === UNRESOLVED) return UNRESOLVED;
+    let keyPrefix = null;
+    if (optionsArg !== void 0) {
+      const options = unwrap(optionsArg);
+      if (options.type !== import_utils11.AST_NODE_TYPES.ObjectExpression) return UNRESOLVED;
+      for (const property of options.properties) {
+        if (property.type !== import_utils11.AST_NODE_TYPES.Property) return UNRESOLVED;
+        if (propertyName2(property) !== "keyPrefix") continue;
+        const prefix = staticPrefix(property.value);
+        if (prefix === UNRESOLVED) return UNRESOLVED;
+        keyPrefix = prefix;
+      }
+    }
+    return { namespaces, keyPrefix };
+  }
+  function bindingFromGetFixedT(call) {
+    const [, nsArg, prefixArg] = call.arguments;
+    const namespaces = resolveNamespaces(nsArg);
+    if (namespaces === UNRESOLVED) return UNRESOLVED;
+    const keyPrefix = staticPrefix(prefixArg);
+    if (keyPrefix === UNRESOLVED) return UNRESOLVED;
+    return { namespaces, keyPrefix };
+  }
+  function isGetFixedT(node) {
+    return node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && node.callee.property.name === "getFixedT" && isInstance(node.callee.object);
+  }
+  function hookCallOf(identifier) {
+    const definition = resolveVariable(identifier)?.defs[0];
+    if (definition?.type !== "Variable" || definition.node.id.type !== import_utils11.AST_NODE_TYPES.Identifier) return null;
+    const init = definition.node.init === null ? null : unwrap(definition.node.init);
+    return init !== null && isHookCall(init) ? init : null;
+  }
+  function bindingOfTSource(object) {
+    const inner = unwrap(object);
+    if (isHookCall(inner)) return bindingFromHook(inner);
+    if (inner.type === import_utils11.AST_NODE_TYPES.Identifier) {
+      const hook = hookCallOf(inner);
+      if (hook !== null) return bindingFromHook(hook);
+      if (isInstance(inner)) return defaultBinding;
+    }
+    return null;
+  }
+  function bindingFromType(annotation) {
+    const type = annotation?.typeAnnotation;
+    if (type?.type !== import_utils11.AST_NODE_TYPES.TSTypeReference) return null;
+    const name = type.typeName.type === import_utils11.AST_NODE_TYPES.Identifier ? type.typeName.name : type.typeName.type === import_utils11.AST_NODE_TYPES.TSQualifiedName ? type.typeName.right.name : null;
+    if (name === null || !settings.typeNames.has(name)) return null;
+    const [nsType, prefixType] = type.typeArguments?.params ?? [];
+    const literalOf = (node) => node.type === import_utils11.AST_NODE_TYPES.TSLiteralType ? staticString(node.literal) : null;
+    let namespaces = defaultBinding.namespaces;
+    if (nsType !== void 0) {
+      if (nsType.type === import_utils11.AST_NODE_TYPES.TSTupleType) {
+        const values = nsType.elementTypes.map(literalOf);
+        if (values.length === 0 || values.some((value) => value === null)) return UNRESOLVED;
+        namespaces = values;
+      } else {
+        const value = literalOf(nsType);
+        if (value === null) return UNRESOLVED;
+        namespaces = [value];
+      }
+    }
+    let keyPrefix = null;
+    if (prefixType !== void 0) {
+      keyPrefix = literalOf(prefixType);
+      if (keyPrefix === null) return UNRESOLVED;
+    }
+    return { namespaces, keyPrefix };
+  }
+  function bindingFromDeclarator(declarator, name, depth) {
+    if (declarator.init === null) return null;
+    const init = unwrap(declarator.init);
+    const id = declarator.id;
+    if (id.type === import_utils11.AST_NODE_TYPES.Identifier) {
+      if (isGetFixedT(init)) return bindingFromGetFixedT(init);
+      if (init.type === import_utils11.AST_NODE_TYPES.MemberExpression && !init.computed && init.property.type === import_utils11.AST_NODE_TYPES.Identifier && init.property.name === "t") {
+        return bindingOfTSource(init.object);
+      }
+      if (init.type === import_utils11.AST_NODE_TYPES.Identifier) return bindingOfIdentifier(init, depth + 1);
+      return null;
+    }
+    if (id.type === import_utils11.AST_NODE_TYPES.ObjectPattern) {
+      for (const property of id.properties) {
+        if (property.type !== import_utils11.AST_NODE_TYPES.Property || targetIdentifier(property.value) !== name) continue;
+        return propertyName2(property) === "t" ? bindingOfTSource(init) : null;
+      }
+      return null;
+    }
+    if (id.type === import_utils11.AST_NODE_TYPES.ArrayPattern) {
+      const first = id.elements[0];
+      if (first && targetIdentifier(first) === name && isHookCall(init)) return bindingFromHook(init);
+    }
+    return null;
+  }
+  function bindingOfIdentifier(identifier, depth = 0) {
+    if (depth > MAX_DEPTH) return null;
+    const variable = resolveVariable(identifier);
+    if (variable === null) {
+      return settings.functions.has(identifier.name) ? defaultBinding : null;
+    }
+    const definition = variable.defs[0];
+    if (definition === void 0) return null;
+    switch (definition.type) {
+      case "ImportBinding": {
+        const specifier = definition.node;
+        if (specifier.type !== import_utils11.AST_NODE_TYPES.ImportSpecifier) return null;
+        const imported = specifier.imported.type === import_utils11.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+        return settings.functions.has(imported) ? defaultBinding : null;
+      }
+      case "Parameter": {
+        const name = definition.name;
+        if (name.type !== import_utils11.AST_NODE_TYPES.Identifier) return null;
+        const typed = bindingFromType(name.typeAnnotation);
+        if (typed !== null) return typed;
+        return settings.functions.has(name.name) ? UNRESOLVED : null;
+      }
+      case "Variable":
+        return definition.name.type === import_utils11.AST_NODE_TYPES.Identifier ? bindingFromDeclarator(definition.node, definition.name, depth) : null;
+      default:
+        return null;
+    }
+  }
+  function bindingOfCallee(callee) {
+    if (callee.type === import_utils11.AST_NODE_TYPES.Identifier) return bindingOfIdentifier(callee);
+    if (callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && callee.property.name === "t") {
+      return bindingOfTSource(callee.object);
+    }
+    return null;
+  }
+  function readCallOptions(node) {
+    const none = { namespaces: null, plural: false, context: false, returnObjects: false };
+    if (node === void 0) return none;
+    const inner = unwrap(node);
+    if (inner.type !== import_utils11.AST_NODE_TYPES.ObjectExpression) return UNRESOLVED;
+    let namespaces = null;
+    let plural = false;
+    let context2 = false;
+    let returnObjects = false;
+    for (const property of inner.properties) {
+      if (property.type !== import_utils11.AST_NODE_TYPES.Property) return UNRESOLVED;
+      const name = propertyName2(property);
+      if (name === null || name === "keyPrefix") return UNRESOLVED;
+      if (name === "ns") {
+        const resolved = resolveNamespaces(property.value);
+        if (resolved === UNRESOLVED) return UNRESOLVED;
+        namespaces = resolved;
+      } else if (name === "count") {
+        plural = true;
+      } else if (name === "context") {
+        context2 = true;
+      } else if (name === "returnObjects") {
+        const value = unwrap(property.value);
+        returnObjects = !(value.type === import_utils11.AST_NODE_TYPES.Literal && value.value === false);
+      }
+    }
+    return { namespaces, plural, context: context2, returnObjects };
+  }
+  function qualify(raw, binding, optionNamespaces) {
+    const { nsSeparator, keySeparator } = settings;
+    if (nsSeparator !== false && raw.includes(nsSeparator)) {
+      if (binding.keyPrefix !== null) return null;
+      const [head = "", ...rest] = raw.split(nsSeparator);
+      if (head !== "" && rest.length > 0) {
+        return { namespaces: [head], key: rest.join(keySeparator === false ? nsSeparator : keySeparator) };
+      }
+    }
+    const namespaces = optionNamespaces ?? binding.namespaces;
+    if (binding.keyPrefix === null || binding.keyPrefix === "") return { namespaces, key: raw };
+    return { namespaces, key: `${binding.keyPrefix}${keySeparator === false ? "" : keySeparator}${raw}` };
+  }
+  function emit(node, keyNode, binding, options) {
+    const inner = unwrap(keyNode);
+    const raws = [];
+    const single = staticString(inner);
+    if (single !== null) {
+      raws.push(single);
+    } else if (inner.type === import_utils11.AST_NODE_TYPES.ArrayExpression && inner.elements.length > 0) {
+      for (const element of inner.elements) {
+        const value = element === null || element.type === import_utils11.AST_NODE_TYPES.SpreadElement ? null : staticString(element);
+        if (value === null) {
+          onUsage({ kind: "dynamic", node });
+          return;
+        }
+        raws.push(value);
+      }
+    } else if (inner.type === import_utils11.AST_NODE_TYPES.TemplateLiteral) {
+      const head = inner.quasis[0]?.value.cooked ?? "";
+      const qualified = head === "" ? null : qualify(head, binding, options.namespaces);
+      if (qualified === null) {
+        onUsage({ kind: "dynamic", node });
+      } else {
+        onUsage({ kind: "prefix", node, namespaces: qualified.namespaces, prefix: qualified.key });
+      }
+      return;
+    } else {
+      onUsage({ kind: "dynamic", node });
+      return;
+    }
+    let namespaces = null;
+    const keys = [];
+    for (const raw of raws) {
+      const qualified = qualify(raw, binding, options.namespaces);
+      if (qualified === null || raw === "") {
+        onUsage({ kind: "unresolved", node });
+        return;
+      }
+      if (namespaces !== null && namespaces.join("\0") !== qualified.namespaces.join("\0")) {
+        onUsage({ kind: "unresolved", node });
+        return;
+      }
+      namespaces = qualified.namespaces;
+      keys.push(qualified.key);
+    }
+    onUsage({
+      kind: "key",
+      node,
+      namespaces: namespaces ?? binding.namespaces,
+      keys,
+      plural: options.plural,
+      context: options.context,
+      returnObjects: options.returnObjects
+    });
+  }
+  function jsxAttributeValue(attribute) {
+    const value = attribute.value;
+    if (value === null) return null;
+    if (value.type === import_utils11.AST_NODE_TYPES.JSXExpressionContainer) {
+      return value.expression.type === import_utils11.AST_NODE_TYPES.JSXEmptyExpression ? null : value.expression;
+    }
+    return value;
+  }
+  return {
+    CallExpression(node) {
+      const binding = bindingOfCallee(node.callee);
+      if (binding === null) return;
+      const [keyArg, secondArg, thirdArg] = node.arguments;
+      if (keyArg === void 0) return;
+      if (binding === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyArg });
+        return;
+      }
+      const optionsArg = secondArg !== void 0 && staticString(secondArg) !== null ? thirdArg : secondArg;
+      const options = readCallOptions(optionsArg);
+      if (options === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyArg });
+        return;
+      }
+      emit(keyArg, keyArg, binding, options);
+    },
+    JSXOpeningElement(node) {
+      if (node.name.type !== import_utils11.AST_NODE_TYPES.JSXIdentifier || !settings.transComponents.has(node.name.name)) return;
+      const attributes = /* @__PURE__ */ new Map();
+      for (const attribute of node.attributes) {
+        if (attribute.type === import_utils11.AST_NODE_TYPES.JSXSpreadAttribute) {
+          onUsage({ kind: "unresolved", node });
+          return;
+        }
+        if (attribute.name.type === import_utils11.AST_NODE_TYPES.JSXIdentifier) attributes.set(attribute.name.name, attribute);
+      }
+      const keyAttribute = attributes.get("i18nKey");
+      const keyNode = keyAttribute === void 0 ? null : jsxAttributeValue(keyAttribute);
+      if (keyNode === null) return;
+      let binding = defaultBinding;
+      const tAttribute = attributes.get("t");
+      const tNode = tAttribute === void 0 ? null : jsxAttributeValue(tAttribute);
+      if (tNode !== null) {
+        binding = tNode.type === import_utils11.AST_NODE_TYPES.Identifier ? bindingOfIdentifier(tNode) : UNRESOLVED;
+      }
+      let namespaces = null;
+      const nsAttribute = attributes.get("ns");
+      const nsNode = nsAttribute === void 0 ? null : jsxAttributeValue(nsAttribute);
+      if (nsNode !== null) {
+        const resolved = resolveNamespaces(nsNode);
+        if (resolved === UNRESOLVED) binding = UNRESOLVED;
+        else namespaces = resolved;
+      }
+      if (binding === null || binding === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyNode });
+        return;
+      }
+      emit(keyNode, keyNode, binding, {
+        namespaces,
+        plural: attributes.has("count"),
+        context: attributes.has("context"),
+        returnObjects: false
+      });
+    }
+  };
+}
+
+// src/rules/translation-key-exists.ts
+var RULE_NAME11 = "translation-key-exists";
+var stringList = { type: "array", items: { type: "string", minLength: 1 }, uniqueItems: true };
+var separator = { oneOf: [{ type: "string", minLength: 1 }, { type: "boolean", enum: [false] }] };
+var optionSchema9 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    catalogs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["file"],
+        properties: {
+          file: { type: "string", minLength: 1 },
+          namespace: { type: "string", minLength: 1 },
+          keyPath: { type: "string", minLength: 1 }
+        }
+      }
+    },
+    defaultNamespace: { type: "string", minLength: 1 },
+    fallbackNamespaces: stringList,
+    hooks: stringList,
+    instances: stringList,
+    functions: stringList,
+    typeNames: stringList,
+    transComponents: stringList,
+    namespaceIdentifiers: { type: "object", additionalProperties: { type: "string", minLength: 1 } },
+    nsSeparator: separator,
+    keySeparator: separator,
+    pluralSeparator: { type: "string", minLength: 1 },
+    contextSeparator: { type: "string", minLength: 1 },
+    dynamicKeys: { type: "string", enum: ["ignore", "check-prefix"] }
+  }
+};
+var TRANSLATION_DEFAULTS = {
+  defaultNamespace: "translation",
+  hooks: ["useTranslation"],
+  instances: ["i18n", "i18next"],
+  functions: ["t"],
+  typeNames: ["TFunction"],
+  transComponents: ["Trans"],
+  nsSeparator: ":",
+  keySeparator: ".",
+  pluralSeparator: "_",
+  contextSeparator: "_"
+};
+function translationSettingsOf(options) {
+  return {
+    hooks: new Set(options.hooks ?? TRANSLATION_DEFAULTS.hooks),
+    instances: new Set(options.instances ?? TRANSLATION_DEFAULTS.instances),
+    functions: new Set(options.functions ?? TRANSLATION_DEFAULTS.functions),
+    typeNames: new Set(options.typeNames ?? TRANSLATION_DEFAULTS.typeNames),
+    transComponents: new Set(options.transComponents ?? TRANSLATION_DEFAULTS.transComponents),
+    namespaceIdentifiers: options.namespaceIdentifiers ?? {},
+    defaultNamespace: options.defaultNamespace ?? TRANSLATION_DEFAULTS.defaultNamespace,
+    nsSeparator: options.nsSeparator ?? TRANSLATION_DEFAULTS.nsSeparator,
+    keySeparator: options.keySeparator ?? TRANSLATION_DEFAULTS.keySeparator
+  };
+}
+var translationKeyExistsRule = createRule({
+  name: RULE_NAME11,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require every static i18next / react-i18next translation key (`t(...)`, `i18n.t(...)`, `<Trans i18nKey>`) to exist in the catalog of the namespace in scope."
+    },
+    schema: [optionSchema9],
+    messages: {
+      missingKey: "Translation key `{{key}}` does not exist in namespace `{{namespace}}` ({{catalogs}}). It renders as the raw key at runtime: fix the key or add it to the catalog.",
+      missingKeyPrefix: "No key in namespace `{{namespace}}` ({{catalogs}}) starts with `{{prefix}}`, so this template key can never resolve.",
+      unknownNamespace: "Namespace `{{namespace}}` has no catalog in the rule configuration. Fix the namespace name or add a `catalogs` entry for it.",
+      catalogUnreadable: "Translation catalog could not be loaded: {{reason}}."
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options]) {
+    const sources = options.catalogs ?? [];
+    if (sources.length === 0) {
+      return {};
+    }
+    const settings = translationSettingsOf(options);
+    const fallbackNamespaces = options.fallbackNamespaces ?? [];
+    const catalogSettings = {
+      cwd: context.cwd,
+      defaultNamespace: settings.defaultNamespace,
+      keySeparator: settings.keySeparator
+    };
+    const lookupBase = {
+      pluralSeparator: options.pluralSeparator ?? TRANSLATION_DEFAULTS.pluralSeparator,
+      contextSeparator: options.contextSeparator ?? TRANSLATION_DEFAULTS.contextSeparator
+    };
+    const checkPrefix = options.dynamicKeys === "check-prefix";
+    const resolved = /* @__PURE__ */ new Map();
+    const reportedErrors = /* @__PURE__ */ new Set();
+    function catalogsOf(namespace) {
+      let entry = resolved.get(namespace);
+      if (entry === void 0) {
+        entry = catalogsForNamespace(namespace, sources, catalogSettings);
+        resolved.set(namespace, entry);
+      }
+      return entry;
+    }
+    function searched(node, namespaces) {
+      const catalogs = [];
+      for (const namespace of [...namespaces, ...fallbackNamespaces]) {
+        const entry = catalogsOf(namespace);
+        for (const reason of entry.errors) {
+          if (!reportedErrors.has(reason)) {
+            reportedErrors.add(reason);
+            context.report({ node, messageId: "catalogUnreadable", data: { reason } });
+          }
+        }
+        if (entry.errors.length > 0) return null;
+        catalogs.push(...entry.catalogs);
+      }
+      if (catalogs.length === 0) {
+        context.report({ node, messageId: "unknownNamespace", data: { namespace: namespaces.join("`, `") } });
+        return null;
+      }
+      return catalogs;
+    }
+    const labels = (catalogs) => catalogs.map((catalog) => catalog.label).join(", ");
+    return createTranslationVisitor(context, settings, (usage) => {
+      if (usage.kind === "key") {
+        const catalogs = searched(usage.node, usage.namespaces);
+        if (catalogs === null) return;
+        const lookup = { ...lookupBase, plural: usage.plural, context: usage.context, returnObjects: usage.returnObjects };
+        const found = usage.keys.some((key) => catalogs.some((catalog) => catalogHasKey(catalog, key, lookup)));
+        if (!found) {
+          context.report({
+            node: usage.node,
+            messageId: "missingKey",
+            data: { key: usage.keys.join("` | `"), namespace: usage.namespaces.join("`, `"), catalogs: labels(catalogs) }
+          });
+        }
+        return;
+      }
+      if (usage.kind === "prefix" && checkPrefix) {
+        const catalogs = searched(usage.node, usage.namespaces);
+        if (catalogs === null) return;
+        if (!catalogs.some((catalog) => catalogHasPrefix(catalog, usage.prefix))) {
+          context.report({
+            node: usage.node,
+            messageId: "missingKeyPrefix",
+            data: { prefix: usage.prefix, namespace: usage.namespaces.join("`, `"), catalogs: labels(catalogs) }
+          });
+        }
+      }
+    });
+  }
+});
+
 // src/rules/wire-message-naming.ts
-var RULE_NAME9 = "wire-message-naming";
+var RULE_NAME12 = "wire-message-naming";
 var DEFAULT_ROLE_SUFFIXES = ["Event", "Command", "Query"];
-var optionSchema7 = {
+var optionSchema10 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -810,14 +2133,14 @@ function typeLiteralNode(obj) {
   return null;
 }
 var wireMessageNamingRule = createRule({
-  name: RULE_NAME9,
+  name: RULE_NAME12,
   meta: {
     type: "problem",
     docs: {
       description: "A message-schema const ending in a role suffix (default Event/Command/Query) whose zod object declares `type: z.literal(...)` must set that literal to kebab-case(const name minus its role suffix)."
     },
     fixable: "code",
-    schema: [optionSchema7],
+    schema: [optionSchema10],
     messages: {
       typeMismatch: "Wire `type` literal '{{actual}}' for `{{name}}` must be '{{expected}}' \u2014 kebab-case of the const name minus its role suffix."
     }
@@ -853,11 +2176,11 @@ var wireMessageNamingRule = createRule({
 });
 
 // src/rules/zod-schema-naming.ts
-var RULE_NAME10 = "zod-schema-naming";
+var RULE_NAME13 = "zod-schema-naming";
 var SCHEMA_NAME = /^[A-Z][A-Za-z0-9]*Schema$/;
 var SUFFIX = "Schema";
 var DEFAULT_ROLE_SUFFIXES2 = [];
-var optionSchema8 = {
+var optionSchema11 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -890,13 +2213,13 @@ function rootIdentifierName(node) {
   return null;
 }
 var zodSchemaNamingRule = createRule({
-  name: RULE_NAME10,
+  name: RULE_NAME13,
   meta: {
     type: "problem",
     docs: {
       description: "Every exported zod schema is a PascalCase const suffixed `Schema`, paired with a same-named inferred type (`export type Foo = z.infer<typeof FooSchema>`)."
     },
-    schema: [optionSchema8],
+    schema: [optionSchema11],
     messages: {
       schemaNaming: "Exported zod schema `{{name}}` must be a PascalCase const ending in `Schema` (e.g. `FooSchema`).",
       missingType: "Schema `{{name}}` has no sibling `export type {{base}} = z.infer<typeof {{name}}>`. Export the inferred type instead of hand-authoring a duplicate."
@@ -957,12 +2280,15 @@ var rules = {
   "restrict-throw-to-taxonomy": restrictThrowToTaxonomyRule,
   "require-registered-keys": requireRegisteredKeysRule,
   "env-var-schema-parity": envVarSchemaParityRule,
-  "require-schema-parse-at-boundary": requireSchemaParseAtBoundaryRule
+  "require-schema-parse-at-boundary": requireSchemaParseAtBoundaryRule,
+  "schema-enum-field-consistency": schemaEnumFieldConsistencyRule,
+  "fetch-must-check-ok": fetchMustCheckOkRule,
+  "translation-key-exists": translationKeyExistsRule
 };
 
 // src/index.ts
 var NAMESPACE = "noctcore-contracts";
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 var plugin = {
   meta: { name: "@noctcore/eslint-plugin-contracts", version: VERSION },
   rules,