@skapxd/eslint-opinionated 0.16.0 → 0.18.0

package/README.md

@@ -748,6 +748,19 @@ export default [
 ];
 ```
 
+Para librerías npm escritas en TypeScript (tsup o equivalente). Trae las
+bases completas + el set type-driven (tipado, con `projectService`) +
+`await-requires-result` + el contrato de empaquetado:
+
+- `skapxd/package-requires-typed-exports` — los `exports` del package.json
+  cablean los tipos **por condición** (`import` → `.d.mts`, `require` →
+  `.d.ts`); el `types` único por subpath es el bug "FalseCJS".
+- `skapxd/untrusted-module-requires-adapter` — inerte hasta que declares tu
+  inventario de paquetes con tipos mentirosos (ver su sección).
+
+**Este mismo repo se lintea con este preset** — dogfood: la regla de exports
+nos obligó a corregir nuestro propio package.json al nacer.
+
 ### Strict (sin escape via `eslint-disable`)
 
 Un prompt o un agente puede saltarse cualquier regla con
@@ -818,6 +831,7 @@ de cada regla):
 | `nest-validation-pipe-config` | `allowFilePatterns` (globs), `requiredPipeOptions` (default `["transform", "whitelist"]`) |
 | `no-deep-relative-imports` | `maxDepth` |
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
+| `no-anonymous-condition` | `allowFilePatterns` (globs), `maxMemberDepth` (default `2`), `allowTypePredicates` (default `true`, type-aware) |
 | `no-else` | `allowFilePatterns` (globs) |
 | `no-emoji` | `allowFilePatterns` (globs) |
 | `no-explicit-any` | las de la regla original de typescript-eslint (`fixToUnknown`, ...) |
@@ -831,7 +845,9 @@ de cada regla):
 | `no-runtime-state-guard` | `allowFilePatterns` (globs) |
 | `no-tunnel-props` | `allowFilePatterns` (globs), `allowPropPatterns` (regex) |
 | `prefer-abort-signal` | `allowFilePatterns` (globs), `effectNames` (default `["useEffect", "useLayoutEffect"]`) |
+| `package-requires-typed-exports` | `allowFilePatterns` (globs), `anchorFilePatterns` (default `src/index.ts(x)`, `src/main.ts`) |
 | `prefer-tagged-union-state` | `allowFilePatterns` (globs), `loadingPatterns` (regex, en minúsculas), `errorPatterns` (regex, en minúsculas) |
+| `untrusted-module-requires-adapter` | `modules` (default `[]` — inerte), `adapterFilePatterns` (globs), `allowFilePatterns` (globs) |
 | `requires-strict-tsconfig` | `allowFilePatterns` (globs), `anchorFilePatterns` (globs), `requiredCompilerOptions` |
 | `result-error-requires-handling` | `allowFilePatterns` (globs) |
 
@@ -864,6 +880,7 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `skapxd/nest-no-swagger-in-controllers` | Los controllers no se llenan de decoradores de swagger; el plugin introspecciona los DTOs. Preset `nest`. |
 | `skapxd/nest-requires-swagger-plugin` | `nest-cli.json` debe tener el plugin `@nestjs/swagger`: la premisa de las reglas de swagger, verificada. Preset `nest`. |
 | `skapxd/nest-validation-pipe-config` | Todo `new ValidationPipe` configura `transform` y `whitelist`: la premisa de las reglas de DTOs. Preset `nest`. |
+| `skapxd/no-anonymous-condition` | El `if` solo acepta condiciones ya nombradas; todo cómputo (llamada, comparación, `&&`/`||`) se extrae a una `const` con nombre semántico. **Opt-in: no está en ningún preset.** |
 | `skapxd/no-deep-relative-imports` | Limita la profundidad de los imports relativos (`../`). |
 | `skapxd/no-default-export` | Prohíbe `export default`; el nombre del símbolo es el contrato. Exime configs/stories y, en el preset `next`, los entrypoints del App Router. |
 | `skapxd/no-else` | Prohíbe `else`/`else if`: el else es el estado sin nombre. Retorno anticipado, ternario simple o `match()`. |
@@ -883,6 +900,8 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `skapxd/no-try-catch` | Prohíbe `try/catch`; usa `trySafe` de `@skapxd/result`. |
 | `skapxd/no-promise-chain` | Prohíbe `.then/.catch/.finally`; usa `await` (+ `trySafe`). |
 | `skapxd/prefer-ts-pattern` | Prohíbe `switch` y ternarios anidados; usa `match()` de ts-pattern. |
+| `skapxd/package-requires-typed-exports` | Los `exports` del package.json declaran `types` por condición (`import` → `.d.mts`, `require` → `.d.ts`): mata el bug FalseCJS. Preset `package`. |
+| `skapxd/untrusted-module-requires-adapter` | Los paquetes con tipos mentirosos (@types desfasados) solo se importan desde su adaptador: la mentira vive en UN archivo. Preset `package`. |
 | `skapxd/no-jsx-ternary-null` | Prefiere `cond && <El />` sobre `cond ? <El /> : null` en JSX. |
 
 ### `skapxd/one-root-function-per-file`
@@ -1643,6 +1662,57 @@ por indirección tampoco escapa. Solo aplica a clases con `@Controller`
 (configurable con `controllerDecoratorNames` para decoradores propios); los
 services retornan Result con orgullo — ese es el dominio.
 
+### `skapxd/no-anonymous-condition`
+
+La hermana de `no-else`: esa nombra los **caminos**, esta nombra la
+**pregunta**. Un `if` cuya condición es un cómputo evalúa un valor anónimo
+cuyo significado vive solo en la cabeza de quien lo escribió; la regla exige
+bautizarlo (el refactor "introduce explaining variable" de Fowler, como ley):
+
+```ts
+if (matchesAnyGlob(filename, options.allowFilePatterns)) { ... }   // ❌ ¿qué significa que matchee?
+
+const esArchivoExento = matchesAnyGlob(filename, options.allowFilePatterns);
+if (esArchivoExento) { ... }                                       // ✅ la decisión se lee como prosa
+```
+
+Lo **ya nombrado** no se extrae (la lista blanca — extraerlo sería ceremonia
+sin información):
+
+- Variables y sus negaciones: `isReady`, `!isReady`, `!!isReady`.
+- Accesos a propiedad hasta `maxMemberDepth` saltos (contando puntos desde
+  la base como nivel 0: `result.ok` → 1, `options.rules.flag` → 2; default
+  `2`) y sus negaciones — incluido el encadenamiento opcional (`config?.flag`).
+- Comparaciones contra literal booleano o nullish (`x.ok === false`,
+  `x == null`, `x !== undefined`): la escritura explícita de la
+  afirmación/negación/presencia. Cubre las formas oficiales del guard de
+  Result, que `result-error-requires-cause/handling` necesitan ver intactas.
+- **Type guards demostrados por la firma** (`allowTypePredicates`, default
+  `true`): `if (isFunctionNode(x))` pasa cuando la firma declara
+  `x is FunctionNode` — el type-checker lo demuestra (evidencia, no
+  convención de nombre: una `isX(...)` que devuelve `boolean` a secas sí se
+  extrae). Requiere type info; sin parser services no hay evidencia y toda
+  llamada exige nombre. `Result.isErr(x)` pasa por esta vía: es un type
+  predicate real.
+
+Lo que **sí dispara**: llamadas, comparaciones (`a.length <= b.max`,
+`status === "ready"`), combinaciones `&&`/`||` y aritmética
+(`if (total % 2)`). La extracción directa a `const` conserva el narrowing
+(TS 4.4+, aliased conditions).
+
+**Opt-in deliberado: no está en ningún preset.** La calibración contra 4
+proyectos reales (2026-06-12) midió 473/95/308 hallazgos en tres backends
+NestJS en producción y 44 en un front pequeño — señal genuina en la muestra
+revisada, pero un orden de magnitud más invasiva que cualquier regla de las
+bases. Actívala por proyecto (o por carpeta, estilo ola 3 del playbook de
+adopción):
+
+```js
+rules: {
+  "skapxd/no-anonymous-condition": "error",
+}
+```
+
 ### `skapxd/no-deep-relative-imports`
 
 Limita cuántos niveles puede subir un import relativo. Por defecto **prohíbe
@@ -2229,6 +2299,68 @@ no puede traer `signal`.
 `effectNames` permite cubrir wrappers propios (`["useEffect",
 "useLayoutEffect", "useIsomorphicEffect"]`).
 
+### `skapxd/package-requires-typed-exports`
+
+El contrato de empaquetado de una librería TypeScript dual (ESM + CJS): cada
+condición del mapa `exports` declara **sus propios tipos**, del sabor
+correcto.
+
+```jsonc
+"exports": {
+  ".": {
+    "import": { "types": "./dist/index.d.mts", "default": "./dist/index.mjs" },
+    "require": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+  }
+}
+```
+
+El antipatrón que mata es el **"FalseCJS"** (el hallazgo #1 de
+[arethetypeswrong](https://arethetypeswrong.github.io)): un `types` único por
+subpath apuntando al `.d.ts` — los consumidores ESM con
+`moduleResolution: node16` reciben tipos CJS y el contrato miente en la
+frontera más pública que tiene una librería. tsup con `dts: true` ya genera
+los dos sabores (`.d.mts` y `.d.ts`); esta regla verifica que el package.json
+de verdad los cablee y que los archivos existan en disco. Anclada al
+entrypoint (`src/index.ts` por defecto): un reporte por paquete.
+
+Dogfood: esta regla nació reportando a este mismo repo — nuestros `exports`
+tenían el bug y el lint no volvió a verde hasta corregirlos.
+
+### `skapxd/untrusted-module-requires-adapter`
+
+¿Qué pasa cuando los tipos de un paquete de terceros **mienten**? El clásico:
+un paquete escrito en JS cuyos tipos viven aparte (`@types/...`) y van
+desfasados del runtime real, o índices que juran nunca devolver `undefined`.
+Todo el sistema de este paquete descansa en que el tipo dice la verdad
+(`no-impossible-branch` le cree ciegamente) — un tipo mentiroso envenena cada
+regla type-aware que lo toque.
+
+El playbook, en orden:
+
+1. **Armadura de tsconfig primero**: `noUncheckedIndexedAccess` corrige de
+   raíz la clase más común de mentira (index signatures optimistas) sin
+   tocar al tercero — `requires-strict-tsconfig` ya lo exige.
+2. **Frontera anticorrupción** (lo que esta regla impone): declara el módulo
+   como no confiable y enciérralo tras UN adaptador. El adaptador importa el
+   paquete, re-declara los tipos honestos (lo que el runtime de verdad
+   devuelve) y exporta esa versión. El resto del código importa el adaptador
+   y razona con tipos veraces — la mentira queda en un archivo auditable.
+3. **`@ts-expect-error` con descripción** dentro del adaptador si hace falta
+   forzar la corrección — es la puerta que `no-silenced-compiler` deja
+   abierta, declarada y con porqué.
+4. **Arregla el upstream**: PR a DefinitelyTyped. Mientras llega, los pasos
+   1-3 te protegen.
+
+```js
+"skapxd/untrusted-module-requires-adapter": ["error", {
+  adapterFilePatterns: ["src/lib/xlsx-adapter.ts"],
+  modules: ["xlsx"],
+}]
+```
+
+Sin `modules` declarados la regla es inerte: el inventario de sospechosos es
+una decisión del proyecto, no una adivinanza del linter (axioma A5).
+
 ### `skapxd/no-jsx-ternary-null`
 
 Cuando renderizas JSX condicional y una rama del ternario es `null`, prefiere la

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
 import {
   createAstroConfigs
-} from "../chunk-7OIMY5TI.mjs";
-import "../chunk-4FQ7SFU4.mjs";
+} from "../chunk-GSQWHSHV.mjs";
+import "../chunk-QDQUU6QK.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-LSLLVT64.mjs → chunk-3GEFHNU7.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createTypedLanguageOptions,
   typeDrivenRules
-} from "./chunk-4FQ7SFU4.mjs";
+} from "./chunk-QDQUU6QK.mjs";
 
 // src/constants/nest-entrypoint-file-patterns.ts
 var nestEntrypointFilePatterns = [
@@ -130,4 +130,4 @@ function createNestConfigs(pluginReference) {
 export {
   createNestConfigs
 };
-//# sourceMappingURL=chunk-LSLLVT64.mjs.map
+//# sourceMappingURL=chunk-3GEFHNU7.mjs.map

package/dist/{chunk-YRWX3POD.mjs → chunk-54EOEKYS.mjs}

@@ -6,7 +6,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-4FQ7SFU4.mjs";
+} from "./chunk-QDQUU6QK.mjs";
 
 // src/next/configs.ts
 var nextDefaultExportFileGlob = `{${[
@@ -71,4 +71,4 @@ function createNextConfigs(pluginReference) {
 export {
   createNextConfigs
 };
-//# sourceMappingURL=chunk-YRWX3POD.mjs.map
+//# sourceMappingURL=chunk-54EOEKYS.mjs.map

package/dist/{chunk-X2DU5BAB.mjs → chunk-77A4SFGD.mjs}

@@ -2652,6 +2652,157 @@ var noDefaultExport = {
   }
 };
 
+// src/utils/call-has-type-predicate.ts
+function callHasTypePredicate(node, parserServices) {
+  const tsNode = parserServices?.esTreeNodeToTSNodeMap?.get(node);
+  const program = parserServices?.program;
+  if (tsNode === void 0 || program === null || program === void 0) {
+    return false;
+  }
+  const checker = program.getTypeChecker();
+  const signature = checker.getResolvedSignature(
+    tsNode
+  );
+  if (signature === void 0) {
+    return false;
+  }
+  return checker.getTypePredicateOfSignature(signature) !== void 0;
+}
+
+// src/utils/get-member-chain-depth.ts
+function getMemberChainDepth(node) {
+  let current = node.type === "ChainExpression" && node.expression !== void 0 ? node.expression : node;
+  let depth = 0;
+  while (current.type === "MemberExpression") {
+    depth += 1;
+    if (current.object === void 0) {
+      return null;
+    }
+    current = current.object;
+  }
+  if (current.type === "Identifier" || current.type === "ThisExpression") {
+    return depth;
+  }
+  return null;
+}
+
+// src/utils/get-no-anonymous-condition-options.ts
+function getNoAnonymousConditionOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    // Permitir llamadas cuya firma el type-checker demuestra como type
+    // predicate (`x is T`). Sin type info, no hay evidencia y no aplica.
+    allowTypePredicates: options.allowTypePredicates ?? true,
+    // Saltos de propiedad permitidos en la lista blanca, contando desde la
+    // base como nivel 0: `result.ok` → 1, `options.rules.flag` → 2.
+    maxMemberDepth: options.maxMemberDepth ?? 2
+  };
+}
+
+// src/utils/is-guard-literal.ts
+function isGuardLiteral(node) {
+  if (node.type === "Literal") {
+    return typeof node.value === "boolean" || node.value === null;
+  }
+  return node.type === "Identifier" && node.name === "undefined";
+}
+
+// src/utils/is-literal-guard-comparison.ts
+var guardOperators = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
+function isLiteralGuardComparison(node, maxMemberDepth) {
+  if (node.type !== "BinaryExpression") {
+    return false;
+  }
+  if (node.operator === void 0 || !guardOperators.has(node.operator)) {
+    return false;
+  }
+  const { left, right } = node;
+  if (left === void 0 || right === void 0) {
+    return false;
+  }
+  const leftIsGuard = isGuardLiteral(left);
+  const rightIsGuard = isGuardLiteral(right);
+  if (!leftIsGuard && !rightIsGuard) {
+    return false;
+  }
+  const namedSide = leftIsGuard ? right : left;
+  const depth = getMemberChainDepth(namedSide);
+  return depth !== null && depth <= maxMemberDepth;
+}
+
+// src/utils/unwrap-negations.ts
+function unwrapNegations(node) {
+  let current = node;
+  while (current.type === "UnaryExpression" && current.operator === "!" && current.argument !== void 0) {
+    current = current.argument;
+  }
+  return current;
+}
+
+// src/rules/no-anonymous-condition.ts
+var noAnonymousCondition = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "La condicion sin nombre: el if solo acepta condiciones ya nombradas (variables, accesos acotados, type guards demostrados); todo computo se extrae a una const con nombre semantico."
+    },
+    messages: {
+      anonymousCondition: "La condicion sin nombre: este if evalua un computo cuyo significado el lector debe deducir. Extraelo a una const con nombre semantico y la decision se lee como prosa: `const esArchivoExento = matchesAnyGlob(archivo, patrones); if (esArchivoExento) ...`. La extraccion directa a const conserva el narrowing (TS 4.4+). Lo ya-nombrado no se extrae: variables (`isReady`), accesos como `result.ok` (hasta {{maxMemberDepth}} saltos), sus negaciones (`!result.ok`), comparaciones con literal booleano o nullish (`x.ok === false`, `x == null`) y type guards que la firma demuestra (`x is T`)."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          allowTypePredicates: {
+            type: "boolean"
+          },
+          maxMemberDepth: {
+            type: "number"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getNoAnonymousConditionOptions(
+      context.options[0]
+    );
+    const filename = context.filename ?? context.getFilename?.() ?? "";
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
+      return {};
+    }
+    return {
+      IfStatement(node) {
+        const condition = unwrapNegations(node.test);
+        if (condition.type === "Literal") {
+          return;
+        }
+        const depth = getMemberChainDepth(condition);
+        if (depth !== null && depth <= options.maxMemberDepth) {
+          return;
+        }
+        if (isLiteralGuardComparison(condition, options.maxMemberDepth)) {
+          return;
+        }
+        const isProvenTypeGuard = condition.type === "CallExpression" && options.allowTypePredicates && callHasTypePredicate(condition, context.sourceCode?.parserServices);
+        if (isProvenTypeGuard) {
+          return;
+        }
+        context.report({
+          data: { maxMemberDepth: String(options.maxMemberDepth) },
+          messageId: "anonymousCondition",
+          node: node.test
+        });
+      }
+    };
+  }
+};
+
 // src/utils/get-no-else-options.ts
 function getNoElseOptions(options = {}) {
   return {
@@ -2761,8 +2912,14 @@ var noEmoji = {
 
 // src/utils/wrap-tseslint-rule.ts
 import tseslint from "typescript-eslint";
+var upstreamRules = tseslint.plugin.rules;
 function wrapTseslintRule(upstreamRuleName, { description, messages }) {
-  const original = tseslint.plugin.rules[upstreamRuleName];
+  const original = upstreamRules[upstreamRuleName];
+  if (!original) {
+    throw new Error(
+      `wrapTseslintRule: la regla "${upstreamRuleName}" no existe en typescript-eslint.`
+    );
+  }
   return {
     ...original,
     meta: {
@@ -2856,7 +3013,10 @@ function getNoTunnelPropsOptions(options = {}) {
 
 // src/utils/get-object-pattern-prop-names.ts
 function getObjectPatternPropNames(pattern) {
-  const result = { propNames: [], restName: null };
+  const result = {
+    propNames: [],
+    restName: null
+  };
   if (pattern?.type !== "ObjectPattern") {
     return result;
   }
@@ -3494,7 +3654,7 @@ function readResolvedTsconfig(tsconfigPath) {
   if (!parsed.ok || !parsed.value) {
     return null;
   }
-  return parsed.value.options ?? null;
+  return parsed.value.options;
 }
 
 // src/rules/requires-strict-tsconfig.ts
@@ -3841,6 +4001,212 @@ var noRuntimeStateGuard = {
   }
 };
 
+// src/rules/package-requires-typed-exports.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname6, resolve as resolve3 } from "path";
+import { trySafe as trySafe4 } from "@skapxd/result";
+
+// src/utils/get-typed-exports-options.ts
+function getTypedExportsOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    // Anclada al entrypoint de la libreria: un reporte por paquete.
+    anchorFilePatterns: options.anchorFilePatterns ?? [
+      "src/index.ts",
+      "src/index.tsx",
+      "src/main.ts"
+    ]
+  };
+}
+
+// src/utils/get-untyped-export-conditions.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function getUntypedExportConditions(exportsField, packageDir) {
+  const violations = [];
+  const entries = "import" in exportsField || "require" in exportsField ? [[".", exportsField]] : Object.entries(exportsField);
+  for (const [subpath, value] of entries) {
+    if (subpath === "./package.json") {
+      continue;
+    }
+    if (typeof value === "string") {
+      violations.push({ kind: "untyped", condition: "todas", subpath });
+      continue;
+    }
+    for (const condition of ["import", "require"]) {
+      if (!(condition in value)) {
+        continue;
+      }
+      const target = value[condition];
+      if (typeof target !== "object" || typeof target.types !== "string") {
+        violations.push({ kind: "untyped", condition, subpath });
+        continue;
+      }
+      const expectsEsmTypes = condition === "import";
+      const flavorOk = expectsEsmTypes ? target.types.endsWith(".d.mts") : target.types.endsWith(".d.ts") || target.types.endsWith(".d.cts");
+      if (!flavorOk) {
+        violations.push({ kind: "wrong-flavor", condition, subpath });
+        continue;
+      }
+      if (!existsSync3(join3(packageDir, target.types))) {
+        violations.push({ kind: "missing-file", condition, subpath });
+      }
+    }
+  }
+  return violations;
+}
+
+// src/rules/package-requires-typed-exports.ts
+var kindMessages = {
+  "missing-file": "missingTypesFile",
+  untyped: "untypedCondition",
+  "wrong-flavor": "wrongTypesFlavor"
+};
+var packageRequiresTypedExports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "El package.json de una libreria debe cablear los tipos POR CONDICION en exports: import \u2192 .d.mts, require \u2192 .d.ts. Un types unico es el bug FalseCJS."
+    },
+    messages: {
+      missingExports: "El package.json no tiene campo `exports`. Sin el, Node y TypeScript resuelven por heuristicas viejas y los consumidores ESM/CJS pueden recibir artefactos cruzados. Declara el mapa de exports con `types` por condicion.",
+      missingTypesFile: 'En exports["{{subpath}}"].{{condition}}, el archivo de `types` declarado no existe en disco. El contrato apunta a un fantasma: o falta el build (dts) o la ruta esta mal escrita.',
+      unreadablePackageJson: "No encontre un package.json legible subiendo desde este archivo. Esta regla valida el contrato de tipos de la libreria y necesita leerlo.",
+      untypedCondition: 'exports["{{subpath}}"] \u2192 `{{condition}}` no declara su propio `types`. Un `types` unico a nivel del subpath es el bug "FalseCJS": el consumidor ESM con moduleResolution node16 recibe los tipos CJS. Cada condicion declara los suyos \u2014 `import` como objeto con `types: ./dist/x.d.mts` y `default: ./dist/x.mjs`; `require` como objeto con `types: ./dist/x.d.ts` y `default: ./dist/x.js`.',
+      wrongTypesFlavor: 'exports["{{subpath}}"].{{condition}} apunta a tipos del formato equivocado: `import` exige `.d.mts` (tipos ESM) y `require` exige `.d.ts`/`.d.cts` (tipos CJS). tsup con dts: true ya genera ambos sabores.'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          anchorFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getTypedExportsOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    if (matchesAnyGlob(filename, options.allowFilePatterns) || !matchesAnyGlob(filename, options.anchorFilePatterns)) {
+      return {};
+    }
+    return {
+      Program(node) {
+        const absoluteFilename = resolve3(context.cwd ?? process.cwd(), filename);
+        const packageJsonPath = findProjectFile(
+          dirname6(absoluteFilename),
+          "package.json"
+        );
+        const parsed = packageJsonPath ? trySafe4(() => JSON.parse(readFileSync2(packageJsonPath, "utf8"))) : null;
+        if (!parsed || !parsed.ok) {
+          context.report({ messageId: "unreadablePackageJson", node });
+          return;
+        }
+        const exportsField = parsed.value.exports;
+        if (!exportsField || typeof exportsField !== "object") {
+          context.report({ messageId: "missingExports", node });
+          return;
+        }
+        const violations = getUntypedExportConditions(
+          exportsField,
+          dirname6(packageJsonPath)
+        );
+        for (const violation of violations) {
+          context.report({
+            data: {
+              condition: violation.condition,
+              subpath: violation.subpath
+            },
+            messageId: kindMessages[violation.kind],
+            node
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/utils/get-untrusted-module-options.ts
+function getUntrustedModuleOptions(options = {}) {
+  return {
+    // Globs de los archivos adaptador: el UNICO lugar desde donde se permite
+    // importar los modulos declarados como no confiables.
+    adapterFilePatterns: options.adapterFilePatterns ?? [],
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    // Inventario de paquetes cuyos tipos mienten (p. ej. @types desfasados).
+    // Vacio por defecto: la regla es inerte hasta que el proyecto declara
+    // sus sospechosos.
+    modules: options.modules ?? []
+  };
+}
+
+// src/rules/untrusted-module-requires-adapter.ts
+var untrustedModuleRequiresAdapter = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Los modulos declarados como no confiables (tipos que mienten) solo se importan desde su adaptador: la mentira vive en un archivo, no en todos."
+    },
+    messages: {
+      untrustedImport: "`{{moduleSource}}` esta declarado como modulo de tipos NO confiables: importalo solo desde su adaptador ({{adapters}}). El adaptador es la frontera anticorrupcion: re-declara ahi los tipos honestos (lo que el runtime de verdad devuelve) y exporta esa version; el resto del codigo importa el adaptador y razona con tipos veraces. Asi la mentira de terceros vive en UN archivo auditable, no regada por el proyecto."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          adapterFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          modules: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getUntrustedModuleOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    if (options.modules.length === 0 || matchesAnyGlob(filename, options.allowFilePatterns) || matchesAnyGlob(filename, options.adapterFilePatterns)) {
+      return {};
+    }
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        const isUntrusted = options.modules.some(
+          (moduleName) => source === moduleName || source.startsWith(`${moduleName}/`)
+        );
+        if (!isUntrusted) {
+          return;
+        }
+        context.report({
+          data: {
+            adapters: options.adapterFilePatterns.join(", ") || "sin definir",
+            moduleSource: source
+          },
+          messageId: "untrustedImport",
+          node
+        });
+      }
+    };
+  }
+};
+
 // src/shared/rules.ts
 var rules = {
   "class-properties-require-readonly": classPropertiesRequireReadonly,
@@ -3871,6 +4237,7 @@ var rules = {
   "nest-no-swagger-in-controllers": nestNoSwaggerInControllers,
   "nest-requires-swagger-plugin": nestRequiresSwaggerPlugin,
   "nest-validation-pipe-config": nestValidationPipeConfig,
+  "no-anonymous-condition": noAnonymousCondition,
   "no-deep-relative-imports": noDeepRelativeImports,
   "no-default-export": noDefaultExport,
   "no-else": noElse,
@@ -3893,10 +4260,12 @@ var rules = {
   "no-jsx-ternary-null": noJsxTernaryNull,
   "no-nested-if": noNestedIf,
   "no-promise-chain": noPromiseChain,
-  "no-runtime-state-guard": noRuntimeStateGuard
+  "no-runtime-state-guard": noRuntimeStateGuard,
+  "package-requires-typed-exports": packageRequiresTypedExports,
+  "untrusted-module-requires-adapter": untrustedModuleRequiresAdapter
 };
 
 export {
   rules
 };
-//# sourceMappingURL=chunk-X2DU5BAB.mjs.map
+//# sourceMappingURL=chunk-77A4SFGD.mjs.map