@skapxd/eslint-opinionated 0.14.0 → 0.16.0

package/README.md

@@ -98,11 +98,11 @@ 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` |
-| 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` |
+| 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`, `prefer-type-over-interface` |
+| 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`, `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` |
-| A5 | **Las decisiones se declaran, no se interpretan.** Cada rama es explícita y exhaustiva; un caso ignorado es una decisión visible, no un hueco. | `no-else`, `no-nested-if`, `prefer-ts-pattern`, `@typescript-eslint/ban-ts-comment`, el `void promesa()` de `no-floating-promises` |
+| A5 | **Las decisiones se declaran, no se interpretan.** Cada rama es explícita y exhaustiva; un caso ignorado es una decisión visible, no un hueco. | `no-else`, `no-nested-if`, `prefer-ts-pattern`, `no-silenced-compiler`, el `void promesa()` de `no-floating-promises` |
 | A6 | **Evidencia sobre convención.** Una regla decide por lo que el type-checker o los imports demuestran, no por cómo se llama un archivo o un campo. | la implementación type-aware de las reglas de Result, `nest-no-direct-instantiation` (@Injectable resuelto por símbolo), la exención ORM por decorador de `class-properties-require-readonly` |
 | A7 | **Las fronteras son explícitas y únicas.** Lo que cruza una capa lo hace por un contrato, una sola vez, sin túneles. | `no-deep-relative-imports`, `no-tunnel-props`, `nest-no-result-response`, `nest-no-swagger-in-controllers`, `nest-no-inline-query-params` |
 | A8 | **Inmutable por defecto.** La mutación es la excepción que se pide con evidencia, no el estado natural de las cosas. | `class-properties-require-readonly`, `no-accessors` |
@@ -274,6 +274,150 @@ 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:
+
+- `skapxd/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.
+- `skapxd/no-explicit-any`, `skapxd/no-non-null-assertion` y
+  `skapxd/no-silenced-compiler` — 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
@@ -534,7 +678,7 @@ Detalles del preset:
   se escribe `void bootstrap();` — fire-and-forget declarado.
 - Los specs colocados (`*.spec.ts`, `*.e2e-spec.ts`) relajan
   `await-requires-result`, `no-try-catch`, `result-error-requires-handling` y
-  `@typescript-eslint/no-non-null-assertion` (el `!` sobre un fixture es el
+  `no-non-null-assertion` (el `!` sobre un fixture es el
   arrange del test): un test awaitea helpers libremente y descartar un Result
   en una aserción no es perder un trace. `no-floating-promises` sigue activa
   en specs: un `await` olvidado es un falso verde.
@@ -676,6 +820,11 @@ de cada regla):
 | `no-default-export` | `allowFilePatterns` (globs, aditivos a los integrados) |
 | `no-else` | `allowFilePatterns` (globs) |
 | `no-emoji` | `allowFilePatterns` (globs) |
+| `no-explicit-any` | las de la regla original de typescript-eslint (`fixToUnknown`, ...) |
+| `no-floating-promises` | las de la regla original de typescript-eslint (`ignoreVoid`, `allowList`, ...) |
+| `no-impossible-branch` | las de la regla original de typescript-eslint (`allowConstantLoopConditions`, ...) |
+| `no-silenced-compiler` | las de `ban-ts-comment` (`ts-expect-error`, `ts-ignore`, `ts-nocheck`, `minimumDescriptionLength`) |
+| `prefer-type-over-interface` | la de `consistent-type-definitions` (`"type"` o `"interface"`; los presets pasan `"type"`) |
 | `no-functions-inside-components` | `allowJsxCallbacks`, `allowArrayMapCallbacks` (ambas `true` por defecto) |
 | `no-nested-if` | `allowFilePatterns` (globs) |
 | `no-promise-chain` | `methods` |
@@ -719,11 +868,17 @@ 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-explicit-any` | Prohíbe `any`: apaga el sistema de tipos donde más se necesita. `unknown` para lo desconocido, el tipo real para lo demás. Wrapper de typescript-eslint. |
+| `skapxd/no-floating-promises` | Promesas sin `await` ni `void`: el rechazo muere sin pasar por trySafe. El mensaje corrige el consejo upstream (`.then/.catch` aquí están prohibidos). Wrapper de typescript-eslint. |
+| `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-non-null-assertion` | Prohíbe el `!`: es "cállate, yo sé más que tú" dicho al compilador. Modela el tipo o maneja la duda. Wrapper de typescript-eslint. |
 | `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-silenced-compiler` | Prohíbe `@ts-ignore`/`@ts-nocheck`: silenciar la alarma no arregla el incendio. `@ts-expect-error` con descripción queda para tests de tipos. Wrapper de `ban-ts-comment`. |
 | `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. |
 | `skapxd/prefer-abort-signal` | Listeners en efectos se limpian con `AbortController` (`{ signal }` + `abort()`), no con `removeEventListener`. |
 | `skapxd/prefer-tagged-union-state` | Prohíbe estados inconsistentes representables: flag de loading + campo de error independientes → unión etiquetada. |
+| `skapxd/prefer-type-over-interface` | Las uniones discriminadas son types; un `type` no crece en silencio por declaration merging. Wrapper de `consistent-type-definitions`. |
 | `skapxd/no-functions-inside-components` | Prohíbe definir funciones dentro de componentes React. |
 | `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`). |
@@ -831,8 +986,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
@@ -846,32 +1005,29 @@ Fuera del default, a propósito: `exactOptionalPropertyTypes` y
 con muchas librerías — se agregan vía `requiredCompilerOptions` si el
 proyecto los soporta.
 
-Además, los **presets tipados activan reglas curadas de typescript-eslint**
-(que ya es peer dependency — no se reimplementan):
-
-- `@typescript-eslint/no-explicit-any` — `any` apaga el sistema de tipos:
-  todo el esfuerzo muere donde aparece uno.
-- `@typescript-eslint/consistent-type-definitions` con `type` — las uniones
-  discriminadas son types.
-- `@typescript-eslint/no-floating-promises` — cierra el hueco que
-  `await-requires-result` no ve: una llamada async **sin** `await` no produce
-  `AwaitExpression`, así que el rechazo muere sin pasar por `trySafe`
-  (medido: 12 promesas flotantes vivas en un backend Nest real). La única
-  salida es `void promesa()`: fire-and-forget declarado y greppeable.
-- `@typescript-eslint/no-non-null-assertion` — `!` es "cállate, yo sé más
-  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.
-- `@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
-  forma legítima de testear que un estado inválido de verdad no compila.
+Además, los **presets tipados activan reglas curadas de typescript-eslint**,
+todas **re-registradas bajo el namespace skapxd** (mismo motor, cero
+reimplementación — typescript-eslint ya es peer dependency): nombres que
+dicen lo que defienden, mensajes en español que enseñan el fix, y un solo
+namespace en toda tu lista de pendientes. Cada una tiene su sección propia:
+
+- `skapxd/no-explicit-any` — `any` apaga el sistema de tipos: todo el
+  esfuerzo muere donde aparece uno.
+- `skapxd/prefer-type-over-interface` (era `consistent-type-definitions`) —
+  las uniones discriminadas son types.
+- `skapxd/no-floating-promises` — cierra el hueco que `await-requires-result`
+  no ve: una llamada async **sin** `await` no produce `AwaitExpression`, así
+  que el rechazo muere sin pasar por `trySafe` (medido: 12 promesas
+  flotantes vivas en un backend Nest real).
+- `skapxd/no-non-null-assertion` — `!` es "cállate, yo sé más que tú" dicho
+  al compilador. (En `nest/tests` queda apagada: el `!` sobre un fixture es
+  el arrange, no una mentira.)
+- `skapxd/no-impossible-branch` (era `no-unnecessary-condition`) — la
+  generalización type-aware de `no-runtime-state-guard`. Va de la mano de
+  `requires-strict-tsconfig`: sin `noUncheckedIndexedAccess`, `array[i]`
+  miente y la regla acusaría guards necesarios.
+- `skapxd/no-silenced-compiler` (era `ban-ts-comment`) — un error de tipos
+  se arregla modelando mejor, no silenciando la alarma.
 
 Ausencias deliberadas, no olvidos:
 
@@ -1726,6 +1882,113 @@ 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-explicit-any`
+
+Prohíbe `any`. No es una regla de estilo: `any` apaga el sistema de tipos en
+todo lo que toca — el esfuerzo de modelar estados imposibles muere donde
+aparece uno, y se propaga en silencio a cada valor derivado. El mensaje
+enseña la salida: `unknown` para lo genuinamente desconocido (obliga a
+estrechar antes de usar — la duda queda declarada y verificada), el tipo
+real para lo que tiene forma conocida.
+
+Bajo el capó es `@typescript-eslint/no-explicit-any`
+([doc original](https://typescript-eslint.io/rules/no-explicit-any/))
+re-registrada bajo nuestro namespace con mensajes que enseñan (ver
+`skapxd/no-impossible-branch` para el patrón). Los presets tipados activan
+este nombre, no el original.
+
+### `skapxd/no-floating-promises`
+
+Una llamada async **sin** `await` no produce `AwaitExpression` — es el punto
+ciego de `await-requires-result`: el rechazo muere sin pasar por `trySafe`,
+sin trace y sin que nadie lo decidiera (medido al absorberla: 12 promesas
+flotantes vivas en un backend en producción).
+
+Esta regla existía en typescript-eslint
+([doc original](https://typescript-eslint.io/rules/no-floating-promises/)),
+pero su mensaje recomendaba *"end with a call to `.catch`, or end with a
+call to `.then` with a rejection handler"* — **dos caminos que
+`no-promise-chain` prohíbe**. Obedecer a una regla te estrellaba con la
+otra. El wrapper corrige el consejo para este sistema: las dos salidas
+legales son `await` (y ahí entra el pipeline de Result) o `void promesa()`
+— el fire-and-forget declarado y greppeable del axioma A5 (así se escribe
+el `bootstrap()` del `main.ts` de Nest: `void bootstrap();`).
+
+### `skapxd/no-non-null-assertion`
+
+Prohíbe el `!` (non-null assertion): es "cállate, yo sé más que tú" dicho al
+compilador — y un `!` equivocado es un crash en runtime que el tipo juraba
+imposible. Si el valor de verdad no puede ser nulo, que lo diga el tipo
+(modela mejor, o estrecha con un guard que el compilador verifique); si
+puede serlo, el `!` no resuelve la duda: la esconde.
+
+La excepción legítima vive en los tests: el `!` sobre un fixture cuya
+existencia el propio test garantiza es el arrange, no una mentira — por eso
+`nest/tests` la apaga en specs. Bajo el capó es
+`@typescript-eslint/no-non-null-assertion`
+([doc original](https://typescript-eslint.io/rules/no-non-null-assertion/))
+re-registrada con mensajes propios.
+
+### `skapxd/no-silenced-compiler`
+
+No silencies al compilador: `@ts-ignore` y `@ts-nocheck` apagan la alarma en
+vez de arreglar el incendio. Si el compilador es el muro de contención del
+sistema, nadie lo apaga cuando el modelado se pone difícil — un error de
+tipos se resuelve modelando mejor el dominio.
+
+La puerta que queda abierta, a propósito: `@ts-expect-error` **con
+descripción**. Es la forma legítima de testear que un estado inválido de
+verdad NO compila (la otra mitad son los tests de tipos con `expectTypeOf`,
+ver la sección de `requires-strict-tsconfig`) — y a diferencia de
+`@ts-ignore`, avisa cuando la supresión deja de hacer falta. Bajo el capó es
+`@typescript-eslint/ban-ts-comment`
+([doc original](https://typescript-eslint.io/rules/ban-ts-comment/)) con un
+nombre que dice lo que defiende y mensajes propios.
+
+### `skapxd/prefer-type-over-interface`
+
+Usa `type`, no `interface`. Las uniones discriminadas — la columna vertebral
+del modelado de estados de este paquete — son types, y la homogeneidad
+elimina la pregunta "¿esto puede crecer por declaration merging?": un `type`
+no puede ser extendido en silencio desde otro archivo; lo que declara es
+todo lo que hay.
+
+Bajo el capó es `@typescript-eslint/consistent-type-definitions`
+([doc original](https://typescript-eslint.io/rules/consistent-type-definitions/))
+re-registrada con un nombre que declara la opinión (como los demás
+`prefer-*`). Ojo si la activas suelta: el default upstream prefiere
+`interface` — los presets la pasan como `["error", "type"]`.
+
 ### `skapxd/no-functions-inside-components`
 
 Prohíbe definir funciones **con peso propio** dentro de un componente React

package/dist/astro/index.js

@@ -64,9 +64,6 @@ function createBaseLanguageOptions() {
   };
 }
 
-// src/shared/configs/create-shared-configs.ts
-var import_typescript_eslint3 = __toESM(require("typescript-eslint"));
-
 // src/shared/configs/create-typed-language-options.ts
 var import_typescript_eslint2 = __toESM(require("typescript-eslint"));
 function createTypedLanguageOptions() {

package/dist/astro/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/astro/index.ts","../../src/shared/configs/base-rules.ts","../../src/shared/configs/create-base-language-options.ts","../../src/shared/configs/create-shared-configs.ts","../../src/shared/configs/create-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\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","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","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 {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\nexport function createAstroConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/astro/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    // Los .astro no llevan parser propio: lo aporta eslint-plugin-astro,\n    // que el consumidor debe tener configurado.\n    {\n      files: [\"src/**/*.astro\"],\n      name: \"skapxd/astro/astro-files\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/astro/typescript\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/result-error-requires-cause\": \"error\",\n        \"skapxd/result-error-requires-handling\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,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,+BAAqB;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQ,yBAAAA,QAAS;AAAA,EACnB;AACF;;;ACRA,IAAAC,4BAAqB;;;ACArB,IAAAC,4BAAqB;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,0BAAAC,QAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACLO,SAAS,mBAAmB,iBAA0B;AAC3D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,gBAAgB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,gCAAgC;AAAA,QAChC,sCAAsC;AAAA,QACtC,yCAAyC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","import_typescript_eslint","tseslint"]}
+{"version":3,"sources":["../../src/astro/index.ts","../../src/shared/configs/base-rules.ts","../../src/shared/configs/create-base-language-options.ts","../../src/shared/configs/create-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\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","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 {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\nexport function createAstroConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/astro/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    // Los .astro no llevan parser propio: lo aporta eslint-plugin-astro,\n    // que el consumidor debe tener configurado.\n    {\n      files: [\"src/**/*.astro\"],\n      name: \"skapxd/astro/astro-files\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    {\n      files: [\"src/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/astro/typescript\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/await-requires-result\": \"error\",\n        \"skapxd/result-error-requires-cause\": \"error\",\n        \"skapxd/result-error-requires-handling\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,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,+BAAqB;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQ,yBAAAA,QAAS;AAAA,EACnB;AACF;;;ACRA,IAAAC,4BAAqB;AAEd,SAAS,6BAA6B;AAC3C,SAAO;AAAA;AAAA;AAAA,IAGL,QAAQ,0BAAAC,QAAS;AAAA,IACjB,eAAe;AAAA,MACb,gBAAgB;AAAA,IAClB;AAAA,EACF;AACF;;;ACLO,SAAS,mBAAmB,iBAA0B;AAC3D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA;AAAA;AAAA,IAGA;AAAA,MACE,OAAO,CAAC,gBAAgB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,OAAO,CAAC,mBAAmB;AAAA,MAC3B,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,gCAAgC;AAAA,QAChC,sCAAsC;AAAA,QACtC,yCAAyC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","tseslint"]}

package/dist/astro/index.mjs

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

package/dist/{chunk-QR35MHTW.mjs → chunk-4FQ7SFU4.mjs}

@@ -11,9 +11,6 @@ function createTypedLanguageOptions() {
   };
 }
 
-// src/shared/configs/create-shared-configs.ts
-import tseslint3 from "typescript-eslint";
-
 // src/shared/configs/base-rules.ts
 var baseRules = {
   "skapxd/class-properties-require-readonly": "error",
@@ -46,11 +43,30 @@ function createBaseLanguageOptions() {
 
 // src/shared/configs/type-driven-rules.ts
 var typeDrivenRules = {
+  // `any` apaga el sistema de tipos: todo el esfuerzo de modelar estados
+  // irrepresentables muere donde aparece uno. (Era no-explicit-any.)
+  "skapxd/no-explicit-any": "error",
+  // El hueco que await-requires-result no ve: una llamada async SIN await no
+  // produce AwaitExpression — el rechazo muere sin pasar por trySafe. La
+  // única salida sin await es `void promesa()`: fire-and-forget declarado.
+  // (Era no-floating-promises; el mensaje upstream recomendaba .then/.catch,
+  // que no-promise-chain prohíbe — el nuestro corrige el consejo.)
+  "skapxd/no-floating-promises": "error",
+  // La generalización type-aware de no-runtime-state-guard: si el tipo dice
+  // que un estado es imposible, el guard defensivo sobra — y si el guard
+  // 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.
+  // (Era no-unnecessary-condition.)
+  "skapxd/no-impossible-branch": "error",
+  // `!` es "cállate, yo sé más que tú" dicho al compilador. Si el valor no
+  // puede ser nulo, que lo diga el tipo; si puede serlo, hay que modelarlo.
+  "skapxd/no-non-null-assertion": "error",
   // Silenciar la alarma no arregla el incendio: un error de tipos se
   // resuelve modelando mejor, no apagando el compilador. @ts-expect-error
   // queda permitido CON descripción: es la forma legítima de testear que un
-  // estado inválido de verdad no compila.
-  "@typescript-eslint/ban-ts-comment": [
+  // estado inválido de verdad no compila. (Era ban-ts-comment.)
+  "skapxd/no-silenced-compiler": [
     "error",
     {
       "ts-expect-error": "allow-with-description",
@@ -60,25 +76,9 @@ var typeDrivenRules = {
   ],
   // `type` en vez de `interface`: las uniones discriminadas son types, y la
   // homogeneidad evita el "¿esto se puede extender por declaration merging?"
-  "@typescript-eslint/consistent-type-definitions": ["error", "type"],
-  // `any` apaga el sistema de tipos: todo el esfuerzo de modelar estados
-  // irrepresentables muere donde aparece uno.
-  "@typescript-eslint/no-explicit-any": "error",
-  // El hueco que await-requires-result no ve: una llamada async SIN await no
-  // produce AwaitExpression — el rechazo muere sin pasar por trySafe. Esta
-  // regla obliga a awaitear (y ahí entra el pipeline de Result). El operador
-  // `void promesa` queda como única salida: fire-and-forget declarado y
-  // greppeable, no interpretado.
-  "@typescript-eslint/no-floating-promises": "error",
-  // `!` es "cállate, yo sé más que tú" dicho al compilador. Si el valor no
-  // puede ser nulo, que lo diga el tipo; si puede serlo, hay que modelarlo.
-  "@typescript-eslint/no-non-null-assertion": "error",
-  // La generalización type-aware de no-runtime-state-guard: si el tipo dice
-  // que un estado es imposible, el guard defensivo sobra — y si el guard
-  // 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"
+  // (Era consistent-type-definitions, cuyo default upstream es `interface` —
+  // por eso la opción explícita.)
+  "skapxd/prefer-type-over-interface": ["error", "type"]
 };
 
 // src/shared/configs/create-shared-configs.ts
@@ -89,10 +89,11 @@ function createSharedConfigs(pluginReference) {
     backend: {
       languageOptions: typedLanguageOptions,
       name: "skapxd/shared/backend",
-      plugins: {
-        "@typescript-eslint": tseslint3.plugin,
-        skapxd: pluginReference
-      },
+      // Solo el plugin skapxd: las reglas de typescript-eslint entran
+      // re-registradas bajo nuestro namespace (typeDrivenRules), así el
+      // consumidor puede registrar su propia instancia de tseslint sin
+      // chocar con "Cannot redefine plugin".
+      plugins: { skapxd: pluginReference },
       rules: {
         ...baseRules,
         ...typeDrivenRules,
@@ -114,10 +115,7 @@ function createSharedConfigs(pluginReference) {
     frontend: {
       languageOptions: typedLanguageOptions,
       name: "skapxd/shared/frontend",
-      plugins: {
-        "@typescript-eslint": tseslint3.plugin,
-        skapxd: pluginReference
-      },
+      plugins: { skapxd: pluginReference },
       rules: {
         ...baseRules,
         ...typeDrivenRules,
@@ -172,4 +170,4 @@ export {
   createSharedConfigs,
   strictConfig
 };
-//# sourceMappingURL=chunk-QR35MHTW.mjs.map
+//# sourceMappingURL=chunk-4FQ7SFU4.mjs.map

package/dist/chunk-4FQ7SFU4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/configs/create-typed-language-options.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/create-shared-configs.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","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, todas\n// re-registradas bajo el namespace skapxd (ver src/utils/wrap-tseslint-rule.ts):\n// mismo motor, cero reimplementación, pero con nombres que dicen lo que\n// defienden y mensajes que enseñan el fix — un solo namespace en toda la\n// lista de pendientes del consumidor.\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  // `any` apaga el sistema de tipos: todo el esfuerzo de modelar estados\n  // irrepresentables muere donde aparece uno. (Era no-explicit-any.)\n  \"skapxd/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. La\n  // única salida sin await es `void promesa()`: fire-and-forget declarado.\n  // (Era no-floating-promises; el mensaje upstream recomendaba .then/.catch,\n  // que no-promise-chain prohíbe — el nuestro corrige el consejo.)\n  \"skapxd/no-floating-promises\": \"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  // (Era no-unnecessary-condition.)\n  \"skapxd/no-impossible-branch\": \"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  \"skapxd/no-non-null-assertion\": \"error\",\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. (Era ban-ts-comment.)\n  \"skapxd/no-silenced-compiler\": [\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  // (Era consistent-type-definitions, cuyo default upstream es `interface` —\n  // por eso la opción explícita.)\n  \"skapxd/prefer-type-over-interface\": [\"error\", \"type\"],\n};\n","import { 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      // Solo el plugin skapxd: las reglas de typescript-eslint entran\n      // re-registradas bajo nuestro namespace (typeDrivenRules), así el\n      // consumidor puede registrar su propia instancia de tseslint sin\n      // chocar con \"Cannot redefine plugin\".\n      plugins: { skapxd: pluginReference },\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: { skapxd: pluginReference },\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","// 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;;;ACXO,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,OAAOA,eAAc;AAId,SAAS,4BAA4B;AAC1C,SAAO;AAAA,IACL,QAAQA,UAAS;AAAA,EACnB;AACF;;;ACYO,IAAM,kBAAkB;AAAA;AAAA;AAAA,EAG7B,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM1B,+BAA+B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/B,+BAA+B;AAAA;AAAA;AAAA,EAG/B,gCAAgC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKhC,+BAA+B;AAAA,IAC7B;AAAA,IACA;AAAA,MACE,mBAAmB;AAAA,MACnB,aAAa;AAAA,MACb,cAAc;AAAA,IAChB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,qCAAqC,CAAC,SAAS,MAAM;AACvD;;;ACpDO,SAAS,oBAAoB,iBAA0B;AAC5D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL,SAAS;AAAA,MACP,iBAAiB;AAAA,MACjB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,MAKN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,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,EAAE,QAAQ,gBAAgB;AAAA,MACnC,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;;;ACzEO,IAAM,eAAe;AAAA,EAC1B,eAAe;AAAA,IACb,gBAAgB;AAAA,EAClB;AAAA,EACA,MAAM;AACR;","names":["tseslint"]}

package/dist/{chunk-C5JP4FQN.mjs → chunk-7OIMY5TI.mjs}

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