@skapxd/eslint-opinionated 0.3.0 → 0.5.0

package/README.md

@@ -13,8 +13,9 @@ Cursor o Copilot.
 
 - **Una función por archivo:** un archivo con cinco helpers escondidos no pasa;
   la regla hasta te dibuja la carpeta sugerida con formato `tree`.
-- **Errores con `Result`:** una función `async` que puede fallar lo dice en su
-  tipo de retorno (`Promise<Result<...>>`), no en una convención oral.
+- **Errores con `Result`:** ningún `await` queda fuera del sistema de errores:
+  o llamas una función que retorna `Promise<Result<...>>` o envuelves la
+  operación en `trySafe`. Nada lanza sin que el tipo lo diga.
 - **Causa preservada:** al transformar un error de dominio, el `cause` original
   no puede desaparecer — type-aware, vía el checker de TypeScript.
 - **Hooks acotados:** un hook con demasiado estado deja de pasar como "solo un
@@ -251,6 +252,70 @@ 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.
 
+## Cómo encaja todo: `@skapxd/result` + `ts-pattern`
+
+Este plugin no es una colección de reglas sueltas: es el guardián de un
+pipeline de errores donde cada pieza cierra un hueco que las otras dejan.
+
+```text
+excepción ──trySafe──▶ Result ──map con cause──▶ error de dominio ──match()──▶ UI/respuesta
+```
+
+| Pieza | Qué aporta | Regla que lo vigila |
+| --- | --- | --- |
+| `try/catch` prohibido | Los errores no viajan invisibles al tipo. | `skapxd/no-try-catch` |
+| `.then/.catch` prohibido | Una sola forma de asincronía: `await`. | `skapxd/no-promise-chain` |
+| `trySafe` (`@skapxd/result`) | La única puerta: lo que lanza se vuelve `Result`. | `skapxd/await-requires-result` |
+| Errores de dominio con `cause` | Al traducir un error técnico, la causa sobrevive. | `skapxd/result-error-requires-cause` |
+| Un solo contrato `Result` | Nada de `{ ok: ... }` caseros que fragmenten el sistema. | `skapxd/no-ad-hoc-ok-result` |
+| `match()` (`ts-pattern`) | Consumo exhaustivo: el compilador exige manejar cada error. | `skapxd/prefer-ts-pattern` |
+
+De punta a punta:
+
+```ts
+import { Result, trySafe } from "@skapxd/result";
+import { match } from "ts-pattern";
+
+type UserError =
+  | { type: "NETWORK"; message: string; cause: unknown }
+  | { type: "NOT_FOUND"; message: string };
+
+// 1. La frontera con el mundo que lanza: trySafe + errores de dominio.
+async function getUser(id: string): Promise<Result<User, UserError>> {
+  const response = await trySafe(() => fetch(`/users/${id}`));
+
+  if (!response.ok) {
+    return Result.err({
+      cause: response.error, // result-error-requires-cause vigila esto
+      message: "No pude cargar el usuario.",
+      type: "NETWORK",
+    });
+  }
+
+  if (response.value.status === 404) {
+    return Result.err({ message: "El usuario no existe.", type: "NOT_FOUND" });
+  }
+
+  return trySafe(() => response.value.json());
+}
+
+// 2. El consumo: el await ya resuelve en Result (await-requires-result pasa)
+//    y match() obliga a manejar cada variante (prefer-ts-pattern).
+const user = await getUser(id);
+
+const label = match(user)
+  .with({ ok: true }, ({ value }) => value.name)
+  .with({ ok: false, error: { type: "NOT_FOUND" } }, () => "No existe")
+  .with({ ok: false, error: { type: "NETWORK" } }, () => "Reintenta")
+  .exhaustive();
+```
+
+El resultado: ningún error puede escaparse (sin `try/catch` ni `.catch`, todo
+pasa por `trySafe`), ningún error pierde su origen (siempre hay `cause` hasta
+la excepción original), y ningún error queda sin manejar (el `.exhaustive()`
+de ts-pattern no compila si falta una variante). Legibilidad y manejo de
+errores dejan de depender de la disciplina del autor — humano o agente.
+
 ## Estructura del paquete
 
 ```text
@@ -302,6 +367,29 @@ export default [
 ];
 ```
 
+El contrato del back es el mismo que el del front: todo `await` debe resolver
+en un `Result` (`skapxd/await-requires-result`). Exigir además la firma
+`Promise<Result<...>>` en cada función async
+(`skapxd/async-functions-return-result`) está **apagado por defecto** — los
+motivos están documentados en la sección de esa regla. Si quieres el contrato
+duro, actívala encima del preset:
+
+```js
+export default [
+  {
+    files: ["src/server/**/*.{ts,tsx}"],
+    ...skapxd.configs.shared.backend,
+    rules: {
+      ...skapxd.configs.shared.backend.rules,
+      "skapxd/async-functions-return-result": [
+        "error",
+        { checkMissingReturnType: true },
+      ],
+    },
+  },
+];
+```
+
 ### Frontend
 
 ```js
@@ -318,7 +406,7 @@ export default [
 El contrato del front: ninguna función está obligada a retornar `Result`, pero
 toda llamada asíncrona debe ir envuelta en `trySafe` — salvo que lo llamado ya
 retorne `Result`/`Promise<Result<...>>` (exención type-aware de
-`skapxd/await-requires-try-safe`). Aplica el preset a TODO el código del front
+`skapxd/await-requires-result`). Aplica el preset a TODO el código del front
 (componentes, hooks, servicios), no solo a los componentes.
 
 ### Next.js
@@ -427,9 +515,9 @@ bloque con `linterOptions: { noInlineConfig: false }` para esos globs.
 | Regla | Qué protege |
 | --- | --- |
 | `skapxd/one-root-function-per-file` | Un archivo, una función top-level semántica. |
-| `skapxd/async-functions-return-result` | Funciones async de dominio deben retornar `Promise<Result<...>>`. |
+| `skapxd/async-functions-return-result` | Funciones async de dominio deben retornar `Promise<Result<...>>`. **Apagada por defecto; opt-in** (ver motivos en su sección). |
 | `skapxd/result-error-requires-cause` | Un `Result.err` derivado debe preservar `cause: result.error`. |
-| `skapxd/await-requires-try-safe` | Los `await` deben estar protegidos por `trySafe`, salvo que lo awaiteado ya retorne `Result`. La activa el preset `shared.frontend`. |
+| `skapxd/await-requires-result` | Todo `await` debe resolver en un `Result`: o la función llamada retorna `Promise<Result<...>>` (preferido) o se envuelve en `trySafe`. **Obligatoria en todos los presets tipados.** |
 | `skapxd/no-ad-hoc-ok-result` | Evita contratos `{ ok: ... }` hechos a mano en async exports. |
 | `skapxd/max-hook-size` | Marca hooks grandes o con demasiados `useState`. |
 | `skapxd/jsx-return-name-pascal-case` | Funciones que retornan JSX deben nombrarse como componentes. |
@@ -465,6 +553,39 @@ sugiere helpers al lado.
 
 ### `skapxd/async-functions-return-result`
 
+> **Apagada por defecto desde v0.5.0** — ningún preset la activa. La regla
+> obligatoria del sistema de errores es `skapxd/await-requires-result`.
+>
+> **Por qué se tomó esta decisión:**
+>
+> 1. **`await-requires-result` produce el mismo estado final con mejor
+>    ergonomía.** Si ningún `await` puede quedar sin `Result`, envolver con
+>    `trySafe` inline una y otra vez se vuelve incómodo rápido — la presión
+>    natural es extraer funciones que retornen `Promise<Result<...>>` con
+>    errores de dominio. Se llega a las mismas firmas que esta regla imponía,
+>    pero por gravedad, no por decreto.
+> 2. **Imponer la firma choca con los bordes del framework.** Los handlers
+>    `GET/POST` de Next, `page.tsx`, los callbacks de librerías: sus firmas no
+>    son tuyas. Esta regla necesitaba listas de excepciones
+>    (`allowFilePatterns`, `allowNamePatterns`) para convivir con eso;
+>    `await-requires-result` no necesita ninguna, porque envolver un `await`
+>    es compatible con cualquier firma.
+> 3. **Adopción incremental.** En un codebase existente, exigir la firma en
+>    cada función async lo rompe todo de golpe. Exigir `Result` en los `await`
+>    permite migrar llamada por llamada.
+>
+> Sigue disponible para quien quiera endurecer el contrato (p. ej. un backend
+> nuevo donde todas las firmas son tuyas):
+>
+> ```js
+> rules: {
+>   "skapxd/async-functions-return-result": ["error", {
+>     checkMissingReturnType: true,
+>     resultTypeNames: ["Result", "ResultValue", "SafeResult"],
+>   }],
+> }
+> ```
+
 Obliga a que funciones async en dominios configurados declaren un retorno como:
 
 ```ts
@@ -484,7 +605,8 @@ type Result<T, E> = ...;                                // ❌ Result ajeno
 async function no(): Promise<Result<number, Error>> {}  // se reporta
 ```
 
-> Requiere `projectService` (los presets `backend` y `next/server` ya lo activan).
+> Requiere `projectService` (actívalo en `languageOptions.parserOptions` o
+> apóyate en un preset tipado del plugin, que ya lo trae).
 > Sin información de tipos cae a una comprobación por nombre (`resultTypeNames`),
 > menos estricta.
 
@@ -507,27 +629,60 @@ valor del guard y `Result.err` vienen de `@skapxd/result`. Por eso funciona con
 aliases, re-exports y tipos inferidos, sin depender solo del nombre importado en
 el archivo.
 
-### `skapxd/await-requires-try-safe`
+### `skapxd/await-requires-result`
 
-> La activa el preset `shared.frontend` en todo el front: componentes, hooks,
-> handlers y servicios. El contrato queda así: ninguna función está obligada
-> a retornar `Result`, pero toda llamada asíncrona debe ir en `trySafe` — salvo
-> que lo llamado ya retorne `Result` (ver exención más abajo). Para activarla
-> en otros globs, añádela tú mismo:
+> **Es la regla obligatoria del sistema de errores**: la activan todos los
+> presets tipados (`shared.frontend`, `shared.backend`, `next/server`,
+> `astro/typescript`). El contrato queda así: ninguna función está obligada
+> a retornar `Result` (eso es `async-functions-return-result`, apagada por
+> defecto), pero todo `await` debe **resolver** en uno. Para activarla en
+> otros globs, añádela tú mismo:
 >
 > ```js
 > rules: {
->   "skapxd/await-requires-try-safe": ["error", {
+>   "skapxd/await-requires-result": ["error", {
 >     trySafeCallNames: ["trySafe"],
 >     allowFilePatterns: [],
 >   }],
 > }
 > ```
+>
+> (`skapxd/await-requires-try-safe` es el nombre anterior; sigue funcionando
+> como alias deprecado y se eliminará en una versión futura.)
+
+Hay dos caminos válidos, y la regla recomienda el primero:
 
-Obliga a proteger operaciones `await` con `trySafe`:
+**1. El camino preferido: extrae la operación a una función que retorne
+`Promise<Result<...>>`** y modela ahí los errores de dominio. El `trySafe` vive
+dentro de esa función, en la frontera con el código que lanza, y el resto del
+código habla en errores con significado:
 
 ```ts
-const result = await trySafe(() => client.execute({...}));
+async function getUser(id: string): Promise<Result<User, UserError>> {
+  const response = await trySafe(() => fetch(`/users/${id}`));
+
+  if (!response.ok) {
+    return Result.err({
+      cause: response.error,
+      message: "No pude cargar el usuario.",
+      type: "USER_FETCH_FAILED",
+    });
+  }
+
+  return trySafe(() => response.value.json());
+}
+
+// En el componente: ya resuelve en Result, pasa directo.
+const user = await getUser(id); // ✅
+```
+
+La detección es type-aware: la regla resuelve el símbolo hasta `@skapxd/result`,
+así que un `Result` casero (homónimo, de otra librería) no exime.
+
+**2. La alternativa rápida: envuelve el `await` en `trySafe` ahí mismo:**
+
+```ts
+const result = await trySafe(() => client.execute({...})); // ✅
 ```
 
 o dentro de un callback:
@@ -539,18 +694,9 @@ const result = await trySafe(async () => {
 });
 ```
 
-Si lo que se awaitea ya retorna `Result`/`Promise<Result<...>>` de
-`@skapxd/result`, la regla no exige `trySafe`: los errores ya están modelados en
-el tipo y envolverlo sería redundante.
-
-```ts
-declare function getUser(): Promise<Result<User, Error>>;
-
-const result = await getUser(); // ✅ ya es un Result, no necesita trySafe
-```
-
-Esta exención es type-aware: un `Result` casero (que no venga de
-`@skapxd/result`) no exime.
+Sirve para código de pegamento, pero deja el error sin modelar (`Result<T,
+unknown>`). Cuando la misma operación se repite o el error importa, el mensaje
+de la regla empuja hacia el camino 1.
 
 ### `skapxd/max-hook-size`
 
@@ -628,8 +774,9 @@ const result = await trySafe(() => client.execute(query)); // ✅
 if (!result.ok) return Result.err({ cause: result.error, type: "DB_FAILED" });
 ```
 
-Se complementa con `result-error-requires-cause` (preservar la causa) y, si la
-activas, con `await-requires-try-safe` (que además exige envolver cada `await`).
+Se complementa con `result-error-requires-cause` (preservar la causa) y con
+`await-requires-result` (obligatoria en los presets tipados: cada `await`
+resuelve en un `Result`).
 
 ### `skapxd/no-promise-chain`
 
@@ -702,7 +849,7 @@ cierran el hueco.
 
 En cambio, las reglas atadas a `@skapxd/result`
 (`async-functions-return-result`, `result-error-requires-cause`,
-`await-requires-try-safe`) **no** dependen de nombres: resuelven el símbolo hasta
+`await-requires-result`) **no** dependen de nombres: resuelven el símbolo hasta
 el paquete real (vía el `name` de su `package.json`), así que funcionan con
 alias, re-exports y en monorepos.
 

package/dist/astro/index.d.mts

@@ -47,6 +47,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         skapxd: unknown;
     };
     rules: {
+        "skapxd/await-requires-result": string;
         "skapxd/result-error-requires-cause": string;
     };
 })[];

package/dist/astro/index.d.ts

@@ -47,6 +47,7 @@ declare function createAstroConfigs(pluginReference: unknown): ({
         skapxd: unknown;
     };
     rules: {
+        "skapxd/await-requires-result": string;
         "skapxd/result-error-requires-cause": string;
     };
 })[];

package/dist/astro/index.js

@@ -92,6 +92,7 @@ function createAstroConfigs(pluginReference) {
       name: "skapxd/astro/typescript",
       plugins: { skapxd: pluginReference },
       rules: {
+        "skapxd/await-requires-result": "error",
         "skapxd/result-error-requires-cause": "error"
       }
     }

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-typed-language-options.ts","../../src/astro/configs.ts"],"sourcesContent":["export { createAstroConfigs } from \"./configs\";\n","export const baseRules = {\n  \"skapxd/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"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/result-error-requires-cause\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACRA,+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,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","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/no-ad-hoc-ok-result\": \"error\",\n  \"skapxd/no-deep-relative-imports\": \"error\",\n  \"skapxd/no-promise-chain\": \"error\",\n  \"skapxd/no-try-catch\": \"error\",\n  \"skapxd/one-root-function-per-file\": \"error\",\n  \"skapxd/prefer-ts-pattern\": \"error\",\n  \"skapxd/result-error-requires-cause\": \"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      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,YAAY;AAAA,EACvB,8BAA8B;AAAA,EAC9B,mCAAmC;AAAA,EACnC,2BAA2B;AAAA,EAC3B,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,4BAA4B;AAAA,EAC5B,sCAAsC;AACxC;;;ACRA,+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,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":["tseslint","import_typescript_eslint","tseslint"]}

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
 import {
   createAstroConfigs
-} from "../chunk-P32EECMV.mjs";
-import "../chunk-TFGBNVXP.mjs";
+} from "../chunk-7H7DRTP2.mjs";
+import "../chunk-RWQGOTVZ.mjs";
 export {
   createAstroConfigs
 };

package/dist/{chunk-P32EECMV.mjs → chunk-7H7DRTP2.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-TFGBNVXP.mjs";
+} from "./chunk-RWQGOTVZ.mjs";
 
 // src/astro/configs.ts
 function createAstroConfigs(pluginReference) {
@@ -30,6 +30,7 @@ function createAstroConfigs(pluginReference) {
       name: "skapxd/astro/typescript",
       plugins: { skapxd: pluginReference },
       rules: {
+        "skapxd/await-requires-result": "error",
         "skapxd/result-error-requires-cause": "error"
       }
     }
@@ -39,4 +40,4 @@ function createAstroConfigs(pluginReference) {
 export {
   createAstroConfigs
 };
-//# sourceMappingURL=chunk-P32EECMV.mjs.map
+//# sourceMappingURL=chunk-7H7DRTP2.mjs.map

package/dist/{chunk-P32EECMV.mjs.map → chunk-7H7DRTP2.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/astro/configs.ts"],"sourcesContent":["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/result-error-requires-cause\": \"error\",\n      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;AAMO,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,sCAAsC;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/astro/configs.ts"],"sourcesContent":["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      },\n    },\n  ];\n}\n"],"mappings":";;;;;;;AAMO,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,MACxC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-SUNOHZFS.mjs → chunk-QJQ2E2NG.mjs}

@@ -2,7 +2,7 @@ import {
   baseRules,
   createBaseLanguageOptions,
   createTypedLanguageOptions
-} from "./chunk-TFGBNVXP.mjs";
+} from "./chunk-RWQGOTVZ.mjs";
 
 // src/next/configs.ts
 function createNextConfigs(pluginReference) {
@@ -22,21 +22,11 @@ function createNextConfigs(pluginReference) {
       plugins: { skapxd: pluginReference },
       rules: {
         ...baseRules,
-        "skapxd/async-functions-return-result": [
-          "error",
-          {
-            allowFilePatterns: [
-              "/(route|page|layout|template|loading|error|not-found)\\.tsx?$"
-            ],
-            allowNamePatterns: [
-              "^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$",
-              "^handle(Get|Post|Put|Patch|Delete|Head|Options)$",
-              "^start$"
-            ],
-            checkMissingReturnType: true,
-            resultTypeNames: ["Result", "ResultValue", "SafeResult"]
-          }
-        ]
+        // Obligatoria: todo await resuelve en Result. A diferencia de
+        // async-functions-return-result (apagada por defecto), no necesita
+        // excepciones para los entrypoints de Next: envolver un await en
+        // trySafe es compatible con cualquier firma que imponga el framework.
+        "skapxd/await-requires-result": "error"
       }
     },
     {
@@ -63,4 +53,4 @@ function createNextConfigs(pluginReference) {
 export {
   createNextConfigs
 };
-//# sourceMappingURL=chunk-SUNOHZFS.mjs.map
+//# sourceMappingURL=chunk-QJQ2E2NG.mjs.map

package/dist/chunk-QJQ2E2NG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/next/configs.ts"],"sourcesContent":["import {\n  baseRules,\n  createBaseLanguageOptions,\n  createTypedLanguageOptions,\n} from \"#/shared/configs\";\n\nexport function createNextConfigs(pluginReference: unknown) {\n  const baseLanguageOptions = createBaseLanguageOptions();\n  const typedLanguageOptions = createTypedLanguageOptions();\n\n  return [\n    {\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/next/base\",\n      plugins: { skapxd: pluginReference },\n      rules: baseRules,\n    },\n    {\n      files: [\"src/app/api/**/*.{ts,tsx}\", \"src/server/**/*.{ts,tsx}\"],\n      languageOptions: typedLanguageOptions,\n      name: \"skapxd/next/server\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        ...baseRules,\n        // Obligatoria: todo await resuelve en Result. A diferencia de\n        // async-functions-return-result (apagada por defecto), no necesita\n        // excepciones para los entrypoints de Next: envolver un await en\n        // trySafe es compatible con cualquier firma que imponga el framework.\n        \"skapxd/await-requires-result\": \"error\",\n      },\n    },\n    {\n      files: [\"**/*.tsx\"],\n      languageOptions: baseLanguageOptions,\n      name: \"skapxd/next/react\",\n      plugins: { skapxd: pluginReference },\n      rules: {\n        \"skapxd/jsx-return-name-pascal-case\": \"error\",\n        \"skapxd/no-functions-inside-components\": \"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  ];\n}\n"],"mappings":";;;;;;;AAMO,SAAS,kBAAkB,iBAA0B;AAC1D,QAAM,sBAAsB,0BAA0B;AACtD,QAAM,uBAAuB,2BAA2B;AAExD,SAAO;AAAA,IACL;AAAA,MACE,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,OAAO,CAAC,6BAA6B,0BAA0B;AAAA,MAC/D,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA,QAKH,gCAAgC;AAAA,MAClC;AAAA,IACF;AAAA,IACA;AAAA,MACE,OAAO,CAAC,UAAU;AAAA,MAClB,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,SAAS,EAAE,QAAQ,gBAAgB;AAAA,MACnC,OAAO;AAAA,QACL,sCAAsC;AAAA,QACtC,yCAAyC;AAAA,QACzC,8BAA8B;AAAA,QAC9B,wBAAwB;AAAA,UACtB;AAAA,UACA;AAAA,YACE,UAAU;AAAA,YACV,aAAa;AAAA,UACf;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-RP7BOODV.mjs → chunk-QNSHGNVQ.mjs}

@@ -593,8 +593,8 @@ var asyncFunctionsReturnResult = {
       description: "Exige Promise<Result<...>> en funciones async de dominio."
     },
     messages: {
-      missingReturnType: "La funcion async `{{name}}` debe declarar Promise<Result<...>> como tipo de retorno.",
-      invalidReturnType: "La funcion async `{{name}}` debe retornar Promise<Result<...>> para modelar errores de forma explicita."
+      missingReturnType: "La funcion async `{{name}}` debe declarar Promise<Result<...>> como tipo de retorno: trySafe en la frontera, errores de dominio con `cause`, y el consumidor decide con `match()` de ts-pattern.",
+      invalidReturnType: "La funcion async `{{name}}` debe retornar Promise<Result<...>> para modelar errores de forma explicita: trySafe en la frontera, errores de dominio con `cause`, y el consumidor decide con `match()` de ts-pattern."
     },
     schema: [
       {
@@ -780,7 +780,7 @@ var noAdHocOkResult = {
       description: "Prohibe retornar contratos ad hoc con ok en funciones async exportadas."
     },
     messages: {
-      adHocOkResult: "No retornes objetos ad hoc con `ok` desde la funcion async `{{name}}`. Usa Result.ok(...) / Result.err(...) con un error discriminado `{ type: ... }`."
+      adHocOkResult: "No retornes objetos ad hoc con `ok` desde la funcion async `{{name}}`. Usa Result.ok(...) / Result.err(...) de @skapxd/result con un error discriminado `{ type: ... }`: un unico contrato Result permite consumir cada variante con `match()` de ts-pattern y `.exhaustive()`."
     },
     schema: []
   },
@@ -807,8 +807,8 @@ var noAdHocOkResult = {
   }
 };
 
-// src/utils/get-await-requires-try-safe-options.ts
-function getAwaitRequiresTrySafeOptions(options = {}) {
+// src/utils/get-await-requires-result-options.ts
+function getAwaitRequiresResultOptions(options = {}) {
   return {
     allowFilePatterns: options.allowFilePatterns ?? [],
     trySafeCallNames: options.trySafeCallNames ?? ["trySafe"]
@@ -895,15 +895,15 @@ function isTrySafeCall(node, trySafeCallNames) {
   return node?.type === "CallExpression" && isCalleeNamed(node.callee, trySafeCallNames);
 }
 
-// src/rules/await-requires-try-safe.ts
-var awaitRequiresTrySafe = {
+// src/rules/await-requires-result.ts
+var awaitRequiresResult = {
   meta: {
     type: "problem",
     docs: {
-      description: "Exige que los await esten protegidos por trySafe."
+      description: "Exige que todo await resuelva en un Result: una funcion que retorne Promise<Result<...>> o trySafe en el sitio."
     },
     messages: {
-      unprotectedAwait: "El await dentro de `{{name}}` no esta protegido por trySafe. Envuelve la operacion asi: `{{suggestion}}`."
+      awaitWithoutResult: "El await dentro de `{{name}}` no resuelve en un Result. Mejor opcion: extrae la operacion a una funcion que retorne Promise<Result<...>> y modela ahi los errores de dominio con `{ type, message, cause }` (el trySafe vive dentro de esa funcion). Alternativa: envuelvela aqui mismo: `{{suggestion}}`. En ambos casos, consume el Result con `match()` de ts-pattern."
     },
     schema: [
       {
@@ -923,7 +923,7 @@ var awaitRequiresTrySafe = {
     ]
   },
   create(context) {
-    const options = getAwaitRequiresTrySafeOptions(context.options[0]);
+    const options = getAwaitRequiresResultOptions(context.options[0]);
     const filename = context.filename ?? context.getFilename();
     const sourceCode = context.sourceCode ?? context.getSourceCode();
     const typeContext = getTypeContext(context);
@@ -958,7 +958,7 @@ var awaitRequiresTrySafe = {
             name: getAwaitScopeName(node),
             suggestion: getTrySafeAwaitSuggestion(node.argument, sourceCode)
           },
-          messageId: "unprotectedAwait",
+          messageId: "awaitWithoutResult",
           node
         });
       }
@@ -1115,7 +1115,7 @@ var resultErrorRequiresCause = {
       description: "Exige preservar result.error como cause cuando una funcion que retorna Result transforma un Result fallido en Result.err."
     },
     messages: {
-      missingCause: "El error de `{{name}}` ya existe como `{{name}}.error`. Preservalo en Result.err con `cause: {{name}}.error`."
+      missingCause: "El error de `{{name}}` ya existe como `{{name}}.error`. Preservalo en Result.err con `cause: {{name}}.error`: la cadena de causas conecta el error de dominio con la excepcion original que capturo `trySafe`; sin ella el debugging pierde el contexto."
     },
     schema: []
   },
@@ -1382,7 +1382,7 @@ var noTryCatch = {
       description: "Prohibe try/catch; usa trySafe de @skapxd/result para modelar el error como Result."
     },
     messages: {
-      noTryCatch: "Usa `trySafe` de @skapxd/result en lugar de try/catch. El error queda modelado como Result en vez de saltar como excepcion."
+      noTryCatch: "Usa `trySafe` de @skapxd/result en lugar de try/catch: el error queda modelado como Result en vez de saltar como excepcion. Luego mapealo a un error de dominio `{ type, message, cause }` y consumelo con `match()` de ts-pattern."
     },
     schema: []
   },
@@ -1406,8 +1406,8 @@ var preferTsPattern = {
       description: "Prefiere match() de ts-pattern sobre switch/case y ternarios anidados."
     },
     messages: {
-      noSwitch: "Usa `match()` de ts-pattern en lugar de switch/case para un control de flujo exhaustivo y tipado.",
-      noNestedTernary: "Usa `match()` de ts-pattern en lugar de ternarios anidados; mejora la legibilidad y la exhaustividad."
+      noSwitch: "Usa `match()` de ts-pattern en lugar de switch/case para un control de flujo exhaustivo y tipado. Es la pieza que cierra el sistema de errores: un Result con errores `{ type: ... }` se consume con una rama `.with()` por variante y `.exhaustive()` garantiza que ninguna quede sin manejar.",
+      noNestedTernary: "Usa `match()` de ts-pattern en lugar de ternarios anidados; mejora la legibilidad y `.exhaustive()` obliga a cubrir todos los casos."
     },
     schema: []
   },
@@ -1483,7 +1483,7 @@ var noPromiseChain = {
       description: "Prohibe encadenar .then/.catch/.finally en promesas; usa await (envuelto en trySafe)."
     },
     messages: {
-      noPromiseChain: "No encadenes `.{{method}}()` en una promesa. La unica forma de tratar funciones asincronas es `await` (envuelto en `trySafe`)."
+      noPromiseChain: "No encadenes `.{{method}}()` en una promesa. La unica forma de tratar funciones asincronas es `await`: o la funcion llamada ya retorna Promise<Result<...>> o envuelve la llamada en `trySafe` de @skapxd/result."
     },
     schema: [
       {
@@ -1533,7 +1533,16 @@ var rules = {
   "jsx-return-name-pascal-case": jsxReturnNamePascalCase,
   "async-functions-return-result": asyncFunctionsReturnResult,
   "no-ad-hoc-ok-result": noAdHocOkResult,
-  "await-requires-try-safe": awaitRequiresTrySafe,
+  "await-requires-result": awaitRequiresResult,
+  // Alias deprecado del nombre anterior; se elimina en una versión futura.
+  "await-requires-try-safe": {
+    ...awaitRequiresResult,
+    meta: {
+      ...awaitRequiresResult.meta,
+      deprecated: true,
+      replacedBy: ["skapxd/await-requires-result"]
+    }
+  },
   "result-error-requires-cause": resultErrorRequiresCause,
   "max-hook-size": maxHookSize,
   "no-deep-relative-imports": noDeepRelativeImports,
@@ -1547,4 +1556,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-RP7BOODV.mjs.map
+//# sourceMappingURL=chunk-QNSHGNVQ.mjs.map