@skapxd/eslint-opinionated 0.14.0 → 0.15.0

package/README.md

@@ -98,7 +98,7 @@ la que defiende el axioma más fundamental (el orden es jerárquico).
 
 | # | Axioma | Reglas que lo ejecutan |
 | --- | --- | --- |
-| A1 | **Los estados imposibles son irrepresentables.** El tipo modela exactamente los estados válidos; lo inválido no compila. | `prefer-tagged-union-state`, `no-runtime-state-guard`, `requires-strict-tsconfig`, `@typescript-eslint/no-unnecessary-condition`, `no-explicit-any`, `consistent-type-definitions` |
+| A1 | **Los estados imposibles son irrepresentables.** El tipo modela exactamente los estados válidos; lo inválido no compila. | `prefer-tagged-union-state`, `no-runtime-state-guard`, `requires-strict-tsconfig`, `no-impossible-branch`, `no-explicit-any`, `consistent-type-definitions` |
 | A2 | **Ningún efecto es invisible al tipo.** Si una operación puede fallar, su firma lo confiesa — no una convención oral ni un `throw` sorpresa. | `await-requires-result`, `no-try-catch`, `no-promise-chain`, `no-ad-hoc-ok-result`, `@typescript-eslint/no-floating-promises` |
 | A3 | **La información no se destruye.** Un error que se transforma conserva su `cause`; uno que se detecta llega a alguien. Nadie decide "esto no importa" en silencio. | `result-error-requires-cause`, `result-error-requires-handling` |
 | A4 | **Una unidad, una responsabilidad, un nombre semántico.** El árbol de archivos cuenta una historia; una clase expone una intención. | `one-root-function-per-file`, `max-public-methods`, `no-default-export`, `jsx-return-name-pascal-case`, `max-hook-size` |
@@ -274,6 +274,149 @@ hay errores, sale con código `1` (apto para CI). Como acota por **archivo
 completo**, también dispara las reglas estructurales (p. ej.
 `one-root-function-per-file`), que un filtrado por línea se perdería.
 
+## Adopción en proyectos legacy: de `off` a `error`, por olas
+
+El CLI de arriba acota **qué archivos** se juzgan. Este apartado acota **qué
+reglas** — el camino para meter el preset completo en un proyecto legacy
+escrito por humanos, sin que el primer `pnpm lint` escupa 2.000 errores y el
+equipo apague el linter para siempre.
+
+### Las reglas del juego
+
+1. **`off` o `error`, nunca `warn`.** Un warn se ignora desde el día dos y
+   solo entrena al equipo a ignorar amarillo. Una regla está adoptada
+   (`error`) o todavía no (`off`) — no hay estado intermedio.
+2. **Una regla a la vez, y a cero.** Se activa una regla, se arreglan TODOS
+   sus hallazgos, se mergea en verde. Nunca actives una regla con pendientes:
+   el CI rojo permanente es la ventana rota que normaliza ignorar el linter.
+3. **Ratchet: lo que se enciende no se apaga.** El bloque de `off` solo puede
+   encoger. El diff de ese bloque ES la métrica de progreso del equipo.
+4. **Mide antes de activar.** En una rama, borra el `off` de una regla y corre
+   el lint: el número de hallazgos es el precio. **Activa siempre la más
+   barata pendiente** — el momentum importa más que el orden perfecto.
+5. **Deja que el mensaje enseñe.** Los mensajes de error de estas reglas
+   explican el porqué y el cómo (qué patrón usar, cómo se llama, dónde va).
+   Para un equipo sin seniors, el linter es el code review que nadie tiene
+   tiempo de hacer: no resumas las reglas en un documento aparte — el
+   documento es el error en pantalla.
+
+### El mecanismo: la lista de pendientes
+
+El preset completo es la meta; un bloque posterior apaga lo que el equipo aún
+no cumple. **Adoptar una regla = borrar su línea y arreglar lo que aflore:**
+
+```js
+// eslint.config.js
+import skapxd from "@skapxd/eslint-opinionated";
+
+export default [
+  ...skapxd.configs.nest, // la meta: el preset completo, desde el día uno
+
+  // ─── Lista de pendientes ───────────────────────────────────────────
+  // Todo lo que el proyecto aún no cumple, apagado y a la vista.
+  // Este bloque SOLO ENCOGE: se borra una línea, se arregla, se mergea.
+  {
+    rules: {
+      "skapxd/await-requires-result": "off",
+      "skapxd/no-try-catch": "off",
+      // ...
+    },
+  },
+];
+```
+
+### El orden de las olas
+
+El orden no es arbitrario: va de "cada hallazgo es un bug que ya tienes" hacia
+"esto exige rediseñar tipos", y cada ola deja el suelo que la siguiente pisa.
+
+**Ola 1 — bugs gratis y fixes únicos.** Señal pura, arreglo puntual, cero
+rediseño. Aquí el equipo aprende que el linter encuentra cosas reales:
+
+- `@typescript-eslint/no-floating-promises` — cada hallazgo es un error que
+  hoy muere sin que nadie lo vea (en un backend real en producción: 12).
+- `skapxd/nest-requires-swagger-plugin` y `skapxd/nest-validation-pipe-config`
+  — un hallazgo por proyecto, un fix de configuración, y quedan vigiladas las
+  premisas de las olas siguientes.
+- `skapxd/requires-strict-tsconfig` con la exigencia mínima:
+  `{ requiredCompilerOptions: ["strict"] }`. Es el trinquete del tsconfig —
+  cada ola le sube un flag (ver abajo).
+- `skapxd/no-emoji`, `skapxd/no-deep-relative-imports` — fixes mecánicos.
+- `skapxd/prefer-abort-signal` (front) — cada hallazgo es un leak.
+
+**Ola 2 — la forma del código.** Refactors locales, archivo por archivo, sin
+tocar contratos. Es la ola que más enseña por repetición:
+
+- `skapxd/no-nested-if` y `skapxd/no-else` — guard clauses. El refactor más
+  formativo que existe para un junior: aplana la lógica o confiesa que la
+  función hace demasiado.
+- `skapxd/one-root-function-per-file` y `skapxd/no-default-export` — el árbol
+  de archivos empieza a contar la historia.
+- `skapxd/no-accessors`, `skapxd/max-public-methods` — clases con una
+  intención (partir un god-object es la cirugía mayor de esta ola: déjala de
+  última).
+- Front: `skapxd/jsx-return-name-pascal-case`, `skapxd/max-hook-size`,
+  `skapxd/no-functions-inside-components`, `skapxd/no-jsx-ternary-null`,
+  `skapxd/no-tunnel-props`.
+- Nest: `skapxd/nest-no-swagger-in-controllers`,
+  `skapxd/nest-dto-requires-api-property`,
+  `skapxd/nest-dto-requires-validation`,
+  `skapxd/nest-no-inline-query-params`,
+  `skapxd/nest-no-direct-instantiation` — mover decoradores y dependencias a
+  donde pertenecen.
+
+**Ola 3 — el contrato de errores.** La migración de paradigma
+(`@skapxd/result` + `ts-pattern`; ver "Cómo encaja todo" abajo). Aquí NO se va
+regla por regla sino **módulo por módulo**: las seis reglas entran juntas
+(son un solo sistema) pero acotadas por carpeta, y el primer módulo migrado se
+vuelve el ejemplo canónico que el resto copia:
+
+```js
+  // Ola 3: el pipeline de Result entra carpeta por carpeta.
+  {
+    files: ["src/modules/payments/**"],
+    rules: {
+      "skapxd/await-requires-result": "error",
+      "skapxd/no-try-catch": "error",
+      "skapxd/no-promise-chain": "error",
+      "skapxd/no-ad-hoc-ok-result": "error",
+      "skapxd/prefer-ts-pattern": "error",
+      "skapxd/result-error-requires-cause": "error",
+      "skapxd/result-error-requires-handling": "error",
+    },
+  },
+```
+
+(En Nest, suma `skapxd/nest-no-result-response` al grupo: el controller del
+módulo migrado traduce el Result, no lo serializa.) Cuando todos los módulos
+migraron, las líneas salen del bloque por-carpeta y entran globales: se borran
+de la lista de pendientes.
+
+**Ola 4 — el modelado de estados.** Lo más profundo: exige criterio de
+diseño, no solo disciplina. Para cuando el equipo ya vio el patrón en la ola 3:
+
+- `requires-strict-tsconfig` al máximo: `["strict", "noImplicitReturns",
+  "noUncheckedIndexedAccess"]`. Sube un flag a la vez — cada uno aflora
+  errores de compilación que son bugs latentes, no burocracia.
+- `@typescript-eslint/no-explicit-any`, `no-non-null-assertion` y
+  `ban-ts-comment` — se cierran las tres puertas de escape del compilador.
+- `skapxd/class-properties-require-readonly` — el cambio se modela con
+  instancias nuevas.
+- `skapxd/prefer-tagged-union-state` y `skapxd/no-runtime-state-guard` — los
+  booleanos co-dependientes se vuelven uniones etiquetadas.
+- `skapxd/no-impossible-branch` — **la última de todas**: solo es sólida
+  cuando el tsconfig ya está al máximo (sin `noUncheckedIndexedAccess`,
+  acusaría guards necesarios).
+
+### Los dos ejes se combinan
+
+Mientras la lista de pendientes encoge, `skapxd-lint-changed` aplica lo ya
+activado solo a los archivos tocados: el código nuevo nace cumpliendo y el
+legacy se corrige cuando alguien lo visita (regla del boy scout), no en un
+big-bang. Un proyecto mediano recorre las cuatro olas en semanas, no en
+trimestres — y cada semana el lint encuentra menos, porque el equipo ya
+escribe distinto.
+
 ## Cómo encaja todo: `@skapxd/result` + `ts-pattern`
 
 Este plugin no es una colección de reglas sueltas: es el guardián de un
@@ -676,6 +819,7 @@ de cada regla):
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
 | `no-else` | `allowFilePatterns` (globs) |
 | `no-emoji` | `allowFilePatterns` (globs) |
+| `no-impossible-branch` | las de la regla original de typescript-eslint (`allowConstantLoopConditions`, ...) |
 | `no-functions-inside-components` | `allowJsxCallbacks`, `allowArrayMapCallbacks` (ambas `true` por defecto) |
 | `no-nested-if` | `allowFilePatterns` (globs) |
 | `no-promise-chain` | `methods` |
@@ -719,6 +863,7 @@ matchea en cualquier carpeta). Las 7 reglas restantes no tienen opciones: su
 | `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()`. |
 | `skapxd/no-emoji` | Prohíbe emojis en strings y JSX; cada sistema los renderiza distinto. Usa un icono SVG. |
+| `skapxd/no-impossible-branch` | Condiciones que el type-checker demuestra constantes: la pregunta ya tiene respuesta. Es `@typescript-eslint/no-unnecessary-condition` con nombre semántico y mensajes que enseñan el fix. |
 | `skapxd/no-nested-if` | Prohíbe `if` anidados: retorno anticipado o `match()`. Menos carga cognitiva y sin puntos ciegos para las demás reglas. |
 | `skapxd/no-runtime-state-guard` | Prohíbe `if (this.x) throw` en métodos: el estado inválido se hace irrepresentable en el tipo, no se vigila en runtime. |
 | `skapxd/no-tunnel-props` | Ninguna prop viaja más de un nivel: quien la recibe no puede reenviarla a otro componente. Mata el prop drilling. |
@@ -831,8 +976,12 @@ Todas las opciones, con sus defaults:
 Todo el sistema descansa en que el compilador pueda hacer irrepresentables
 los estados inválidos — y eso exige un `tsconfig` implacable. Esta regla lee
 el `tsconfig.json` **real** del proyecto (con la API de TypeScript: soporta
-JSONC y resuelve la cadena de `extends`) y exige los flags, anclada a un
-entrypoint para reportar una vez por proyecto:
+JSONC y resuelve la cadena de `extends`) y exige los flags, reportando una
+vez por proyecto: si existe un archivo ancla (`anchorFilePatterns`, default
+`src/main.ts(x)`/`src/index.ts(x)`), el reporte le pertenece a ese archivo;
+si el proyecto no tiene entrypoint clásico (Astro, librerías), reporta sobre
+el primer archivo del run y los demás callan — un proyecto sin ancla no se
+queda sin guardián:
 
 - `strict` — sin él, el sistema de tipos está apagado a medias.
 - `noImplicitReturns` — una rama que sale sin valor deja de ser silenciosa
@@ -862,12 +1011,14 @@ Además, los **presets tipados activan reglas curadas de typescript-eslint**
   que tú" dicho al compilador. Si no puede ser nulo, que lo diga el tipo.
   (En `nest/tests` queda apagada: el `!` sobre un fixture cuya existencia el
   propio test garantiza es el arrange, no una mentira.)
-- `@typescript-eslint/no-unnecessary-condition` — la generalización
-  type-aware de `no-runtime-state-guard`: si el tipo dice que un estado es
-  imposible, el guard defensivo sobra; si el guard hace falta, lo que está
-  mal es el tipo. Por eso esta regla y `requires-strict-tsconfig` van
-  juntas: sin `noUncheckedIndexedAccess`, `array[i]` miente y la regla
-  acusaría guards necesarios.
+- `skapxd/no-impossible-branch` — la generalización type-aware de
+  `no-runtime-state-guard`: si el tipo dice que un estado es imposible, el
+  guard defensivo sobra; si el guard hace falta, lo que está mal es el tipo.
+  Es `@typescript-eslint/no-unnecessary-condition` **re-registrada bajo
+  nuestro namespace** (ver su sección): mismo motor, nombre que dice lo que
+  defiende y mensajes que enseñan el fix. Por eso esta regla y
+  `requires-strict-tsconfig` van juntas: sin `noUncheckedIndexedAccess`,
+  `array[i]` miente y la regla acusaría guards necesarios.
 - `@typescript-eslint/ban-ts-comment` — un error de tipos se arregla
   modelando mejor, no silenciando la alarma: `@ts-ignore` y `@ts-nocheck`
   prohibidos. `@ts-expect-error` **con descripción** queda permitido: es la
@@ -1726,6 +1877,36 @@ en un `<input>` es la frontera con el DOM). Para wrappers legítimos de un
 design system, exime props por nombre (`allowPropPatterns: ["^className$"]`)
 o archivos completos (`allowFilePatterns`).
 
+### `skapxd/no-impossible-branch`
+
+La rama imposible: una condición que el type-checker demuestra constante. Si
+el tipo dice que un valor siempre es truthy, ese `if` no decide nada; si un
+`?.` cuelga de algo que nunca es nullish, finge una duda que el modelo ya
+resolvió. La pregunta ya tiene respuesta — y un `if` que no pregunta es
+código muerto disfrazado de prudencia.
+
+```ts
+const sheet = workbook.Sheets[name]; // tipo: WorkSheet (¿seguro?)
+if (!sheet) continue; // ❌ "always falsy"... ¿o el tipo miente?
+```
+
+El mensaje de error enseña la lección completa: **si la comprobación hace
+falta en runtime, lo que está mal es el tipo**. El caso clásico es el acceso
+por índice sin `noUncheckedIndexedAccess` — `array[i]` y `obj[key]` juran que
+nunca son `undefined`, y esta regla, creyéndoles, acusaría guards necesarios.
+Por eso va de la mano de `skapxd/requires-strict-tsconfig`, que exige ese
+flag: primero el tsconfig dice la verdad, después esta regla opina.
+
+Bajo el capó es `@typescript-eslint/no-unnecessary-condition`
+([doc original](https://typescript-eslint.io/rules/no-unnecessary-condition/))
+**re-registrada bajo nuestro namespace**: mismo motor y mismas opciones, pero
+con un nombre que dice lo que defiende (axioma A1: los estados imposibles son
+irrepresentables — es la generalización type-aware de
+`no-runtime-state-guard`) y mensajes en español que explican el fix en vez
+del críptico "Unnecessary conditional". Los presets tipados activan este
+nombre y **no** el original: una sola fuente de verdad para configurarla,
+silenciarla o buscarla.
+
 ### `skapxd/no-functions-inside-components`
 
 Prohíbe definir funciones **con peso propio** dentro de un componente React

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
 import {
   createAstroConfigs
-} from "../chunk-C5JP4FQN.mjs";
-import "../chunk-QR35MHTW.mjs";
+} from "../chunk-DJDXQWCP.mjs";
+import "../chunk-F6GJW5A4.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-C5JP4FQN.mjs → chunk-DJDXQWCP.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-QR35MHTW.mjs";
+} from "./chunk-F6GJW5A4.mjs";
 
 // src/astro/configs.ts
 function createAstroConfigs(pluginReference) {
@@ -41,4 +41,4 @@ function createAstroConfigs(pluginReference) {
 export {
   createAstroConfigs
 };
-//# sourceMappingURL=chunk-C5JP4FQN.mjs.map
+//# sourceMappingURL=chunk-DJDXQWCP.mjs.map

package/dist/{chunk-QR35MHTW.mjs → chunk-F6GJW5A4.mjs}

@@ -78,7 +78,9 @@ var typeDrivenRules = {
   // hace falta, lo que está mal es el tipo. Requiere el tsconfig de
   // requires-strict-tsconfig para ser sólida: sin noUncheckedIndexedAccess,
   // `array[i]` miente y esta regla acusaría guards necesarios.
-  "@typescript-eslint/no-unnecessary-condition": "error"
+  // Es @typescript-eslint/no-unnecessary-condition re-registrada bajo un
+  // nombre que dice lo que defiende, con mensajes que enseñan el fix.
+  "skapxd/no-impossible-branch": "error"
 };
 
 // src/shared/configs/create-shared-configs.ts
@@ -172,4 +174,4 @@ export {
   createSharedConfigs,
   strictConfig
 };
-//# sourceMappingURL=chunk-QR35MHTW.mjs.map
+//# sourceMappingURL=chunk-F6GJW5A4.mjs.map

package/dist/{chunk-QR35MHTW.mjs.map → chunk-F6GJW5A4.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/shared/configs/create-typed-language-options.ts","../src/shared/configs/create-shared-configs.ts","../src/shared/configs/base-rules.ts","../src/shared/configs/create-base-language-options.ts","../src/shared/configs/type-driven-rules.ts","../src/shared/configs/strict-config.ts"],"sourcesContent":["import tseslint from \"typescript-eslint\";\n\nexport function createTypedLanguageOptions() {\n  return {\n    // Sin el parser explícito, un consumidor que use solo estos presets\n    // obtiene \"Parsing error\" en cada archivo TS (espree no parsea TS).\n    parser: tseslint.parser,\n    parserOptions: {\n      projectService: true,\n    },\n  };\n}\n","import tseslint from \"typescript-eslint\";\nimport { baseRules } from \"./base-rules\";\nimport { createBaseLanguageOptions } from \"./create-base-language-options\";\nimport { createTypedLanguageOptions } from \"./create-typed-language-options\";\nimport { typeDrivenRules } from \"./type-driven-rules\";\n\nexport function createSharedConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return {\n    backend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/backend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // La regla obligatoria del sistema de errores es await-requires-result\n        // (todo await resuelve en Result). async-functions-return-result queda\n        // apagada por defecto: exigir la firma por decreto choca con los bordes\n        // del framework y bloquea la adopción incremental; la presión sobre los\n        // awaits produce el mismo estado final. Ver \"¿Por qué está apagada por\n        // defecto?\" en el README.\n        \"skapxd/await-requires-result\": \"error\",\n      },\n    },\n    base: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    frontend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/frontend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // En el front no se obliga a retornar Result, pero todo await debe\n        // resolver en uno: o la función llamada ya retorna Promise<Result>\n        // (camino preferido: errores modelados en el dominio) o se envuelve\n        // en trySafe en el sitio.\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/jsx-return-name-pascal-case\": \"error\",\n        // Anti prop-drilling: ninguna prop viaja más de un nivel. Quien la\n        // crea puede pasarla a UN hijo; quien la recibe no la reenvía —\n        // estado y acciones a un store global o custom hook.\n        \"skapxd/no-functions-inside-components\": \"error\",\n        \"skapxd/no-tunnel-props\": \"error\",\n        // Listeners en efectos: un AbortController por efecto, cleanup con\n        // un solo abort() en vez de removeEventListener por listener.\n        \"skapxd/prefer-abort-signal\": \"error\",\n        \"skapxd/no-jsx-ternary-null\": \"error\",\n        \"skapxd/max-hook-size\": [\n          \"error\",\n          {\n            maxLines: 120,\n            maxUseState: 1,\n          },\n        ],\n      },\n    },\n    package: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/package\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/one-root-function-per-file\": \"error\",\n      },\n    },\n  };\n}\n","export const baseRules = {\n  \"skapxd/class-properties-require-readonly\": \"error\",\n  \"skapxd/max-public-methods\": \"error\",\n  \"skapxd/no-accessors\": \"error\",\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-default-export\": \"error\",\n  \"skapxd/no-else\": \"error\",\n  \"skapxd/no-emoji\": \"error\",\n  \"skapxd/no-nested-if\": \"error\",\n  \"skapxd/no-runtime-state-guard\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-tagged-union-state\": \"error\",\n  \"skapxd/requires-strict-tsconfig\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n  \"skapxd/result-error-requires-handling\": \"error\",\n};\n","import tseslint from \"typescript-eslint\";\n\n// Variante sin type-checking: solo el parser, para presets que aplican a TS\n// pero no necesitan projectService (base, package, next/base, next/react).\nexport function createBaseLanguageOptions() {\n  return {\n    parser: tseslint.parser,\n  };\n}\n","// Reglas de typescript-eslint que el diseño guiado por tipos exige y que no\n// tiene sentido reimplementar — typescript-eslint ya es peer dependency.\n//\n// Ausencias deliberadas (no son olvidos):\n// - switch-exhaustiveness-check: prefer-ts-pattern prohíbe el switch entero;\n//   match().exhaustive() da la misma garantía sin él.\n// - prefer-readonly: superada por class-properties-require-readonly, que\n//   exige readonly en la declaración (no solo en privados nunca reasignados).\n// - strict-boolean-expressions: castiga narrowing legítimo por cientos\n//   (560 hallazgos en un backend real) sin hacer irrepresentable ningún\n//   estado nuevo. Ruido, no señal.\n// - explicit-module-boundary-types: los contratos que importan ya están\n//   gobernados (Result en await-requires-result, respuestas de controller en\n//   nest-no-result-response); anotar todo lo demás es ceremonia (198\n//   hallazgos) que la inferencia resuelve sin perder garantías.\n// - prefer-readonly-parameter-types: impracticable con cualquier parámetro\n//   que venga de una librería externa.\nexport const typeDrivenRules = {\n  // Silenciar la alarma no arregla el incendio: un error de tipos se\n  // resuelve modelando mejor, no apagando el compilador. @ts-expect-error\n  // queda permitido CON descripción: es la forma legítima de testear que un\n  // estado inválido de verdad no compila.\n  \"@typescript-eslint/ban-ts-comment\": [\n    \"error\",\n    {\n      \"ts-expect-error\": \"allow-with-description\",\n      \"ts-ignore\": true,\n      \"ts-nocheck\": true,\n    },\n  ],\n  // `type` en vez de `interface`: las uniones discriminadas son types, y la\n  // homogeneidad evita el \"¿esto se puede extender por declaration merging?\"\n  \"@typescript-eslint/consistent-type-definitions\": [\"error\", \"type\"],\n  // `any` apaga el sistema de tipos: todo el esfuerzo de modelar estados\n  // irrepresentables muere donde aparece uno.\n  \"@typescript-eslint/no-explicit-any\": \"error\",\n  // El hueco que await-requires-result no ve: una llamada async SIN await no\n  // produce AwaitExpression — el rechazo muere sin pasar por trySafe. Esta\n  // regla obliga a awaitear (y ahí entra el pipeline de Result). El operador\n  // `void promesa` queda como única salida: fire-and-forget declarado y\n  // greppeable, no interpretado.\n  \"@typescript-eslint/no-floating-promises\": \"error\",\n  // `!` es \"cállate, yo sé más que tú\" dicho al compilador. Si el valor no\n  // puede ser nulo, que lo diga el tipo; si puede serlo, hay que modelarlo.\n  \"@typescript-eslint/no-non-null-assertion\": \"error\",\n  // La generalización type-aware de no-runtime-state-guard: si el tipo dice\n  // que un estado es imposible, el guard defensivo sobra — y si el guard\n  // hace falta, lo que está mal es el tipo. Requiere el tsconfig de\n  // requires-strict-tsconfig para ser sólida: sin noUncheckedIndexedAccess,\n  // `array[i]` miente y esta regla acusaría guards necesarios.\n  \"@typescript-eslint/no-unnecessary-condition\": \"error\",\n};\n","// Config endurecida: ignora TODOS los comentarios `eslint-disable` (y demás\n// directivas inline) en los archivos que cubre. Así ni una persona ni un agente\n// pueden saltarse una regla con `// eslint-disable-next-line`.\nexport const strictConfig = {\n  linterOptions: {\n    noInlineConfig: true,\n  },\n  name: \"skapxd/strict\",\n};\n"],"mappings":";AAAA,OAAO,cAAc;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,SAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACXA,OAAOA,eAAc;;;ACAd,IAAM,YAAY;AAAA,EACvB,4CAA4C;AAAA,EAC5C,6BAA6B;AAAA,EAC7B,uBAAuB;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,oCAAoC;AAAA,EACpC,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,sCAAsC;AAAA,EACtC,yCAAyC;AAC3C;;;ACnBA,OAAOC,eAAc;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQA,UAAS;AAAA,EACnB;AACF;;;ACSO,IAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAK7B,qCAAqC;AAAA,IACnC;AAAA,IACA;AAAA,MACE,mBAAmB;AAAA,MACnB,aAAa;AAAA,MACb,cAAc;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA,EAGA,kDAAkD,CAAC,SAAS,MAAM;AAAA;AAAA;AAAA,EAGlE,sCAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtC,2CAA2C;AAAA;AAAA;AAAA,EAG3C,4CAA4C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM5C,+CAA+C;AACjD;;;AH7CO,SAAS,oBAAoB,iBAA0B;AAC5D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL,SAAS;AAAA,MACP,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS;AAAA,QACP,sBAAsBC,UAAS;AAAA,QAC/B,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,QACL,GAAG;AAAA,QACH,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOH,gCAAgC;AAAA,MAClC;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA,UAAU;AAAA,MACR,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS;AAAA,QACP,sBAAsBA,UAAS;AAAA,QAC/B,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,QACL,GAAG;AAAA,QACH,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,QAKH,gCAAgC;AAAA,QAChC,sCAAsC;AAAA;AAAA;AAAA;AAAA,QAItC,yCAAyC;AAAA,QACzC,0BAA0B;AAAA;AAAA;AAAA,QAG1B,8BAA8B;AAAA,QAC9B,8BAA8B;AAAA,QAC9B,wBAAwB;AAAA,UACtB;AAAA,UACA;AAAA,YACE,UAAU;AAAA,YACV,aAAa;AAAA,UACf;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,qCAAqC;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AACF;;;AI5EO,IAAM,eAAe;AAAA,EAC1B,eAAe;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA,EACA,MAAM;AACR;","names":["tseslint","tseslint","tseslint"]}
+{"version":3,"sources":["../src/shared/configs/create-typed-language-options.ts","../src/shared/configs/create-shared-configs.ts","../src/shared/configs/base-rules.ts","../src/shared/configs/create-base-language-options.ts","../src/shared/configs/type-driven-rules.ts","../src/shared/configs/strict-config.ts"],"sourcesContent":["import tseslint from \"typescript-eslint\";\n\nexport function createTypedLanguageOptions() {\n  return {\n    // Sin el parser explícito, un consumidor que use solo estos presets\n    // obtiene \"Parsing error\" en cada archivo TS (espree no parsea TS).\n    parser: tseslint.parser,\n    parserOptions: {\n      projectService: true,\n    },\n  };\n}\n","import tseslint from \"typescript-eslint\";\nimport { baseRules } from \"./base-rules\";\nimport { createBaseLanguageOptions } from \"./create-base-language-options\";\nimport { createTypedLanguageOptions } from \"./create-typed-language-options\";\nimport { typeDrivenRules } from \"./type-driven-rules\";\n\nexport function createSharedConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return {\n    backend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/backend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // La regla obligatoria del sistema de errores es await-requires-result\n        // (todo await resuelve en Result). async-functions-return-result queda\n        // apagada por defecto: exigir la firma por decreto choca con los bordes\n        // del framework y bloquea la adopción incremental; la presión sobre los\n        // awaits produce el mismo estado final. Ver \"¿Por qué está apagada por\n        // defecto?\" en el README.\n        \"skapxd/await-requires-result\": \"error\",\n      },\n    },\n    base: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    frontend: {\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/shared/frontend\",\n      plugins: {\n        \"@typescript-eslint\": tseslint.plugin,\n        skapxd: pluginReference,\n      },\n      rules: {\n        ...baseRules,\n        ...typeDrivenRules,\n        // En el front no se obliga a retornar Result, pero todo await debe\n        // resolver en uno: o la función llamada ya retorna Promise<Result>\n        // (camino preferido: errores modelados en el dominio) o se envuelve\n        // en trySafe en el sitio.\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/jsx-return-name-pascal-case\": \"error\",\n        // Anti prop-drilling: ninguna prop viaja más de un nivel. Quien la\n        // crea puede pasarla a UN hijo; quien la recibe no la reenvía —\n        // estado y acciones a un store global o custom hook.\n        \"skapxd/no-functions-inside-components\": \"error\",\n        \"skapxd/no-tunnel-props\": \"error\",\n        // Listeners en efectos: un AbortController por efecto, cleanup con\n        // un solo abort() en vez de removeEventListener por listener.\n        \"skapxd/prefer-abort-signal\": \"error\",\n        \"skapxd/no-jsx-ternary-null\": \"error\",\n        \"skapxd/max-hook-size\": [\n          \"error\",\n          {\n            maxLines: 120,\n            maxUseState: 1,\n          },\n        ],\n      },\n    },\n    package: {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/shared/package\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/one-root-function-per-file\": \"error\",\n      },\n    },\n  };\n}\n","export const baseRules = {\n  \"skapxd/class-properties-require-readonly\": \"error\",\n  \"skapxd/max-public-methods\": \"error\",\n  \"skapxd/no-accessors\": \"error\",\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-default-export\": \"error\",\n  \"skapxd/no-else\": \"error\",\n  \"skapxd/no-emoji\": \"error\",\n  \"skapxd/no-nested-if\": \"error\",\n  \"skapxd/no-runtime-state-guard\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-tagged-union-state\": \"error\",\n  \"skapxd/requires-strict-tsconfig\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"error\",\n  \"skapxd/result-error-requires-handling\": \"error\",\n};\n","import tseslint from \"typescript-eslint\";\n\n// Variante sin type-checking: solo el parser, para presets que aplican a TS\n// pero no necesitan projectService (base, package, next/base, next/react).\nexport function createBaseLanguageOptions() {\n  return {\n    parser: tseslint.parser,\n  };\n}\n","// Reglas de typescript-eslint que el diseño guiado por tipos exige y que no\n// tiene sentido reimplementar — typescript-eslint ya es peer dependency.\n//\n// Ausencias deliberadas (no son olvidos):\n// - switch-exhaustiveness-check: prefer-ts-pattern prohíbe el switch entero;\n//   match().exhaustive() da la misma garantía sin él.\n// - prefer-readonly: superada por class-properties-require-readonly, que\n//   exige readonly en la declaración (no solo en privados nunca reasignados).\n// - strict-boolean-expressions: castiga narrowing legítimo por cientos\n//   (560 hallazgos en un backend real) sin hacer irrepresentable ningún\n//   estado nuevo. Ruido, no señal.\n// - explicit-module-boundary-types: los contratos que importan ya están\n//   gobernados (Result en await-requires-result, respuestas de controller en\n//   nest-no-result-response); anotar todo lo demás es ceremonia (198\n//   hallazgos) que la inferencia resuelve sin perder garantías.\n// - prefer-readonly-parameter-types: impracticable con cualquier parámetro\n//   que venga de una librería externa.\nexport const typeDrivenRules = {\n  // Silenciar la alarma no arregla el incendio: un error de tipos se\n  // resuelve modelando mejor, no apagando el compilador. @ts-expect-error\n  // queda permitido CON descripción: es la forma legítima de testear que un\n  // estado inválido de verdad no compila.\n  \"@typescript-eslint/ban-ts-comment\": [\n    \"error\",\n    {\n      \"ts-expect-error\": \"allow-with-description\",\n      \"ts-ignore\": true,\n      \"ts-nocheck\": true,\n    },\n  ],\n  // `type` en vez de `interface`: las uniones discriminadas son types, y la\n  // homogeneidad evita el \"¿esto se puede extender por declaration merging?\"\n  \"@typescript-eslint/consistent-type-definitions\": [\"error\", \"type\"],\n  // `any` apaga el sistema de tipos: todo el esfuerzo de modelar estados\n  // irrepresentables muere donde aparece uno.\n  \"@typescript-eslint/no-explicit-any\": \"error\",\n  // El hueco que await-requires-result no ve: una llamada async SIN await no\n  // produce AwaitExpression — el rechazo muere sin pasar por trySafe. Esta\n  // regla obliga a awaitear (y ahí entra el pipeline de Result). El operador\n  // `void promesa` queda como única salida: fire-and-forget declarado y\n  // greppeable, no interpretado.\n  \"@typescript-eslint/no-floating-promises\": \"error\",\n  // `!` es \"cállate, yo sé más que tú\" dicho al compilador. Si el valor no\n  // puede ser nulo, que lo diga el tipo; si puede serlo, hay que modelarlo.\n  \"@typescript-eslint/no-non-null-assertion\": \"error\",\n  // La generalización type-aware de no-runtime-state-guard: si el tipo dice\n  // que un estado es imposible, el guard defensivo sobra — y si el guard\n  // hace falta, lo que está mal es el tipo. Requiere el tsconfig de\n  // requires-strict-tsconfig para ser sólida: sin noUncheckedIndexedAccess,\n  // `array[i]` miente y esta regla acusaría guards necesarios.\n  // Es @typescript-eslint/no-unnecessary-condition re-registrada bajo un\n  // nombre que dice lo que defiende, con mensajes que enseñan el fix.\n  \"skapxd/no-impossible-branch\": \"error\",\n};\n","// Config endurecida: ignora TODOS los comentarios `eslint-disable` (y demás\n// directivas inline) en los archivos que cubre. Así ni una persona ni un agente\n// pueden saltarse una regla con `// eslint-disable-next-line`.\nexport const strictConfig = {\n  linterOptions: {\n    noInlineConfig: true,\n  },\n  name: \"skapxd/strict\",\n};\n"],"mappings":";AAAA,OAAO,cAAc;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,SAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACXA,OAAOA,eAAc;;;ACAd,IAAM,YAAY;AAAA,EACvB,4CAA4C;AAAA,EAC5C,6BAA6B;AAAA,EAC7B,uBAAuB;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,oCAAoC;AAAA,EACpC,mCAAmC;AAAA,EACnC,4BAA4B;AAAA,EAC5B,sCAAsC;AAAA,EACtC,yCAAyC;AAC3C;;;ACnBA,OAAOC,eAAc;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQA,UAAS;AAAA,EACnB;AACF;;;ACSO,IAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAK7B,qCAAqC;AAAA,IACnC;AAAA,IACA;AAAA,MACE,mBAAmB;AAAA,MACnB,aAAa;AAAA,MACb,cAAc;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA,EAGA,kDAAkD,CAAC,SAAS,MAAM;AAAA;AAAA;AAAA,EAGlE,sCAAsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtC,2CAA2C;AAAA;AAAA;AAAA,EAG3C,4CAA4C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5C,+BAA+B;AACjC;;;AH/CO,SAAS,oBAAoB,iBAA0B;AAC5D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL,SAAS;AAAA,MACP,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS;AAAA,QACP,sBAAsBC,UAAS;AAAA,QAC/B,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,QACL,GAAG;AAAA,QACH,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOH,gCAAgC;AAAA,MAClC;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA,UAAU;AAAA,MACR,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS;AAAA,QACP,sBAAsBA,UAAS;AAAA,QAC/B,QAAQ;AAAA,MACV;AAAA,MACA,OAAO;AAAA,QACL,GAAG;AAAA,QACH,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,QAKH,gCAAgC;AAAA,QAChC,sCAAsC;AAAA;AAAA;AAAA;AAAA,QAItC,yCAAyC;AAAA,QACzC,0BAA0B;AAAA;AAAA;AAAA,QAG1B,8BAA8B;AAAA,QAC9B,8BAA8B;AAAA,QAC9B,wBAAwB;AAAA,UACtB;AAAA,UACA;AAAA,YACE,UAAU;AAAA,YACV,aAAa;AAAA,UACf;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,qCAAqC;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AACF;;;AI5EO,IAAM,eAAe;AAAA,EAC1B,eAAe;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA,EACA,MAAM;AACR;","names":["tseslint","tseslint","tseslint"]}

package/dist/{chunk-YUKVSZZ4.mjs → chunk-MLFXSEY7.mjs}

@@ -2759,6 +2759,33 @@ var noEmoji = {
   }
 };
 
+// src/rules/no-impossible-branch.ts
+import tseslint from "typescript-eslint";
+var original = tseslint.plugin.rules["no-unnecessary-condition"];
+var elTipoMiente = " Si la comprobacion hace falta en runtime, el tipo esta mintiendo: arregla el tipo, no borres el guard a ciegas (acceso por indice tipo `array[i]` u `obj[key]`? te falta `noUncheckedIndexedAccess` en el tsconfig \u2014 `skapxd/requires-strict-tsconfig` lo exige).";
+var noImpossibleBranch = {
+  ...original,
+  meta: {
+    ...original.meta,
+    docs: {
+      ...original.meta.docs,
+      description: "La rama imposible: condiciones que el type-checker demuestra constantes. Si el tipo dice que no puede pasar, la rama sobra; si la rama hace falta, lo que esta mal es el tipo."
+    },
+    messages: {
+      ...original.meta.messages,
+      alwaysFalsy: "Rama imposible: el tipo dice que este valor SIEMPRE es falsy \u2014 el camino positivo de esta condicion es codigo muerto." + elTipoMiente,
+      alwaysNullish: "Rama imposible: el tipo dice que el lado izquierdo del `??` SIEMPRE es null/undefined \u2014 la expresion es solo su fallback." + elTipoMiente,
+      alwaysTruthy: "Pregunta ya respondida: el tipo dice que este valor SIEMPRE es truthy \u2014 la condicion solo tiene un camino posible." + elTipoMiente,
+      comparisonBetweenLiteralTypes: "Comparacion constante: `{{left}} {{operator}} {{right}}` siempre es {{trueOrFalse}} segun los tipos \u2014 esta decision no decide nada." + elTipoMiente,
+      never: "Rama imposible: este valor es de tipo `never` \u2014 segun el modelo, este punto del codigo es inalcanzable." + elTipoMiente,
+      neverNullish: "El `??` no aporta: el tipo dice que el lado izquierdo NUNCA es null/undefined \u2014 el fallback es codigo muerto." + elTipoMiente,
+      neverOptionalChain: "El `?.` sobra: el tipo dice que este valor nunca es nullish \u2014 el encadenamiento opcional finge una duda que el modelo ya resolvio." + elTipoMiente,
+      noOverlapBooleanExpression: "Comparacion imposible: los tipos de ambos lados no se solapan, asi que el resultado siempre es el mismo (ej. comparar con `null` un valor cuyo tipo nunca incluye `null`)." + elTipoMiente,
+      noStrictNullCheck: "Esta regla necesita `strictNullChecks` (viene con `strict: true`): sin el, los tipos mienten sobre null/undefined y la regla acusaria guards necesarios. `skapxd/requires-strict-tsconfig` vigila esa premisa."
+    }
+  }
+};
+
 // src/utils/get-no-tunnel-props-options.ts
 function getNoTunnelPropsOptions(options = {}) {
   return {
@@ -3323,7 +3350,7 @@ var preferTaggedUnionState = {
 };
 
 // src/rules/requires-strict-tsconfig.ts
-import { dirname as dirname4, resolve as resolve2 } from "path";
+import { dirname as dirname5, resolve as resolve2 } from "path";
 
 // src/utils/get-strict-tsconfig-options.ts
 function getStrictTsconfigOptions(options = {}) {
@@ -3349,8 +3376,38 @@ function getStrictTsconfigOptions(options = {}) {
   };
 }
 
-// src/utils/read-resolved-tsconfig.ts
+// src/utils/is-anchorless-check-redundant.ts
 import { dirname as dirname3 } from "path";
+
+// src/utils/anchor-file-exists.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function anchorFileExists(rootDir, anchorFilePatterns) {
+  return anchorFilePatterns.some((pattern) => {
+    const literal = pattern.replace(/^\*\*\//, "");
+    if (literal.includes("*") || literal.includes("{")) {
+      return false;
+    }
+    return existsSync2(join2(rootDir, literal));
+  });
+}
+
+// src/utils/is-anchorless-check-redundant.ts
+var checkedRoots = /* @__PURE__ */ new Set();
+function isAnchorlessCheckRedundant(tsconfigPath, fallbackRootKey, anchorFilePatterns) {
+  const rootKey = tsconfigPath ?? fallbackRootKey;
+  if (checkedRoots.has(rootKey)) {
+    return true;
+  }
+  checkedRoots.add(rootKey);
+  if (!tsconfigPath) {
+    return false;
+  }
+  return anchorFileExists(dirname3(tsconfigPath), anchorFilePatterns);
+}
+
+// src/utils/read-resolved-tsconfig.ts
+import { dirname as dirname4 } from "path";
 import ts3 from "typescript";
 import { trySafe as trySafe3 } from "@skapxd/result";
 function readResolvedTsconfig(tsconfigPath) {
@@ -3362,7 +3419,7 @@ function readResolvedTsconfig(tsconfigPath) {
     return ts3.parseJsonConfigFileContent(
       raw.config,
       ts3.sys,
-      dirname3(tsconfigPath)
+      dirname4(tsconfigPath)
     );
   });
   if (!parsed.ok || !parsed.value) {
@@ -3406,16 +3463,24 @@ var requiresStrictTsconfig = {
   create(context) {
     const options = getStrictTsconfigOptions(context.options[0]);
     const filename = context.filename ?? context.getFilename();
-    if (matchesAnyGlob(filename, options.allowFilePatterns) || !matchesAnyGlob(filename, options.anchorFilePatterns)) {
+    if (matchesAnyGlob(filename, options.allowFilePatterns)) {
       return {};
     }
+    const isAnchor = matchesAnyGlob(filename, options.anchorFilePatterns);
     return {
       Program(node) {
         const absoluteFilename = resolve2(context.cwd ?? process.cwd(), filename);
         const tsconfigPath = findProjectFile(
-          dirname4(absoluteFilename),
+          dirname5(absoluteFilename),
           "tsconfig.json"
         );
+        if (!isAnchor && isAnchorlessCheckRedundant(
+          tsconfigPath,
+          context.cwd ?? process.cwd(),
+          options.anchorFilePatterns
+        )) {
+          return;
+        }
         const compilerOptions = tsconfigPath ? readResolvedTsconfig(tsconfigPath) : null;
         if (!compilerOptions) {
           context.report({ messageId: "missingTsconfig", node });
@@ -3741,6 +3806,9 @@ var rules = {
   "no-default-export": noDefaultExport,
   "no-else": noElse,
   "no-emoji": noEmoji,
+  // Re-registro de @typescript-eslint/no-unnecessary-condition con nombre
+  // semántico y mensajes propios (ver src/rules/no-impossible-branch.ts).
+  "no-impossible-branch": noImpossibleBranch,
   "no-tunnel-props": noTunnelProps,
   "no-functions-inside-components": noFunctionsInsideComponents,
   "no-try-catch": noTryCatch,
@@ -3757,4 +3825,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-YUKVSZZ4.mjs.map
+//# sourceMappingURL=chunk-MLFXSEY7.mjs.map