fiscal-es 0.1.0 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+## 1.0.0
+
+**Breaking: all public identifiers renamed to English** (ADR-009). The computation is unchanged: every verified
+case in `cases/` gives the same output as in 0.1.0. The YAML keys of the cases do not change.
+
+Error messages are now in English.
+
+| 0.1.0 | 1.0.0 |
+| ----- | ----- |
+| `Centimos` | `Cents` |
+| `Bp`, `bp`, `parseEuros`, `formatEuros` | unchanged |
+| `CERO` | `ZERO` |
+| `sumar` | `add` |
+| `restar` | `subtract` |
+| `max0` | `clampZero` |
+| `porBp` | `timesBp` |
+| `redondearCentimos` | `roundCents` |
+| `calcularAhorro` | `computeSavingsTax` |
+| `EntradaAhorro` | `SavingsInput` |
+| `EntradaAhorro.ejercicio` | `SavingsInput.taxYear` |
+| `EntradaAhorro.gananciasPatrimoniales` | `SavingsInput.capitalGains` |
+| `EntradaAhorro.perdidasPatrimoniales` | `SavingsInput.capitalLosses` |
+| `EntradaAhorro.rendimientosCapitalMobiliario` | `SavingsInput.investmentIncome` |
+| `ResultadoAhorro` | `SavingsResult` |
+| `ResultadoAhorro.baseLiquidableAhorro` | `SavingsResult.savingsTaxableBase` |
+| `ResultadoAhorro.cuotaEstatal` | `SavingsResult.stateTax` |
+| `ResultadoAhorro.cuotaAutonomica` | `SavingsResult.regionalTax` |
+| `ResultadoAhorro.cuotaAhorro` | `SavingsResult.totalTax` |
+| `getTabla` | `getTaxTable` |
+| `ejerciciosDisponibles` | `availableTaxYears` |
+| `TablaIRPF` | `TaxTable` |
+| `TablaIRPF.ejercicio` | `TaxTable.taxYear` |
+| `TablaIRPF.fuente` / `fuente.verificado` | `TaxTable.source` / `source.verifiedOn` |
+| `TablaIRPF.escalaAhorro` | `TaxTable.brackets` |
+| `TramoAhorro` | `TaxBracket` |
+| `TramoAhorro.hasta` / `estatalBp` / `autonomicoBp` | `TaxBracket.upTo` / `stateBp` / `regionalBp` |
+| `EjercicioSinTabla` (`.ejercicio`, `name`) | `UnknownTaxYear` (`.taxYear`, `name`) |
+| `EntradaInvalida` (`.campo`, `.valor`, `name`) | `InvalidInput` (`.field`, `.value`, `name`) |
+
+## 0.1.0
+
+First release.

package/README.md

@@ -1,94 +1,117 @@
 # fiscal-es
 
-Cuota del IRPF sobre la base del ahorro (España, territorio común): integra ganancias, pérdidas y rendimientos
-del capital mobiliario de un ejercicio y aplica la escala estatal y la autonómica por separado.
+Spanish personal income tax (IRPF) on the savings base (Spain, common territory): integrates capital gains, capital
+losses and investment income for one tax year and applies the state and regional scales separately.
 
-TypeScript, ESM, sin dependencias de runtime, funciones puras. Importes en céntimos enteros (`Centimos`) y tipos
-en puntos básicos enteros (`Bp`); nunca coma flotante.
+TypeScript, ESM, no runtime dependencies, pure functions. Amounts in integer cents (`Cents`) and rates in integer
+basis points (`Bp`); never floating point.
 
-## Instalación
+## Installation
 
 ```sh
 npm install fiscal-es
 ```
 
-Solo ESM (`import`); no hay build CommonJS.
+ESM only (`import`); there is no CommonJS build.
 
-## Uso
+## Usage
 
-### Calcular la cuota del ahorro
+### Computing the savings tax
 
 ```js
-import { calcularAhorro, formatEuros, parseEuros } from "fiscal-es";
+import { computeSavingsTax, formatEuros, parseEuros } from "fiscal-es";
 
-const r = calcularAhorro({
-  ejercicio: 2026,
-  gananciasPatrimoniales: parseEuros("10000.00"),
-  perdidasPatrimoniales: parseEuros("3000.00"),
-  rendimientosCapitalMobiliario: parseEuros("0.00"),
+const r = computeSavingsTax({
+  taxYear: 2026,
+  capitalGains: parseEuros("10000.00"),
+  capitalLosses: parseEuros("3000.00"),
+  investmentIncome: parseEuros("0.00"),
 });
-// r = { baseLiquidableAhorro: 700000, cuotaEstatal: 67500, cuotaAutonomica: 67500, cuotaAhorro: 135000 }
-formatEuros(r.cuotaAhorro); // "1350.00"
+// r = { savingsTaxableBase: 700000, stateTax: 67500, regionalTax: 67500, totalTax: 135000 }
+formatEuros(r.totalTax); // "1350.00"
 ```
 
-`parseEuros` solo acepta el formato `"-1234.56"` (punto decimal, dos decimales); cualquier otro lanza
-`SyntaxError`. Una entrada sin sentido (importes no enteros, ganancias o pérdidas negativas) lanza
-`EntradaInvalida`; un ejercicio sin tabla, `EjercicioSinTabla`.
+`parseEuros` only accepts the format `"-1234.56"` (decimal point, two decimals); anything else throws
+`SyntaxError`. Input that makes no sense (non-integer amounts, negative gains or losses) throws `InvalidInput`;
+a tax year without a table throws `UnknownTaxYear`.
 
-### Ejercicios disponibles
+### Available tax years
 
 ```js
-import { ejerciciosDisponibles, getTabla } from "fiscal-es";
+import { availableTaxYears, getTaxTable } from "fiscal-es";
 
-for (const ejercicio of ejerciciosDisponibles()) {
-  console.log(ejercicio, getTabla(ejercicio).fuente.verificado); // 2026 "2026-10-25"
+for (const taxYear of availableTaxYears()) {
+  console.log(taxYear, getTaxTable(taxYear).source.verifiedOn); // 2026 "2026-10-25"
 }
 ```
 
-## Rango y errores
-
-El cálculo es exacto para importes de hasta ≈ 9 000 millones de euros por operación: con tipos de hasta
-10 000 bp, el producto intermedio céntimos × puntos básicos cabe en `Number.MAX_SAFE_INTEGER`. Por encima, una
-operación cuyo resultado o producto intermedio salga del rango entero seguro lanza `RangeError`.
-
-- `SyntaxError`: `parseEuros` recibe un formato distinto de `"-1234.56"` (ver [Uso](#uso)).
-- `EntradaInvalida`: `calcularAhorro` recibe un importe que no es un entero de céntimos (`NaN`, fracción de
-  céntimo), ganancias o pérdidas negativas, o un ejercicio no entero.
-- `EjercicioSinTabla`: `calcularAhorro` recibe un ejercicio sin tabla.
-- `RangeError`: `parseEuros`, `sumar`, `restar`, `porBp` o `redondearCentimos` reciben o producen un valor fuera
-  del rango entero seguro.
-
-## Ejercicios soportados
-
-| Ejercicio | Escala verificada |
-| --------- | ----------------- |
-| 2026      | 2026-10-25        |
-
-## `cases/`: la spec ejecutable
-
-Cada fichero YAML de `cases/` es un caso con su entrada, la salida esperada al céntimo, la referencia normativa
-y la fecha en que una persona lo verificó. La suite del paquete los ejecuta todos contra el motor; un cambio en
-el motor que altere la salida de un caso verificado es un cambio de versión mayor. El formato está en
-`cases/SCHEMA.md`. `cases/_propuestos/` contiene casos aún no verificados y no forma parte de la spec.
-
-## Límites conocidos
-
-- Sin compensación cruzada: un saldo negativo de ganancias y pérdidas no compensa rendimientos del capital
-  mobiliario positivos, ni al revés (art. 49.1 LIRPF). El saldo negativo simplemente no tributa.
-- Sin arrastre de saldos negativos a los cuatro ejercicios siguientes (art. 49.2 LIRPF).
-- Sin regímenes forales (Navarra, País Vasco).
-- Solo la base del ahorro: no calcula la base general, mínimos personales ni deducciones.
-
-## Desarrollo en el monorepo
-
-`exports` tiene una condición propia, `fiscal-es-src`, que apunta a `src/` para que la app del monorepo use el
-motor sin construirlo; los consumidores externos no la activan y reciben `dist/`.
-
-## Aviso
-
-Herramienta de cálculo. No es asesoramiento fiscal ni financiero. Comprueba tu caso con la normativa vigente o
-con un profesional.
-
-## Licencia
+## Range and errors
+
+The computation is exact for amounts up to ≈ 9 000 million euros per operation: with rates up to 10 000 bp, the
+intermediate product cents × basis points fits in `Number.MAX_SAFE_INTEGER`. Above that, any operation whose result
+or intermediate product leaves the safe integer range throws `RangeError`.
+
+- `SyntaxError`: `parseEuros` receives a format other than `"-1234.56"` (see [Usage](#usage)).
+- `InvalidInput`: `computeSavingsTax` receives an amount that is not an integer number of cents (`NaN`, a fraction
+  of a cent), negative gains or losses, or a non-integer tax year.
+- `UnknownTaxYear`: `computeSavingsTax` receives a tax year without a table.
+- `RangeError`: `parseEuros`, `add`, `subtract`, `timesBp` or `roundCents` receive or produce a value outside the
+  safe integer range.
+
+## Supported tax years
+
+| Tax year | Scale verified on |
+| -------- | ----------------- |
+| 2026     | 2026-10-25        |
+
+## `cases/`: the executable spec
+
+Each YAML file in `cases/` is a case with its input, the expected output to the cent, the legal reference and the
+date on which a person verified it. The package's test suite runs all of them against the engine; a change to the
+engine that alters the output of a verified case is a major version change. The format is described in
+`cases/SCHEMA.md`. The cases are written in Spanish, with Spanish keys (`ganancias_patrimoniales`, `cuota_ahorro`…),
+because they are checked against the Spanish tax return manual; [Terminology](#terminology) maps them to the API.
+
+## Terminology
+
+| Identifier | Spanish term | LIRPF |
+| ---------- | ------------ | ----- |
+| `computeSavingsTax` | cuota del ahorro | arts. 49, 50.2, 66.1 y 76 |
+| `SavingsInput` / `SavingsResult` | entrada / resultado del ahorro | |
+| `taxYear` | ejercicio | |
+| `capitalGains` (`ganancias_patrimoniales`) | ganancias patrimoniales | art. 33 |
+| `capitalLosses` (`perdidas_patrimoniales`) | pérdidas patrimoniales | art. 33 |
+| `investmentIncome` (`rendimientos_capital_mobiliario`) | rendimientos del capital mobiliario | art. 25 |
+| `savingsTaxableBase` (`base_liquidable_ahorro`) | base liquidable del ahorro | arts. 49 y 50.2 |
+| `stateTax` (`cuota_estatal`) | cuota estatal | art. 66.1 |
+| `regionalTax` (`cuota_autonomica`) | cuota autonómica | art. 76 |
+| `totalTax` (`cuota_ahorro`) | cuota del ahorro (estatal + autonómica) | |
+| `TaxTable` / `getTaxTable` / `availableTaxYears` | tabla normativa del ejercicio / ejercicios disponibles | |
+| `TaxBracket` (`upTo`, `stateBp`, `regionalBp`) | tramo de la escala del ahorro (hasta, tipo estatal, tipo autonómico) | arts. 66.1 y 76 |
+| `UnknownTaxYear` | ejercicio sin tabla | |
+| `InvalidInput` | entrada inválida | |
+| `Cents` / `Bp` | céntimos / puntos básicos | |
+| `add` / `subtract` / `clampZero` / `ZERO` | sumar / restar / acotar a cero / cero | |
+| `timesBp` / `roundCents` | céntimos × puntos básicos / redondeo al céntimo | |
+
+## Known limitations
+
+- No cross-offsetting: a negative balance of gains and losses does not offset positive investment income, nor the
+  other way round (art. 49.1 LIRPF). The negative balance simply is not taxed.
+- No carry-forward of negative balances to the following four tax years (art. 49.2 LIRPF).
+- No foral regimes (Navarra, País Vasco).
+- Savings base only: does not compute the general base, personal allowances or deductions.
+
+## Development in the monorepo
+
+`exports` has a custom condition, `fiscal-es-src`, pointing to `src/` so the monorepo app can use the engine without
+building it; external consumers do not enable it and get `dist/`.
+
+## Disclaimer
+
+A calculation tool. Not tax or financial advice. Check your situation against current legislation or with a
+professional.
+
+## License
 
 MIT

package/cases/irpf/compensacion/irpf-compensacion-2026-011.yaml

@@ -0,0 +1,24 @@
+id: irpf-compensacion-2026-011
+title: Dos saldos con céntimos que suman exactamente el umbral del primer tramo (6.000,00)
+ejercicio: 2026
+estado: verde
+normativa:
+  - ref: "Ley 35/2006 IRPF, art. 49 (integración y compensación en la base imponible del ahorro)"
+  - ref: "Ley 35/2006 IRPF, art. 66.1 (gravamen estatal base del ahorro)"
+  - ref: "Ley 35/2006 IRPF, art. 76 (gravamen autonómico base del ahorro)"
+verificado: "2026-10-26"
+input:
+  ganancias_patrimoniales: "4000.50"
+  perdidas_patrimoniales: "1000.50"
+  rendimientos_capital_mobiliario: "3000.00"
+expected:
+  base_liquidable_ahorro: "6000.00"
+  cuota_estatal: "570.00"
+  cuota_autonomica: "570.00"
+  cuota_ahorro: "1140.00"
+notas: >
+  Saldo G − P = 400.050 − 100.050 = 300.000 c; RCM 300.000 c; base 600.000 c = 6.000,00, exactamente en el
+  límite inclusivo del primer tramo. 600.000 c × 950 bp = 570.000.000 → 57.000 c = 570,00 por cuota; total 1.140,00.
+  Los casos de umbral existentes (006, 018, 015, 019) llegan al límite con un solo saldo; este llega sumando
+  dos saldos y con céntimos en ganancias y pérdidas, y detecta un `<` en lugar de `<=` en el corte del tramo
+  cuando la base viene de la integración.

package/cases/irpf/compensacion/irpf-compensacion-2026-012.yaml

@@ -0,0 +1,23 @@
+id: irpf-compensacion-2026-012
+title: Pérdidas con céntimos que dejan la base un céntimo por encima del segundo umbral (50.000,01)
+ejercicio: 2026
+estado: verde
+normativa:
+  - ref: "Ley 35/2006 IRPF, art. 49 (integración y compensación en la base imponible del ahorro)"
+  - ref: "Ley 35/2006 IRPF, art. 66.1 (gravamen estatal base del ahorro)"
+  - ref: "Ley 35/2006 IRPF, art. 76 (gravamen autonómico base del ahorro)"
+verificado: "2026-10-26"
+input:
+  ganancias_patrimoniales: "50500.00"
+  perdidas_patrimoniales: "499.99"
+  rendimientos_capital_mobiliario: "0.00"
+expected:
+  base_liquidable_ahorro: "50000.01"
+  cuota_estatal: "5190.00"
+  cuota_autonomica: "5190.00"
+  cuota_ahorro: "10380.00"
+notas: >
+  Saldo G − P = 5.050.000 − 49.999 = 5.000.001 c = 50.000,01. Por cuota: 600.000 × 950 = 570.000.000;
+  4.400.000 × 1.050 = 4.620.000.000; 1 × 1.150 = 1.150; acumulado 5.190.001.150 c·bp → 519.000,115 c →
+  519.000 c = 5.190,00. Total 10.380,00. Mismo resultado que irpf-ahorro-2026-011, pero la base sale de restar
+  pérdidas con céntimos: detecta errores de signo o de redondeo en la compensación antes de la escala.

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+/** No tax table registered for the requested tax year ("ejercicio sin tabla"). */
+export declare class UnknownTaxYear extends Error {
+    readonly taxYear: number;
+    readonly name = "UnknownTaxYear";
+    constructor(taxYear: number);
+}
+/** Invalid input ("entrada inválida"): non-integer amounts, negative gains or losses, non-integer tax year. */
+export declare class InvalidInput extends Error {
+    readonly field: string;
+    readonly value: number;
+    readonly name = "InvalidInput";
+    constructor(field: string, value: number, reason: string);
+}

package/dist/errors.js

@@ -0,0 +1,20 @@
+/** No tax table registered for the requested tax year ("ejercicio sin tabla"). */
+export class UnknownTaxYear extends Error {
+    taxYear;
+    name = "UnknownTaxYear";
+    constructor(taxYear) {
+        super(`No tax table for tax year ${String(taxYear)}`);
+        this.taxYear = taxYear;
+    }
+}
+/** Invalid input ("entrada inválida"): non-integer amounts, negative gains or losses, non-integer tax year. */
+export class InvalidInput extends Error {
+    field;
+    value;
+    name = "InvalidInput";
+    constructor(field, value, reason) {
+        super(`Invalid input: ${field} = ${String(value)} (${reason})`);
+        this.field = field;
+        this.value = value;
+    }
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export type { Bp, Centimos } from "./dinero.js";
-export { bp, CERO, formatEuros, max0, parseEuros, porBp, redondearCentimos, restar, sumar } from "./dinero.js";
-export { EjercicioSinTabla, EntradaInvalida } from "./errores.js";
-export { calcularAhorro } from "./irpf/ahorro.js";
-export type { EntradaAhorro, ResultadoAhorro } from "./irpf/tipos.js";
-export type { TablaIRPF, TramoAhorro } from "./tablas/index.js";
-export { ejerciciosDisponibles, getTabla } from "./tablas/index.js";
+export type { Bp, Cents } from "./money.js";
+export { add, bp, clampZero, formatEuros, parseEuros, roundCents, subtract, timesBp, ZERO } from "./money.js";
+export { InvalidInput, UnknownTaxYear } from "./errors.js";
+export { computeSavingsTax } from "./tax/savings.js";
+export type { SavingsInput, SavingsResult } from "./tax/tipos.js";
+export type { TaxBracket, TaxTable } from "./tables/index.js";
+export { availableTaxYears, getTaxTable } from "./tables/index.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { bp, CERO, formatEuros, max0, parseEuros, porBp, redondearCentimos, restar, sumar } from "./dinero.js";
-export { EjercicioSinTabla, EntradaInvalida } from "./errores.js";
-export { calcularAhorro } from "./irpf/ahorro.js";
-export { ejerciciosDisponibles, getTabla } from "./tablas/index.js";
+export { add, bp, clampZero, formatEuros, parseEuros, roundCents, subtract, timesBp, ZERO } from "./money.js";
+export { InvalidInput, UnknownTaxYear } from "./errors.js";
+export { computeSavingsTax } from "./tax/savings.js";
+export { availableTaxYears, getTaxTable } from "./tables/index.js";

package/dist/money.d.ts

@@ -0,0 +1,32 @@
+declare const centsBrand: unique symbol;
+declare const bpBrand: unique symbol;
+/** Amount in euro cents ("importe en céntimos"). Safe integer. */
+export type Cents = number & {
+    readonly [centsBrand]: true;
+};
+/** Rate in basis points ("tipo en puntos básicos"): 12.34 % = 1234. Safe integer. */
+export type Bp = number & {
+    readonly [bpBrand]: true;
+};
+/** Builds a `Bp` ("puntos básicos") from an integer. */
+export declare function bp(n: number): Bp;
+/** Converts `"-1234.56"` euros to cents ("importe en céntimos"). Accepts only `^-?\d+\.\d{2}$`; any other format throws. */
+export declare function parseEuros(s: string): Cents;
+/** Cents to euros ("importe en euros"), exact inverse of `parseEuros`: `123456` → `"1234.56"`. */
+export declare function formatEuros(c: Cents): string;
+/** Zero cents ("cero céntimos"), to initialise accumulators without literals in the logic. */
+export declare const ZERO: Cents;
+/** Adds cents ("sumar"). Throws if the result leaves the safe integer range (ADR-002). */
+export declare function add(a: Cents, b: Cents): Cents;
+/** Subtracts cents ("restar"). Throws if the result leaves the safe integer range (ADR-002). */
+export declare function subtract(a: Cents, b: Cents): Cents;
+/** `max(c, 0)`: clamps a negative amount to zero ("saldo acotado a cero"). */
+export declare function clampZero(c: Cents): Cents;
+/** Integer product cents × bp ("céntimos por puntos básicos"), to accumulate before `roundCents`. Throws outside the safe range. */
+export declare function timesBp(c: Cents, t: Bp): number;
+/**
+ * Cents·bp → cents ("redondeo al céntimo"): divides by 10 000 and rounds to the cent, half away from zero.
+ * The engine's only division point (ADR-002).
+ */
+export declare function roundCents(centsTimesBp: number): Cents;
+export {};

package/dist/money.js

@@ -0,0 +1,65 @@
+// Dinero y tipos como enteros (ADR-002). Nunca float para importes.
+const EUROS_FORMAT = /^(-?)(\d+)\.(\d{2})$/;
+const BP_PER_UNIT = 10_000;
+function requireSafeInteger(n, what) {
+    if (!Number.isSafeInteger(n)) {
+        throw new RangeError(`${what} must be a safe integer; got ${String(n)}`);
+    }
+}
+/** Builds a `Bp` ("puntos básicos") from an integer. */
+export function bp(n) {
+    requireSafeInteger(n, "Bp");
+    return n;
+}
+/** Converts `"-1234.56"` euros to cents ("importe en céntimos"). Accepts only `^-?\d+\.\d{2}$`; any other format throws. */
+export function parseEuros(s) {
+    const m = EUROS_FORMAT.exec(s);
+    if (m === null) {
+        throw new SyntaxError(`Invalid amount format: "${s}" (expected e.g. "8000.00")`);
+    }
+    const [, sign, euros, cents] = m;
+    const abs = Number(`${euros ?? ""}${cents ?? ""}`);
+    requireSafeInteger(abs, "Amount");
+    return (sign === "-" && abs !== 0 ? -abs : abs);
+}
+/** Cents to euros ("importe en euros"), exact inverse of `parseEuros`: `123456` → `"1234.56"`. */
+export function formatEuros(c) {
+    requireSafeInteger(c, "Cents");
+    const digits = String(Math.abs(c)).padStart(3, "0");
+    return `${c < 0 ? "-" : ""}${digits.slice(0, -2)}.${digits.slice(-2)}`;
+}
+/** Zero cents ("cero céntimos"), to initialise accumulators without literals in the logic. */
+export const ZERO = 0;
+/** Adds cents ("sumar"). Throws if the result leaves the safe integer range (ADR-002). */
+export function add(a, b) {
+    const sum = a + b;
+    requireSafeInteger(sum, "Sum of cents");
+    return sum;
+}
+/** Subtracts cents ("restar"). Throws if the result leaves the safe integer range (ADR-002). */
+export function subtract(a, b) {
+    const difference = a - b;
+    requireSafeInteger(difference, "Difference of cents");
+    return difference;
+}
+/** `max(c, 0)`: clamps a negative amount to zero ("saldo acotado a cero"). */
+export function clampZero(c) {
+    return (c > 0 ? c : 0);
+}
+/** Integer product cents × bp ("céntimos por puntos básicos"), to accumulate before `roundCents`. Throws outside the safe range. */
+export function timesBp(c, t) {
+    const product = c * t;
+    requireSafeInteger(product, "Cents·bp");
+    return product;
+}
+/**
+ * Cents·bp → cents ("redondeo al céntimo"): divides by 10 000 and rounds to the cent, half away from zero.
+ * The engine's only division point (ADR-002).
+ */
+export function roundCents(centsTimesBp) {
+    requireSafeInteger(centsTimesBp, "Cents·bp");
+    const abs = Math.abs(centsTimesBp);
+    const remainder = abs % BP_PER_UNIT;
+    const quotient = (abs - remainder) / BP_PER_UNIT + (remainder * 2 >= BP_PER_UNIT ? 1 : 0);
+    return (centsTimesBp < 0 && quotient !== 0 ? -quotient : quotient);
+}

package/dist/tables/2026.d.ts

@@ -0,0 +1,28 @@
+export declare const taxTable2026: {
+    readonly taxYear: 2026;
+    readonly source: {
+        readonly ref: "Ley 35/2006 IRPF, art. 66.1 (escala estatal) y art. 76 (escala autonómica) de la base del ahorro";
+        readonly verifiedOn: "2026-10-25";
+    };
+    readonly brackets: readonly [{
+        readonly upTo: import("../money.js").Cents;
+        readonly stateBp: import("../money.js").Bp;
+        readonly regionalBp: import("../money.js").Bp;
+    }, {
+        readonly upTo: import("../money.js").Cents;
+        readonly stateBp: import("../money.js").Bp;
+        readonly regionalBp: import("../money.js").Bp;
+    }, {
+        readonly upTo: import("../money.js").Cents;
+        readonly stateBp: import("../money.js").Bp;
+        readonly regionalBp: import("../money.js").Bp;
+    }, {
+        readonly upTo: import("../money.js").Cents;
+        readonly stateBp: import("../money.js").Bp;
+        readonly regionalBp: import("../money.js").Bp;
+    }, {
+        readonly upTo: null;
+        readonly stateBp: import("../money.js").Bp;
+        readonly regionalBp: import("../money.js").Bp;
+    }];
+};

package/dist/tables/2026.js

@@ -0,0 +1,16 @@
+import { bp, parseEuros } from "../money.js";
+// Escala verificada contra el manual de Renta; fecha en `source.verifiedOn`.
+export const taxTable2026 = {
+    taxYear: 2026,
+    source: {
+        ref: "Ley 35/2006 IRPF, art. 66.1 (escala estatal) y art. 76 (escala autonómica) de la base del ahorro",
+        verifiedOn: "2026-10-25",
+    },
+    brackets: [
+        { upTo: parseEuros("6000.00"), stateBp: bp(950), regionalBp: bp(950) },
+        { upTo: parseEuros("50000.00"), stateBp: bp(1050), regionalBp: bp(1050) },
+        { upTo: parseEuros("200000.00"), stateBp: bp(1150), regionalBp: bp(1150) },
+        { upTo: parseEuros("300000.00"), stateBp: bp(1350), regionalBp: bp(1350) },
+        { upTo: null, stateBp: bp(1500), regionalBp: bp(1500) },
+    ],
+};

package/dist/tables/index.d.ts

@@ -0,0 +1,6 @@
+import type { TaxTable } from "./tipos.js";
+export type { TaxBracket, TaxTable } from "./tipos.js";
+/** Normative table for a tax year ("tabla normativa del ejercicio", ADR-003). Throws `UnknownTaxYear`. */
+export declare function getTaxTable(taxYear: number): TaxTable;
+/** Tax years with a registered table ("ejercicios disponibles"), ascending. */
+export declare function availableTaxYears(): readonly number[];

package/dist/tables/index.js

@@ -0,0 +1,14 @@
+import { UnknownTaxYear } from "../errors.js";
+import { taxTable2026 } from "./2026.js";
+const TABLES = new Map([[taxTable2026.taxYear, taxTable2026]]);
+/** Normative table for a tax year ("tabla normativa del ejercicio", ADR-003). Throws `UnknownTaxYear`. */
+export function getTaxTable(taxYear) {
+    const table = TABLES.get(taxYear);
+    if (table === undefined)
+        throw new UnknownTaxYear(taxYear);
+    return table;
+}
+/** Tax years with a registered table ("ejercicios disponibles"), ascending. */
+export function availableTaxYears() {
+    return [...TABLES.keys()].sort((a, b) => a - b);
+}

package/dist/tables/tipos.d.ts

@@ -0,0 +1,21 @@
+import type { Bp, Cents } from "../money.js";
+/** One bracket of the savings scale ("tramo de la escala del ahorro"). */
+export type TaxBracket = {
+    /** Upper limit of the bracket, inclusive ("hasta"). `null` = no limit. */
+    readonly upTo: Cents | null;
+    /** State rate ("tipo estatal", art. 66.1 LIRPF). */
+    readonly stateBp: Bp;
+    /** Regional rate ("tipo autonómico", art. 76 LIRPF). */
+    readonly regionalBp: Bp;
+};
+/** Normative IRPF table for one tax year ("tabla normativa del ejercicio"). */
+export type TaxTable = {
+    readonly taxYear: number;
+    readonly source: {
+        readonly ref: string;
+        /** ISO date of human verification against the source; `null` if not verified. */
+        readonly verifiedOn: string | null;
+    };
+    /** Savings scale ("escala del ahorro"). */
+    readonly brackets: ReadonlyArray<TaxBracket>;
+};

package/dist/tax/brackets.d.ts

@@ -0,0 +1,7 @@
+import type { Cents } from "../money.js";
+import type { TaxBracket } from "../tables/index.js";
+/**
+ * Cuota de aplicar una escala por tramos a `base`. Acumula céntimos·bp en enteros a lo largo de toda la
+ * escala y redondea una sola vez al final, nunca por tramo (ADR-002). `upTo` es inclusivo.
+ */
+export declare function applyBrackets(base: Cents, brackets: ReadonlyArray<TaxBracket>, scale: "state" | "regional"): Cents;

package/dist/tax/brackets.js

@@ -0,0 +1,18 @@
+import { clampZero, roundCents, subtract, timesBp, ZERO } from "../money.js";
+/**
+ * Cuota de aplicar una escala por tramos a `base`. Acumula céntimos·bp en enteros a lo largo de toda la
+ * escala y redondea una sola vez al final, nunca por tramo (ADR-002). `upTo` es inclusivo.
+ */
+export function applyBrackets(base, brackets, scale) {
+    let from = ZERO;
+    let accumulated = ZERO;
+    for (const bracket of brackets) {
+        const ceiling = bracket.upTo === null || base < bracket.upTo ? base : bracket.upTo;
+        const slice = clampZero(subtract(ceiling, from));
+        accumulated += timesBp(slice, scale === "state" ? bracket.stateBp : bracket.regionalBp);
+        if (bracket.upTo === null || base <= bracket.upTo)
+            break;
+        from = bracket.upTo;
+    }
+    return roundCents(accumulated);
+}

package/dist/{irpf/compensacion.d.ts → tax/offsetting.d.ts}

@@ -1,5 +1,5 @@
-import type { Centimos } from "../dinero.js";
-import type { EntradaAhorro } from "./tipos.js";
+import type { Cents } from "../money.js";
+import type { SavingsInput } from "./tipos.js";
 /**
  * Base liquidable del ahorro = saldo de ganancias − pérdidas + saldo de rendimientos del capital mobiliario,
  * cada saldo acotado a cero por separado.
@@ -7,4 +7,4 @@ import type { EntradaAhorro } from "./tipos.js";
  * v1 (ADR-005): un saldo negativo no compensa al otro (compensación cruzada con límite del art. 49.1 LIRPF)
  * ni se arrastra a ejercicios siguientes (art. 49.2). Simplemente no tributa.
  */
-export declare function integrarBaseAhorro(e: EntradaAhorro): Centimos;
+export declare function integrateSavingsBase(e: SavingsInput): Cents;

package/dist/{irpf/compensacion.js → tax/offsetting.js}

@@ -1,4 +1,4 @@
-import { max0, restar, sumar } from "../dinero.js";
+import { add, clampZero, subtract } from "../money.js";
 /**
  * Base liquidable del ahorro = saldo de ganancias − pérdidas + saldo de rendimientos del capital mobiliario,
  * cada saldo acotado a cero por separado.
@@ -6,8 +6,8 @@ import { max0, restar, sumar } from "../dinero.js";
  * v1 (ADR-005): un saldo negativo no compensa al otro (compensación cruzada con límite del art. 49.1 LIRPF)
  * ni se arrastra a ejercicios siguientes (art. 49.2). Simplemente no tributa.
  */
-export function integrarBaseAhorro(e) {
-    const saldoGananciasPerdidas = max0(restar(e.gananciasPatrimoniales, e.perdidasPatrimoniales));
-    const saldoRendimientos = max0(e.rendimientosCapitalMobiliario);
-    return sumar(saldoGananciasPerdidas, saldoRendimientos);
+export function integrateSavingsBase(e) {
+    const gainsLossesBalance = clampZero(subtract(e.capitalGains, e.capitalLosses));
+    const incomeBalance = clampZero(e.investmentIncome);
+    return add(gainsLossesBalance, incomeBalance);
 }

package/dist/tax/savings.d.ts

@@ -0,0 +1,6 @@
+import type { SavingsInput, SavingsResult } from "./tipos.js";
+/**
+ * Savings tax ("cuota del ahorro", arts. 49, 50.2, 66.1 y 76 LIRPF).
+ * Cuota de la base del ahorro: estatal y autonómica por separado, cada una redondeada; la total es su suma.
+ */
+export declare function computeSavingsTax(e: SavingsInput): SavingsResult;

package/dist/tax/savings.js

@@ -0,0 +1,44 @@
+import { add } from "../money.js";
+import { InvalidInput } from "../errors.js";
+import { getTaxTable } from "../tables/index.js";
+import { integrateSavingsBase } from "./offsetting.js";
+import { applyBrackets } from "./brackets.js";
+/** Rechaza entradas sin sentido. Los rendimientos del capital mobiliario sí pueden ser negativos. */
+function validate(e) {
+    if (!Number.isInteger(e.taxYear)) {
+        throw new InvalidInput("taxYear", e.taxYear, "must be an integer year");
+    }
+    const amounts = {
+        capitalGains: e.capitalGains,
+        capitalLosses: e.capitalLosses,
+        investmentIncome: e.investmentIncome,
+    };
+    for (const [field, value] of Object.entries(amounts)) {
+        if (!Number.isSafeInteger(value)) {
+            throw new InvalidInput(field, value, "must be a safe integer of cents");
+        }
+    }
+    if (e.capitalGains < 0) {
+        throw new InvalidInput("capitalGains", e.capitalGains, "must be ≥ 0");
+    }
+    if (e.capitalLosses < 0) {
+        throw new InvalidInput("capitalLosses", e.capitalLosses, "must be ≥ 0");
+    }
+}
+/**
+ * Savings tax ("cuota del ahorro", arts. 49, 50.2, 66.1 y 76 LIRPF).
+ * Cuota de la base del ahorro: estatal y autonómica por separado, cada una redondeada; la total es su suma.
+ */
+export function computeSavingsTax(e) {
+    validate(e);
+    const table = getTaxTable(e.taxYear);
+    const savingsTaxableBase = integrateSavingsBase(e);
+    const stateTax = applyBrackets(savingsTaxableBase, table.brackets, "state");
+    const regionalTax = applyBrackets(savingsTaxableBase, table.brackets, "regional");
+    return {
+        savingsTaxableBase,
+        stateTax,
+        regionalTax,
+        totalTax: add(stateTax, regionalTax),
+    };
+}

package/dist/tax/tipos.d.ts

@@ -0,0 +1,23 @@
+import type { Cents } from "../money.js";
+/** Savings input ("rentas de la base del ahorro" de un ejercicio, art. 46 LIRPF). */
+export type SavingsInput = {
+    /** Tax year ("ejercicio"). */
+    taxYear: number;
+    /** Capital gains ("ganancias patrimoniales", art. 33 LIRPF). */
+    capitalGains: Cents;
+    /** Capital losses ("pérdidas patrimoniales", art. 33 LIRPF). */
+    capitalLosses: Cents;
+    /** Investment income ("rendimientos del capital mobiliario", art. 25 LIRPF). May be negative. */
+    investmentIncome: Cents;
+};
+/** Savings result ("base liquidable y cuotas del ahorro"). */
+export type SavingsResult = {
+    /** Savings taxable base ("base liquidable del ahorro", arts. 49 y 50.2 LIRPF). */
+    savingsTaxableBase: Cents;
+    /** State tax ("cuota estatal", art. 66.1 LIRPF). */
+    stateTax: Cents;
+    /** Regional tax ("cuota autonómica", art. 76 LIRPF). */
+    regionalTax: Cents;
+    /** Total savings tax ("cuota del ahorro"): `stateTax + regionalTax`. */
+    totalTax: Cents;
+};

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "fiscal-es",
-  "version": "0.1.0",
+  "version": "1.0.0",
+  "description": "Spanish personal income tax (IRPF) on the savings base: exact integer-cent engine with executable YAML test cases",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,7 +13,12 @@
     "irpf",
     "fiscalidad",
     "españa",
-    "ahorro"
+    "ahorro",
+    "spain",
+    "tax",
+    "income-tax",
+    "savings",
+    "capital-gains"
   ],
   "exports": {
     ".": {
@@ -27,14 +33,15 @@
     "cases",
     "!cases/_propuestos",
     "LICENSE",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "sideEffects": false,
   "engines": {
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
     "test": "vitest run",
     "typecheck": "tsc && tsc -p tests"
   },

package/dist/dinero.d.ts

@@ -1,31 +0,0 @@
-declare const marcaCentimos: unique symbol;
-declare const marcaBp: unique symbol;
-/** Importe en céntimos de euro. Entero seguro. */
-export type Centimos = number & {
-    readonly [marcaCentimos]: true;
-};
-/** Tipo en puntos básicos: 12,34 % = 1234. Entero seguro. */
-export type Bp = number & {
-    readonly [marcaBp]: true;
-};
-/** Construye un `Bp` a partir de un entero. */
-export declare function bp(n: number): Bp;
-/** Convierte `"-1234.56"` en céntimos. Acepta solo `^-?\d+\.\d{2}$`; cualquier otro formato lanza. */
-export declare function parseEuros(s: string): Centimos;
-/** Inversa exacta de `parseEuros`: `123456` → `"1234.56"`. */
-export declare function formatEuros(c: Centimos): string;
-/** Cero céntimos, para inicializar acumuladores sin literales en la lógica. */
-export declare const CERO: Centimos;
-/** Lanza si el resultado sale del rango entero seguro (ADR-002). */
-export declare function sumar(a: Centimos, b: Centimos): Centimos;
-/** Lanza si el resultado sale del rango entero seguro (ADR-002). */
-export declare function restar(a: Centimos, b: Centimos): Centimos;
-export declare function max0(c: Centimos): Centimos;
-/** Producto entero céntimos × bp, para acumular antes de `redondearCentimos`. Lanza fuera del rango seguro. */
-export declare function porBp(c: Centimos, t: Bp): number;
-/**
- * Céntimos·bp → céntimos: divide entre 10 000 y redondea al céntimo, mitad alejándose de cero.
- * Único punto de división del motor (ADR-002).
- */
-export declare function redondearCentimos(centimosPorBp: number): Centimos;
-export {};

package/dist/dinero.js

@@ -1,64 +0,0 @@
-// Dinero y tipos como enteros (ADR-002). Nunca float para importes.
-const FORMATO_EUROS = /^(-?)(\d+)\.(\d{2})$/;
-const BP_POR_UNIDAD = 10_000;
-function exigirEntero(n, que) {
-    if (!Number.isSafeInteger(n)) {
-        throw new RangeError(`${que} debe ser un entero seguro; recibido ${String(n)}`);
-    }
-}
-/** Construye un `Bp` a partir de un entero. */
-export function bp(n) {
-    exigirEntero(n, "Bp");
-    return n;
-}
-/** Convierte `"-1234.56"` en céntimos. Acepta solo `^-?\d+\.\d{2}$`; cualquier otro formato lanza. */
-export function parseEuros(s) {
-    const m = FORMATO_EUROS.exec(s);
-    if (m === null) {
-        throw new SyntaxError(`Importe con formato inválido: "${s}" (se espera p. ej. "8000.00")`);
-    }
-    const [, signo, euros, cent] = m;
-    const abs = Number(`${euros ?? ""}${cent ?? ""}`);
-    exigirEntero(abs, "Importe");
-    return (signo === "-" && abs !== 0 ? -abs : abs);
-}
-/** Inversa exacta de `parseEuros`: `123456` → `"1234.56"`. */
-export function formatEuros(c) {
-    exigirEntero(c, "Centimos");
-    const digitos = String(Math.abs(c)).padStart(3, "0");
-    return `${c < 0 ? "-" : ""}${digitos.slice(0, -2)}.${digitos.slice(-2)}`;
-}
-/** Cero céntimos, para inicializar acumuladores sin literales en la lógica. */
-export const CERO = 0;
-/** Lanza si el resultado sale del rango entero seguro (ADR-002). */
-export function sumar(a, b) {
-    const suma = a + b;
-    exigirEntero(suma, "Suma de céntimos");
-    return suma;
-}
-/** Lanza si el resultado sale del rango entero seguro (ADR-002). */
-export function restar(a, b) {
-    const resta = a - b;
-    exigirEntero(resta, "Resta de céntimos");
-    return resta;
-}
-export function max0(c) {
-    return (c > 0 ? c : 0);
-}
-/** Producto entero céntimos × bp, para acumular antes de `redondearCentimos`. Lanza fuera del rango seguro. */
-export function porBp(c, t) {
-    const producto = c * t;
-    exigirEntero(producto, "Céntimos·bp");
-    return producto;
-}
-/**
- * Céntimos·bp → céntimos: divide entre 10 000 y redondea al céntimo, mitad alejándose de cero.
- * Único punto de división del motor (ADR-002).
- */
-export function redondearCentimos(centimosPorBp) {
-    exigirEntero(centimosPorBp, "Céntimos·bp");
-    const abs = Math.abs(centimosPorBp);
-    const resto = abs % BP_POR_UNIDAD;
-    const cociente = (abs - resto) / BP_POR_UNIDAD + (resto * 2 >= BP_POR_UNIDAD ? 1 : 0);
-    return (centimosPorBp < 0 && cociente !== 0 ? -cociente : cociente);
-}

package/dist/errores.d.ts

@@ -1,11 +0,0 @@
-export declare class EjercicioSinTabla extends Error {
-    readonly ejercicio: number;
-    readonly name = "EjercicioSinTabla";
-    constructor(ejercicio: number);
-}
-export declare class EntradaInvalida extends Error {
-    readonly campo: string;
-    readonly valor: number;
-    readonly name = "EntradaInvalida";
-    constructor(campo: string, valor: number, motivo: string);
-}

package/dist/errores.js

@@ -1,18 +0,0 @@
-export class EjercicioSinTabla extends Error {
-    ejercicio;
-    name = "EjercicioSinTabla";
-    constructor(ejercicio) {
-        super(`No hay tabla normativa para el ejercicio ${String(ejercicio)}`);
-        this.ejercicio = ejercicio;
-    }
-}
-export class EntradaInvalida extends Error {
-    campo;
-    valor;
-    name = "EntradaInvalida";
-    constructor(campo, valor, motivo) {
-        super(`Entrada inválida: ${campo} = ${String(valor)} (${motivo})`);
-        this.campo = campo;
-        this.valor = valor;
-    }
-}

package/dist/irpf/ahorro.d.ts

@@ -1,3 +0,0 @@
-import type { EntradaAhorro, ResultadoAhorro } from "./tipos.js";
-/** Cuota de la base del ahorro: estatal y autonómica por separado, cada una redondeada; la total es su suma. */
-export declare function calcularAhorro(e: EntradaAhorro): ResultadoAhorro;

package/dist/irpf/ahorro.js

@@ -1,41 +0,0 @@
-import { sumar } from "../dinero.js";
-import { EntradaInvalida } from "../errores.js";
-import { getTabla } from "../tablas/index.js";
-import { integrarBaseAhorro } from "./compensacion.js";
-import { aplicarEscala } from "./escala.js";
-/** Rechaza entradas sin sentido. Los rendimientos del capital mobiliario sí pueden ser negativos. */
-function validar(e) {
-    if (!Number.isInteger(e.ejercicio)) {
-        throw new EntradaInvalida("ejercicio", e.ejercicio, "debe ser un año entero");
-    }
-    const importes = {
-        gananciasPatrimoniales: e.gananciasPatrimoniales,
-        perdidasPatrimoniales: e.perdidasPatrimoniales,
-        rendimientosCapitalMobiliario: e.rendimientosCapitalMobiliario,
-    };
-    for (const [campo, valor] of Object.entries(importes)) {
-        if (!Number.isSafeInteger(valor)) {
-            throw new EntradaInvalida(campo, valor, "debe ser un entero seguro de céntimos");
-        }
-    }
-    if (e.gananciasPatrimoniales < 0) {
-        throw new EntradaInvalida("gananciasPatrimoniales", e.gananciasPatrimoniales, "no puede ser negativo");
-    }
-    if (e.perdidasPatrimoniales < 0) {
-        throw new EntradaInvalida("perdidasPatrimoniales", e.perdidasPatrimoniales, "no puede ser negativo");
-    }
-}
-/** Cuota de la base del ahorro: estatal y autonómica por separado, cada una redondeada; la total es su suma. */
-export function calcularAhorro(e) {
-    validar(e);
-    const tabla = getTabla(e.ejercicio);
-    const baseLiquidableAhorro = integrarBaseAhorro(e);
-    const cuotaEstatal = aplicarEscala(baseLiquidableAhorro, tabla.escalaAhorro, "estatal");
-    const cuotaAutonomica = aplicarEscala(baseLiquidableAhorro, tabla.escalaAhorro, "autonomico");
-    return {
-        baseLiquidableAhorro,
-        cuotaEstatal,
-        cuotaAutonomica,
-        cuotaAhorro: sumar(cuotaEstatal, cuotaAutonomica),
-    };
-}

package/dist/irpf/escala.d.ts

@@ -1,7 +0,0 @@
-import type { Centimos } from "../dinero.js";
-import type { TramoAhorro } from "../tablas/index.js";
-/**
- * Cuota de aplicar una escala por tramos a `base`. Acumula céntimos·bp en enteros a lo largo de toda la
- * escala y redondea una sola vez al final, nunca por tramo (ADR-002). `hasta` es inclusivo.
- */
-export declare function aplicarEscala(base: Centimos, tramos: ReadonlyArray<TramoAhorro>, tipo: "estatal" | "autonomico"): Centimos;

package/dist/irpf/escala.js

@@ -1,18 +0,0 @@
-import { CERO, max0, porBp, redondearCentimos, restar } from "../dinero.js";
-/**
- * Cuota de aplicar una escala por tramos a `base`. Acumula céntimos·bp en enteros a lo largo de toda la
- * escala y redondea una sola vez al final, nunca por tramo (ADR-002). `hasta` es inclusivo.
- */
-export function aplicarEscala(base, tramos, tipo) {
-    let desde = CERO;
-    let acumulado = CERO;
-    for (const tramo of tramos) {
-        const techo = tramo.hasta === null || base < tramo.hasta ? base : tramo.hasta;
-        const porcion = max0(restar(techo, desde));
-        acumulado += porBp(porcion, tipo === "estatal" ? tramo.estatalBp : tramo.autonomicoBp);
-        if (tramo.hasta === null || base <= tramo.hasta)
-            break;
-        desde = tramo.hasta;
-    }
-    return redondearCentimos(acumulado);
-}

package/dist/irpf/tipos.d.ts

@@ -1,13 +0,0 @@
-import type { Centimos } from "../dinero.js";
-export type EntradaAhorro = {
-    ejercicio: number;
-    gananciasPatrimoniales: Centimos;
-    perdidasPatrimoniales: Centimos;
-    rendimientosCapitalMobiliario: Centimos;
-};
-export type ResultadoAhorro = {
-    baseLiquidableAhorro: Centimos;
-    cuotaEstatal: Centimos;
-    cuotaAutonomica: Centimos;
-    cuotaAhorro: Centimos;
-};

package/dist/tablas/2026.d.ts

@@ -1,28 +0,0 @@
-export declare const tabla2026: {
-    readonly ejercicio: 2026;
-    readonly fuente: {
-        readonly ref: "Ley 35/2006 IRPF, art. 66.1 (escala estatal) y art. 76 (escala autonómica) de la base del ahorro";
-        readonly verificado: "2026-10-25";
-    };
-    readonly escalaAhorro: readonly [{
-        readonly hasta: import("../dinero.js").Centimos;
-        readonly estatalBp: import("../dinero.js").Bp;
-        readonly autonomicoBp: import("../dinero.js").Bp;
-    }, {
-        readonly hasta: import("../dinero.js").Centimos;
-        readonly estatalBp: import("../dinero.js").Bp;
-        readonly autonomicoBp: import("../dinero.js").Bp;
-    }, {
-        readonly hasta: import("../dinero.js").Centimos;
-        readonly estatalBp: import("../dinero.js").Bp;
-        readonly autonomicoBp: import("../dinero.js").Bp;
-    }, {
-        readonly hasta: import("../dinero.js").Centimos;
-        readonly estatalBp: import("../dinero.js").Bp;
-        readonly autonomicoBp: import("../dinero.js").Bp;
-    }, {
-        readonly hasta: null;
-        readonly estatalBp: import("../dinero.js").Bp;
-        readonly autonomicoBp: import("../dinero.js").Bp;
-    }];
-};

package/dist/tablas/2026.js

@@ -1,16 +0,0 @@
-import { bp, parseEuros } from "../dinero.js";
-// Escala verificada contra el manual de Renta; fecha en `fuente.verificado`.
-export const tabla2026 = {
-    ejercicio: 2026,
-    fuente: {
-        ref: "Ley 35/2006 IRPF, art. 66.1 (escala estatal) y art. 76 (escala autonómica) de la base del ahorro",
-        verificado: "2026-10-25",
-    },
-    escalaAhorro: [
-        { hasta: parseEuros("6000.00"), estatalBp: bp(950), autonomicoBp: bp(950) },
-        { hasta: parseEuros("50000.00"), estatalBp: bp(1050), autonomicoBp: bp(1050) },
-        { hasta: parseEuros("200000.00"), estatalBp: bp(1150), autonomicoBp: bp(1150) },
-        { hasta: parseEuros("300000.00"), estatalBp: bp(1350), autonomicoBp: bp(1350) },
-        { hasta: null, estatalBp: bp(1500), autonomicoBp: bp(1500) },
-    ],
-};

package/dist/tablas/index.d.ts

@@ -1,5 +0,0 @@
-import type { TablaIRPF } from "./tipos.js";
-export type { TablaIRPF, TramoAhorro } from "./tipos.js";
-export declare function getTabla(ejercicio: number): TablaIRPF;
-/** Ejercicios con tabla normativa registrada, en orden ascendente. */
-export declare function ejerciciosDisponibles(): readonly number[];

package/dist/tablas/index.js

@@ -1,13 +0,0 @@
-import { EjercicioSinTabla } from "../errores.js";
-import { tabla2026 } from "./2026.js";
-const TABLAS = new Map([[tabla2026.ejercicio, tabla2026]]);
-export function getTabla(ejercicio) {
-    const tabla = TABLAS.get(ejercicio);
-    if (tabla === undefined)
-        throw new EjercicioSinTabla(ejercicio);
-    return tabla;
-}
-/** Ejercicios con tabla normativa registrada, en orden ascendente. */
-export function ejerciciosDisponibles() {
-    return [...TABLAS.keys()].sort((a, b) => a - b);
-}

package/dist/tablas/tipos.d.ts

@@ -1,16 +0,0 @@
-import type { Bp, Centimos } from "../dinero.js";
-export type TramoAhorro = {
-    /** Límite superior del tramo (incluido). `null` = sin límite. */
-    readonly hasta: Centimos | null;
-    readonly estatalBp: Bp;
-    readonly autonomicoBp: Bp;
-};
-export type TablaIRPF = {
-    readonly ejercicio: number;
-    readonly fuente: {
-        readonly ref: string;
-        /** Fecha ISO de verificación humana contra la fuente; `null` si no se ha verificado. */
-        readonly verificado: string | null;
-    };
-    readonly escalaAhorro: ReadonlyArray<TramoAhorro>;
-};